MyBatis Plus操作小结

MyBatis Plus入门（算是官方文档使用）

简介

Mybatis-Plus（简称MP）是一个 Mybatis 的增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。这是官方给的定义，关于mybatis-plus的更多介绍及特性，可以参考mybatis-plus官网。它类似于JPA，封装好了一些crud方法，我们不需要再写xml了，可以直接调用这些方法。

这篇博文接博主上一篇博文MyBatis标签以及常用的SQL

spring整合mybatis-plus

依赖，博主这里选择的是2.3版本的。为什么不选最新的3.3.1版本，因为博主的工程中有大量的其他的配置，在使用过程中，3.3.1版本和博主配置的其他东西的版本不兼容。

<!-- mybatis-plus 依赖 -->
<dependency>
  <groupId>com.baomidou</groupId>
  <artifactId>mybatis-plus</artifactId>
  <version>2.3</version>
</dependency>

配置（微调），把MyBatis的sqlSessionFactory换成MyBatis-Plus的sqlSessionFactory。并将扫描Dao包换成扫描Repository。

<!-- 配置SqlSessionFactory对象 -->
<!--<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">-->
<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.spring.MybatisSqlSessionFactoryBean">
    <!-- 注入数据库连接池 -->
    <property name="dataSource" ref="dataSource"/>
    <!-- 扫描model包 使用别名 -->
    <property name="typeAliasesPackage" value="com.cloneZjrt.model"/>
    <property name="configLocation" value="classpath:mybatis-config.xml"/>
    <!-- 扫描sql配置文件:mapper需要的xml文件 -->
    <property name="mapperLocations" value="classpath:com/cloneZjrt/dao/mapper/*.xml"/>
</bean>

<!-- 配置扫描Dao接口包，动态实现Dao接口，注入到spring容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 注入sqlSessionFactory -->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!-- 给出需要扫描Dao接口包 -->
        <!--<property name="basePackage" value="com.cloneZjrt.dao"/>-->
        <property name="basePackage" value="com.cloneZjrt.repository" />
    </bean>

Repository

public interface UserRepository extends BaseMapper<UserEntity> {

}

实体类

@Data
@TableName(value = "userinfo")//对应表名
public class UserEntity {

    @TableId(value = "userid",type = IdType.AUTO)//对应列名以及设置自增
    private long userId;
    @TableField(value = "username")
    private String userName;

    @TableField(exist = false)//exist表示这个属性在表中是否存在，默认是true存在。
    private List<RoleEntity> roleEntities;

}

测试

@Autowired
private UserRepository userRepository;

@Test
public void testMp(){

    UserEntity userEntity = userRepository.selectById(1l);
    System.out.println(JSON.parseObject(JSON.toJSONString(userEntity), new TypeReference<Map<String, Object>>(){}));
}

{userName=111, userId=1}

常用功能

CRUD（Create，Retrieve，Update，Delete）

使用BaseMapper接口

接口命名方式上还是比较简单易懂的，在使用时，可翻阅官方文档的解释和例子(2.x版本和3.x版本存在些微调)

public interface BaseMapper<T> {
    //插入单条
    Integer insert(T var1);
	//插入多条
    Integer insertAllColumn(T var1);
	//通过ID删除
    Integer deleteById(Serializable var1);
	//通过某个属性删除
    Integer deleteByMap(@Param("cm") Map<String, Object> var1);
	//执行EntityWrapper进行删除
    Integer delete(@Param("ew") Wrapper<T> var1);
	//删除多条
    Integer deleteBatchIds(@Param("coll") Collection<? extends Serializable> var1);
	//根据ID修改
    Integer updateById(@Param("et") T var1);
	
    Integer updateAllColumnById(@Param("et") T var1);
	
    Integer update(@Param("et") T var1, @Param("ew") Wrapper<T> var2);

    Integer updateForSet(@Param("setStr") String var1, @Param("ew") Wrapper<T> var2);
	//根据ID查询
    T selectById(Serializable var1);
	//根据ID集查询
    List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> var1);
	//根据属性查询
    List<T> selectByMap(@Param("cm") Map<String, Object> var1);
	
    T selectOne(@Param("ew") T var1);

    Integer selectCount(@Param("ew") Wrapper<T> var1);
	//根据EntityWrapper进行查找对象集合
    List<T> selectList(@Param("ew") Wrapper<T> var1);
	//根据EntityWrapper进行查找对象Map集合
    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> var1);

    List<Object> selectObjs(@Param("ew") Wrapper<T> var1);

    List<T> selectPage(RowBounds var1, @Param("ew") Wrapper<T> var2);

    List<Map<String, Object>> selectMapsPage(RowBounds var1, @Param("ew") Wrapper<T> var2);
}

