Java: métodos comunes de LambdaQueryWrapper

1. Compruebe si el paquete jar de mybatisPlus está importado al proyecto.

2. La capa de servicio y la clase de implementación deben integrarse con mybatisPlus.

el servicio hereda IService<>

La clase de implementación debe heredar la clase de implementación ServiceImpl<mapper, entidad class> de IService

3. Si desea algunos métodos en el mapeador, el mapeador debe heredar BaseMapper<clase de entidad>

4. Para implementar el método en la clase de implementación, no es necesario escribir un método en xml.Métodos de uso común

Resumido de la siguiente manera:

【1 pagina

参数1是分页起始位置，一般是1，参数2：结束位置，    一般都是前端传过来的，查询的数量
Page<LandLossAllowance> page1 = new Page<LandLossAllowance>(参数1,参数2);
LambdaQueryWrapper<LandLossAllowance> queryWrapper = new LambdaQueryWrapper<>();
条件 eq 指的是相等
queryWrapper.eq(LandLossAllowance::getCountrySide,landLossAllowanceOption.getCountrySide());
执行page方法 page(参数1，参数2)
    参数1：上面的new的分页对象，参数2是lambda表达式查询条件
IPage<LandLossAllowance> iPage = page(page1, queryWrapper);

(1) La diferencia entre PageHelper e IPage : 

Instrucciones:

PageHelper.startPage() y luego escribe sql. El siguiente sql funciona.
IPage necesita pasar el objeto Page de clase de implementación de IPage en la capa dao, que implementa IPage.

la diferencia:

El principio interno de PageHelper es asignar el número de página entrante y el número de artículo al objeto Página, guardarlo en un hilo local ThreadLoacl y luego ingresar al interceptor de Mybatis.
    Luego, guarde los parámetros de paginación en el hilo local del interceptor. Finalmente, estos parámetros de paginación se unen con el sql original y el sql definido internamente para completar el procesamiento de paginación de sql.
    En el medio, se juzgará si el tipo de SQL es una consulta o una operación de modificación. Si es una consulta, ingresará a la lógica de paginación y determinará si el objeto de página encapsulado es nulo, si es nulo, no habrá paginación, de lo contrario será paginación.

El principio interno de IPage también se basa en interceptores, pero este intercepta métodos y parámetros en los métodos, lo que también determinará si se trata de una operación de consulta. Si se trata de una operación de consulta, se ingresará la lógica de procesamiento de paginación.
Después de ingresar al procesamiento lógico de paginación, el interceptor obtendrá los parámetros del método mediante reflexión para determinar si existe una clase de implementación del objeto IPage. Si no existe no se realizará ninguna paginación, si existe el parámetro se asignará al objeto IPage.
Luego realice el procesamiento de empalme de SQL para completar la operación de paginación.
Pero usar IPage requiere inyectar un interceptor de beans y dejar que Spring lo administre. como sigue. De lo contrario no se producirá la interceptación.

Después de usar Ipage, necesitas inyectar alguna configuración:

@Configuration
@MapperScan(value={"com.XX.**.mapper*"})
public class MybatisPlusConfig {

