Mybatis && Mybatis-plus

导读：

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

   文章结构：

    1. mybatis

    2. mybatis-plus

    3. 总结

Mybatis:

1.依赖包：

(1)spring：

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.2</version>
        </dependency>

(2)spring boot:

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

2.配置：

(1)spring:

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

  <?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>
  
      <!--加载数据库配置文件-->
      <properties resource="db.properties"/>
  
      <!--常用设置-->
      <settings>
          <!-- 懒加载。如果设为‘false'，则所有相关联的都会被初始化加载。 -->
          <setting name="lazyLoadingEnabled" value="true"/>
          <!-- 当设置为‘true'的时候，懒加载的对象可能被任何懒属性全部加载。否则，每个属性都按需加载。 -->
          <setting name="aggressiveLazyLoading" value="false"/>
          <!--日志信息打印-->
          <setting name="logImpl" value="STDOUT_LOGGING"/>
          <!--缓存设置-->
          <setting name="cacheEnabled" value="true"/>
          <!--驼峰命名-->
          <setting name="mapUnderscoreToCamelCase" value="true"/>
      </settings>
  
      <!--别名设置-->
      <typeAliases>
          <package name="com.wsw.entity"/>
      </typeAliases>
  
      <!--插件配置-->
      <plugins>
          <plugin interceptor=""></plugin>
      </plugins>
  
      <!--环境配置-->
      <environments default="">
          <environment id="">
              <!--事务管理-->
              <transactionManager type="">
                  <property name="" value=""/>
              </transactionManager>
              <!--数据源配置-->
              <dataSource type="">
                  <property name="" value=""/>
                  <property name="" value=""/>
              </dataSource>
          </environment>
      </environments>
  
      <!--映射文件配置:下面三种方式可随机采用其中一种-->
      <mappers>
          <!--相对路径文件映射-->
          <mapper resource=""/>
          <!--绝对路径文件映射-->
          <mapper url=""/>
          <!--包映射-->
          <package name=""/>
      </mappers>
  
  </configuration>

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

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

(2)spring boot(yaml):

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

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

3.使用：

实体类：User->School->Page

@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class User {
    /**
     * 用户编号
     */
    private int uId;
    /**
     * 用户姓名
     */
    private String uName;
    /**
     * 用户性别
     */
    private int uSex;
    /**
     * 用户年龄
     */
    private int uAge;
    /**
     * 用户身份证
     */
    private String uIdentity;
    /**
     * 用户出生日期
     */
    private Timestamp uBirth;
    /**
     * 关联学校：1:1
     */
    private School school;
}

@AllArgsConstructor
@NoArgsConstructor
@Data
@ToString
public class School {
    /**
     * 学校编号
     */
    private int schoolId;
    /**
     * 学校名称
     */
    private String schoolName;
    /**
     * 学校面积
     */
    private double schoolSize;
    /**
     * 一对多
     */
    List<User> userList;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Page<T> {

    /**
     * 当前页号
     */
    private int pageNo;
    /**
     * 当前页面大小
     */
    private int pageSize;
    /**
     * 总记录数
     */
    private int totalCount;
    /**
     * 总页数
     */
    private int totalPage;
    /**
     * 每页的显示的数据
     */
    private List<User> lists;

}

dao层接口：UserDao->SchoolDao

@Repository
public interface UserDao {

    /**
     * 查看所有用户
     * @return
     */
    List<User> selectAll();

    /**
     * 插入一条用户记录
     * @param user
     */
    void insertOne(User user);

    /**
     * 分页查询
     * @param pageNum:偏移量，代表从第pageNum+1的位置开始取记录
     * @param pageCount:取记录的总数
     * @return
     */
    List<User> selectByPageNo(@Param("pageNum") int pageNum, @Param("pageCount") int pageCount);

