一、Mybatis-plus

简介

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

愿景 我们的愿景是成为 MyBatis 最好的搭档，就像 魂斗罗 中的 1P、2P，基友搭配，效率翻倍。

Mybatis-plus - 图1

特性

  • 无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
  • 损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
  • 强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，更有强大的条件构造器，满足各类使用需求
  • 支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
  • 支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），可自由配置，完美解决主键问题
  • 支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作
  • 支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
  • 内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，支持模板引擎，更有超多自定义配置等您来使用
  • 内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，配置好插件之后，写分页等同于普通 List 查询
  • 分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
  • 内置性能分析插件：可输出 Sql 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
  • 内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作

支持数据库

  • mysql 、 mariadb 、 oracle 、 db2 、 h2 、 hsql 、 sqlite 、 postgresql 、 sqlserver 、 presto
  • 达梦数据库 、 虚谷数据库 、 人大金仓数据库

框架结构

Mybatis-plus - 图2

代码托管

Gitee | Github

二、快速入门

地址：https://mp.baomidou.com/guide/quick-start.html#初始化工程

使用第三方组件

  1. 导入对应依赖
  2. 研究依赖配置
  3. 代码如何编写
  4. 提高扩展技术能力！

步骤

  1. 创建数据库mybatis_plus
  2. 创建user表,插入数据
  1. DROP TABLE IF EXISTS user;
  3. CREATE TABLE user
  4. (
  5.     id BIGINT(20) NOT NULL COMMENT '主键ID',
  6.     name VARCHAR(30) NULL DEFAULT NULL COMMENT '姓名',
  7.     age INT(11) NULL DEFAULT NULL COMMENT '年龄',
  8.     email VARCHAR(50) NULL DEFAULT NULL COMMENT '邮箱',
  9.     PRIMARY KEY (id)
  10. );
  12. DELETE FROM user;
  14. INSERT INTO user (id, name, age, email) VALUES
  15. (1, 'Jone', 18, 'test1@baomidou.com'),
  16. (2, 'Jack', 20, 'test2@baomidou.com'),
  17. (3, 'Tom', 28, 'test3@baomidou.com'),
  18. (4, 'Sandy', 21, 'test4@baomidou.com'),
  19. (5, 'Billie', 24, 'test5@baomidou.com');
  1. 编写项目,初始化项目! 使用SpringBoot初始化!
  2. 导入依赖
  1. <dependency>
  2.     <groupId>org.springframework.boot</groupI
  3.     <artifactId>spring-boot-starter-web</arti
  4. </dependency>
  5. <dependency>
  6.     <groupId>org.springframework.boot</groupI
  7.     <artifactId>spring-boot-starter-test</art
  8.     <scope>test</scope>
  9.     <exclusions>
  10.         <exclusion>
  11.             <groupId>org.junit.vintage</group
  12.             <artifactId>junit-vintage-engine<
  13.         </exclusion>
  14.     </exclusions>
  15. </dependency>
  16. <!--数据库驱动-->
  17. <dependency>
  18.     <groupId>mysql</groupId>
  19.     <artifactId>mysql-connector-java</artifac
  20.     <version>8.0.20</version>
  21. </dependency>
  22. <!--lombok-->
  23. <dependency>
  24.     <groupId>org.projectlombok</groupId>
  25.     <artifactId>lombok</artifactId>
  26.     <version>1.18.12</version>
  27. </dependency>
  28. <!--mybatis-plus-->
  29. <dependency>
  30.     <groupId>com.baomidou</groupId>
  31.     <artifactId>mybatis-plus-boot-starter</ar
  32.     <version>3.3.1</version>
  33. </dependency>

说明:我们使用mybatis-plus可以节省大量代码,尽量不要同时导入mybatis和mybatis-plus!版本差异!

  1. 配置数据库,和mybatis一样
  1. spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
  2. spring.datasource.url=jdbc:mysql://localhost:3306/mybatis_plus?userSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
  3. spring.datasource.username=mybatis_plus
  4. spring.datasource.password=mybatis_plus123
  1. 在 Spring Boot 启动类中添加 @MapperScan 注解，扫描 Mapper 文件夹：
  1. @MapperScan("com.godfrey.mapper")
  2. @SpringBootApplication
  3. public class MybatisPlusApplication {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(MybatisPlusApplication.class, args);
  7.     }
  9. }
  1. 编码

编写实体类 User.java

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class User {
  5.     private Long id;
  6.     private String name;
  7.     private Integer age;
  8.     private String email;
  9. }

编写Mapper类 UserMapper.java

  1. @Mapper
  2. public interface UserMapper extends BaseMapper<User> {
  3. }

8.使用

添加测试类，进行功能测试：

  1. @SpringBootTest
  2. class MybatisPlusApplicationTests {
  4.     @Resource
  5.     private UserMapper userMapper;
  7.     @Test
  8.     void contextLoads() {
  9.         //查询全部用户
  10.         //参数是一个Wrapper,条件构造器
  11.         List<User> users = userMapper.selectList(null);
  12.         users.forEach(System.out::println);
  13.     }
  14. }

控制台输出：

  1. User(id=1, name=Jone, age=18, email=test1@baomidou.com)
  2. User(id=2, name=Jack, age=20, email=test2@baomidou.com)
  3. User(id=3, name=Tom, age=28, email=test3@baomidou.com)
  4. User(id=4, name=Sandy, age=21, email=test4@baomidou.com)
  5. User(id=5, name=Billie, age=24, email=test5@baomidou.com)

小结

通过以上几个简单的步骤，我们就实现了 User 表的 CRUD 功能，甚至连 XML 文件都不用编写！

从以上步骤中，我们可以看到集成MyBatis-Plus非常的简单，只需要引入 starter 工程，并配置 mapper 扫描路径即可。

三、配置日志

  1. # 配置日志
  2. mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

四、CRUD扩展

插入操作

  1. //测试插入
  2. @Test
  3. public void testInsert(){
  4.     User user = new User();
  5.     user.setName("淮城一只猫");
  6.     user.setAge(5);
  7.     user.setEmail("2424496907@qq.com");
  8.     int result = userMapper.insert(user); //自动生成id
  9.     System.out.println(result); //受影响的行数
  10.     System.out.println(user); //发现id自动回填
  11. }

Mybatis-plus - 图3

数据库插入的id默认是全局唯一id

主键生成策略

默认ID_WORKER,全局唯一id

分布式系统唯一id生成方案汇总

雪花算法:

snowflake是Twitter开源的分布式ID生成算法，结果是一个long型的ID。其核心思想是：使用41bit作为毫秒数，10bit作为机器的ID（5个bit是数据中心，5个bit的机器ID），12bit作为毫秒内的流水号（意味着每个节点在每毫秒可以产生 4096 个 ID），最后还有一个符号位，永远是0。可以保证几乎全球唯一!

