Red de conocimiento informático - Material del sitio web - Cómo utilizar mybatis con elegancia

Cómo utilizar mybatis con elegancia

Cómo usar mybatis con elegancia

En los últimos dos días se inició un nuevo proyecto porque los miembros del equipo del proyecto siempre han usado mybatis. Aunque personalmente prefiero el modelo minimalista de jpa, Sin embargo, para mantener la uniformidad en la selección de tecnología para el proyecto, se eligió mybatis. Me conecté a Internet para encontrar información relevante sobre la combinación de Spring Boot y Mybatis. Hay varias formas, lo que cansa a la gente. Después de combinar la demostración oficial y la documentación de Mybatis, finalmente encontré los dos modos más simples. después del resumen de tiempo.

La esencia del marco ORM es simplificar la codificación de las bases de datos operativas en la programación. Ahora quedan básicamente dos empresas. Una es hibernate, que afirma que se puede utilizar sin escribir una frase de SQL. y el otro puede depurar SQL dinámico de manera flexible Mybatis, ambos tienen sus propias características y pueden usarse de manera flexible según las necesidades en el desarrollo de sistemas a nivel empresarial. Encontré un fenómeno interesante: a la mayoría de las empresas tradicionales les gusta usar la hibernación y la industria de Internet generalmente usa mybatis.

La característica de hibernación es que todo SQL se genera utilizando código Java. No es necesario salir del programa para escribir (leer) SQL. Tiene la integridad de la programación. arriba, es el modelo jpa de datos de primavera. Básicamente, el sql correspondiente se puede generar según el nombre del método. Si no sabe mucho al respecto, puede leer mi último artículo springboot (5): El uso de jpa de datos de primavera. .

Mybatis es más problemático de usar en la etapa inicial. 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 deficiencia en la etapa inicial y desarrolló un generador que puede generar automáticamente clases de entidad, archivos de configuración y códigos de capa DAO en función de los resultados de la tabla, lo que puede reducir parte de la carga de trabajo de desarrollo. , también se llevó a cabo mucha optimización para permitir el uso de anotaciones y la gestión automática de capas y archivos de configuración, etc., y este es el modelo del que hablaré hoy. -starter es springboot + mybatis, que se puede anotar completamente sin un archivo de configuración y se puede configurar y usar fácilmente.

Ahora piénselo, Spring Boot es increíble. Todo lo relacionado con Spring Boot simplificará la complejidad.

mybatis-spring-boot-starter

Descripción oficial: MyBatis Spring-Boot-Starter te ayudará a usar MyBatis con Spring Boot

De hecho, myBatis parece En primavera, Boot es tan popular que se ha desarrollado un conjunto de soluciones para unirse a la diversión, pero esta solución resuelve muchos problemas y, de hecho, es mucho más sencilla de usar. mybatis-spring-boot-starter tiene principalmente dos soluciones: una es utilizar anotaciones para resolver todos los problemas y la otra es la antigua tradición simplificada.

Por supuesto, cualquier modo debe introducir primero el archivo pom de mybatis-spring-boot-starter. La última versión ahora es 1.1.1 (es casi Double 11 :))

< dependencia>

org.mybatis.spring.boot

mybatis-spring-boot-starter

1.1.1

1234512345

Ahora introduzcamos los dos modos de desarrollo respectivamente

Sin archivo de configuración Versión de anotación

Todo se hace mediante anotaciones.

1 Agregar archivos maven relacionados

org.springframework.boot

spring-boot-starter

org.springframework.boot

spring-boot-starter-test

prueba

org.springframework.boot

spring-boot- web de inicio

org.mybatis.spring.boot

mybatis-spring-boot-starter

1.1.1

mysql

mysql-connector-java

< /dependency>

org.springframework.boot

spring-boot-devtools

true

123456789101112131415161718192021222324252627282912345678910111213141516171819202122 23242 526272829

Paquete completo de pompones No lo publicaré aquí, solo puede mirar el código fuente