    /**
     * 分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        // 设置sql的limit为无限制，默认是500
        return new PaginationInterceptor().setLimit(-1);
    }
}

(2) Algunas definiciones de expresiones lambda de uso común

com.baomidou.mybatisplus.core.conditions.query.QueryWrapper es un objeto comúnmente utilizado en el marco MybatisPlus para construir condiciones de consulta.

Usar expresiones lambda es más claro y conciso:

 QueryWrapper<User> queryWrapper = new QueryWrapper<>();
  queryWrapper.lambda().eq(User::getName,"aa");
  queryWrapper.lambda().ge(User::getAge,20);

De forma predeterminada, hay varias condiciones y conexiones: el SQL correspondiente al método de escritura anterior es: donde nombre como '%aa%' y edad >= 20

Si desea utilizar o conectarse, el método es el siguiente:

queryWrapper.lambda().and(wq->{
    wq.like(User::getName,"aa");
    wq.or().like(User::getName,"bb);
});

Aquí hay una extensión de un escenario que encontré: lo que debe estar O conectado son todos los elementos de una colección:

List<String> nameList = Lists.newArrayList("aa","bb","cc");
String firstName = nameList.get(0);
nameList.remove(0);
queryWrapper.lambda().and(wq->{
    wq.like(User::getName,firstName);
    for(String name : nameList){
        wq.or().like(User::getName,name);
    }
});

La condición de consulta condición
allEq
está encapsulada con Map

"nombre" -> "Zhang San"

“edad” -> 20

public void testAllEq() {     QueryWrapper<Usuario> queryWrapper = new QueryWrapper<>();     // Condición de encapsulación     Map<String, Object> hashMap = new HashMap<>();     hashMap.put("nombre", "Zhang San" );     hashMap.put("edad", 20);     queryWrapper.allEq(hashMap);     Lista<Usuario> lista de usuarios = userMapper.selectList(queryWrapper);     lista de usuarios.forEach(usuario -> {         System.out.println(usuario);     }); } eq eq("nombre de columna", valor) -> nombre de columna = valor





 

 

    Lista pública<Dict> listByDictCode(DictCode dictCode) {         LambdaQueryWrapper<Dict> wrapper = Wrappers.lambdaQuery();         wrapper.eq(Dict::getDictCode, dictCode.getCode())                .eq(Dict::getEnabled, DictEnableEnum.VALID.getType());         devolver this.baseMapper.selectList(wrapper);     } ne ne("列名", 值) -> 列名 != 值

    Lista pública<Dict> listByDictCode(DictCode dictCode) {         LambdaQueryWrapper<Dict> wrapper = Wrappers.lambdaQuery();         wrapper.ne(Dict::getDictCode, dictCode.getCode())                .ne(Dict::getEnabled, DictEnableEnum.VALID.getType());         devolver this.baseMapper.selectList(wrapper);     } gt gt("edad", 20) -> edad > 20

    Lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         wrapper.gt(Usuario::getAge, 20);                     devolver this.baseMapper.selectList(wrapper);     } ge ge("edad", 20) -> edad >= 20

    Lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         wrapper.ge(Usuario::getAge, 20);                     devolver this.baseMapper.selectList(wrapper);     } lt lt("edad", 20) -> edad < 20

    Lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         wrapper.lt(Usuario::getAge, 20);                     devolver this.baseMapper.selectList(wrapper);     } le le("edad", 21) -> edad <= 21

    Lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         wrapper.le(Usuario::getAge, 20);                     devolver this.baseMapper.selectList(wrapper);     } entre,noentreentre ("edad", 18, 25) -> edad ENTRE 18 Y 25 ，年龄在18到25之间

notBetween significa que no tiene entre 18 y 25 años

    lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         wrapper.between(User::getAge, 18,25);                         return this.baseMapper.selectList(wrapper);     } me gusta, no me gusta me gusta Valor coincidente-> consulta difusa "%valor%"

NotLike consulta difusa no coincide con "%value%"

    Lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();          wrapper.like(Usuario::getName, "张");                    devolver this.baseMapper.selectList(wrapper);     } likeLeft likeLeft 匹配值 -> "%值"

    Lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();          wrapper.likeLeft(Usuario::getName, "张");                    devolver this.baseMapper.selectList(wrapper);     } me gustaDerecho me gustaDerecho 匹配值 -> "值%"

    lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         wrapper.likeRight(User::getName, "Zhang");                    devuelve this.baseMapper.selectList(wrapper);     } consulta de valor nulo isNull isNotNull consulta de valor no nulo     public List<Usuario> userList() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         wrapper.isNull(Usuario::getName);         //wrapper.isNotNull(Usuario::getName);                       return this .baseMapper.selectList(wrapper);     } in in("name", "Zhang San", "李思") -> name in ("Zhang San", "李思") Usuario cuyo nombre es Zhang San o Li Si

notIn
notIn("nombre", "张三", "李思") -> nombre no en ("张三", "李思") Usuario cuyo nombre no es Zhang San o Li Si

    Lista pública<Usuario> lista de usuarios() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         wrapper.in(Usuario::getName, "张三","李四");         //wrapper.in(Usuario::getName, "张三","李四");                    devolver this.baseMapper.selectList(wrapper);     } inSql、notInSql public List<Usuario> userList() {     LambdaQueryWrapper<Usuario> wrapper= new LambdaQueryWrapper<>();     // SELECCIONE id, nombre, correo electrónico, edad DEL usuario DONDE (edad EN (seleccione la edad del usuario donde id = 1))     wrapper.inSql(Usuario::getAge, "seleccione la edad del usuario donde id = 1");     devolver this.baseMapper.selectList(wrapper); } grupoPor分组

Lista pública<Usuario> lista de usuarios() {     LambdaQueryWrapper<Usuario> contenedor = nuevo LambdaQueryWrapper<>();     wrapper.groupBy(Usuario::getName);     devolver this.baseMapper.selectList(wrapper); } orderBy、orderByAsc、orderByDesc public List<Usuario> userList() {     LambdaQueryWrapper<Usuario> contenedor = new LambdaQueryWrapper<>();     // SELECCIONAR id, nombre, correo electrónico, edad DEL usuario ORDENAR POR nombre ASC, edad DESC     wrapper.orderBy(true, true, Usuario::getName).orderBy(true, false, Usuario::getAge);     // SELECCIONAR id, nombre, correo electrónico, edad DEL usuario ORDENAR POR nombre ASC, edad ASC     wrapper.orderByAsc(Usuario::getName, Usuario::getAge);     // SELECCIONAR id, nombre, correo electrónico, edad DEL usuario ORDENAR POR nombre DESC, edad DESC









    


 

    wrapper.orderByDesc(Usuario::getName, Usuario::getAge);
 
    devolver this.baseMapper.selectList(wrapper);
}
o、y
    public List<Usuario> userList() {         LambdaQueryWrapper<Usuario> wrapper = Wrappers.lambdaQuery();         // SELECCIONE id, nombre, correo electrónico, edad DEL usuario DONDE (nombre =? Y id =?)         wrapper.eq(Usuario::getName, "张三").and().eq(Usuario::getId,1) ;         // SELECCIONE id, nombre, correo electrónico, edad DEL usuario DONDE (nombre =? O id =?)                wrapper.eq(Usuario::getName, "张三").or().eq(Usuario::getId,1) ;              devolver this.baseMapper.selectList(wrapper);     }这里说明一下or和and的问题

 


 

código de error

Lista pública<Usuario> lista de usuarios() {     LambdaQueryWrapper<Usuario> contenedor = nuevo LambdaQueryWrapper<>();     wrapper.eq(Usuario::getId,1);     wrapper.like(Usuario::getName,"Zhang")            .o( )            .like(User::getEmail,"163")            .or()            .like(User::getAge,1); } La declaración SQL escrita de acuerdo con el método de escritura anterior es la siguiente:
 

DONDE id = '1' 
    Y nombre COMO '%张%'
    O correo electrónico COMO '%163%'
    O edad COMO '%1%'
Esto obviamente es incorrecto. Según el orden de ejecución de la declaración MySQL, se ejecutará en último lugar. Esto hará que [nombre como '%张%'] La condición o después de que se establezca la condición no sea válida, por lo que la primera condición no desempeña el papel de y.

Solución
lista pública<Usuario> lista de usuarios() {     LambdaQueryWrapper<Usuario> wrapper = new LambdaQueryWrapper<>();     wrapper.eq(Usuario::getId,1);     wrapper.and(wrapper->wrapper.like(Usuario:: getName ,"Zhang")                                 .or()                                 .like(User::getEmail,"163")                                 .or()                                 .like(User::getAge,1)                ); } La declaración SQL obtenida de esta manera es la siguiente
 

WHERE id = '1' 
    AND (nombre COMO '%张%'
    O correo electrónico COMO '%163%'
    O edad COMO '%1%')
Esto resuelve el problema. Este problema se resuelve para las personas nuevas en mi empresa (incluyéndome a mí ) ) parece haber encontrado este problema, déjame explicarlo aquí

última
declaración SQL de empalmes al final

Nota: last() tiene el riesgo de inyección SQL, ¡úselo con precaución!

Lista pública<Usuario> lista de usuarios() {     LambdaQueryWrapper<Usuario> contenedor = nuevo LambdaQueryWrapper<>();     // SELECCIONE id, nombre, correo electrónico, edad DEL usuario DONDE (nombre =? O edad =?) límite 1     wrapper.eq(Usuario::getName, "张三").or().eq(Usuario::getAge, 20).último("límite 1");     devolver this.baseMapper.selectList(wrapper); } existe、notExists public List<Usuario> userList() {     LambdaQueryWrapper<Usuario> contenedor = new LambdaQueryWrapper<>();     // SELECCIONE id, nombre, correo electrónico, edad DEL usuario DONDE (EXISTE (seleccione el nombre del usuario donde la edad > ?))     wrapper.exists("seleccione el nombre del usuario donde la edad > 21");     // SELECCIONAR identificación, nombre, correo electrónico,








 


 

    wrapper.notExists("seleccione el nombre del usuario con edad > 21");
 
    devolver this.baseMapper.selectList(wrapper);
}