【Mybatis-Plus】根据自定义注解实现自动加解密

已于 2024-06-16 17:40:29 修改
阅读量1.2k 收藏 25
点赞数 8
分类专栏： Spring Boot 文章标签： mybatis 自动 加密 解密 拦截器 mybatis-plus 注解
于 2024-06-16 17:32:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/friendlytkyj/article/details/139723244
版权

背景

我们把数据存到数据库的时候，有些敏感字段是需要加密的，从数据库查出来再进行解密。如果存在多张表或者多个地方需要对部分字段进行加解密操作，每个地方都手写一次加解密的动作，显然不是最好的选择。如果我们使用的是Mybatis框架，那就跟着一起探索下如何使用框架的拦截器功能实现自动加解密吧。

定义一个自定义注解

我们需要一个注解，只要实体类的属性加上这个注解，那么就对这个属性进行自动加解密。我们把这个注解定义灵活一点，不仅可以放在属性上，还可以放到类上，如果在类上使用这个注解，代表这个类的所有属性都进行自动加密。

/**
 * 加密字段
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD, ElementType.ANNOTATION_TYPE, ElementType.TYPE})
public @interface EncryptField {

}

定义实体类

package com.wen3.demo.mybatisplus.po;

import com.baomidou.mybatisplus.annotation.*;
import com.wen3.demo.mybatisplus.encrypt.annotation.EncryptField;
import lombok.Getter;
import lombok.Setter;
import lombok.experimental.Accessors;

@EncryptField
@Getter
@Setter
@Accessors(chain = true)
@KeySequence(value = "t_user_user_id_seq", dbType = DbType.POSTGRE_SQL)
@TableName("t_USER")
public class UserPo {

    /**
     * 用户id
     */
    @TableId(value = "USER_ID", type = IdType.INPUT)
    private Long userId;

    /**
     * 用户姓名
     */
    @TableField("USER_NAME")
    private String userName;

    /**
     * 用户性别
     */
    @TableField("USER_SEX")
    private String userSex;

    /**
     * 用户邮箱
     */
    @EncryptField
    @TableField("USER_EMAIL")
    private String userEmail;

    /**
     * 用户账号
     */
    @TableField("USER_ACCOUNT")
    private String userAccount;

    /**
     * 用户地址
     */
    @TableField("USER_ADDRESS")
    private String userAddress;

    /**
     * 用户密码
     */
    @TableField("USER_PASSWORD")
    private String userPassword;

    /**
     * 用户城市
     */
    @TableField("USER_CITY")
    private String userCity;

    /**
     * 用户状态
     */
    @TableField("USER_STATUS")
    private String userStatus;

    /**
     * 用户区县
     */
    @TableField("USER_SEAT")
    private String userSeat;
}

拦截器

Mybatis-Plus有个拦截器接口com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor，但发现这个接口有一些不足

  • 必须构建一个MybatisPlusInterceptor这样的Bean
  • 并调用这个Bean的addInnerInterceptor方法，把所有的InnerInterceptor加入进去，才能生效
  • InnerInterceptor只有before拦截，缺省after拦截。加密可以在before里面完成，但解密需要在after里面完成，所以这个InnerInterceptor不能满足我们的要求

所以继续研究源码，发现Mybatis有个org.apache.ibatis.plugin.Interceptor接口，这个接口能满足我对自动加解密的所有诉求

  • 首先，实现Interceptor接口，只要注册成为Spring容器的Bean，拦截器就能生效
  • 可以更加灵活的在before和after之间插入自己的逻辑

加密拦截器

创建名为EncryptInterceptor的加密拦截器，对update操作进行拦截，对带@EncryptField注解的字段进行加密处理，无论是save方法还是saveBatch方法都会被成功拦截到。

package com.wen3.demo.mybatisplus.encrypt.interceptor;

import com.wen3.demo.mybatisplus.encrypt.annotation.EncryptField;
import com.wen3.demo.mybatisplus.encrypt.util.FieldEncryptUtil;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Objects;

/**
 * 对update操作进行拦截，对{@link EncryptField}字段进行加密处理；
 * 无论是save方法还是saveBatch方法都会被成功拦截；
 */
@Slf4j
@Intercepts({
        @Signature(type = Executor.class, method = "update", args = {MappedStatement.class, Object.class})
})
@Component
public class EncryptInterceptor implements Interceptor {

    private static final String METHOD = "update";