主键自增

我们需要配置注解自增:

  1. 实体类字段上:@TableId(type = IdType.AUTUO)
  2. 数据库字段一定要自增

Mybatis-plus - 图4

3.再次测试插入即可！

其余的策略解释

  1. public enum IdType {
  2.     AUTO(0), //id自增
  3.     NONE(1), //未设置主键
  4.     INPUT(2), //手动输入
  5.     ID_WORKER(3), //默认值,全局唯一id
  6.     UUID(4), //全局唯一id,uuid
  7.     ID_WORKER_STR(5); //ID_WORKER的字符串表示法
  8. }

更新操作

  1. //测试更新
  2. @Test
  3. public void testUpdate(){
  4.     User user = new User();
  5.     user.setId(6L);
  6.     user.setName("我的博客叫：淮城一只猫");
  7.     user.setAge(6);
  8.     user.setEmail("2424496907@qq.com");
  9.     //注意：updateById参数是一个对象
  10.     int result = userMapper.updateById(user); //自动生成id
  11.     System.out.println(result); //受影响的行数
  12. }

自动填充

创建时间、修改时间!这些操作一般自动化完成的,我们不希望手动更新！

阿里巴巴开发手册:所有的数据库表:gmt_create、gmt_modified几乎所有表都要配置上!而且需要自动化！

方式一:数据库级别(工作中不建议这么做)

  1. 在表中新增字段create_time、update_time

Mybatis-plus - 图5

  1. 再次测试插入方法,需要先把实体类同步！
  1. private Date creteTime;
  2. private Date updateTime;

Mybatis-plus - 图6

方式二:代码级别

  1. 输出数据库中的默认值、更新操作

Mybatis-plus - 图7

  1. 在实体类字段属性上需要注释
  1. //字段添加填充内容
  2. @TableField(fill = FieldFill.INSERT)
  3. private Date creteTime;
  4. @TableField(fill = FieldFill.INSERT_UPDATE)
  5. private Date updateTime;
  1. 编写处理器处理注解！
  1. @Slf4j
  2. @Component
  3. public class MyMetaObjectHandler implements MetaObjectHandler{
  4.     //插入时填充策略
  5.     @Override
  6.     public void insertFill(MetaObject metaObject) {
  7.         log.info("start insert fill ....");
  8.         this.setFieldValByName("createTime",new Date(),metaObject);
  9.         this.setFieldValByName("updateTime",new Date(),metaObject);
  10.     }
  12.     //更新时填充策略
  13.     @Override
  14.     public void updateFill(MetaObject metaObject) {
  15.         log.info("start update fill ....");
  16.         this.setFieldValByName("updateTime",new Date(),metaObject);
  17.     }
  18. }
  1. 测试插入
  2. 测试更新、观察时间即可！

乐观锁

乐观锁：顾名思义乐观，它总是认为不会出现问题，无论干什么都不去上锁！如果出现问题，再次更新值测试 悲观锁：顾名思义悲观，它总是认为会出现问题，无论干什么都会加上锁！再去操作

乐观锁实现方式：

  • 取出记录时，获取当前version
  • 更新时，带上这个version
  • 执行更新时， set version = newVersion where version = oldVersion
  • 如果version不对，就更新失败

测试MP乐观锁插件

  1. 数据库中添加version字段！

Mybatis-plus - 图8

  1. 实体类添加对应字段
  1. @Version  //乐观锁注解
  2. private Integer version;
  1. 注册组件
  1. @MapperScan("com.godfrey.mapper")
  2. @EnableTransactionManagement  //自动管理事务（默认也是开启的）
  3. @Configuration  //配置类
  4. public class MybaitsPlusConfig {
  6.     //注册乐观锁插件
  7.     @Bean
  8.     public OptimisticLockerInterceptor optimisticLockerInterceptor() {
  9.         return new OptimisticLockerInterceptor();
  10.     }
  11. }
  1. 测试一下
  1. //测试乐观锁成功！
  2. @Test
  3. public void testOptimisticLocker1() {
  4.     //1.查询用户信息
  5.     User user = userMapper.selectById(1L);
  6.     //2.修改用户信息
  7.     user.setName("godfrey");
  8.     user.setEmail("13610506606@163.com");
  9.     //3.执行更新操作
  10.     userMapper.updateById(user);
  11. }
  14. //测试乐观锁失败！多线程下
  15. @Test
  16. public void testOptimisticLocker2() {
  17.     //线程1
  18.     User user1 = userMapper.selectById(1L);
  19.     user1.setName("godfrey111");
  20.     user1.setEmail("13610506606@163.com");
  22.     //模拟另外一个线程执行插队操作
  23.     User user2 = userMapper.selectById(1L);
  24.     user2.setName("godfrey222");
  25.     user2.setEmail("13610506606@163.com");
  26.     userMapper.updateById(user2);
  28.     //自旋锁多次操作尝试提交
  29.     userMapper.updateById(user1);
  30. }

Mybatis-plus - 图9

查询操作

  1. //测试查询
  2. @Test
  3. public void testSelectById() {
  4.     User user = userMapper.selectById(1L);
  5.     System.out.println(user);
  6. }
  8. //测试批量查询
  9. @Test
  10. public void testSelectByBatchId() {
  11.     List<User> users = userMapper.selectBatchIds(Arrays.asList(1L, 2L, 3L));
  12.     users.forEach(System.out::println);
  13. }
  15. //条件查询之一 使用map操作
  16. @Test
  17. public void testSelectBatchIds() {
  18.     HashMap<String, Object> map = new HashMap<>();
  19.     //自定义查询
  20.     map.put("name","Tom");
  21.     map.put("age",28);
  23.     List<User> users = userMapper.selectByMap(map);
  24.     users.forEach(System.out::println);
  25. }

分页查询

分页在网站中使用非常多！

  1. 原始limit进行分页
  2. pageHelper第三方插件
  3. MP其实也内置了分页插件

如何使用？

  1. 配置分页插件
  1. //分页插件
  2. @Bean
  3. public PaginationInterceptor paginationInterceptor() {
  4.     return new PaginationInterceptor();
  5. }
  1. 直接使用Page对象即可！
  1. //测试分页查询
  2. @Test
  3. public void testPage() {
  4.     //参数一：当前页
  5.     //参数二：页面大小
  6.     //使用了分页插件之后，所有的分页操作页变得简单了
  7.     Page<User> page = new Page<>(1,5);
  8.     userMapper.selectPage(page,null);
  10.     page.getRecords().forEach(System.out::println);
  11.     System.out.println(page.getTotal());
  12. }

删除操作