使用IService接口

public interface IService<T> {
    boolean insert(T var1);

    boolean insertAllColumn(T var1);

    boolean insertBatch(List<T> var1);

    boolean insertBatch(List<T> var1, int var2);

    boolean insertOrUpdateBatch(List<T> var1);

    boolean insertOrUpdateBatch(List<T> var1, int var2);

    boolean insertOrUpdateAllColumnBatch(List<T> var1);

    boolean insertOrUpdateAllColumnBatch(List<T> var1, int var2);

    boolean deleteById(Serializable var1);

    boolean deleteByMap(Map<String, Object> var1);

    boolean delete(Wrapper<T> var1);

    boolean deleteBatchIds(Collection<? extends Serializable> var1);

    boolean updateById(T var1);

    boolean updateAllColumnById(T var1);

    boolean update(T var1, Wrapper<T> var2);

    boolean updateForSet(String var1, Wrapper<T> var2);

    boolean updateBatchById(List<T> var1);

    boolean updateBatchById(List<T> var1, int var2);

    boolean updateAllColumnBatchById(List<T> var1);

    boolean updateAllColumnBatchById(List<T> var1, int var2);

    boolean insertOrUpdate(T var1);

    boolean insertOrUpdateAllColumn(T var1);

    T selectById(Serializable var1);

    List<T> selectBatchIds(Collection<? extends Serializable> var1);

    List<T> selectByMap(Map<String, Object> var1);

    T selectOne(Wrapper<T> var1);

    Map<String, Object> selectMap(Wrapper<T> var1);

    Object selectObj(Wrapper<T> var1);

    int selectCount(Wrapper<T> var1);

    List<T> selectList(Wrapper<T> var1);

    Page<T> selectPage(Page<T> var1);

    List<Map<String, Object>> selectMaps(Wrapper<T> var1);

    List<Object> selectObjs(Wrapper<T> var1);

    Page<Map<String, Object>> selectMapsPage(Page var1, Wrapper<T> var2);

    Page<T> selectPage(Page<T> var1, Wrapper<T> var2);
}

这些常规的API基本上实现了数据库的逻辑操作，稍微复杂使用下面的条件构造器来设置条件。

条件构造器

EntityWrapper<T>中有很多方法，方法名也较易懂，原理就是进行SQL的拼接，需要啥用啥就行。

• setSqlSelect：设置SELECT查询字段
• where：WHERE语句，拼接 - WHERE条件
• and：AND语句，拼接 - AND 字段=值
• andNew：AND语句，拼接 - AND （字段=值）
• or：OR语句，拼接 - OR 字段=值
• orNew：OR语句，拼接 - OR（字段=值）
• eq：等于=
• allEq：基于map内容等于=
• ne：不等于<>
• gt：大于>
• ge：大于等于>=
• lt：小于<
• le：小于等于<=
• like：模糊查询LIKE
• notLike：模糊查询NOT LIKE
• in：IN查询
• notin：NOT IN查询
• isNull：NULL值查询
• isNotNull：IS NOT NULL
• groupBy：分组GROUP BY
• having：HAVING关键词
• orderBy：排序ORDER BY
• orderAsc：ASC排序ORDER BY
• orderDesc：DESC排序ORDER BY
• exists：EXISTS条件语句
• notExists：NOT EXISTS条件语句
• between：BETWEEN条件语句
• notBetween：NOT BETWEEN条件语句
• addFilter：自由拼接SQL
• last：拼接在最后，例如last(“LIMIT 1”)

简单使用1：模糊和范围查询的拼接

List<UserEntity> userEntities = userRepository.selectList(
        new EntityWrapper<UserEntity>().like("username","1").and().between("userid",1l,12l)
);
for(UserEntity u : userEntities){
    System.out.println(entityToMap(u));
}

简单使用2：EntityWrapper配合Page实现分页查询

List<UserEntity> userEntityList = userRepository.selectPage(
        new Page<UserEntity>(2,3),new EntityWrapper<UserEntity>()
);
for(UserEntity u : userEntityList){
    System.out.println(entityToMap(u));
}

