Mybatis && Mybatis-plus

本文转载自查看原文 2019-10-23 18:06 551 Mybatis&&Mybatis-plus

导读：

我感觉mybatis-plus的出现是真的挺nice的，无论是配置还是使用都是那么的令人神往，在配置上与mybatis其实并没有多大的区别，可能这就是partner吧。它独有的单表操作，分页自带插件，代码生成器，条件构造器这些强大的功能扩展其实还是很贴合大部分人的口味的。

文章结构：

1. mybatis

2. mybatis-plus

3. 总结

Mybatis:

1.依赖包：

(1)spring：

1         <dependency>
2             <groupId>org.mybatis</groupId>
3             <artifactId>mybatis</artifactId>
4             <version>3.5.2</version>
5         </dependency>

1         <dependency>
2             <groupId>org.mybatis</groupId>
3             <artifactId>mybatis-spring</artifactId>
4             <version>1.3.2</version>
5         </dependency>

(2)spring boot:

1         <dependency>
2             <groupId>org.mybatis.spring.boot</groupId>
3             <artifactId>mybatis-spring-boot-starter</artifactId>
4             <version>2.1.0</version>
5         </dependency>

2.配置：

(1)spring:

新建一个mybatis的l配置文件mybatis-config.xml，用于mybatis基本信息的配置：

 1 <?xml version="1.0" encoding="UTF-8" ?>
 2 <!DOCTYPE configuration
 3         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
 4         "http://mybatis.org/dtd/mybatis-3-config.dtd">
 5 
 6 <configuration>
 7 
 8     <!--加载数据库配置文件-->
 9     <properties resource="db.properties"/>
10 
11     <!--常用设置-->
12     <settings>
13         <!-- 懒加载。如果设为‘false'，则所有相关联的都会被初始化加载。 -->
14         <setting name="lazyLoadingEnabled" value="true"/>
15         <!-- 当设置为‘true'的时候，懒加载的对象可能被任何懒属性全部加载。否则，每个属性都按需加载。 -->
16         <setting name="aggressiveLazyLoading" value="false"/>
17         <!--日志信息打印-->
18         <setting name="logImpl" value="STDOUT_LOGGING"/>
19         <!--缓存设置-->
20         <setting name="cacheEnabled" value="true"/>
21         <!--驼峰命名-->
22         <setting name="mapUnderscoreToCamelCase" value="true"/>
23     </settings>
24 
25     <!--别名设置-->
26     <typeAliases>
27         <package name="com.wsw.entity"/>
28     </typeAliases>
29 
30     <!--插件配置-->
31     <plugins>
32         <plugin interceptor=""></plugin>
33     </plugins>
34 
35     <!--环境配置-->
36     <environments default="">
37         <environment id="">
38             <!--事务管理-->
39             <transactionManager type="">
40                 <property name="" value=""/>
41             </transactionManager>
42             <!--数据源配置-->
43             <dataSource type="">
44                 <property name="" value=""/>
45                 <property name="" value=""/>
46             </dataSource>
47         </environment>
48     </environments>
49 
50     <!--映射文件配置:下面三种方式可随机采用其中一种-->
51     <mappers>
52         <!--相对路径文件映射-->
53         <mapper resource=""/>
54         <!--绝对路径文件映射-->
55         <mapper url=""/>
56         <!--包映射-->
57         <package name=""/>
58     </mappers>
59 
60 </configuration>

在spring的配置文件applicationContext.xml中配置mybatis的sqlSessionFactory，同时加载mybatis的配置文件:

1 <!-- 配置sqlSessionFactory，SqlSessionFactoryBean是用来产生sqlSessionFactory的 -->
2     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
3         <!-- 加载mybatis的全局配置文件 -->
4         <property name="configLocation" value="classpath:mybatis-config.xml"/>
5     </bean>

(2)spring boot(yaml):

在spring boot的全局配置文件application.yaml中配置mybatis相关属性：

 1 mybatis-plus:
 2   #别名设置
 3   type-aliases-package: com.wsw.springboot.entity 6   #映射文件扫描
 7   #mapper-locations:
 8   configuration:
 9     #懒加载设置
10     lazy-loading-enabled: true
11     #日志打印
12     #log-impl:
13     #驼峰命名
14     map-underscore-to-camel-case: true
15     #缓存设置
16     cache-enabled: true
17     #主键自动生成并获取
18     use-generated-keys: true

