一、MybatisPlus简介

1.1.简介

Mybatis-Plus（简称MP）是一个 Mybatis 的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。

1.2.文档地址

1.3.MybatisPlus的特性

无侵入：Mybatis-Plus 在 Mybatis 的基础上进行扩展，只做增强不做改变，引入 Mybatis-Plus 不会对您现有的 Mybatis 构架产生任何影响，而且 MP 支持所有 Mybatis 原生的特性
依赖少：仅仅依赖 Mybatis 以及 Mybatis-Spring
损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
预防Sql注入：内置 Sql 注入剥离器，有效预防Sql注入攻击
通用CRUD操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
多种主键策略：支持多达4种主键策略（内含分布式唯一ID生成器），可自由配置，完美解决主键问题
支持热加载：Mapper 对应的 XML 支持热加载，对于简单的 CRUD 操作，甚至可以无 XML 启动
支持ActiveRecord：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可实现基本 CRUD 操作
支持代码生成：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用（P.S. 比 Mybatis 官方的 Generator 更加强大！）
支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
支持关键词自动转义：支持数据库关键词（order、key……）自动转义，还可自定义关键词
内置分页插件：基于 Mybatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通List查询
内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能有效解决慢查询
内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，预防误操作

二、集成MybatisPlus

2.1.Maven导入MybatisPlus依赖

<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>3.0-gamma</version>
</dependency>

2.2.修改sqpsessionFactoryBean

<!--  配置SqlSessionFactoryBean 
  Mybatis提供的: org.mybatis.spring.SqlSessionFactoryBean
  MP提供的:com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean
  -->
<!-- 配置sqlsessionFactoryBean -->
<bean id="sqlSessionFactoryBean" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
    <!-- 数据源 -->
    <property name="dataSource" ref="dataSource"></property>
    <property name="configLocation" value="classpath:mybatis-config.xml"></property> 
    <!-- 别名处理 -->
    <property name="typeAliasesPackage" value="com.luo.beans"></property>
</bean>

三、入门的Hello World

3.1.准备数据表