利用条件构造器和BaseMapper能解决大部分需求，实在有需求无法很好的实现，那么回到mapper.xml文件中编写，MyBatis-Plus和MyBatis可以很好的兼容使用。

代码生成器

这是MyBatis-Plus的一个工具，可节省大量编程时间。

先导入模板依赖

<!-- 模板引擎 -->
<dependency>
  <groupId>org.apache.velocity</groupId>
  <artifactId>velocity-engine-core</artifactId>
  <version>2.1</version>
</dependency>

/**
 * <p>
 * 代码生成器演示
 * </p>
 */
public class MpGenerator {
    
    /**
     * <p>
     * MySQL 生成演示
     * </p>
     */
    public static void main(String[] args) {

        final String path = System.getProperty("user.dir") + "/src/main/java/";
        final String comName = "com.***";
        final String comPath = "com/***";

        AutoGenerator mpg = new AutoGenerator();
        // 选择 freemarker 引擎，默认 Veloctiy
        // mpg.setTemplateEngine(new FreemarkerTemplateEngine());

        // 全局配置
        GlobalConfig gc = new GlobalConfig();
        // 输出目录
        gc.setOutputDir(path);
        // 是否覆盖
        gc.setFileOverride(true);
        // 不需要ActiveRecord特性的请改为false
        gc.setActiveRecord(true);
        // XML 二级缓存
        gc.setEnableCache(false);
        // XML ResultMap
        gc.setBaseResultMap(true);
        // XML columList
        gc.setBaseColumnList(true);
        // 是否生成 kotlin 代码
        gc.setKotlin(false);
        //文件的生成者
        gc.setAuthor("root");
        // 自定义文件命名，注意 %s 会自动填充表实体属性！
        gc.setMapperName("%sDao");
        gc.setXmlName("%sMapper");
        gc.setServiceName("%sService");
        gc.setServiceImplName("%sServiceImpl");
        gc.setControllerName("%sController");
        mpg.setGlobalConfig(gc);

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setDbType(DbType.MYSQL);
//        dsc.setTypeConvert(new MySqlTypeConvert(){
//            // 自定义数据库表字段类型转换【可选】
//            @Override
//            public DbColumnType processTypeConvert(String fieldType) {
//                System.out.println("转换类型：" + fieldType);
//                // 注意！！processTypeConvert 存在默认类型转换，如果不是你要的效果请自定义返回、非如下直接返回。
//                return super.processTypeConvert(fieldType);
//            }
//        });
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("root");
        dsc.setUrl("jdbc:mysql://127.0.0.1:3306/zxs?characterEncoding=utf8");
        mpg.setDataSource(dsc);

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        // strategy.setCapitalMode(true);// 全局大写命名 ORACLE 注意
        //strategy.setTablePrefix(new String[] { "tlog_", "tsys_" });// 此处可以修改为您的表前缀
        // 表名生成策略
        strategy.setNaming(NamingStrategy.underline_to_camel);
        // 需要生成的表
        strategy.setInclude("user_entity" );
        //实体类使用Lombok
        strategy.setEntityLombokModel(true);
        // strategy.setExclude(new String[]{"test"}); // 排除生成的表
        // 自定义实体父类
        // strategy.setSuperEntityClass("com.baomidou.demo.TestEntity");
        // 自定义实体，公共字段
        // strategy.setSuperEntityColumns(new String[] { "test_id", "age" });
        // 自定义 mapper 父类
        // strategy.setSuperMapperClass("com.baomidou.demo.TestMapper");
        // 自定义 service 父类
        // strategy.setSuperServiceClass("com.baomidou.demo.TestService");
        // 自定义 service 实现类父类
        // strategy.setSuperServiceImplClass("com.baomidou.demo.TestServiceImpl");
        // 自定义 controller 父类
        // strategy.setSuperControllerClass("com.baomidou.demo.TestController");
        // 【实体】是否生成字段常量（默认 false）
        // public static final String ID = "test_id";
        // strategy.setEntityColumnConstant(true);
        // 【实体】是否为构建者模型（默认 false）
        // public User setName(String name) {this.name = name; return this;}
        // strategy.setEntityBuilderModel(true);
        mpg.setStrategy(strategy);

        // 包配置
        PackageConfig pc = new PackageConfig();
        //基本包路劲
        pc.setParent(comName);
        pc.setController("controller");
        pc.setEntity("entity");
        pc.setMapper("dao");
        pc.setService("service");
        pc.setServiceImpl("serviceImpl");
        pc.setXml("mapper");

        mpg.setPackageInfo(pc);

        // 注入自定义配置，可以在 VM 中使用 cfg.abc 【可无】
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                Map<String, Object> map = new HashMap<String, Object>();
                map.put("abc", this.getConfig().getGlobalConfig().getAuthor() + "-mp");
                this.setMap(map);
            }
        };

        // 自定义 xxList.jsp 生成
        List<FileOutConfig> focList = new ArrayList<FileOutConfig>();