    /**
     * 查询所有记录数
     * @return
     */
    int selectTotalCount();

}

@Repository
public interface SchoolDao {
    /**
     * 查看所有的学校信息
     * @return
     */
    List<School> selectAllSchool();

    /**
     * 模糊查询-like关键字使用
     * @param sName
     * @return
     */
    List<School> selectLikeParam(@Param(value = "sName") String sName);

    /**
     * 条件查询-if,where等条件使用
     * @param min
     * @param max
     * @return
     */
    List<School> selectInAverage(@Param(value = "min") double min, @Param("max") double max);
}

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

public interface UserService {
    /**
     * 查询所有用户
     * @return
     */
    List<User> getAll();

    /**
     * 创建一条用户记录
     * @param user
     */
    void createOne(User user);

    /**
     * 分页显示用户记录
     * @param pageNum
     * @param pageCount
     * @return
     */
    Page<User> selectByPage(int pageNum, int pageCount);

}

@Service("userService")
@Transactional
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public List<User> getAll() {
        return  userDao.selectAll();
    }

    @Override
    public void createOne(User user) {
        userDao.insertOne(user);
    }

    @Override
    public Page<User> selectByPage(int pageNum, int pageCount) {
        Page<User> page = new Page<User>();
        //设置总记录数
        page.setTotalCount(userDao.selectTotalCount());
        //设置每一页显示的记录数
        page.setPageSize(pageCount);
        //设置当前总页数:如果当前的总记录数能够整除每一页的页面记录数大小，则总页数为除后结果
        if ((page.getTotalCount() - pageNum) % page.getPageSize() == 0) {
            page.setTotalPage((page.getTotalCount() - pageNum) / page.getPageSize());
        } else {
            //否则为结果加一
            page.setTotalPage(((page.getTotalCount() - pageNum) / page.getPageSize()) + 1);
        }
        //总记录数小于每页要求记录数时默认为1
        if (page.getTotalCount() < page.getPageSize()) {
            page.setTotalPage(1);
        }
        page.setLists(userDao.selectByPageNo(pageNum, pageCount));
        return page;
    }

}

public interface SchoolService {
    /**
     * 查看所有学校记录
     * @return
     */
    List<School> getAll();

    /**
     * 模糊查询:like关键字使用
     * @param sName
     * @return
     */
    List<School> useLike(String sName);

    /**
     * 条件查询
     * @param min
     * @param max
     * @return
     */
    List<School> useConditions(double min,double max);
}

@Service("schoolService")
@Transactional
public class SchoolServiceImpl implements SchoolService {

    @Autowired
    private SchoolDao schoolDao;

    @Override
    public List<School> getAll() {
        return schoolDao.selectAllSchool();
    }

    @Override
    public List<School> useLike(String sName) {
        return schoolDao.selectLikeParam(sName);
    }

    @Override
    public List<School> useConditions(double min, double max) {
        return schoolDao.selectInAverage(min, max);
    }
}

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

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