DROP TABLE IF EXISTS `tbl_user`;
CREATE TABLE `tbl_user` (
  `email` varchar(50) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `gender` char(255) DEFAULT NULL,
  `user_name` varchar(255) DEFAULT NULL,
  `id` int(11) NOT NULL AUTO_INCREMENT,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

INSERT INTO `tbl_user` VALUES ('243518985@qq.com', 24, '1', '罗康元 ', 1);
INSERT INTO `tbl_user` VALUES ('1835856@qq.com', 34, '2', '张三', 2);
INSERT INTO `tbl_user` VALUES ('323134435@163.com', 53, '1', '李四', 3);
INSERT INTO `tbl_user` VALUES ('345464566@qq.com', 43, '1', '王五', 4);
INSERT INTO `tbl_user` VALUES ('luokangyuansb@gmail.com', 45, '1', '赵六', 5);

3.2.准备Java实体类

public class User {
	
	private Integer id;
	
	private String userName;
	
	private String email;
	
	private Integer gender;
	
	private Integer age;
}

3.3.加入依赖的jar包

<dependencies>
    <!-- mp依赖:mybatisPlus 会自动的维护Mybatis 以及MyBatis-spring相关的依赖-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus</artifactId>
        <version>2.3</version>
    </dependency>
    <!--junit -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.9</version>
    </dependency>
    <!-- log4j -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
    <!-- c3p0 -->
    <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>0.9.5.2</version>
    </dependency>
    <!-- mysql -->
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.11</version>
    </dependency>
    <!-- spring -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.10.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>4.3.10.RELEASE</version>
    </dependency>
</dependencies>

3.5.mybatis-config.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

</configuration>

3.6.log4j.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
 
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
 
 <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
   <param name="Encoding" value="UTF-8" />
   <layout class="org.apache.log4j.PatternLayout">
    <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n" />
   </layout>
 </appender>
 <logger name="java.sql">
   <level value="debug" />
 </logger>
 <logger name="org.apache.ibatis">
   <level value="info" />
 </logger>
 <root>
   <level value="debug" />
   <appender-ref ref="STDOUT" />
 </root>
</log4j:configuration>

3.7.db.properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Hongkong
jdbc.username=root
jdbc.password=jiamei@20141107.

3.8.applicationContext.xml文件

<!-- 数据源 -->
<context:property-placeholder location="classpath:db.properties" />
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="${jdbc.driver}"></property>
    <property name="jdbcUrl" value="${jdbc.url}"></property>
    <property name="user" value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>
</bean>
<!--事务管理器  -->
<bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!--基于注解的事务管理  -->
<tx:annotation-driven transaction-manager="dataSourceTransactionManager" />
<!--  配置SqlSessionFactoryBean 
  Mybatis提供的: org.mybatis.spring.SqlSessionFactoryBean
  MP提供的:com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean
  -->
<!-- 配置sqlsessionFactoryBean -->
<bean id="sqlSessionFactoryBean" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
    <!-- 数据源 -->
    <property name="dataSource" ref="dataSource"></property>
    <property name="configLocation" value="classpath:mybatis-config.xml"></property> 
    <!-- 别名处理 -->
    <property name="typeAliasesPackage" value="com.luo.beans"></property>
</bean>
<!--  配置mybatis扫描的mapper接口路径-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
    <property name="basePackage" value="com.luo.mapper"></property>
</bean>

3.9.通用的CRUD操作

假设我们有一张user表，我们需要对这个表进行增删改查操作，如果说没有代码生成的话，在mybatis我们需要编写UserMapper接口，手写CRUD方法，在UserMapper.xml文件中写对应的sql语句，但是，在MybatisPlus中，我们只需要创建UserMapper接口，继承BaseMapper接口，就可以完成CRUD操作，甚至不需要创建SQl映射文件。

1
2
3

public interface UserMapper extends BaseMapper<User>{

}

然后，我们就写一些基本的单元测试方法，测试我们的CRUD，来到我们的测试类中，如下：

public class TestMp {

    private ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");

    private UserMapper userMapper = ioc.getBean("userMapper",UserMapper.class);
}

说明：在测试类中我们将使用从SpringIOC容器中获取的userMapper进行CRUD一系列操作

保存一条数据userMapper.insert(user);

@Test
public void insert(){
    User user = new User();
    user.setUserName("luokangyuan");
    user.setAge(66);
    user.setEmail("2356775645@qq.com");
    user.setGender(2);
    Integer result = userMapper.insert(user);
    System.out.println(result);
    // 直接获取插入数据返回的自增主键值
    System.out.println(user.getId()+"======");
}

插入数据的方法有两个：insert和insertAllColumn，二者的执行结果是一样的，区别在于，前者会根据实体类的每一个属性值进行一个非空校验，在插入的sql语句中不会出现实体类属性为空的字段；

注意：在没有使用全局配置之前，我们需要指定实体类对应的数据库表和主键生成策略

主键生成策略：@TableId(type = IdType.AUTO,value = "id"),value属性值当实体类字段名和数据库一致时可以不写，这里的value指的是数据库字段名称，type的类型有以下几种：
- IdType.AUTO：数据库ID自增
- IdType.INPUT：用户输入ID
- IdType.ID_WORKER：全局唯一ID，内容为空自动填充（默认配置）
- IdType.UUID：全局唯一ID，内容为空自动填充
实体对应表名注解：@TableName(value = "tbl_user");指定当前实体类对应的数据库表
数据库字段映射名称：@TableField(value = "user_name"),当禁止驼峰映射规则后可以使用
忽略插入到表的字段：@ableField(exist = false),如下，数据库没有money这个字段，如果不忽略，那么插入就会报错，找不到这个字段；

1 2	@TableField(exist = false) private Double money;

更新一条数据

@Test
public void update(){
    User user = new User();
    user.setId(7);
    user.setUserName("王八");
    user.setAge(56);
    //user.setEmail("2356775645@qq.com");
    user.setGender(2);
    Integer result = userMapper.updateById(user);
}

同理：更新方法也有两个updateById和updateAllColumnById,前者会对实体类属性名进行非空校验，为空的就不会出现在sql语句中，也就是不会更新原有数据，后者是会更新所有列，如果实体类属性值为空，则数据库对应字段名更新为null；

查询一条数据

@Test
public void select(){
    // 1.通过ID查询一条数据
    User user = userMapper.selectById(7);
    // 2.通过多个列进行查询,如果查处的数据有多条就会报错
    User u = new User();
    u.setId(2);
    u.setUserName("张三");
    User user1 = userMapper.selectOne(u);
    // 3.查询符合多个ID的数据,使用的是in关键字查询
    List<Integer> ids = new ArrayList<Integer>();
    ids.add(3);
    ids.add(4);
    ids.add(5);
    List<User> users = userMapper.selectBatchIds(ids);
    // 4.通过封装map条件,注意的是封装的是列字段名，不是实体里属性名，
    // map中的key充当sql中的条件名称
    Map<String,Object> maps = new HashMap<String, Object>();
    maps.put("user_name","张三");
    maps.put("age",347);
    List<User> users1 = userMapper.selectByMap(maps);
    // 5.分页查询方法,查看第二页，每页2条数据,在sql语句并没有limit关键字
    // 所以要实现物理分页，还需借助插件，例如mybatis的pageHepler或者MybatisPlus提供的分页插件
    List<User> users2 = userMapper.selectPage(new Page<User>(2, 2), null);
}

删除一条数据

@Test
public void delete(){
    // 1.根据ID删除
    Integer integer = userMapper.deleteById(8);
    // 2.根据条件删除，map中的key为列名，千万注意
    Map<String ,Object> maps = new HashMap<String, Object>();
    maps.put("age",66);
    maps.put("gender",2);
    Integer integer1 = userMapper.deleteByMap(maps);
    // 3.根据ID批量删除,使用in关键字
    List<Integer> ids = new ArrayList<Integer>();
    ids.add(5);
    ids.add(7);
    Integer integer2 = userMapper.deleteBatchIds(ids);
}

3.10.MybatisPlus全局配置

在前面的CRUD操作中，我们会使用直接注解指定主键生成策略和表名到实体类的映射，但是配置的仅仅会对当前实体类起作用，所以，引入了全局配置，如下：

<!-- 定义MybatisPlus的全局策略配置-->
<bean id ="globalConfiguration" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">
    <!--映射数据库下划线字段名到数据库实体类的驼峰命名的映射-->
    <property name="dbColumnUnderline" value="true"></property>
    <!-- 全局的主键策略 -->
    <property name="idType" value="0"></property>
    <!-- 全局的表前缀策略配置 -->
    <property name="tablePrefix" value="tbl_"></property>
</bean>

然后，将MybatisPlus全局配置注入到sqlSessionFactoryBean中

1 2	<!-- 注入全局MP策略配置 --> <property name="globalConfig" ref="globalConfiguration"></property>

3.11.mybatisPlusCRUD总结

在前面，我们实现了基本的CRUD操作，操作简单，仅仅只需继承一个BaseMapper就可以完成，实现单一，批量，分页等等一系列操作，很大的减少了开发负担，但这仅仅是Mybatisplus的冰山一角，当我们需要多条件查询的时候，就会使用到MybatisPlus中强大的条件构造器EntityWrapper；

四、条件查询

条件构造器就是EntityWrapper，就是一个封装查询条件对象，让开发者自由的定义查询条件，主要用于sql的拼接，排序或者实体参数等；条件构造器

注意：使用的参数是数据库字段名称，不是Java类属性名

4.1.selectPage中的条件查询

@Test
public void entityWrapperTedst(){
    // 分页查询第一页，每页2条记录，年龄在41-53之间，genger为1，user_name为王五的用户
    List<User> users = userMapper.selectPage(new Page<User>(1, 2),
         new EntityWrapper<User>()
         .between("age", 41, 53)
         .eq("gender",1)
         .eq("user_name","王五")
	);

}

4.2.模糊查询和或查询

@Test
public void selectListTest(){
    List<User> users = userMapper.selectList(new EntityWrapper<User>()
          .eq("gender", 1)
          .like("user_name", "三")
          .orNew()
          .like("email", "5")
    );
}

使用或条件查询可以使用or()也可以使用orNew(),二者的区别在于sql中的条件部分不一样，如下：

使用or()的sql语句

1	SELECT id AS id,user_name AS userName,email,gender,age FROM tbl_user WHERE (gender = ? AND user_name LIKE ? OR email LIKE ?)

使用orNew()的sql语句

1	SELECT id AS id,user_name AS userName,email,gender,age FROM tbl_user WHERE (gender = ? AND user_name LIKE ?) OR (email LIKE ?)

4.3.修改满足条件的数据

@Test
public void updataByEntityWrapper(){
    User user = new User();
    user.setEmail("luokangyuan@sina,com");
    user.setAge(24);
    user.setUserName("四川麻酱");
    Integer update = userMapper.update(user, new EntityWrapper<User>()
       .eq("user_name","李四")
       .eq("age",53)
       );
}

4.4.删除满足条件的数据

@Test
public void deleteByEntityWrapper(){
    userMapper.delete(new EntityWrapper<User>()
      .eq("user_name","王八")
      .eq("age",56)
    );
}

4.5.条件查询之Condition

Condition继承了Wrapper类，另外，我们不需要再new一个Condition对象，直接调用condition类的静态方法create就可以得到一个condition对象，然后使用wrapper的所有方法，简单使用如下：

@Test
public void testCondition(){
    userMapper.selectPage(new Page<User>(1,2), Condition.create()
     .between("age",45,56)
   );
}

五、活动记录AR

Active Record(活动记录)，简称AR，是一种领域模型模式，特点就是一个模型类对应关系型数据库中的一个表，而模型类的一个实例对应表中的一条记录；

5.1.开启AR模式

开启AR模式的方法很简单，就是让我们的实体类继承Model类，并实现其抽象方法，指定主键即可，如下

public class User extends Model<User> {

    @Override
    protected Serializable pkVal() {
        return id;
    }
}

5.2.插入一条数据

@Test
public void insert(){
    User user = new User();
    user.setUserName("杉木");
    user.setAge(25);
    user.setEmail("shancnu@163.com");
    user.setGender(1);
    boolean rs = user.insert();
}

5.3.修改一条数据

@Test
public void update(){
    User user = new User();
    user.setUserName("杉木博客");
    user.setAge(35);
    user.setId(10);
    boolean rs = user.updateById();
}

说明：和通用的CRUD中的更新方法一样，updateAllColumnById()会更新所有列

5.4.查询数据

@Test
public void select(){
    User user = new User();
    user.setId(2);
    // 根据ID查询一条数据
    User user1 = user.selectById();
    // 查询所有的数据
    List<User> users = user.selectAll();
    // 根据条件查询
    List<User> usersList = user.selectList(new EntityWrapper<User>()
           .like("user_name", "三"));
    // 统计满足条件的数据数量
    int gender = user.selectCount(new EntityWrapper<User>().eq("gender", 1));
    // 统计全表数量
    int count = user.selectCount(null);
}

5.5.删除一条数据

@Test
public void delete(){
    User user = new User();
    user.setId(7);
    boolean rs = user.deleteById();
    System.out.print(rs);
}

当然，也可以根据条件删除多条数据，这里需要注意的是：当删除不存在的数据时候，返回的结果也是true；

// 删除不存在逻辑属于成功
public static boolean delBool(Integer result) {
    return null != result && result >= 0;
}

5.6.分页查询数据

在前面的CRUD中的分页查询返回的是list数据集合，但是在AR中返回的却是Page对象，如下

@Test
public void selectPage(){
    User user = new User();
    Page<User> userPage = user.selectPage(new Page<User>(1, 2),
          new EntityWrapper<User>().like("user_name", "三"));
    List<User> records = userPage.getRecords();
}

5.7.AR总结

AR提供的是一种更为快速的实现CRUD操作，本质很是调用Mybatis对应的方法，说的简单一点就是语法糖；

糖虽然好吃，但是，不要管不住嘴；

六、代码生成器

我们知道mybatis有一个代码生成器MBG，可以生成Java实体类mapper接口和映射文件，但是MybatisPlus却更加强大，可以生成service和controller，可以配置实体类是否支持AR等，代码生成器

说明：建议数据库表名和字段名采用驼峰命名方式，和实体来一致，可以避免在对应实体类产生的性能损耗

6.1.导入依赖

<dependency>
    <groupId>org.apache.velocity</groupId>
    <artifactId>velocity-engine-core</artifactId>
    <version>2.0</version>
</dependency>

说明：MybatisPlus默认使用的是velocity模版引

6.2.编写配置类

@Test
public void testMbg(){

    // 1.全局配置
    GlobalConfig globalConfig = new GlobalConfig();
    globalConfig.setActiveRecord(true)// 是否开启AR模式
        .setAuthor("luokangyuan") // 指定作者
        .setOutputDir("/Users/luokangyuan/Documents/project/mybatisdemo/src/main/java")
        .setFileOverride(true) // 指定文件覆盖
        .setIdType(IdType.AUTO) // 设置主键自增策略
        .setServiceImplName("%sService") // 设置生成的services接口的名字的首字母是否为I
        .setBaseResultMap(true) // 基本的字段映射
        .setBaseColumnList(true); // 基本的sql片段
    // 2.配置数据源
    DataSourceConfig dataSourceConfig = new DataSourceConfig();
    dataSourceConfig.setDbType(DbType.MYSQL) // 设置数据库类型
        .setDriverName("com.mysql.jdbc.Driver")
        .setUrl("jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=Hongkong")
        .setUsername("root")
        .setPassword("jiamei@20141107.");
    // 3.策略配置
    StrategyConfig strategyConfig = new StrategyConfig();
    strategyConfig.setCapitalMode(true) //全局大写命名
        .setDbColumnUnderline(true) // 指定表名和字段名是否使用了下划线
        .setNaming(NamingStrategy.underline_to_camel) // 数据库字段下划线转驼峰命令策略
        .setTablePrefix("tbl_") // 设置表前缀
        .setInclude("tbl_dept","tbl_file"); // 设置需要生成的表
    // 4.包名策略配置
    PackageConfig packageConfig = new PackageConfig();
    packageConfig.setParent("com.luo") // 设置父包
        .setMapper("mapper")
        .setService("service")
        .setController("controller")
        .setEntity("beans")
        .setXml("mapper");
    // 5. 开始生成代码
    AutoGenerator autoGenerator = new AutoGenerator();
    autoGenerator.setGlobalConfig(globalConfig)
        .setDataSource(dataSourceConfig)
        .setStrategy(strategyConfig)
        .setPackageInfo(packageConfig);
    autoGenerator.execute();
}

6.3.生成的service代码查看

@Service
public class DeptService extends ServiceImpl<DeptMapper, Dept> implements IDeptService {

}

DeptService继承了ServiceImpl，在ServiceImpl中就已经注入了DeptMapper，所以，我们就不需要再次注入，在ServiceImpl中也帮我们提供了常用的CRUD方法，我们可以直接使用，

@Controller
@RequestMapping("/dept")
public class DeptController {
    @Autowired
    private IDeptService service;

    public String select(){
        service.selectList(null);
        return null;
    }
}

七、插件扩展

7.1.注册分页插件

<bean id="sqlSessionFactoryBean" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
    <!-- 数据源 -->
    <property name="dataSource" ref="dataSource"></property>
    <property name="configLocation" value="classpath:mybatis-config.xml"></property>
    <!-- 别名处理 -->
    <property name="typeAliasesPackage" value="com.luo.beans"></property>
    <!-- 注入全局MP策略配置 -->
    <property name="globalConfig" ref="globalConfiguration"></property>
    <property name="plugins">
        <list>
            <bean class="com.baomidou.mybatisplus.plugins.PaginationInterceptor"></bean>
        </list>
    </property>
</bean>

真正的分页查询

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

private UserMapper userMapper = ioc.getBean("userMapper",UserMapper.class);

@Test
public void testPage(){
    Page<User> page = new Page<User>(1,4);
    List<User> users = userMapper.selectPage(page,null);
    page.setRecords(users);
    System.out.print("总记录数"+page.getTotal());
    System.out.print("当前页码"+page.getCurrent());
    System.out.print("总页码"+page.getPages());
    System.out.print("每页记录数"+page.getSize());
    System.out.print("是否有前一页"+page.hasPrevious());
    System.out.print("是否有后一页"+page.hasNext());
}

说明：我们可以将分页查询的数据放在page对象中，返回前端一个page对象即可

7.2.执行分析插件

1
2
3

<bean class="com.baomidou.mybatisplus.plugins.SqlExplainInterceptor">
    <property name="stopProceed" value="true"></property>
</bean>

测试如下：

@Test
public void testDeltetAll(){
    userMapper.delete(null);
}

sql分析插件只支持mysql5.6.3以上的版本，本质就是通过sql分析命令Explain分析当前的sql语句，根据结果集中的Extra列来断定当前是否全表操作；

7.3.性能分析插件

性能分析插件用于输出每秒sql语句和其执行时间,首先注册插件，如下：

1
2
3

<bean class="com.baomidou.mybatisplus.plugins.PerformanceInterceptor">
    <property name="format" value="true"></property>
</bean>

测试如下：

@Test
public  void testPer(){
    Dept dept = new Dept();
    dept.setDeptName("开发部");
    dept.setDeptCount("34");
    dept.setDeptBegintime(new Date());
    dept.insert();
}

结果如下：

Time：142 ms - ID：com.luo.mapper.DeptMapper.insert
Execute SQL：
   INSERT 
   INTO
       tbl_dept
       ( dept_count, dept_name, dept_beginTime ) 
   VALUES
       ( '34', '开发部', '2018-08-26 23:09:17.293' )]