//        focList.add(new FileOutConfig("/template/list.jsp.vm") {
//            @Override
//            public String outputFile(TableInfo tableInfo) {
//                // 自定义输入文件名称
//                return "D://aToServer//testMp//my_" + tableInfo.getEntityName() + ".jsp";
//            }
//        });
//        cfg.setFileOutConfigList(focList);
//        mpg.setCfg(cfg);

        // 调整 xml 生成目录演示
        focList.add(new FileOutConfig("/templates/mapper.xml.vm") {
            @Override
            public String outputFile(TableInfo tableInfo) {
                return  path + comPath + "/dao/mapper/" + tableInfo.getEntityName() + ".xml";
            }
        });
        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 关闭默认 xml 生成，调整生成 至 根目录
        TemplateConfig tc = new TemplateConfig();
        tc.setXml(null);
        mpg.setTemplate(tc);

        // 自定义模板配置，可以 copy 源码 mybatis-plus/src/main/resources/templates 下面内容修改，
        // 放置自己项目的 src/main/resources/templates 目录下, 默认名称一下可以不配置，也可以自定义模板名称
        // TemplateConfig tc = new TemplateConfig();
        // tc.setController("...");
        // tc.setEntity("...");
        // tc.setMapper("...");
        // tc.setXml("...");
        // tc.setService("...");
        // tc.setServiceImpl("...");
        // 如上任何一个模块如果设置 空 OR Null 将不生成该模块。
        // mpg.setTemplate(tc);

        // 执行生成
        mpg.execute();

        // 打印注入设置【可无】
        System.err.println(mpg.getCfg().getMap().get("abc"));
    }

}

ActiveRecord

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

实现其实很简单，只需要把实体类继承Model即可，需要注意的是，要求实现pkVal()方法，用来指定主键属性。

@Data
@TableName(value = "userinfo")
public class UserEntity extends Model<UserEntity> {

    @TableId(value = "userid",type = IdType.AUTO)
    private long userId;
    @TableField(value = "username")
    private String userName;

    @TableField(exist = false)
    private List<RoleEntity> roleEntities;

    public UserEntity(){

    }

    @Override
    protected Serializable pkVal() {
        return this.userId;
    }

}

实体类实现之后，会有一些方法可以使用，以下是一些Demo

// 初始化 成功标识
boolean result = false;
// 初始化 User
UserEntity user = new UserEntity();

// 保存 User
user.setUserName("Tom");
result = user.insert();

// 更新 User
user.setUserName("Tony");
result = user.updateById();

// 查询 User
UserEntity exampleUser = user.selectById();

// 查询姓名为‘张三’的所有用户记录
List<UserEntity> userList1 = user.selectList(
        new EntityWrapper<UserEntity>().eq("username", "张三")
);

// 删除 User
result = user.deleteById();

// 分页查询 10 条姓名为‘张三’的用户记录
List<UserEntity> userList = user.selectPage(
        new Page<UserEntity>(1, 10),
        new EntityWrapper<UserEntity>().eq("username", "张三")
).getRecords();

// 分页查询 10 条姓名为‘张三’、性别为男，且年龄在18至50之间的用户记录
List<UserEntity> userEntityList = user.selectPage(
        new Page<UserEntity>(1, 10),
        new EntityWrapper<UserEntity>().eq("username", "张三")
                .eq("sex", 0)
                .between("age", "18", "50")
).getRecords();

• AR模式提供了一种更加便捷的方式实现了CRUD操作，其本质还是调用了Mybatis对应的方法（sqlSession调用方法），类似于语法糖。

语法糖：计算机学专家发明的一种术语。指计算机语言中添加的某种语法，这种语法对原本语言的功能并没有影响，可以更方便开发者使用，可以避免出错的机会，让程序可读性更好。

• 到此，我们简单领略了Mybatis-Plus的魅力与高效率，值得一提的是：我们提供了强大的代码生成器，可以快速生成各类代码，真正做到了即开即用。

可参考博文Mybatis-Plus 条件构造器_EntityWrapper