<mapper namespace="com.sunsharing.dao.UserDao">

    <!--一对一关联嵌套查询-->
    <resultMap id="asossiateWithSchool" type="user">
        <id property="uId" column="u_id"/>
        <result property="uName" column="u_name"/>
        <result property="uSex" column="u_sex"/>
        <result property="uAge" column="u_age"/>
        <result property="uBirth" column="u_birth"/>
        <association property="school" javaType="school" column="school_id" select="selectSchool"/>
    </resultMap>

    <select id="selectAll" resultMap="asossiateWithSchool">
      select *from `user`
    </select>

    <select id="selectSchool" resultType="school">
         select *from `user` u,school s where u.school_id=s.school_id and u_id=#{uId}
    </select>
    <!--插入一条记录，允许主键自增，获取主键-->
    <insert id="insertOne" parameterType="user" useGeneratedKeys="true">
      INSERT INTO `react`.`user`
     (`u_id`, `u_name`, `u_sex`, `u_age`, `u_identity`, `u_birth`)
      VALUES
     (#{uId}, #{uName},#{uSex}, #{uAge}, #{uIdentity}, #{uBirth})
    </insert>

    <!--传入参数包含多个-->
    <parameterMap id="parameters" type="int">
        <parameter property="pageNum" javaType="int"/>
        <parameter property="pageCount" javaType="int"/>
    </parameterMap>

    <select id="selectByPageNo" parameterMap="parameters" resultType="user">
        select *from `user` limit #{pageNum},#{pageCount}
    </select>

    <select id="selectTotalCount" resultType="int">
        select count(0) from `user`
    </select>

</mapper>

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

<mapper namespace="com.sunsharing.dao.SchoolDao">

    <!--嵌套查询，包含多对一的关系-->
    <resultMap id="assosiateWithUser" type="school">
        <id property="schoolId" column="school_id"/>
        <result property="schoolName" column="school_name"/>
        <collection property="userList" ofType="user" column="u_id"/>
    </resultMap>

    <select id="selectAllSchool" resultMap="assosiateWithUser">
      select *from school
    </select>

    <!--like关键字使用 :搭配if,where,可多条件累加-->
    <select id="selectLikeParam" parameterType="java.lang.String" resultType="school">
        <bind name="sName" value="'%' + sName + '%'"/>
        select *from school
        <where>
            <!--下面两种方式可供选择-->
            <if test="sName!=null">
                <!--1.使用$符号声明变量可能造成sql注入的威胁-->
                school_name like '%${sName}%'
            </if>
            <if test="sName!=null">
                <!--2.通过bind拼凑字符串，防止sql注入-->
                school_name like #{sName}
            </if>
        </where>
    </select>

    <!--like关键字使用 :搭配choose,when,供多条件选择-->
    <select id="selectLikeParam" parameterType="java.lang.String" resultType="school">
        select *from school
        <choose>
            <when test="schoolName!=null">
                school_Name like #{sName}
            </when>
            <when test="schoolName==null">
                school_Name like '清华小学'
            </when>
        </choose>
    </select>

    <parameterMap id="parameters" type="double">
        <parameter property="min" javaType="double"/>
        <parameter property="max" javaType="double"/>
    </parameterMap>

    <!-- where,if,>,<符号使用-->
    <select id="selectInAverage" parameterMap="parameters" resultType="school">
        select *from school school_size
        <where>
            <if test="min!=null || max!=null">
                <!--<![CDATA[>]]>表示为>符号-->
                school_size <![CDATA[>]]> #{min}  and school_size <![CDATA[<]]> #{max}
            </if>

        </where>

    </select>
    
</mapper>

单元测试：

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

public class UnitTest extends BaseTest {

    @Autowired
    private UserService userService;

    @Autowired
    private SchoolService schoolService;

    @Test
    public void showByPage() {
        //3为sql查询limit函数的第一个参数（x），代表从x+1的位置开始执行查询(默认为0)
        // 2为限制每次显示的记录数，相当于页面大小
        Page<User> page = userService.selectByPage(3, 2);
        List<User> list = page.getLists();
        System.out.println("分页查询记录显示：");
        list.stream().forEach(System.out::println);
        System.out.println("每页的记录数为：" + page.getPageSize());
        System.out.println("总页数为：" + page.getTotalPage());
        System.out.println("总记录数：" + page.getTotalCount());
    }

    @Test
    public void showManyToOne() {
        List<School> schools = schoolService.getAll();
        schools.stream().forEach(System.out::println);
    }

    @Test
    public void showOneToOne() {
        List<User> list = userService.getAll();
        list.stream().forEach(System.out::println);
    }

    @Test
    public void useLike() {
        List<School> schoolList = schoolService.useLike("清华");
        schoolList.stream().forEach(System.out::println);
    }

    @Test
    public void useIf() {
        List<School> list = schoolService.useConditions(500.0, 720.0);
        list.stream().forEach(System.out::println);
    }

}

效果截图：

showByPage()：

 showManyToOne():

showOneToOne():

useLike():

useIf():

4.总结：

 mybatis:

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

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

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

Mybatis-plus:

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

依赖包：

      <!--spring boot-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.2.0</version>
        </dependency>

        <!--spring-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus</artifactId>
            <version>3.2.0</version>
        </dependency>

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

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

简单crud:

实体类

@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "house")
public class House {
    /**
     * 注意：如果id与数据库字段对应不上，需要自动配置value与数据库表中字段关联
     */
    @TableId(value = "house_id")
    private Integer houseId;
    private String houseName;
    private Double houseArea;
    private Double housePrice;
    private Integer uId;
}