7.4.乐观锁插件

当我们在开发中，有时需要判断，当我们更新一条数据库记录时，希望这条记录没有被别人更新，这个时候就可以使用乐观锁插件，他的原理就是，取出记录时，获取当前的version，更新的时候带上这个version，执行更新的时候set version = yourVersion+1 where version = yourVersion,如果version不对，则更新失败，注意的是：@version用于注解实体字段，必须要有；

首先，注册插件

1	<bean class="com.baomidou.mybatisplus.plugins.OptimisticLockerInterceptor"></bean>

实体类添加对应属性,同时数据库表也要添加对应字段

1 2	@Version private Integer version;

测试如下：

@Test
public void testVersion(){
    Dept dept = new Dept();
    dept.setDeptName("测试部");
    dept.setVersion(1);
    dept.setId(1);
    dept.updateById();
}

如果：这个时候将数据库version改为2，在执行更新就会显示更新记录数为0；

八、自定义全局操作

8.1.自定义全局实例

自定义全局操作，就是将我们需要的sql在项目启动的时候就注入到全局中，操作步骤如下：

在Mapper接口中定义我们需要注入的方法；
扩展AutoSqlInjector中的inject方法，实现Mapper中我们自定义方法要注入的sql；
最后，在全局配置中，配置我们自定义的注入器即可；

