MyBatis

简介

Mybatis是一个java的sql映射框架。它提供了数据库的操作能力，相当于一个增强的JDBC。使用时。只需编写sql语句，其他操作，诸如创建销毁Connection、Statement、sql的执行等，Mybatis会自定完成。对于传统的JDBC编程，其代码较多，开发效率的，且需要关注Connection、Statement、ResultSet对象的创建与销毁，而且对ResultSet对象的查询结果还需要进行进一步的封装，重复代码较多，业务逻辑代码与数据库操作代码冗余

Mybatis的两个主要使命：

  • sql mapper：sql映射。可以把数据库表中的一行数据映射为一个java对象。我们操作java对象就相当于操作表中的数据
  • Data Access Object：数据访问。对数据库执行增删改查

需要注意的是，Mybatis默认不自动提交事务

配置文件中支持配置日志打印功能

Mybatis默认开启事务，即关闭自动提交

SQLSession(持久化管理器)

是Mybatis的核心，它的创建方法是由SQLSessionFactoryBuilder工厂创建的

  1. @Bean
  2. public Connection connection(){
  3.     // TODO: 2021/7/26 创建一个工厂
  4.     SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  5.     InputStream resourceAsStream = SqlSessionFactoryBuilder.class.getClassLoader().getResourceAsStream("mybatis-config.xml");
  6.     SqlSessionFactory build = builder.build(resourceAsStream);
  7.     // TODO: 2021/7/26 创建了持久化管理器 ，所谓工厂模式，是将配置信息放入工厂，最终将创建一个持久化管理器
  8.     SqlSession sqlSession = build.openSession();
  9.     Connection connection = sqlSession.getConnection();
  10.     return connection;
  11. }

也可以将其写在一个工具类上，这样就不用每次都写了，因为SqlSessionFactory 接口对象是一个重量级对象，即系统开销大的对象，且是线程安全的，所以一个应用只需要一个该对象即可

  1. public class GradleMyBatisUtils {
  3.     private static SqlSessionFactory factory;
  4.     // TODO: 2021/7/28 可以把ThreadLocal<>看成是一个容器，这个容器有判断hash值的方法，确定在里面的实例是否是唯一（即单例）
  5.     private static ThreadLocal<SqlSession> local = new ThreadLocal<>();
  7.     static {
  8.         try {
  9.             factory = new SqlSessionFactoryBuilder().build(
  10.                 GradleMyBatisUtils.class.getClassLoader().getResourceAsStream("classpath:mybatis-config.xml")
  11.             );
  12.         } catch (Exception e) {
  13.             throw new ExceptionInInitializerError("MyBatis初始化失败" + e.getMessage());
  14.         }
  15.     }
  17.     // TODO: 2021/7/28 获取一个持久化管理器，管理器里包数据库连接池，事务和数据库连接的相关信息，具体内容和配置文件中有关
  18.     public static SqlSession getSession(){
  19.         // TODO: 2021/7/28 从容器中获得对象， 由于是单例的，所以，会依据类型进行匹配
  20.         SqlSession sqlSession = local.get();
  21.         if (sqlSession == null) {
  22.             sqlSession = factory.openSession();
  23.             local.set(sqlSession);
  24.         }
  25.         return sqlSession;
  26.     }
  28.     // TODO: 2021/7/28 关闭持久化管理对象，关闭此对象，会同时关闭数据库连接池中相关对象，如connection,statement等！ 
  29.     public static void close(){
  30.         SqlSession sqlSession = local.get();
  31.         if (sqlSession!=null) {
  32.             sqlSession.close();
  33.             local.remove();
  34.         }
  35.     }
  36. }

动态sql

if标签

SQL的if语句，其主要通途是对传入的参数对象的某个属性进行条件判断，如果条件为真，就可以执行或者拼接sql语句。判断是在if标签中的test属性中进行的

  1. <select id="selectif" parameterType="Student" resultType="Student">
  2.     select name, age
  3.     from student
  4.     where 1 = 1
  5.     <if test="name!=null and name!=''">
  6.         and name = #{name}
  7.     </if>
  8. </select>

choose标签

意思和if差不多，但只会拼接一个sql语句

  1. <select id="selectchoose" parameterType="Student" resultType="Student">
  2.     select name, age
  3.     from student
  4.     where
  5.     <choose>
  6.         <when test="name != null and name !=''">
  7.             name=#{name}
  8.         </when>
  9.         <when test="age!=null and age!=0">
  10.             age=#{age}
  11.         </when>
  12.         <otherwise>
  13.             1=1
  14.         </otherwise>
  15.     </choose>
  16. </select>

