MyBatis插件 - 通用mapper

1、简单认识通用mapper

1.1、了解mapper

作用：就是为了帮助我们自动的生成sql语句 [ ps：MyBatis需要编写xxxMapper.xml，而逆向工程是根据entity实体类来进行生成的，有时由于业务需要，会让实体类与数据库字段名不对应，所以逆向工程生成的xxxMapper.xml配置就会有问题。其实：通用Mapper和JPA很像 ]
通用mapper是MyBatis的一个插件，是pageHelper的同一个作者进行开发的
作者gitee地址：https://gitee.com/free
通用mapper官网地址：https://gitee.com/free/Mapper
通用mapper文档介绍地址：https://gitee.com/free/Mapper/wikis/Home

1.2、学习通用mapper需要的知识

Mybatis
Spring

2、玩通用mapper

2.1、准备工作

建测试表

CREATE TABLE `user` (
  `user_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `user_name` varchar(20) DEFAULT NULL COMMENT '用户名',
  `user_sex` varchar(2) DEFAULT NULL COMMENT '用户性别',
  `user_salary` decimal(5,2) DEFAULT NULL COMMENT '用户薪资',
  PRIMARY KEY (`user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表';


insert  into `user`(`user_id`,`user_name`,`user_sex`,`user_salary`) values 
(1,'紫邪情','女',100.00),
(2,'紫玲','女',50.00),
(3,'张三','男',999.99);

创建Spring项目并导入依赖

    
    
    
        
            org.springframework
            spring-context
            5.2.9.RELEASE
        
		
            org.springframework
            spring-aspects
            5.1.9.RELEASE
        

        
        
            org.mybatis
            mybatis
            3.4.6
        

        
        
            org.mybatis
            mybatis-spring
            2.0.2
        

        
        
            mysql
            mysql-connector-java
            5.1.47
        

        
            com.alibaba
            druid
            1.2.6
        

        
            org.springframework
            spring-jdbc
            5.2.9.RELEASE
        

        
            org.projectlombok
            lombok
            1.18.22
        

        
            junit
            junit
            4.12
            test
        

        
            log4j
            log4j
            1.2.17
        

        
        
            tk.mybatis
            mapper
            3.4.2

编写SSM框架整合的xml文件


<?xml version="1.0" encoding="UTF-8"?>

注意点：在扫描mapper层时，使用通用mapper覆盖mybatis，写法不太一样

我的项目结构如下

建对应的实体类

注意点：数据类型用包装类，因为包装类可以判断null值，这个涉及到通用mapper的原理，数据类型用包装类在MaBatis中就已经知道的事情

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
public class UserEntity implements Serializable {

    private Integer userId;
    private String userName;
    private String userSex;
    private Double userSalary;
}

2.2、玩通用mapper的基础API

先看一下通用mapper大概有哪些API

// 这里接口直接继承通用mapper接口即可
//    注意：泛型中的信息就是实体类
public interface UserMapper extends Mapper {		// 看源码，点mapper即可进入

}

看看BaseMapper

其他的都是差不多的套路，归纳起来其实就是增删查改的封装，然后做了不同的细分，需要继续查看的，那就往后挨个去点击

2.2.1、和select相关

2.2.1、selectOne方法和 @Table注解及@Column注解

编写测试类并启动

package cn.zixieqing;


import cn.zixieqing.entity.*;
import cn.zixieqing.mapper.*;
import org.junit.*;
import org.springframework.context.*;
import org.springframework.context.support.*;


public class MyTest {

    @Test
    public void selectOneTest() {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = context.getBean("userMapper", UserMapper.class);

        UserEntity userEntity = new UserEntity();
        userEntity.setUserId(1)
                .setUserName("紫邪情")
                .setUserSex("女")
                .setUserSalary(new Double(100));
        System.out.println(userMapper.selectOne(userEntity));
    }
}

出现报错：Table 'mapper_study.user_entity' doesn't exist

原因就是编写的实体类名叫做UserEntity，而数据库的表名叫做user，解决方式就是在实体类中加入@Table注释，注意此注解是import javax.persistence.*;包下的

另外的selectxxx方法直接一点就出来了，基本上都是见名知意，就算不知道的源码中也有解释，通用mapper就是国内人写的

至于@Column注解就是见名知意，用来处理实体类的字段和数据库中的字段不一致的问题
- 默认规则：
  - 实体类字段：驼峰式命名
  - 数据库表字段：使用“_”区分各个单词

2.2.2、观察日志总结selectOne方法

selectOne()是将封装的实体类作为了WHERE子句的条件
- 这里是使用了非空的值作为的WHERE子句

在条件表达式中使用“=”进行比较
注意点：要求必须返回一个实体类结果，如果有多个，则会抛出异常

2.2.3、xxxByPrimaryKey方法和 @Id注解

测试

    @Test
    public void selectByPrimaryKey() {
        System.out.println(userMapper.selectByPrimaryKey(3));
    }

结果：发现将实体类的所有字段属性都作为WHERE子句的条件了
解决办法：给实体类中对应的数据库表的主键字段加上@Id注解

2.2.4、xxxByPrimaryKey方法和 @Id注解总结

@Id注解

为了将实体类字段属性和对应的数据库表主键做匹配
原因：通用mapper在执行xxxByPrimaryKey方法时会出现两种情况：
- 1、没有加@Id注解时，通用mapper会将实体类的所有属性作为联合主键来匹配数据库表的主键，故而会出现将实体类中的字段属性全部作为WHERE子句后面的条件字段
  - ```
  SELECT user_id,user_name,user_sex,user_salary 
  FROM user 
  WHERE user_id = ? AND user_name = ? AND user_sex = ? AND user_salary = ?
```
- 2、使用@Id主键将实体类中的字段属性和数据库表中的主键做明确匹配

xxxByPrimaryKey方法

需要使用@Id注解来让实体类中的字段属性和数据库表中的主键做明确匹配，否则：通用mapper默认将实体类的所有字段属性作为联合主键来进行匹配

2.2.5、select方法

传什么，就用什么来拼接WHERE子句的条件

测试

    @Test
    public void select() {
        UserEntity userEntity = new UserEntity();
        userEntity.setUserName("紫邪情");
        System.out.println(userMapper.select(userEntity));
    }

2.2.6、xxxSelective方法

可选择的嘛
非主键字段，如果不为null，则就加入sql语句
注意：是非null啊，所以前面才说实体类的类型最好用包装类

2.2.2、和insert相关

2.2.2.1、insert方法

测试

    @Test
    public void insertTest() {

        UserEntity userEntity = new UserEntity();
        userEntity.setUserId(4)
                .setUserName("不知火舞");

        // 这个API会将null也拼接到SQL语句中
        System.out.println(userMapper.insert(userEntity));
    }

2.2.2.2、insertSelective方法

    @Test
    public void insertSelective() {
        UserEntity userEntity = new UserEntity();
        userEntity.setUserName("百里守约")
                .setSex("老六");

        // 这个API会将非null的字段拼接sql语句中
        userMapper.insertSelective(userEntity);
    }

2.2.2.3、@GeneratedValue注解

这个注解是为了让通用mapper在执行insert语句之后，把数据库中自动生成的主键值回填到实体类对象中
官网文档介绍：https://gitee.com/free/Mapper/wikis/2.orm/2.3-generatedvalue

2.2.3、和update相关

2.2.3.1、updateByPrimaryKeySelective方法

这个其实看一眼就知道了，也就是：根据主键把不为null值的字段修改掉，即：set后面的字段就是实体类中不为null的字段

    @Test
    public void updateByPrimaryKeySelectiveTest() {

        System.out.println( userMapper.updateByPrimaryKeySelective( new UserEntity().setUserId(1).setUserName("小紫") ) );
    }

2.2.4、和delete相关

2.2.4.1、delete方法

切记：使用时，记得把实体类值传进去，否则：若是null的实体类，则：SQL语句就没有WHERE条件了，继而：变成全表的逻辑删除了
原理：还是一样的，使用非null的字段作为WHERE子句条件

2.2.4.2、deleteByPrimaryKey方法

见名知意，直接通过主键来删

    @Test
    public void deleteByPrimaryKeyTest() {
        userMapper.deleteByPrimaryKey(2);
    }

2.2.5、@Transient注解

一般情况下，实体中的字段和数据库表中的字段是一一对应的，但是也有很多情况我们会在实体中增加一些额外的属性，这种情况下，就需要使用 @Transient 注解来告诉通用 Mapper 这不是表中的字段

@Transient
private String otherThings; //非数据库表中字段

2.3、QBC查询

QBC全称：query by criteria 也就是通过规则( criteria )来查询

2.3.1、Criteria对象

public class ExampleTest {

    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserMapper userMapper = context.getBean("userMapper", UserMapper.class);

    // 1、创建Example对象
    Example example = new Example(UserEntity.class);


    @Test
    public void exampleTest() {

        // 2、使用Example创建Criteria对象
        Example.Criteria criteria = example.createCriteria();

        // 3、添加规则 下面这些都是Criteria能够调的API，还有其他的，需要时再说
        /*
            andGreaterThan 即：>               andGreaterThanOrEqualTo 即：>=
            andLessThan 即：<                  andLessThanOrEqualTo 即：<=
            andIn 即：就是SQL的in               andNotIn  就是SQL的not in
            andBetween  即：SQL的between       andNotBetween 即SQL中的not between
            andLike 即sql中的like              andNotLike  即SQL的not like
            要看这些比较符，直接点andGreaterThan看源码，里面都有各种介绍 
        */
        criteria.andGreaterThan("userSalary", 50).andLessThan("userSalary", 200);

        // 4、调用Example封装的API 不止selectByExample这一个，还有其他的CRUD
        List userEntities = userMapper.selectByExample(example);

        for (UserEntity userEntity : userEntities) {
            System.out.println(userEntity);
        }
    }
}

2.3.2、Example对象能调用的API

2.3.2.1、CreateCriteria()

    @Test
    public void createCriteriaTest() {

        // createCriteria创建规则 - 有一个别扭的注意点
        Example.Criteria criteria01 = example.createCriteria();
        Example.Criteria criteria02 = example.createCriteria();
        // 使用Example调用or()时，传入的这个Criteria对象的参数有点别扭
        // 添加规则1
        criteria01.andGreaterThan("userId", 1).andLessThan("userId", 6);
        // 添加规则2
        criteria02.andGreaterThan("userSalary", 100).andLessThan("userSalary", 500);
        /*
        * 拼接的SQL语句：
        *   SELECT user_id,user_name,user_sex,user_salary
        *   FROM user
        *   WHERE ( user_id > ? and user_id < ? ) or ( user_salary > ? and user_salary < ? )
        * */
        // 别扭之处就在这里：是将规则2 criteria02 使用or拼接起来，理论上应该是criteria01.or(criteria02)
        // 但是：却是使用example来调的or( Criteria criteria )，所以感觉example就相当于是criteria01一样，有点别扭
        example.or(criteria02);
        List userEntities = userMapper.selectByExample(example);
        userEntities.forEach(System.out::println);
    }

2.3.2.2、orderBy( String property )排序

    @Test
    public void orderByTest() {

        // userSalary 排序字段      desc 排序方式 - 降序desc 升序asc
        example.orderBy("userSalary").desc();

        userMapper.selectByExample(example).forEach(System.out::println);
    }

2.3.2.3、setDistinct( boolean isDistinct )去重

    @Test
    public void setDistinctTest() {
        example.setDistinct(true);
        userMapper.selectByExample(example).forEach(System.out::println);
    }

2.3.2.4、selectProperties( String... properties )设置select后的字段

    // 设置拼接SQL的select后面的字段
    @Test
    public void selectPropertiesTest() {
        // 拼接的SQL语句： SELECT user_id , user_name FROM user
        // 默认是* 即：实体类的所有字段都拼接上去了
        example.selectProperties("userId","userName");

        userMapper.selectByExample(example).forEach(System.out::println);
    }

2.3.2.5、excludeProperties(String... properties)设置select后不包含的字段

    // 设置select后不包含的字段
    @Test
    public void excludePropertiesTest() {

        // SQL语句 SELECT user_name , user_sex FROM user 
        example.excludeProperties("userId", "userSalary");

        userMapper.selectByExample(example).forEach(System.out::println);
    }

其他的API直接用example点就出来了，都是见名知意的

2.4、通用mapper逆向工程

2.4.1、pom.xml配置

    
    
        
            tk.mybatis
            mapper
            4.0.0-beta3
        

        
        
            org.mybatis
            mybatis
            3.5.7
        
    

    
        
            
                maven-compiler-plugin
                
                    1.8
                    1.8
                
            
            
                org.mybatis.generator
                mybatis-generator-maven-plugin
                1.3.6
                
                    
                    
                        ${basedir}/generatorConfig.xml
                    
                    true
                    true
                
                
                
                    
                        mysql
                        mysql-connector-java
                        5.1.47
                    
                    
                        tk.mybatis
                        mapper
                        4.0.0-beta3

若是出现上述报RowBounds不存在的原因在下面这里

2.4.2、generatorConfig.xml配置

引入的外部文件db.properties的配置

# 数据库配置
jdbc.driver=com.mysql.jdbc.Driver

# 注意：建议使用db.properties配置从而在generatorConfig.xml中引入的原因就在这里
# 在这里可以在这个url后面拼接参数，如：useSSL=false
# 若是直接把这些配置写到generatorConfig.xml中，那么后面的参数配置就有几个奇葩的地方
# 			1、参数之间不是通过&隔开，而是需要使用;分号隔开  如：useSSL=false;useUnicode=true
#			2、false / true等值需要使用``括起来，具体可以尝试，然后看报的ERROR
jdbc.url=jdbc:mysql://localhost:3306/mapper_study?useSSL=false&useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

#c3p0
jdbc.maxPoolSize=50
jdbc.minPoolSize=10
jdbc.maxStatements=100
jdbc.testConnection=true

# 通用Mapper配置 若是在generatorConfig.xml的plugin配置中是通过引入的方式来做的，那么就可以在这里配置这两个信息
# 从而方便管理
# mapper.plugin=tk.mybatis.mapper.generator.MapperPlugin
# mapper.Mapper=tk.mybatis.mapper.common.Mapper

2.4.3、启动

在 pom.xml 这一级目录的命令行窗口执行 mvn mybatis-generator:generate即可

2.5、自定义mapper

自定义mapper接口的作用：根据实际需要自行重组mapper接口【 ps：即并不是通用mapper中的所有接口和方法都需要】

2.5.1、玩一下自定义mapper接口

1、自定义自己要的mapper接口

package cn.zixieqing.common;


import tk.mybatis.mapper.common.*;


public interface CustomMapper extends BaseMapper {
    // 这个自定义的mapper，想继承前面画的通用mapper中的哪个接口都可以
}

2、编写业务mapper

package cn.zixieqing.mapper;

import cn.zixieqing.common.*;
import cn.zixieqing.entity.*;


public interface UserMapper extends CustomMapper {
}

注意点：别把自定义mapper和业务mapper放到一个包中，会报错

3、修改applicationContext.xml文件的MapperScannerConfigurer配置

    
    
        
        
        
            
                
                mapper=cn.zixieqing.common.CustomMapper

4、测试

    @Test
    public void customMapperTest() {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapper = context.getBean("userMapper",UserMapper.class);

        userMapper.selectAll().forEach(System.out::println);

    }

补充1、要是不想写applicationContext.xml中MapperScannerConfigurer的那个配置

那把内容注释掉，在自定义mapper接口的地方加个注解@RegisterMapper就搞定了

补充2、如果将自定义mapper接口和业务mapper接口放到一个包中了

一运行就会报错

tk.mybatis.mapper.MapperException: java.lang.ClassCastException: sun.reflect.generics.reflectiveObjects.TypeVariableImpl cannot be cast to java.lang.Class

原因就是利用反射，获取类对象时失败，即：原因如下

2.6、了解通用mapper的二级缓存

一二级缓存的概念哪些就跳过了，MyBatis中已经见过了，这里玩通用mapper的配置
测试：自行编写一个业务mapper，然后去继承mapper，从而多次执行，会发现SQL执行了多次

注意：需要让mapper中的实体类T实现Serializable接口，从而让其拥用序列号，否则：会报错的

修改mybatis-config.xml文件

在业务mapper接口中添加@CacheNamespace注解

@CacheNamespace
public interface UserMapper extends Mapper {
}

再次测试

2.7、类型处理器 typeHandler

这里说的类型是简单类型和复杂类型，注意：和Java中说的基本类型和引用类型不是一回事，不是说基本类型就一定是简单类型，这里不用去考虑基本和引用的问题
简单类型和复杂类型可以参考一对一和一对多这两种
简单类型：只有一个值
复杂类型：有多个值

而上面这种，对于userName来说，是无法进行CRUD的

这种情况就是复杂类型，而通用mapper默认是没处理的，就有点类似于在上述例子的userName上加了一个@Transient注解，从而忽略了该字段，从而造成的效果就是：去数据库中找对应的字段值时没找到，从数据库中找到数据，然后返还给对象时没有相应的对象可以接受

解决办法：自定义类型处理器

具体操作流程如下：

1、创建一个类型处理器的类，然后实现TypeHandler接口，其中：T就是要处理的那个类型，如：上述例子的NameEntity

2、实现里面的四个方法

    @Override
    public void setParameter(PreparedStatement preparedStatement, int i, NameEntity nameEntity, JdbcType jdbcType) throws SQLException {

    }

    @Override
    public NameEntity getResult(ResultSet resultSet, String s) throws SQLException {
        return null;
    }

    @Override
    public NameEntity getResult(ResultSet resultSet, int i) throws SQLException {
        return null;
    }

    @Override
    public NameEntity getResult(CallableStatement callableStatement, int i) throws SQLException {
        return null;
    }

实例逻辑编写如下

public class NameHandler implements TypeHandler {

    /**
     * 这个方法就是：对象NameEntity ——> 数据库的流程规则，可以将其理解为序列化流程 但是完全不一样啊
     * 只是说：像序列化一样把数据转成一个样
     * @param ps
     * @param i
     * @param nameEntity
     * @param jdbcType
     * @throws SQLException
     */
    @Override
    public void setParameter(PreparedStatement ps, int i, NameEntity nameEntity, JdbcType jdbcType) throws SQLException {

        // 1、验证NameEntity
        if ( null == nameEntity) {
            return;
        }

        // 2、取出nameEntity中的值
        String firstName = nameEntity.getFirstName();
        String lastName = nameEntity.getLastName();

        // 3、把取出的值 拼接成 一个字符串
        // 自定义规则：使用 - 进行隔开
        StringBuilder builder = new StringBuilder();
        builder.append(firstName)
                .append("-")
                .append(lastName);

        // 4、拼接SQL的参数
        ps.setString(i,builder.toString() );
    }

    /**
     * 这下面三个是重载，是为了解决：数据库 ——> 对象NameEntity的流程，类似于反序列化，把另一个东西转成正常需要的样子
     * @param resultSet
     * @param columnName
     * @return
     * @throws SQLException
     */
    @Override
    public NameEntity getResult(ResultSet resultSet, String columnName ) throws SQLException {
        // 1、从结果集ResultSet根据字段名取出字段值
        String columnValue = resultSet.getString(columnName);

        // 2、验证columnValue
        if ( null == columnValue || columnValue.length() == 0 || !columnValue.contains("-") ) {
            return null;
        }

        // 3、根据“-”对columnValue进行拆分
        String[] column = columnValue.split("-");

        // 4、把拆分之后的值 给到 对象的对应值
        return new NameEntity().setFirstName( column[0] ).setLastName( column[1] );
    }

    @Override
    public NameEntity getResult(ResultSet resultSet, int i) throws SQLException {

        // 1、从结果集ResultSet根据字段名取出字段值
        String columnValue = resultSet.getString(i);

        // 2、验证columnValue
        if ( null == columnValue || columnValue.length() == 0 || !columnValue.contains("-") ) {
            return null;
        }

        // 3、根据“-”对columnValue进行拆分
        String[] column = columnValue.split("-");

        // 4、把拆分之后的值 给到 对象的对应值
        return new NameEntity().setFirstName( column[0] ).setLastName( column[1] );
    }

    @Override
    public NameEntity getResult(CallableStatement cs, int i) throws SQLException {


        // 1、从CallableStatement 根据 索引取出字段值
        String columnValue = cs.getString(i);

        // 2、验证columnValue
        if ( null == columnValue || columnValue.length() == 0 || !columnValue.contains("-") ) {
            return null;
        }

        // 3、根据“-”对columnValue进行拆分
        String[] column = columnValue.split("-");

        // 4、把拆分之后的值 给到 对象的对应值
        return new NameEntity().setFirstName( column[0] ).setLastName( column[1] );
    }
}

3、注册类型处理器

第一种( 字段级别 )：使用@ColumnType(typeHandler = xxxx.class)注解
- 注意啊：我这里是改数据库了的，这是做的查询嘛，要是数据库中的数据没符合规范，那还是查不到
第二种( 全局配置）：在mybatis-config.xml中进行配置

<?xml version="1.0" encoding="UTF-8" ?>

给用到该类型的地方添加@Column注解

@Data
@AllArgsConstructor
@NoArgsConstructor
@Accessors(chain = true)
@Table(name = "user")
@ToString
public class UserEntity implements Serializable {

    private static final long serialVersionUID = -5580827379143778431L;

    private Integer userId;

    /**
     * @Transient
     *
     * @ColumnType(typeHandler = NameHandler.class)
     */
    @Column
    private NameEntity userName;

    private String userSex;

    private Double userSalary;
}

3、最后，附上markdown地址

https://www.aliyundrive.com/s/yEMddoGw1KJ

mybatis

MyBatis插件 - 通用mapper

1、简单认识通用mapper

1.1、了解mapper

1.2、学习通用mapper需要的知识

2、玩通用mapper

2.1、准备工作

2.2、玩通用mapper的基础API

2.2.1、和select相关

2.2.1、selectOne方法 和 @Table注解 及@Column注解

2.2.2、观察日志总结selectOne方法

2.2.3、xxxByPrimaryKey方法 和 @Id注解

2.2.4、xxxByPrimaryKey方法 和 @Id注解总结

2.2.5、select方法

2.2.6、xxxSelective方法

2.2.2、和insert相关

2.2.2.1、insert方法

2.2.2.2、insertSelective方法

2.2.2.3、@GeneratedValue注解

2.2.3、和update相关

2.2.3.1、updateByPrimaryKeySelective方法

2.2.4、和delete相关

2.2.4.1、delete方法

2.2.4.2、deleteByPrimaryKey方法

2.2.5、@Transient注解

2.3、QBC查询

2.3.1、Criteria对象

2.3.2、Example对象能调用的API

2.3.2.1、CreateCriteria()

2.3.2.2、orderBy( String property )排序

2.3.2.3、setDistinct( boolean isDistinct )去重

2.3.2.4、selectProperties( String... properties )设置select后的字段

2.3.2.5、excludeProperties(String... properties)设置select后不包含的字段

2.4、通用mapper逆向工程

2.4.1、pom.xml配置

2.4.2、generatorConfig.xml配置

2.4.3、启动

2.5、自定义mapper

2.5.1、玩一下自定义mapper接口

2.6、了解通用mapper的二级缓存

2.7、类型处理器 typeHandler

3、最后，附上markdown地址

相关

2.2.1、selectOne方法和 @Table注解及@Column注解

2.2.3、xxxByPrimaryKey方法和 @Id注解

2.2.4、xxxByPrimaryKey方法和 @Id注解总结