dao层接口

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

测试

 @Autowired
    private HouseDao houseDao;

    @Test
    public void unitTest() {
        //create
        House house = new House(6, "枋湖公园", 500.25, 1000.9, 2);
        houseDao.insert(house);
        System.out.println("单条记录插入成功!");
        //read
        System.out.println("id为6的房子记录：" + houseDao.selectById(6));
        //update
        house.setHouseName("修改房名");
        houseDao.updateById(house);
        System.out.println("修改后的记录：" + houseDao.selectById(6));
        //delete
        houseDao.deleteById(6);
        System.out.println(null == houseDao.selectById(6) ? "记录已删除" : "记录未删除");
    }

效果截图：

 2.分页：

HouseService->HouseServiceImpl->HouseController

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

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

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

效果截图：

 

3.条件构造器：

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

效果截图：

 

 4.强大的代码生成器：

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

依赖：

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.0.7</version>
        </dependency>

        <dependency>
            <groupId>org.apache.velocity</groupId>
            <artifactId>velocity</artifactId>
            <version>1.7</version>
        </dependency>

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

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

package com.wsw.springboot.util;

import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.DataSourceConfig;
import com.baomidou.mybatisplus.generator.config.GlobalConfig;
import com.baomidou.mybatisplus.generator.config.PackageConfig;
import com.baomidou.mybatisplus.generator.config.StrategyConfig;
import com.baomidou.mybatisplus.generator.config.TemplateConfig;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;


/**
 * 工具类:mybatis-plus：代码生成
 * @author :wen
 */
public class GenerateCodeDevUtil {
    /**
     * Service接口是否统一I开头
     */
    private static final boolean SERVICE_BEGIN_WHTH_I = false;
    /**
     * 设置包名
     */
    private static final String PACKAGE_NAME = "com.admin";
    /**
     *数据库驱动名称
     */
    private static final String DRIVER_NAME = "com.mysql.jdbc.Driver";
    /**
     *数据库URL
     */
    private static final String URL = "jdbc:mysql://localhost:3306/springboot?characterEncoding=utf8";
    /**
     *数据库User
     */
    private static final String USER = "root";
    /**
     *数据库连接密码
     */
    private static final String PASSWORD = "199815";

    /**
     * 私有化构造器：外部无需new对象，直接通过类名调用方法
     */
    private GenerateCodeDevUtil() {

    }

    /**
     * 全局配置：相当于mybatis-plus.xml进行相关配置
     * @return
     */
    private static GlobalConfig globalConfig() {
        GlobalConfig globalConfig = new GlobalConfig();
        //作者名
        globalConfig.setAuthor("wen");
        //文件输出目录
        globalConfig.setOutputDir("C:\Users\Administrator\Desktop\demo");
        //根据数据库列表名称
        globalConfig.setBaseColumnList(true);
        globalConfig.setActiveRecord(true);
        globalConfig.setBaseResultMap(true);
        //缓存配置
        globalConfig.setEnableCache(true);
        //文件重写
        globalConfig.setFileOverride(true);
        //设置控制层类命名 +%s默认加上实体类名前缀
        globalConfig.setControllerName("%sController");
        //设置dao层接口名称
        globalConfig.setMapperName("%sDao");
        //设置serviceImpl层类名称
        globalConfig.setServiceImplName("%sServiceImpl");
        globalConfig.setServiceName("%sService");
        return globalConfig;
    }