第一步：mapper中定义方法

public interface UserMapper extends BaseMapper<User> {
    
    int deleteAll();
}

第二步：重写inject方法

public class MySqlInjector  extends AutoSqlInjector {

    @Override
    public void inject(Configuration configuration, MapperBuilderAssistant builderAssistant, Class<?> mapperClass, Class<?> modelClass, TableInfo table) {
        // 构造sql语句
        String sql = "delete from " + table.getTableName();
        // 构造方法名
        String method = "deleteAll";
        // 构造SqlSource对象
        SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
        // 构造一个删除的MapperStatement
        this.addDeleteMappedStatement(mapperClass,method,sqlSource);
    }
}ß

第三步：注入自定义配置

<bean id ="globalConfiguration" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">
     <!--映射数据库下划线字段名到数据库实体类的驼峰命名的映射-->
     <property name="dbColumnUnderline" value="true"></property>
     <!-- 全局的主键策略 -->
     <property name="idType" value="0"></property>
     <!-- 全局的表前缀策略配置 -->
     <property name="tablePrefix" value="tbl_"></property>
     <!--注入自定义全局操作-->
     <property name="sqlInjector" ref="mySqlInjector"></property>
</bean>
<bean class="com.luo.injector.MySqlInjector" id="mySqlInjector"></bean>

