第一片心意
第一片心意

MyBatis&Plus笔记

本博客对应B站尚学堂 mybatis&mubatis-plus 学习视频，连接：点我

1. MyBatis入门

MyBatis 本是Apache的一个开源项目iBatis, 2010年这个项目由Apache Software
Foundation 迁移到了Google Code，且改名为MyBatis。2013年11月迁移到GitHub。iBATIS一词来源于"internet"和"abatis"的组合，是一个基于Java的持久层框架。

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。

关键字：框架、ORM、持久层

1.1. 认识框架

框架（Framework）是一个框子–指其约束性，也是一个架子–指其支撑性。是一个基本概念上的结构，用于去解决或者处理复杂的问题。框架这个广泛的定义使用的十分流行，尤其在软件概念。

框架( Framework )是构成一类特定软件可复用设计的一组相互协作的类。框架规定了你的应用的体系结构。它定义了整体结构，类和对象的分割，各部分的主要责任，类和对象怎么协作，以及控制流程。框架预定义了这些设计参数，以便于应用设计者或实现者能集中精力于应用本身的特定细节。

在开发过程使用框架，同样可以保证减少开发时间、降低开发难度，并且还保证设计质量。好比和世界上最优秀的软件工程师是一个项目的，并且他们完成的还是基础、全局的工作。

框架还有一个作用是约束。同样的技术解决同样的问题会产生不同流程和风格的解决方案，而采用一种框架其实就是限制用户必须使用其规定的方案来实现，可以降低程序员之间沟通以及日后维护的成本。

常用的基于JavaEE的三大开源框架，已经从SSH、SSH2过渡到了SSM：SpringMVC、Spring、MyBatis。

总之，框架是一个半成品，已经对基础的代码进行了封装并提供相应的API，开发者在使用框架是直接调用封装好的API可以省去很多代码编写，从而提高工作效率和开发速度。

1.2. 认识ORM

JDBC的缺点：需要手动完成面向对象的Java语言、面向关系的数据库之间数据的转换，代码繁琐无技术含量，影响了开发效率。

如下所示，查询需要手动的将结果集的列数据转换为Java对象的属性；而添加操作时需要手动将Java对象的属性转换为数据库表的列字段。

rs = stmt.executeQuery(sql);
//5.必理结果（将ResultSet的数据封装到一个List中）while (rs.next ()){
//获取当前行各个字段的值
int empno = rs.getInt(columnLabel:"empno");
String ename = rs.getString(columnLabel:"ename");
String job = rs.getString(columnLabel:"job");
int mgr = rs.getInt(columnLabel:"mgr");
Date hireDate = rs.getDate(columnLabel:"HIREDATE");
double sal = rs.getDouble(columnLabel:"SAL");
double comm = rs.getDouble(columnLabel:"COMM");
int deptno = rs.getInt(columnLabel:"DEPTNO");//将当前行各个字段的值封装到一个Emp对象中
Emp emp = new Emp(empno, ename, job, mgr, hireDate, sal, comm, deptno);
//将Emp.对象添加到集合中list.add(emp);