    /**
     * 数据源配置
     * @return
     */
    private static DataSourceConfig dataSourceConfig() {
        DataSourceConfig dataSourceConfig = new DataSourceConfig();
        dataSourceConfig.setDriverName(DRIVER_NAME);
        dataSourceConfig.setUrl(URL);
        dataSourceConfig.setUsername(USER);
        dataSourceConfig.setPassword(PASSWORD);
        return dataSourceConfig;
    }

    /**
     * 包配置:包括每一层的包命名:controller/entity/dao/service/serviceImpl
     * @return
     */
    private static PackageConfig packageConfig() {
        PackageConfig packageConfig = new PackageConfig();
        packageConfig.setParent(PACKAGE_NAME);
        packageConfig.setController("controller");
        packageConfig.setEntity("entity");
        packageConfig.setMapper("dao");
        packageConfig.setService("service");
        packageConfig.setServiceImpl("service.impl");
        return packageConfig;
    }

    /**
     * 自定义配置，包括文件命名，输出目录等
     * @return
     */
    private static InjectionConfig injectionConfig() {
        InjectionConfig injectionConfig = new InjectionConfig() {
            @Override
            public void initMap() {

            }
        };
        return injectionConfig;
    }

    /**
     * 模板配置
     * @return
     */
    private static TemplateConfig templateConfig() {
        TemplateConfig templateConfig = new TemplateConfig();
        //配置生成的xml路径
        return templateConfig;
    }

    /**
     * 策略配置:命名，前缀，表字段
     * @return
     */
    private static StrategyConfig strategyConfig() {
        StrategyConfig strategyConfig = new StrategyConfig();
        strategyConfig.setEntityBuilderModel(true);
        strategyConfig.setVersionFieldName("super code man");
        strategyConfig.setCapitalMode(true);
        //设置数据库表名
        strategyConfig.setInclude("users", "house");
        //驼峰命名
        strategyConfig.setNaming(NamingStrategy.underline_to_camel);
        //实体类不加注解
        strategyConfig.setEntityTableFieldAnnotationEnable(false);
        return strategyConfig;
    }

    /**
     * 加载全部配置
     */
    public static void start() {
        AutoGenerator autoGenerator = new AutoGenerator();
        autoGenerator.setCfg(injectionConfig());
        autoGenerator.setTemplate(templateConfig());
        autoGenerator.setPackageInfo(packageConfig());
        autoGenerator.setDataSource(dataSourceConfig());
        autoGenerator.setGlobalConfig(globalConfig());
        autoGenerator.setStrategy(strategyConfig());
        System.out.println("全部配置加载成功！开始执行生成代码...");
        autoGenerator.execute();
    }

}

效果截图：

   控制台：

   生成文件：

 

 

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.admin.dao.HouseDao">

    <!-- 开启二级缓存 -->
    <cache type="org.mybatis.caches.ehcache.LoggingEhcache"/>

    <!-- 通用查询映射结果 -->
    <resultMap id="BaseResultMap" type="com.admin.entity.House">
        <id column="house_id" property="houseId" />
        <result column="house_name" property="houseName" />
        <result column="house_area" property="houseArea" />
        <result column="house_price" property="housePrice" />
        <result column="u_id" property="uId" />
    </resultMap>

    <!-- 通用查询结果列 -->
    <sql id="Base_Column_List">
        house_id, house_name, house_area, house_price, u_id
    </sql>

</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> {

}

package com.admin.dao;

import com.admin.entity.House;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author wen
 * @since 2019-10-25
 */
public interface HouseDao extends BaseMapper<House> {

}

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则是通过提供的配置相关类进行代码层的配置，并且可以实现个性化配置。