    @Setter(onMethod_ = {@Autowired})
    private FieldEncryptUtil fieldEncryptUtil;

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        if(!StringUtils.equals(METHOD, invocation.getMethod().getName())) {
            return invocation.proceed();
        }

        // 根据update拦截规则，第0个参数一定是MappedStatement，第1个参数是需要进行判断的参数
        Object param = invocation.getArgs()[1];
        if(Objects.isNull(param)) {
            return invocation.proceed();
        }

        // 加密处理
        fieldEncryptUtil.encrypt(param);

        return invocation.proceed();
    }
}

解密拦截器

创建名为DecryptInterceptor的加密拦截器，对query操作进行拦截，对带@EncryptField注解的字段进行解密处理，无论是返回单个对象，还是对象的集合，都会被拦截到。

package com.wen3.demo.mybatisplus.encrypt.interceptor;

import cn.hutool.core.util.ClassUtil;
import com.wen3.demo.mybatisplus.encrypt.annotation.EncryptField;
import com.wen3.demo.mybatisplus.encrypt.util.FieldEncryptUtil;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.executor.resultset.ResultSetHandler;
import org.apache.ibatis.plugin.Interceptor;
import org.apache.ibatis.plugin.Intercepts;
import org.apache.ibatis.plugin.Invocation;
import org.apache.ibatis.plugin.Signature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.sql.Statement;
import java.util.Collection;

/**
 * 对query操作进行拦截，对{@link EncryptField}字段进行解密处理；
 */
@Slf4j
@Intercepts({
        @Signature(type = ResultSetHandler.class, method = "handleResultSets", args = Statement.class)
})
@Component
public class DecryptInterceptor implements Interceptor {

    private static final String METHOD = "query";

    @Setter(onMethod_ = {@Autowired})
    private FieldEncryptUtil fieldEncryptUtil;

    @SuppressWarnings("rawtypes")
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        Object result = invocation.proceed();

        // 解密处理
        // 经过测试发现，无论是返回单个对象还是集合，result都是ArrayList类型
        if(ClassUtil.isAssignable(Collection.class, result.getClass())) {
            fieldEncryptUtil.decrypt((Collection) result);
        } else {
            fieldEncryptUtil.decrypt(result);
        }

        return result;
    }
}

加解密工具类

由于加密和解密绝大部分的逻辑是相似的，不同的地方在于

  • 加密需要通过反射处理的对象，是在SQL执行前，是Invocation对象的参数列表中下标为1的参数；而解决需要通过反射处理的对象，是在SQL执行后，对执行结果对象进行解密处理。
  • 一个是获取到字段值进行加密，一个是获取到字段值进行解密

于是把加解密逻辑抽象成一个工具类，把差异的部分做为参数传入

package com.wen3.demo.mybatisplus.encrypt.util;

import cn.hutool.core.util.ClassUtil;
import cn.hutool.core.util.ReflectUtil;
import com.wen3.demo.mybatisplus.encrypt.annotation.EncryptField;
import com.wen3.demo.mybatisplus.encrypt.service.FieldEncryptService;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.reflect.FieldUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.annotation.AnnotationUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.lang.reflect.Field;
import java.util.Collection;
import java.util.List;
import java.util.Objects;

/**
 * 加解密工具类
 */
@Slf4j
@Component
public class FieldEncryptUtil {

    @Setter(onMethod_ = {@Autowired})
    private FieldEncryptService fieldEncryptService;

    /**对EncryptField注解进行加密处理*/
    public void encrypt(Object obj) {
        if(ClassUtil.isPrimitiveWrapper(obj.getClass())) {
            return;
        }
        encryptOrDecrypt(obj, true);
    }

    /**对EncryptField注解进行解密处理*/
    public void decrypt(Object obj) {
        encryptOrDecrypt(obj, false);
    }

    /**对EncryptField注解进行解密处理*/
    public void decrypt(Collection list) {
        if(CollectionUtils.isEmpty(list)) {
            return;
        }
        list.forEach(this::decrypt);
    }