2. Agregue configuraciones relevantes a application.properties

mybatis.type-aliases-package=com.neo. .entidad

spring.datasource.driver

ClassName = com.mysql.jdbc.Driver

spring.datasource.url = jdbc:mysql://localhost:3306/test1?useUnicode=true&characterEncoding=utf-8

spring. datasource.username = root

spring.datasource.password = root123456123456

springboot cargará automáticamente la configuración relacionada con spring.datasource.*, la fuente de datos se inyectará automáticamente en sqlSessionFactory, sqlSessionFactory Se inyecta automáticamente en el Mapper. Por cierto, no tienes que preocuparte por nada, simplemente recógelo y úsalo.

Agregue @MapperScan para escanear el paquete del asignador en la clase de inicio

@SpringBootApplication

@MapperScan("com.neo.mapper")

Aplicación de clase pública {

public static void main(String[] args) {

SpringApplication.run(Application.class, args);

}

}1234567812345678

O agregue la anotación @Mapper directamente en la clase Mapper. Se recomienda usar la anterior, de lo contrario será bastante problemático agregar anotaciones a cada mapeador.

3. Desarrollar Mapper

El tercer paso es el más crítico, la producción de SQL está aquí

interfaz pública UserMapper {

@Select("SELECT * FROM usuarios")

@Results({

@Result(property = "userSex", column = "user_sex", javaType = UserSexEnum.class),

@Result(property = "nickName", column = "nick_name")

})

Lista getAll();

@Select( "SELECCIONAR * DE usuarios DONDE id = #{id}")

@Results({

@Result(property = "userSex", column = " user_sex", javaType = UserSexEnum .class),

@Result(property = "nickName", column = "nick_name")

})

UserEntity getOne (ID largo);

@Insert("INSERTAR EN usuarios(nombredeusuario,contraseña,sexo_usuario) VALORES(#{nombredeusuario}, #{contraseña}, ​​#{sexo de usuario})")

void insert(Usuario UserEntity);

@Update("ACTUALIZAR usuarios SET userName=#{userName},nick_name=#{nickName} WHERE id =#{id}")

actualización nula (usuario UserEntity);

@Delete("BORRAR DE usuarios DONDE id =#{id}")

eliminación nula (ID larga);

}12345678910111213141516171819202122232425261234567891011121314151617 181920212223242526

Para estar más cerca de la producción, subrayé especialmente los dos atributos user_sex y nick_name en la base de datos, que son inconsistentes con los nombres de atributos de clase de entidad. Además, user_sex. usa una enumeración

@Select es una clase de consulta. Nota: todas las consultas usan este

@Result para modificar el conjunto de resultados devuelto y asociar el resultado real.

Existe una correspondencia uno a uno entre los atributos de la clase de entidad y los campos de la base de datos. Si los atributos de la clase de entidad y los nombres de los atributos de la base de datos son consistentes, no es necesario modificar este atributo.

@Insert se utiliza para insertar en la base de datos. Pasar directamente la clase de entidad analizará automáticamente los atributos a los valores correspondientes.

@Update es responsable de la modificación, y usted también puede hacerlo. pasar directamente el objeto

@delete es responsable de la eliminación

Para obtener más atributos, consulte aquí

Tenga en cuenta la diferencia entre usar el símbolo # y el símbolo $ :

// Este ejemplo crea una declaración preparada, algo así como select * from profesor donde nombre = ?;

@Select("Seleccione * del profesor donde nombre = #{nombre} ")

Profesor selectTeachForGivenName(@Param( "name") String name);

// Este ejemplo crea n declaraciones en línea, algo así como select * from teacher donde nombre = 'algúnNombre ';

@Select("Seleccionar * del profesor donde nombre = '${name}'")

Profesor selectTeachForGivenName(@Param("nombre") Nombre de cadena);12345671234567

4. Uso

Los tres pasos anteriores básicamente han completado el desarrollo de la capa dao relevante. Cuando se usa, se puede inyectar como una clase normal.