3.使用：

实体类：User->School->Page

 1 @Data
 2 @ToString
 3 @AllArgsConstructor
 4 @NoArgsConstructor
 5 public class User {
 6     /**
 7      * 用户编号
 8      */
 9     private int uId;
10     /**
11      * 用户姓名
12      */
13     private String uName;
14     /**
15      * 用户性别
16      */
17     private int uSex;
18     /**
19      * 用户年龄
20      */
21     private int uAge;
22     /**
23      * 用户身份证
24      */
25     private String uIdentity;
26     /**
27      * 用户出生日期
28      */
29     private Timestamp uBirth;
30     /**
31      * 关联学校：1:1
32      */
33     private School school;
34 }

 1 @AllArgsConstructor
 2 @NoArgsConstructor
 3 @Data
 4 @ToString
 5 public class School {
 6     /**
 7      * 学校编号
 8      */
 9     private int schoolId;
10     /**
11      * 学校名称
12      */
13     private String schoolName;
14     /**
15      * 学校面积
16      */
17     private double schoolSize;
18     /**
19      * 一对多
20      */
21     List<User> userList;
22 }

 1 @Data
 2 @AllArgsConstructor
 3 @NoArgsConstructor
 4 @ToString
 5 public class Page<T> {
 6 
 7     /**
 8      * 当前页号
 9      */
10     private int pageNo;
11     /**
12      * 当前页面大小
13      */
14     private int pageSize;
15     /**
16      * 总记录数
17      */
18     private int totalCount;
19     /**
20      * 总页数
21      */
22     private int totalPage;
23     /**
24      * 每页的显示的数据
25      */
26     private List<User> lists;
27 
28 }

dao层接口：UserDao->SchoolDao

 1 @Repository
 2 public interface UserDao {
 3 
 4     /**
 5      * 查看所有用户
 6      * @return
 7      */
 8     List<User> selectAll();
 9 
10     /**
11      * 插入一条用户记录
12      * @param user
13      */
14     void insertOne(User user);
15 
16     /**
17      * 分页查询
18      * @param pageNum:偏移量，代表从第pageNum+1的位置开始取记录
19      * @param pageCount:取记录的总数
20      * @return
21      */
22     List<User> selectByPageNo(@Param("pageNum") int pageNum, @Param("pageCount") int pageCount);
23 
24     /**
25      * 查询所有记录数
26      * @return
27      */
28     int selectTotalCount();
29 
30 }

 1 @Repository
 2 public interface SchoolDao {
 3     /**
 4      * 查看所有的学校信息
 5      * @return
 6      */
 7     List<School> selectAllSchool();
 8 
 9     /**
10      * 模糊查询-like关键字使用
11      * @param sName
12      * @return
13      */
14     List<School> selectLikeParam(@Param(value = "sName") String sName);
15 
16     /**
17      * 条件查询-if,where等条件使用
18      * @param min
19      * @param max
20      * @return
21      */
22     List<School> selectInAverage(@Param(value = "min") double min, @Param("max") double max);
23 }