where标签

一般要结合if或者choose一起使用

  1. <select id="selectwhere" parameterType="Student" resultType="Student">
  2.     select name,age from student
  3.     <where>
  4.         <if test="name != null and name != ''">
  5.             and name=#{name}
  6.         </if>
  7.     </where>
  8. </select>

set标签

在做更新操作的时候用set标签，set标签不能单独使用，一般也需要结合if或choose来使用

  1. <update id="updateset" parameterType="Student">
  2.     update student
  3.     <set>
  4.         <if test="name !=null and name !=''">
  5.             name = #{name},
  6.         </if>
  7.         <if test="age!=null and age!=0">
  8.             age=#{age}
  9.         </if>
  10.     </set>
  11.     <where>
  12.         <if test="id!=null and id!=''">
  13.             and id=#{id}
  14.         </if>
  15.     </where>
  16. </update>

trim标签

可以在语句的两边去除、增加相关的内容。其主要作用是可以在语句的开头或者末尾添加特定的前缀或后缀，也可以删除揩油或末尾参数指定的内容

  1. <select id="selecttrim" parameterType="Student" resultType="Student">
  2.     select name,age from student
  3.     <trim prefix="where" prefixOverrides="and|or">
  4.         <if test="id != null">
  5.             and id=#{id}
  6.         </if>
  7.     </trim>
  8. </select>

foreach标签

增强for循环，如在数据库表中需要同事找出字段不同值的内容。

foreach中的属性：

collection：要遍历的集合，主要意思是所有的集合都会转换成一个map。mao的key名是传入参数的类型

item：迭代遍历

open：遍历前添加的字符串

close：遍历后添加的字符串

spearator：元素的分隔符

index：遍历元素的索引

  1. List<Student> selectforeach(List<Integer> list);
  1. <select id="selectforeach" resultType="Student">
  2.     select name,age from student
  3.     where id in
  4.     <foreach collection="list" item="abc" open="(" close=")" separator=",">
  5.         #{abc}
  6.     </foreach>
  7. </select>

多表关系之间的映射

提个数据库对象中的一个属性可以是另外一个数据库表对象

当对象模型作为SQL语句的一个参数的时候，如果有一个属性是对象，那么在占位符#{}中可以用这个对象的属性