基本的删除操作

  1. //通过id删除
  2. @Test
  3. public void testDeleteById() {
  4.     userMapper.deleteById(8L);
  5. }
  7. //通过id批量删除
  8. @Test
  9. public void testDeleteBatchId() {
  10.     userMapper.deleteBatchIds(Arrays.asList(6L, 7L));
  11. }
  13. //通过map删除
  14. @Test
  15. public void testDeleteMap() {
  16.     HashMap<String, Object> map = new HashMap<>();
  17.     map.put("name", "godfrey");
  18.     userMapper.deleteByMap(map);
  19. }

我们在工作中会遇到一些问题：逻辑删除！

逻辑删除

物理删除：从数据库中直接移除 逻辑删除：在数据库中没有被移除，而是通过一个变量来让他失效！delete=0 => delete=1

管理员可以查看被删除的记录！防止数据的丢失，类似于回收站！

测试一下：

  1. 在数据表中增加deleted字段

Mybatis-plus - 图10

  1. 实体类中同步属性
  1. //逻辑删除字段
  2. private Integer deleted;
  1. 配置
  1. # 配置逻辑删除
  2. mybatis-plus.global-config.db-config.logic-delete-field=deleted # 全局逻辑删除的实体字段名
  3. mybatis-plus.global-config.db-config.logic-delete-value=1 # 逻辑已删除值(默认为 1)
  4. mybatis-plus.global-config.db-config.logic-not-delete-value=0 # 逻辑未删除值(默认为 0)
  1. 测试一下删除

Mybatis-plus - 图11

Mybatis-plus - 图12

以上的所有CRUD操作及其扩展操作，我们都必须精通掌握！会大大提高工作和写项目效率

性能分析插件

我们在开发中，会遇到一些慢sql，我们有必要把它揪出来 。测试！druid…

MP也提供性能分析插件，如果超过这个时间就停止运行！官方3.1.0以上版本推荐使用p6spy！

  1. 导入依赖
  1. <!--p6spy性能分析插件-->
  2. <dependency>
  3.     <groupId>p6spy</groupId>
  4.     <artifactId>p6spy</artifactId>
  5.     <version>3.9.0</version>
  6. </dependency>
  1. 修改数据库连接配置
  1. # 数据库连接配置
  2. spring.datasource.driver-class-name=com.p6spy.engine.spy.P6SpyDriver
  3. spring.datasource.url=jdbc:p6spy:mysql://localhost:3306/mybatis_plus?userSSL=false&useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT%2B8
  1. 新建spy.properties 并设置参数
  1. #3.2.1以上使用
  2. modulelist=com.baomidou.mybatisplus.extension.p6spy.MybatisPlusLogFactory,com.p6spy.engine.outage.P6OutageFactory
  3. #3.2.1以下使用或者不配置
  4. #modulelist=com.p6spy.engine.logging.P6LogFactory,com.p6spy.engine.outage.P6OutageFactory
  5. # 自定义日志打印
  6. logMessageFormat=com.baomidou.mybatisplus.extension.p6spy.P6SpyLogger
  7. #日志输出到控制台
  8. appender=com.baomidou.mybatisplus.extension.p6spy.StdoutLogger
  9. # 使用日志系统记录 sql
  10. #appender=com.p6spy.engine.spy.appender.Slf4JLogger
  11. # 设置 p6spy driver 代理
  12. deregisterdrivers=true
  13. # 取消JDBC URL前缀
  14. useprefix=true
  15. # 配置记录 Log 例外,可去掉的结果集有error,info,batch,debug,statement,commit,rollback,result,resultset.
  16. excludecategories=info,debug,result,commit,resultset
  17. # 日期格式gui
  18. dateformat=yyyy-MM-dd HH:mm:ss
  19. # 实际驱动可多个
  20. #driverlist=org.h2.Driver
  21. # 是否开启慢SQL记录
  22. outagedetection=true
  23. # 慢SQL记录标准 2 秒
  24. outagedetectioninterval=2
  1. 测试使用！（只要超过了规定时间就会抛出异常）

Mybatis-plus - 图13

注意，插件会影响性能，建议开发和测试环境下使用

条件构造器

  1. 测试一
  1. @Test
  2. void test1() {
  3.     //查询name不为空的用户，并且邮箱不为空的，年龄大于等于12
  4.     QueryWrapper<User> wapper = new QueryWrapper<>();
  5.     wapper.isNotNull("name")
  6.             .isNotNull("email")
  7.             .ge("age", 12);
  8.     userMapper.selectList(wapper).forEach(System.out::println);
  9. }
  1. 测试二
  1. @Test
  2. void test2() {
  3.     //查询名字为Tom
  4.     QueryWrapper<User> wapper = new QueryWrapper<>();
  5.     wapper.eq("name","Tom");
  6.     User user = userMapper.selectOne(wapper);
  7.     System.out.println(user);
  8. }
  1. 测试三
  1. //范围查询
  2. @Test
  3. void test3() {
  4.     //查询年龄在20~30岁之间的用户
  5.     QueryWrapper<User> wapper = new QueryWrapper<>();
  6.     wapper.between("age", 20, 30);//区间
  7.     System.out.println(userMapper.selectCount(wapper));//查询结果数
  8. }
  1. 测试四
  1. //模糊查询
  2. @Test
  3. void test4() {
  4.     //查询名字有
  5.     QueryWrapper<User> wapper = new QueryWrapper<>();
  6.     wapper.notLike("name","e")//%e%
  7.             .likeRight("email","t");//t%
  8.     List<Map<String, Object>> maps = userMapper.selectMaps(wapper);
  9.     maps.forEach(System.out::println);
  10. }
  1. 测试五
  1. //子查询
  2. @Test
  3. void test5() {
  4.     QueryWrapper<User> wapper = new QueryWrapper<>();
  5.     //id在子查询中查出来
  6.     wapper.inSql("id","select id from user where id<3");
  7.     List<Object> objects = userMapper.selectObjs(wapper);
  8.     objects.forEach(System.out::println);
  9. }
  1. 测试六
  1. //排序
  2. @Test
  3. void test6() {
  4.     QueryWrapper<User> wapper = new QueryWrapper<>();
  5.     //通过id进行排序
  6.     wapper.orderByDesc("id");
  7.     userMapper.selectList(wapper).forEach(System.out::println);
  8. }

代码生成器

mapper、pojo、service、controller都给我自己去编写完成！

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。

1.EasyCode介绍

1.1 EasyCode是一个什么东西？

EasyCode是基于IntelliJ IDEA Ultimate版开发的一个代码生成插件，主要通过自定义模板（基于velocity）来生成各种你想要的代码。通常用于生成Entity、Dao、Service、Controller。如果你动手能力强还可以用于生成HTML、JS、PHP等代码。理论上来说只要是与数据有关的代码都是可以生成的。

1.2 原理

基于Mybatis底层强大的逆向工程能力和良好的项目架构

1.3 使用环境

IntelliJ IDEA Ultimate版

1.4 支持的数据库类型

因为是基于Database Tool开发，所有Database Tool支持的数据库都是支持的。