service层：UserService->UserServiceImpl ->SchoolService->SchoolServiceImpl

 1 public interface UserService {
 2     /**
 3      * 查询所有用户
 4      * @return
 5      */
 6     List<User> getAll();
 7 
 8     /**
 9      * 创建一条用户记录
10      * @param user
11      */
12     void createOne(User user);
13 
14     /**
15      * 分页显示用户记录
16      * @param pageNum
17      * @param pageCount
18      * @return
19      */
20     Page<User> selectByPage(int pageNum, int pageCount);
21 
22 }

 1 @Service("userService")
 2 @Transactional
 3 public class UserServiceImpl implements UserService {
 4 
 5     @Autowired
 6     private UserDao userDao;
 7 
 8     @Override
 9     public List<User> getAll() {
10         return  userDao.selectAll();
11     }
12 
13     @Override
14     public void createOne(User user) {
15         userDao.insertOne(user);
16     }
17 
18     @Override
19     public Page<User> selectByPage(int pageNum, int pageCount) {
20         Page<User> page = new Page<User>();
21         //设置总记录数
22         page.setTotalCount(userDao.selectTotalCount());
23         //设置每一页显示的记录数
24         page.setPageSize(pageCount);
25         //设置当前总页数:如果当前的总记录数能够整除每一页的页面记录数大小，则总页数为除后结果
26         if ((page.getTotalCount() - pageNum) % page.getPageSize() == 0) {
27             page.setTotalPage((page.getTotalCount() - pageNum) / page.getPageSize());
28         } else {
29             //否则为结果加一
30             page.setTotalPage(((page.getTotalCount() - pageNum) / page.getPageSize()) + 1);
31         }
32         //总记录数小于每页要求记录数时默认为1
33         if (page.getTotalCount() < page.getPageSize()) {
34             page.setTotalPage(1);
35         }
36         page.setLists(userDao.selectByPageNo(pageNum, pageCount));
37         return page;
38     }
39 
40 }

 1 public interface SchoolService {
 2     /**
 3      * 查看所有学校记录
 4      * @return
 5      */
 6     List<School> getAll();
 7 
 8     /**
 9      * 模糊查询:like关键字使用
10      * @param sName
11      * @return
12      */
13     List<School> useLike(String sName);
14 
15     /**
16      * 条件查询
17      * @param min
18      * @param max
19      * @return
20      */
21     List<School> useConditions(double min,double max);
22 }

 1 @Service("schoolService")
 2 @Transactional
 3 public class SchoolServiceImpl implements SchoolService {
 4 
 5     @Autowired
 6     private SchoolDao schoolDao;
 7 
 8     @Override
 9     public List<School> getAll() {
10         return schoolDao.selectAllSchool();
11     }
12 
13     @Override
14     public List<School> useLike(String sName) {
15         return schoolDao.selectLikeParam(sName);
16     }
17 
18     @Override
19     public List<School> useConditions(double min, double max) {
20         return schoolDao.selectInAverage(min, max);
21     }
22 }

映射文件：user-mapper.xml->school-mapper.xml

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
 3         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 4 
 5 <mapper namespace="com.sunsharing.dao.UserDao">
 6 
 7     <!--一对一关联嵌套查询-->
 8     <resultMap id="asossiateWithSchool" type="user">
 9         <id property="uId" column="u_id"/>
