Se ha lanzado un nuevo proyecto en los últimos dos días porque los miembros del equipo del proyecto siempre han usado mybatis. Aunque personalmente prefiero el modelo minimalista de JPA, MyBatis todavía está decidido a mantener la selección de tecnología unificada para mantener el proyecto. Me conecté en línea para encontrar información relevante sobre la combinación de Spring Boot y MyBatis. Hay varias formas, lo que hace que la gente esté cansada de leerlo. Combinando la demostración oficial y los documentos de MyBatis, finalmente encontré los dos modos más simples. Pasé un día resumiéndolo y compartiéndolo.
La esencia del marco ORM es simplificar la codificación de las bases de datos operativas en la programación. Ahora básicamente quedan dos compañías. Una es afirmar que no puede escribir una oración de SQL Hibernate, y la otra es depurar de manera flexible mybatis de SQL dinámico. Ambos tienen sus propias características y pueden usarse de manera flexible de acuerdo con las necesidades en el desarrollo del sistema de nivel empresarial. Encontré un fenómeno interesante: a la mayoría de las empresas tradicionales les gusta usar Hibernate, y la industria de Internet generalmente usa mybatis.
La característica de Hibernate es que todo SQL se genera con el código Java, y no hay necesidad de escribir (leer) SQL sin saltar del programa. Tiene integridad de programación. Se desarrolla en la parte superior del modelo. Básicamente, el SQL correspondiente se puede generar en función del nombre del método. Si no sabe mucho, puede leer mi artículo anterior sobre el uso de Datos Spring JPA.
MyBatis es muy problemático en la etapa inicial, que requiere varios archivos de configuración, clases de entidad, asociaciones de mapeo de capas DAO y muchas otras configuraciones. Por supuesto, MyBatis también descubrió esta desventaja. En la etapa inicial, se desarrolló el generador, que puede producir automáticamente clases de entidad, archivos de configuración y código de capa DAO basado en los resultados de la tabla, lo que puede reducir parte del volumen de desarrollo; En la etapa posterior, se pueden usar muchas optimizaciones para usar anotaciones, administrar automáticamente las capas y archivos de configuración DAO, etc., y el desarrollo en la parte superior es el modelo del que vamos a hablar hoy. MyBatis-Spring-Boot Starter es SpringBoot+MyBatis puede anotar completamente sin archivos de configuración, y también puede ser una configuración simple y fácil de comenzar.
Ahora piénsalo, Spring Boot es increíble. Mientras asocie cualquier cosa con Spring Boot, lo simplificará.
MyBatis-Spring-Boot-starter
Descripción oficial: mybatis spring-boot starter te ayudará a usar mybatis con boot de primavera
De hecho, MyBatis ha desarrollado una solución para unirse a la diversión debido a la bota de primavera tan popular, pero este ha resuelto muchos problemas y de hecho es mucho más suave de usar. Hay dos soluciones principales para MyBatis-Spring-Boot-Starter. Una es usar anotaciones para resolver todos los problemas, y el otro es la antigua tradición simplificada.
Por supuesto, cualquier modo debe introducir primero el archivo POM de MyBatis-Spring-Boot-Starter. Ahora la última versión es 1.1.1 (simplemente está en el doble de 11 :))
<Spendency> <MoupRoMID> org.mybatis.spring.boot </groupid> <artifactID> mybatis-spring-boot-starter </arfactid> <version> 1.1.1 </versión> </pendency>
Presentaré dos modelos de desarrollo
Sin versión de anotación de archivo de configuración
Se hace con anotaciones.
1 Agregar archivos maven relevantes
<Spendencies> <Spendency> <MoupRid> org.springframework.boot </proupid> <artifactid> spring-boot-starter </artifactid> </pendency> <pendency> <grupeD> org.springframework.boot </groupid> <artifactidid </groupid> <artifactIDid > Spring-Boot-Starter-test </arfactid> <cope> test </scope> </pendency> <pendency> <uproupid> org.springframework.boot </groupid> <artifactid> spring-boot-starter-web </artifactid> </pendency> <penen> dency> <MoupRid> org.mybatis.spring.boot </groupid> <artifactid> mybatis-spring-boot-starter </arifactid> <verose> 1.1.1 </versión> </pendency> <pendency> <uproupid> mysql </proupid> <artifactid> mysql-cc onnector-java </artifactid> </pendency> <pendency> <grupoD> org.springframework.boot </groupid> <artifactid> spring-boot-devlools </artifactid> <pectional> true </pectional> </dependency> </pendences>>
No publicaré el paquete de POM completo aquí, lea el código fuente directamente
2. Application.Properties Agregar configuraciones relevantes
mybatis.type-aliases-package = com.neo.entityspring.datasource.driverClassName = com.mysql.jdbc.driverspring.datasource.url = jdbc: mysql: // localhost: 3306/test1? usanunicode & carácter = verdadero = utf-8spring.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame.datame rootspring.datasource.password = root
SpringBoot cargará automáticamente la configuración relevante de Spring.DataSource.*, Y la fuente de datos se inyectará automáticamente en SQLSessionFactory. El SQLSessionFactory se inyectará automáticamente en el mapeador. Por cierto, no tiene que preocuparse por todo, solo recógelo y úselo.
Agregue un escaneo del paquete mapper en la clase de inicio @MapperScan
@Springbootapplication@mapperscan ("com.neo.mapper") aplicación de clase pública {public static void main (string [] args) {springapplication.run (application.class, args);}}O simplemente agregue Annotation @mapper en la clase Mapper. Se recomienda usar el anterior, de lo contrario será bastante problemático agregar anotación a cada mapeador.
3. Desarrollar mapeador
El tercer paso es la parte más crítica, y la producción de SQL está aquí
interfaz pública usermapper {@select ("select * de usuarios")@resultados ({@result (propiedad = "usersex", column = "user_sex", javatype = UsersExeNum.class),@result (Property = "Nickname", column = "nick_name")}) Lista <sereSentity> getAll ();@select ("seleccione * de Uss Usss donde id = = #{id}")@Results({@Result(property = "userSex", column = "user_sex", javaType = UserSexEnum.class),@Result(property = "nickName", column = "nick_name")})UserEntity getOne(Long id);@Insert("INSERT INTO users(userName,passWord,user_sex) VALUES(#{userName}, #{passWord}, #{Usersex}) ") void insert (userEntity user);@Update (" Usuar los usuarios Establecer username =#{username}, nick_name =#{apodo} donde id =#{id} "void update (userEntity user);@delete (" delete de usuarios donde id =#{id} ") void (largo id);};};}Para estar más cerca de la producción, subrayé especialmente los dos atributos de user_sex y nick_name en la base de datos y los nombres de los atributos de la clase de entidad son inconsistentes. Además, user_sex usa enumeraciones
@Select es una anotación de la clase de consulta, y todas las consultas usan esto
@Result Modifique el conjunto de resultados devuelto, y los atributos de clase de entidad asociados y los campos de la base de datos corresponden uno por uno. Si los atributos de la clase de entidad y los nombres de los atributos de la base de datos son consistentes, este atributo no es necesario para modificar.
@Insert Inserte la base de datos para usar, pasando directamente la clase de entidad analizará automáticamente el atributo al valor correspondiente
@Update es responsable de modificar, y también se puede pasar directamente al objeto
@Delete es responsable de eliminar
Para obtener más propiedades, consulte aquí: http://www.mybatis.org/mybatis-3/zh/java-api.html
Tenga en cuenta que la diferencia entre usar # símbolo y $ símbolo:
// Este ejemplo crea una declaración preparada, algo así como seleccionar * de maestro donde nombre =?;@Select ("select * de maestro donde nombre = #{name}") maestro selectTeachForgivenName (@param ("name") name de cadena); // Este ejemplo crea una declaración inferior, algo así como seleccionar * del maestro donde name = 'Somename';@SELECT (SELECT ("SELECT (" De Maestro Where Name = '$ {nombre {Nombre {Nombre { selectTeachForGivenName (@param ("nombre") nombre de cadena);4. Use
Los tres pasos anteriores básicamente completan el desarrollo relevante de la capa. Al usarlo, simplemente úselo como una clase ordinaria y se puede inyectar en él.
@Runwith (SpringRunner.class) @SpringBoottestPublic Class Usermappertest {@aUtoWiredPrivate Usermapper usermapper; @TestPublic Void testInSert () arroja excepción {usermapper.insert (New UserEntity ("AA", "A123456", UsersExenum.man); UserEntity ("BB", "B123456", UsersExeNum.woman)); usermapper.insert (new UserEntity ("CC", "B123456", UsersExeNum.woman)); afirmar.AssERTequals (3, usermapper.getAll (). Size ();}@testpeid void testQraery () Shows Exceptcess -Execeptectity de SHOLES SHOLES. Usermapper.getAll (); system.out.println (users.ToString ());}@testPublic void testupDate () lanza excepción {userEntity user = Usermapper.getone (3l); system.out.println (user.ToString ()); user.setNickName ("neo"); usermapper.update (user); afirmo.asserttrue (("neo" .equals (usermapper.getone (3l) .getNickName ()));}}Hay adiciones completas, deleciones, modificaciones y búsquedas en el código fuente, por lo que no las publicaré aquí.
Versión XML minimalista
La versión XML minimalista mantiene la antigua tradición de mapear archivos. La optimización se refleja principalmente en la capa de implementación que no es necesario implementarse. El sistema encontrará automáticamente el SQL correspondiente en el archivo de mapeo de acuerdo con el nombre del método.
1. Configuración
El archivo POM es el mismo que la versión anterior, excepto que la siguiente configuración se agrega a application.properties
mybatis.config-locations = classpath: mybatis/mybatis-config.xmlmybatis.mapper-locations = classpath: mybatis/mapper/*. xml
Especifica la dirección del archivo de configuración básica de MyBatis y el archivo de asignación de clase de entidad
Configuración de MyBatis-Config.xml
<Configuration> <PyyPealiases> <typealias alias = "integer" type = "java.lang.integer" /> <typealias alias = "long" type = "java.lang.long" /> <typealias alias = "Hashmap" type = "java.hashmap" /> <<pit typealy = "Linkedhashmap" type = "java.util.linkedhashmap" /> <typealias alias = "arrayList" type = "java.util.arrayList" /> <typealias alias = "linkedList" type = "java.util.linkedlist" /> </trypealiase> </formuation>
Aquí también puede agregar una configuración básica de mybatis
2. Agregue el archivo de asignación del usuario
<mappper namespace = "com.neo.mapper.usermapper"> <resultmap id = "BaseResultMap" type = "com.neo.entity.userEntity"> <id columna = "id" propiedad = "id" jdbctype = "bigint" /> <resultado columna = "useName" propiedad = "username" jdbctypee = "var" /"result" /"Results /" Result " Propiedad = "Password" JDBCType = "Varchar" /> <resultado columna = "user_sex" Property = "UsersEx" javatype = "com.neo.enums.usersexenum" /> <resultado column = "nick_name" Property = "Nickname" jdbctype = "varchar" /> </sultMap> <sql id = "base_column_monn, ID, ID, ID, ID, ID," VarCar ". contraseña, user_sex, nick_name </sql> <select id = "getall" resultMap = "BaseResultMap"> Seleccionar <incluir refid = "base_column_list" /> de usuarios < /select> <select id = "getOne" parametType = "java.lang.long" resultMap = "BaseresultMap" UsersWhere id = #{id} </select> <insertar id = "insertar" parametertype = "com.neo.entity.userEntity"> Insertar en usuarios (username, contraseña, user_sex) valores ( #{username}, #{contraseña}, #{usersex}) </sert> <update ID "if if <fi" com.neo.NeO test = "username! = null"> username = #{username}, </if> <if test = "contraseña! = null"> contraseña = #{contraseña}, </if> nick_name = #{Nickname} Where id = # {id} </update> <elete id = "Delete" parametertype = "java.lang.lang "long" delementa "DeleteSeSers #{id} </elete> </mapper>De hecho, solo estaba moviendo el mapper SQL de la versión anterior al XML aquí
3. Escribir código de capa DAO
interfaz pública usermapper {list <sureDentity> getAll (); userEntity getone (ID long); void insert (usuario de usuario); ovoid Update (usuario de usuario); void delete (ID long);}En comparación con el paso anterior, solo quedan métodos de interfaz.
4. Use
No hay diferencia entre usarlo y la versión anterior, mire el código
Cómo elegir
Los dos modos tienen sus propias características. La versión anotada es adecuada para modos simples y rápidos. De hecho, al igual que el popular modelo de microservicio hoy en día, un microservicio corresponderá a su propia base de datos. La demanda de consulta de conexión múltiple se reducirá considerablemente, y se volverá cada vez más adecuada para este modo.
El antiguo modelo tradicional es más adecuado para grandes proyectos. Puede generar de manera flexible SQL dinámicamente, lo cual es conveniente para ajustar SQL, y también tiene la sensación de escribir SQL con gran placer y elegancia.
Código de muestra-Github: https://github.com/ityouknow/spring-boot-examples
Código de ejemplo-Code Cloud: https://gitee.com/ityouknow/spring-boot-examples