包括如下数据库：

  1. MySQL
  2. SQL Server
  3. Oracle
  4. PostgreSQL
  5. Sqlite
  6. Sybase
  7. Derby
  8. DB2
  9. HSQLDB
  10. H2

当然支持的数据库类型也会随着Database Tool插件的更新同步更新。

1.5 功能说明：

  • 支持多表同时操作
  • 支持同时生成多个模板
  • 支持自定义模板
  • 支持自定义类型映射（支持正则）
  • 支持自定义附加列
  • 支持列附加属性
  • 所有配置项目支持分组模式，在不同项目（或选择不同数据库时），只需要切换对应的分组，所有配置统一变化

1.6 功能对比：

功能 Easy Code 其他工具
自定义模板 支持 支持
多表生成 支持 支持
生成方式 无缝集成在项目中 部分工具需要复制粘贴
附加列 支持 不支持
附加列属性 支持 不支持
动态调试模板 支持 不支持
图形化界面 支持 部分支持
使用环境 仅限IDEA 支持各种形式
在线支持 后期扩展 不支持
自定义类型映射 支持 部分支持
全局变量 支持 不支持

2.EasyCode使用

2.1 下载Easy Code插件

Mybatis-plus - 图14

2.2 创建一个SpringBoot项目

Mybatis-plus - 图15

2.3 配置数据源

使用Easy Code一定要使用IDEA自带的数据库工具来配置数据源

Mybatis-plus - 图16!

打开侧边的Database，查看效果

Mybatis-plus - 图17

提前准备的数据表

Mybatis-plus - 图18

2.4 自定义生成模板

Mybatis-plus - 图19

第一次安装EasyCode的时候默认的模板（服务于MyBatis）可以生成下面类型的代码

  1. entity.java
  2. dao.java
  3. service.java
  4. serviceImpl.java
  5. controller.java
  6. mapper.xml
  7. debug.json

2.5 以user表为例，根据你定义的模板生成代码，文章的最后贴出我使用的自定义的模板

Mybatis-plus - 图20

选择模板

Mybatis-plus - 图21

点击OK之后，就可以看到生成了这些代码

Mybatis-plus - 图22

2.6 代码展示

实体类层：User.java
  1. package com.godfrey.easycode.entity;
  3. import java.io.Serializable;
  5. /**
  6.  * (User)实体类
  7.  *
  8.  * @author godfrey
  9.  * @since 2020-04-20 19:21:17
  10.  */
  11. public class User implements Serializable {
  12.     private static final long serialVersionUID = 502672392114472688L;
  13.     /**
  14.      * 主键ID
  15.      */
  16.     private Integer id;
  17.     /**
  18.      * 姓名
  19.      */
  20.     private String name;
  21.     /**
  22.      * 年龄
  23.      */
  24.     private Integer age;
  25.     /**
  26.      * 邮箱
  27.      */
  28.     private String email;
  31.     public Integer getId() {
  32.         return id;
  33.     }
  35.     public void setId(Integer id) {
  36.         this.id = id;
  37.     }
  39.     public String getName() {
  40.         return name;
  41.     }
  43.     public void setName(String name) {
  44.         this.name = name;
  45.     }
  47.     public Integer getAge() {
  48.         return age;
  49.     }
  51.     public void setAge(Integer age) {
  52.         this.age = age;
  53.     }
  55.     public String getEmail() {
  56.         return email;
  57.     }
  59.     public void setEmail(String email) {
  60.         this.email = email;
  61.     }
  63.     @Override
  64.     public String toString() {
  65.         return "User{" +
  66.                 "id=" + id +
  67.                 "name=" + name +
  68.                 "age=" + age +
  69.                 "email=" + email +
  70.                 '}';
  71.     }
  72. }

Dao数据库访问层：UserDao.java
  1. package com.godfrey.easycode.dao;
  3. import com.godfrey.easycode.entity.User;
  4. import org.apache.ibatis.annotations.Mapper;
  6. import java.util.List;
  8. /**
  9.  * description : (User)表数据库访问层
  10.  *
  11.  * @author godfrey
  12.  * @since  2020-04-20 19:21:17
  13.  */
  14. @Mapper
  15. public interface UserDao {
  17.     /**
  18.      * description : 添加User
  19.      *
  20.      * @param user 实例对象
  21.      * @return 影响行数
  22.      * @author godfrey
  23.      * @since  2020-04-20 19:21:17
  24.      */
  25.     int insert(User user);
  27.     /**
  28.      * description : 删除User
  29.      *
  30.      * @param  id 主键
  31.      * @return 影响行数
  32.      * @author godfrey
  33.      * @since  2020-04-20 19:21:17
  34.      */
  35.     int deleteById(Integer id);
  37.     /**
  38.      * description : 通过ID查询单条数据
  39.      *
  40.      * @param  id 主键
  41.      * @return 实例对象
  42.      * @author godfrey
  43.      * @since  2020-04-20 19:21:17
  44.      */
  45.     User queryById(Integer id);
  47.     /**
  48.      * description : 查询全部数据(分页使用MyBatis的插件实现)
  49.      *
  50.      * @return 对象列表
  51.      * @author godfrey
  52.      * @since  2020-04-20 19:21:17
  53.      */
  54.     List<User> queryAll();
  56.     /**
  57.      * description : 实体作为筛选条件查询数据
  58.      *
  59.      * @param  user 实例对象
  60.      * @return 对象列表
  61.      * @author godfrey
  62.      * @since  2020-04-20 19:21:17
  63.      */
  64.     List<User> queryAll(User user);
  66.     /**
  67.      * description : 修改User
  68.      *
  69.      * @param  user 根据user的主键修改数据
  70.      * @return 影响行数
  71.      * @author godfrey
  72.      * @since  2020-04-20 19:21:17
  73.      */
  74.     int update(User user);
  75. }

Service服务接口层：UserService.java
  1. package com.godfrey.easycode.service;
  3. import com.godfrey.easycode.entity.User;
  4. import java.util.List;
  6. /**
  7.  * description : (User)表服务接口
  8.  *
  9.  * @author godfrey
  10.  * @since  2020-04-20 19:21:17
  11.  */
  12. public interface UserService {
  14.     /**
  15.      * description : 添加User
  16.      *
  17.      * @param  user 实例对象
  18.      * @return 是否成功
  19.      * @author godfrey
  20.      * @since  2020-04-20 19:21:17
  21.      */
  22.     boolean insert(User user);
  24.     /**
  25.      * description : 删除User
  26.      *
  27.      * @param  id 主键
  28.      * @return 是否成功
  29.      * @author godfrey
  30.      * @since  2020-04-20 19:21:17
  31.      */
  32.     boolean deleteById(Integer id);
  34.     /**
  35.      * description : 查询单条数据
  36.      * @param  id 主键
  37.      * @return 实例对象
  38.      * @author godfrey
  39.      * @since  2020-04-20 19:21:17
  40.      */
  41.     User queryById(Integer id);
  43.     /**
  44.      * description : 查询全部数据(分页使用MyBatis的插件实现)
  45.      *
  46.      * @return 对象列表
  47.      * @author godfrey
  48.      * @since  2020-04-20 19:21:17
  49.      */
  50.     List<User> queryAll();
  52.     /**
  53.      * description : 实体作为筛选条件查询数据
  54.      *
  55.      * @param  user 实例对象
  56.      * @return 对象列表
  57.      * @author godfrey
  58.      * @since  2020-04-20 19:21:17
  59.      */
  60.     List<User> queryAll(User user);
  62.     /**
  63.      * description : 修改数据，哪个属性不为空就修改哪个属性
  64.      *
  65.      * @param  user 实例对象
  66.      * @return 是否成功
  67.      * @author godfrey
  68.      * @since  2020-04-20 19:21:17
  69.      */
  70.     boolean update(User user);
  71. }