10         <result property="uName" column="u_name"/>
11         <result property="uSex" column="u_sex"/>
12         <result property="uAge" column="u_age"/>
13         <result property="uBirth" column="u_birth"/>
14         <association property="school" javaType="school" column="school_id" select="selectSchool"/>
15     </resultMap>
16 
17     <select id="selectAll" resultMap="asossiateWithSchool">
18       select *from `user`
19     </select>
20 
21     <select id="selectSchool" resultType="school">
22          select *from `user` u,school s where u.school_id=s.school_id and u_id=#{uId}
23     </select>
24     <!--插入一条记录，允许主键自增，获取主键-->
25     <insert id="insertOne" parameterType="user" useGeneratedKeys="true">
26       INSERT INTO `react`.`user`
27      (`u_id`, `u_name`, `u_sex`, `u_age`, `u_identity`, `u_birth`)
28       VALUES
29      (#{uId}, #{uName},#{uSex}, #{uAge}, #{uIdentity}, #{uBirth})
30     </insert>
31 
32     <!--传入参数包含多个-->
33     <parameterMap id="parameters" type="int">
34         <parameter property="pageNum" javaType="int"/>
35         <parameter property="pageCount" javaType="int"/>
36     </parameterMap>
37 
38     <select id="selectByPageNo" parameterMap="parameters" resultType="user">
39         select *from `user` limit #{pageNum},#{pageCount}
40     </select>
41 
42     <select id="selectTotalCount" resultType="int">
43         select count(0) from `user`
44     </select>
45 
46 </mapper>

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD mapper 3.0//EN"
 3         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
 4 
 5 <mapper namespace="com.sunsharing.dao.SchoolDao">
 6 
 7     <!--嵌套查询，包含多对一的关系-->
 8     <resultMap id="assosiateWithUser" type="school">
 9         <id property="schoolId" column="school_id"/>
10         <result property="schoolName" column="school_name"/>
11         <collection property="userList" ofType="user" column="u_id"/>
12     </resultMap>
13 
14     <select id="selectAllSchool" resultMap="assosiateWithUser">
15       select *from school
16     </select>
17 
18     <!--like关键字使用 :搭配if,where,可多条件累加-->
19     <select id="selectLikeParam" parameterType="java.lang.String" resultType="school">
20         <bind name="sName" value="'%' + sName + '%'"/>
21         select *from school
22         <where>
23             <!--下面两种方式可供选择-->
24             <if test="sName!=null">
25                 <!--1.使用$符号声明变量可能造成sql注入的威胁-->
26                 school_name like '%${sName}%'
27             </if>
28             <if test="sName!=null">
29                 <!--2.通过bind拼凑字符串，防止sql注入-->
30                 school_name like #{sName}
31             </if>
32         </where>
33     </select>
34 
35     <!--like关键字使用 :搭配choose,when,供多条件选择-->
36     <select id="selectLikeParam" parameterType="java.lang.String" resultType="school">
37         select *from school
38         <choose>
39             <when test="schoolName!=null">
40                 school_Name like #{sName}
41             </when>
42             <when test="schoolName==null">
43                 school_Name like '清华小学'
44             </when>
45         </choose>
46     </select>
47 
48     <parameterMap id="parameters" type="double">
49         <parameter property="min" javaType="double"/>
50         <parameter property="max" javaType="double"/>
51     </parameterMap>
52 
53     <!-- where,if,>,<符号使用-->
54     <select id="selectInAverage" parameterMap="parameters" resultType="school">
55         select *from school school_size
56         <where>
57             <if test="min!=null || max!=null">
58                 <!--<![CDATA[>]]>表示为>符号-->
59                 school_size <![CDATA[>]]> #{min}  and school_size <![CDATA[<]]> #{max}
60             </if>
61 
62         </where>
63 
64     </select>
65     
66 </mapper>

单元测试：

1 @RunWith(SpringJUnit4ClassRunner.class)
2 @ContextConfiguration("classpath:applicationContext.xml")
3 public class BaseTest {
4 }

 1 public class UnitTest extends BaseTest {
 2 
 3     @Autowired
 4     private UserService userService;
 5 
 6     @Autowired
 7     private SchoolService schoolService;
 8 
 9     @Test
10     public void showByPage() {
11         //3为sql查询limit函数的第一个参数（x），代表从x+1的位置开始执行查询(默认为0)
12         // 2为限制每次显示的记录数，相当于页面大小
13         Page<User> page = userService.selectByPage(3, 2);
14         List<User> list = page.getLists();
15         System.out.println("分页查询记录显示：");
16         list.stream().forEach(System.out::println);
17         System.out.println("每页的记录数为：" + page.getPageSize());
18         System.out.println("总页数为：" + page.getTotalPage());
19         System.out.println("总记录数：" + page.getTotalCount());
20     }
21 
22     @Test
23     public void showManyToOne() {
24         List<School> schools = schoolService.getAll();
25         schools.stream().forEach(System.out::println);
26     }
27 
28     @Test
29     public void showOneToOne() {
30         List<User> list = userService.getAll();
31         list.stream().forEach(System.out::println);
32     }
33 
34     @Test
35     public void useLike() {
36         List<School> schoolList = schoolService.useLike("清华");
37         schoolList.stream().forEach(System.out::println);
38     }
39 
40     @Test
41     public void useIf() {
42         List<School> list = schoolService.useConditions(500.0, 720.0);
43         list.stream().forEach(System.out::println);
44     }
45 
46 }

效果截图：

showByPage()：

showManyToOne():

showOneToOne():

useLike():

useIf():

4.总结：

mybatis:

1.半对象-关系型orm框架，对jdbc的底层数据库连接，销毁等封装性高，对sql语句封装性较差，可通过手写sql实现复杂的sql操作。

2.提供一对一，一对多的复杂嵌套查询机制。

3.可使用动态sql灵活的操作相关sql语句，实现sql的动态变化，功能相对完善。

Mybatis-plus:

在mybatis的基础上增加了一些新的扩展，比如单表操作以对象操作数据库，提供mp自带分页插件、分页工具类等，提供许多条件构造器，提供强大的代码生成器等等。

依赖包：

 1       <!--spring boot-->
 2         <dependency>
 3             <groupId>com.baomidou</groupId>
 4             <artifactId>mybatis-plus-boot-starter</artifactId>
 5             <version>3.2.0</version>
 6         </dependency>
 7 
 8         <!--spring-->
 9         <dependency>
10             <groupId>com.baomidou</groupId>
11             <artifactId>mybatis-plus</artifactId>
12             <version>3.2.0</version>
13         </dependency>

1.单表操作面向对象化：

前提：单表，继承BaseMapper<T>接口

简单crud:

实体类

 1 @Data
 2 @ToString
 3 @AllArgsConstructor
 4 @NoArgsConstructor
 5 @TableName(value = "house")
 6 public class House {
 7     /**
 8      * 注意：如果id与数据库字段对应不上，需要自动配置value与数据库表中字段关联
 9      */
10     @TableId(value = "house_id")
11     private Integer houseId;
12     private String houseName;
13     private Double houseArea;
14     private Double housePrice;
15     private Integer uId;
16 }

dao层接口

@Repository
public interface HouseDao extends BaseMapper<House> {
    
}

测试

 1  @Autowired
 2     private HouseDao houseDao;
 3 
 4     @Test
 5     public void unitTest() {
 6         //create
 7         House house = new House(6, "枋湖公园", 500.25, 1000.9, 2);
 8         houseDao.insert(house);
 9         System.out.println("单条记录插入成功!");
10         //read
11         System.out.println("id为6的房子记录：" + houseDao.selectById(6));
12         //update
13         house.setHouseName("修改房名");
14         houseDao.updateById(house);
15         System.out.println("修改后的记录：" + houseDao.selectById(6));
16         //delete
17         houseDao.deleteById(6);
18         System.out.println(null == houseDao.selectById(6) ? "记录已删除" : "记录未删除");
19     }

效果截图：

2.分页：

HouseService->HouseServiceImpl->HouseController

1 /**
2      * 翻页显示记录
3      * @return
4      */
5     List<House> selectByPage(Integer currPageNo, Integer pageSize);

1    @Override
2     public List<House> selectByPage(Integer currPageNo, Integer pageSize) {
3         // 分页查询 pageSize 条用户id为1的房源记录
4         List<House> houseList = houseDao.selectPage(
5             new Page<House>(currPageNo, pageSize),
6             new QueryWrapper<House>().eq("u_id", "1")
7         ).getRecords();
8         return houseList;
9     }

1   @GetMapping("/test/{pageNo}/{pageSize}")
2     public String byPageFromMplus(@PathVariable(name = "pageNo") Integer currPage, @PathVariable(name = "pageSize") Integer pageSize) {
3         List<House> list = houseService.selectByPage(currPage, pageSize);
4         System.out.println("显示列表："+list);
5         //循环遍历
6         list.stream().forEach(System.out::println);
7         return "分页显示："+list;
8     }

效果截图：

3.条件构造器：

 1  /**
 2      * 各种条件构造函数的熟悉使用
 3      */
 4     @Test
 5     public void conditionTest() {
 6         //ge(String "column",Object value) :对应的是数据库的字段名称 ，ge表示大于等于
 7         System.out.println("房子面积大于120的记录数为：" + houseDao.selectCount(new QueryWrapper<House>().ge("house_area", 120)));
 8         //eq(String "column",Object value): eq表示等于
 9         System.out.println("房子面积等于120的记录为：" + houseDao.selectOne(new QueryWrapper<House>().eq("house_area", 120)));
10         House house = new House();
11         house.setHouseId(1);
12         //set(String "column",Object value)：set表示设置当前column的值为value
13         houseDao.update(house, new UpdateWrapper<House>().set("house_name", "测试"));
14         System.out.println("修改后记录为：" + houseDao.selectById(1));
15         //between(String "column",Object val1,Object val2): between表示当前的column的值范围在val1-val2之间
16         List<House> houseList = houseDao.selectList(new QueryWrapper<House>().between("house_area", 120, 160));
17         System.out.println("房子面积在120-150之间的所有记录为：");
18         houseList.stream().forEach(System.out::println);
19     }

效果截图：

4.强大的代码生成器：

ps:默认的模板引擎是velocity,如果未声明

依赖：

 1         <dependency>
 2             <groupId>com.baomidou</groupId>
 3             <artifactId>mybatis-plus-generator</artifactId>
 4             <version>3.0.7</version>
 5         </dependency>
 6 
 7         <dependency>
 8             <groupId>org.apache.velocity</groupId>
 9             <artifactId>velocity</artifactId>
10             <version>1.7</version>
11         </dependency>

附上笔者自己根据官方文档整理出来的小小工具类，用于代码生成。

ps:有些配置还没怎么搞懂，但大致功能已经实现且能够成功运行。

  1 package com.wsw.springboot.util;
  2 
  3 import com.baomidou.mybatisplus.generator.AutoGenerator;
  4 import com.baomidou.mybatisplus.generator.InjectionConfig;
  5 import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
  6 import com.baomidou.mybatisplus.generator.config.GlobalConfig;
  7 import com.baomidou.mybatisplus.generator.config.PackageConfig;
  8 import com.baomidou.mybatisplus.generator.config.StrategyConfig;
  9 import com.baomidou.mybatisplus.generator.config.TemplateConfig;
 10 import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
 11 
 12 
 13 /**
 14  * 工具类:mybatis-plus：代码生成
 15  * @author :wen
 16  */
 17 public class GenerateCodeDevUtil {
 18     /**
 19      * Service接口是否统一I开头
 20      */
 21     private static final boolean SERVICE_BEGIN_WHTH_I = false;
 22     /**
 23      * 设置包名
 24      */
 25     private static final String PACKAGE_NAME = "com.admin";
 26     /**
 27      *数据库驱动名称
 28      */
 29     private static final String DRIVER_NAME = "com.mysql.jdbc.Driver";
 30     /**
 31      *数据库URL
 32      */
 33     private static final String URL = "jdbc:mysql://localhost:3306/springboot?characterEncoding=utf8";
 34     /**
 35      *数据库User
 36      */
 37     private static final String USER = "root";
 38     /**
 39      *数据库连接密码
 40      */
 41     private static final String PASSWORD = "199815";
 42 
 43     /**
 44      * 私有化构造器：外部无需new对象，直接通过类名调用方法
 45      */
 46     private GenerateCodeDevUtil() {
 47 
 48     }
 49 
 50     /**
 51      * 全局配置：相当于mybatis-plus.xml进行相关配置
 52      * @return
 53      */
 54     private static GlobalConfig globalConfig() {
 55         GlobalConfig globalConfig = new GlobalConfig();
 56         //作者名
 57         globalConfig.setAuthor("wen");
 58         //文件输出目录
 59         globalConfig.setOutputDir("C:\\Users\\Administrator\\Desktop\\demo");
 60         //根据数据库列表名称
 61         globalConfig.setBaseColumnList(true);
 62         globalConfig.setActiveRecord(true);
 63         globalConfig.setBaseResultMap(true);
 64         //缓存配置
 65         globalConfig.setEnableCache(true);
 66         //文件重写
 67         globalConfig.setFileOverride(true);
 68         //设置控制层类命名 +%s默认加上实体类名前缀
 69         globalConfig.setControllerName("%sController");
 70         //设置dao层接口名称
 71         globalConfig.setMapperName("%sDao");
 72         //设置serviceImpl层类名称
 73         globalConfig.setServiceImplName("%sServiceImpl");
 74         globalConfig.setServiceName("%sService");
 75         return globalConfig;
 76     }
 77 
 78     /**
 79      * 数据源配置
 80      * @return
 81      */
 82     private static DataSourceConfig dataSourceConfig() {
 83         DataSourceConfig dataSourceConfig = new DataSourceConfig();
 84         dataSourceConfig.setDriverName(DRIVER_NAME);
 85         dataSourceConfig.setUrl(URL);
 86         dataSourceConfig.setUsername(USER);
 87         dataSourceConfig.setPassword(PASSWORD);
 88         return dataSourceConfig;
 89     }
 90 
 91     /**
 92      * 包配置:包括每一层的包命名:controller/entity/dao/service/serviceImpl
 93      * @return
 94      */
 95     private static PackageConfig packageConfig() {
 96         PackageConfig packageConfig = new PackageConfig();
 97         packageConfig.setParent(PACKAGE_NAME);
 98         packageConfig.setController("controller");
 99         packageConfig.setEntity("entity");
100         packageConfig.setMapper("dao");
101         packageConfig.setService("service");
102         packageConfig.setServiceImpl("service.impl");
103         return packageConfig;
104     }
105 
106     /**
107      * 自定义配置，包括文件命名，输出目录等
108      * @return
109      */
110     private static InjectionConfig injectionConfig() {
111         InjectionConfig injectionConfig = new InjectionConfig() {
112             @Override
113             public void initMap() {
114 
115             }
116         };
117         return injectionConfig;
118     }
119 
120     /**
121      * 模板配置
122      * @return
123      */
124     private static TemplateConfig templateConfig() {
125         TemplateConfig templateConfig = new TemplateConfig();
126         //配置生成的xml路径
127         return templateConfig;
128     }
129 
130     /**
131      * 策略配置:命名，前缀，表字段
132      * @return
133      */
134     private static StrategyConfig strategyConfig() {
135         StrategyConfig strategyConfig = new StrategyConfig();
136         strategyConfig.setEntityBuilderModel(true);
137         strategyConfig.setVersionFieldName("super code man");
138         strategyConfig.setCapitalMode(true);
139         //设置数据库表名
140         strategyConfig.setInclude("users", "house");
141         //驼峰命名
142         strategyConfig.setNaming(NamingStrategy.underline_to_camel);
143         //实体类不加注解
144         strategyConfig.setEntityTableFieldAnnotationEnable(false);
145         return strategyConfig;
146     }
147 
148     /**
149      * 加载全部配置
150      */
151     public static void start() {
152         AutoGenerator autoGenerator = new AutoGenerator();
153         autoGenerator.setCfg(injectionConfig());
154         autoGenerator.setTemplate(templateConfig());
155         autoGenerator.setPackageInfo(packageConfig());
156         autoGenerator.setDataSource(dataSourceConfig());
157         autoGenerator.setGlobalConfig(globalConfig());
158         autoGenerator.setStrategy(strategyConfig());
159         System.out.println("全部配置加载成功！开始执行生成代码...");
160         autoGenerator.execute();
161     }
162 
163 }

效果截图：

控制台：

生成文件：

里面的内容也是有自动添加，可能有些配置不怎么清楚，生成的配置有点简陋。

 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.admin.dao.HouseDao">
 4 
 5     <!-- 开启二级缓存 -->
 6     <cache type="org.mybatis.caches.ehcache.LoggingEhcache"/>
 7 
 8     <!-- 通用查询映射结果 -->
 9     <resultMap id="BaseResultMap" type="com.admin.entity.House">
10         <id column="house_id" property="houseId" />
11         <result column="house_name" property="houseName" />
12         <result column="house_area" property="houseArea" />
13         <result column="house_price" property="housePrice" />
14         <result column="u_id" property="uId" />
15     </resultMap>
16 
17     <!-- 通用查询结果列 -->
18     <sql id="Base_Column_List">
19         house_id, house_name, house_area, house_price, u_id
20     </sql>
21 
22 </mapper>

package com.admin.service;

import com.admin.entity.House;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author wen
 * @since 2019-10-25
 */
public interface HouseService extends IService<House> {

}

 1 package com.admin.dao;
 2 
 3 import com.admin.entity.House;
 4 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 5 
 6 /**
 7  * <p>
 8  *  Mapper 接口
 9  * </p>
10  *
11  * @author wen
12  * @since 2019-10-25
13  */
14 public interface HouseDao extends BaseMapper<House> {
15 
16 }

mybatis 与 mybatis-plus的区别：

相同之处：

1.在相关信息配置上mybatis与mybatis-plus的差异性不是很大，基本配置项相同

2.mybatis的多表操作，嵌套查询与mybatis-plus的操作一致，无差异性

不同之处：

1.mybatis-plus对单表的操作不再依靠书写sql，dao层映射，而是通过操作对象来实现单表的增删查改相关操作。

2.mybtis-plus在mybatis的基础上扩展了许多功能，可以通过mybatis-plus的提供的分页插件实现分页，也可以通过mybatis-plus的条件构造实现mybatis单表的动态sql,无需再通过配置文件进行复杂sql的书写。

3.mybatis的逆向工程插件包mybatis-generator与mybatis-plus的mybatisplus-generator实际使用方式发生改变，mybatis是通过xml配置文件进行逆向工程相关信息的配置，mybatis-plus则是通过提供的配置相关类进行代码层的配置，并且可以实现个性化配置。

免责声明！

本站转载的文章为个人学习借鉴使用，本站对版权不负任何法律责任。如果侵犯了您的隐私权益，请联系本站邮箱yoyou2525@163.com删除。

猜您在找 MyBatis与Mybatis-plus的区别 Mybatis-plus的使用 Mybatis-Plus的使用 MyBatis-Plus使用 MyBatis-Plus mybatis-plus - buildSqlSessionFactory() mybatis-plus - 初识 mybatis-plus - MybatisPlusAutoConfiguration Mybatis-plus基本用法 Mybatis-Plus和Mybatis的区别