Tabla de contenido
2. Personaliza la implementación específica de SQL
2.2 Paso de parámetros de contenedor + SQL de anotación
2.3 Parámetro de pase de envoltura + archivo xml SQL
2.4 Paso normal de parámetros + archivo XML SQL
1. Introducción
La intención original de Mybatis-Plus (en lo sucesivo, MBP) es simplificar el desarrollo y no se recomienda que los desarrolladores escriban declaraciones SQL por sí mismos; sin embargo, a veces las necesidades de los clientes son más complejas y es difícil lograr lo requerido. solo mediante el uso de la combinación de Service, Mapper y Wrapper proporcionada por MBP. ; Luego usaremos SQL personalizado.
El desarrollo de Java usa mybatis-plus para realizar operaciones SQL, lo que a menudo ahorra tiempo y esfuerzo en comparación con mybatis, porque mybatis-plus encapsula muchas interfaces de uso común. Pero para algunas consultas más complejas, mybatis-plus también palidece en comparación, y necesitamos personalizar la instrucción sql. Este artículo presentará cómo personalizar sentencias sql, sql dinámico, etc. al usar mybatis-plus/mybatis.
Mybatis-Plus tiene varias formas de implementar la personalización:
1) Anotar SQL
2) Parámetro de pase de contenedor + SQL de anotación
Limitaciones: no es adecuado para consultas de asociación de varias tablas, demasiados campos de consulta y códigos son desordenados
3) Paso de parámetros de envoltura + archivo XML SQL: recomendado
4) Paso de parámetro de objeto + archivo XML SQL
La forma más tradicional de escribir, el proceso es demasiado engorroso y la configuración es problemática para una consulta simple de una sola tabla.
2. Personaliza la implementación específica de SQL
2.1 Anotar SQL
Mybatis-plus proporciona la función de anotar SQL, que puede realizar la escritura de SQL a través de la anotación.La premisa de anotar SQL es habilitar la función de anotación en el archivo de configuración de Mybatis.
Podemos usar SQL personalizado completo en la clase de herencia de Mapper;
//多数据源情况下，@DS注解用于指定数据源
@DS("zw-mysqldb")
public interface CarMapper extends BaseMapper<Car> {
@Select("select * from car where car_seq = #{carSeq}")
Car queryCar(String carSeq);
} @RequestMapping("/ok")
public void testCustomSQL2() {
Car car = carMapper.queryCar("11");
System.out.println(car.toString());
}Reponer:
1）使用@Param注解
当以下面的方式进行写SQL语句时：
@Select("select column from table where userid = #{userid} ")
public int selectColumn(int userid);
当你使用了使用@Param注解来声明参数时，如果使用 #{} 或 ${} 的方式都可以。
@Select("select column from table where userid = ${userid} ")
public int selectColumn(@Param("userid") int userid);
当你不使用@Param注解来声明参数时，必须使用使用 #{}方式。如果使用 ${} 的方式，会报错。
@Select("select column from table where userid = ${userid} ")
public int selectColumn(@Param("userid") int userid);
2）不使用@Param注解
不使用@Param注解时，参数只能有一个，并且是Javabean。在SQL语句里可以引用JavaBean的属性，而且只能引用JavaBean的属性。
// 这里id是user的属性
@Select("SELECT * from Table where id = ${id}")
Enchashment selectUserById(User user);En el código anterior, se utiliza el método de anotar SQL y la instrucción SQL se especifica a través de la anotación @Select. Utilice la anotación @Param para especificar el nombre del parámetro en el método, lo que puede facilitar la transferencia de parámetros. El nombre del parámetro es coherente con el nombre del parámetro sql y se puede omitir.
La ventaja de anotar SQL es que el código es conciso y legible, y también se puede combinar con Wrapper y otros métodos para construir SQL complejo.
2.2 Paso de parámetros de contenedor + SQL de anotación
Algunos escenarios de uso utilizando el método Wrapper:
1) Consulta dinámica: use Wrapper para unir dinámicamente las declaraciones SQL de acuerdo con diferentes condiciones de consulta para lograr una consulta precisa.
2) Consulta conjunta de varias tablas: Cuando realice una consulta conjunta de varias tablas, use Wrapper para empalmar fácilmente las declaraciones SQL para realizar consultas conjuntas de varias tablas.
3) Consulta de paginación: en la consulta de paginación, el uso de Wrapper puede empalmar convenientemente las declaraciones SQL para realizar la función de paginación.
4) Consulta condicional: use Wrapper para unir dinámicamente las declaraciones SQL de acuerdo con diferentes condiciones para realizar la consulta condicional.
5) Consulta de clasificación: use Wrapper para empalmar fácilmente las declaraciones SQL para realizar la función de clasificación
Cuando se usa SQL combinado con Wrapper para construir SQL complejo, generalmente se deben completar los siguientes pasos:
a) Crear un objeto Wrapper
Al crear un objeto Wrapper, la construcción de SQL y la configuración de condiciones se pueden realizar convenientemente. El siguiente es un código de muestra para crear un objeto Wrapper:
QueryWrapper<Entity> wrapper = new QueryWrapper<>();
b) Establecer condiciones de consulta
Puede usar los métodos del objeto Wrapper para establecer condiciones de consulta, como eq, ne y otros métodos para establecer condiciones como igual a y no igual a. El siguiente es el código de muestra para establecer las condiciones de consulta:
wrapper.eq("column1", value1)
.ne("column2", value2)
.like("column3", value3);
//示例
wrapper.eq("car_state", "1")
.like("car_id", "渝A");c) Establecer condiciones de clasificación (no obligatorio)
Puede usar el método orderBy del objeto Wrapper para establecer condiciones de clasificación, como orderByAsc, orderByDesc y otros métodos pueden establecer un orden ascendente, descendente y otras condiciones. El siguiente es un código de muestra para configurar las condiciones de clasificación:
wrapper.orderByAsc("car_id")d) Establecer condiciones de paginación (no requerido)
Puede usar los métodos del objeto Wrapper para establecer las condiciones de paginación, por ejemplo, el método de página puede establecer condiciones como el número de página y el tamaño de cada página. Aquí está el código de muestra para establecer la condición de paginación:
Page<Car> resultPage = new Page<>(1, 10);
carMapper.selectByPrimaryKey(resultPage,wrapper)
e) interfaz del mapeador
@Select("select * from car ${ew.customSqlSegment}")
Page<Car> selectByPrimaryKey(Page<Car> page, @Param(Constants.WRAPPER) QueryWrapper<Car> queryWrapper);f) Ejecutar operaciones SQL
El método de la interfaz ejecuta operaciones SQL, como selectList, selectPage y otros métodos pueden ejecutar operaciones de consulta SQL y también pueden personalizar consultas. El siguiente es un código completo de muestra para realizar operaciones SQL:
//分页查询方式1
QueryWrapper<Car> wrapper = new QueryWrapper<>();
Page<Car> resultPage = new Page<>(1, 10);
wrapper.eq("car_state", "1")
.like("car_id", "渝A")
.orderByAsc("car_id");//排序
carMapper.selectByPrimaryKey(resultPage,wrapper);
//分页查询方式2
IPage<Car> page = new Page<>(1, 10); // 分页查询
LambdaQueryWrapper<Car> qw = new LambdaQueryWrapper<Car>()
.like(Car::getCarId, "渝A") // 车牌号 =
.eq(Car::getCarState, 1); // 状态
//selectPage是BaseMapper自带方法
IPage<Car> userPage = carMapper.selectPage(page, qw);Aviso:
1) Use la clase uservo personalizada en QueryWrapper, no se puede usar LambdaQueryWrapper
2) Tanto IPage como Page mencionados anteriormente se pueden usar para paginar Aquí hay varias formas de MybatisPlus
archivo xml
g) Resultado de la ejecución:
Reponer:
En aplicaciones prácticas, también podemos usar LambdaQueryWrapper y QueryWrapper para implementar operaciones de consulta más complejas para satisfacer diferentes necesidades comerciales. Por ejemplo, podemos usar LambdaQueryWrapper y QueryWrapper para consultas dinámicas y combinar sentencias SQL juzgando los parámetros pasados desde el front-end para lograr operaciones de consulta flexibles.
public List<UserEntity> getUserList(String name, Integer age) {
LambdaQueryWrapper<UserEntity> qw = new LambdaQueryWrapper<UserEntity>()
.eq(StringUtils.isNotEmpty(name), UserEntity::getName, name) // 姓名 = name
.gt(age != null, UserEntity::getAge, age); // 年龄 > age
return userMapper.selectList(qw);
}
En el código anterior, implementamos operaciones de consulta dinámica a través de LambdaQueryWrapper. Si el parámetro de nombre pasado no está vacío, se agregará una condición de consulta igual; si el parámetro de edad pasado no está vacío, se agregará una condición de consulta mayor que.
Tales operaciones de consulta pueden combinar de manera flexible declaraciones SQL de acuerdo con los parámetros pasados desde el front-end para satisfacer más necesidades comerciales.
Aviso:
1) El objeto de consulta @Param(Constants.WRAPPER) Wrapper en el método mapper, el valor de Constants.WRAPPER es ew.
2) Primero juzgue si hay una condición where en ew.emptyOfWhere, y luego empalme si es así,3) El valor de ew.customSqlSegment es la declaración WHERE + sql, y hay otro ew.sqlSegment que no incluye la cadena WHERE
4) ${ew.customSqlSegment} es un marcador de posición de condición de consulta, que representa la condición de consulta de Wapper.
Por supuesto, Mybatis-Plus proporciona algunos métodos SQL personalizados, como selectObjs, selectByMap, etc., que se pueden usar directamente, por ejemplo:
List<Object> objs = userMapper.selectObjs(
new QueryWrapper<User>().select("max(age)").eq("name", "张三")
);2.3 Parámetro de pase de envoltura + archivo xml SQL
El paso de parámetros Wrapper es un método de operación avanzado en Mybatis, que puede pasar parámetros dinámicamente al consultar
1) clase de mapeador
Car selectBySeq @Param(Constants.WRAPPER) QueryWrapper<Car> queryWrapper);2) archivo de configuración xml
<select id="selectBySeq " resultMap="BaseResultMap">
select * from `car` ${ew.customSqlSegment}
</select>3) Pasar parámetros de consulta a través de Wapper
Use Wrapper para pasar parámetros dinámicamente
1. Use la clase base Wrapper para personalizar la instrucción SQL detrás de Where;
2. Usa el contenedor de consulta
-
seleccione | seleccionar(Cadena... sqlSeleccionar)
例select("id", "nombre", "edad")
Elija cualquiera de los dos métodos anteriores, y los parámetros son Wrapper
@RequestMapping("/ok")
public void testCustomSQL2() {
LambdaQueryWrapper<Car> query = new LambdaQueryWrapper<>();
query.eq(Car::getCarId, "11");
Car car= carMapper.queryCarSeq(query);
System.out.println(car.toString());
}
//或者
Wrapper wrapper = new QueryWrapper<Car>().eq("car_state", 1).like("cai_id", "渝");
List<Car> userList = carMapper.queryCarSeq(wrapper);
La ventaja de la combinación de los parámetros SQL del archivo XML y Wrapper es que mejora la capacidad de mantenimiento, la legibilidad y la seguridad del código. Es adecuado para escenarios donde el volumen del código es grande y requiere un desarrollo colaborativo de varias personas, y puede ataques de inyección
2.4 Paso normal de parámetros + archivo XML SQL
Cree una carpeta del asignador en el directorio de recursos y luego cree un archivo xml con el mismo nombre que la interfaz del asignador, como UserMapper.xml, para definir instrucciones SQL personalizadas.
//xml文件式，myabtis原生方式
Car selectByAnnotationXML(String seq);Cree el archivo UserDao.xml en mapeador
<select id="selectByAnnotationXML" parameterType="java.lang.String" resultMap="BaseResultMap">
select *
from car
where car_seq = #{seq,jdbcType=VARCHAR}
</select>
Este método es la forma más básica de contactar con mybatis
3. Resumen
En general, hay dos formas de escribir sql, una es escribir directamente en el método del mapeador usando anotaciones y la otra es escribir en el archivo xml; también hay dos formas de pasar parámetros, una es pasar parámetros directamente en el ensamblado sql en el archivo xml, uno es pasar el constructor condicional de parámetros a través de Wapper
Ventajas de las anotaciones
Conciso y fácil de entender: en comparación con la configuración XML, el uso de anotaciones es más conciso e intuitivo, lo que hace que el código sea más legible y fácil de mantener.
Fácil de depurar: las configuraciones de anotación se pueden escribir directamente en las clases de Java, lo que reduce el tiempo para buscar y modificar SQL en XML.
Mejor rendimiento : cuando se realiza una gran cantidad de operaciones CRUD, el rendimiento de la configuración de anotaciones es mayor, porque no hay sobrecarga de análisis XML.
Desventajas de las anotaciones
No favorece el mantenimiento: acoplar el código SQL y Java hace que el código sea difícil de mantener y refactorizar, especialmente cuando se trata de SQL más complejo.
Mala legibilidad de SQL: en comparación con la escritura de SQL en XML, las declaraciones de SQL en las anotaciones suelen ser más detalladas y difíciles de leer.
Ventajas de XML
Fácil de mantener: SQL está separado del código Java y el código es más fácil de mantener, especialmente cuando es necesario modificar SQL.
Buena legibilidad de SQL: escribir SQL en XML puede hacer que el formato de SQL sea más claro y legible.
Fácil de administrar: los archivos de configuración XML se pueden administrar globalmente, lo que hace que la estructura del proyecto sea más clara.
Desventajas de XML
Complicado: en comparación con las anotaciones, la configuración XML es más engorrosa y requiere más código.
Problemas de rendimiento: al realizar una gran cantidad de operaciones, el análisis y la lectura de XML tardarán un cierto tiempo, lo que reducirá el rendimiento del sistema .
En resumen, la elección de anotaciones y XML debe decidirse de acuerdo con la situación real y las necesidades del proyecto. Para consultas y operaciones simples, las anotaciones pueden ser más adecuadas; para consultas y operaciones complejas, XML es más adecuado.
Los métodos comunes se refieren a documentos oficiales.