En el artículo anterior, los principios básicos y el uso del arranque de primavera se han explicado a través de un programa simple de Helloworld. Este artículo explica principalmente cómo acceder a la base de datos a través del arranque de Spring. Este artículo demostrará tres formas de acceder a la base de datos. El primero es JDBCTemplate, el segundo es JPA, y el tercero es mybatis. Como se mencionó anteriormente, esta serie utilizará un sistema de blog como base para la explicación, por lo que este artículo explicará el almacenamiento y el acceso del artículo (pero no incluye los detalles del artículo). Debido a que la implementación final se completa a través de MyBatis, solo se realizará una simple demostración de JDBCTemplate y JPA, y la parte myBatis implementará completamente la adición, eliminación, modificación y búsqueda del artículo.
1. Preparación
Antes de demostrar estos métodos, primero debe preparar algo. El primero es la base de datos. Este sistema se implementa utilizando MySQL. Primero necesitamos crear una tabla TB_ARTICL:
DROP TABLE IF EXISTS `tb_article`;CREATE TABLE `tb_article` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `title` varchar(255) NOT NULL DEFAULT '', `summary` varchar(1024) NOT NULL DEFAULT '', `status` int(11) NOT NULL DEFAULT '0', `type` int(11) NOT NULL, `user_id` BigInt (20) No NULL predeterminado '0', `create_time` timestamp No null predeterminado Current_timestamp,` uply_time` timestamp no nulo predeterminado Current_timestamp, `public_time` timestamp no NULL NULL Current_timestamp, clave primaria (` id`)) Engine = innodb predeterminado Charset = utf8;
En la demostración posterior, esta tabla se agregará, eliminará, modificará y verificará. Debería ver que no hay detalles del artículo en esta tabla. La razón es que los detalles del artículo son relativamente largos. Si se coloca en esta tabla, afectará fácilmente la eficiencia de consultar la lista de artículos, por lo que los detalles del artículo se almacenarán en otra tabla por separado. Además, necesitamos configurar el grupo de conexión de la base de datos. Aquí usamos el grupo de conexión Druid. Además, el archivo de configuración está configurado utilizando YAML, es decir, Application.yml (también puede usar el archivo de configuración Application.Properties. No hay una gran diferencia. Si no está familiarizado con YMAL y está interesado, puede verificarlo, lo cual es relativamente simple). La configuración del grupo de conexión es la siguiente:
Primavera: DataSource: URL: JDBC: mySQL: //127.0.0.1: 3306/Blog? UseUnicode = true & caracterSencoding = utf-8 & Usessl = false controlador de control
Finalmente, también necesitamos establecer una clase POJO correspondiente a la base de datos, el código es el siguiente:
Artículo de clase pública {ID de largo privado; título de cadena privada; resumen de cadena privada; Fecha privada CreateTime; Fecha privada PublicteMe; Fecha privada de actualización; ID de usuario largo privado; estado entero privado; Tipo de entero privado;}Ok, ese es todo el trabajo que necesita para preparar, y ahora comienza a implementar la operación de la base de datos.
2. Integración con JDBCTemplate
Primero, primero accedemos a la base de datos a través de JDBCTemplate. Aquí solo demostramos la inserción de datos. Como se mencionó en el artículo anterior, Spring Boot proporciona muchos entrantes para admitir diferentes funciones. Para admitir JDBCTemplate, solo necesitamos introducir el siguiente arranque:
<Spendency> <ProupId> org.springframework.boot </groupid> <artifactid> spring-boot-starter-jdbc </artifactid> </pendency>
Ahora podemos implementar la inserción de datos a través de JDBCTemplate:
Interfaz pública Articledao {Long InsertArticle (artículo Artículo);} @RepositoryPublic Class ArticledaJdbctEmplateImpl implementa Articledao {@AUTOWIREDIREDIRDIRD Private CandarMeterJdbctemplate jdbctemplate; @Override public Long InsertArtice (artículo Artículo) {String sql = "Insertar en tb_article (título, resumen, user_id, create_time, public_time, update_time, status)" + "valores (: title ,: summary ,: userId ,: createTime ,: publicteMe ,: UpdateTime,: status)"; Map <string, object> param = new HashMap <> (); param.put ("title", artículo.gettitle ()); param.put ("sumario", artículo.getSummary ()); param.put ("userId", artículo.getUserId ()); param.put ("status", artículo.getStatus ()); param.put ("createTime", artículo.getCreateTime ()); param.put ("createTime", artículo.getCreateTime ()); param.put ("PublicteMe", artículo.getPublicEtime ()); param.put ("updateTime", artículo.getUpDateTime ()); return (long) jdbctemplate.update (sql, param); }}Usamos Junit para probar el código anterior:
@Runwith (SpringJunit4ClassRunner.class) @SpringBoottest (classes = Application.Class) Public Class ArticlDaoTest {@aUtowired private articledao articledao; @Test public void testInsert () {artículo Artículo = nuevo artículo (); Artículo.settitle ("Título de prueba"); Artículo.setsummary ("Resumen de prueba"); Artículo.setUserID (1L); Artículo.setStatus (1); Artículo.setCreateTime (nueva fecha ()); Artículo.setUpDateTime (nueva fecha ()); artículo.setPublicEtime (nueva fecha ()); articledao.insertarticle (artículo); }}Para apoyar el programa de prueba anterior, también debe introducir un iniciador:
<Spendency> <ProupId> org.springframework.boot </groupid> <artifactId> spring-boot-starter-test </arfactid> <cope> test </cope> </dependence>
En el código anterior, podemos ver que, de hecho, básicamente no hay configuración, excepto la introducción del inicio de JDBC. Este es el proceso de configuración automática del arranque de primavera. El código anterior debe prestar atención a la ubicación de la clase de aplicación. Esta clase debe estar ubicada en el paquete principal de la clase DAO. Por ejemplo, DAO se encuentra en el paquete com.pandy.blog.dao. Ahora movemos la clase Application.java del paquete com.pandy.blog al paquete com.pandy.blog, y aparecerá el siguiente error:
Causado por: org.springframework.beans.factory.nosuchbeandefinitionException: no hay bean calificador de tipo 'com.pandy.blog.dao.articledao' Disponible: esperado al menos 1 frijol que califica como candidato de Autowire. Anotaciones de dependencia: {@org.springframework.beans.factory.annotation.aUtowired (requerido = verdadero)} en org.springframework.beanss.factory.support.defaultListableBeanFactory.raisenomatchingBeanFound (defaultListableBeanFactory.Java:1493) ATA org. org.springframework.beans.factory.annotation.aUtowiredAnnotationBeanPostProcessor $ AutowiredFieldElement.Inject (AutowiredAnnotationBeanPostprocessor.Java:585) ... 28 másEn otras palabras, no se puede encontrar la implementación de Articledao. ¿Cuál es la razón? En la publicación de blog anterior, hemos visto que la anotación @springbootapplication hereda @ComponentsCan, que solo escanea los paquetes y subpackages donde la clase de aplicación se encuentra de manera predeterminada. Por lo tanto, para el error anterior, además de mantener la clase de aplicación en el paquete principal de DAO, también puede especificar el paquete escaneado para resolver:
@Springbootapplication@componentscan ({"com.pandy.blog"}) aplicación de clase pública {public static void main (string [] args) lanza la excepción {springapplication.run (application.class, args); }}3. Integración con JPA
Ahora comenzaremos a explicar cómo implementar operaciones de bases de datos a través de JPA. Todavía es similar a JDBCTemplate. Primero, necesitamos introducir el iniciador correspondiente:
<Spendency> <MoupRoMID> org.springframework.boot </groupid> <artifactId> spring-boot-starter-data-jpa </artifactid> </pendency>
Luego necesitamos agregar anotación de entidad a la clase POJO y especificar el nombre de la tabla (si no se especifica, el nombre de la tabla predeterminado es el artículo), y luego necesitamos especificar la identificación y su estrategia de generación. Todos estos son conocimientos de JPA y no tienen nada que ver con Spring Boot. Si no está familiarizado con él, puede ver los puntos de conocimiento de JPA:
@Entity (name = "tb_article") Artículo de clase pública {@id @GeneratedValue ID de largo privado; título de cadena privada; resumen de cadena privada; Fecha privada CreateTime; Fecha privada PublicteMe; Fecha privada de actualización; ID de usuario largo privado; estado de entero privado;}Finalmente, necesitamos heredar la clase JParepository. Aquí implementamos dos métodos de consulta. La primera es una consulta que cumple con la especificación de nombres de JPA. JPA nos ayudará automáticamente a completar la generación de declaraciones de consulta. La otra forma es implementar JPQL (una consulta similar a SQL compatible con JPA).
Interfaz pública ArticLerepository extiende jParepository <Artículo, Long> {Lista pública <Atículo> FindByUserId (Long UserId); @Query ("Seleccione Art de com.pandy.blog.po.article art Where title =: title") Public List <Attic> QueryBytitle (@param ("Título") Título de cadena);}Ok, podemos probar el código anterior nuevamente:
@RunWith (SpringJUnit4ClassRunner.class) @SpringBoottest (classes = Application.Class) public class ArticLerepositoryTest {@AUTOWIREDIRDIRIRD PRIVADO ARTICLEREPOSTORY ArticLerepository; @Test public void testQuery () {list <At artículo> articLelist = articLerepository.QueryByTitle ("Título de prueba"); afirmarTrue (articLelist.size ()> 0); }}Tenga en cuenta que todavía hay problemas similares a JDBCTemplate aquí. Debe hacer que la clase de inicio de la aplicación no esté en el paquete principal de las clases de respositorio y entidad, de lo contrario aparecerá el siguiente error:
Causado por: org.springframework.beans.factory.nosuchbeandefinitionException: No calificación del tipo de tipo 'com.pandy.blog.dao.articleRepository' disponible: esperado al menos 1 bean que califica como candidato de Autowire. Anotaciones de dependencia: {@org.springframework.beans.factory.annotation.aUtowired (requerido = verdadero)} en org.springframework.beanss.factory.support.defaultListableBeanFactory.raisenomatchingBeanFound (defaultListableBeanFactory.Java:1493) ATA org. org.springframework.beans.factory.annotation.aUtowiredAnnotationBeanPostProcessor $ AutowiredFieldElement.Inject (AutowiredAnnotationBeanPostprocessor.Java:585) ... 28 másPor supuesto, también puede especificar el paquete JPA escaneado anotando @enableJparePositories, pero aún no funciona, y el siguiente error aparecerá:
Causado por: java.lang.illegalargumentException: no es un tipo administrado: clase com.pandy.blog.po.article en org.hibernate.jpa.internal.metamodel.metamodelimpl.managedtype (metamodelimpl.java:210) AT AT org.springframework.data.jpa.repository.support.jpametamodelEntityInformation. <Init> (jpametamodelentityInformation.java:70) en org.springframework.data.jpa.repository.support.jpaEntityInformationsupport.getEntityInformation (jPaEntityInformationsupport.java:68) AT org.springframework.data.jpa.repository.support.jparpositoryFactory.getEntityInformation (jParepositoryFactory.java:153) en org.springframework.data.jpa.Repository.support.jparepository.GetTargetRepositorory (jParepositoryeryory (jPareposoryRory) en org.springframework.data.jpa.repository.support.jparepositoryfactory.getTargetRepository (jParepositoryFactory.java:82) en org.springframework.data.repository.core.support.repositoryFactorySupport.getRepository (RepositoryFactorySupport.java:199) en org.springframework.data.repository.core.support.repositoryFactoryBeansupport.initandreturn (RepositoryFactoryBeansupport.java:277) en org.springframework.data.repository.core.support.repositoryfactorybeSupport.afterPropertiesSet (repositoryFactoryBeansupport.Java:263) en org.springframework.data.jpa.repository.support.jparepositoryFactoryBean.AfterPropertIesset (jParepositoryFactoryBean.java:101) en org.springframework.beans.factory.support.AbstractAutowirecapableBeanFactory.InvokeInitMethods (abstractAutOweCapableBeanFactory.Java:1687) en org.springframework.beans.factory.support.AbstractAUTOWECapableBeanFactory.InitializeBean (abstractAutOweCapableBeanFactory.Java:1624) ... 39 más
Este error indica que la entidad no se puede reconocer, por lo que también debe especificar el paquete de entidad anotando @EntityScan. La configuración final es la siguiente:
@Springbootapplication@componentscan ({"com.pandy.blog"})@enablejparePositories (basepackages = "com.pandy.blog")@entityscan ("com.pandy.blog") aplicación de clase pública {public static void main (string [] args) lanza excepción {springapplication.run (application.class, args, args); }}4. Integración con MyBatis
Finalmente, echemos un vistazo a cómo lograr el acceso a la base de datos a través de MyBatis. Del mismo modo, todavía necesitamos introducir iniciador:
<Spendency> <MoupRoMID> org.mybatis.spring.boot </groupid> <artifactID> mybatis-spring-boot-starter </arfactid> <version> 1.1.1 </versión> </pendency>
Dado que el arranque no es proporcionado oficialmente por Spring Boot, el número de versión es inconsistente con Spring Boot y debe especificarse manualmente.
MyBatis generalmente puede especificar SQL que opera bases de datos a través de XML o anotaciones. Personalmente, prefiero XML, por lo que este artículo solo demuestra acceder a bases de datos a través de XML. Primero, necesitamos configurar el directorio mapper. Lo configuramos en Application.yml:
MyBatis: Locaciones de configuración: MyBatis/MyBatis-Config.xml Locaciones mapeadores: mybatis/mapper/*. xml type-aliases-package: com.pandy.blog.po
La configuración aquí incluye principalmente tres partes, una son algunas configuraciones de MyBatis en sí, como alias para tipos básicos. El segundo es especificar la ubicación del archivo mapeador, y el tercero es el alias para la clase POJO. Esta configuración también se puede implementar a través de la configuración de Java. Debido a problemas de espacio, no explicaré en detalle aquí. Los amigos interesados pueden implementarlo por sí mismos.
Después de la configuración, primero escribimos la interfaz mapper:
interfaz pública Articlemapper {public Long InsertArticle (artículo Artículo); public void Updatearticle (artículo Artículo); Artículo público QueryByid (ID Long); Lista pública <At artículo> QueryArticlesByPage (@Param ("Artículo") Artículo del artículo, @param ("PageSize") int PAGESIZE, @param ("offset") int offset);}Esta interfaz define temporalmente solo cuatro métodos, a saber, agregar, actualizar y consultar según ID y paginación. Esta es una interfaz, y es similar a JPA, por lo que no necesita implementar clases. A continuación escribimos un archivo XML:
<? xml versión = "1.0" encoding = "utf-8"?> <! Doctype mapper public "-// mybatis.org//dtd mapper 3.0 // en" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper Namespace = "com.pandy.blog.dao.articlEmapper"> <resultMap id = "ArticLEmap" type = "com.pandy.blog.po.article"> <id columna = "id" propiedad = "id" jdbctype = "entero"/> <resultado column column = "title =" title "title" title "" jdbctypee = "" Varche "Vare" Varche "/" Result "/" Result "/" Results "/Results/sur. <Results"/"Result"/Results/"VareR"/"VareR" VareR "VareR" VareR "VareS" Varcher "Varcher"/Results/Results/SUTCe VareNe columna = "summary" propiedad = "summary" jdbctype = "varchar"/> <resultado columna = "user_id" propiedad = "userId" jdbctype = "entero"/> <resultado column = "status" propiedad = "status" jdbctype = "entero"/> <resultado columna = "create_time" Property = "createTime" jdbctypePe columna = "update_time" propiedad = "updateTime" jdbctype = "timestamp"/> <resultado column = "public_time" Property = "PublicteMe" jdbctype = "timestamp"/> </resultmap> <sql id = "base_column"> title, sumario, user_id, estatus, create_time, update_time, public_time </sql> parametertype = "artículo"> insertar en tb_article (<incluido refid = "base_column"/>) value (#{title},#{summary},#{userId},#{status},#{ tb_article <set> <if test = "title! = null"> title = #{title}, </if test = "summary! = null"> summary = #{sumario}, </if> <if test = "status! = null"> status = #{status}, </if> <if test = "publictee! = null"> public_time = # #{ #}, <///if PublicteMe! = Null "> Public_time = # #{ #}, <///if PublicteMe! = Null"> Public_Time = # #{ <if test="updateTime !=null "> update_time = #{updateTime}, </if> </set> WHERE id = #{id} </update> <select id="queryById" parameterType="Long" resultMap="articleMap"> SELECT id,<include refid="base_column"></include> FROM tb_article WHERE id = #{id} </select> <select id = "QueryarticlesByPage" resultMap = "ArticLEmap"> Select ID, <incluido refid = "base_column"> </cló> de tb_article <where> <if test = "artículo.title! = null"> title como concliente ('%', $ {artículo.title}, '%') </if <if <if test = "Artículo como un óxido ('%', $ {artículo. user_id = #{artículoFinalmente, necesitamos especificar manualmente los paquetes escaneados por el mapeador:
@Springbootapplication@mapperscan ("com.pandy.blog.dao") aplicación de clase pública {public static void main (string [] args) lanza la excepción {springapplication.run (application.class, args); }}Ok, la integración con MyBatis también se completa, probémosla nuevamente:
@RunWith (SpringJunit4ClassRunner.class) @SpringBoottest (classes = Application.Class) public class ArticLemapPertest {@AUTOWIREDIRIRD Private ArticLemapper mapper; @Test public void testInsert () {artículo Artículo = nuevo artículo (); artículo. Settitle ("Título de prueba 2"); artículo. Setsummary ("Resumen de prueba 2"); Artículo.setUserID (1L); Artículo.setStatus (1); Artículo.setCreateTime (nueva fecha ()); Artículo.setUpDateTime (nueva fecha ()); artículo.setPublicEtime (nueva fecha ()); mapper.insertArticle (artículo); } @Test public void testMyBatisQuery () {Artículo Artículo = Mappper.QueryById (1L); afirmarnotnull (artículo); } @Test public void topupDate () {artículo artículo = mappper.queryById (1l); artículo.setPublicEtime (nueva fecha ()); Artículo.setUpDateTime (nueva fecha ()); Artículo.setStatus (2); mapper.updateartle (artículo); } @Test public void testQueryByPage () {Artículo Artículo = nuevo artículo (); Artículo.setUserID (1L); Lista <artículo> list = mApper.QueryarticlesByPage (artículo, 10,0); afirmarTrue (list.size ()> 0); }}5. Resumen
Este artículo demuestra la integración de Spring Boot con JDBCTemplate, JPA y MyBatis. En general, la configuración es relativamente simple. Los estudiantes que han realizado configuraciones relacionadas antes deben sentir que es obvio. De hecho, Spring Boot nos ha brindado una gran ayuda en este sentido. En artículos posteriores, solo usaremos MyBatis para realizar operaciones de bases de datos. Otra cosa a tener en cuenta aquí es que la consulta de paginación de MyBatis está escrita a mano aquí. Esta paginación se puede completar a través de complementos durante el desarrollo formal, pero esto no tiene nada que ver con el arranque de primavera, por lo que este artículo utiliza temporalmente este método manual para realizar el procesamiento de la paginación.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.