添加操作

  1. <insert id="insertEmp" parameterType="Emp">
  2.     insert into emp(empname, empage, deptid)
  3.     VALUES (#{empname}, #{empage}, #{dept.deptid})
  4. </insert>
  1. @Test
  2. public void test237() {
  3.     Dept dept = new Dept();
  4.     Dept dept1 = new Dept();
  5.     dept.setDeptname("市场部");
  6.     dept1.setDeptname("营销部");
  8.     Emp emp1 = new Emp("admin", 20, dept);
  9.     Emp emp2 = new Emp("javachello", 30, dept1);
  11.     try {
  12.         dreamDept.insertDept(dept);
  13.         dreamDept.insertDept(dept1);
  15.         dreamEmp.insertEmp(emp1);
  16.         dreamEmp.insertEmp(emp2);
  18.         MyBatisUtils.commit();
  19.     } catch (Exception e) {
  20.         MyBatisUtils.rollback();
  21.         e.printStackTrace();
  22.     } finally {
  23.         MyBatisUtils.close();
  24.     }
  25. }

查询操作

多对一

在多对一关系中，举个例子就是多个员工对应一个部门

可通过标签做属性的映射

  1. <resultMap id="deptmapperthis" type="Dept">
  2.     <id property="deptid" column="deptId"/>
  3.     <result property="deptname" column="deptName"/>
  4. </resultMap>
  1. <resultMap id="empMapper2" type="Emp">
  2.     <id property="empid" column="empid"/>
  3.     <result property="empname" column="empname"/>
  4.     <result property="empage" column="empage"/>
  5.     <association property="dept" javaType="Dept" resultMap="deptmapperthis"/>
  6. </resultMap>

一对多

在一个对象中，定义另外一个对象集合，在java中可以这样理解，而在数据库表中，一对多可以理解为：通过Group by 分组后的一个字段，在别的字段中包含多条记录

  1. <resultMap id="deptnewmapper" type="Dept">
  2.     <id property="deptid" column="deptid"/>
  3.     <result property="deptname" column="deptname"/>
  4.     <collection property="emps"  ofType="Emp">
  5.         <id property="empid" column="empId"/>
  6.         <result property="empname" column="empName"/>
  7.         <result property="empage" column="empAge"/>
  8.     </collection>
  9. </resultMap>

代码生成器

mybatis-generator是一款mybatis的插件，能够自动生成Mybatis相关的代码，如：dao接口、mapper映射文件、实体类，实体类可以是与数据库表对应的java对象，也可以是sql条件对象

存在的缺点：

  • 生成的代码默认只支持单表操作，多表查询需要自己编写；
  • 对象之间的关系需要自己维护；
  • 保存返回主键需要自己添加

分页插件

PageHelper

  1. <dependency>
  2.     <groupId>com.github.pagehelper</groupId>
  3.     <artifactId>pagehelper</artifactId>
  4.     <version>5.2.1</version>
  5. </dependency>
  7. <dependency>
  8.     <groupId>com.github.jsqlparser</groupId>
  9.     <artifactId>jsqlparser</artifactId>
  10.     <version>4.0</version>
  11. </dependency>
  1. <!-- 
  2.     plugins在配置文件中的位置必须符合要求，否则会报错，顺序如下:
  3.     properties?, settings?, 
  4.     typeAliases?, typeHandlers?, 
  5.     objectFactory?,objectWrapperFactory?, 
  6.     plugins?, 
  7.     environments?, databaseIdProvider?, mappers?
  8. -->
  9. <plugins>
  10.     <plugin interceptor="com.github.pagehelper.PageInterceptor">
  11.         <!-- config params as the following -->
  12.         <!--<!–分页参数合理化  –>-->
  13.         <property name="reasonable" value="true"/>
  14.     </plugin>
  15. </plugins>
  1. @RequestMapping("/emps")
  2. public String list(@RequestParam(required = false,defaultValue = "1",value = "pn")Integer pn,Map<String,Object> map){
  4.     //引入分页查询，使用PageHelper分页功能
  5.     //在查询之前传入当前页，然后多少记录
  6.     PageHelper.startPage(pn,5);
  7.     //startPage后紧跟的这个查询就是分页查询
  8.     List<Employee> emps = employeeService.getAll();
  9.     //使用PageInfo包装查询结果，只需要将pageInfo交给页面就可以
  10.     PageInfo pageInfo = new PageInfo<>(emps,5);
  11.     //pageINfo封装了分页的详细信息，也可以指定连续显示的页数
  13.     map.put("pageInfo",pageInfo);
  14.     return "list";
  15. }
  1. public class PageInfo<T> implements Serializable {
  2.     private static final long serialVersionUID = 1L;
  3.     //当前页
  4.     private int pageNum;
  5.     //每页的数量
  6.     private int pageSize;
  7.     //当前页的数量
  8.     private int size;
  10.     //由于startRow和endRow不常用，这里说个具体的用法
  11.     //可以在页面中"显示startRow到endRow 共size条数据"
  13.     //当前页面第一个元素在数据库中的行号
  14.     private int startRow;
  15.     //当前页面最后一个元素在数据库中的行号
  16.     private int endRow;
  17.     //总记录数
  18.     private long total;
  19.     //总页数
  20.     private int pages;
  21.     //结果集
  22.     private List<T> list;
  24.     //前一页
  25.     private int prePage;
  26.     //下一页
  27.     private int nextPage;
  29.     //是否为第一页
  30.     private boolean isFirstPage = false;
  31.     //是否为最后一页
  32.     private boolean isLastPage = false;
  33.     //是否有前一页
  34.     private boolean hasPreviousPage = false;
  35.     //是否有下一页
  36.     private boolean hasNextPage = false;
  37.     //导航页码数
  38.     private int navigatePages;
  39.     //所有导航页号
  40.     private int[] navigatepageNums;
  41.     //导航条上的第一页
  42.     private int navigateFirstPage;
  43.     //导航条上的最后一页
  44.     private int navigateLastPage;
  46.     public PageInfo() {
  47.     }
  49.     /**
  50.      * 包装Page对象
  51.      *
  52.      * @param list
  53.      */
  54.     public PageInfo(List<T> list) {
  55.         this(list, 8);
  56.     }
  58.     /**
  59.      * 包装Page对象
  60.      *
  61.      * @param list          page结果
  62.      * @param navigatePages 页码数量
  63.      */
  64.     public PageInfo(List<T> list, int navigatePages) {
  65.         if (list instanceof Page) {
  66.             Page page = (Page) list;
  67.             this.pageNum = page.getPageNum();
  68.             this.pageSize = page.getPageSize();
  70.             this.pages = page.getPages();
  71.             this.list = page;
  72.             this.size = page.size();
  73.             this.total = page.getTotal();
  74.             //由于结果是>startRow的，所以实际的需要+1
  75.             if (this.size == 0) {
  76.                 this.startRow = 0;
  77.                 this.endRow = 0;
  78.             } else {
  79.                 this.startRow = page.getStartRow() + 1;
  80.                 //计算实际的endRow（最后一页的时候特殊）
  81.                 this.endRow = this.startRow - 1 + this.size;
  82.             }
  83.         } else if (list instanceof Collection) {
  84.             this.pageNum = 1;
  85.             this.pageSize = list.size();
  87.             this.pages = this.pageSize > 0 ? 1 : 0;
  88.             this.list = list;
  89.             this.size = list.size();
  90.             this.total = list.size();
  91.             this.startRow = 0;
  92.             this.endRow = list.size() > 0 ? list.size() - 1 : 0;
  93.         }
  94.         if (list instanceof Collection) {
  95.             this.navigatePages = navigatePages;
  96.             //计算导航页
  97.             calcNavigatepageNums();
  98.             //计算前后页，第一页，最后一页
  99.             calcPage();
  100.             //判断页面边界
  101.             judgePageBoudary();
  102.         }
  103.     }
  104. }

#{}和${}的区别

{}和${}的作用是一样的，都是可以获取参数，但两者的实现原理不同

{}底层是使用Preparestatement来进行操作的，在执行sql语句的时候会把它替换成？，这样的方式是可以防止sql注入的

而${}的底层是使用Statement来进行参照的，获取参数后，会使用字符串拼接的方式来拼接参数，因此不能防止sql注入，但它却可以替换表名或列名，这也是它能够留下来的原因

一级缓存和二级缓存

经常查询并且不经常改变的数据，且数据的正确与否对最终结果影响不大的，适合做缓存

一级缓存

在同一个SQLSession中执行相同的sql查询是，第一次回去查询数据库，并写在缓存中，第二次则直接从缓存中取。该缓存是SQLSession提供的一块区域，该区域结构是一个map

当执行的sql两次查询中间发生了增删改的操作，则SQLSession的缓存会被清空

Mybatis的内部缓存使用一个hashmap，key为hashcode+statementId+sql语句，value为查询出来的结果集映射成的java对象

二级缓存

二级缓存是mapper级别的，Mybatis默认是没有开启二级缓存的

第一次调用mapper下的SQL去查询表记录，查询到的信息会被存放到该mapper对应的二级缓存区域。当第二次调用namespace下的mapper映射文件时，相同的sql查询记录，会从对应的二级缓存内取出结果集。

image.png

Spring整合MyBatis

第一步：在pom.xml中加入依赖

  1. <dependencies>
  2.   <dependency>
  3.     <groupId>junit</groupId>
  4.     <artifactId>junit</artifactId>
  5.     <version>4.11</version>
  6.     <scope>test</scope>
  7.   </dependency>
  8.   <!--  spring的maven依赖  -->
  9.   <dependency>
  10.     <groupId>org.springframework</groupId>
  11.     <artifactId>spring-context</artifactId>
  12.     <version>5.2.8.RELEASE</version>
  13.   </dependency>
  14.   <!-- spring事务依赖1 -->
  15.   <dependency>
  16.     <groupId>org.springframework</groupId>
  17.     <artifactId>spring-tx</artifactId>
  18.     <version>5.2.8.RELEASE</version>
  19.   </dependency>
  20.   <!-- spring事务依赖2 -->
  21.   <dependency>
  22.     <groupId>org.springframework</groupId>
  23.     <artifactId>spring-jdbc</artifactId>
  24.     <version>5.2.7.RELEASE</version>
  25.   </dependency>
  26.   <!--  mybatis依赖  -->
  27.   <dependency>
  28.     <groupId>org.mybatis</groupId>
  29.     <artifactId>mybatis</artifactId>
  30.     <version>3.5.1</version>
  31.   </dependency>
  32.   <!--  spring和mybatis的集成依赖  -->
  33.   <dependency>
  34.     <groupId>org.mybatis</groupId>
  35.     <artifactId>mybatis-spring</artifactId>
  36.     <version>1.3.1</version>
  37.   </dependency>
  38.   <!--  mysql驱动依赖  -->
  39.   <dependency>
  40.     <groupId>mysql</groupId>
  41.     <artifactId>mysql-connector-java</artifactId>
  42.     <version>8.0.17</version>
  43.   </dependency>
  44.   <!-- 阿里的数据库连接池  -->
  45.   <dependency>
  46.     <groupId>com.alibaba</groupId>
  47.     <artifactId>druid</artifactId>
  48.     <version>1.1.12</version>
  49.   </dependency>
  50. </dependencies>
  52. <build>
  53.   <resources>
  54.     <resource>
  55.       <directory>src/main/java</directory> <!--所在的目录-->
  56.       <includes>  <!--  包括目录下的.properties跟.xml文件都会进行编译  -->
  57.         <include>**/*.properties</include>
  58.         <include>**/*.xml</include>
  59.       </includes>
  60.       <filtering>false</filtering>
  61.     </resource>
  62.   </resources>
  63. </build>

第二步：创建实体类

  1. public class Student {
  2.     private int id;
  3.     private String name;
  4.     private String email;
  5.     private int age;
  7.     public Student(){}
  9.     public Student(int id, String name, String email, int age) {
  10.         this.id = id;
  11.         this.name = name;
  12.         this.email = email;
  13.         this.age = age;
  14.     }
  16.     @Override
  17.     public String toString() {
  18.         return "Student{" +
  19.                 "id=" + id +
  20.                 ", name='" + name + '\'' +
  21.                 ", email='" + email + '\'' +
  22.                 ", age=" + age +
  23.                 '}';
  24.     }
  25. }

第三步：dao接口和mapper文件

  1. import org.example.entity.Student;
  2. import java.util.List;
  4. public interface StudentDao {
  5.     List<Student> QueryAllStudent();
  6.     int InsertStudent(Student stu);
  7. }

.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="org.example.dao.StudentDao">
  7.     <select id="QueryAllStudent" resultType="Student">
  8.         select * from student;
  9.     </select>
  10.     <insert id="InsertStudent" >
  11.         insert into student values(#{id}, #{name}, #{email}, #{age});
  12.     </insert>
  13. </mapper>

当数据库表字段名与实体类属性名不一致时，可使用别名或者

  1.     <!-- TODO:外部定义的映射标签
  2.         1：id:是一个标识符，在后面sql语句中被调用
  3.         2：type：要映射到的返回对象
  4.         3.区分主键和普通字段，主键单独用id标签，普通字段用result标签
  5.         4.proerties是自定义对象中的属性，column是数据库表中的字段-->
  6.     <resultMap id="studentMapper" type="NewStudent">
  7.         <id property="user_id" column="id"/>
  8.         <result property="user_name" column="name"/>
  9.         <result property="user_age" column="age"/>
  10.     </resultMap>

第四步：创建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">
  6. <configuration>
  7.     <!-- settings：控制mybatis全局行为 -->
  8.     <settings>
  9.         <!-- 设置mybatis输出日志 -->
  10.         <setting name="logImpl" value="STDOUT_LOGGING"/>
  11.     </settings>
  13.     <typeAliases>
  14.         <!-- 实体类所在的包名 -->
  15.         <package name="org.example.entity"/>
  16.     </typeAliases>
  18.     <mappers>
  19.         <mapper resource="org/example/dao/StudentDao.xml"/>
  20.     </mappers>
  21. </configuration>

第五步：创建service接口和实现类，属性是dao

  1. import org.example.entity.Student;
  2. import java.util.List;
  4. public interface StudentService {
  6.     List<Student> QueryAllStudent();
  7.     int InsertStudent(Student stu);
  8. }
  1. import org.example.dao.StudentDao;
  2. import org.example.entity.Student;
  3. import org.example.service.StudentService;
  4. import java.util.List;
  6. public class StudentServiceImpl implements StudentService {
  8.     private StudentDao studentDao;
  10.     @Override
  11.     public List<Student> QueryAllStudent() {
  12.         return studentDao.QueryAllStudent();
  13.     }
  15.     @Override
  16.     public int InsertStudent(Student stu) {
  17.         return studentDao.InsertStudent(stu);
  18.     }
  20.     public void setStudentDao(StudentDao studentDao) {
  21.         this.studentDao = studentDao;
  22.     }
  23. }

第六步：创建spring主配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  6.     <!--  声明数据源，代替mybatis的数据库
  7.             init-method:开始时执行的方法
  8.             destroy-method：结束时执行的方法
  9.     -->
  10.     <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
  11.           init-method="init" destroy-method="close">
  12.         <property name="url" value="jdbc:mysql://localhost:3306/ssm?useSSL=false&amp;serverTimezone=UTC" />
  13.         <property name="username" value="root" />
  14.         <property name="password" value="密码" />
  15.         <property name="maxActive" value="20" />
  16.     </bean>
  18.     <!--  声明Mybatis中提供的SqlSessionFactoryBean类，创建SqlSessionFactory  -->
  19.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean" >
  20.         <!--  set注入，将数据库连接池赋值给dataSource属性 -->
  21.         <property name="dataSource" ref="myDataSource" />
  22.         <!--  set注入，指定mybatis主配置文件的位置  -->
  23.         <property name="configLocation" value="classpath:mybatis.xml" />
  24.     </bean>
  26.     <!--  使用SqlSession的getMapper(Class)创建dao对象
  27.             MapperScannerConfigurer：在内部调用getMapper(Class)生成每个dao接口的代理对象
  28.                                      需要指定sqlSessionFactory对象的id
  29.       -->
  30.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer" >
  31.         <!--  指定sqlSessionFactory对象的id -->
  32.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
  33.         <!--  指定dao接口所在的包名
  34.                 MapperScannerConfigurer会扫描这个包中的所有接口(多个包用逗号分隔)，
  35.                 把每个接口都执行一次getMapper()方法，得到每个接口的dao对象(对象名默认以接口名首字母小写)
  36.          -->
  37.         <property name="basePackage" value="org.example.dao" />
  38.     </bean>
  40.     <!--  声明service  -->
  41.     <bean id="studentService" class="org.example.service.impl.StudentServiceImpl" >
  42.         <!--  set注入，将spring创建的studentDao对象赋值给studentDao属性  -->
  43.         <property name="studentDao" ref="studentDao" />
  44.     </bean>
  45. </beans>

最后测试：

  1. @Test
  2. public void test01()
  3. {
  4.     String config = "spring-config.xml";
  5.     ApplicationContext ac = new ClassPathXmlApplicationContext(config);
  6.     // 获取到service对象
  7.     StudentService std = (StudentService) ac.getBean("studentService");
  8.     List<Student> students = std.QueryAllStudent();
  9.     students.forEach(x -> System.out.println(x));
  10. }

mybatis-plus

官方文档：https://mp.baomidou.com

全新的 MyBatis-Plus 3.0 版本基于 JDK8，提供了 lambda 形式的调用

Spring Boot 工程：

  • 配置 MapperScan 注解

Navicat Premium 15 永久激活版安装教程 - 简书 (jianshu.com)

条件构造器

警告:

不支持以及不赞成在 RPC 调用中把 Wrapper 进行传输

  1. wrapper 很重
  2. 传输 wrapper 可以类比为你的 controller 用 map 接收值(开发一时爽,维护火葬场)
  3. 正确的 RPC 调用姿势是写一个 DTO 进行传输,被调用方再根据 DTO 执行相应的操作
  4. 我们拒绝接受任何关于 RPC 传输 Wrapper 报错相关的 issue 甚至 pr

RPC：远程过程调用协议。所谓远程过程调用，通俗的理解就是可以在本地程序中调用运行在另外一台服务器上的程序的功能方法。这种调用的过程跨越了物理服务器的限制，是在网络中完成的，在调用远端服务器上程序的过程中，本地程序等待返回调用结果，直到远端程序执行完毕，将结果进行返回到本地，最终完成一次完整的调用。

DTO：DTO就是数据传输对象(Data Transfer Object)的缩写。 DTO模式，是指将数据封装成普通的JavaBeans，在J2EE多个层次之间传输。 DTO类似信使，是同步系统中的Message。 该JavaBeans可以是一个数据模型Model。

设计一个dto：

（1）定义一个父类，在父类中就是共同的字段；

（2）定义子类，子类继承父类，然后子类在定义自己的私有字段。