    /**对EncryptField注解进行加解密处理*/
    private void encryptOrDecrypt(Object obj, boolean encrypt) {
        // 根据update拦截规则，第0个参数一定是MappedStatement，第1个参数是需要进行判断的参数
        if(Objects.isNull(obj)) {
            return;
        }

        // 获取所有带加密注解的字段
        List<Field> encryptFields = null;
        // 判断类上面是否有加密注解
        EncryptField encryptField = AnnotationUtils.findAnnotation(obj.getClass(), EncryptField.class);
        if(Objects.nonNull(encryptField)) {
            // 如果类上有加密注解，则所有字段都需要加密
            encryptFields = FieldUtils.getAllFieldsList(obj.getClass());
        } else {
            encryptFields = FieldUtils.getFieldsListWithAnnotation(obj.getClass(), EncryptField.class);
        }

        // 没有字段需要加密，则跳过
        if(CollectionUtils.isEmpty(encryptFields)) {
            return;
        }

        encryptFields.forEach(f->{
            // 只支持String类型的加密
            if(!ClassUtil.isAssignable(String.class, f.getType())) {
                return;
            }

            String oldValue = (String) ReflectUtil.getFieldValue(obj, f);
            if(StringUtils.isBlank(oldValue)) {
                return;
            }

            String logText = null, newValue = null;
            if(encrypt) {
                logText = "encrypt";
                newValue = fieldEncryptService.encrypt(oldValue);
            } else {
                logText = "decrypt";
                newValue = fieldEncryptService.decrypt(oldValue);
            }

            log.info("{} success[{}=>{}]. before:{}, after:{}", logText, f.getDeclaringClass().getName(), f.getName(), oldValue, newValue);
            ReflectUtil.setFieldValue(obj, f, newValue);
        });
    }
}

加解密算法

Mybatis-Plus自带了一个AES加解密算法的工具，我们只需要提供一个加密key，然后就可以完成一个加解密的业务处理了。

  • 先定义一个加解密接口
package com.wen3.demo.mybatisplus.encrypt.service;

/**
 * 数据加解密接口
 */
public interface FieldEncryptService {

    /**对数据进行加密*/
    String encrypt(String value);

    /**对数据进行解密*/
    String decrypt(String value);

    /**判断数据是否忆加密*/
    default boolean isEncrypt(String value) {
        return false;
    }
}
  • 然后实现一个默认的加解密实现类
package com.wen3.demo.mybatisplus.encrypt.service.impl;

import cn.hutool.core.util.ClassUtil;
import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.AES;
import com.wen3.demo.mybatisplus.encrypt.service.FieldEncryptService;
import org.springframework.stereotype.Component;

import javax.crypto.IllegalBlockSizeException;

/**
 * 使用Mybatis-Plus自带的AES加解密
 */
@Component
public class DefaultFieldEncryptService implements FieldEncryptService {

    private static final String ENCRYPT_KEY = "abcdefghijklmnop";

    @Override
    public String encrypt(String value) {
        if(isEncrypt(value)) {
            return value;
        }
        return AES.encrypt(value, ENCRYPT_KEY);
    }

    @Override
    public String decrypt(String value) {
        return AES.decrypt(value, ENCRYPT_KEY);
    }

    @Override
    public boolean isEncrypt(String value) {
        // 判断是否已加密
        try {
            // 解密成功，说明已加密
            decrypt(value);
            return true;
        } catch (MybatisPlusException e) {
            if(ClassUtil.isAssignable(IllegalBlockSizeException.class, e.getCause().getClass())) {
                return false;
            }
            throw e;
        }
    }
}

自动加解密单元测试

package com.wen3.demo.mybatisplus.service;

import cn.hutool.core.util.RandomUtil;
import com.wen3.demo.mybatisplus.MybatisPlusSpringbootTestBase;
import com.wen3.demo.mybatisplus.encrypt.service.FieldEncryptService;
import com.wen3.demo.mybatisplus.po.UserPo;
import jakarta.annotation.Resource;
import org.apache.commons.lang3.RandomStringUtils;
import org.junit.jupiter.api.Test;

import java.util.Collections;
import java.util.List;
import java.util.Map;

class UserServiceTest extends MybatisPlusSpringbootTestBase {

    @Resource
    private UserService userService;
    @Resource
    private FieldEncryptService fieldEncryptService;