@RunWith(SpringRunner.class)

@SpringBootTest

clase pública UserMapperTest {

@Autowired

UserMapper privado UserMapper;

@Test

public void testInsert () arroja una excepción {

UserMapper.insert(new UserEntity("aa", "a123456", UserSexEnum.MAN));

UserMapper.insert(new UserEntity("bb" , "b123456", UserSexEnum.WOMAN));

UserMapper.insert(new UserEntity("cc", "b123456", UserSexEnum.WOMAN));

Assert.assertEquals( 3, UserMapper.getAll().size());

}

@Test

public void testQuery() arroja una excepción {

List usuarios = UserMapper.getAll();

System.out.println(users.toString()) ;

}

@ Test

public void testUpdate() arroja una excepción {

UserEntity user = UserMapper.getOne(3l);

System.out.println(usuario.toString())

;

user.setNickName("neo");

UserMapper.update(usuario);

Assert.assertTrue(("neo".equals(UserMapper .getOne(3l).getNickName())));

}

}12345678910111213141516171819202122232425262728293031123456789101112131415161718192021222 32425 262728293031

La capa del controlador en el código fuente tiene adiciones y eliminaciones completas y modificaciones, aquí ya no está publicado

El código fuente está aquí spring-boot-mybatis-annotation

Versión XML minimalista

La versión XML minimalista mantiene La antigua tradición de mapear archivos y optimizarla se refleja principalmente en el hecho de que no es necesario implementar dao en la capa de implementación. El sistema encontrará automáticamente el sql correspondiente en el archivo de mapeo según el nombre del método.

1. Configuración

archivo pom y la versión anterior Lo mismo, solo agregue la siguiente configuración a application.properties

mybatis.config-locations=classpath:mybatis/mybatis-config .xml

mybatis.mapper-locations=classpath:mybatis/mapper /*.xml1212

Especifica la dirección del archivo de configuración básica de mybatis y del archivo de mapeo de clases de entidad

configuración mybatis-config.xml

1234567891012345678910

También puede agregar algunas configuraciones básicas de mybatis aquí

2. Agregar el archivo de mapeo del usuario

< asignador namespace="com.neo.mapper.UserMapper" >>p>

>p>

lumn="nombre de usuario" propiedad="nombre de usuario" jdbcType="VARCHAR" />

id, nombre de usuario, contraseña, sexo_usuario, apodo

>p>

INSERTAR EN

usuarios

(nombre de usuario,contraseña,sexo_usuario)

VALUES

(#{nombre de usuario}, #{contraseña}, ​​#{sexo de usuario})

ACTUALIZAR

usuarios

SET

userName = #{userName},

contraseña = #{contraseña},

nick_name = #{nickName}

DÓNDE

id = #{id}

ELIMINAR DE

usuarios

DÓNDE<

/p>

id =#{id}

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849 5051 5212345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152

De hecho, es el mapeador en la versión anterior El sql se ha movido al xml aquí

3 Escriba el código de la capa Dao

interfaz pública UserMapper {

List getAll();

UserEntity getOne(ID largo);

inserción nula (usuario UserEntity);

actualización nula (usuario UserEntity);

eliminación nula (ID larga);

}1234567891011121312345678910111213

En comparación con el paso anterior, aquí solo quedan los métodos de la interfaz

4.

Uso y No hay diferencia entre la versión anterior, solo veamos el código

Versión de configuración xml

Cómo elegir

Los dos modos tienen sus propias características y la versión anotada es adecuada para el modelo de simplicidad y velocidad; de hecho, al igual que el ahora popular modelo de microservicio, un microservicio corresponderá a su propia base de datos y la necesidad de consultas de conexión de varias tablas se reducirá considerablemente y será cada vez más adecuado para este modelo.

El antiguo modelo tradicional es más adecuado para proyectos a gran escala. Puede generar SQL de manera flexible y dinámica, lo que facilita el ajuste de SQL. También se siente como escribir SQL de manera feliz y elocuente.