ServiceImpl服务接口实现层：UserServiceImpl.java
  1. package com.godfrey.easycode.service.impl;
  3. import com.godfrey.easycode.entity.User;
  4. import com.godfrey.easycode.dao.UserDao;
  5. import com.godfrey.easycode.service.UserService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  9. import java.util.List;
  11.  /**
  12.   * description : (User)表服务实现类
  13.   *
  14.   * @author godfrey
  15.   * @since  2020-04-20 19:21:17
  16.   **/
  17. @Service("userService")
  18. public class UserServiceImpl implements UserService {
  20.     @Autowired
  21.     protected UserDao userDao;
  23.     /**
  24.      * description : 添加User
  25.      *
  26.      * @param  user 实例对象
  27.      * @return 是否成功
  28.      * @author godfrey
  29.      * @since  2020-04-20 19:21:17
  30.      */
  31.     @Override
  32.     public boolean insert(User user) {
  33.         return userDao.insert(user) == 1;
  34.     }
  36.     /**
  37.      * description : 删除User
  38.      *
  39.      * @param  id 主键
  40.      * @return 是否成功
  41.      * @author godfrey
  42.      * @since  2020-04-20 19:21:17
  43.      */
  44.     @Override
  45.     public boolean deleteById(Integer id) {
  46.         return userDao.deleteById(id) == 1;
  47.     }
  49.     /**
  50.      * description : 查询单条数据
  51.      *
  52.      * @param  id 主键
  53.      * @return 实例对象
  54.      * @author godfrey
  55.      * @since  2020-04-20 19:21:17
  56.      */
  57.     @Override
  58.     public User queryById(Integer id) {
  59.         return userDao.queryById(id);
  60.     }
  62.     /**
  63.      * description : 查询全部数据(分页使用MyBatis的插件实现)
  64.      *
  65.      * @return 对象列表
  66.      * @author godfrey
  67.      * @since  2020-04-20 19:21:17
  68.      */
  69.     @Override
  70.     public List<User> queryAll() {
  71.         return userDao.queryAll();
  72.     }
  74.     /**
  75.      * description : 实体作为筛选条件查询数据
  76.      *
  77.      * @param user 实例对象
  78.      * @return 对象列表
  79.      * @author godfrey
  80.      * @since  2020-04-20 19:21:17
  81.      */
  82.     @Override
  83.     public List<User> queryAll(User user) {
  84.         return userDao.queryAll(user);
  85.     }
  87.     /**
  88.      * description : 修改数据，哪个属性不为空就修改哪个属性
  89.      *
  90.      * @param user 实例对象
  91.      * @return 是否成功
  92.      * @author godfrey
  93.      * @since  2020-04-20 19:21:17
  94.      */
  95.     @Override
  96.     public boolean update(User user) {
  97.         return userDao.update(user) == 1;
  98.     }
  99. }

前端控制器：UserController.java
  1. package com.godfrey.easycode.controller;
  3. import com.godfrey.easycode.entity.User;
  4. import com.godfrey.easycode.service.UserService;
  5. import org.springframework.web.bind.annotation.*;
  7. import javax.annotation.Resource;
  9. /**
  10.  * description : (User)表控制层
  11.  *
  12.  * @author godfrey
  13.  * @since  2020-04-20 19:21:17
  14.  */
  15. @RestController
  16. @RequestMapping("user")
  17. public class UserController {
  18.     /**
  19.      * 服务对象
  20.      */
  21.     @Resource
  22.     private UserService userService;
  24.     /**
  25.      * description : 通过主键查询单条数据
  26.      *
  27.      * @param  id 主键
  28.      * @return 单条数据
  29.      * @author godfrey
  30.      * @since  2020-04-20 19:21:17
  31.      */
  32.     @GetMapping("selectOne")
  33.     public User selectOne(Integer id) {
  34.         return this.userService.queryById(id);
  35.     }
  36. }

Mapper映射文件：UserMapper.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  3. <mapper namespace="com.godfrey.easycode.dao.UserDao">
  5.     <!--user的映射结果集-->
  6.     <resultMap type="com.godfrey.easycode.entity.User" id="UserMap">
  7.         <result property="id" column="id" jdbcType="INTEGER"/>
  8.         <result property="name" column="name" jdbcType="VARCHAR"/>
  9.         <result property="age" column="age" jdbcType="INTEGER"/>
  10.         <result property="email" column="email" jdbcType="VARCHAR"/>
  11.     </resultMap>
  13.     <!--全部字段-->
  14.     <sql id="allColumn"> id, name, age, email </sql>
  16.     <!--添加语句的字段列表-->
  17.     <sql id="insertColumn">
  18.         <if test="name != null and name != ''">
  19.             name,
  20.         </if>
  21.         <if test="age != null">
  22.             age,
  23.         </if>
  24.         <if test="email != null and email != ''">
  25.             email,
  26.         </if>
  27.     </sql>
  29.     <!--添加语句的值列表-->
  30.     <sql id="insertValue">
  31.         <if test="name != null and name != ''">
  32.             #{name},
  33.         </if>
  34.         <if test="age != null">
  35.             #{age},
  36.         </if>
  37.         <if test="email != null and email != ''">
  38.             #{email},
  39.         </if>
  40.     </sql>
  42.     <!--通用对User各个属性的值的非空判断-->
  43.     <sql id="commonsValue">
  44.         <if test="name != null and name != ''">
  45.             name = #{name},
  46.         </if>
  47.         <if test="age != null">
  48.             age = #{age},
  49.         </if>
  50.         <if test="email != null and email != ''">
  51.             email = #{email},
  52.         </if>
  53.     </sql>
  55.     <!--新增user:哪个字段不为空就添加哪列数据,返回自增主键-->
  56.     <insert id="insert" keyProperty="id" useGeneratedKeys="true">
  57.         insert into user
  58.         <trim prefix="(" suffix=")" suffixOverrides=",">
  59.             <include refid="insertColumn"/>
  60.         </trim>
  61.         <trim prefix="values (" suffix=")" suffixOverrides=",">
  62.             <include refid="insertValue"/>
  63.         </trim>
  64.     </insert>
  66.     <!--删除user:通过主键-->
  67.     <delete id="deleteById">
  68.         delete from user
  69.         <where>
  70.             id = #{id}
  71.         </where>
  72.     </delete>
  74.     <!--查询单个user-->
  75.     <select id="queryById" resultMap="UserMap">
  76.         select
  77.         <include refid="allColumn"></include>
  78.         from user
  79.         <where>
  80.             id = #{id}
  81.         </where>
  82.     </select>
  84.     <!--通过实体作为筛选条件查询-->
  85.     <select id="queryAll" resultMap="UserMap">
  86.         select
  87.         <include refid="allColumn"></include>
  88.         from user
  89.         <trim prefix="where" prefixOverrides="and" suffixOverrides=",">
  90.             <include refid="commonsValue"></include>
  91.         </trim>
  92.     </select>
  94.     <!--通过主键修改数据-->
  95.     <update id="update">
  96.         update user
  97.         <set>
  98.             <include refid="commonsValue"></include>
  99.         </set>
  100.         <where>
  101.             id = #{id}
  102.         </where>
  103.     </update>
  104. </mapper>