    @Test
    void save() {
        UserPo userPo = new UserPo();
        String originalValue = RandomStringUtils.randomAlphabetic(16);
        String encryptValue = fieldEncryptService.encrypt(originalValue);
        userPo.setUserEmail(originalValue);
        userPo.setUserName(RandomStringUtils.randomAlphabetic(16));
        boolean testResult = userService.save(userPo);
        assertTrue(testResult);
        assertNotEquals(originalValue, userPo.getUserEmail());
        assertEquals(encryptValue, userPo.getUserEmail());

        // 测试解密: 返回单个对象
        UserPo userPoQuery = userService.getById(userPo.getUserId());
        assertEquals(originalValue, userPoQuery.getUserEmail());
        // 测试解密: 返回List
        List<UserPo> userPoList = userService.listByEmail(encryptValue);
        assertEquals(originalValue, userPoList.get(0).getUserEmail());

        // 测试saveBatch方法也会被拦截加密
        userPo.setUserId(null);
        testResult = userService.save(Collections.singletonList(userPo));
        assertTrue(testResult);
        assertNotEquals(originalValue, userPo.getUserEmail());
        assertEquals(encryptValue, userPo.getUserEmail());
    }
}

单元测试运行截图

在这里插入图片描述

太空眼睛
关注
  • 8
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
在MyBatis-Plus中实现字段加密与解密
qq_38978882的博客
02-05 1598
在MyBatis-Plus中实现字段加密与解密
MybatisPlus实现AES加密解密，实现yml配置文件中数据库连接信息如用户名，密码等信息加密解密
最新发布
小哇
07-04 255
配置启动参数，将解密秘钥信息填入启动配置里面的Program arguments里面或java -jar方式时。
基于Mybatis-Plus拦截器实现MySQL数据加解密
tianmaxingkonger的专栏
06-01 8000
本文基于SpringBoot+MybatisPlus（3.5.X）+MySQL8架构，Dao层与DB中间使用MP的拦截器机制，对数据存取过程进行拦截，实现数据的加解密操作。实体类上使用自定义注解，来标记需要进行加解密// 必须使用@EncryptedTable注解// 使用@EncryptedColumn注解// 使用@EncryptedColumn注解通过MP自带API、Lambda、自定义mapper接口三种方式进行测试。
MyBatis-Plus 优雅实现数据加密存储
一碗清深的博客
02-22 2837
本文将基于Mybatis-Plus讲述如何在数据的源头存储层保障其安全。我们都知道一些核心私密字段，比如说密码，手机号等在数据库层存储就不能明文存储，必须加密存储保证即使数据库泄露了也不会轻易曝光数据。
基于MyBatis-Plus数据库存取字段加解密解法两种
叽叽叽叽叽叽叽叽叽叽叽叽叽叽叽叽
12-30 8758
基于框架中使用的MyBatis-Plus整理了两个方法，一种是MyBatis-Plus自带的TypeHandler，另一种是基于MyBatis的Intercept拦截器。方法一配置简单使用麻烦，方法二配置麻烦使用简单，自己斟酌使用即可。当然方法二适用只使用MyBatis + Springboot的架构。 MyBatis-Plus版本：3.4.0 一、基于MyBatis-Plus自定义类型处理器（TypeHandler）的方法 1、创建TypeHandler //AES 是工具方法类，按加密需求设置 publ
mybatisplus配置拦截器实现保存加密，输出解密，模糊查询
LuckyTHP
04-17 1561
（1）使用@TableField(typeHandler = TypeHandler.class)注解自带的字段类型处理器，写一个 handle 类继承 BaseTypeHandler。本身这个是用来处理字段类型转换的，如map转list之类的，这里也可以用作值加密。注：使用这种方式有个前提，需要在@TableName注解上加上，才能使查询生效，否则只是新增修改生效进行拦截。没看源码猜想应该是先查整个实体有没有，再逐个进行字段拦截处理优化效率。@Data。
mybatis-plus实现数据字段加解密
alan3258的专栏
04-13 1226
在需要加解密的实体类头部添加注解@EncryptedTable，同时在需要加解密的字段上添加@EncryptedField注解即可。
MyBatisPlus数据自动加解密存取和字段防篡改有效性校验码自动生成存储处理器
qq_37148232的博客
07-19 1395
5、SecretDecryptInterceptor，拦截ResultSetHandler.handleResultSets，解密带SecretField字段的entity属性。10、SeretSecurityAutoConfiguration，总配置类，用于开启是否向Spring注册启用加密码组件。SecretWrarpperEnhancer:低层次代码向高层次代码的entity对象设置一些加解密字段的扩展接口。7、SecretModel，标记该实体有需要加解密的字段。
MybatisPlus实现数据库加解密
t194978的博客
04-28 3699
为了保护用户隐私，我们需要对数据库用户关键数据，入库加密，取出来解密。为了我们系统自身的安全数据库连接用户名和密码都要加解密 1、数据库连接加解密 1.1、数据库连接配置 ####################...
mybatis-plus 数据字段进行加解密入库，且加密字段支持模糊搜索
从零开始的博客
09-09 2231
需求很简单： 就是将数据存储到数据库，并且将敏感数据字段进行加密处理保存（比如：身份证，手机号，银行卡 等等）需求也很变态：加密的数据要模糊搜素！！如果需求不需要模糊搜素，直接加密入库就完事了，直接看这篇文章mybatis-plus进行数据字段加密解密入库，就可以了！工具类import cn/**/*** iktry {Lexeme le;= null) {} /*** 部分分词} }/**/*** ik。
Java操作MyBatis-Plus通过自定义拦截器对mysql字段以注解形式实现自动加解密
weixin_43029331的博客
03-07 4967
Java操作MyBatis-Plus对mysql字段以注解形式实现自动加解密
实现 MyBatis-Plus 中的配置加密功能（使用 AES 算法）
jakelihua
07-31 2628
在项目开发过程中，为了增强数据安全性，我们常常需要对敏感信息进行加密处理。MyBatis-Plus 提供了方便的配置加密功能，使我们能够对配置文件中的敏感信息进行加密和解密操作。本文将详细介绍如何实现 MyBatis-Plus 中的配置加密功能，并给出相应的代码示例。
MyBatis-Plus数据安全保护(加密解密)
tongxin_tongmeng的博客
01-16 3700
项目创建、POM依赖、YML配置、SQL脚本、代码生成、加密算法、字段加密、加密测试、自定义算法
mybatis-plus数据库字段信息加解密
bailegebai的博客
10-19 4766
在之前的文章中我们实现了springboot整合mybits-plus，并且配置了多数据源。接下来我们来实现一下敏感数据的保存并查询。
Mybatis-plus数据库表字段加解密存储
weixin_45906061的博客
08-05 6322
项目开发过程中，经常遇到敏感信息加密存储，如身份证号、手机号等，常规操作为存、取数据时对字段值进行单独加、解密处理，不利于维护且扩展性差，今天我们通过继承mybatis-plus（mybatis同样适用）提供的BaseTypeHandler类来统一解决此类问题。一、导入依赖（基于springboot），加密算法使用hutool包提供的AES，自行导入其他加密包也可。...
字段加解密 crypt field
_
03-18 319
java加密
MyBatis-Plus实现自动加密解密
YW_Danny的博客
09-01 6019
MyBatis-Plus实现加密解密实现TypeHandler添加注解查询加密字段 通过使用MyBatis的typeHandler功能，对入参和出参进行处理，实现无缝加密解密（将明文加密后保存至数据库；从数据库读取时，自动将密文解密成明文） 实现TypeHandler @Slf4j public class UserTypeHandler extends BaseTypeHandler<Object> { /** * 非空字段加密 * @param preparedS
Mybatis拦截器安全加解密MySQL数据实战
superjava_的博客
01-08 4329
需求背景 公司为了通过一些金融安全指标（政策问题）和防止数据泄漏，需要对用户敏感数据进行加密，所以在公司项目中所有存储了用户信息的数据库都需要进行数据加密改造。包括Mysql、redis、mongodb、es、HBase等。 因为在项目中是使用springboot+mybatis方式连接数据库进行增删改查，并且项目是中途改造数据。所以为了不影响正常业务，打算这次改动尽量不侵入到业务代码，加上mybatis开放的各种拦截器接口，所以就以此进行改造数据。 本篇文章讲述如何在现有项目中尽量不侵入业务方式进行
mybatis-plus实现自定义复杂sql查询
06-28
### 回答1： Mybatis-Plus是Mybatis的一个增强工具，它可以优化我们的开发效率。在实际的项目开发中，我们通常需要编写复杂的SQL查询语句来满足业务需求。下面我将介绍如何在自定义的Mapper类中实现复杂的SQL查询操作。 Mybatis-Plus提供了很多基础的查询方法，比如新增、修改、删除、查询全部等，但是当我们遇到一些比较复杂的查询需求时，需要自己手动编写SQL语句。我们可以在自定义的Mapper接口中定义SQL查询方法，然后在XML文件中编写SQL语句，最后通过Mybatis-Plus的注解进行映射。 首先，在自定义的Mapper接口中定义一个查询方法，比如：selectUserList。在这个方法上使用注解@Select，用于映射XML文件中的SQL语句。在这个方法的参数中，我们可以传入一些查询条件用于过滤查询结果，比如用户姓名、年龄等信息。如果需要分页查询，我们可以传入Page对象，然后在XML文件中使用<if>标签判断是否需要拼装分页的SQL语句。 然后，在XML文件中编写SQL语句。针对不同的查询需求，我们可以使用各种关键字、函数、运算符等语法进行拼装。在使用变量的时候，需要使用#{XXX}形式的占位符来代替变量，同时也可以使用${XXX}形式的占位符来代替SQL关键字、表名等信息。 最后，在Mapper接口上使用@Mapper注解将这个接口进行映射，然后在Service层中调用这个接口中定义的查询方法即可。如果需要进行分页查询，我们需要手动创建一个Page对象，并设置分页信息，然后将这个对象传入到Mapper接口中即可。 总之，对于比较复杂的SQL查询操作，我们可以通过自定义Mapper接口、XML文件以及Mybatis-Plus注解的方式来实现。这样可以大大提升我们的查询效率和开发效率，减少我们的工作量和出错的概率。 ### 回答2： MyBatis-Plus 是一个 Mybatis 的增强工具，在持久层操作方面做了很多增强和优化，其中包括自定义复杂 SQL 查询。 实现自定义复杂 SQL 查询的步骤如下： 1. 在实体类中添加查询参数的字段，如下： ``` public class User { private Integer id; private String name; private Integer age; private String phone; // getter and setter ... } ``` 2. 在 mapper.xml 中编写自定义复杂 SQL 查询语句： ``` <select id="selectByCustomQuery" resultMap="BaseResultMap"> SELECT id,name,age,phone FROM user <where> <if test="name!=null"> and name like concat('%', #{name}, '%') </if> <if test="age!=null"> and age = #{age} </if> <if test="phone!=null"> and phone like concat('%', #{phone}, '%') </if> </where> </select> ``` 3. 在 mapper 接口中添加自定义查询的方法： ``` public interface UserMapper extends BaseMapper<User> { List<User> selectByCustomQuery(@Param("name") String name, @Param("age") Integer age, @Param("phone") String phone); } ``` 4. 在 service 层中调用自定义查询的方法： ``` @Service public class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; @Override public List<User> findByCustomQuery(String name, Integer age, String phone) { return userMapper.selectByCustomQuery(name, age, phone); } } ``` 最后，调用 findByCustomQuery 方法可以实现自定义复杂 SQL 查询。 以上是实现自定义复杂 SQL 查询的简单步骤，需要注意的是在 XML 中编写 SQL 语句时，需要加入防 SQL 注入的措施。 ### 回答3： MyBatis-Plus是一款基于MyBatis的增强工具包，它封装了很多MyBatis的常用操作，例如：分页查询、自动逆向工程、注解CRUD、性能分析等，其中自定义复杂SQL查询也得到了很好的支持。 MyBatis-Plus自定义复杂SQL语句的步骤如下： 1.定义Mapper接口 在Mapper接口中定义自定义查询方法，例如： ```java @Select("SELECT * FROM user WHERE age > #{age}") List<User> selectByAge(Integer age); ``` 2.使用MyBatis-Plus提供的BaseMapper 在Mapper接口中继承MyBatis-Plus提供的BaseMapper，并使用@Mapper注解标记接口。 ```java @Mapper public interface UserMapper extends BaseMapper<User> { @Select("SELECT * FROM user WHERE age > #{age}") List<User> selectByAge(Integer age); } ``` 3.使用XML方式实现自定义查询 如果自定义查询语句比较复杂，可以使用XML方式实现。在Mapper接口中定义方法，例如： ```java List<UserVO> selectUserVO(); ``` 在resources/mapper/UserMapper.xml中实现自定义sql语句，例如： ```xml <select id="selectUserVO" resultMap="userVOResultMap"> SELECT u.*, d.name AS deptName FROM user u LEFT JOIN department d ON u.dept_id = d.id </select> ``` 4.在Service层调用Mapper接口中的自定义方法 在Service层中注入Mapper，并调用Mapper接口中的自定义方法，例如： ```java @Service public class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; @Override public List<UserVO> selectUserVO() { return userMapper.selectUserVO(); } } ``` 以上就是使用MyBatis-Plus实现自定义复杂SQL查询的步骤，它可以很好地帮助我们提高数据查询的效率和灵活性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

太空眼睛

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值