测试

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

private UserMapper userMapper = ioc.getBean("userMapper",UserMapper.class);

@Test
public void testInject(){
    int rs = userMapper.deleteAll();
}

8.2.逻辑删除

所谓逻辑删除，就是不真正的删除数据的记录，而是变为无效状态，在MybatisPlus中，给我们提供logicSqlInjector

第一步：数据库添加逻辑字段

第二步：实体类添加对应属性和注解

1 2	@TableLogic private Integer logicFlag;

第三步：MybatisPlus全局配置中加入logicSqlInjector

<bean id ="globalConfiguration" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">
    <!--映射数据库下划线字段名到数据库实体类的驼峰命名的映射-->
    <property name="dbColumnUnderline" value="true"></property>
    <!-- 全局的主键策略 -->
    <property name="idType" value="0"></property>
    <!-- 全局的表前缀策略配置 -->
    <property name="tablePrefix" value="tbl_"></property>
    <!--注入自定义全局操作-->
    <property ref="logicSqlInjector" name="sqlInjector"></property>
    <!--注入逻辑删除全局值-->
    <property name="logicDeleteValue" value="-1"></property>
    <property name="logicNotDeleteValue" value="1"></property>
</bean>
<!--逻辑删除-->
<bean class="com.baomidou.mybatisplus.mapper.LogicSqlInjector" id="logicSqlInjector"></bean>