以上代码完全是生成出来了，从头到尾只需要点几下鼠标，是不是很神奇！

3.我的默认定制模板

entity.java

  1. ##引入宏定义
  2. $!define
  4. ##使用宏定义设置回调（保存位置与文件后缀）
  5. #save("/entity", ".java")
  7. ##使用宏定义设置包后缀
  8. #setPackageSuffix("entity")
  10. ##使用全局变量实现默认包导入
  11. $!autoImport
  12. import java.io.Serializable;
  14. ##使用宏定义实现类注释信息
  15. #tableComment("实体类")
  16. public class $!{tableInfo.name} implements Serializable {
  17.     private static final long serialVersionUID = $!tool.serial();
  18. #foreach($column in $tableInfo.fullColumn)
  19.     #if(${column.comment})/**
  20.      * ${column.comment}
  21.      */#end
  23.     private $!{tool.getClsNameByFullName($column.type)} $!{column.name};
  24. #end
  26. #foreach($column in $tableInfo.fullColumn)
  27.     ##使用宏定义实现get,set方法
  28.     #getSetMethod($column)
  29. #end
  31.     @Override
  32.     public String toString() {
  33.         return "$!{tableInfo.name}{" +
  34.     #foreach($column in $tableInfo.fullColumn)
  35.             "$!{column.name}=" + $!{column.name} +
  36.     #end
  37.             '}';
  38.     }
  39. }