try {
    //2.建立和数据库的连接
    conn = DBUtil.getConnection();//3.创建一个SQL命分发送器
    String sql `="insert into emp values(null,?,?,?,?,?,?,?)";
    pstmt = conn.prepareStatement(sql);
    //4.准备好SQL语句，通过SQL命分发送器发运给数据库，并得到结果
    pstmt.setString(parameterIndex:1, emp.getEname());
    pstmt.setString(parameterIndex:2, emp.getJob());
    pstmt.setInt(parameterIndex:3, emp.getMgr());
    pstmt.setDate(parameterIndex:4, new Date(emp.getHireDate().getTime()));
    pstmt.setDouble(parameterlndex:5, emp.getSal());
    pstmt.setDouble(parameterIndex:6, emp.getComm());
    pstmt.setInt(parameterlndex:7, emp.getDeptno());
    n = pstmt.executeUpdate();
} catch (SQLException e) {
    e.printStackTrace();
} finally {
    //6.关闭资源
    DBUtil.closeAll(rs, pstmt, conn);
}

关于面向对象的Java语言、面向关系的数据库之间数据的转换必须要做，问题在于这个转换是否可以不由开发者来做。

ORM框架就是专门来做这个问题的，相当于在面向对象语言和关系数据库之间搭建了一个桥梁。

ORM，Object-Relationl
Mapping，对象关系映射，它的作用是在关系型数据库和对象之间做一个映射，然后我们在具体操作数据库的时候，只要像平时操作对象一样操作它就可以了，ORM框架会根据映射完成对数据库的操作，就不需要再去和复杂的SQL语句打交道了。

MyBatis&Plus笔记_第1张图片

另外学习ORM必须知道两个概念：持久化、持久层

什么是"持久化"

持久化（Persistence），即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的数据存储在关系型的数据库中，当然也可以存储在磁盘文件中、XML数据文件中等等。

什么是 “持久层”

持久层（Persistence
Layer），即专注于实现数据持久化应用领域的某个特定系统的一个逻辑层面，将数据使用者和数据实体相关联。之前使用JDBC访问数据库的DAO层，后面采用MyBatis访问数据库的mapper层，就是持久层。

1.3. 认识MyBatis

MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录.

精简解释：MyBatis是一个半自动ORM框架，其本质是对JDBC的封装。使用MyBatis重点需要程序员编写SQL命令，不需要写一行JDBC代码。

1.3.1. 1.4 和Hibernate的比较(了解)

Hibernate是一个全自动的ORM框架。因为Hibernate创建了Java对象和数据库表之间的完整映射，可以完全以面向对象的思想来操作数据库，程序员不需要手写SQL语句，而MyBatis中还需要手写SQL语句，所以是半自动化的，工作量要大于Hibernate。

为什么半自动化的MyBatis比自动化的Hibernate受欢迎?

MyBatis需要手写SQL语句，所以工作量要大于Hibernate。但是也正是由于自定义SQL语句，所以其灵活性、可优化性就超过了Hibernate。

Hibernate封装了SQL语句，由开发者对对象操作，Hibernate来生成SQL语句。虽然也可以通过映射配置来控制生成的SQL语句，但是对于要生成复杂的SQL语句，很难实现，或者实现后导致性能的丢失。

而MyBatis将手写SQL语句的工作丢给开发者，可以更加精确的定义SQL，更加灵活，也便于性能优化。完成同样功能的两条SQL语句的性能可能相差十几倍到几十倍，在高并发、快响应要求下的互联网系统中，对性能的影响更明显。

MyBatis对存储过程可提供很好的支持。另外MyBatis的开发工作量大不意味着学习成本大。对于新手，学习Hibernate时间成本比Mybatis大很多，Mybatis很快就上手了。

总之，因为MySQL具有封装少、映射多样化、支持存储过程、可以进行SQL语句优化等特点，符合互联网高并发、大数据、高性能、高响应的要求，使它取代Hibernate成为了Java互联网中首选的持久框架。而对于对性能要求不高的比如内部管理系统、ERP等可以使用Hibernate。

2. MyBatis快速上手

任务：使用MyBatis完成对Emp单表的CRUD操作。准备完毕后项目结构如图所示。

MyBatis&Plus笔记_第2张图片

2.1. 搭建MyBatis环境

2.1.1. 加入jar包

MyBatis运行需要其核心包以及依赖包，这些jar包可以从MyBatis官网下载包中找到，同时还要添加JDBC访问数据库的驱动包。

如果需要使用JUnit进行单元测试，还需要加入JUnit的相关jar包。

2.1.2. 准备配置文件

在src下定义MyBatis的配置文件，无固定名称。mybatis.cfg.xml是官方源码配置文件名称，从框架规范角度上考虑我们也叫这个名字。在配置文件中定义影响
MyBatis 的设置和属性信息。这里先来定义数据库的连接信息和事务管理信息。


DOCTYPE configuration
        PUBLIC "http://mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="mysql">
        <environment id="mysql">
            
            <transactionManager type="JDBC">transactionManager>
            
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            dataSource>
        environment>
    environments>
configuration>

注意事项：

  1. XML文件需要提供dtd或者xsd文件，来定义XML文件的标签结构。

  2. 数据库四个连接参数的name属性的值来自org.apache.ibatis.datasource.unpooled包下类UnpooledDataSource。

    public class UnpooledDataSource implements DataSource {
	private ClassLoader driverClassLoader;
	private Properties driverProperties;
	private static Map<String, Driver> registeredDrivers = new ConcurrentHashMap<>();

	private String driver;
	private String url;
	private String username;
	private String password;

	private Boolean autocommit;
	private Integer defaultTransactionIsolationLevel;
    private Integer defaultNetworkTimeout;
}

2.1.3. 准备映射文件

MyBatis的主要工作就是进行映射，甚至可以占到全部工作量的80%以上。MyBatis的映射可以通过XML和注解来实现。面对复杂的SQL语句，注解也会力不从心。所以MyBaits中更多使用XML配置来实现。

此处创建映射文件EmployeeMapper.xml，和实体类Employee对应。


DOCTYPE mapper
        PUBLIC "http://mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.bjsxt.mapper.EmployeeMapper">
mapper>

目前对文件名没有要求，建议采用实体名+Mapper的方式命名。

namespace：命名空间。


DOCTYPE mapper
        PUBLIC "http://mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.bjsxt.mapper.EmployeeMapper">
mapper>

定义好映射件后，需要在MyBatis的配置文件指明映射文件的位置，这个位置是相对于项目根目录的位置。

<mappers>
    <mapper resource="com/bjsxt/mapper/EmployeeMapper.xml"/>
mappers>

2.1.4. 准备log4j

在mybatis.cfg.xml中配置MyBatis所使用的具体日志实现。如果不指定将自动搜索。可能会搜到log4j，也可能会搜到了其他的日志实现，所以还是设置为好。

<settings>
    <setting name="logImpl" value="LOG4J"/>
settings>

将log4j.properties文件放到资源目录下。可以将全局的日志级别调高，避免大量debug信息的干扰。同时将对映射文件的日志级别调低，用来显示SQL语句的调试信息。开发阶段，建议启动控制的日志。

#定义全局日志级别
log4j.rootLogger=error,stdout,logfile
#包级别日志
log4j.logger.com.bjsxt.mapper=debug
#接口级别日志
#log4j.logger.com.bjsxt.mapper.EmployeeMapper=debug
#方法级别日志
#log4j.logger.com.bjsxt.mapper.EmployeeMapper.findBy=debug
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.err
log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout

2.2. 完成多个select操作

搭建好MyBatis环境后，完成select操作，只涉及到映射文件和测试类。

在mapper文件中加入以下代码。

<select id="selectAll" resultType="com.bjsxt.entity.Employee">
    select *
    from emp
select>
<select id="selectById" resultType="com.bjsxt.entity.Employee" parameterType="int">
    select *
    from emp
    where empno = #{param1}
select>
<select id="selectEmp" resultType="com.bjsxt.entity.Employee" parameterType="com.bjsxt.entity.Employee">
    select *
    from emp
    where job = #{job}
    	and deptno = #{deptno}
select>

在对应的接口中加入以下代码。

public List<Employee> selectAll();
public Employee selectById(Integer id);
public List<Employee> selectEmp(Employee employee);

如果idea安装了mybatis相关插件的话，可以看到接口和配置文件中方法和sql语句的对应关系。

注意事项：

  1. id要求唯一。

  2. paramterType参数类型，可以省略。如果提供该参数，必须写正确类型。MyBatis可以通过类型处理器(TypeHandler)推断出具体传入语句的参数。parameterType取值只能是一个类型，相当于方法参数只能是一个参数（类型不限），局限性比较大。后续开发中都省略此参数。

  3. resultType 返回值类型。

    1. 返回值是集合，resultType取值为集合的元素泛型类型的完整路径名。

    2. 返回值是对象，resultType取值为对应类的完整路径名。

  4. 关于方法参数传递。

    1. 参数是基本数据类型，使用 #{param1} 来接收数据（其实可以是任意名称）。

    2. 参数是引用数据类型，使用 $(属性名) 接收数据，底层调用的是其getter方法。如果没有getter方法，就会直接找同名属性。

  5. 初学者最直观感受是mapper.xml是编写SQL命令的文件，实际上这个文件相当分层开发中dao.impl下的数据访问层实现类（也可以说MyBatis一个好处就是不用写DAO实现类了）。也就是说MyBatis会把mapper.xml文件解析成一个类。

测试类中利用SqlSession直接来发送SQL命令给服务器。常用方法有selectList()、selectOne()等。

public class TestEmployee {
    @Test
    public void testSelectAll() throws IOException {
        //创建SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis.cfg.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession
        SqlSession session = factory.openSession();
        //调用查询方法
        List<Employee> list = session.selectList("com.bjsxt.mapper.EmployeeMapper.selectAll");
        //关闭资源
        session.close();
        //输出结果
        list.forEach(System.out::println);
    }

    @Test
    public void testSelectById() throws IOException {
        Employee emp = session.selectOne("com.bjsxt.mapper.EmployeeMapper.selectById", 7839);
    }

    @Test
    public void testSelectEmp() throws IOException {
        Employee emp = new Employee();
        emp.setJob("CLERK");
        emp.setDeptno(20);
        List<Employee> list = session.selectList("com.bjsxt.mapper.EmployeeMapper.selectEmp", emp);
    }
}

其中TestSelectById() 、testSelectEmp()只提供了核心代码。

没有进行任何指定，MyBatis是如何把数据库查询结果中字段的值赋给Java中实体类的对应属性呢？这用到了自动映射技术。

Auto Mapping(结果自动映射)是 MyBatis 提供的按照名称自动把结果集中数据映射到对象属性的一种技术。查询到结果集后按照名称去类中找属性的set方法进行赋值。在新版本中如果属性没有提供set方法，则直接找同名属性进行赋值。

在映射过程中 MyBatis 会自动进行类型转换，也就是说即使 varchar 类型 name ，如果可以保证里面值都能被转换为数字，在Java中也可以使用int类型name接收。

在数据库中列名规范是xx_xxx这种形式，中间使用下划线分割。而在Java中属性名按照小驼峰方式进行命名，这就可能导致列名和属性名不一致的问题，针对这种方式最简单的处理办法就是给列起别名，进行auto mapping。

例如：列名 sxt_id 属性名sxtId 利用别名方式的SQL如下：

select sxt_id as sxtid from a_table

此处注意：列名或别名不考虑大小写问题

2.3. 完成DML操作

完成DML操作，在映射文件和接口中加入以下代码。

<insert id="insertEmp" parameterType="com.bjsxt.entity.Employee">
    insert into emp
    values (null, #{ename}, #{job}, #{mgr}, #{hireDate}, #{sal}, #{comm}, #{deptno})
insert>
<update id="updateEmp">
    update emp
    set job = #{job},
        sal = #{sal}
    where empno = #{empno}
update>
<delete id="deleteEmp">
    delete
    from emp
    where empno = #{param1}
delete>

int insertEmp(Employee employee);
int updateEmp(Employee employee);
int deleteEmp(Employee employee);

注意事项：

  1. DML操作的底层调用 executeUpdate()，返回值都是int类型，不需要提供，也不用 resultType 属性来指定。

  2. 其实insert、update、delete任何一个元素都可以完成所有DML操作的映射。

在测试类中完成对Emp表的DML操作，涉及事务的手动和自动提交。

public class TestEmployee1 {
    @Test
    public void insertEmp() throws IOException {
        //创建SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession，并设置自动提交事务
        SqlSession session = factory.openSession(true);
        //调用方法
        Employee emp = new Employee("zhangsan", "clerk", 7839, Date.valueOf("1999-12-23"), 800, 300, 10);
        emp.setJob("CLERK");
        emp.setDeptno(20);
        int n = session.insert("com.bjsxt.mapper.EmployeeMapper.insertEmp", emp);
        //关闭资源
        session.close();
        //输出结果
        System.out.println(n);
    }

    @Test
    public void updateEmp() throws IOException {
        //创建SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession，设置不自动提交事务
        SqlSession session = factory.openSession();
        //调用方法
        Employee emp = new Employee();
        emp.setJob("Manager");
        emp.setSal(3000);
        emp.setEmpno(7940);
        int n = session.update("com.bjsxt.mapper.EmployeeMapper.updateEmp", emp);
        //提交事务
        session.commit();
        //关闭资源
        session.close();
        //输出结果
        System.out.println(n);
    }

    @Test
    public void deleteEmp() {
        SqlSession session = null;
        try {
            //创建SqlSessionFactory
            InputStream is = Resources.getResourceAsStream("mybatis.xml");
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
            //创建SqlSession，设置不自动提交事务
            session = factory.openSession();
            //调用方法
            int n = session.delete("com.bjsxt.mapper.EmployeeMapper.deleteEmp", 7941);
            //提交事务
            session.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //回滚事务
            session.rollback();
        } finally {
            //关闭资源
            session.close();
        }
    }
}

注意事项：

  1. 执行DML操作，默认事务手动提交。此时可以两种方案解决

    1. 使用自动提交

    2. 手动执行commit ()或者rollback()结束事务

      推荐手动提交事务。因为复杂业务中一个事务会包括多个DML操作，自动提交只能做到一个事务只有一个DML操作。

  2. 其实一个SqlSession的update、delete、insert中任意一个方法均可完成所有DML操作。底层都是调用的update方法，就好比JDBC中的 executeUpdate() 可以完成DML操作一样。

    MyBatis&Plus笔记_第3张图片

3. MyBatis功能详解

3.1. 关于jar包

编号 元素列表 作用
1 mybatis-3.5.2.jar Mybatis核心jar包
2 ant-1.10.3.jar 将软件编译、测试、部署等步骤联系在一起加以自动化的一个软件构建工具
3 ant-launcher-1.10.3.jar 将软件编译、测试、部署等步骤联系在一起加以自动化的一个软件构建工具
4 asm-7.0.jar 代码生成，代码混淆，代码转换等等以字节码为操作目标的工作，一定程度上类似javac的功能
5 cglib-3.2.10.jar 实现动态代理的技术，延迟加载时使用
6 javassist-3.24.1-GA.jar 可用来检查、”动态”修改及创建 Java类。功能与JDK自带反射功能类似，但比反射功能更强大
7 ognl-3.2.10.jar 对象导航图语言的缩写，功能强大的表达式语言工具包。在动态SQL和${param}中使用
8 commons-logging-1.2.jar 日志包
9 slf4j-api-1.7.26.jar 日志包
10 slf4j-log4j12-1.7.26.jar 日志包
11 log4j-1.2.17.jar 日志包
12 log4j-api-2.11.2.jar 日志包
13 log4j-core-2.11.2.jar 日志包

3.2. 关于核心API

SqlSessionFactoryBuilder

根据配置或者代码生成SqlSessionFactory，采用的是分步构建的构建者模式。

SqlSessionFactory

生产SqlSession，使用的是工厂模式。

SqlSession

可获取Mapper的接口，相当于Connection，也可以发送SQL语句并返回结果。

Mapper

映射器。由一个Java接口和XML文件（或者注解构成），需要给出对应的SQL和映射规则，负责发送SQL去执行并返回结果。

生命周期

SqlSessionFactoryBuilder

该类用来创建SqlSessionFactory对象，当SqlSessionFactory对象被创建后，该对象也就没有存在的必要了。

SqlSessionFactory

该对象应该在你的应用执行期间一直存在，由于要从该对象中获取SqlSession对象，这样的操作会相当频繁，同时创建SqlSessionFactory对象是一件一起消耗资源的事，因此，该对象的生命周期当前应用具有相同生命周期。

SqlSession

每个线程都应该有自己的SqlSession实例，SqlSession实例不能被共享，是线程不安全的，因此最佳的范围是请求或方法范围。

Mapper

关闭SqlSessin的时候也就关闭了由其所产生的Mapper。

3.3. 关于配置文件

  1. transactionManager

    在 MyBatis 中有两种事务管理器类型(也就是
    type=“[JDBC|MANAGED]”):

    1. JDBC – 这个配置直接简单使用了 JDBC
      的提交和回滚设置。它依赖于从数据源得到的连接来管理事务范围。

    2. MANAGED –
      这个配置几乎没做什么。它从来不提交或回滚一个连接。而它会让容器来管理事务的整个生命周期(比如 Spring 或 JEE 应用服务器的上下文) 。

      在MyBatis核心包中可以看到两种事务管理器类型的相关类。

      MyBatis&Plus笔记_第4张图片

  2. dataSource

    有三种内建的数据源类型(也就是 type=“???”):

    1. UNPOOLED –
      这个数据源的实现是每次被请求时简单打开和关闭连接。它有一点慢,
      这是对简单应用程序的一个很好的选择,
      因为它不需要及时的可用连接。UNPOOLED 类型的数据源仅仅需要配置以下 5 种属性：

      1. driver – 这是 JDBC 驱动的 Java 类的完全限定名。
      2. url– 这是数据库的 JDBC URL 地址。
      3. username– 登录数据库的用户名。
      4. password– 登录数据库的密码。
      5. defaultTransactionIsolationLevel – 默认的连接事务隔离级别。

    2. POOLED – 这是 JDBC
      连接对象的数据源连接池的实现,用来减少创建新的连接实例时的初始连接和认证时间。一种当前 Web 应用程序用来快速响应请求很流行的方法。 除了上述提到 UNPOOLED 下的属性外，还有更多属性用来配置 POOLED 的数据源：

      1. poolMaximumActiveConnections – 在任意时间可以存在的活动（也就是正在使用）连接数量，默认值：10。
      2. poolMaximumIdleConnections – 任意时间可以存在的空闲连接数。
      3. poolMaximumCheckoutTime – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000
        毫秒（即 20 秒）。
      4. poolTimeToWait – 这是一个底层设置，如果获取连接花费了相当长的时间，连接池会打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直安静的失败），默认值：20000
        毫秒（即 20 秒）。
      5. poolMaximumLocalBadConnectionTolerance --这是一个关于坏连接容忍度的底层设置，作用于每一个尝试从缓存池获取连接的线程。如果这个线程获取到的是一个坏的连接，那么这个数据源允许这个线程尝试重新获取一个新连接，但这个重新尝试次数不应超过 poolMaximumIdleConnections 与 poolMaximumLocalBadConnectionTolerance之和。 默认值：3 （新增于 3.4.5）。
      6. poolPingQuery – 发送到数据库的侦测查询SQL语句，用来检验连接是否正常工作并准备接受请求。默认是"NO PING QUERY SET"，这会导致多数数据库驱动失败时带有一个恰当的错误消息。
      7. poolPingEnabled --是否启用侦测查询。若开启，需要设置 poolPingQuery属性为一个可执行的 SQL 语句（最好是一个速度非常快的 SQL 语句），默认值：false。
      8. poolPingConnectionsNotUsedFor – 配置 poolPingQuery 的频率。可以被设置为和数据库连接超时时间一样，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。

    3. JNDI – 这个数据源实现是为了使用如 Spring 或应用服务器这类容器,
      容器可集中或在外部配置数据源,然后放置一个 JNDI
      上下文的引用。这个数据源配置只需要两个属性。

      1. initial_context – 这个属性用来在 InitialContext 中寻找上下文（即，initialContext.lookup(initial_context)）。这是个可选属性，如果忽略，那么将会直接从 InitialContext 中寻找 data_source 属性。

      2. data_source– 这是引用数据源实例位置的上下文的路径。提供了 initial_context 配置时会在其返回的上下文中进行查找，没有提供时则直接在 InitialContext 中查找。

        在MyBatis核心包中可以看到三种内置数据源类型的相关类。

        MyBatis&Plus笔记_第5张图片

  3. mappers
    告诉了 MyBatis 去哪里找映射文件。

    
<mappers>
    <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
    <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
    <mapper resource="org/mybatis/builder/PostMapper.xml"/>
mappers>

<mappers>
    <mapper url="file:///var/mappers/AuthorMapper.xml"/>
    <mapper url="file:///var/mappers/BlogMapper.xml"/>
    <mapper url="file:///var/mappers/PostMapper.xml"/>
mappers>

<mappers>
    <mapper class="org.mybatis.builder.AuthorMapper"/>
    <mapper class="org.mybatis.builder.BlogMapper"/>
    <mapper class="org.mybatis.builder.PostMapper"/>
mappers>

<mappers>
    <package name="org.mybatis.builder"/>
mappers>

    推荐使用第四种方式，但前提是一定要显式的提供相应的接口定义，且要求接口名和mapper.xml文件名必须完全相同。

3.4. 关于日志管理

Mybatis 的内置日志工厂（LogFactory）提供日志功能，内置日志工厂将日志交给以下其中一种工具作代理：

  • SLF4J

  • Apache Commons Logging

  • Log4j 2

  • Log4j

  • JDK logging

  • NO_LOGGING

MyBatis 内置日志工厂基于运行时自省机制选择合适的日志工具。它会使用第一个查找得到的工具（按上文列举的顺序查找）。如果一个都未找到，日志功能就会被禁用。也就是说在项目中把日志工具环境配置出来后，不用在MyBatis进行配置就可以让日志生效。

LogFactory.java

static {
    tryImplementation(LogFactory::useSlf4jLogging);
    tryImplementation(LogFactory::useCommonsLogging);
    tryImplementation(LogFactory::useLog4J2Logging);
    tryImplementation(LogFactory::useLog4JLogging);
    tryImplementation(LogFactory::useJdkLogging);
    tryImplementation(LogFactory::useNoLogging);
}

不少应用服务器（如 Tomcat 和 WebShpere）的类路径中已经包含 Commons Logging，所以在这种配置环境下的 MyBatis 会把它作为日志工具，记住这点非常重要。这将意味着，在诸如 WebSphere 的环境中，它提供了 Commons Logging 的私有实现，你的 Log4J 配置将被忽略。MyBatis 将你的 Log4J
配置忽略掉是相当令人郁闷的（事实上，正是因为在这种配置环境下，MyBatis 才会选择使用 Commons Logging 而不是 Log4J）。如果你的应用部署在一个类路径已经包含 Commons Logging 的环境中，而你又想使用其它日志工具，你可以通过在 MyBatis 配置文件 mybatis-config.xml 里面添加一项 setting 来选择别的日志工具。

<settings>
    <setting name="logImpl" value="LOG4J"/>
settings>

Configuration.java

public void setLogImpl(Class<? extends Log> logImpl) {
    if (logImpl != null) {
        this.logImpl = logImpl;
        LogFactory.useCustomLogging(this.logImpl);
    }
}

无论使用哪种日志工具对于程序员来说目的都是一样：打印运行过程中的日志信息。日志信息中对平时开发最重要的是运行过程中SQL的打印，这也是在开发过程中MyBatis日志的重要性。

4. MyBatis配置完善

4.1. 使用别名alias

类型别名是为 Java 类型命名一个短的名字。它只和 XML 配置有关,只用来减少类完全限定名的多余部分。注意：别名都是不区分大小写的。

在配置文件中为类的完整路径定义别名，可以采用两种方式

  1. 使用typeAlias指定单个类的别名。

    <typeAliases>
    <typeAlias type="com.bjsxt.entity.Employee" alias="employee">typeAlias>
typeAliases>

  2. 使用package指定某个包下所有类的默认别名。

    <typeAliases>
    <package name="com.bjsxt.entity"/>
typeAliases>

引入别名后的映射文件就可以进行如下配置。

<select id="selectEmp" resultType="employee" parameterType="employee">
    select *
    from emp
    where job = #{job}
    	and deptno = #{deptno}
select>

注意：不建议使用类别名，会降低代码的阅读性，增加后期维护成本。

对于普通的 Java 类型,有许多内建的类型别名。

别名 映射的类型 别名 映射的类型 别名 映射的类型
_byte byte string String date Date
_long long byte Byte decimal BigDecimal
_short short long Long bigdecimal BigDecimal
_int int short Short object Object
_integer int int Integer map Map
_double double integer Integer hashmap HashMap
_float float double Double list List
_boolean boolean float Float arraylist ArrayList
boolean Boolean collection Collection
iterator Iterator

其实这些系统内置的别名设置都是在org.apache.ibatis.type.TypeAliasRegistry类中指定并注册的。

TypeAliasRegistry.java

public class TypeAliasRegistry {

  private final Map<String, Class<?>> typeAliases = new HashMap<>();

  public TypeAliasRegistry() {
    registerAlias("string", String.class);

    registerAlias("byte", Byte.class);
    registerAlias("long", Long.class);
    registerAlias("short", Short.class);
    registerAlias("int", Integer.class);
    registerAlias("integer", Integer.class);
    registerAlias("double", Double.class);
    registerAlias("float", Float.class);
    registerAlias("boolean", Boolean.class);

    registerAlias("byte[]", Byte[].class);
    registerAlias("long[]", Long[].class);
    registerAlias("short[]", Short[].class);
    registerAlias("int[]", Integer[].class);
    registerAlias("integer[]", Integer[].class);
    registerAlias("double[]", Double[].class);
    registerAlias("float[]", Float[].class);
    registerAlias("boolean[]", Boolean[].class);

    registerAlias("_byte", byte.class);
    registerAlias("_long", long.class);
    registerAlias("_short", short.class);
    registerAlias("_int", int.class);
    registerAlias("_integer", int.class);
    registerAlias("_double", double.class);
    registerAlias("_float", float.class);
    registerAlias("_boolean", boolean.class);

    registerAlias("_byte[]", byte[].class);
    registerAlias("_long[]", long[].class);
    registerAlias("_short[]", short[].class);
    registerAlias("_int[]", int[].class);
    registerAlias("_integer[]", int[].class);
    registerAlias("_double[]", double[].class);
    registerAlias("_float[]", float[].class);
    registerAlias("_boolean[]", boolean[].class);

    registerAlias("date", Date.class);
    registerAlias("decimal", BigDecimal.class);
    registerAlias("bigdecimal", BigDecimal.class);
    registerAlias("biginteger", BigInteger.class);
    registerAlias("object", Object.class);

    registerAlias("date[]", Date[].class);
    registerAlias("decimal[]", BigDecimal[].class);
    registerAlias("bigdecimal[]", BigDecimal[].class);
    registerAlias("biginteger[]", BigInteger[].class);
    registerAlias("object[]", Object[].class);

    registerAlias("map", Map.class);
    registerAlias("hashmap", HashMap.class);
    registerAlias("list", List.class);
    registerAlias("arraylist", ArrayList.class);
    registerAlias("collection", Collection.class);
    registerAlias("iterator", Iterator.class);

    registerAlias("ResultSet", ResultSet.class);
  }

另外在org.apache.ibatis.session.Configuration的无参数构造方法中有更多的别名设置，比如JDBC、POOLED、LOG4J。

Configuration.java

public Configuration() {
    typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
    typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);

    typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
    typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
    typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

    typeAliasRegistry.registerAlias("PERPETUAL", PerpetualCache.class);
    typeAliasRegistry.registerAlias("FIFO", FifoCache.class);
    typeAliasRegistry.registerAlias("LRU", LruCache.class);
    typeAliasRegistry.registerAlias("SOFT", SoftCache.class);
    typeAliasRegistry.registerAlias("WEAK", WeakCache.class);

    typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);

    typeAliasRegistry.registerAlias("XML", XMLLanguageDriver.class);
    typeAliasRegistry.registerAlias("RAW", RawLanguageDriver.class);

    typeAliasRegistry.registerAlias("SLF4J", Slf4jImpl.class);
    typeAliasRegistry.registerAlias("COMMONS_LOGGING", JakartaCommonsLoggingImpl.class);
    typeAliasRegistry.registerAlias("LOG4J", Log4jImpl.class);
    typeAliasRegistry.registerAlias("LOG4J2", Log4j2Impl.class);
    typeAliasRegistry.registerAlias("JDK_LOGGING", Jdk14LoggingImpl.class);
    typeAliasRegistry.registerAlias("STDOUT_LOGGING", StdOutImpl.class);
    typeAliasRegistry.registerAlias("NO_LOGGING", NoLoggingImpl.class);

    typeAliasRegistry.registerAlias("CGLIB", CglibProxyFactory.class);
    typeAliasRegistry.registerAlias("JAVASSIST", JavassistProxyFactory.class);

    languageRegistry.setDefaultDriverClass(XMLLanguageDriver.class);
    languageRegistry.register(RawLanguageDriver.class);
}

4.2. 引入属性文件

将数据库的四个连接参数放入属性文件，更便于修改维护。此时需要在配置文件中指定属性文件的位置，并给四个连接属性赋值。

<properties resource="jdbc.properties">properties>
<environments default="mysql">
    <environment id="mysql">
        <transactionManager type="jdbc">transactionManager>
        <dataSource type="pooled">
            <property name="driver" value="${driver}"/>
            <property name="url" value="${url}"/>
            <property name="username" value="${user}"/>
            <property name="password" value="${pwd}"/>
        dataSource>
    environment>
environments>

4.3. 提供工具类复用代码

定义MyBatisUtil工具类，封装获取SqlSession和关闭SqlSession的操作。

public class DBUtil {
    private static SqlSessionFactory factory;

    /*
     * 获取SqlSession
     */
    static {
        //创建SqlSessionFactory
        InputStream is = null;
        try {
            is = Resources.getResourceAsStream("mybatis-cfg.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        factory = new SqlSessionFactoryBuilder().build(is);
    }

    public static SqlSession getSqlSession() {
        return factory.openSession();
    }

    /**
     * 关闭SqlSession
     *
     */
    public static void closeSqlSession(SqlSession sqlSession) {
        if (sqlSession != null) {
            //关闭sqlSession
            sqlSession.close();
        }
    }
}

测试类中使用MyBatisUtil类，可以简化操作。

public class TestEmployee {
    @Test
    public void updateEmp3() throws IOException {
        //创建SqlSession
        SqlSession session = DBUtil.getSqlSession();
        //调用查询方法
        Employee emp = new Employee();
        emp.setJob("Manager");
        emp.setSal(4000);
        emp.setEmpno(7943);
        int n = session.update("com.bjsxt.mapper.EmMapper.updateEmp", emp);
        session.commit();
        //关闭资源
        DBUtil.closeSqlSession(session);
        //输出结果
        System.out.println(n);
    }
}

4.4. idea使用技巧：引入本地DTD文件

在没有联网的情况下，让dtd约束继续起作用，并且出现标签提示，可以通过引入本地dtd文件来实现。

下载dtd：在浏览器中输入dtd的网络地址即可实现下载。比如：http://mybatis.org/dtd/mybatis-3-config.dtd。

将下载的dtd拷贝到本地的一个目录下

Idea操作路径：File—Settings—Languages & Frameworks

MyBatis&Plus笔记_第6张图片

其中URI 复制dtd的网络地址即可。File选择dtd文件在本地的地址。OK!

注：在MyBatis的核心jar包中就提供了mybatis-3-config.dtd.

4.5. idea使用技巧：创建文件模板

idea提供了大量的内置文件模板template，可以自定义模板，避免重复，提高效率。

创建入口1：右键----new----Edit file Templates

创建入口2：File–settings—editor—File and Code Templates

使用入口：右键----new---- 选择模板名称

MyBatis&Plus笔记_第7张图片

5. Mapper代理

前面已经使用MyBatis完成了对Emp表的CRUD操作，都是由SqlSession调用自身方法发送SQL命令并得到结果的，实现了MyBatis的入门。

但是却存在如下缺点：

  1. 不管是selectList()、selectOne()、selectMap()，都只能提供一个查询参数。如果要多个参数，需要封装到JavaBean中，并不一是一个好办法。

  2. 返回值类型较为固定。

  3. 只提供了映射文件，没有提供数据库操作的接口，不利于后期的维护扩展。

在MyBatis中提供了另外一种成为Mapper代理（或称为接口绑定）的操作方式。在实际开发中推荐使用该方式。

下面使用 Mapper 代理的方式来实现对Emp表的CRUD操作，完成多个参数传递、模糊查询、分页查询、自增主键回填等更多的实现。搭建好的项目框架如图所示，相比而言，增加了接口EmployeeMapper。但是却会引起映射文件和测试类的变化。

MyBatis&Plus笔记_第8张图片

5.1. 使用Mapper代理方式实现查询

首先定义接口EmployeeMapper

public interface EmployeeMapper {
    public List<Employee> findAll();
    public Employee findById(int empno);
    public Employee findById2(int empno);
}

定义映射文件EmployeeMapper.xml，要求映射文件名必须和接口名相同。

在映射文件中进行配置

<mapper namespace="com.bjsxt.mapper.EmployeeMapper">
    <select id="findAll" resultType="employee">
        select empno,ename,sal,comm,deptno from emp
    select>
    <select id="findById" resultType="employee">
        select empno,ename,sal,comm,deptno from emp
        where empno = #{empno}
    select>
    <select id="findById2" resultType="employee">
        select empno,ename,sal,comm,deptno from emp
        where empno = ${ename}
    select>
mapper>

注意

  1. 使用Mapper代理方式，namespace必须是接口的全路径名。

  2. 使用Mapper代理方式，select等映射标签的id必须是接口中方法的名字。

  3. 使用**#{}，底层使用PreparedStatement**；而使用**${}，底层使用Statement**，会有SQL注入风险，不建议使用。

测试类完成对数据库的相关操作

public class TestEmployee {
    @Test
    public void testFindAll() throws IOException {
        //创建SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession
        SqlSession session = factory.openSession();
        //创建Mapper(使用代理模式创建一个EmployeeMapper的实现类)
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
        //调用方法
        List<Employee> list = mapper.findAll();
        //关闭资源
        session.close();
        //输出结果
        list.forEach(System.out::println);
    }

    @Test
    public void testFindById() throws IOException {
        //创建Mapper(使用代理模式创建一个EmployeeMapper的实现类)
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
        //调用方法
        //Employee emp = mapper.findById(7839);
        Employee emp = mapper.findById2(7839);
    }
}

注意：此时对数据库的操作不是由SqlSession发起，不是调用selectList()、selectOne()等方法，而是由EmployeeMapper接口发起，直接调用接口的方法，更容易理解。

EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);

这条语句的底层使用了动态代理模式，动态创建一个EmployeeMapper的一个代理对象并赋值给接口引用。所以在MyBatis中不需要显式提供Mapper接口的实现类，这也是简单的地方。

MyBatis&Plus笔记_第9张图片

5.2. 使用SQL元素重用数据库字段列表

在映射文件中，可以使用SQL标签定义SQL语句的一部分，方便SQL语句来引用。

比如最典型的就是数据库表的列名，通常情况下要在select、insert语句中来反复编写，此时就可以使用SQL元素编写一次，之后就可以多次引用了。

引用时要使用include元素来完成，避免了重复书写，也便于后期修改维护。

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <sql id = "cols1">
        empno,ename,sal,comm,deptno
    sql>
    <select id = "findAll" resultType = "employee">
        select
        <include refid = "cols1">
        include>
        from emp
    select>
    <select id = "findById" resultType = "employee">
        select
        <include refid = "cols1">
        include>
        from emp
        where empno = #{empno}
    select>
    <select id = "findById2" resultType = "employee">
        select
        <include refid = "cols1">
        include>
        from emp
        where empno = ${ename}
    select>
mapper>

6. 更多的映射

下面继续使用Mapper代理方式完成更多更复杂的数据库操作，涉及多个参数传递、模糊查询、分页查询、自增主键回填等内容。

6.1. 多参数传递

在EmployeeMapper接口中定义方法实现同时按照job、deptno两个字段完成信息查询。可以有四种方式来实现。分别为：

  1. 直接传递多个参数

    映射文件中，参数可以使用param1，param2…表示，或者使用arg0，arg1…表示，但可读性低。

  2. 使用Param注解传递多个参数

    映射文件中参数可以使用Param注解指定的名称来表示，同时保留使用param1，
    param2…表示，但是不可以再使用arg0，arg1…表示

  3. 使用JavaBean传递多个参数

    映射文件中的参数直接使用JavaBean的属性来接收，可读性高。底层调用是相应属性的getter方法。

  4. 使用Map传递多个参数

    映射文件中使用相应参数在map中的key来表示。

public interface EmployeeMapper {
    public List<Employee> findEmp(String job, int deptno);
    public List<Employee> findEmp2(@Param("job") String job, @Param("deptno") int deptno);
    public List<Employee> findEmp3(Employee emp);
    public List<Employee> findEmp4(Map<String, String> map);
}

因为映射文件元素的id要保持唯一，所以Mapper接口不允许存在重载的方法。

在映射文件完成SQL语句的编写，关键是参数的接收。

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    
    <select id = "findEmp" resultType = "employee">
        select * from emp where job = #{param1} and deptno = #{param2}
    select>
    
    <select id = "findEmp2" resultType = "employee">
        select * from emp where job = #{job} and deptno = #{deptno}
    select>
    
    <select id = "findEmp3" resultType = "employee">
        select * from emp where job = #{job} and deptno = #{deptno}
    select>
    
    <select id = "findEmp4" resultType = "employee">
        select * from emp where job = #{job} and deptno = #{deptNo}
    select>
mapper>

在测试类中完成SQL语句的调用和结果输出。

public class TestEmployee {
    @Test
    public void testFindEmp() throws IOException {
        //调用方法
        Employee emp = new Employee();
        emp.setJob("CLERK");
        emp.setDeptno(20);
        List<Employee> list = mapper.findEmp3(emp);
        list.forEach(System.out::println);
        Map<String, String> map = new HashMap();
        map.put("job", "CLERK");
        map.put("deptNo", 20);
        List<Employee> list2 = mapper.findEmp4(map);
        list2.forEach(System.out::println);
        //关闭资源
        session.close();
    }
}

总结：

  1. 使用Map方式导致了业务可读性的丧失，使后续扩展和维护的困难，应该果断放弃使用。

  2. 直接传递多个参数，会导致映射文件中可读性降低，从可读性考虑，也不推荐使用。

  3. 如果参数数量<=5个，推荐使用Param注解方式，因为更直观。

  4. 如果参数数量>5个，推荐使用JavaBean方式。

  5. 如果涉及到多个JavaBean的参数，可以同时使用Param注解进行标记。

6.2. 模糊查询

在进行模糊查询时，在映射文件中可以使用**concat()**函数来连接参数和通配符。另外注意对于特殊字符，比如<，不能直接书写，应该使用对应的字符实体替换。

public interface EmployeeMapper {
    public List<Employee> findEmp5(@Param("ename") String ename, @Param("hireDate") Date hireDate);
}

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <select id = "findEmp5" resultType = "employee">
        select * from emp
        where ename like concat("%",#{ename},"%") and hiredate < #{hireDate}
    select>
mapper>

6.3. 分页参数

MyBatis不仅提供分页，还内置了一个专门处理分页的类RowBounds，其实就是一个简单的实体类。其中有两个成员变量：

  • offset：偏移量，从0开始计数。

  • limit：限制条数。

在映射文件中不需要接收RowBounds的任何信息，MyBatis会自动识别并据此完成分页。从控制台显示的SQL日志中发现，SQL语句中也没有引入分页。这说明是MyBatis先查询出所有符合条件的数据，再根据偏移量和限制条数筛选指定内容。所有仅适用小数据量情况，对于大数据的情况，需要自己编写分页类来实现。后续分页专题专门说明。

public interface EmployeeMapper {
    public List<Employee> findEmp6(@Param("ename") String ename, @Param("hireDate") Date hireDate, RowBounds rowBounds);
    public List<Employee> findEmp7(@Param("ename") String ename, @Param("hireDate") Date hireDate, @Param("offset") int offset, @Param("limit") int limit);
}

<select id = "findEmp6" resultType = "employee">
    select *
    from emp
    where ename like concat("%",#{ename},"%") and hiredate < #{hireDate}
select>
<select id = "findEmp7" resultType = "employee">
    select *
    from emp
    where ename like concat("%",#{ename},"%") and hiredate < #{hireDate}
    limit #{offset},#{limit}
select>

RowBounds rowBounds = new RowBounds(4, 3);
List<Employee> list = mapper.findEmp6("A", Date.valueOf("1987-12-1"), rowBounds);
List<Employee> list = mapper.findEmp7("", Date.valueOf("1987-12-23"), 3, 5);

6.4. 自增主键回填

MySQL支持主键自增。有时候完成添加后需要立刻获取刚刚自增的主键，由下一个操作来使用。比如结算购物车后，主订单的主键确定后，需要作为后续订单明细项的外键存在。MyBatis提供了支持，可以非常简单的获取。

方式1：通过useGeneratedKeys属性实现

<insert id = "save" useGeneratedKeys = "true" keyProperty = "empno">
    insert into emp
    values(null,#{ename},#{job},#{mgr},#{hireDate},#{sal},#{comm},#{deptno})
insert>

useGeneratedKeys：表示要使用自增的主键。

keyProperty：表示把自增的主键赋给JavaBean的哪个成员变量。
以添加Employee对象为例，添加前Employee对象的empno是空的，添加完毕后可以通过getEmpno() 获取自增的主键。

方式2：通过selectKey元素实现

<insert id = "save">
    <selectKey order = "AFTER" keyProperty = "empno" resultType = "int">
        select @@identity
    selectKey>
    insert into emp (empno,ename,sal) values(null,#{ename},#{sal})
insert>

order：取值AFTER|BEFORE，表示在新增之后|之前执行selectKey中的SQL命令

keyProperty：执行select @@identity后结果填充到哪个属性中

resultType：结果类型。

技术扩展

在很多应用场景中需要新增数据后获取到新增数据的主键值，针对这样的需求一般由三种解决方式：

  1. 主键自定义，用户通过UUID或时间戳等方式生成唯一主键，把这个值当做主键值。在分布式场景中应用较多。

  2. 查询后通过select max(主键) from 表获取主键最大值。这种方式在多线程访问情况下可能出现问题。

  3. 查询后通过select @@identity获取最新生成主键。要求这条SQL必须在insert操作之后，且数据库连接没有关闭。

7. 动态SQL

经常遇到很多按照很多查询条件进行查询的情况，比如智联招聘的职位搜索，比如OA系统中的支出查询等。其中经常出现很多条件不取值的情况，在后台应该如何完成最终的SQL语句呢？

如果采用JDBC进行处理，需要根据条件是否取值进行SQL语句的拼接，一般情况下是使用StringBuilder类及其append方法实现，还是有些繁琐的。如果你有使用 JDBC 或其它类似框架的经验，你就能体会到根据不同条件拼接 SQL语句的痛苦。例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。

MyBatis在简化操作方法提出了动态SQL功能，将使用Java代码拼接SQL语句，改变为在XML映射文件中借助标签拼接SQL语句。相比而言，大大减少了代码量，更灵活、高度可配置、利于后期维护。

MyBatis中动态SQL是编写在mapper.xml中的，其语法和JSTL类似，但是却是基于强大的OGNL表达式实现的。

MyBatis也可以在注解中配置SQL，但是由于注解功能受限，尤其是对于复杂的SQL语句，可读性很差，所以较少使用。

定义如下接口及其功能来练习动态SQL语句。

public interface EmployeeMapper {
    public List<Employee> findEmp(@Param("job") String job, @Param("deptno") int deptno, @Param("sal") double sal);
    public List<Employee> findEmp2(@Param("job") String job, @Param("deptno") int deptno, @Param("sal") double sal);
    public List<Employee> findEmp3(@Param("ename") String ename, @Param("job") String job);
    public List<Employee> findEmp4(@Param("ename") String ename, @Param("job") String job);
    public int updateEmp(String job, double sal, int empno);
    public List<Employee> findEmp5(List<Integer> deptNoList);
    public List<Employee> findEmp6(@Param("deptnoList") List<Integer> deptNoList);
    public List<Employee> findEmp7(int[] arr);
}

7.1. if

每一个if相当于一个if单分支语句。一般添加一个 where 1=1 的查询所有数据的条件，作为第一个条件。这样可以让后面每个if语句的SQL语句都以and开始。

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <select id = "findEmp" resultType = "employee">
        select * from emp where 1=1
        <if test = "job!=null and job !='' ">
            and job =#{job}
        if>
        <if test = "deptno !=0 ">
            and deptno = #{deptno}
        if>
        <if test = "sal>0">
            and sal > #{sal}
        if>
    select>
mapper>

7.2. where

使用where元素，就不需要提供 where 1=1 这样的条件了。如果标签内容不为空字符串则自动添加where关键字，并且会自动去掉第一个条件前面的and或or。

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <select id = "findEmp2" resultType = "employee">
        select * from emp
        <where>
            <if test = "job != null and job !=''">
                and job =#{job}
            if>
            <if test = "deptno > 0">
                and deptno = #{deptno}
            if>
            <if test = "sal > 0">
                and sal > #{sal}
            if>
        where>
    select>
mapper>

7.3. bind

bind主要的一个场合是模糊查询，通过bind通配符和查询值，可以避免使用数据库的具体语法来进行拼接。比如MySQL中通过concat来进行拼接，而Oracle中使用||来进行拼接。

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <select id = "findEmp3" resultType = "employee">
        select * from emp where ename like concat("%",#{ename},"%" )
        and job like concat("%",#{job},"%" )
    select>
    <select id = "findEmp4" resultType = "employee">
        <bind name = "cename" value = "'%'+ename+'%'">
        bind>
        <bind name = "cjob" value = "'%'+job+'%'">
        bind>
        select * from emp where ename like #{cename} and job like #{cjob}
    select>
mapper>

7.4. set

set元素用于在update语句中给字段赋值。借助if的配置，可以只对有具体值的字段进行更新。set元素会自动帮助添加set关键字，自动去掉最后一个if语句多余的逗号。

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <update id = "updateEmp">
        update emp
        <set>
            <if test = "param1!=null and param1 != ''">
                job = #{param1},
            if>
            <if test = "param2>0">
                sal = #{param2}
            if>
        set>
        where empno = #{param3}
    update>
mapper>

7.5. foreach

foreach 元素是非常强大的,它允许你指定一个集合或者数组，声明集合项和索引变量。它们可以用在元素体内，也允许你指定开放和关闭的字符串，在迭代之间放置分隔符。这个元素是很智能的，它不会偶然地附加多余的分隔符。

注意，你可以传递一个 List 实例或者数组作为参数对象传给 MyBatis。当你这么做的时候,MyBatis 会自动将它包装在一个 Map 中,用名称在作为键。List 实例将会以list作为键,而数组实例将会以array作为键。

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <select id = "findEmp5" resultType = "employee">
        select * from emp where deptno in
        <foreach collection = "collection" item = "deptno" open = "(" separator = "," close = ")">
            #{deptno}
        foreach>
    select>

    <select id = "findEmp6" resultType = "employee">
        select * from emp where deptno in
        <foreach collection = "deptnoList" item = "deptno" open = "(" separator = "," close = ")">
            #{deptno}
        foreach>
    select>

    <select id = "findEmp7" resultType = "employee">
        select * from emp where deptno in
        <foreach collection = "array" item = "deptno" open = "(" separator = "," close = ")">
            #{deptno}
        foreach>
    select>
mapper>

建议少使用in语句，因为对性能有影响。如果in中元素很多，会对性能有较大影响，此时就不建议使用foreach语句了。

8. 缓存

缓存的重要性是不言而喻的。将相同查询条件的SQL语句执行一遍后所得到的结果存在内存或者某种缓存介质当中，当下次遇到一模一样的查询SQL时不再执行SQL与数据库交互，而是直接从缓存中获取结果，可以减少服务器的压力；尤其是在查询越多、缓存命中率越高的情况下，使用缓存对性能的提高会更明显。

MyBatis允许使用缓存，缓存一般放置在高速读/写的存储器上，比如服务器的内存，能够有效的提供系统性能。MyBatis分为一级缓存和二级缓存，同时也可配置关于缓存设置。

一级存储是SqlSession上的缓存，二级缓存是在SqlSessionFactory上的缓存。默认情况下，MyBatis开启一级缓存，没有开启二级缓存。当数据量大的时候可以借助一些第三方缓存框架或Redis缓存来协助保存Mybatis的二级缓存数据。

8.1. 一级缓存

一级存储是SqlSession上的缓存，默认开启，要求实体类对象实现Serializable接口。下面在没有任何配置的情况下，测试一级缓存。

public class TestCache{
    @Test
    public void testCacheLevel1() throws IOException {
        //创建SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis.cfg.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession
        SqlSession session = factory.openSession();
        //创建Mapper(使用代理模式创建一个EmployeeMapper的实现类)
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);

        mapper.findEmp3("A", "CLERK");
        mapper.findEmp3("C", "CLERK");
        mapper.findEmp3("C", "CLERK");

        session.close();
    }
}

DEBUG - ==> Preparing: select * from emp where ename like concat("8",?,"8") 
DEBUG - ==> Parameters: A(String), CLERK(String)
DEBUG - <==Total: 6
DEBUG - ==> Preparing: select * from emp where ename like concat("8",?,"8") 
DEBUG - ==> Parameters:M(String),SALESMAN(String)
DEBUG - <==Total: 1

从输出结果可以看出，两次执行 mapper.findEmp3(“C”, “CLERK”); 语句，只访问了一次数据库。第一次执行该SQL语句，结果缓存到一级缓存中，后续执行相同语句，会使用缓存中缓存的数据，而不是对数据库再次执行SQL，从而提高了查询效率。

8.2. 二级缓存

二级缓存是SqlSessionFactory上的缓存，可以是由一个SqlSessionFactory创建的SqlSession之间共享缓存数据。默认并不开启。下面的代码中创建了两个SqlSession，执行相同的SQL语句，尝试让第二个SqlSession使用第一个SqlSession查询后缓存的数据。

public class TestCache {
    @Test
    public void testCacheLevel2() throws IOException {
        //创建SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis.cfg.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession
        SqlSession session = factory.openSession();
        SqlSession session2 = factory.openSession();
        //创建Mapper(使用代理模式创建一个EmployeeMapper的实现类)
        EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
        EmployeeMapper mapper2 = session2.getMapper(EmployeeMapper.class);

        mapper.findEmp3("A", "CLERK");
        session.commit();
        mapper2.findEmp3("A", "CLERK");
        session2.commit();
        session.close();
        session2.close();
    }
}

注意其中的commit()，执行该命令后才会将该SqlSession的查询结果从一级缓存中放入二级缓存，供其他SqlSession使用。另外执行SqlSession的**close()**也会将该SqlSession的查询结果从一级缓存中放入二级缓存。两种方式区别在于在当前SqlSession是否关闭了。

DEBUG - ==> Preparing: select * from emp where ename like concat("%",?,"8")
DEBUG - ==> Parameters: A(String), CLERK(String)
DEBUG - <==		Total: 6
DEBUG - ==> Preparing: select * from emp where ename like concat("8",?," )
DEBUG - ==> Parameters: A(String), CLERK(String)
DEBUG - <==		Total: 6

执行结果显示进行了两次对数据库的SQL查询，说明二级缓存并没有开启。需要进行如下步骤完成开启。

  1. 全局开关：在mybatis-config.xml文件中的标签配置开启二级缓存

    <settings>
    <setting name = "cacheEnabled" value = "true"/>
settings>

    cacheEnabled的默认值就是true，所以这步的设置可以省略。

  2. 分开关：在要开启二级缓存的mapper文件中开启缓存

    <mapper namespace="com.bjsxt.mapper.EmployeeMapper">
    <cache/>
mapper>

  3. 缓存中存储的JavaBean对象必须实现序列化接口

    public class Employee implements Serializable

经过设置后，查询结果如下所示。发现第一个SqlSession会首先去二级缓存中查找，如果不存在，就查询数据库，在commit()或者close()的时候将数据放入到二级缓存。第二个SqlSession执行相同SQL语句查询时就直接从二级缓存中获取了。

DEBUG - Cache Hit Ratio [com.bjsxt.mapper.EmployeeMapper]:0.0 
DEBUG - ==>	Preparing: select * from emp where ename like concat("%",?,"%" )
DEBUG - ==>	Parameters: A(String),CLERK(String)
DEBUG - <==	Total: 6
DEBUG -	Cache Hit Ratio [com.bjsxt.mapper.EmployeeMapper]:0.5

注意结果中的第一行和最后一行的数值不一样。

注意：

  1. MyBatis的二级缓存的缓存介质有多种多样，而并不一定是在内存中，所以需要对JavaBean对象实现序列化接口。

  2. 二级缓存是以 namespace 为单位的，不同 namespace 下的操作互不影响。

  3. 加入Cache元素后，会对相应命名空间所有的select元素查询结果进行缓存，而其中的insert、update、delete在操作会清空整个namespace的缓存。

  4. 如果在加入Cache元素的前提下让个别 select 元素不使用缓存，可以使用useCache属性，设置为false。

    <select id = "findEmp3" resultType = "employee" flushCache = "false" useCache = "false"/>

  5. cache 有一些可选的属性 type, eviction, flushInterval,size, readOnly, blocking。

    <cache type = "" readOnly = "" eviction = "" flushInterval = "" size = "" blocking = ""/>
    属性 含义 默认值
    type 自定义缓存类，要求实现org.apache.ibatis.cache.Cache接口 null
    readOnly 是否只读
    true:给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。
    false:会返回缓存对象的拷贝(通过序列化) 。这会慢一些,但是安全。    		 false
    eviction 缓存策略
    LRU（默认） – 最近最少使用：移除最长时间不被使用的对象。
    FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
    SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
    WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。    		 LRU
    flushInterval 刷新间隔，毫秒为单位。默认为null，也就是没有刷新间隔，只有执行update、insert、delete语句才会刷新。 null
    size 缓存对象个数。 1024
    blocking 是否使用阻塞性缓存BlockingCache
    true：在查询缓存时锁住对应的Key，如果缓存命中了则会释放对应的锁，否则会在查询数据库以后再释放锁，保证只有一个线程到数据库中查找指定key对应的数据。
    false：不使用阻塞性缓存，性能更好。    		 false

  6. 缓存相关API

    1. 缓存的功能由根接口org.apache.ibatis.cache.Cache定义。整个体系采用装饰器设计模式。

    2. 数据存储和缓存的基本功能由org.apache.ibatis.cache.impl.PerpetualCache永久缓存实现，其底层采用了HashMap结构来存储缓存信息。

    3. 通过一系列的装饰器来对PerpetualCache永久缓存进行缓存策略等方便的控制。

  7. 查询数据顺序

    1. 二级缓存

    2. 一级缓存

    3. 数据库

    4. 把数据保存到一级

    5. 当SqlSession关闭或者提交的时候，把数据刷入到二级缓存中

9. MyBatis实现多表查询

前面已经使用MyBatis完成了对Emp表的CRUD操作，不管是使用SqlSession直接操作，还是使用Mapper代理方式，都只是完成了对单个数据库表的操作。这肯定是远远不够的。

在实际开发中，经常会将来自多张表的数据在一个位置显示。比如查询并显示的员工信息中会有来自部门表、岗位表的数据，而后台一般是定义一个方法：

List<User> findUser(conditions);

比如查询的考勤信息中会有来自用户表、部门表的数据，而后台一般是定义一个方法：

List<Duty>findDuty(conditions)

这就要求User中要包含部门Dept、岗位Position的信息；而Duty中包含用户User、部门Dept的信息。

在MyBatis中是如何实现对多表的查询并实现数据的组装呢？（此处就没有DML操作什么事了）。

我们依次通过三种方式来实现，以Dept表和Emp为例进行讲解。

  1. 无级联查询：开发者手动完成多表数据的组装，需要执行多条SQL语句。

  2. 级联查询：使用MyBatis映射配置自动完成数据的组装，需执行多条SQL语句。

  3. 连接查询：使用MyBatis映射配置自动完成数据的组装，只需执行一条SQL语句

数据库表之间的关联关系有一对一、一对多、多对多三种方式，其中掌握一对多是关键。一对多关联映射掌握了，就可将相关语法之间应用到一对一、多对多映射中。部门和员工就是一对多关联关系。

功能1：查询所有员工及其部门的信息（多对一关联）

包含字段：编号empno，姓名ename，工资sal,津贴comm,部门编号deptno、部门名称dname。其中deptno是关联字段，dname来自另外的一张表：部门表DEPT。

功能2：查询10号部门及其该部门员工信息。（一对多关联）

包含字段：部门的所有字段 deptno、dname、loc。员工字段显示empno、ename、sal、comm。

注意：为了进行区别，将dept表的deptno列名称修改为deptno1，和emp表的外键不一致，学习中会明白更多的细节。

项目最终结构如图所示。需要定义两个实体类、两个映射接口、两个映射XML文件。

MyBatis&Plus笔记_第10张图片

需要在两个实体类之间建立他们之间的关联关系。数据库表之间建立关联通过外键，类之间建立关联可以通过属性。

一个员工只有一个部门，需要一个Dept类的成员变量。

一个部门有多个员工，需要增加一个集合类型的成员变量，比如List\ employeeList;

均需提供setter和getter方法

Dept实体类

@Data
public class Dept {
    private int deptno1;
    private String dname;
    private String location;
    private List<Employee> employeeList = new ArrayList<>();
}

注意：Dept类的属性名location，和数据库表的列loc不一致。

Employee实体类

@Data
public class Employee {
    private int empno;
    private String ename;
    private String job;
    private int mgr;
    private Date hireDate;
    private double sal;
    private double comm;
    private int deptno;
    private Dept dept;
}

9.1. 无级联查询

该方式需要开发者手动完成多表数据的组装，需要执行多条SQL语句。

根据测试类中的查询要求在映射文件定义相关查询元素。

EmployeeMapper.xml

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <select id = "findAll" resultType = "employee">
        select * from emp;
    select>
    <select id = "findByDeptno" resultType = "employee">
        select * from emp where deptno = #{param1}
    select>
mapper>

DeptMapper.xml

<mapper namespace = "com.bjsxt.mapper.DeptMapper">
    <select id = "findById" resultType = "dept">
        select * from dept where deptno1 = #{param1}
    select>
mapper>

功能1：查询所有员工的信息（多对一关联）

public class TestNoCascade {
    @Test
    public void testFindAllEmp() throws IOException {
        //获取SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //获取SqlSession
        SqlSession sqlSession = factory.openSession();
        //获取Mapper
        EmployeeMapper empMapper = sqlSession.getMapper(EmployeeMapper.class);
        DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
        //（使用Mapper）访问数据库并获取结果
        List<Employee> empList = empMapper.findAll();
        for (Employee emp : empList) {
            //获取员工的部门编号
            int deptno = emp.getDeptno();
            //按照部门编号查询指定的部门
            Dept dept = deptMapper.findById(deptno);
            //把部门信息组装到员工信息中
            emp.setDept(dept);
        }
        //关闭SqlSession
        sqlSession.close();
        //输出结果
        for (Employee emp : empList) {
            if (emp.getDept() != null) {//如果有部门
                System.out.println(emp.getEmpno() + "\t" + emp.getEname()
                        + "\t" + emp.getSal() + "" + emp.getComm() + "\t" + emp.getDeptno()
                        + "\t" + emp.getDept().getDeptno1() + "\t" + emp.getDept().getDname()
                        + "\t" + emp.getDept().getLocation());
            } else {
                System.out.println(emp.getEmpno() + "\t" + emp.getEname()
                        + "\t" + emp.getSal() + emp.getComm() +
                        "\t" + emp.getDeptno());
            }
        }
    }
}

运行的日志结果如下图所示。可以看到有多条SQL语句。第一条语句负责查询所有的员工信息。下面要为每个员工再执行一条SQL语句来获取该员工的部门信息。

为什么获取部门编号的语句和员工的数据不相同呢，并且少于员工数量呢？这是因为用到了一级缓存，对于同一部门员工，只有第一次才执行SQL查询，后面使用缓存数据即可。

MyBatis&Plus笔记_第11张图片

功能2：查询10号部门及其该部门员工信息。

public class TestNoCascade {
    @Test
    public void testFindDeptByNo() throws IOException {
        //获取SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis-cfg.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //获取SqlSession
        SqlSession sqlSession = factory.openSession();
        //获取Mapper
        EmployeeMapper empMapper = sqlSession.getMapper(EmployeeMapper.class);
        DeptMapper deptMapper = sqlSession.getMapper(DeptMapper.class);
        int deptno = 10;
        //（使用Mapper）访问数据库并获取结果
        Dept dept = deptMapper.findById(deptno);
        //查询该部门的员工信息
        List<Employee> empList = empMapper.findByDeptNo(deptno);
        //将员工信息放入部门
        dept.setEmployeeList(empList);
        //关闭SqlSession
        sqlSession.close();
        //输出结果
        System.out.println(dept.getDeptno1() + "\t" + dept.getDname() + "\t" + dept.getLocation());
        List<Employee> empList2 = dept.getEmployeeList();
        for (Employee emp : empList2) {
            System.out.println("\t" + emp);
        }
    }
}

该方式缺点明显，需要开发者手动的进行多次查询并组装数据，繁琐，代码量大。但是毕竟也实现了最终目的，也利于理解多表查询自动组装数据的过程。实际开发中很少使用。

9.2. 级联查询

级联查询，顾名思义，就是利于数据库表间的外键关联关系进行自动的级联查询操作。使用MyBatis实现级联查询，除了实体类增加关联属性外，还需要在映射文件中进行配置。

9.2.1. 立即加载

功能1：查询所有员工的信息（多对一关联）

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <select id = "findAll2" resultMap = "employeeMap">
        select * from emp;
    select>
    <resultMap id = "employeeMap" type = "employee">
        <result property = "deptno" column = "deptno">result>
        <association property = "dept"
                     javaType = "com.bjsxt.entity.Dept"
                     column = "deptno"
                     jdbcType = "INTEGER"
                     fetchType = "eager"
                     select = "com.bjsxt.mapper.DeptMapper.findById">
        association>
    resultMap>
mapper>

注意：非关联字段可使用自动映射，关联字段映射（）是否省略会得到不同的结果。不建议省略。

public class TestCascade {
    @Test
    public void testSelect1() throws IOException {
        //创建SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession
        SqlSession session = factory.openSession();
        //创建Mapper(使用代理模式创建一个EmployeeMapper的实现类)
        EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
        //查询员工信息
        List<Employee> list = employeeMapper.findAll2();
        session.close();
        //在前台展示内容
        //省略
    }
}

经过对比，发现经过在映射文件中配置，测试类的代码大大简化了，无序手动进行关联查询和组装数据了。

功能2：查询10号部门及其该部门员工信息。

<mapper namespace = "com.bjsxt.mapper.DeptMapper">
    <select id = "findById2" resultMap = "deptMap">
        select * from dept where deptno1 = #{arg0}
    select>
    <resultMap id = "deptMap" type = "dept">
        <id property = "deptno1" column = "deptno1">id>
        <result property = "dname" column = "dname">result>
        <result property = "location" column = "loc">result>
        <collection property = "employeeList"
                    javaType = "list"
                    column = "deptno1"
                    jdbcType = "INTEGER"
                    select = "com.bjsxt.mapper.EmployeeMapper.findByDeptno"
                    fetchType = "eager">
        collection>
    resultMap>
mapper>

其实 collection 只要提供属性property、column、select配置即可，其他属性会有默认值。

注意：collection的column属性是当前类Dept对应表dept的主键列deptno1。

public class TestCascade {
    @Test
    public void testSelect2() throws IOException {
        //创建SqlSessionFactory
        InputStream is = Resources.getResourceAsStream("mybatis.xml");
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
        //创建SqlSession
        SqlSession session = factory.openSession();
        //创建Mapper
        DeptMapper deptMapper = session.getMapper(DeptMapper.class);
        //查询10号部门信息
        Dept dept = deptMapper.findById2(10);
        session.close();
        //模拟在前台展示内容
        System.out.println(dept.getDeptno1() + "\t" + dept.getDname());
        List<Employee> list = dept.getEmployeeList();
        for (int i = 0; i < list.size(); i++) {
            Employee emp = list.get(i);
            System.out.println("\t" + emp);
        }
    }
}

9.2.2. 结果映射resultMap

功能1和功能2中都使用了resultMap。在单表情况下，数据库字段名和实体类属性如果一致，还可以自动映射Auto-Mapping。那么在复杂的情况下，比如在进行多表查询时，就需要对查询结果进行手动映射。resultMap就是来完成手动映射的，可实现一次配置多次复用的效果。

语法结构

<resultMap id = "" type = "">
    <id property = "" javaType = "" column = "" jdbcType = "" typeHandler = "">id>
    <result property = "" column = "">result>
    <association property = "" column = "" fetchType = "" select = "">association>
    <collection property = "" column = "" fetchType = "" select = "" ofType = "">collection>
resultMap>

resultMap元素有两个属性

  1. id：resultMap的唯一标记，被select元素引用时使用。

  2. type：最终形成哪个类的对象。可以是别名或者全限定名。和之前resultType一样，只是显示的是自定义规则映射后形成某个类对象。

resultMap元素有多个子元素

  1. id：配置主键列和属性的关系。

  2. result：配置非主键列和属性的关系。

  3. association：配置多对一、一对一关联字段列和属性关系，对应一个对象属性。

  4. collection：配置一对多、多对多的关联字段和属性的关系，对应一个集合属性。

    属性 描述
    property 需要映射到JavaBean 的属性名称。
    javaType property的类型，一个完整的类名，或者是一个类型别名。如果你匹配的是一个JavaBean，那MyBatis 通常会自行检测到。
    column 数据表的列名或者列别名。
    jdbcType column在数据库表中的类型。这个属性只在insert,update 或delete 的时候针对允许空的列有用。JDBC 需要这项，但 MyBatis 不需要。取值是 JDBCType 枚举的值.
    typeHandler 使用这个属性可以覆写类型处理器，实现javaType、jdbcType之间的相互转换。一般可以省略，会探测到使用的什么类型的typeHandler进行处理。
    fetchType 自动延迟加载策略。
    select association、collection的属性，使用哪个查询查询属性的值，要求指定namespace+id的全名称。
    ofType collection的属性，指明集合中元素的类型（即泛型类型）。

注意事项：

  1. 在级联查询时，对于一致的JavaBean属性和数据库表字段，因为可以自动映射，所以id、result元素可以省略。

  2. 在resultMap手动映射中，一个关联列可能对应多个property（比如dept表的deptno1，emp表的deptno列），建议都进行手动映射，否则会影响查询结果。

  3. javaType、jdbcType、typeHandler三个属性能省略则省略。

9.2.3. 延迟加载

认识N+1查询问题（感觉1+N问题才更确切）

示例1：查询所有员工信息（含部门名称）

select * from emp  
select * from dept where deptno = 20
select * from dept where deptno = 30
select * from dept where deptno = 30

示例2：查询所有部门信息（含每个部门的员工信息）

select * from dept
select * from emp where deptno = 10
select * from emp where deptno = 20
select * from emp where deptno = 30
select * from emp where deptno = 40

如果第一个查询有N条记录，要随后对数据库进行N次查询，共计1+N次查询，对数据库查询次数多，服务器压力大，造成N+1问题。

解决方案：

  1. 延迟加载。关联表的数据只有等到真正使用的时候才进行查询，不使用不查询。

  2. 连接查询。一条SQL语句查询到所有的数据。

延迟加载

延迟加载的内容等到真正使用时才去进行加载（查询）。多用在关联对象或集合中。

比如在功能1：查询所有员工的信息中只显示员工信息，而不显示部门信息；那对部门的SQL语句不就白查询了吗，能否默认不查询，等真正使用的时候才查询，延迟一下查询的时间，这就不更灵活了吗？

resultMap可以实现高级映射（使用association、collection实现一对一及一对多映射），association、collection具备延迟加载设置功能。

延迟加载的好处：先从单表查询、需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

延迟加载的设置

第一步，全局开关：在mybatis-cfg.xml中打开延迟加载的开关。配置完成后所有的association和collection元素都生效。

<settings>
    <setting name = "lazyLoadingEnabled" value = "true"/>
    <setting name = "aggressiveLazyLoading" value = "true"/>
settings>

lazyLoadingEnabled:是否开启延迟加载，是Mybatis是否启用懒加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。

aggressiveLazyLoading：当开启时，任何方法的调用都会加载懒加载对象的所有属性。否则，每个属性会按需加载。

第二步分开关：指定的association和collection元素中配置fetchType属性。eager：表示立刻加载；lazy：表示延迟加载。将覆盖全局延迟设置。

功能1：fetchType=“eager”

MyBatis&Plus笔记_第12张图片

功能1：fetchType=“lazy”

MyBatis&Plus笔记_第13张图片

功能2：fetchType=“eager”

MyBatis&Plus笔记_第14张图片

功能2：fetchType=“lazy”

在这里插入图片描述

10. MyBatis SQL实现多表查询

10.1. 多表连接查询

多表连接查询（join）只需执行一条SQL语句，就可以查询到多张表的数据，效率很高。但是其中会有大量的重复数据。

MyBatis&Plus笔记_第15张图片

另外每一条记录中有多个表的字段，一般情况下会转换并组装到一个对象中。如图所示数据可以考虑组装到7个Employee对象中，每个Emp中还包括其所属Dept信息；或者组装到3个Dept对象中，每个Dept对象中有该部门的所有员工信息。

使用MyBatis完成上面两个操作，除了必须提供的多表查询语句外，关键还是需要使用resultMap的进行结果映射。

功能1：查询所有员工的信息（多对一关联）

<mapper namespace = "com.bjsxt.mapper.EmployeeMapper">
    <select id = "findAll3" resultMap = "employeeMap2">
        select empno,ename,sal,comm, e.deptno,dname
        from emp e
        left join dept d
        on e.deptno = d.deptno
    select>
    <resultMap id = "employeeMap2" type = "employee">
        <id property = "empno" column = "empno">id>
        <result property = "ename" column = "ename">result>
        <result property = "sal" column = "sal">result>
        <result property = "comm" column = "comm">result>
        <result property = "deptno" column = "deptno">result>
        <association property = "dept" column = "deptno">
            <id property = "deptno" column = "deptno">id>
            <result property = "dname" column = "dname">result>
        association>
    resultMap>
mapper>

功能2：查询10号部门及其该部门员工信息。

<mapper namespace = "com.bjsxt.mapper.DeptMapper">
    <select id = "findById3" resultMap = "deptMap2">
        select empno,ename,sal,comm, e.deptno,dname
        from emp e
        join dept d
        on e.deptno = d.deptno
        where d.deptno = ${param1}
    select>
    <resultMap id = "deptMap2" type = "dept">
        <id property = "deptno" column = "deptno">id>
        <result property = "dname" column = "dname">result>
        <collection property = "employeeList" ofType = "employee">
            <id property = "empno" column = "empno">id>
            <result property = "ename" column = "ename">result>
            <result property = "sal" column = "sal">result>
            <result property = "comm" column = "comm">result>
        collection>
    resultMap>
mapper>

注意：

  1. 多表连接查询只有立即查询，不能配置延迟加载。

  2. 多表连接查询中ResultMap中各列无法省略、必须配置，省略的不会自动映射。

10.2. 多表查询总结与扩展

  1. 级联查询和多表连接查询的比较及其选择

    级联查询 SQL多表连接查询
    SQL语句数量 多条 一条
    性能 性能低 性能高
    延迟加载 立即加载、延迟加载 只有立即加载
    灵活性 更灵活 不灵活
    SQL难易度 简单 复杂
    选择依据 简单、灵活 高性能

  2. ResultType和ResultMap使用场景

    1. 如果你做的是单表的查询并且封装的实体和数据库的字段一一对应，使用resultType

    2. 如果实体封装的属性和数据库的字段不一致 resultMap

    3. 使用N+1级联查询的时候 resultMap

    4. 使用的是多表的连接查询 resultMap

  3. 一对一关联映射的实现

    1. 实例：学生和学生证、雇员和工牌

    2. 数据库层次：主键关联或者外键关联

    3. MyBatis层次：在映射文件的设置双方均使用association即可，用法相同

  4. 多对多映射的实现

    1. 实例：学生和课程、用户和角色

    2. 数据库层次：引入一个中间表将一个多对多转为两个一对多

    3. MyBatis层次

      1. 方法1：在映射文件中双方均使用collection即可，不用引入中间类

      2. 方法2：引入中间类和中间类的映射文件，按照两个一对多处理

  5. 自关联映射

    1. 实例：Emp表中的员工和上级。一般是一对多关联

    2. 数据库层次：外键参考当前表的主键（比如mgr参考empno）

    3. MyBatis层次：按照一对多处理，但是增加的属性都写到一个实体类中，增加的映射也都写到一个映射文件中

11. MyBatis注解开发

MyBatis编写SQL除了使用Mapper.xml外，还可以使用注解完成。当使用Auto Mapping时使用注解非常简单，不需要频繁的在接口和mapper.xml两个文件之间进行切换。但是在必须配置resultMap时使用注解将会变得很麻烦，这种情况下推荐使用mapper.xml进行配置。

MyBatis支持纯注解方式，也支持纯mapper.xml方式，也支持注解和mapper.xml混合形式。当只有接口没有mapper.xml时在mybatis.cfg.xml中可以通过加载接口类。如果是混合使用时，使用。此方式一直是官方推荐方式。

如果某个功能同时使用两种方式进行配置，XML方式将覆盖注解方式。

下面使用注解完成对Emp的CRUD操作。

public interface EmpMapper {
    @Select("select * from emp")
    public List<Employee> findAll();

    @Select("select * from emp where empno = #{param1}")
    public Employee findById(int empno);

    @Select(value = "select * from emp where job =#{job} and deptno = #{deptno}")
    public List<Employee> findEmp(String job, int deptno);

    @Insert("insert into emp values(null,#{ename},#{job}," + "#{mgr},#{hireDate},#{sal},#{comm},#{deptno})")
    int saveEmp(Employee emp);

    @Update("update emp set job =#{job},sal =#{sal} where empno =#{empno}")
    int updateEmp(Employee emp);

    @Delete("delete from emp where empno = #{param1}")
    int deleteEmp(Employee emp);
}

如果希望通过注解实现和mapper.xml中相同功能的效果，可以使用@Results注解实现。

如果对象中关联了集合类型对象可以通过@Result - many属性加载集合属性的值。在注解实现中只能通过N+1查询方式，而没有连接查询方式。

如果对象中关联了另一个对象，使用@Result - one属性加载另一个对象。

在MyBatis3的注解中包含了@SelectProvider、@UpdateProvider、@DeleteProvider、@InsertProvider，统称@SqlProvider，这些方法分别对应着查询、修改、删除、新增。当使用这些注解时将不在注解中直接编写SQL，而是调用某个类的特定方法形成的SQL。

public class MyProvider {
    public String selectStudents() {
        return "select * from student";
    }
}

@SelectProvider(type= MyProvider.class,method = "selectStudents")
List<Student> selectStudent();

具体在框架中使用注解还是XML配置方式，要视框架情况而定。Spring、SpringBoot中更推荐注解方式。但是在MyBatis中更推荐使用XML配置方式。原因如下：

  1. 使用注解没有实现Java代码和SQL语句的解耦。

  2. 无法实现SQL语句的动态拼接。

  3. 进行多表的查询时定制ResultMap比较麻烦。

注解和XML的优缺点

XML 注解
优点 1.类和类之间的解耦。
2.利于修改。直接修改XML文件，无需到源代码中修改。
3.配置集中在XML中，对象间关系一目了然，利于快速了解项目和维护
4.容易和其他系统进行数据交换。		 1.简化配置。
2.使用起来直观且容易，提升开发效率。
3.类型安全，编译器进行校验，不用等到运行期才会发现错误。
4.注解的解析可以不依赖于第三方库，可以之间使用Java自带的反射。

12. MyBatis Plus 的简介

12.1. 为什么使用MyBatis Plus

  1. 在之前学习Mybatis时，我们对单表的增删改查的操作，都是自己在mapper.xml中进行代码的书写，这样一来我们书写的代码比较的麻烦。

  2. 我们目前封装数据库的实体的时候，每张表都需要自己的书写实体类，这样一来，我们书写的代码也比较麻烦。

12.2. 解决的方案

MyBatis Plus：其实就是对MyBatis的进一步的封装。

12.3. MyBatis Plus 的简介

Mybatis-Plus（简称MP），是一个 Mybatis 增强工具，在 Mybatis 的基础上只做增强不做改变，为简化开发、提高效率而生。官方文档说的愿景是成为 Mybatis 最好的搭档。

特性

  • 无侵入∶只做增强不做改变，引入它不会对现有工程产生影响。

  • 损耗小∶启动即会自动注入基本 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 操作智能分析阻断，也可自定义拦截规则，预防误操作。

架构原理

MyBatis&Plus笔记_第16张图片

13. MyBatis Plus 的框架搭建

13.1. 导包

在原有SSM的jar包的基础上增加MybatisPlus的jar即可。

<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plusartifactId>
    <version>3.5.1version>
dependency>

13.2. 搭建SSM开发环境

  1. 在Src下创建MVC的包结构。

  2. 在src下创建和配置SSM相关配置文件。

    注意:其他配置和原有SSM流程不变，在applicationcontext.xml文件中，将Mybatis的工厂bean替换为MybatisPlus的工厂bean即可。

    
<bean id="factory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">bean>

  3. 在web.xml中配置SSM相关信息

13.3. 建表

创建t_student表并添加测试数据

CREATE TABLE t_student
(
    `sid`     int (10) NOT NULL AUTO INCREMENT,
    `s_name`  varchar(100) NOT NULL,
    `sage`   int(3) DEFAULT NULL,
    `ssex`   char(1)  DEFAULT NULL,
    `sphone` char(11) DEFAULT NULL,
    PRIMARY KEY (`sid`)
) ENGINE=InnoDB AUTO INCREMENT=4 DEFAULT CHARSET=utf8;

13.4. 创建实体类

在pojo层下创建Student表的实体类

@Data
@TableName("t_student")
public class Student {
    @TableId("sid")
    private Integer id;
    @TableField("s_name")
    private String sname;
    private String sage;
    private String ssex;
    private String sphone;
}

13.5. 创建mapper接口

在mapper层创建StudentMapper接口并继承BaseMapper接口

public interface StudentMapper extends BaseMapper<Student> {
}

13.6. 使用

创建测试类，并从Spring容器中获取StudentMapper的接口的实例化对象并使用对象完成数据的查询操作，查询所有的学生信息。

public class TestMyBatisPlus {

    /**
     * 测试MyBatis的CURD操作

     * 测试查询
     */
    @Test
    public void testMpSel() {
        // 获取spring容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("application.properties");
        // 获取mapper对象
        StudentMapper sm = (StudentMapper) ac.getBean("studentMapper");
        // 查询所有学生信息
        List<Student> students = sm.selectList(null);
        // 输出
        System.out.println(students);
    }

}

13.7. MyBatis和Mybatis Plus的使用比较

MybatisPlus包含了Mybatis的所有功能，也就说在MybatisPlus中我们仍然可以按照Mybatis的方式来完成数据库的操作(无侵入)。

MybatisPlus的数据库操作的Mapper层的接口只需要继承BaseMapper接口，就自动的拥有了当前对应的表的基本的CRUE操作，无需声明接口方法及其xml文件，极大的提升了开发效率(MybatisPlus是通过实体类来逆向动态生成对应的表的基本的Sql语句)。

14. MyBatis Plus 中的CRUD

14.1. 添加操作

/*MP的新增
  insert方法∶
  说明∶BaseMapper接口中提供了数据新增的insert方法
  作用∶完成数据的新增
  参数∶封装了要新增的数据的实体类对象
  使用∶
    直接调用即可。但是在进行根据实体类动态生成SqL语句时,
    会判断实体类中的属性值是否为null，只有非null值才会,
    拼接在Sql语句中完成新增.
  注意∶
    需要在实体类中使用注解 @TabLeName 指明实体类对应的表名，如果类名和表名一致则省略不写
    需要在对应主键的属性上使用注解 @TabLeId 表明该属性是表的主键，并且需要说主键的设置类型，比如∶自增
    需要在普通属性上使用注解 @TabLeField 表明该属性对应的字段的名称，如果属性名和字段名一致，则省略不写
*/

//1.测试新增一条学生信息（张同学，30，1，15566339966）
@Test
public void testMpInsert(){
	//获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //创建学生实体类存储新增数据
    Student student=new Student();
    student.setSname("张同学2");
    //student.setSage(30);
    student.setSsex("1");
	student.setSphone("15566339966");
    //完成新增
	int i = studentMapper.insert(student);
    int i2= studentMapper.insert(student);
    //打印新增结果
	System.out.println（"新增结果∶"+i);
}

14.2. 修改操作

//2.更新操作--updateById方法
/**
  updateById方法
    作用∶更新数据到数据库中
    参数∶存储了要更新的数据的值
    注意∶
      将主键ID作为条件来完成更新，并且只更新实体类对象中有值的属性，null值的属性不参与更新
*/
@Test
public void testMpUpdateById(){
	//获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //创建实体类存储要更新的数据
    Student student=new Student();
    student.setSid(5);
    student.setSname("李同学");
    //完成更新
	int i = studentMapper.updateById(student);
    //打印更新结果
	System.out.println("更新结果∶"+i);
}

14.3. 删除操作

/*
  deleteById方法：
    作用∶根据ID删除指定的数据
    参数∶要删除的数据的ID值
*/
@Test
public void testMpDeleteById(){
	//获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean( s: "studentMapper");//完成删除
	int i = studentMapper.deleteById(5);
    //打印删除结果
	System.out.println("删除结果∶"+i)
}

/**
  deleteByMap方法∶
    作用∶根据指定的字段完成数据的删除
    参数∶map集合
    注意∶
      传入的map集合中存储了要删除的数据的键值对，键名为数据库中的字段的名称，不是实体类的属性名。
*/
@Test
public void testMpDeleteByMap(){
	//获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //创建Map集合
	Map<String,Object> map=new HashMap<>();
    map.put("s_name"，"刘同学");
    map.put("sage",20);
    //完成删除
	int i = studentMapper.deleteByMap(map);
    //打印删除结果
	System.out.println("删除结果∶"+i);
}

/**
  deleteBatchIds方法∶
    作用∶多选删除，将符合ID要求的数据全部删除
    参数∶存储了要删除的数据的ID的集合
*/
@Test
public void testMpDeleteBatchIds(){
	//获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //创建List集合
	List<Integer> ids=new ArrayList<>();
    ids.add(2);
    ids.add(4);
    //完成删除
	int i = studentMapper.deleteBatchIds(ids);
    //打印删除结果
	System.out.println("删除结果∶"+i);
}

14.4. 查询操作

/* 
  selectById方法∶
    作用∶根据id查询数据
    参数∶要查询的数据的ID
    返回值∶ 存储了查询结果的实体类对象
*/
@Test
public void testSelectById(){
    //获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //完成查询
	Student student = studentMapper.selectById(1);
    //打印查询结果
	System.out.println(student);
}

/*
  selectByMap方法∶
    作用∶根据指定的字段查询数据
    参数∶存储了指定字段及其字段值的map集合
    返回值∶存储了查询结果的list集合
    注意:
	  map中的键名为要查询的数据的字段名，不是实体类的属性名
*/

@Test
public void testSelectByMap(){
	//获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //创建Map集合
	Map<String,Object> map=new HashMap<>();
    map.put("s_name"，"张同学");
    map.put("sage",20);
    //完成查询
	List<Student> students = studentMapper.selectByMap(map);
    //打印查询结果
	System.out.println(students);
}

/**
  selectBatchIds方法∶
    作用∶根据id查询数据
    参数∶存储了要查询的数据的Id的集合
    返回值∶存储了查询结果的list集合
*/
@Test
public void testSelectBatchIds(){
	//获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationCantext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //创建List集合
	List<Integer> ids=new ArrayList<>();
    ids.add(1);
    ids.add(2);
    //完成查询
	List<Student> students = studentMapper.selectBatchIds(ids);
    //打印查询结果
	System.out.println(students);
}

15. 条件构造器Wrapper的使用

15.1. Wrapper条件构造器的介绍

问题：

目前我们可以使用mp完成基本的增删改查操作，但是我们在进行数据操作时，很多时候Sql语句中的筛选条件是非常复杂的，比如or关键，>,<，模糊查询等，怎么办?

解决:

mp提供了功能非常强大的Wrapper条件构造器。

本质:

条件构造器其实就是一个对象，以方法的形式提供了数据库操作的筛选关键字。

我们调用该对象，来拼接我们的筛选条件即可。

实现:

QueryWrapper

使用:

创建QueryWrapper对象，使用该对象中提供的对应的数据库操作的方法，来完成条件的拼接，QueryWrapper对象最终存储拼接好的Sql片段，将片段拼接在Sql语句中。

15.2. QueryWrapper常用方法

MyBatis&Plus笔记_第17张图片

15.3. 带条件的查询的代码示例

/*
*  使用eq和or方法完成条件拼接
*/
@Test
public void testSelParam(){
    //获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //条件查询
	List<Student> students = studentMapper.selectList(new Querywrapper<Student>()
                                                      .eq("sage", 20)
                                                      .or()
                                                      .eq("s_name", "张同学"));
	//输出查询结果
	System.out.println(students);
}

/**
  查询名字中包含同学，并且年龄为20的信息
  使用Like完成操作
*/
@Test
public void testSelParam2(){
    //获取Spring容器对象
	ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取容器中mapper接口对象
	StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //条件查询
	List<Student> students = studentMapper.selectList(new QueryWrapper<Student>()
                                                      .like("s_name", "同学")
                                                      .eq("sage", 20);
                                                      
    //输出查询结果
	System.out.println(students);
}

16. MybatisPlus的分页查询

16.1. 介绍

问题:

对于传统的分页Sql语句，需要我们自己在Sql语句中使用limit关键字来实现分页查询。但是呢，在MybatisPlus中，Sql语句是动态生成的，那么如何完成数据的分页查询呢？

解决:

使用分页插件。

使用:

  1. 在配置文件中配置分页插件。

  2. 在代码中调用分页效果。

16.2. 配置


<bean id = "factory" class = "com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    <property name = "plugins">
        <array>
            <bean class = "com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor">
                <property name = "dialectType" value = "mysql">property>
            bean>
        array>
    property>
bean>

16.3. 使用

/*
      1.创建 Page 对象，在该对象中声明页面数和每页的数量
      2.调用 selectPage 方法完成分页查询
        参数∶
          Page参数∶封装了分页的页码数和每页数量的对象
          Wrapper参数∶封装了筛选条件的条件构造器对象。没有筛选条件则传入null值
      3.从selectPage方法的返回值对象Page中获取分页数据
    */
//测试Mp的分页插件
@Test
public void testMpPage(){
    //获取Spring容器对象
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取Mapper对象
    StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //分页查询所有的学生信息//创建分页对象
    Page<Student>page=new Page<>(2, 2);
    //分页查询
    Page<Student> ps = studentMapper.selectPage(page, null);
    //输出分页查询结果
    System.out.println("获取当前的分页数据∶"+ps.getRecords());
    System.out.println("获取当前的页码数∶"+ps.getCurrent());
    System.out.println("获取当前的每页显示的数据量∶"+ps.getSize();
	System.out.println("总的数据量∶"+ps.getTotal());
    System.out.println("总的页码数∶"+ps.getPages());
    //分页查询名字中包含"同学"的数据
    //创建分页对象
    Page<Student>p=new Page<>(1, 2);
    //分页查询
    Page<Student> p2 = studentMapper.selectPage(p,
		new Querywrapper<Student>()
			.like("s_name", "同学")
			.eq("sage", 20);
	//输出分页查询结果
	System.out.println（"获取当前的分页数据∶"+p2.getRecords());
	System.out.println("获取当前的页码数∶"+p2.getCurrent());
	System.out.println("获取当前的每页显示的数据量∶"+p2.getSize());
	System.out.println("总的数据量∶"+p2.getTotal());
	System.out.println("总的页码数∶"+p2.getPages());
}

17. MybatisPlus的常用注解

17.1. 介绍

问题:

在使用MybatisPlus后，我们不用再声明Sql语句了，只需要我们的Mapper接口继承BaseMapper接口即可拥有对应的CRUD操作。通过我们之前的学习我们发现，MyBatisPlus其实在根据我们的实体类来动态的生成对象的Sql语句，默认会按照类名即是对应的表的表名，属性名即是对应的表的字段名。但是如果实体类名和表名不一致，或者属性名和字段名不一致怎么办？

解决:

在实体类上使用注解表名对应的映射关系。

注意:

建议大家在开发时尽量保证实体类和表之间的字段名称是相同的，这样就不用声明注解了。

17.2. 常用注解及其作用

17.2.1. @TableName注解

作用:表明实体类对应的数据库表。

使用:在类名上使用，值为对应的表的表名。

示例:

@TableName("t_student")
public class Student {
    ...
}

官方说明:

MyBatis&Plus笔记_第18张图片

17.2.2. @TableId

作用:表明类中的某个属性为主键字段对应的属性。

使用:在类中为主键的字段上使用。

示例:

@TableName("t_student")
public class Student {
    @TableId(type = IdType.AUTO)
    private Integer sid;
    @TableField("s_name")
    private String sname;
    private Integer sage;
    private String ssex;
    private String sphone;
}

官方说明:

MyBatis&Plus笔记_第19张图片

17.2.3. @TableField

作用:表明普通属性映射的表中的字段，值为字段名。

使用:在普通属性上使用。

示例：

@TableName("t_student")
public class Student {
    @TableId(type = IdType.AUTO)
    private Integer sid;
    @TableField("s_name")
    private String sname;
    private Integer sage;
    private String ssex;
    private String sphone;
    //在实体类中定义的非数据库字段的属性，需要设置
    @TableField(exist = false)
    private String fav;
}

官方说明:

MyBatis&Plus笔记_第20张图片

17.3. 获取自增的主键值

在Mybatis中需要使用 useGeneratedKeys，keyProperty，keyColumn 设置自增主键值的回返，然后在实体类对象中获取即可。在MybatisPlus中在进行数据新增时，在新增成功后，会自动的将自增的主键值返回到实体类对象中，前提是需要在实体类中使用@TableId表明主键字段，并且为自增类型。

/**
* 测试MybatisPlus获取自增主键
*/
@Test
public void testGetId(){
    //获取Spring容器对象
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //获取Mapper对象
    StudentMapper studentMapper=(StudentMapper) ac.getBean("studentMapper");
    //创建学生信息
    Student student=new Student();
    student.setSname("王兀");
    student.setSsex("1");
    student.setSage(40);
    student.setSphone("16633669988");
    //完成新增
    int i = studentMapper.insert(student);
    //输出新增数据的主键值
    System.out.println("主键∶"+student.getSid());
    //输出新增结果
    System.out.println("新增结果∶"+i);
}

18. MybatisPlus的全局配置策略

18.1. 介绍

问题:

假如我们每个实体类和数据库中的表名都不一致，表名都以t_开头，类名没有t_字符，比如t_student表和Student类。这样每个实体类上我们都要使用@TableName注解来表名类和表的映射关系，过于麻烦怎么办?

解决:

使用MP的全局配置策略：GlobalConfig

作用:

  1. 配置表和类名映射关系的前缀。

  2. 配置全局主键自增。

18.2. 示例


<bean id="factory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
    
    <property name="globalConfig" ref="globalConfig">property>
    <---配置分页插件-->
        <property name="plugins">
            <array>
                <bean class="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor">
                    <!--设置当前数据库的类型->
                    <property name="dialeetType" value="mysql">property>
                bean>
            array>
        property>
        bean>
    
    <bean id="globalConfig" class-"com.baomidou.mybatisplus.core,config.GlobalConfig">
        
        <property name="dbConfig">
            <bean id="db" class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
                
                <property name="tablePrefix" value="t_">property>
                
                <property name="idType" value="AUTO">property>
            bean>
        property>
    bean>

19. Active Record

ActiveRecord 形式调用，实体类只需继承 Model 类即可进行强大的 CRUD 操作。

19.1. AR模式和MP的Mapper模式的比较

  1. 原有MP的Mapper模式。

    1. 创建项目完成Spring和MP的集成。

    2. 创建数据库表对应的实体类。

    3. 创建mapper接口并继承BaseMapper接口。

    4. 从Spring容器中获取Mapper接口的实例化对象完成数据库操作。

      描述:

      ​ 通过以上流程，MP的操作模式较优于原有Mybatis的数据库操作流程。

      ​ 没有任何变化，只是我们在编写代码的时候不用在mapper层声明，
      Sql语句或者XML文件了，提升了开发效率。

  2. MP的AR模式

    1. 创建项目完成Spring和MP的集成。

    2. 创建数据库表对应的实体类，继续Model类。

    3. 在实体类中覆写pkVal方法。

    4. 创建Mapper接口并继承BaseMapper接口。

    5. 创建Spring对象，让Spring容器完成对Mapper层的实例化扫描。

    6. 创建实体类对象，直接调用实体类从Model中继承的数据库方法完成数据库操作。

  3. 流程比较分析

    MP的AR模式其实底层仍然使用的是Mapper层在完成数据库操作。

    只不过由我们自己调用Mapper对象操作数据库，变成了通过实体类对象来调用Mapper完成数据库操作。

    从代码的物理视图上我们是看不到实体类调用Mapper的过程的。也就说，本质上仍然是Mapper层在操作数据库。

19.2. AR模式的特点

AR模式较于传统的MP模式操作数据库，在代码体系中，我们不用再获取Mapper对象，然后再将实体类传入给mapper层完成数据库操作，直接使用实体类即可完成操作，提升了开发效率。

19.3. AR模式的使用代码示例

  1. 创建一个集成了MP的SSM项目。

  2. 在pojo层创建实体类，并继承Model类，覆写pkVal的方法。

    public class Student extends Model<Student> {
    @TableId(type = IdType.AUTO)
    private Integer sid;
    @TableField("s_name")
    private String sname;
    private String ssex;
    private Integer sage;
    private String sphone;
    //覆写方法，指明主键，返回主键字段对应的属性@0verride
    protected Serializable pkVal() {
        return sid;
    }
}

  3. 使用AR模式完成数据库操作。

    /**
测试插入
*/
@Test
public void testMpARIns(){
    //创建spring容器
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //创建实体类
    Student student=new Student();
    student.setSname("腾同学");
    student.setSsex("1");
    student.setSage(20);
    student.setSphone("16699887766");
    //完成增加
    boolean flag = student.insert();
    System.out.println(flag);
}

//测试MP的AR模式的查询
/**
	注意使用AR的查询是需要在实体类属性上使用 @TableId 注解表明该属性为主键属性
*/
@Test
public void testMpARSel(){
    //创建spring容器
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //创建实体类
    Student student=new Student();
    student.setSid(2);
    Student student1 = student.selectById();
    //完成查询
    System.out.println(student1);
}

//测试MP的AR模式的更新
@Test
public void testMpARUp(){
    //创建spring容器
    ApplicationContext ac=new ClassPathXmlApplicationCcntext("applicationcontext-mp.xml");
    //创建实体类
    Student student=new Student();
    student.setSid(3);
    student.setSsex("0");
    student.setSage(25);
    //测试更新
    boolean b = student.updateById();
    System.out.println(b);
}

//测试MP的AR模式的删除@Test
public void testMpARDel(){
    //创建spring容器
    ApplicationContext ac=new ClassPathXmlApplicationContext("applicationcontext-mp.xml");
    //创建实体类
    Student student=new Student();
    student.setSid(9);
    //测试删除
    boolean b = student.deleteById();
    System.out.println(b);
}

20. AutoGenerator代码生成器

20.1. 介绍

问题:

目前我们在开发SSM项目的时候，会先搭建一个SSM的开发环境。

我们会根据数据库的表在pojo包中创建对应的实体类，而且在不关心项目功能的同时，在mapper层对数据库的表的基础增删改查功能提前实现，同理，在service层可以将基础的业务代码提前声明。

然后再根据项目功能完成对应的复杂操作。而整个过程需要程序员手动完成搭建，效率低下。

解决:

创建一个代码生成类，调用该类的对象，并将对应的数据库表作为参数传递进入以及一些生成代码的其他要求也传递给该对象，让该对象帮助我们生成基础的开发代码。

实现:

MP的代码生成器。

作用:

根据数据库中的表动态的生成表对应的mapper,service,pojo,controller层的基础代码，提升开发效率。

20.2. 使用

推荐查看官网新版实现方式。

https://baomidou.com/pages/779a6e/

你可能感兴趣的:(mybatis)

  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • MyBatis 详解 阿贾克斯的黎明 javamybatis
    目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
  • mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析 weixin_39844942 mybatis二级缓存失效
    这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
  • 详解mybatis的一二级缓存以及缓存失效原因 仰望天花板 缓存数据库mybatisjavamysql
    数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
  • 36. MyBatis如何支持多数据库操作？如何配置不同的数据源？ 这孩子叫逆 Mybatis笔记mybatis数据库
    在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
  • MyBatis批量插入大量数据 小黑屋说YYDS MyBatisjava
    1.思路分析批量插入这个问题，我们用JDBC操作，其实就是两种思路吧：用一个for循环，把数据一条一条的插入（这种需要开启批处理）。生成一条插入sql，类似这种insertintouser(username,address)values(‘aa’,‘bb’),(‘cc’,‘dd’)…。到底哪种快呢？我们从两方面来考虑这个问题：插入SQL本身执行的效率。网络I/O。先说第一种方案，就是用for循环循
  • MyBatis 查询数据库_mybatis查询某个库的所有表名(2) 2401_84181942 程序员mybatisoracletomcat
    标签说明：***``标签**：需要指定namespace属性，表示命名空间，值为mapper接口的全限定名，包括全包名.类名。***``查询标签**：是用来执行数据库的查询操作的：`id`：是和Interface（接口）中定义的方法名称一样的，表示对接口的具体实现方法。`resultType`：是返回的数据类型，也就是开头我们定义的实体类。####2.4.4添加Service服务层实现代码如下：@
  • 5-【JavaWeb】JUnit 单元测试及JUL 日志系统 weixin_44329069 JavaWebjunit单元测试
    1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
  • 【免费】springboot项目申报管理系统|毕业设计|Javaweb项目 计算机学姐来啦 springbootssmjavaspringboot课程设计后端毕设毕业设计java-ee
    收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
  • MyBatis系统学习（一）——项目结构及其含义 OEC小胖胖 MyBatismybatis学习web后端
    1.MyBatis简介MyBatis是一款优秀的持久层框架，它通过SQL映射的方式实现Java对数据库操作的映射，既保留了SQL语句的灵活性，也简化了代码的编写。在一个MyBatis项目中，核心部分主要有：配置文件（mybatis-config.xml）映射文件（Mapper.xml）实体类（Entity/POJO）接口类（Mapper接口）MyBatis会话工厂（SqlSessionFactor
  • MyBatis 如何将 Mapper 接口与其 XML 映射文件关联：深入原理与实现 OEC小胖胖 web后端mybatisxmljavaweb后端
    MyBatis如何将Mapper接口与其XML映射文件关联：深入原理与实现1.概述MyBatis是一个简单、灵活的持久层框架，它通过SQL语句将Java对象与数据库进行映射。MyBatis支持基于XML和注解的配置方式。在实际开发中，XML映射文件与Mapper接口的关联是MyBatis的核心功能之一。通过这种关联，开发者可以在Mapper接口中定义方法，并在XML文件中编写SQL语句，从而实现数
  • Mybatis实现员工管理系统 wu1113_ mybatisjavamaven
    文章目录1.案例需求2.编程思路3.案例源码4.小结1.案例需求在上次做的父子模块的maven以及Ajax实现人工管理系统的基础上使用Mybatis实现员工管理系统的增删改查，具体运行效果如下：2.编程思路Mybatis框架的一般执行流程：创建MyBatis配置文件mybatis-config.xml在里面加载数据源、事务等，管理映射文件创建需要的映射文件mapper.xml，用于映射表中列和实体
  • springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么 okchan666 springbootjava
    先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
  • MyBatis 方法重载的陷阱及解决方案 molashaonian mybatis方法重载异常方法名相同
    在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
  • Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码 及 功能清单 Xiaohong0716 mybatisjavaspringcloud
    一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
  • BindingException: Invalid bound statement (not found) 小卡车555 MyBatismybatisjavamysql
    Mybatis出现绑定异常问题的解决org.apache.ibatis.binding.BindingException:Invalidboundstatement(notfound)一般的原因是Mapperinterface和xml文件的定义对应不上，需要检查包名，namespace，函数名称等能否对应上，需要比较细致的对比，我经常就是写错了一两个字母搞的很长时间找不到错误按以下步骤一一执行：1
  • 工程项目管理系统源码与Spring Cloud：实现高效系统管理与二次开发 微服务技术分享 springcloudjava工程项目管理系统源码
    随着企业规模的不断扩大和业务的快速发展，传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性，企业需要借助先进的数字化技术进行转型。本文将介绍一款采用SpringCloud+SpringBoot+Mybatis技术框架的工程项目管理系统，该系统涵盖了项目管理、合同管理、预警管理、竣工管理、质量管理等多个方面，通过数据字典、编码管理、用户管理
  • [附源码]SSM计算机毕业设计游戏账号交易平台JAVA 计算机程序源码 java游戏mysql
    项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
  • Mybatis Mysql 莫夏_b560
    1、查询失败或者结果异常andfwbdh=#{fwbdh}更换成andfwbdh=#{fwbdh}
  • 33. MyBatis中的@Param注解如何使用？如何在Mapper接口中传递多个参数？ 这孩子叫逆 Mybatis笔记javamybatistomcat
    在MyBatis中，@Param注解用于将方法参数绑定到SQL语句中的命名参数。它主要用于在Mapper接口中传递多个参数，以便在SQL语句中更方便地引用这些参数。为什么使用@Param注解？在MyBatis中，当Mapper接口的方法只有一个参数时，MyBatis会默认将这个参数的名称绑定为#{parameter}，可以直接在SQL语句中引用它。如果方法有多个参数，MyBatis默认使用para
  • Python+Django毕业设计校园易购二手交易平台（程序+LW+部署） Python、JAVA毕设程序源码 课程设计javamysql
    项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
  • Springboot3 整合 Mybatis3 （前程似锦） mybatisjavaspringboot
    Springboot3整合MybatisSpringboot3整合MybatisSpringboot3整合Mybatis一、导入依赖二、编写配置文件三、定义模型entity实体类四、在启动类上添加注解，表示mapper接口所在位置五、定义mapper接口六、定义mapper.xml映射文件七、service层八、测试一、导入依赖mybatis的必要依赖注意：使用springboot3的话要使用my
  • mybatis支持json，Spring boot配置 Knight_9
    mysql5.7版本以后支持原生json格式，基于Springboot进行配置说明。mybatis支持mysql的json格式mysql-connector，mysql的驱动版本要大于等于5.1.40，否则json字段查询会发生乱码。继承BaseTypeHandler自定义一个json类型处理器，放到一个handler包下，例：packagecom.c.config.handler;importc
  • 【Java】Mybatis Druid连接池配置详细 beautiful_huang Java
    pom.xmlcom.alibabadruid1.0.18.propertiesspring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.url=jdbc:mysql://localhost:3306/mybatis2?characterEncoding=utf-8&useSSL=truespring.da
  • 关于com.baomidou:mybatis-plus-boot-starter:jar:unknown was not found解决办法 波斯CD mybatisjarjava
    原型com.baomidoumybatis-plus-boot-starter修改以后解决了com.baomidoumybatis-plus-boot-starter3.5.3.1
  • MyBatis-Plus 3.5.5的代码生成器 实践【完整代码】 qq_43513957 mybatis
    MyBatis-Plus3.5.5的代码生成器实践【完整代码】1.表：要有一个version字段，乐观锁更新。配置拦截器的代码packagecom.example.demo.zmybatisplusGenerator.config;importcom.baomidou.mybatisplus.annotation.DbType;importcom.baomidou.mybatisplus.exte
  • 深入解析 MyBatis：从理论到项目实例 OEC小胖胖 web后端mybatisjavaspringweb后端
    深入解析MyBatis：从理论到项目实例目录MyBatis概述MyBatis项目结构及作用核心概念详解分页功能的实现与深入剖析动态SQL缓存机制详解与Spring集成常见问题与深入分析完整项目示例总结1.MyBatis概述MyBatis是一个轻量级的持久层框架，使用SQL查询语句来访问数据库。它与Java对象建立映射关系，通过配置文件或注解来管理SQL语句，灵活性高且与数据库操作直接相关，适合需要
  • MyBatis Plus 实战详解 Aries263 redis分布式数据库
    一、引言MyBatisPlus（简称MP）是MyBatis的增强工具，旨在简化开发、提高效率。它保留了MyBatis的强大功能，并在其基础上进行了扩展和优化，提供了强大的CRUD操作、配置选项、条件构造器等功能。本文将详细介绍MyBatisPlus的安装、配置、基本操作以及分页和条件查询的使用。二、安装与配置1.添加依赖首先，在Maven项目的pom.xml中添加MyBatisPlus的依赖。以下
  • 在springboot中，利用xml配置mybatis的方法 猪猡猪猡猪 javamybatismybatisspringbootxmljavamysql
    前置步骤参考博客：SpringBoot配置Mybatis的两种方式（通过XML配置和通过YML配置文件配置）_Darreni的博客-CSDN博客但按照博客中的关键代码和步骤创建的项目无法启动启动报错：Description:FailedtoconfigureaDataSource:'url’attributeisnotspecif:Reason:Failedtodetermineasuitable
  • MyBatis 学习笔记(4) 动态SQL 张云飞Vir
    1.背景本节讲mybatis应对动态SQL的场景。2.知识动态SQL是指“条件"不固定的SQL，对比于一般的SQL，动态SQL会有一个或者多个条件/参数。比如：场景：查询的时候，如果用户输入了姓名，就按姓名模糊查询；同时又输入了邮箱，就再增加一个条件按姓名+邮箱两个条件查询。传统的拼接SQL很费力，拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。借助功能强大的基于OGNL的
  • java封装继承多态等 麦田的设计者 javaeclipsejvmcencapsulatopn
           最近一段时间看了很多的视频却忘记总结了，现在只能想到什么写什么了，希望能起到一个回忆巩固的作用。     1、final关键字       译为：最终的        &
  • F5与集群的区别 bijian1013 weblogic集群F5
            http请求配置不是通过集群，而是F5；集群是weblogic容器的，如果是ejb接口是通过集群。         F5同集群的差别，主要还是会话复制的问题，F5一把是分发http请求用的，因为http都是无状态的服务，无需关注会话问题，类似
  • LeetCode[Math] - #7 Reverse Integer Cwind java题解MathLeetCodeAlgorithm
    原题链接：#7 Reverse Integer   要求： 按位反转输入的数字 例1： 输入 x = 123, 返回 321 例2： 输入 x = -123, 返回 -321   难度：简单   分析： 对于一般情况，首先保存输入数字的符号，然后每次取输入的末位（x%10）作为输出的高位（result = result*10 + x%10）即可。但
  • BufferedOutputStream 周凡杨
         首先说一下这个大批量，是指有上千万的数据量。      例子：      有一张短信历史表，其数据有上千万条数据，要进行数据备份到文本文件，就是执行如下SQL然后将结果集写入到文件中！      select t.msisd
  • linux下模拟按键输入和鼠标 被触发 linux
    查看/dev/input/eventX是什么类型的事件， cat /proc/bus/input/devices 设备有着自己特殊的按键键码，我需要将一些标准的按键，比如0－9，X－Z等模拟成标准按键，比如KEY_0,KEY-Z等，所以需要用到按键 模拟，具体方法就是操作/dev/input/event1文件，向它写入个input_event结构体就可以模拟按键的输入了。 linux/in
  • ContentProvider初体验 肆无忌惮_ ContentProvider
    ContentProvider在安卓开发中非常重要。与Activity，Service，BroadcastReceiver并称安卓组件四大天王。 在android中的作用是用来对外共享数据。因为安卓程序的数据库文件存放在data/data/packagename里面，这里面的文件默认都是私有的，别的程序无法访问。 如果QQ游戏想访问手机QQ的帐号信息一键登录，那么就需要使用内容提供者COnte
  • 关于Spring MVC项目（maven）中通过fileupload上传文件 843977358 mybatisspring mvc修改头像上传文件upload
    Spring MVC 中通过fileupload上传文件，其中项目使用maven管理。   1.上传文件首先需要的是导入相关支持jar包：commons-fileupload.jar,commons-io.jar 因为我是用的maven管理项目，所以要在pom文件中配置（每个人的jar包位置根据实际情况定） <!-- 文件上传 start by zhangyd-c --&g
  • 使用svnkit api，纯java操作svn，实现svn提交，更新等操作 aigo svnkit
     原文：http://blog.csdn.net/hardwin/article/details/7963318   import java.io.File; import org.apache.log4j.Logger; import org.tmatesoft.svn.core.SVNCommitInfo; import org.tmateso
  • 对比浏览器，casperjs，httpclient的Header信息 alleni123 爬虫crawlerheader
    @Override protected void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { String type=req.getParameter("type"); Enumeration es=re
  • java.io操作 DataInputStream和DataOutputStream基本数据流 百合不是茶 java流
    1，java中如果不保存整个对象，只保存类中的属性，那么我们可以使用本篇文章中的方法，如果要保存整个对象  先将类实例化  后面的文章将详细写到     2，DataInputStream 是java.io包中一个数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。应用程序可以使用数据输出流写入稍后由数据输入流读取的数据。
  • 车辆保险理赔案例 bijian1013 车险
    理赔案例： 一货运车，运输公司为车辆购买了机动车商业险和交强险，也买了安全生产责任险，运输一车烟花爆竹，在行驶途中发生爆炸，出现车毁、货损、司机亡、炸死一路人、炸毁一间民宅等惨剧，针对这几种情况，该如何赔付。 赔付建议和方案： 客户所买交强险在这里不起作用，因为交强险的赔付前提是：“机动车发生道路交通意外事故”； 如果是交通意外事故引发的爆炸，则优先适用交强险条款进行赔付，不足的部分由商业
  • 学习Spring必学的Java基础知识(5)—注解 bijian1013 javaspring
            文章来源：http://www.iteye.com/topic/1123823，整理在我的博客有两个目的：一个是原文确实很不错，通俗易懂，督促自已将博主的这一系列关于Spring文章都学完；另一个原因是为免原文被博主删除，在此记录，方便以后查找阅读。           有必要对
  • 【Struts2一】Struts2 Hello World bit1129 Hello world
    Struts2 Hello World应用的基本步骤 创建Struts2的Hello World应用，包括如下几步： 1.配置web.xml 2.创建Action 3.创建struts.xml，配置Action 4.启动web server，通过浏览器访问   配置web.xml <?xml version="1.0" encoding="
  • 【Avro二】Avro RPC框架 bit1129 rpc
    1. Avro RPC简介 1.1. RPC RPC逻辑上分为二层，一是传输层，负责网络通信；二是协议层，将数据按照一定协议格式打包和解包 从序列化方式来看，Apache Thrift 和Google的Protocol Buffers和Avro应该是属于同一个级别的框架，都能跨语言，性能优秀，数据精简，但是Avro的动态模式（不用生成代码，而且性能很好）这个特点让人非常喜欢，比较适合R
  • lua　set get cookie ronin47 lua cookie
    lua: local access_token = ngx.var.cookie_SGAccessToken if access_token then ngx.header["Set-Cookie"] = "SGAccessToken="..access_token.."; path=/;Max-Age=3000" end
  • java-打印不大于N的质数 bylijinnan java
    public class PrimeNumber { /** * 寻找不大于N的质数 */ public static void main(String[] args) { int n=100; PrimeNumber pn=new PrimeNumber(); pn.printPrimeNumber(n); System.out.print
  • Spring源码学习-PropertyPlaceholderHelper bylijinnan javaspring
    今天在看Spring 3.0.0.RELEASE的源码，发现PropertyPlaceholderHelper的一个bug 当时觉得奇怪，上网一搜，果然是个bug，不过早就有人发现了，且已经修复： 详见： http://forum.spring.io/forum/spring-projects/container/88107-propertyplaceholderhelper-bug
  • [逻辑与拓扑]布尔逻辑与拓扑结构的结合会产生什么? comsci 拓扑
       如果我们已经在一个工作流的节点中嵌入了可以进行逻辑推理的代码,那么成百上千个这样的节点如果组成一个拓扑网络,而这个网络是可以自动遍历的,非线性的拓扑计算模型和节点内部的布尔逻辑处理的结合,会产生什么样的结果呢?    是否可以形成一种新的模糊语言识别和处理模型呢?  大家有兴趣可以试试,用软件搞这些有个好处,就是花钱比较少,就算不成
  • ITEYE 都换百度推广了 cuisuqiang GoogleAdSense百度推广广告外快
    以前ITEYE的广告都是谷歌的Google AdSense，现在都换成百度推广了。   为什么个人博客设置里面还是Google AdSense呢？   都知道Google AdSense不好申请，这在ITEYE上也不是讨论了一两天了，强烈建议ITEYE换掉Google AdSense。至少，用一个好申请的吧。   什么时候能从ITEYE上来点外快，哪怕少点
  • 新浪微博技术架构分析 dalan_123 新浪微博架构
    新浪微博在短短一年时间内从零发展到五千万用户，我们的基层架构也发展了几个版本。第一版就是是非常快的，我们可以非常快的实现我们的模块。我们看一下技术特点，微博这个产品从架构上来分析，它需要解决的是发表和订阅的问题。我们第一版采用的是推的消息模式，假如说我们一个明星用户他有10万个粉丝，那就是说用户发表一条微博的时候，我们把这个微博消息攒成10万份，这样就是很简单了，第一版的架构实际上就是这两行字。第
  • 玩转ARP攻击 dcj3sjt126com r
    我写这片文章只是想让你明白深刻理解某一协议的好处。高手免看。如果有人利用这片文章所做的一切事情，盖不负责。 网上关于ARP的资料已经很多了，就不用我都说了。 用某一位高手的话来说，“我们能做的事情很多，唯一受限制的是我们的创造力和想象力”。 ARP也是如此。 以下讨论的机子有 一个要攻击的机子：10.5.4.178 硬件地址：52:54:4C:98
  • PHP编码规范 dcj3sjt126com 编码规范
    一、文件格式 1. 对于只含有 php 代码的文件，我们将在文件结尾处忽略掉 "?>" 。这是为了防止多余的空格或者其它字符影响到代码。例如：<?php$foo = 'foo';2. 缩进应该能够反映出代码的逻辑结果，尽量使用四个空格，禁止使用制表符TAB，因为这样能够保证有跨客户端编程器软件的灵活性。例
  • linux 脱机管理（nohup） eksliang linux nohupnohup
    脱机管理 nohup 转载请出自出处：http://eksliang.iteye.com/blog/2166699 nohup可以让你在脱机或者注销系统后，还能够让工作继续进行。他的语法如下 nohup [命令与参数] --在终端机前台工作 nohup [命令与参数] & --在终端机后台工作   但是这个命令需要注意的是，nohup并不支持bash的内置命令，所
  • BusinessObjects Enterprise Java SDK greemranqq javaBOSAPCrystal Reports
    最近项目用到oracle_ADF  从SAP/BO 上调用 水晶报表，资料比较少，我做一个简单的分享，给和我一样的新手 提供更多的便利。   首先，我是尝试用JAVA JSP 去访问的。   官方API：http://devlibrary.businessobjects.com/BusinessObjectsxi/en/en/BOE_SDK/boesdk_ja
  • 系统负载剧变下的管控策略 iamzhongyong 高并发
    假如目前的系统有100台机器，能够支撑每天1亿的点击量（这个就简单比喻一下），然后系统流量剧变了要，我如何应对，系统有那些策略可以处理，这里总结了一下之前的一些做法。 1、水平扩展 这个最容易理解，加机器，这样的话对于系统刚刚开始的伸缩性设计要求比较高，能够非常灵活的添加机器，来应对流量的变化。 2、系统分组 假如系统服务的业务不同，有优先级高的，有优先级低的，那就让不同的业务调用提前分组
  • BitTorrent DHT 协议中文翻译 justjavac bit
    前言 做了一个磁力链接和BT种子的搜索引擎 {Magnet & Torrent}，因此把 DHT 协议重新看了一遍。 BEP: 5Title: DHT ProtocolVersion: 3dec52cb3ae103ce22358e3894b31cad47a6f22bLast-Modified: Tue Apr 2 16:51:45 2013 -070
  • Ubuntu下Java环境的搭建 macroli java工作ubuntu
    配置命令： 　　$sudo apt-get install ubuntu-restricted-extras 　　再运行如下命令： 　　$sudo apt-get install sun-java6-jdk 　　待安装完毕后选择默认Java. 　　$sudo update- alternatives --config java 　　安装过程提示选择，输入“2”即可，然后按回车键确定。
  • js字符串转日期（兼容IE所有版本） qiaolevip TODateStringIE
    /** * 字符串转时间（yyyy-MM-dd HH:mm:ss） * result （分钟） */ stringToDate : function(fDate){ var fullDate = fDate.split(" ")[0].split("-"); var fullTime = fDate.split("
  • 【数据挖掘学习】关联规则算法Apriori的学习与SQL简单实现购物篮分析 superlxw1234 sql数据挖掘关联规则
    关联规则挖掘用于寻找给定数据集中项之间的有趣的关联或相关关系。 关联规则揭示了数据项间的未知的依赖关系，根据所挖掘的关联关系，可以从一个数据对象的信息来推断另一个数据对象的信息。 例如购物篮分析。牛奶 ⇒ 面包 [支持度：3%，置信度：40%] 支持度3%：意味3%顾客同时购买牛奶和面包。 置信度40%：意味购买牛奶的顾客40%也购买面包。 规则的支持度和置信度是两个规则兴
  • Spring 5.0 的系统需求，期待你的反馈 wiselyman spring
                   Spring 5.0将在2016年发布。Spring5.0将支持JDK 9。          Spring 5.0的特性计划还在工作中，请保持关注，所以作者希望从使用者得到关于Spring 5.0系统需求方面的反馈。  
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他