测试

@Test
public void testLogin(){
    Integer integer = userMapper.deleteById(1);
}

说明：我们做的是删除操作，但是，执行的却是update操作，同时，查询的时候自动添加了有效判断

九、公共字段填充

这里涉及到一个元数据处理接口MetaObjectHandler,元对象是Mybatis提供的一个用于更加方便，更加优雅的访问对象的属性，给对象的属性赋值的一个对象，本质上metaObject获取对象的值或者是给对象的属性赋值，都是通过反射获取到属性对应方法的Invoker；

9.1.使用实例

第一步：注解需要填充的字段

1 2	@TableField(value = "user_name",fill = FieldFill.INSERT_UPDATE) private String userName;

第二步：自定义填充处理器

public class MetaHandler extends MetaObjectHandler {
    /**
     * 插入操作：自动填充
     * @param metaObject
     */
    public void insertFill(MetaObject metaObject) {
        // 获取到需要被填充的字段值
        Object userName = getFieldValByName("userName", metaObject);
        if(userName == null){
            setFieldValByName("userName","四川码酱",metaObject);
        }
    }

    /**
     * 更新操作：自动填充
     * @param metaObject
     */
    public void updateFill(MetaObject metaObject) {
        // 获取到需要被填充的字段值
        Object userName = getFieldValByName("userName", metaObject);
        if(userName == null){
            setFieldValByName("userName","康哥哥",metaObject);
        }
    }
}