dao.java

  1. ##定义初始变量
  2. #set($tableName = $tool.append($tableInfo.name, "Dao"))
  3. ##设置回调
  4. $!callback.setFileName($tool.append($tableName, ".java"))
  5. $!callback.setSavePath($tool.append($tableInfo.savePath, "/dao"))
  7. ##拿到主键
  8. #if(!$tableInfo.pkColumn.isEmpty())
  9.     #set($pk = $tableInfo.pkColumn.get(0))
  10. #end
  12. #if($tableInfo.savePackageName)package $!{tableInfo.savePackageName}.#{end}dao;
  14. import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};
  15. import org.apache.ibatis.annotations.Mapper;
  17. import java.util.List;
  19. /**
  20.  * description : $!{tableInfo.comment}($!{tableInfo.name})表数据库访问层
  21.  *
  22.  * @author $!author
  23.  * @since  $!time.currTime()
  24.  */
  25. @Mapper
  26. public interface $!{tableName} {
  28.     /**
  29.      * description : 添加$!{tableInfo.name}
  30.      *
  31.      * @param $!tool.firstLowerCase($!{tableInfo.name}) 实例对象
  32.      * @return 影响行数
  33.      * @author $!author
  34.      * @since  $!time.currTime()
  35.      */
  36.     int insert($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
  38.     /**
  39.      * description : 删除$!{tableInfo.name}
  40.      *
  41.      * @param  $!pk.name 主键
  42.      * @return 影响行数
  43.      * @author $!author
  44.      * @since  $!time.currTime()
  45.      */
  46.     int deleteById($!pk.shortType $!pk.name);
  48.     /**
  49.      * description : 通过ID查询单条数据
  50.      *
  51.      * @param  $!pk.name 主键
  52.      * @return 实例对象
  53.      * @author $!author
  54.      * @since  $!time.currTime()
  55.      */
  56.     $!{tableInfo.name} queryById($!pk.shortType $!pk.name);
  58.     /**
  59.      * description : 查询全部数据(分页使用MyBatis的插件实现)
  60.      *
  61.      * @return 对象列表
  62.      * @author $!author
  63.      * @since  $!time.currTime()
  64.      */
  65.     List<$!{tableInfo.name}> queryAll();
  67.     /**
  68.      * description : 实体作为筛选条件查询数据
  69.      *
  70.      * @param  $!tool.firstLowerCase($!{tableInfo.name}) 实例对象
  71.      * @return 对象列表
  72.      * @author $!author
  73.      * @since  $!time.currTime()
  74.      */
  75.     List<$!{tableInfo.name}> queryAll($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
  77.     /**
  78.      * description : 修改$!{tableInfo.name}
  79.      *
  80.      * @param  user 根据$!tool.firstLowerCase($!{tableInfo.name})的主键修改数据
  81.      * @return 影响行数
  82.      * @author $!author
  83.      * @since  $!time.currTime()
  84.      */
  85.     int update($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
  86. }

service.java

  1. ##定义初始变量
  2. #set($tableName = $tool.append($tableInfo.name, "Service"))
  3. ##设置回调
  4. $!callback.setFileName($tool.append($tableName, ".java"))
  5. $!callback.setSavePath($tool.append($tableInfo.savePath, "/service"))
  7. ##拿到主键
  8. #if(!$tableInfo.pkColumn.isEmpty())
  9.     #set($pk = $tableInfo.pkColumn.get(0))
  10. #end
  12. #if($tableInfo.savePackageName)package $!{tableInfo.savePackageName}.#{end}service;
  14. import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};
  15. import java.util.List;
  17. /**
  18.  * description : $!{tableInfo.comment}($!{tableInfo.name})表服务接口
  19.  *
  20.  * @author $!author
  21.  * @since  $!time.currTime()
  22.  */
  23. public interface $!{tableName} {
  25.     /**
  26.      * description : 添加$!{tableInfo.name}
  27.      *
  28.      * @param  $!tool.firstLowerCase($!{tableInfo.name}) 实例对象
  29.      * @return 是否成功
  30.      * @author $!author
  31.      * @since  $!time.currTime()
  32.      */
  33.     boolean insert($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
  35.     /**
  36.      * description : 删除$!{tableInfo.name}
  37.      *
  38.      * @param  $!pk.name 主键
  39.      * @return 是否成功
  40.      * @author $!author
  41.      * @since  $!time.currTime()
  42.      */
  43.     boolean deleteById($!pk.shortType $!pk.name);
  45.     /**
  46.      * description : 查询单条数据
  47.      * @param  $!pk.name 主键
  48.      * @return 实例对象
  49.      * @author $!author
  50.      * @since  $!time.currTime()
  51.      */
  52.     $!{tableInfo.name} queryById($!pk.shortType $!pk.name);
  54.     /**
  55.      * description : 查询全部数据(分页使用MyBatis的插件实现)
  56.      *
  57.      * @return 对象列表
  58.      * @author $!author
  59.      * @since  $!time.currTime()
  60.      */
  61.     List<$!{tableInfo.name}> queryAll();
  63.     /**
  64.      * description : 实体作为筛选条件查询数据
  65.      *
  66.      * @param  $!tool.firstLowerCase($!{tableInfo.name}) 实例对象
  67.      * @return 对象列表
  68.      * @author $!author
  69.      * @since  $!time.currTime()
  70.      */
  71.     List<$!{tableInfo.name}> queryAll($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
  73.     /**
  74.      * description : 修改数据，哪个属性不为空就修改哪个属性
  75.      *
  76.      * @param  $!tool.firstLowerCase($!{tableInfo.name}) 实例对象
  77.      * @return 是否成功
  78.      * @author $!author
  79.      * @since  $!time.currTime()
  80.      */
  81.     boolean update($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name}));
  82. }

serviceImpl.java

  1. ##定义初始变量
  2. #set($tableName = $tool.append($tableInfo.name, "ServiceImpl"))
  3. ##设置回调
  4. $!callback.setFileName($tool.append($tableName, ".java"))
  5. $!callback.setSavePath($tool.append($tableInfo.savePath, "/service/impl"))
  7. ##拿到主键
  8. #if(!$tableInfo.pkColumn.isEmpty())
  9.     #set($pk = $tableInfo.pkColumn.get(0))
  10. #end
  12. #if($tableInfo.savePackageName)package $!{tableInfo.savePackageName}.#{end}service.impl;
  14. import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};
  15. import $!{tableInfo.savePackageName}.dao.$!{tableInfo.name}Dao;
  16. import $!{tableInfo.savePackageName}.service.$!{tableInfo.name}Service;
  17. import org.springframework.beans.factory.annotation.Autowired;
  18. import org.springframework.stereotype.Service;
  20. import java.util.List;
  22.  /**
  23.   * description : $!{tableInfo.comment}($!{tableInfo.name})表服务实现类
  24.   *
  25.   * @author $!author
  26.   * @since  $!time.currTime()
  27.   **/
  28. @Service("$!tool.firstLowerCase($!{tableInfo.name})Service")
  29. public class $!{tableName} implements $!{tableInfo.name}Service {
  31.     @Autowired
  32.     protected $!{tableInfo.name}Dao $!tool.firstLowerCase($!{tableInfo.name})Dao;
  34.     /**
  35.      * description : 添加$!{tableInfo.name}
  36.      *
  37.      * @param  $!tool.firstLowerCase($!{tableInfo.name}) 实例对象
  38.      * @return 是否成功
  39.      * @author $!author
  40.      * @since  $!time.currTime()
  41.      */
  42.     @Override
  43.     public boolean insert($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
  44.         return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.insert($!tool.firstLowerCase($!{tableInfo.name})) == 1;
  45.     }
  47.     /**
  48.      * description : 删除$!{tableInfo.name}
  49.      *
  50.      * @param  $!pk.name 主键
  51.      * @return 是否成功
  52.      * @author $!author
  53.      * @since  $!time.currTime()
  54.      */
  55.     @Override
  56.     public boolean deleteById($!pk.shortType $!pk.name) {
  57.         return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.deleteById($!pk.name) == 1;
  58.     }
  60.     /**
  61.      * description : 查询单条数据
  62.      *
  63.      * @param  $!pk.name 主键
  64.      * @return 实例对象
  65.      * @author $!author
  66.      * @since  $!time.currTime()
  67.      */
  68.     @Override
  69.     public $!{tableInfo.name} queryById($!pk.shortType $!pk.name) {
  70.         return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.queryById($!pk.name);
  71.     }
  73.     /**
  74.      * description : 查询全部数据(分页使用MyBatis的插件实现)
  75.      *
  76.      * @return 对象列表
  77.      * @author $!author
  78.      * @since  $!time.currTime()
  79.      */
  80.     @Override
  81.     public List<$!{tableInfo.name}> queryAll() {
  82.         return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.queryAll();
  83.     }
  85.     /**
  86.      * description : 实体作为筛选条件查询数据
  87.      *
  88.      * @param $!tool.firstLowerCase($!{tableInfo.name}) 实例对象
  89.      * @return 对象列表
  90.      * @author $!author
  91.      * @since  $!time.currTime()
  92.      */
  93.     @Override
  94.     public List<$!{tableInfo.name}> queryAll($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
  95.         return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.queryAll($!tool.firstLowerCase($!{tableInfo.name}));
  96.     }
  98.     /**
  99.      * description : 修改数据，哪个属性不为空就修改哪个属性
  100.      *
  101.      * @param $!tool.firstLowerCase($!{tableInfo.name}) 实例对象
  102.      * @return 是否成功
  103.      * @author $!author
  104.      * @since  $!time.currTime()
  105.      */
  106.     @Override
  107.     public boolean update($!{tableInfo.name} $!tool.firstLowerCase($!{tableInfo.name})) {
  108.         return $!{tool.firstLowerCase($!{tableInfo.name})}Dao.update($!tool.firstLowerCase($!{tableInfo.name})) == 1;
  109.     }
  110. }

controller.java

  1. ##定义初始变量
  2. #set($tableName = $tool.append($tableInfo.name, "Controller"))
  3. ##设置回调
  4. $!callback.setFileName($tool.append($tableName, ".java"))
  5. $!callback.setSavePath($tool.append($tableInfo.savePath, "/controller"))
  6. ##拿到主键
  7. #if(!$tableInfo.pkColumn.isEmpty())
  8.     #set($pk = $tableInfo.pkColumn.get(0))
  9. #end
  11. #if($tableInfo.savePackageName)package $!{tableInfo.savePackageName}.#{end}controller;
  13. import $!{tableInfo.savePackageName}.entity.$!{tableInfo.name};
  14. import $!{tableInfo.savePackageName}.service.$!{tableInfo.name}Service;
  15. import org.springframework.web.bind.annotation.*;
  17. import javax.annotation.Resource;
  19. /**
  20.  * description : $!{tableInfo.comment}($!{tableInfo.name})表控制层
  21.  *
  22.  * @author $!author
  23.  * @since  $!time.currTime()
  24.  */
  25. @RestController
  26. @RequestMapping("$!tool.firstLowerCase($tableInfo.name)")
  27. public class $!{tableName} {
  28.     /**
  29.      * 服务对象
  30.      */
  31.     @Resource
  32.     private $!{tableInfo.name}Service $!tool.firstLowerCase($tableInfo.name)Service;
  34.     /**
  35.      * description : 通过主键查询单条数据
  36.      *
  37.      * @param  id 主键
  38.      * @return 单条数据
  39.      * @author $!author
  40.      * @since  $!time.currTime()
  41.      */
  42.     @GetMapping("selectOne")
  43.     public $!{tableInfo.name} selectOne($!pk.shortType id) {
  44.         return this.$!{tool.firstLowerCase($tableInfo.name)}Service.queryById(id);
  45.     }
  46. }

mapper.xml

  1. ##引入mybatis支持
  2. $!mybatisSupport
  4. ##设置保存名称与保存位置
  5. $!callback.setFileName($tool.append($!{tableInfo.name}, "Dao.xml"))
  6. $!callback.setSavePath($tool.append($modulePath, "/src/main/resources/mybatis/mapper"))
  8. ##拿到主键
  9. #if(!$tableInfo.pkColumn.isEmpty())
  10.     #set($pk = $tableInfo.pkColumn.get(0))
  11. #end
  13. <?xml version="1.0" encoding="UTF-8"?>
  14. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  15. <mapper namespace="$!{tableInfo.savePackageName}.dao.$!{tableInfo.name}Dao">
  17.     <!--$!{tableInfo.obj.name}的映射结果集-->
  18.     <resultMap type="$!{tableInfo.savePackageName}.entity.$!{tableInfo.name}" id="$!{tableInfo.name}Map">
  19. #foreach($column in $tableInfo.fullColumn)
  20.         <result property="$!column.name" column="$!column.obj.name" jdbcType="$!column.ext.jdbcType"/>
  21. #end
  22.     </resultMap>
  24.     <!--全部字段-->
  25.     <sql id="allColumn"> #allSqlColumn() </sql>
  27.     <!--添加语句的字段列表-->
  28.     <sql id="insertColumn">
  29. #foreach($column in $tableInfo.otherColumn)
  30.         <if test="$!column.name != null#if($column.type.equals("java.lang.String")) and $!column.name != ''#end">
  31.             $!column.obj.name,
  32.         </if>
  33. #end
  34.     </sql>
  36.     <!--添加语句的值列表-->
  37.     <sql id="insertValue">
  38. #foreach($column in $tableInfo.otherColumn)
  39.         <if test="$!column.name != null#if($column.type.equals("java.lang.String")) and $!column.name != ''#end">
  40.             #{$!column.name},
  41.         </if>
  42. #end
  43.     </sql>
  45.     <!--通用对$!{tableInfo.name}各个属性的值的非空判断-->
  46.     <sql id="commonsValue">
  47. #foreach($column in $tableInfo.otherColumn)
  48.         <if test="$!column.name != null#if($column.type.equals("java.lang.String")) and $!column.name != ''#end">
  49.             $!column.obj.name = #{$!column.name},
  50.         </if>
  51. #end
  52.     </sql>
  54.     <!--新增$!{tableInfo.obj.name}:哪个字段不为空就添加哪列数据,返回自增主键-->
  55.     <insert id="insert" keyProperty="$!pk.name" useGeneratedKeys="true">
  56.         insert into $!{tableInfo.obj.name}
  57.         <trim prefix="(" suffix=")" suffixOverrides=",">
  58.             <include refid="insertColumn"/>
  59.         </trim>
  60.         <trim prefix="values (" suffix=")" suffixOverrides=",">
  61.             <include refid="insertValue"/>
  62.         </trim>
  63.     </insert>
  65.     <!--删除$!{tableInfo.obj.name}:通过主键-->
  66.     <delete id="deleteById">
  67.         delete from $!{tableInfo.obj.name}
  68.         <where>
  69.             $!pk.obj.name = #{$!pk.name}
  70.         </where>
  71.     </delete>
  73.     <!--查询单个$!{tableInfo.obj.name}-->
  74.     <select id="queryById" resultMap="$!{tableInfo.name}Map">
  75.         select
  76.         <include refid="allColumn"></include>
  77.         from $!tableInfo.obj.name
  78.         <where>
  79.             $!pk.obj.name = #{$!pk.name}
  80.         </where>
  81.     </select>
  83.     <!--通过实体作为筛选条件查询-->
  84.     <select id="queryAll" resultMap="$!{tableInfo.name}Map">
  85.         select
  86.         <include refid="allColumn"></include>
  87.         from $!tableInfo.obj.name
  88.         <trim prefix="where" prefixOverrides="and" suffixOverrides=",">
  89.             <include refid="commonsValue"></include>
  90.         </trim>
  91.     </select>
  93.     <!--通过主键修改数据-->
  94.     <update id="update">
  95.         update $!{tableInfo.obj.name}
  96.         <set>
  97.             <include refid="commonsValue"></include>
  98.         </set>
  99.         <where>
  100.             $!pk.obj.name = #{$!pk.name}
  101.         </where>
  102.     </update>
  103. </mapper>

新创建一个分组Lombok，可以在生成实体类的时候使用Lombok注解

Mybatis-plus - 图23

Mybatis-plus - 图24

实体类层：entity.java

  1. ##引入宏定义
  2. $!define
  4. ##使用宏定义设置回调（保存位置与文件后缀）
  5. #save("/entity", ".java")
  7. ##使用宏定义设置包后缀
  8. #setPackageSuffix("entity")
  10. ##使用全局变量实现默认包导入
  11. $!autoImport
  12. import java.io.Serializable;
  13. import lombok.AllArgsConstructor;
  14. import lombok.Builder;
  15. import lombok.Data;
  17. ##使用宏定义实现类注释信息
  18. #tableComment("实体类")
  19. @AllArgsConstructor
  20. @Data
  21. @Builder
  22. public class $!{tableInfo.name} implements Serializable {
  23.     private static final long serialVersionUID = $!tool.serial();
  24. #foreach($column in $tableInfo.fullColumn)
  25.     #if(${column.comment})/**
  26.     * ${column.comment}
  27.     */#end
  29.     private $!{tool.getClsNameByFullName($column.type)} $!{column.name};
  30. #end
  31. }

多个分组的切换

选择好分组后，点击OK，之后在Datebase视图的数据表右键选择EasyCode生成的时候会让你选择当前分组的模板

Mybatis-plus - 图25
Mybatis-plus - 图26
Mybatis-plus - 图27
Mybatis-plus - 图28

转自：https://www.yuque.com/fm98/mybatis/kcgfhl