第三步：注入全局配置

<bean id ="globalConfiguration" class="com.baomidou.mybatisplus.entity.GlobalConfiguration">
    <!--映射数据库下划线字段名到数据库实体类的驼峰命名的映射-->
    <property name="dbColumnUnderline" value="true"></property>
    <!-- 全局的主键策略 -->
    <property name="idType" value="0"></property>
    <!-- 全局的表前缀策略配置 -->
    <property name="tablePrefix" value="tbl_"></property>
    <!--注入自定义全局操作-->
    <!--<property name="sqlInjector" ref="mySqlInjector"></property>-->
    <property ref="logicSqlInjector" name="sqlInjector"></property>
    <!--注入逻辑删除全局值-->
    <property name="logicDeleteValue" value="-1"></property>
    <property name="logicNotDeleteValue" value="1"></property>
    <!--注入公共字段填充处理器-->
    <property name="metaObjectHandler" ref="metaHandler"></property>
</bean>
<!--自定义公共字段填充处理器-->
<bean class="com.luo.bandler.MetaHandler" id="metaHandler"></bean>

第四步：测试

@Test
public void testCom(){
    User user = new User();
    user.setId(11);
    user.setLogicFlag(1);
    user.updateById();
}

十、IEDA开发插件

10.1.安装方法

打开IDEA设置–Plugins–Browse repositories –搜索mybatisx,安装即可

10.2.支持的功能

根据mapper接口方法自动生成xml文件，接口方法定位xml,xml自动定位mapper接口；