肥电

mybatis

1.前言

1.1.总体技术体系

1.1.1.单一架构

一个项目，一个工程，导出为一个war包，在一个Tomcat上运行。也叫all in one。

1.1.2.分布式架构

一个项目，拆分成很多个模块，每个模块是一个工程。每一个工程都是运行在自己的Tomcat上。模块之间可以互相调用。每一个模块内部可以看成是一个单一架构的应用。

1.2.框架的概念

框架=jar包+配置文件

1.3.Mybatis历史

MyBatis最初是Apache的一个开源项目iBatis, 2010年6月这个项目由Apache Software Foundation迁移到了Google Code。随着开发团队转投Google Code旗下， iBatis3.x正式更名为MyBatis。代码于2013年11月迁移到Github。

iBatis一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。 iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。

1.4.Mybatis下载地址

https://github.com/mybatis/mybatis-3

1.5.Mybatis特性

MyBatis支持定制化SQL、存储过程以及高级映射

MyBatis避免了几乎所有的JDBC代码和手动设置参数以及结果集解析操作

MyBatis可以使用简单的XML或注解实现配置和原始映射；将接口和Java的POJO（Plain Ordinary Java Object，普通的Java对象）映射成数据库中的记录

Mybatis是一个半自动的ORM（Object Relation Mapping）框架

1.6.与其它持久化层技术对比

JDBC
1. SQL 夹杂在Java代码中耦合度高，导致硬编码内伤
2. 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
3. 代码冗长，开发效率低
Hibernate 和 JPA
1. 操作简便，开发效率高
2. 程序中的长难复杂 SQL 需要绕过框架
3. 内部自动生产的 SQL，不容易做特殊优化
4. 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难。
5. 反射操作太多，导致数据库性能下降
MyBatis
1. 轻量级，性能出色
2. SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
3. 开发效率稍逊于HIbernate，但是完全能够接收

2.Mybatis基本用法

2.1.HelloWorld

2.1.1.物理建模

CREATE DATABASE `mybatis-example`;

USE `mybatis-example`;

CREATE TABLE `t_emp`(
emp_id INT AUTO_INCREMENT,
emp_name CHAR(100),
emp_salary DOUBLE(10,5),
PRIMARY KEY(emp_id)
)ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `t_emp`(emp_name,emp_salary) VALUES("tom",200.33);

2.1.2.逻辑建模

2.1.2.1.创建Maven module

2.1.2.2.引入MyBatis及其他相关依赖

<dependencies>
    
    <dependency>
        <groupId>org.mybatisgroupId>
        <artifactId>mybatisartifactId>
        <version>3.5.7version>
    dependency>
    
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
        <scope>testscope>
    dependency>
    
    <dependency>
        <groupId>mysqlgroupId>
        <artifactId>mysql-connector-javaartifactId>
        <version>5.1.3version>
    dependency>
    <dependency>
        <groupId>org.projectlombokgroupId>
        <artifactId>lombokartifactId>
        <version>1.18.6version>
    dependency>
dependencies>

2.1.2.3.创建Java实体类

实体类是和现实世界中某一个具体或抽象的概念对应，是软件开发过程中，为了管理现实世界中的数据而设计的模型。

实体类的多个不同的叫法：

domain：领域模型

entity：实体

POJO：Plain Old Java Object

Java bean：一个Java类

/**
 * 和数据库表t_emp对应的实体类
 * emp_id INT AUTO_INCREMENT
 * emp_name CHAR(100)
 * emp_salary DOUBLE(10,5)
 * 
 * Java的实体类中，属性的类型不要使用基本数据类型，要使用包装类型。因为包装类型可以赋值为null，表示空，而基本数据类型不可以。
 */
@NoArgsConstructor
@AllArgsConstructor
@Data
@ToString
public class Emp {
    private Long empId;
    private String empName;
    private Double empSalary;
}

2.1.3.搭建框架开发环境

主要操作就是创建全局配置文件和Mybatis映射文件

2.1.3.1.Mybatis全局配置文件

习惯上命名为mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以大家操作时可以直接复制、粘贴。

mybatis-config.xml


DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    
    <environments default="development">
        
        <environment id="development">
            
            <transactionManager type="JDBC"/>
            
            <dataSource type="POOLED">
                
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis-example?useUnicode=true&characterEncoding=utf-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            dataSource>
        environment>
    environments>
    
    <mappers>
        
        
        
        <mapper resource="mappers/EmployeeMapper.xml"/>
    mappers>
configuration>

environments表示配置Mybatis的开发环境，可以配置多个环境，在众多具体环境中，使用default属性指定实际运行时使用的环境。default属性的取值是environment标签的id属性的值。environment表示配置Mybatis的一个具体的环境。配置Mybatis的内置的事务管理器。dataSource数据源类型，在里面设置具体的数据库连接的具体信息
在mappers标签中进行Mapper注册：指定Mybatis映射文件的具体位置，在mapper文件写sql语句。
- mapper标签：配置一个具体的Mapper映射文件
- resource属性：指定Mapper映射文件的实际存储位置，这里需要使用一个以类路径根目录为基准的相对路径
对Maven工程的目录结构来说，resources目录下的内容会直接放入类路径，所以这里我们可以以resources目录为基准
配置url时在xml配置文件中，需要将’&‘符号转义，所以这里要写成’&’。如果关联外部配置文件jdbc.proerties中在properties类型问可以写&。

注意：配置文件存放的位置是src/main/resources目录下。

2.1.3.2.Mybatis映射文件

相关概念：ORM（Object Relationship Mapping）对象关系映射。

对象：Java的实体类对象
关系：关系型数据库
映射：二者之间的对应关系

Java概念	数据库概念
类	表
属性	字段/列
对象	记录/行


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




<mapper namespace="com.stonebridge.myBatis.dao.EmployeeMapper">

    
    
    
    

    
    
    
    <select id="selectEmpById" resultType="com.stonebridge.myBatis.domain.Emp">
        
        
        
        select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}
    select>
mapper>

namespace

在Java程序中，必须找到当前的Mapper配置文件，才能进一步找到这里配置的SQL语句。Java程序就是通过mapper标签的namespace属性找到当前Mapper配置文件。将来为了让一个Java接口，直接对应这个Mapper配置文件，通常使用Java接口的全类名作为这个namespace属性的值。以前我们叫dao，现在叫mapper，本质上都是持久化层的类型，只是命名习惯的区别。
sql类型的定义
- select语句使用select标签
- insert语句使用insert标签
- update语句使用update标签
- delete语句使用delect标签
在select标签中编写一条select语句实现查询效果

id属性：这条SQL语句的唯一标识

resultType属性：Mybatis负责解析结果集，将解析得到的数据封装到Java类型中。resultType属性就是指定这个Java类型

如果查出表的字段和Java类型的字段不一致，例如数据库字段含有下划线，大小写和java不一致。可以通过取别名的方式实现

注意：EmployeeMapper.xml所在的目录要和mybatis-config.xml中使用mapper标签配置的一致。

2.1.4.junit测试代码

public class Mybatis {
    @Test
    public void TestSelect() throws IOException {
        // 1.使用Mybatis的Resources类读取Mybatis全局配置文件
        InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
        // 2.创建SqlSessionFactoryBuilder对象。主要用于创建SqlSessionFactory
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        // 3.调用builder对象的build方法创建SqlSessionFactory对象
        SqlSessionFactory sessionFactory = builder.build(inputStream);
        // 4.通过SqlSessionFactory对象开启一个从Java程序到数据库的会话
        SqlSession session = sessionFactory.openSession();
        // 5.通过SqlSession对象找到Mapper配置文件中可以执行的SQL语句
        // statement参数的格式：Mapper配置文件的namespace属性.SQL标签的id属性
        // parameter参数：给SQL语句传入的参数
        Object object = session.selectOne("com.stonebridge.myBatis.dao.EmployeeMapper.selectEmpById", "1");
        // 6.直接打印查询结果
        System.out.println("object = " + object);
        // 7.提交事务
        session.commit();
        // 8.关闭SqlSession
        session.close();
    }
}

执行测试代码：

2.1.5.Mybatis执行流程说明

2.1.5.1.执行回顾

@Test
public void testHelloWorldReview() throws IOException {
    //1.借助Mybatis的Resource类将Mybatis全局配置文件读取到内存中
    //这里使用的路径仍然是一个以类路径目录为基准的相对路径
    InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
    //2.创建SqlSessionFactoryBuilder对象。SqlSessionFactoryBuilder对象主要用于创建SqlSessionFactory，SqlSessionFactory又是生产SqlSession的
    SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
    //3.调用builder对象的build()方法读取《全局配置文件的输入流》来创建SqlSessionFactory
    SqlSessionFactory factory = builder.build(inputStream);
    //4.调用工厂对象的方法开启一个会话，从java程序的持久层到数据库的会话
    SqlSession session = factory.openSession();
    //5.执行Mapper配置文件中准备好sql语句。找到sql语句的过程：通过namespace找到mapper映射文件的sql语句标签
    //备注：此时执行的查找操作的sql已经不是到xml配置文件中找了，因为xml配置文件中的信息已经读取到内存中封装成了对象，
    //所以此时其实是到已经封装的对象中查找，查找的依据是：mapper配置文件namespace值，sql语句标签的id
    String statement = "com.stonebridge.myBatis.dao.EmployeeMapper.selectEmpById";
    Long empId = 1L;
    Object object = session.selectOne(statement, empId);
    // 6.直接打印查询结果
    System.out.println("object = " + object);
    // 7.提交事务
    session.commit();
    // 8.关闭SqlSession
    session.close();
}

流程说明：

借助Mybatis的Resource类将Mybatis全局配置文件读取到内存中
创建SqlSessionFactoryBuilder对象。
SqlSessionFactoryBuilder对象使用build()方法读取<全局配置文件的输入流>来创建SqlSessionFactory对象。
SqlSessionFactory对象调用工厂对象的方法开启一个会话SqlSession，代表java程序的持久层和数据库之间的会话。（HttpSession是Java程序和浏览器之间的会话）

如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个“工厂类”中，以后都使用这个工厂类来“生产”我们需要的对象。

刚开始接触框架，我们会认为Java程序会转入XML配置文件中执行，但其实框架会在初始化时将XML文件读取进来，封装到对象中，再然后就都是Java代码的执行了，XML中的配置是没法执行的。

2.1.5.2.图解

2.1.5.3.源码

封装Configuration对象
准备去获取已映射的指令
正式获取已映射的指令
mappedStatements对象结构

mappedStatements对象的类型：Configuration类中的一个静态内部类：StrictMap

2.2.HelloWorld强化

2.2.1.加入日志

2.2.1.1.目的

在Mybatis工作过程中，通过打印日志的方式，将要执行的SQL语句打印出来。

2.2.1.2.操作

加入依赖


<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.17version>
dependency>

加入log4j的配置文件

支持XML和properties属性文件两种形式。无论使用哪种形式，文件名是固定的：

log4j.xml
log4j.properties


DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
    <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
        <param name="Encoding" value="UTF-8"/>
        <layout class="org.apache.log4j.PatternLayout">
            <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m  (%F:%L) \n"/>
        layout>
    appender>
    <logger name="java.sql">
        <level value="debug"/>
    logger>
    <logger name="org.apache.ibatis">
        <level value="info"/>
    logger>
    <root>
        <level value="debug"/>
        <appender-ref ref="STDOUT"/>
    root>
log4j:configuration>

日志的级别

FATAL(致命)>ERROR(错误)>WARN(警告)>INFO(信息)>DEBUG(调试)

从左到右打印的内容越来越详细
STDOUT

是standard output的缩写，意思是标准输出。对于Java程序来说，打印到标准输出就是打印到控制台。

打印效果

DEBUG 10-26 22:02:51,877 ==>  Preparing: select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=?  (BaseJdbcLogger.java:137) 
DEBUG 10-26 22:02:51,910 ==> Parameters: 1(String)  (BaseJdbcLogger.java:137) 
DEBUG 10-26 22:02:51,936 <==      Total: 1  (BaseJdbcLogger.java:137) 
object = Emp(empId=1, empName=tom, empSalary=200.33)

2.2.2.关联外部配置文件

2.2.2.1.需求

在实际开发时，同一套代码往往会对应多个不同的具体服务器环境。使用的数据库连接参数也不同。为了更好的维护这些信息，我们建议把数据库连接信息提取到Mybatis全局配置文件外边。

2.2.2.2.操作

创建jdbc.properties配置文件

wechat.dev.driver=com.mysql.jdbc.Driver
wechat.dev.url=jdbc:mysql://localhost:3306/mybatis-example?useUnicode=true&characterEncoding=UTF-8
wechat.dev.username=root
wechat.dev.password=123456

wechat.test.driver=com.mysql.jdbc.Driver
wechat.test.url=jdbc:mysql://192.168.198.150:3306/mybatis-example?useUnicode=true&characterEncoding=UTF-8
wechat.test.username=root
wechat.test.password=123456

wechat.product.driver=com.mysql.jdbc.Driver
wechat.product.url=jdbc:mysql://192.168.198.200:3306/mybatis-example?useUnicode=true&characterEncoding=UTF-8
wechat.product.username=root
wechat.product.password=123456

配置url时在xml配置文件中，需要将’&‘符号转义，所以这里要写成’&’。如果关联外部配置文件jdbc.proerties中在properties类型问可以写&。

在Mybatis全局配置文件中指定外部jdbc.properties文件的位置


<properties resource="jdbc.properties"/>

在需要具体属性值的时候使用${key}格式引用属性文件中的键

<dataSource type="POOLED">
    
    <property name="driver" value="${wechat.dev.driver}"/>
    <property name="url" value="${wechat.dev.url}"/>
    <property name="username" value="${wechat.dev.username}"/>
    <property name="password" value="${wechat.dev.password}"/>
dataSource>

2.2.3.使用Mapper接口

Mybatis中的Mapper接口相当于以前的Dao。但是区别在于，Mapper仅仅是接口，我们不需要提供实现类。

2.2.3.1.实现流程

2.2.3.2.项目结构

2.2.3.3.Mapper接口

声明这个接口是为了上层代码调用Mybatis的具体功能。就整个接口及其中的方法而言

接口的全类名要和Mapper配置文件的namespace一致，这样才能通过接口找到Mapper配置信息。
接口中的方法名要和mapper配置中sql语句所在标签的id一致，这样才能通过方法名找到具体的sql语句。
mapper配置文件的id属性值是唯一，所以对应mapper接口中的方法名也是唯一，当前接口的方法不允许重载。

方法对应Mapper配置文件配置的标签，就方法而言。

方法的参数对应sql中#{XXXX}声明的参数
方法的返回值类型和resultType属性指定的类型一致

public interface EmployeeMapper {
    /**
     * 通过这个方法对应Mapper配置文件的sql语句
     *
     * @param empId 当前方法的参数对应sql中#{empId}声明的参数
     * @return 当前方法的返回值类型和resultType属性指定的类型一致
     */
    Emp selectEmpById(Long empId);

    Integer insertEmp(Emp emp);

    Integer deleteEmp(Long empId);

    Integer updateEmp(Emp emp);
}

2.2.3.4.在mapper.xml中的标签写sql语句

在select标签中编写一条select语句实现查询效果。

id属性：这条SQL语句的唯一标识
resultType属性：Mybatis负责解析结果集，将解析得到的数据封装到Java类型中。resultType属性就是指定这个Java类型。如果查出表的字段和Java类型的字段不一致，可以通过取别名的方式实现。

SQL语句参数接收

#{empId}这里是为了方便接收Java程序传过来的参数数据
如果参数是基本类型，Mybatis负责将#{empId}部分转换为"?"占位符。用empId去填充占位符。
如果参数类型需要从Bean中解析

以insertEmp(Emp emp);为例

现在在这条SQL语句中，#{}中的表达式需要被用来从Emp emp实体类中获取emp_name的值、emp_salary的值。

而我们从实体类中获取值通常都是调用getter()方法。而getter()方法、setter()方法定义了实体类的属性。

定义属性的规则是：把get、set去掉，剩下部分首字母小写。

所以我们在#{}中使用getXxx()方法、setXxx()方法定义的属性名即可。


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.stonebridge.myBatis.dao.EmployeeMapper">
    
    
    
    
    <select id="selectEmpById" resultType="com.stonebridge.myBatis.domain.Emp">
        
        
        
        select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{empId}
    select>

    
    <insert id="insertEmp">
        
        
        
        
        
        INSERT INTO t_emp(emp_name,emp_salary) VALUES (#{empName},#{empSalary})
    insert>
    <delete id="deleteEmp">
        DELETE
        FROM t_emp
        WHERE emp_id = #{empId}
    delete>
    
    <update id="updateEmp">
        UPDATE t_emp
        SET emp_name=#{empName},
            emp_salary=#{empSalary}
        where emp_id = #{empId}
    update>
mapper>

2.2.3.5.Junit测试环境准备环境

@Before标注的方法会在会在每个@Test方法执行前执行。init()方法读取配置文件，准备环境。

@After标注的方法会在会在每个@Test方法执行前执行。clear()方法关闭资源。

public class MyBastisTestImprove {
    private SqlSession session;

    //junit会在每个@Test方法执行前执行
    @Before
    public void init() throws IOException {
        session = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml")).openSession();
    }

    @Test
    public void testUserMapperInterface() {
      //TODD
    }

    @After
    public void clear() {
        session.commit();
        session.close();
    }
}

2.2.3.6.调用Mapper接口实现增删改查

public class MyBastisTestImprove {
    private SqlSession session;

    //junit会在每个@Test方法执行前执行
    @Before
    public void init() throws IOException {
        session = new SqlSessionFactoryBuilder().build(Resources.getResourceAsStream("mybatis-config.xml")).openSession();
    }

    //执行查询
    @Test
    public void testUserMapperInterface() {
        EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
        System.out.println("employeeMapper.getClass().getName():" + employeeMapper.getClass().getName());
        //调用employeeMapper的方法去完成对数据库的操作
        Emp emp = employeeMapper.selectEmpById(1L);
        System.out.println(emp.toString());
    }

    //执行插入方法
    @Test
    public void TestInsert() {
        EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
        Integer row = employeeMapper.insertEmp(new Emp(null, "网", 112.333));
        System.out.println(row);
    }
    
    //执行删除方法
    @Test
    public void TestDelete() {
        EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
        Integer row = employeeMapper.deleteEmp(2l);
        System.out.println(row);
    }

    //执行更新方法
    @Test
    public void TestUpdate() {
        EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
        Integer row = employeeMapper.updateEmp(new Emp(3l, "张三", 222.33));
        System.out.println(row);
    }

    @After
    public void clear() {
        session.commit();
        session.close();
    }
}

2.3.给SQL语句传参

2.3.1.#{}方式

Mybatis会在运行过程中，把配置文件中的SQL语句里面的#{}转换为“?”占位符，发送给数据库执行。

配置文件中的SQL：

<delete id="deleteEmployeeById">
    delete from t_emp where emp_id=#{empId}
delete>

实际执行的SQL：

delete from t_emp where emp_id=?

2.3.2.${}方式

根据${}拼字符串

示例：

Mapper接口

public interface EmployeeMapper {
    Emp selectEmpByName(String name);
}

在mapper.xml配置文件配置sql

<select id="selectEmpByName" resultType="com.stonebridge.myBatis.domain.Emp">
    select emp_id empId, emp_name empName, emp_salary empSalary
    from t_emp
    where emp_name like "%${name}%"
select>

调用

@Test
public void testDollar() {
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    Emp emp = employeeMapper.selectEmpByName("r");
    System.out.println(emp.toString());
}

拼接sql效果

select emp_id empId, emp_name empName, emp_salary empSalary from t_emp where emp_name like "%r%"

2.4.数据输入

2.4.1.Mybatis总体机制概括

2.4.2.概念说明

这里数据输入具体是指上层方法（例如Service方法）调用Mapper接口时，数据传入的形式。

简单类型：只包含一个值的数据类型
- 基本数据类型：int、byte、short、double、……
- 基本数据类型的包装类型：Integer、Character、Double、……
- 字符串类型：String
复杂类型：包含多个值的数据类型
- 实体类类型：Employee、Department、……
- 集合类型：List、Set、Map、……
- 数组类型：int[]、String[]、……
- 复合类型：List、实体类中包含集合……

2.4.3.单个简单类型参数

2.4.3.1.Mapper接口中抽象方法的声明

Integer deleteEmp(Long empId);

2.4.3.2.Mapper配置文件

<delete id="deleteEmp">
    DELETE
    FROM t_emp
    WHERE emp_id = #{empId}
delete>

2.4.4.实体类类型参数

2.4.4.1.Mapper接口中抽象方法的声明

Integer insertEmp(Emp emp);

2.4.4.2.mapper配置文件

<insert id="insertEmp">
    INSERT INTO t_emp(emp_name,emp_salary) VALUES (#{empName},#{empSalary})
insert>

2.4.4.3.关系流程

Mybatis会根据#{}中传入的数据，加工成getXxx()方法，通过反射在实体类对象中调用这个方法，从而获取到对应的数据。填充到#{}这个位置。

2.4.5.零散的简单类型数据

2.4.5.1.Mapper接口中抽象方法的声明

Integer createEmp(@Param("empId") Long empId, @Param("name") String name, @Param("salary") Double salary);

2.4.5.2.Mapper配置文件

如果我们有在接口声明抽象方法时使用@Param注解给参数命名，那么就可以在#{}中使用我们指定的名称

void updateSalaryById(@Param(“empId”) Long empId, @Param(“empSalary”) Double salary);

如果我们没有在接口声明抽象方法时给参数命名，那么Mybatis会要求使用默认参数名

BindingException: Parameter ‘salary’ not found. Available parameters are [arg1, arg0, param1, param2]

<insert id="createEmp">
    INSERT INTO t_emp(emp_id, emp_name, emp_salary)
    VALUES (#{empId}, #{name}, #{salary})
insert>

2.4.5.3.Junit测试

@Test
public void TestMultiParama() {
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    Long empId = 24L;
    Double salary = Double.parseDouble("12345.67");
    String name = "stonebridge";
    Integer row = employeeMapper.createEmp(empId, name, salary);
    System.out.println(row); //1
}

2.4.5.4.测试效果

INSERT INTO t_emp(emp_id, emp_name, emp_salary) VALUES (?, ?, ?)  (BaseJdbcLogger.java:137) 
Parameters: 24(Long), stonebridge(String), 12345.67(Double)  (BaseJdbcLogger.java:137) 
DEBUG 10-28 21:13:38,791 <==    Updates: 1  (BaseJdbcLogger.java:137)

2.4.5.5.对应关系

2.4.6.Map类型参数

2.4.6.1.Mapper接口中抽象方法的声明

int updateEmployeeByMap(Map<String, Object> paramMap);

2.4.6.2.Mapper配置文件

<update id="updateEmployeeByMap">
    update t_emp
    set emp_salary=#{empSalaryKey}
    where emp_id = #{empIdKey}
update>

2.4.6.3.Junit测试

@Test
public void testUpdateEmpNameByMap() {
    EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
    Map<String, Object> paramMap = new HashMap<>();
    paramMap.put("empSalaryKey", 999.99);
    paramMap.put("empIdKey", 3);
    int result = mapper.updateEmployeeByMap(paramMap);
    System.out.println("result = " + result);
}

2.4.6.4.对应关系

#{}中写Map中的key

2.4.6.5.使用场景

有很多零散的参数需要传递，但是没有对应的实体类类型可以使用。使用@Param注解一个一个传入又太麻烦了，可以都封装到Map中。

2.5.数据输出

2.5.1.返回单个简单类型数据

2.5.1.1.Mapper接口中的抽象方法

int selectEmpCount();

2.5.1.2.Mapper配置文件

<select id="selectEmpCount" resultType="int">
    select count(*) from t_emp
select>

2.5.1.3.Junit测试

@Test
public void testEmpCount() {
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    int count = employeeMapper.selectEmpCount();
    System.out.println("count = " + count);
}

2.5.2.返回实体类对象

2.5.2.1.Mapper接口的抽象方法

Employee selectEmployee(Integer empId);

2.5.2.2.Mapper配置文件



<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    
    
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{maomi}
select>

通过给数据库表字段加别名，让查询结果的每一列都和Java实体类中属性对应起来。如果所有查询的字段和实体类中的字段都对不上，就会返回null，而不是空的实体类对象。

2.5.2.3.Junit测试

@Test
public void testSelectEmployee() {
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    Emp emp = employeeMapper.selectEmployee(23);
    System.out.println(emp);
}

2.5.2.4.补充：增加全局配置自动识别对应关系

在mybatis的主配置文件mybatis-config.xml开启增加全局配置自动识别对应关系。

将mapUnderscoreToCamelCase属性配置为true，表示开启自动映射驼峰式命名规则

规则要求如下：

数据库表字段命名方式：单词_单词；例如depart_name
Java实体类属性名命名方式：首字母小写的驼峰式命名；例如departName


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

开启该配置后,Mapper配置文件。

<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    select emp_id,emp_name,emp_salary from t_emp where emp_id=#{maomi}
select>

2.5.3.返回Map类型

适用于SQL查询返回的各个字段综合起来并不和任何一个现有的实体类对应，没法封装到实体类对象中。能够封装成实体类类型的，就不使用Map类型。

2.5.3.1.Mapper接口的抽象方法

Map<String,Object> selectEmpNameAndMaxSalary();

2.5.3.2.Mapper配置文件



<select id="selectEmpNameAndMaxSalary" resultType="map">
    SELECT emp_name                     员工姓名,
    emp_salary                          员工工资,
    (SELECT AVG(emp_salary) FROM t_emp) 部门平均工资
    FROM t_emp
    WHERE emp_salary = (
    SELECT MAX(emp_salary)
    FROM t_emp
    )
select>

2.5.3.3.Junit测试

@Test
public void testQueryEmpNameAndSalary() {
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    Map<String, Object> resultMap = employeeMapper.selectEmpNameAndMaxSalary();
    Set<Map.Entry<String, Object>> entrySet = resultMap.entrySet();
    for (Map.Entry<String, Object> entry : entrySet) {
        String key = entry.getKey();
        Object value = entry.getValue();
        System.out.println(key + "=" + value);
    }
}

2.5.4.返回List类型

查询结果返回多个实体类对象，希望把多个实体类对象放在List集合中返回。此时不需要任何特殊处理，在resultType属性中还是设置实体类类型即可。

2.5.4.1.Mapper接口的抽象方法

List<Emp> selectAll();

2.5.4.2.Mapper配置文件


<select id="selectAll" resultType="com.stonebridge.myBatis.domain.Emp">
    select emp_id empId, emp_name empName, emp_salary empSalary
    from t_emp
select>

2.5.4.3.Junit测试

@Test
public void testSelectAll() {
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    List<Emp> employeeList = employeeMapper.selectAll();
    for (Emp employee : employeeList) {
        System.out.println("employee = " + employee);
    }
}

2.5.5.返回自增主键

2.5.5.1.使用场景

例如：保存订单信息。需要保存Order对象和List。其中，OrderItem对应的数据库表，包含一个外键，指向Order对应表的主键。

在保存List的时候，需要使用下面的SQL：

insert into t_order_item(item_name,item_price,item_count,order_id) values(...)

这里需要用到的order_id，是在保存Order对象时，数据库表以自增方式产生的，需要特殊办法拿到这个自增的主键值。至于，为什么不能通过查询最大主键的方式解决这个问题，参考下图：

2.5.5.2.在Mapper配置文件中设置方式

Mapper接口中的抽象方法
```
int insertEmployee(Employee employee);
```

SQL语句




<insert id="insertEmployee" useGeneratedKeys="true" keyProperty="empId">
    insert into t_emp(emp_name,emp_salary)
    values(#{empName},#{empSalary})
insert>

Junit测试

@Test
public void testSaveEmp() {
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    Emp employee = new Emp();
    employee.setEmpName("john");
    employee.setEmpSalary(666.66);
    employeeMapper.insertEmployee(employee);
    System.out.println("employee.getEmpId() = " + employee.getEmpId());
}

注意

Mybatis是将自增主键的值设置到实体类对象中，而不是以Mapper接口方法返回值的形式返回。

2.5.5.3.不支持自增主键的数据库

而对于不支持自增型主键的数据库（例如 Oracle），则可以使用 selectKey 子元素：selectKey 元素将会首先运行，id 会被设置，然后插入语句会被调用。

<insert id="insertEmployee" parameterType="com.atguigu.mybatis.beans.Employee" databaseId="oracle">
        <selectKey order="BEFORE" keyProperty="id" resultType="integer">
            select employee_seq.nextval from dual 
        selectKey>    
        insert into orcl_employee(id,last_name,email,gender) values(#{id},#{lastName},#{email},#{gender})
insert>

2.5.6.数据库表字段和实体类属性对应关系

2.5.6.1.别名

将字段的别名设置成和实体类属性一致。



<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    
    
    select emp_id empId,emp_name empName,emp_salary empSalary from t_emp where emp_id=#{maomi}
select>

关于实体类属性的约定：getXxx()方法、setXxx()方法把方法名中的get或set去掉，首字母小写。

2.5.6.2.全局配置自动识别驼峰式命名规则

在Mybatis全局配置文件加入如下配置：


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

SQL语句中可以不使用别名


<select id="selectEmployee" resultType="com.atguigu.mybatis.entity.Employee">
    select emp_id,emp_name,emp_salary from t_emp where emp_id=#{empId}
select>

2.5.6.3.使用resultMap

使用resultMap标签定义对应关系，再在后面的SQL语句中引用这个对应关系

Mapper接口中的抽象方法
```
List<Emp> selectWithResultMap();
```

映射文件




<resultMap id="selectWithResultMapResultMap" type="com.stonebridge.myBatis.domain.Emp">
    
    <id column="emp_id" property="empId"/>
    
    
    <result column="emp_name" property="empName"/>
    <result column="emp_salary" property="empSalary"/>
resultMap>



<select id="selectWithResultMap" resultMap="selectWithResultMapResultMap">
    select emp_id, emp_name, emp_salary
    from t_emp
select>

测试

@Test
public void testSelectWithResultMap() {
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    List<Emp> empList = employeeMapper.selectWithResultMap();
    for (Emp emp : empList) {
        System.out.println("emp = " + emp);
    }
}

3.关联关系

3.1.概念

3.1.1.关联关系概念说明

3.1.1.1.数量关系

主要体现在数据库表中

一对一

夫妻关系，人和身份证号
一对多

用户和用户的订单，锁和钥匙
多对多

老师和学生，部门和员工

3.1.1.2.关联关系的方向

主要体现在Java实体类中

双向：双方都可以访问到对方
- Customer：包含Order的集合属性
- Order：包含单个Customer的属性
单向：双方中只有一方能够访问到对方
- Customer：不包含Order的集合属性，访问不到Order
- Order：包含单个Customer的属性

3.1.2.创建模型

3.1.2.1.创建实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Customer {
    private long customerId;
    private String customerName;

    // 体现对多关系
    private List<Order> orderList;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Order {
    private long orderId;
    private String orderName;
    private long customerId;
    // 体现对一关系
    private Customer customer;
}

3.1.2.2.创建数据库表插入测试数据

CREATE TABLE `t_customer` (
     `customer_id` INT NOT NULL AUTO_INCREMENT, 
     `customer_name` CHAR(100), 
     PRIMARY KEY (`customer_id`) 
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `t_order` ( 
    `order_id` INT NOT NULL AUTO_INCREMENT, 
    `order_name` CHAR(100), 
    `customer_id` INT, 
    PRIMARY KEY (`order_id`) 
)ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO `t_customer` (`customer_name`) VALUES ('c01');
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o1', '1'); 
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o2', '1'); 
INSERT INTO `t_order` (`order_name`, `customer_id`) VALUES ('o3', '1');

实际开发时，一般在开发过程中，不给数据库表设置外键约束。

原因是避免调试不方便。

一般是功能开发完成，再加外键约束检查是否有bug。

3.2.一对一

3.2.1.JavaBean

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Customer {
    private Integer customerId;
    private String customerName;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Order {
    private long orderId;
    private String orderName;
    private long customerId;
    // 体现对一关系
    private Customer customer;
}

3.2.2.创建OrderMapper接口

public interface OrderMapper {
    Order selectOrderWithCustomer(Integer orderId);
}

3.2.3.创建OrderMapper.xml配置文件

配置关联关系和SQL语句


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




<mapper namespace="com.stonebridge.mybatis.mapper.OrderMapper">
    
    
    
    <resultMap id="selectOrderWithCustomerResultMap" type="com.stonebridge.mybatis.entity.Order">
        
        
        
        
        <id column="order_id" property="orderId">id>
        <result column="order_name" property="orderName">result>
        <result column="customer_id" property="customerId">result>

        
        
        
        
        <association property="customer" javaType="com.stonebridge.mybatis.entity.Customer">
            
            <id column="customerId" property="customer_id">id>
            <result column="customerName" property="customer_name">result>
        association>
    resultMap>
    <select id="selectOrderWithCustomer" resultMap="selectOrderWithCustomerResultMap">
        select order_id, order_name, a.customer_id
        from t_order a
                 left join t_customer b on a.customer_id = b.customer_id
        where order_id = #{orderId};
    select>
mapper>

3.2.4.在MyBatis全局配置文件中注册配置文件

mybatis-config.xml


<mappers>
    
    
    
    <mapper resource="mappers/OrderMapper.xml"/>
mappers>

3.2.5.Junit测试

@Test
public void testQueryOrderWithCustomer() {
    OrderMapper orderMapper = session.getMapper(OrderMapper.class);
    Order order = orderMapper.selectOrderWithCustomer(1);
    System.out.println(order);
}

DEBUG 10-30 22:52:25,155 ==>  Preparing: select order_id, order_name, a.customer_id from t_order a left join t_customer b on a.customer_id = b.customer_id where order_id = ?;  (BaseJdbcLogger.java:137) 
DEBUG 10-30 22:52:25,244 ==> Parameters: 1(Integer)  (BaseJdbcLogger.java:137) 
DEBUG 10-30 22:52:25,272 <==      Total: 1  (BaseJdbcLogger.java:137) 
Order(orderId=1, orderName=o1, customerId=1, customer=null)

3.2.6.对应关系参考

在“对一”关联关系中，我们的配置比较多，但是关键词就只有：association和javaType

3.3.一对多

3.3.1.JavaBean

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Customer {
    private Integer customerId;
    private String customerName;
    // 声明order的List集合类型的属性，建立『对多(对方是多的一端)』关联关系
    private List<Order> orderList;
}

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class Order {
    private Integer orderId;
    private String orderName;
    private Integer customerId;
}

3.3.2.创建CustomerMapper接口

public interface CustomerMapper {
    Customer selectCustomerWithOrderList(int i);
}

3.3.3.创建OrderMapper.xml配置文件

配置关联关系和SQL语句


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




<mapper namespace="com.stonebridge.mybatis.mapper.CustomerMapper">
    
    <resultMap id="selectCustomerWithOrderLisResultMap" type="com.stonebridge.mybatis.entity.Customer">
        
        <id column="customer_id" property="customerId">id>
        <result column="customer_name" property="customerName">result>
        
        
        
        <collection property="orderList" ofType="com.stonebridge.mybatis.entity.Order">
            
            <id column="order_id" property="orderId">id>
            <result column="order_name" property="orderName">result>
            <result column="customer_id" property="customerId">result>
        collection>
    resultMap>
    
    <select id="selectCustomerWithOrderList" resultMap="selectCustomerWithOrderLisResultMap">
        select c.customer_id, customer_name, order_id, order_name
        from t_customer c
                 left join t_order o on c.customer_id = o.customer_id
        where c.customer_id = #{customerId}
    select>
mapper>

3.3.4.在MyBatis全局配置文件中注册配置文件

mybatis-config.xml


<mappers>
    
    
    
    <mapper resource="mappers/OrderMapper.xml"/>
mappers>

3.3.5.Junit测试

@Test
public void testQueryCustomerWithOrderList() {
    CustomerMapper customerMapper = session.getMapper(CustomerMapper.class);
    Integer customerId = 1;
    // 执行查询
    Customer customer = customerMapper.selectCustomerWithOrderList(customerId);
    // 打印Customer本身
    System.out.println("customer = " + customer);
    // 从Customer中获取Order集合数据
    List<Order> orderList = customer.getOrderList();
    for (Order order : orderList) {
        System.out.println("order = " + order);
    }
}

3.3.6.对应关系参考

在“对多”关联关系中，同样有很多配置，但是提炼出来最关键的就是：collection和ofType

3.4.分步查询

3.4.1.概念和需求

在执行一对一查询关联查询时，查询Order表作为主表，其中的Customer数据不管用不用都会查出来，如果查询的数据不用就浪费资源，完全不查需要的时候又要单独查询，此时也没有必要考虑关联关系了。

希望即能维持关联关系，用的时候又可以查询出来。

为了实现延迟加载，对Customer和Order的查询必须分开，分成两步来做，才能够实现（分步查询是懒加载的基础）。为此，我们需要单独查询Order，也就是需要在Mapper配置文件中，单独编写查询Order集合数据的SQL语句。

3.4.2.一对一分步查询

3.4.2.1.创建OrderMapper接口

public interface OrderMapper {
    Order selectOrderWithOrderTwoStep(Integer orderId);
}

3.4.2.2.在映射文件配置sql

OrderMapper.xml


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.stonebridge.mybatis.mapper.OrderMapper">
    <resultMap id="selectOrderWithCustomerTwoStepResultMap" type="com.stonebridge.mybatis.entity.Order">
        
        <id column="order_id" property="orderId"/>
        <result column="order_name" property="orderName"/>
        <result column="customer_id" property="customerId"/>

        
        
        
        <association
                property="customer"
                column="customer_id"
                select="com.stonebridge.mybatis.mapper.CustomerMapper.selectCustomerById"/>
    resultMap>

    
    
    <select id="selectOrderWithOrderTwoStep" resultMap="selectOrderWithCustomerTwoStepResultMap">
        select order_id, order_name, customer_id
        from t_order
        where order_id = #{orderId}
    select>
mapper>

CustomerMapper.xml

配置分步查询中对com.stonebridge.mybatis.mapper.CustomerMapper.selectCustomerById进行定义


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.stonebridge.mybatis.mapper.CustomerMapper">
    <select id="selectCustomerById" resultType="com.stonebridge.mybatis.entity.Customer">
        select customer_id, customer_name
        from t_customer
        where customer_id = #{customerId}
    select>
mapper>

3.4.2.3.Junit测试

@Test
public void testQueryOrderWithOrderList() {
    OrderMapper orderMapper = session.getMapper(OrderMapper.class);
    Integer orderId = 1;
    // 查询Order对象
    Order order = orderMapper.selectOrderWithOrderTwoStep(orderId);
    // 打印Order对象本身信息
    System.out.println("order = " + order);
    // 通过Order对象获取关联的Customer对象
    Customer customer = order.getCustomer();
    System.out.println("customer = " + customer);
}

3.4.3.一对多分布查询

3.4.3.1.创建CustomerMapper接口

public interface CustomerMapper {
    Customer selectCustomerWithOrderList(Integer customerId);
}

3.4.3.2.在映射文件配置sql

CustomerMapper.xml


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.stonebridge.mybatis.mapper.CustomerMapper">
    <resultMap id="selectCustomerWithOrderListResultMap" type="com.stonebridge.mybatis.entity.Customer">
        
        <id column="customer_id" property="customerId"/>
        <result column="customer_name" property="customerName"/>

        
        
        
        
        <collection property="orderList"
                    column="customer_id"
                    select="com.stonebridge.mybatis.mapper.OrderMapper.selectOrderListByCustomerId"/>
    resultMap>
    <select id="selectCustomerWithOrderList" resultMap="selectCustomerWithOrderListResultMap">
        select customer_id, customer_name
        from t_customer
        where customer_id = #{customerId}
    select>
mapper>

OrderMapper.xml

配置分步查询中对com.stonebridge.mybatis.mapper.CustomerMapper.selectCustomerById进行定义


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.stonebridge.mybatis.mapper.OrderMapper">der_id = #{orderId}
    select>
    
    <select id="selectOrderListByCustomerId" resultType="com.stonebridge.mybatis.entity.Order">
        select order_id, order_name, customer_id
        from t_order
        where customer_id = #{customerId}
    select>
mapper>

3.4.3.3.Junit测试

@Test
public void testQueryCustomerWithOrderList() {
    CustomerMapper customerMapper = session.getMapper(CustomerMapper.class);
    Integer customerId = 1;
    // 查询Order对象
    Customer customer = customerMapper.selectCustomerWithOrderList(customerId);
    // 打印Order对象本身信息
    System.out.println("customer = " + customer);
    // 通过Order对象获取关联的Customer对象
    List<Order> list = customer.getOrderList();
    for (Order order : list) {
        System.out.println("order=" + order);
    }
}

3.4.3.4.各个要素之间的对应关系

3.5.延迟加载

3.5.1.概念

查询到Customer的时候，不一定会使用Order的List集合数据。如果Order的集合数据始终没有使用，那么这部分数据占用的内存就浪费了。对此，我们希望不一定会被用到的数据，能够在需要使用的时候再去查询。

例如：对Customer进行1000次查询中，其中只有15次会用到Order的集合数据，那么就在需要使用时才去查询能够大幅度节约内存空间。

延迟加载的概念：对于实体类关联的属性到需要使用时才查询。也叫懒加载。

3.5.2.在Mybatis全局配置文件中配置settings

3.5.2.1.低版本

在Mybatis全局配置文件中配置settings


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

官方文档中对aggressiveLazyLoading属性的解释：

When enabled, an object with lazy loaded properties will be loaded entirely upon a call to any of the lazy properties.Otherwise, each property is loaded on demand.

3.5.2.2.较高版本


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

3.5.2.3.Junit测试

不要先打印customer整体

@Test
public void testQueryCustomerWithOrderList() throws InterruptedException {
    CustomerMapper customerMapper = session.getMapper(CustomerMapper.class);
    Integer customerId = 1;
    // 查询Order对象
    Customer customer = customerMapper.selectCustomerWithOrderList(customerId);
    // 打印Order对象本身信息
    // System.out.println("customer = " + customer);
    System.out.println("customerId:" + customer.getCustomerId());
    System.out.println("customerName:" + customer.getCustomerName());
    TimeUnit.SECONDS.sleep(3);
    // 通过Order对象获取关联的Customer对象
    List<Order> list = customer.getOrderList();
    for (Order order : list) {
        System.out.println("order=" + order);
    }
}

效果：刚开始先查询Customer本身，需要用到OrderList的时候才发送SQL语句去查询

3.5.2.4.关键词总结

我们是在“对多”关系中举例说明延迟加载的，在“对一”中配置方式基本一样。

关联关系	配置项关键词	所在配置文件
对一	association标签/javaType属性	Mapper配置文件中的resultMap
对多	collection标签/ofType属性	Mapper配置文件中的resultMap
对一分步	association标签/select属性	Mapper配置文件中的resultMap
对多分步	collection标签/select属性	Mapper配置文件中的resultMap
延迟加载[低]	lazyLoadingEnabled设置为true aggressiveLazyLoading设置为false	Mybatis全局配置文件中的settings
延迟加载[高]	lazyLoadingEnabled设置为true	Mybatis全局配置文件中的settings

3.6.多对多关联关系需要中间表

3.7.1.如果不使用中间表

在某一个表中，使用一个字段保存多个“外键”值，这将导致无法使用SQL语句进行关联查询。

3.7.2.使用中间表

这样就可以使用SQL进行关联查询了。只是有可能需要三张表进行关联。

3.7.3.中间表设置主键

3.7.3.1.另外设置一个专门的主键字段

3.7.3.2.使用联合主键

使用联合主键时，只要多个字段的组合不重复即可，单个字段内部是可以重复的。

4.动态SQL

4.1.简介

Mybatis框架的动态SQL技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题。

One of the most powerful features of MyBatis has always been its Dynamic SQL capabilities. If you have any experience with JDBC or any similar framework, you understand how painful it is to conditionally concatenate strings of SQL together, making sure not to forget spaces or to omit a comma at the end of a list of columns. Dynamic SQL can be downright painful to deal with.

MyBatis的一个强大的特性之一通常是它的动态SQL能力。如果你有使用JDBC或其他相似框架的经验，你就明白条件地串联SQL字符串在一起是多么的痛苦，确保不能忘了空格或在列表的最后省略逗号。动态SQL可以彻底处理这种痛苦。

4.2.if和where标签

使用where标签动态生成SQL语句中的where子句
- 如果where标签内没有有效的条件，那么最终的SQL语句中，不会出现where关键词
- 能够去除查询条件中前后多余的and或or

使用if标签可以让SQL语句的片段，在满足条件时才加入最终的SQL语句

test属性：if标签中的判断条件。在test属性中能直接访问接口抽象方法传入的数据。

test属性：在条件判断语句中，难免会用到大于号、小于号。此时需要将大于号(>)、小于号(<)转义

XML转义字符

<	<	小于号
>	>	大于号
<=	<=	小于等于号
>=	>=	大于等于号
&	&	和
'	’	单引号
"	"	双引号


<select id="selectEmpByCondition" resultType="com.stonebridge.MyBatis.domain.Emp">
    select emp_id, emp_name, emp_salary
    from t_emp
    
    
    
    <where>
        
        
        <if test="empName!=null">
            or emp_name=#{empName}
        if>
        
        <if test="empSalary > 100">
            or emp_salary=#{empSalary}
        if>
        
        
        
        
    where>
select>

测试：

@Test
public void testQueryEmp() {
    EmployeeMapper customerMapper = session.getMapper(EmployeeMapper.class);
    Map<String, Object> map = new HashMap<>();
    map.put("empName",null);
    map.put("empSalary",999.99);
    List<Emp> list = customerMapper.selectEmpByCondition(map);
    for (Emp emp : list) {
        System.out.println("emp:" + emp.toString());
    }
}

@Test
public void testQueryEmp() {
    EmployeeMapper customerMapper = session.getMapper(EmployeeMapper.class);
    Map<String, Object> map = new HashMap<>();
    map.put("empName","stonebridge");
    map.put("empSalary",200000);
    List<Emp> list = customerMapper.selectEmpByCondition(map);
    for (Emp emp : list) {
        System.out.println("emp:" + emp.toString());
    }
}

4.3.set标签

4.3.1.相关业务需求举例

实际开发时，对一个实体类对象进行更新。往往不是更新所有字段，而是更新一部分字段。此时页面上的表单往往不会给不修改的字段提供表单项。

<form action="" method="">
    <input type="hidden" name="userId" value="5232" />
    年  龄：<input type="text" name="userAge" /><br/>
    性  别：<input type="text" name="userGender" /><br/>
    坐  标：<input type="text" name="userPosition" /><br/>
    
    
    
    <button type="submit">修改button>
form>

例如上面的表单，如果服务器端接收表单时，使用的是User这个实体类，那么userName、userBalance、userGrade接收到的数据就是null。

如果不加判断，直接用User对象去更新数据库，在Mapper配置文件中又是每一个字段都更新，那就会把userName、userBalance、userGrade设置为null值，从而造成数据库表中对应数据被破坏。

此时需要我们在Mapper配置文件中，对update语句的set子句进行定制，此时就可以使用动态SQL的set标签，没有set子句的update语句会导致SQL语法错误。

4.3.2.实际配置方式


<update id="updateEmployeeDynamic">
    update t_emp
    
    
    <set>
        <if test="empName != null">
            emp_name=#{empName},
        if>
        <if test="empSalary < 3000">
            emp_salary=#{empSalary},
        if>
    set>
    where emp_id=#{empId}
    
update>

@Test
public void testUpadteEmpCondition() {
    EmployeeMapper customerMapper = session.getMapper(EmployeeMapper.class);
    Map<String, Object> map = new HashMap<>();
    map.put("empName", "stonebridge");
    map.put("empSalary", 20000);
    Integer row = customerMapper.updateEmpConditional(map);
}

4.4.trim标签

4.4.1.基本概念

使用trim标签控制条件部分两端是否包含某些字符

prefix属性：指定要动态添加的前缀
suffix属性：指定要动态添加的后缀
prefixOverrides属性：指定要动态去掉的前缀，使用“|”分隔有可能的多个值
suffixOverrides属性：指定要动态去掉的后缀，使用“|”分隔有可能的多个值


<select id="selectEmployeeByConditionByTrim" resultType="com.atguigu.mybatis.entity.Employee">
    select emp_id,emp_name,emp_age,emp_salary,emp_gender
    from t_emp
    
    
    
    
    
    
    <trim prefix="where" suffixOverrides="and|or">
        <if test="empName != null">
            emp_name=#{empName} and
        if>
        <if test="empSalary > 3000">
            emp_salary>#{empSalary} and
        if>
        <if test="empAge <= 20">
            emp_age=#{empAge} or
        if>
        <if test="empGender=='male'">
            emp_gender=#{empGender}
        if>
    trim>
select>

4.4.2.示例


<select id="selectEmpByConditionByTrim" resultType="com.stonebridge.MyBatis.domain.Emp">
    select emp_id, emp_name, emp_salary from t_emp
    
    
    <trim prefix="where" prefixOverrides="and|or">
        
        
        <if test="empName != null">
            or emp_name=#{empName}
        if>

        
        <if test="empSalary > 2000">
            and emp_salary>#{empSalary}
        if>
    trim>
select>

@Test
public void testSelectEmpByConditionByTrim() {
    EmployeeMapper customerMapper = session.getMapper(EmployeeMapper.class);
    Map<String, Object> map = new HashMap<>();
    map.put("empName", "stonebridge");
    //        map.put("empSalary", 2000);
    List<Emp> list = customerMapper.selectEmpByConditionByTrim(map);
    for (Emp emp : list) {
        System.out.println(emp);
    }
}

4.5.choose/when/otherwise标签

多个分支条件中，仅执行一个

从上到下依次执行条件判断
遇到的第一个满足条件的分支就会被采纳
被采纳分支后面的分支都将不被考虑
如果所有的when分支都不满足，那么就执行otherwise分支


<select id="selectEmployeeByConditionByChoose" resultType="com.atguigu.mybatis.entity.Employee">
    select emp_id,emp_name,emp_salary from t_emp
    where
    <choose>
        <when test="empName != null">emp_name=#{empName}when>
        <when test="empSalary < 3000">emp_salary < 3000when>
        <otherwise>1=1otherwise>
    choose>
    
    
select>

4.6.foreach标签

4.6.1.基本用法

用批量插入举例


<foreach collection="empList" item="emp" separator="," open="values" index="myIndex">
    
    (#{emp.empName},#{myIndex},#{emp.empSalary},#{emp.empGender})
foreach>

4.6.2.批量更新时需要注意

上面批量插入的例子本质上是一条SQL语句，而实现批量更新则需要多条SQL语句拼起来，用分号分开。也就是一次性发送多条SQL语句让数据库执行。此时需要在数据库连接信息的URL地址中设置：allowMultiQueries=true

atguigu.dev.url=jdbc:mysql://192.168.198.100:3306/mybatis0922?allowMultiQueries=true

对应的foreach标签如下：


<update id="updateEmployeeBatch">
    <foreach collection="empList" item="emp" separator=";">
        update t_emp set emp_name=#{emp.empName} where emp_id=#{emp.empId}
    foreach>
update>

4.6.3.关于foreach标签的collection属性

如果没有给接口中List类型的参数使用@Param注解指定一个具体的名字，那么在collection属性中默认可以使用collection或list来引用这个list集合。这一点可以通过异常信息看出来：

Parameter 'empList' not found. Available parameters are [collection, list]

在实际开发中，为了避免隐晦的表达造成一定的误会，建议使用@Param注解明确声明变量的名称，然后在foreach标签的collection属性中按照@Param注解指定的名称来引用传入的参数。

4.6.4.示例





<insert id="batchInsert">
    insert into t_emp(emp_name, emp_salary)
    
    
    
    
    
    
    <foreach collection="empList" item="emp" separator="," open="values">
        (#{emp.empName},#{emp.empSalary})
    foreach>
insert>

@Test
public void testBatchInsert() {
    EmployeeMapper customerMapper = session.getMapper(EmployeeMapper.class);
    List<Emp> list = new ArrayList<>();
    for (int i = 0; i < 10; i++) {
        Emp emp = new Emp(null, "tiger_" + i, i * 1000.00);
        list.add(emp);
    }
    customerMapper.batchInsert(list);
}

4.7.sql标签

4.7.1.抽取重复的SQL片段


<sql id="mySelectSql">
    select emp_id,emp_name,emp_age,emp_salary,emp_gender from t_emp
sql>

4.7.2.引用已抽取的SQL片段


<include refid="mySelectSql"/>

5.缓存机制

5.1.简介

理解缓存的工作机制和缓存的用途。

5.1.1.缓存机制介绍

为了节约时间，节约性能，一个数据集查出来后把他放在缓存里面，下次需要的时候直接获取。

缓存一定是用在查询过程中的，增删改后数据库数据和缓存不一致，很多情况执行增删改后会清空缓存。

5.1.2.一级缓存和二级缓存

5.1.2.1.使用顺序

查询的顺序是：

先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。
如果二级缓存没有命中，再查询一级缓存
如果一级缓存也没有命中，则查询数据库
SqlSession关闭之前，一级缓存中的数据会写入二级缓存

5.1.2.2.效用范围

一级缓存：SqlSession级别，一级缓存占用的内存很小，默认存在
二级缓存：SqlSessionFactory级别，只要应用在运行，二级缓存就一直存在，二级缓存为整个应用服务，内存占用规模比较大。需要配置。

它们之间范围的大小参考下面图：

5.2.一级缓存

5.2.1.验证一级缓存

@Test
public void testFirstLevelCache() {
    SqlSession session = factory.openSession();
    EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
    Integer empId = 1;
    Emp emp01 = mapper.selectEmpById(empId);
    System.out.println("第一次查询emp01=" + emp01.toString());

    Emp emp02 = mapper.selectEmpById(empId);
    System.out.println("第二次查询emp02=" + emp02.toString());
    session.commit();
    session.close();
}

打印结果：

5.2.2.一级缓存失效的情况

一级缓存的应用范围就是在同一个事务中，连续两次相同的查询操作才会用到，故一级缓存应用范围不大。

不是同一个SqlSession
同一个SqlSession但是查询条件发生了变化
同一个SqlSession两次查询期间执行了任何一次增删改操作
同一个SqlSession两次查询期间手动清空了缓存
同一个SqlSession两次查询期间提交了事务

5.3.二级缓存

这里使用的是Mybatis自带的二级缓存。

5.3.1.代码测试二级缓存

5.3.1.1.开启二级缓存功能

在想要使用二级缓存的Mapper配置文件中加入cache标签

<mapper namespace="com.stonebridge.MyBatis.dao.EmployeeMapper">
    
    <cache/>
mapper>

5.3.1.2.让实体类支持序列化

public class Emp implements Serializable {
	……
}

5.3.1.3.Junit测试

未启用二级缓存

查询后SqlSession关闭时，一级缓存中的数据会写入二级缓存。此时后续相同查询才会使用二级缓存。如果未关闭SqlSession则不会将一级缓存写入二级缓存。

示例：

@Test
public void testSecondLevelCache() {
    // 测试二级缓存存在：使用两个不同SqlSession执行查询
    // 说明：SqlSession提交事务时才会将查询到的数据存入二级缓存
    // 所以本例并没有能够成功从二级缓存获取到数据
    SqlSession session01 = factory.openSession();
    SqlSession session02 = factory.openSession();
    EmployeeMapper mapper01 = session01.getMapper(EmployeeMapper.class);
    EmployeeMapper mapper02 = session02.getMapper(EmployeeMapper.class);
    Integer empId = 1;
    // DEBUG 11-01 16:59:15,933 Cache Hit Ratio [com.stonebridge.MyBatis.dao.EmployeeMapper]: 0.0
    Emp emp01 = mapper01.selectEmpById(empId);
    // DEBUG 11-01 16:59:16,630 Cache Hit Ratio [com.stonebridge.MyBatis.dao.EmployeeMapper]: 0.0
    Emp emp02 = mapper02.selectEmpById(empId);
    System.out.println("emp01 = " + emp01);
    System.out.println("emp02 = " + emp02);
    session01.commit();
    session01.close();
    session02.commit();
    session02.close();
}

启用二级缓存

@Test
public void testSecondLevelCacheWork() {
    SqlSession session = factory.openSession();
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    Integer empId = 1;
    // 第一次查询
    Emp emp01 = employeeMapper.selectEmpById(empId);
    System.out.println("emp01 = " + emp01);
    // 提交事务
    session.commit();
    // 关闭旧SqlSession
    session.close();
    // 开启新SqlSession
    session = factory.openSession();
    // 第二次查询
    employeeMapper = session.getMapper(EmployeeMapper.class);
    Emp emp02 = employeeMapper.selectEmpById(empId);
    System.out.println("emp02 = " + emp02);
    session.commit();
    session.close();
    session = factory.openSession();
    employeeMapper = session.getMapper(EmployeeMapper.class);
    employeeMapper.selectEmpById(empId);
    session.commit();
    session.close();
}

5.3.2.查询结果存入二级缓存的时机

结论：SqlSession关闭的时候，一级缓存中的内容会被存入二级缓存

// 1.开启两个SqlSession
SqlSession session01 = factory.openSession();
SqlSession session02 = factory.openSession();
    
// 2.获取两个EmployeeMapper
EmployeeMapper employeeMapper01 = session01.getMapper(EmployeeMapper.class);
EmployeeMapper employeeMapper02 = session02.getMapper(EmployeeMapper.class);
    
// 3.使用两个EmployeeMapper做两次查询，返回两个Employee对象
Employee employee01 = employeeMapper01.selectEmployeeById(2);
Employee employee02 = employeeMapper02.selectEmployeeById(2);
    
// 4.比较两个Employee对象
System.out.println("employee02.equals(employee01) = " + employee02.equals(employee01));

上面代码打印的结果是：

DEBUG 12-01 10:10:32,209 Cache Hit Ratio [com.atguigu.mybatis.EmployeeMapper]: 0.0  (LoggingCache.java:62) 
DEBUG 12-01 10:10:32,570 ==>  Preparing: select emp_id,emp_name,emp_salary,emp_gender,emp_age from t_emp where emp_id=?   (BaseJdbcLogger.java:145) 
DEBUG 12-01 10:10:32,624 ==> Parameters: 2(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 12-01 10:10:32,643 <==      Total: 1  (BaseJdbcLogger.java:145) 
DEBUG 12-01 10:10:32,644 Cache Hit Ratio [com.atguigu.mybatis.EmployeeMapper]: 0.0  (LoggingCache.java:62) 
DEBUG 12-01 10:10:32,661 ==>  Preparing: select emp_id,emp_name,emp_salary,emp_gender,emp_age from t_emp where emp_id=?   (BaseJdbcLogger.java:145) 
DEBUG 12-01 10:10:32,662 ==> Parameters: 2(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 12-01 10:10:32,665 <==      Total: 1  (BaseJdbcLogger.java:145) 
employee02.equals(employee01) = false

修改代码：

// 1.开启两个SqlSession
SqlSession session01 = factory.openSession();
SqlSession session02 = factory.openSession();
    
// 2.获取两个EmployeeMapper
EmployeeMapper employeeMapper01 = session01.getMapper(EmployeeMapper.class);
EmployeeMapper employeeMapper02 = session02.getMapper(EmployeeMapper.class);
    
// 3.使用两个EmployeeMapper做两次查询，返回两个Employee对象
Employee employee01 = employeeMapper01.selectEmployeeById(2);
    
// ※第一次查询完成后，把所在的SqlSession关闭，使一级缓存中的数据存入二级缓存
session01.close();
Employee employee02 = employeeMapper02.selectEmployeeById(2);
    
// 4.比较两个Employee对象
System.out.println("employee02.equals(employee01) = " + employee02.equals(employee01));
    
// 5.另外一个SqlSession用完正常关闭
session02.close();

打印结果：

DEBUG 12-01 10:14:06,804 Cache Hit Ratio [com.atguigu.mybatis.EmployeeMapper]: 0.0  (LoggingCache.java:62) 
DEBUG 12-01 10:14:07,135 ==>  Preparing: select emp_id,emp_name,emp_salary,emp_gender,emp_age from t_emp where emp_id=?   (BaseJdbcLogger.java:145) 
DEBUG 12-01 10:14:07,202 ==> Parameters: 2(Integer)  (BaseJdbcLogger.java:145) 
DEBUG 12-01 10:14:07,224 <==      Total: 1  (BaseJdbcLogger.java:145) 
DEBUG 12-01 10:14:07,308 Cache Hit Ratio [com.atguigu.mybatis.EmployeeMapper]: 0.5  (LoggingCache.java:62) 
employee02.equals(employee01) = false

5.3.3.二级缓存相关配置

在Mapper配置文件中添加的cache标签可以设置一些属性：

eviction属性：缓存回收策略

LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。

FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。

SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。

WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。

默认的是 LRU。
flushInterval属性：刷新间隔，单位毫秒

默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新
size属性：引用数目，正整数

代表缓存最多可以存储多少个对象，太大容易导致内存溢出
readOnly属性：只读，true/false

true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。

false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是 false。

5.4.整合EHCache

5.4.1.EHCache简介

官网地址：https://www.ehcache.org/

Ehcache is an open source, standards-based cache that boosts performance, offloads your database, and simplifies scalability. It’s the most widely-used Java-based cache because it’s robust, proven, full-featured, and integrates with other popular libraries and frameworks. Ehcache scales from in-process caching, all the way to mixed in-process/out-of-process deployments with terabyte-sized caches.

5.4.2.整合操作

5.4.2.1.Mybatis环境

在Mybatis环境下整合EHCache，前提当然是要先准备好Mybatis的环境。

5.4.2.2.添加依赖

依赖信息


<dependency>
    <groupId>org.mybatis.cachesgroupId>
    <artifactId>mybatis-ehcacheartifactId>
    <version>1.2.1version>
dependency>

<dependency>
    <groupId>ch.qos.logbackgroupId>
    <artifactId>logback-classicartifactId>
    <version>1.2.3version>
dependency>

依赖传递情况

各主要jar包作用

jar包名称	作用
mybatis-ehcache	Mybatis和EHCache的整合包
ehcache	EHCache核心包
slf4j-api	SLF4J日志门面包
logback-classic	支持SLF4J门面接口的一个具体实现

5.4.2.3.整合EHCache

创建EHCache配置文件

ehcache.xml

文件内容


<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    
    <diskStore path="D:\atguigu\ehcache"/>

    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    defaultCache>
ehcache>

引入第三方框架或工具时，配置文件的文件名可以自定义吗？

可以自定义：文件名是由我告诉其他环境

不能自定义：文件名是框架内置的、约定好的，就不能自定义，以避免框架无法加载这个文件

指定缓存管理器的具体类型

还是到查询操作所的Mapper配置文件中，找到之前设置的cache标签：
```
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
```

5.4.2.4.加入logback日志

存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志。

各种Java日志框架简介

门面：

名称	说明
JCL（Jakarta Commons Logging）	陈旧
SLF4J（Simple Logging Facade for Java）★	适合
jboss-logging	特殊专业领域使用

实现：

名称	说明
log4j★	最初版
JUL（java.util.logging）	JDK自带
log4j2	Apache收购log4j后全面重构，内部实现和log4j完全不同
logback★	优雅、强大

注：标记★的技术是同一作者。

Logback配置文件


<configuration debug="true">
    
    <appender name="STDOUT"
              class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            
            
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%npattern>
        encoder>
    appender>
    
    
    <root level="DEBUG">
        
        <appender-ref ref="STDOUT"/>
    root>
    
    <logger name="com.atguigu.crowd.mapper" level="DEBUG"/>
configuration>

5.4.2.5.Junit测试

正常按照二级缓存的方式测试即可。因为整合EHCache后，其实就是使用EHCache代替了Mybatis自带的二级缓存。

@Test
public void testSecondLevelCacheWork() {
    SqlSession session = factory.openSession();
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    Integer empId = 1;
    // 第一次查询
    Emp emp01 = employeeMapper.selectEmpById(empId);
    System.out.println("emp01 = " + emp01);
    // 提交事务
    session.commit();
    // 关闭旧SqlSession
    session.close();
    // 开启新SqlSession
    session = factory.openSession();
    // 第二次查询
    employeeMapper = session.getMapper(EmployeeMapper.class);
    Emp emp02 = employeeMapper.selectEmpById(empId);
    System.out.println("emp02 = " + emp02);
    session.commit();
    session.close();
    session = factory.openSession();
    employeeMapper = session.getMapper(EmployeeMapper.class);
    employeeMapper.selectEmpById(empId);
    session.commit();
    session.close();
}

5.4.3.EHCache配置文件说明

当借助CacheManager.add(“缓存名称”)创建Cache时，EhCache便会采用指定的的管理策略。

defaultCache标签各属性说明：

属性名	是否必须	作用
maxElementsInMemory	是	在内存中缓存的element的最大数目
maxElementsOnDisk	是	在磁盘上缓存的element的最大数目，若是0表示无穷大
eternal	是	设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds、timeToLiveSeconds判断
overflowToDisk	是	设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
timeToIdleSeconds	否	当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
timeToLiveSeconds	否	缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
diskSpoolBufferSizeMB	否	DiskStore(磁盘缓存)的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区
diskPersistent	否	在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
diskExpiryThreadIntervalSeconds	否	磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
memoryStoreEvictionPolicy	否	当内存缓存达到最大，有新的element加入的时候，移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）

5.5.缓存的基本原理

5.5.1.Cache接口

5.5.1.1.Cache接口的重要地位

org.apache.ibatis.cache.Cache接口：所有缓存都必须实现的顶级接口

org.apache.ibatis.cache.impl.PerpetualCache：mybatis一级缓存和二级缓存都需要的用到的类

5.5.1.2.Cache接口中的方法

缓存基本都是键值对结构，查询条件不同，去的值不同。根据Cache接口中方法的声明我们能够看到，缓存的本质是一个Map。

方法名	作用
putObject()	将对象存入缓存
getObject()	从缓存中取出对象
removeObject()	从缓存中删除对象

5.5.2.PerpetualCache

org.apache.ibatis.cache.impl.PerpetualCache是Mybatis的默认缓存，也是Cache接口的默认实现。Mybatis一级缓存和自带的二级缓存都是通过PerpetualCache来操作缓存数据的。但是这就奇怪了，同样是PerpetualCache这个类，怎么能区分出来两种不同级别的缓存呢？

其实很简单，调用者不同。

一级缓存：由BaseExecutor调用PerpetualCache
二级缓存：由CachingExecutor调用PerpetualCache，而CachingExecutor可以看做是对BaseExecutor的装饰

5.5.3.一级缓存机制

org.apache.ibatis.executor.BaseExecutor类中的关键方法：

BaseExecutor实现org.apache.ibatis.executor.Executor接口

5.5.3.1.query()方法

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
        throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
        clearLocalCache();
    }
    List<E> list;
    try {
        queryStack++;
        
        // 尝试从本地缓存中获取数据
        list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
        
        if (list != null) {
            handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
        } else {
            
            // 如果本地缓存中没有查询到数据，则查询数据库
            list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        }
    } finally {
        queryStack--;
    }
    if (queryStack == 0) {
        for (org.apache.ibatis.executor.BaseExecutor.DeferredLoad deferredLoad : deferredLoads) {
            deferredLoad.load();
        }
        // issue #601
        deferredLoads.clear();
        if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
            // issue #482
            clearLocalCache();
        }
    }
    return list;
}

5.5.3.2.queryFromDatabase()方法

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
        
        // 从数据库中查询数据
        list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
        localCache.removeObject(key);
    }
    
    // 将数据存入本地缓存
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
        localOutputParameterCache.putObject(key, parameter);
    }
    return list;
}

5.5.4.二级缓存机制

5.5.4.1.未开启二级缓存

5.5.4.2.使用自带二级缓存

5.5.4.3.使用EHCache

6.逆向工程

6.1.概念与机制

6.1.1.概念

正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。Hibernate是支持正向工程的。

逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：

Java实体类
Mapper接口
Mapper配置文件

6.1.2.基本原理

6.2.具体实现

6.2.1.配置POM


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>MyBatis-ProartifactId>
        <groupId>org.stonebridgegroupId>
        <version>1.0-SNAPSHOTversion>
    parent>
    <modelVersion>4.0.0modelVersion>

    <artifactId>mybatis-MBGartifactId>

    <properties>
        <maven.compiler.source>8maven.compiler.source>
        <maven.compiler.target>8maven.compiler.target>
    properties>
    
    <dependencies>
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.7version>
        dependency>
    dependencies>
    
    <build>
        
        <plugins>
            
            <plugin>
                <groupId>org.mybatis.generatorgroupId>
                <artifactId>mybatis-generator-maven-pluginartifactId>
                <version>1.3.0version>
                
                <dependencies>
                    
                    <dependency>
                        <groupId>org.mybatis.generatorgroupId>
                        <artifactId>mybatis-generator-coreartifactId>
                        <version>1.3.2version>
                    dependency>

                    
                    <dependency>
                        <groupId>com.mchangegroupId>
                        <artifactId>c3p0artifactId>
                        <version>0.9.2version>
                    dependency>

                    
                    <dependency>
                        <groupId>mysqlgroupId>
                        <artifactId>mysql-connector-javaartifactId>
                        <version>5.1.8version>
                    dependency>
                dependencies>
            plugin>
        plugins>
    build>
project>

6.2.2.MBG配置文件

文件名必须是：generatorConfig.xml

注意数据库的链接信息和目录名称


DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    
    <context id="DB2Tables" targetRuntime="MyBatis3">
        
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/mybatis-example"
                        userId="root"
                        password="123456">
        jdbcConnection>
        
        <javaModelGenerator targetPackage="com.stonebridge.mybatis.entity" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
            <property name="trimStrings" value="true"/>
        javaModelGenerator>
        
        <sqlMapGenerator targetPackage="com.stonebridge.mybatis.mapper" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
        sqlMapGenerator>
        
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.stonebridge.mybatis.mapper"
                             targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true"/>
        javaClientGenerator>
        
        
        
        <table tableName="t_emp" domainObjectName="Employee"/>
        <table tableName="t_customer" domainObjectName="Customer"/>
        <table tableName="t_order" domainObjectName="Order"/>
    context>
generatorConfiguration>

6.2.3.执行MBG插件的generate目标

6.2.4.生成效果

6.3.QBC查询

6.3.1.概念

QBC：Query By Criteria

QBC查询最大的特点就是将SQL语句中的WHERE子句进行了组件化的封装，让我们可以通过调用Criteria对象的方法自由的拼装查询条件。

6.3.2.示例

@Test
public void testQBC() {
    // 目标：组装查询条件WHERE (xxx and xxx) or (xxx and xxx)
    // 1.创建Example对象
    EmployeeExample example = new EmployeeExample();
    // 2.根据Example对象创建Criteria对象
    EmployeeExample.Criteria criteria01 = example.createCriteria();
    EmployeeExample.Criteria criteria02 = example.or();
    // 3.在Criteria对象中添加查询条件
    // ①emp_name like %o% and emp_salary > 6000.00
    criteria01.andEmpNameLike("%o%").andEmpSalaryGreaterThan(6000.00);
    // ②emp_name like %t% and emp_salary < 3000.00
    criteria02.andEmpNameLike("%t%").andEmpSalaryLessThan(3000.00);
    // 4.根据Example对象执行查询
    EmployeeMapper employeeMapper = session.getMapper(EmployeeMapper.class);
    List<Employee> employeeList = employeeMapper.selectByExample(example);
    for (Employee employee : employeeList) {
        System.out.println("employee = " + employee);
    }
    // 最终运行的结果：WHERE ( emp_name like %o% and emp_salary > 6000.00) or( emp_name like %t% and emp_salary < 3000.00 )
}

// 1.创建EmployeeExample对象
EmployeeExample example = new EmployeeExample();
// 2.通过example对象创建Criteria对象
EmployeeExample.Criteria criteria01 = example.createCriteria();
EmployeeExample.Criteria criteria02 = example.or();
// 3.在Criteria对象中封装查询条件
criteria01.andEmpAgeBetween(9, 99).andEmpNameLike("%o%").andEmpGenderEqualTo("male").andEmpSalaryGreaterThan(500.55);
criteria02.andEmpAgeBetween(9, 99).andEmpNameLike("%o%").andEmpGenderEqualTo("male").andEmpSalaryGreaterThan(500.55);
SqlSession session = factory.openSession();
EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
// 4.基于Criteria对象进行查询
List<Employee> employeeList = mapper.selectByExample(example);
for (Employee employee : employeeList) {
System.out.println("employee = " + employee);
}
session.close();
// 最终SQL的效果：
// WHERE ( emp_age between ? and ? and emp_name like ? and emp_gender = ? and emp_salary > ? ) or( emp_age between ? and ? and emp_name like ? and emp_gender = ? and emp_salary > ? )

7.其他

7.1.实体类类型别名

7.1.1.目标

让Mapper配置文件中使用的实体类类型名称更简洁。让Mapper配置文件中使用的实体类类型名称更简洁。

7.1.2.Mybatis全局配置文件


<typeAliases>
    
    <package name="com.atguigu.mybatis.entity"/>
typeAliases>

7.1.3.Mapper配置文件

在Mapper文件中配置对应的resultType时就不需要，配置全限定名。只需要使用简单类名即可。



<select id="selectEmployeeById" resultType="Employee">
    select emp_id,emp_name,emp_salary,emp_gender,emp_age from t_emp
    where emp_id=#{empId}
select>

7.2.类型处理器

7.2.1.Mybatis内置类型处理器

无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时，都会用类型处理器将获取的值以合适的方式转换成 Java 类型。

类型处理器	Java类型	JDBC类型
BooleanTypeHandler	Boolean，boolean	任何兼容的布尔值
ByteTypeHandler	Byte，byte	任何兼容的数字或字节类型
ShortTypeHandler	Short，short	任何兼容的数字或短整型
IntegerTypeHandler	Integer，int	任何兼容的数字和整型
LongTypeHandler	Long，long	任何兼容的数字或长整型
FloatTypeHandler	Float，float	任何兼容的数字或单精度浮点型
DoubleTypeHandler	Double，double	任何兼容的数字或双精度浮点型
BigDecimalTypeHandler	BigDecimal	任何兼容的数字或十进制小数类型
StringTypeHandler	String	CHAR和VARCHAR类型
ClobTypeHandler	String	CLOB和LONGVARCHAR类型
NStringTypeHandler	String	NVARCHAR和NCHAR类型
NClobTypeHandler	String	NCLOB类型
ByteArrayTypeHandler	byte[]	任何兼容的字节流类型
BlobTypeHandler	byte[]	BLOB和LONGVARBINARY类型
DateTypeHandler	Date(java.util)	TIMESTAMP类型
DateOnlyTypeHandler	Date(java.util)	DATE类型
TimeOnlyTypeHandler	Date(java.util)	TIME类型
SqlTimestampTypeHandler	Timestamp(java.sql)	TIMESTAMP类型
SqlDateTypeHandler	Date(java.sql)	DATE类型
SqlTimeTypeHandler	Time(java.sql)	TIME类型
ObjectTypeHandler	任意	其他或未指定类型
EnumTypeHandler	Enumeration类型	VARCHAR。任何兼容的字符串类型，作为代码存储（而不是索引）

7.3.Mapper映射

Mybatis允许在指定Mapper映射文件时，只指定其所在的包：

<mappers>
        <package name="com.atguigu.mybatis.dao"/>
mappers>

此时这个包下的所有Mapper配置文件将被自动加载、注册，比较方便。

但是，要求是：

Mapper接口和Mapper配置文件名称一致
Mapper配置文件放在Mapper接口所在的包内

如果工程是Maven工程，那么Mapper配置文件还是要放在resources目录下：

7.4.总结

Mybatis环境所需依赖 ★
配置
- Mybatis全局配置
- Mapper配置 ★
Mapper接口 ★
API
- SqlSessionFactory
- SqlSession
MBG ★
缓存
- 一级缓存
- 二级缓存
  - 自带
  - EHCache ☆
原理
- 把配置文件信息封装到Java对象中
- 缓存底层机制
- 四大接口
- Mybatis底层是JDBC

7.5.脑图脉络

7.5.1.MyBatis所需要的依赖

7.5.2.Mybatis全局配置

7.5.3.Mapper配置

7.5.4.mapper接口

7.5.5.逆向工程

7.5.6.缓存

7.5.7.原理

你可能感兴趣的:(Java,mybatis,java,数据持久化,mybatis)

Apache OFBiz路径遍历漏洞(CVE-2024-36104) WuY1nSec 漏洞复现 apache
0x01漏洞描述ApacheOFBiz是美国阿帕奇（Apache）基金会的一套企业资源计划（ERP）系统。该系统提供了一整套基于Java的Web应用程序组件和工具。ApacheOFBiz18.12.14之前版本存在命令执行漏洞，该漏洞源于ControlFilter对路径限制不当导致用户能够访问ProgramExport导出功能执行Groovy代码。0x02影响版本ApacheOFBiz<18.12
Spring框架快速入门手册 Uncoverlove spring mysql mybatis java 后端
说明：本文试图将Spring框架的知识体系进行整合分析，并冠以自己的理解，为初学Spring框架的同学，提供一个快速入门手册。同时呢，也是为了总结一下工作学习中遇到的问题和经验，以免发生遗漏！文末将附上Spring的学习资料，以供大家学习~（申明一下：纯小白一枚，由于工作需要自学的Spring，或许某些理解会出现偏差，烦请各位斧正！不慎感激！！）快速入门推荐阅读书籍（欢迎补充）：1、《JavaEE
Java通过Apache POI操作Excel IT__learning 数据分析 java apache excel
1、添加依赖org.apache.poipoi3.9org.apache.poipoi-ooxml3.9joda-timejoda-time2.10.12、读EXCELpublicstaticvoidread()throwsException{FileInputStreamstream=newFileInputStream("D:\\Test\\file.xlsx");//1.创建工作簿对象,并指
【MyBatis-Plus 注解配置】开发中常用注解整理与介绍 Yan.love mybatis 后端 java
不知道朋友们会不会在SpringBoot中集成MyBatis-Plus的时候，总是这个注解那个注解，都不知道哪些是MyBatis-Plus的了，搞得晕乎乎的，所以我整理了一份MyBatis-Plus开发中常用的注解，相信看完你就知道哪些注解是MyBatis-Plus提供的了，以后在开发中就能够更加清晰了1.@TableName作用：指定实体类对应的数据库表名。用法：@TableName("user
【MyBatis-Plus 进阶功能】开发中常用场景剖析 Yan.love mybatis 后端 java 数据库
MyBatis-Plus（MP）除了封装常见的CRUD操作，还提供了一些高级功能，进一步简化复杂场景下的开发工作。本文将逐一讲解逻辑删除、自动填充、多表关联查询的原理与使用方式，让你快速掌握这些技巧！一、逻辑删除逻辑删除是指在数据库中不直接删除记录，而是通过标记（如is_deleted字段）表示数据是否有效。1.原理与配置逻辑删除是指在数据库中不直接删除记录，而是通过标记（如is_deleted字
【MyBatis-Plus 插件】并发控制机制——乐观锁 Yan.love mybatis java 后端
乐观锁是一种非阻塞的并发控制机制，在多线程环境中确保数据一致性。MyBatis-Plus使用@Version注解和乐观锁插件轻松实现这一功能。在正式介绍乐观锁之前，我们先来聊一聊没有乐观锁时会出现的问题，以及它解决的痛点。1.没有乐观锁时的问题在多线程或高并发场景下，如果多个线程同时读取和修改同一条数据，就可能导致数据覆盖问题。问题场景：库存扣减假设一个商品的库存为10，两名用户A和B同时购买1个
【MyBatis-Plus 分页插件】深入分析和实战解析 Yan.love mybatis java 后端
分页是Web应用开发中的高频需求，而在MyBatis的生态中，MyBatis-Plus分页插件PaginationInnerInterceptor和MyBatis的PageHelper是两种常见的实现方案。本文将通过工作机制、使用方法和细节剖析，带你循序渐进地掌握这两种方式，并为你的项目选择提供指导。一、什么是分页？分页的核心目标是减少数据传输量和前端渲染压力。通过限制每次查询的结果数量，分页能够
英伟达系列显卡大解析B100、H200、L40S、A100 2301_78234743 java
家里有了变故。。。快手数分秋招一面面经我发现算法岗也不很难进啊(深度学习)算法想转数开…Java零基础校招学习路线突击版（吐血整理）等的花都谢了的华子最后给开了22k，武汉，应该是14a。不过在这几个月里我坚定了搞几年快钱回家和np朋友因骂了hr，boos被封了哈哈哈在央企想被开除需要做什么？2024小米分布式存储研发急招华为2012被毁意向我发现算法岗也不很难进啊(深度学习)在央企想被开除需要做
java24种设计模式目录,为大家整理最全的24种设计模式详解，必收藏高补 java24种设计模式目录
设计模式六大原则单一职责原则一个方法尽可能做一件事情，一般来说不应该让一个方法承担多个职责。单一职责原则的英文名称是SingleResponsibilityPrinciple，简称是SRP。单一职责原则的定义是：应该有且仅有一个原因引起类的变更。SRP的原话解释是：Thereshouldneverbemorethanonereasonforaclasstochange.单一职责原则提出了一个编写程
结构型模式之适配器模式：让不兼容的接口兼容菜就多练少说设计模式适配器模式
在软件开发中，经常会遇到这样一种情况：系统的不同部分需要进行交互，但由于接口不兼容，导致无法直接使用。这时，适配器模式（AdapterPattern）就能派上用场。适配器模式是设计模式中的结构型模式，它的目的是通过创建一个适配器类来“包装”一个不兼容的接口，使得两个接口能够兼容、协作。简单来说，适配器模式就是“转换接口”模式。本文将深入探讨适配器模式，讲解其概念、应用场景，并展示如何在Java中实
【JS】JS中的jQuery库简介及使用方法菜就多练少说 javascript javascript jquery 开发语言
jQuery简介及使用方法jQuery简介如何使用jQuery1导入jQuery库2编写自己的jQuery文件3jQuery语法3.1基础语法3.2文档就绪函数3.3选择器3.4事件绑定函数结语jQuery简介jQuery是一个流行的JavaScript库，用于简化JavaScript编程。它提供了许多便捷的方法来处理DOM操作、事件处理、动画效果等，使得JavaScript开发变得更加简单和高效
高性能缓存利器：Caffeine 在 Spring Boot 中的应用阿里小阿希 JAVA 缓存 spring boot spring
在现代应用程序中，缓存是提高数据检索速度、减少对数据库或其他数据源访问次数的重要手段。SpringCache提供了多种缓存实现方式，而在我们的SpringBoot项目中，我们选择了Caffeine作为默认的缓存库。Caffeine简介Caffeine是一个基于Java8的高性能、近乎最佳的缓存库。它提供了多种优化技术，如写入时复制（Copy-on-Write）和分段锁（SegmentedLocki
Android自动化测试工具海棠如醉 web技术自动化运维
细解自动化测试工具Airtest-CSDN博客以下是几种常见的Android应用自动化测试工具：Appium：支持多种编程语言，如Java、Python、Ruby、JavaScript等。可以用于Web应用程序和原生应用程序的自动化测试，并支持iOS和Android平台。Espresso：由Google开发的AndroidUI测试框架，可用于测试应用程序的用户界面和与用户的交互。Espresso支
SpringBoot整合MinIO实现文件的上传下载以及获取预览URL .晚安. spring boot 后端 java web
SpringBoot整合MinIO实现文件的上传下载以及获取预览URLJDK17SpringBoot3参考https://min.io/docs/minio/linux/developers/java/API.html?ref=docs-redirect#uploadObject源码https://gitee.com/Uncommen/easy-min-io引入依赖在pom.xml中添加主要的依赖
Java并发——ThreadLocal .晚安. java 开发语言
Java——ThreadLocal什么是ThreadLocal？ThreadLocal可以翻译为线程本地存储，是用来解决多线程间对共享资源的访问安全性的一种技术。当我们在面临多线程并发问题时，例如线程A创建了对于一个共享资源（static）的访问链接，此时当线程A正在访问该资源时，线程B也通过该链接开始对资源进行访问，而当线程A访问资源完毕后关闭了对于资源的访问链接，那么线程B就会出错。一种解决方
java不用缓存实现token续签_JWT实现登陆认证及Token自动续期 deep go
过去这段时间主要负责了项目中的用户管理模块，用户管理模块会涉及到加密及认证流程，加密已经在前面的文章中介绍了，可以阅读：https://juejin.cn/post/6916150628955717646今天就来讲讲认证功能的技术选型及实现。技术上没啥难度当然也没啥挑战，但是对一个原先没写过认证功能的菜鸡甜来说也是一种锻炼吧技术选型要实现认证功能，很容易就会想到JWT或者session，但是两者有
项目使用mybatis-plus分页插件和pageHelper分页插件引起失效问题！ JavinLu mybatis java springboot 个人开发深度学习
一、背景项目中以前的源码是使用pageHelper分页插件来实现。涉及到的sql代码还是要手写部分。而目前在Springboot项目中，使用的主流的方式就是一个基于mybatis-plus的.page()的分页，当然这种分页方式是适用于一些简单的查询和简单场景下。对于多表联查等场景，可能还是需要通过手写sql来实现复杂查询。这时候就可以使用pageHelper的分页插件。二、问题描述在同时使用my
计算机毕业设计Java河南省农村多元化养老服务管理系统设计与实现(源码+系统+mysql数据库+lw文档) 山逸网络数据库 java mysql
计算机毕业设计Java河南省农村多元化养老服务管理系统设计与实现(源码+系统+mysql数据库+lw文档)计算机毕业设计Java河南省农村多元化养老服务管理系统设计与实现(源码+系统+mysql数据库+lw文档)本源码技术栈：项目架构：B/S架构开发语言：Java语言开发软件：ideaeclipse前端技术：Layui、HTML、CSS、JS、JQuery等技术后端技术：JAVA运行环境：Win1
MyBatis-Plus接入和简单使用测试开发小白变怪兽服务端 mybatis
如何接入https://baomidou.com/getting-started/简单使用方法使用MyBatis-Plus时，大多数场景下不需要编写XML和SQL，因为它提供了强大的通用CRUD操作和条件构造器。但以下情况可能需要手动编写SQL：1.不需要写XML/SQL的场景(1)通用CRUD操作MyBatis-Plus的BaseMapper接口已经内置了通用的增删改查方法，例如：userMap
Spring Boot入门(15)：一键生成，轻松搭建你的Spring Boot+MyBatis-Plus项目！喵手 Springboot spring boot mybatis 后端
1.前言SpringBoot是一种全新的基于Spring框架的用于快速开发新一代应用程序的框架。它能够使开发者通过简单的配置快速搭建项目，并能够提供常见的功能模块，如数据库访问、事务管理、Web开发和安全管理等。而MyBatis-Plus是一个功能强大的MyBatis增强工具，它基于MyBatis本身进行了扩展，可以大幅度减少开发工作量，提高开发效率。本文将介绍如何使用MyBatis-Plus的A
MybatisPlus查询结果返回值为null 雾林小妖 Java开发常见BUG解决方案 java spring mybatis springboot
1、问题描述返回值为null，程序不报错，但是条数好像是正确的。我出现问题的代码如下：1、自定义类StudentMapper继承了BaseMapper接口publicinterfaceStudentMapperextendsBaseMapper{}2、使用StudentMapper中的selectList方法查询数据的时候，打印结果的时候返回值都会null，但是条数没有问题，也就是有几条数据就返回
模拟类似 DeepSeek 的对话二川bro 前端智能AI 前端人工智能
以下是一个完整的JavaScript数据流式获取实现方案，模拟类似DeepSeek的对话式逐段返回效果。包含前端实现、后端模拟和详细注释：流式对话演示#output{border:1pxsolid#ccc;padding:20px;margin:20px;min-height:200px;font-family:monospace;white-space:pre-wrap;}.loading{di
Spring bean factory 门里有什么
EJB：JAVA中的商业应用组件技术（EnterpriseJavaBean）控制反转/反向控制inversionofcontrol依赖注入：dependencyinjection所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的不再是引用它的对象，而是spring。对于某个具体的对象而言，以前是它控制其他对象，现在是所有对象都被spring控制，所以这叫控制反转。IoC的一个重
MyBatis-Plus 分页查询接口返回值问题剖析字节熊猫 mybatis tomcat java mybatis-plus
在使用MyBatis-Plus进行分页查询时，很多开发者会遇到一个常见的问题：当分页查询接口返回值定义为Page时，执行查询会抛出异常；而将返回值修改为IPage时，分页查询却能正常工作。本文将从MyBatis-Plus的分页机制入手，详细分析这一问题的根源，并提供相应的解决方案。一、问题现象描述在MyBatis-Plus中，我们通常会定义一个分页查询接口，如下：PageselectComment
计算机毕业设计springboot基于BS的驾校在线学习考试系统43i2x9【附源码+数据库+部署+LW】゛花昔计算机毕设源码程序课程设计 spring boot 学习
本项目包含程序+源码+数据库+LW+调试部署环境，文末可获取一份本项目的java源码和数据库参考。系统的选题背景和意义选题背景：随着社会的发展和交通工具的普及，驾驶证成为了越来越多人的需求。然而，传统的驾校学习考试方式存在一些问题，如时间和空间限制、学习资源不足等。为了解决这些问题，基于BS（Browser/Server）架构的驾校在线学习考试系统应运而生。该系统利用互联网浏览器作为客户端，通过服
深入理解Java集合框架：构建高效、灵活的数据管理方案 love729234ming java 开发语言
深入理解Java集合框架：构建高效、灵活的数据管理方案引言Java集合框架（JavaCollectionsFramework,JCF）是Java语言提供的一套用于表示和操作集合的统一架构。它包含了一系列的接口和类，用于存储和操作对象集合，如列表（List）、集合（Set）、映射（Map）和队列（Queue）等。集合框架的设计初衷是为了提供一套灵活、可重用且类型安全的集合数据结构，帮助开发者以统一和
Java常用集合与映射的线程安全问题深度解析扣得A艾 java 安全开发语言
Java常用集合与映射的线程安全问题深度解析一、线程安全基础认知在并发编程环境下，当多个线程同时操作同一集合对象时，若未采取同步措施，可能导致以下典型问题：数据竞争：多个线程同时修改数据导致结果不可预测状态不一致：部分线程看到集合的中间状态内存可见性：线程本地缓存与主内存数据不同步死循环风险：特定操作引发无限循环（如JDK7的HashMap扩容）二、典型非线程安全集合问题分析1.ArrayList
Java网络编程：TCP的socket编程想作会飞的鱼 Java网络编程网络编程 socket java tcp
一、Java中的网络编程协议相当于相互通信的程序间达成的一种约定，它规定了分组报文的结构、交换方式、包含的意义以及怎样对报文所包含的信息进行解析，TCP/IP协议族有IP协议、TCP协议和UDP协议。现在TCP/IP协议族中的主要socket类型为流套接字（使用TCP协议）和数据报套接字（使用UDP协议）。TCP协议提供面向连接的服务，通过它建立的是可靠地连接。Java为TCP协议提供了两个类：S
JAVA简单实现国密双向认证 [email protected] JAVA 安全相关 java 开发语言国密
要实现国密双向认证的数据发送，需要使用支持国密算法的Java库，并且确保HTTP客户端能够处理SSL/TLS连接时的客户端证书验证。在这个例子中，使用Java标准库结合BouncyCastle作为提供国密算法的支持。下面是一个简化的示例，展示如何使用Java实现国密双向认证的数据发送。请注意，实际开发中可能需要更多的错误处理和配置细节。首先，确保你已经添加了BouncyCastle作为安全提供者，
前端流式输出实现详解：从原理到实践代码剑客588 前端
前端流式输出实现详解：从原理到实践前言一、流式输出核心原理1.1什么是流式输出？1.2技术优势对比1.3关键技术支撑二、原生JavaScript实现方案2.1使用FetchAPI流式处理关键点解析：2.2处理SSE（Server-SentEvents）三、主流框架实现示例3.1React实现方案3.2Vue实现方案四、高级优化策略4.1性能优化4.2用户体验增强4.3安全注意事项五、实际应用案例5
算法单链的创建与删除换个号韩国红果果 c 算法
先创建结构体 struct student { int data; //int tag;//标记这是第几个 struct student *next; }; // addone 用于将一个数插入已从小到大排好序的链中 struct student *addone(struct student *h,int x){ if(h==NULL) //??????
《大型网站系统与Java中间件实践》第2章读后感白糖_ java中间件
断断续续花了两天时间试读了《大型网站系统与Java中间件实践》的第2章，这章总述了从一个小型单机构建的网站发展到大型网站的演化过程---整个过程会遇到很多困难，但每一个屏障都会有解决方案，最终就是依靠这些个解决方案汇聚到一起组成了一个健壮稳定高效的大型系统。看完整章内容，
zeus持久层spring事务单元测试 deng520159 java DAO spring jdbc
今天把zeus事务单元测试放出来,让大家指出他的毛病, 1.ZeusTransactionTest.java 单元测试 package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Test; import
Rss 订阅开发周凡杨 html xml 订阅 rss 规范
RSS是 Really Simple Syndication的缩写（对rss2.0而言，是这三个词的缩写，对rss1.0而言则是RDF Site Summary的缩写，1.0与2.0走的是两个体系）。 RSS
分页查询实现 g21121 分页查询
在查询列表时我们常常会用到分页，分页的好处就是减少数据交换，每次查询一定数量减少数据库压力等等。按实现形式分前台分页和服务器分页：前台分页就是一次查询出所有记录，在页面中用js进行虚拟分页，这种形式在数据量较小时优势比较明显，一次加载就不必再访问服务器了，但当数据量较大时会对页面造成压力，传输速度也会大幅下降。服务器分页就是每次请求相同数量记录，按一定规则排序，每次取一定序号直接的数据
spring jms异步消息处理 510888780 jms
spring JMS对于异步消息处理基本上只需配置下就能进行高效的处理。其核心就是消息侦听器容器，常用的类就是DefaultMessageListenerContainer。该容器可配置侦听器的并发数量，以及配合MessageListenerAdapter使用消息驱动POJO进行消息处理。且消息驱动POJO是放入TaskExecutor中进行处理，进一步提高性能，减少侦听器的阻塞。具体配置如下：
highCharts柱状图布衣凌宇 hightCharts 柱图
第一步：导入 exporting.js,grid.js,highcharts.js;第二步：写controller @Controller@RequestMapping(value="${adminPath}/statistick")public class StatistickController { private UserServi
我的spring学习笔记2-IoC（反向控制依赖注入） aijuans spring mvc Spring 教程 spring3 教程 Spring 入门
IoC（反向控制依赖注入）这是Spring提出来了，这也是Spring一大特色。这里我不用多说，我们看Spring教程就可以了解。当然我们不用Spring也可以用IoC，下面我将介绍不用Spring的IoC。 IoC不是框架，她是java的技术，如今大多数轻量级的容器都会用到IoC技术。这里我就用一个例子来说明：如：程序中有 Mysql.calss 、Oracle.class 、SqlSe
TLS java简单实现 antlove java ssl keystore tls secure
1. SSLServer.java package ssl; import java.io.FileInputStream; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; import java.security.KeyStore; import
Zip解压压缩文件百合不是茶 Zip格式解压 Zip流的使用文件解压
ZIP文件的解压缩实质上就是从输入流中读取数据。Java.util.zip包提供了类ZipInputStream来读取ZIP文件,下面的代码段创建了一个输入流来读取ZIP格式的文件; ZipInputStream in = new ZipInputStream(new FileInputStream(zipFileName)); &n
underscore.js 学习（一） bijian1013 JavaScript underscore
工作中需要用到underscore.js，发现这是一个包括了很多基本功能函数的js库，里面有很多实用的函数。而且它没有扩展 javascript的原生对象。主要涉及对Collection、Object、Array、Function的操作。学
java jvm常用命令工具——jstatd命令(Java Statistics Monitoring Daemon) bijian1013 java jvm jstatd
1.介绍 jstatd是一个基于RMI（Remove Method Invocation）的服务程序，它用于监控基于HotSpot的JVM中资源的创建及销毁，并且提供了一个远程接口允许远程的监控工具连接到本地的JVM执行命令。 jstatd是基于RMI的，所以在运行jstatd的服务
【Spring框架三】Spring常用注解之Transactional bit1129 transactional
Spring可以通过注解@Transactional来为业务逻辑层的方法(调用DAO完成持久化动作)添加事务能力，如下是@Transactional注解的定义： /* * Copyright 2002-2010 the original author or authors. * * Licensed under the Apache License, Version
我(程序员)的前进方向 bitray 程序员
作为一个普通的程序员,我一直游走在java语言中,java也确实让我有了很多的体会.不过随着学习的深入,java语言的新技术产生的越来越多,从最初期的javase,我逐渐开始转变到ssh,ssi,这种主流的码农,.过了几天为了解决新问题,webservice的大旗也被我祭出来了,又过了些日子jms架构的activemq也开始必须学习了.再后来开始了一系列技术学习,osgi,restful.....
nginx lua开发经验总结 ronin47
使用nginx lua已经两三个月了，项目接开发完毕了，这几天准备上线并且跟高德地图对接。回顾下来lua在项目中占得必中还是比较大的，跟PHP的占比差不多持平了，因此在开发中遇到一些问题备忘一下 1：content_by_lua中代码容量有限制，一般不要写太多代码，正常编写代码一般在100行左右（具体容量没有细心测哈哈，在4kb左右），如果超出了则重启nginx的时候会报 too long pa
java-66-用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。颠倒之后的栈为{5,4,3,2,1}，5处在栈顶 bylijinnan java
import java.util.Stack; public class ReverseStackRecursive { /** * Q 66.颠倒栈。 * 题目：用递归颠倒一个栈。例如输入栈{1,2,3,4,5}，1在栈顶。 * 颠倒之后的栈为{5,4,3,2,1}，5处在栈顶。 *1. Pop the top element *2. Revers
正确理解Linux内存占用过高的问题 cfyme linux
Linux开机后，使用top命令查看，4G物理内存发现已使用的多大3.2G，占用率高达80%以上： Mem: 3889836k total, 3341868k used, 547968k free, 286044k buffers Swap: 6127608k total,&nb
[JWFD开源工作流]当前流程引擎设计的一个急需解决的问题 comsci 工作流
当我们的流程引擎进入IRC阶段的时候，当循环反馈模型出现之后，每次循环都会导致一大堆节点内存数据残留在系统内存中，循环的次数越多，这些残留数据将导致系统内存溢出，并使得引擎崩溃。。。。。。而解决办法就是利用汇编语言或者其它系统编程语言，在引擎运行时，把这些残留数据清除掉。
自定义类的equals函数 dai_lm equals
仅作笔记使用 public class VectorQueue { private final Vector<VectorItem> queue; private class VectorItem { private final Object item; private final int quantity; public VectorI
Linux下安装R语言 datageek R语言 linux
命令如下：sudo gedit /etc/apt/sources.list1、deb http://mirrors.ustc.edu.cn/CRAN/bin/linux/ubuntu/ precise/ 2、deb http://dk.archive.ubuntu.com/ubuntu hardy universesudo apt-key adv --keyserver ke
如何修改mysql 并发数(连接数)最大值 dcj3sjt126com mysql
MySQL的连接数最大值跟MySQL没关系，主要看系统和业务逻辑了方法一：进入MYSQL安装目录打开MYSQL配置文件 my.ini 或 my.cnf查找 max_connections=100 修改为 max_connections=1000 服务里重起MYSQL即可　　方法二：MySQL的最大连接数默认是100客户端登录：mysql -uusername -ppass
单一功能原则 dcj3sjt126com 面向对象的程序设计软件设计编程原则
单一功能原则[ 编辑] SOLID 原则单一功能原则开闭原则 Liskov代换原则接口隔离原则依赖反转原则查论编在面向对象编程领域中，单一功能原则（Single responsibility principle）规定每个类都应该有
POJO、VO和JavaBean区别和联系 fanmingxing VO POJO javabean
POJO和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Plain Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比POJO复杂很多，JavaBean是一种组件技术，就好像你做了一个扳子，而这个扳子会在很多地方被
SpringSecurity3.X--LDAP：AD配置 hanqunfeng SpringSecurity
前面介绍过基于本地数据库验证的方式，参考http://hanqunfeng.iteye.com/blog/1155226，这里说一下如何修改为使用AD进行身份验证【只对用户名和密码进行验证，权限依旧存储在本地数据库中】。将配置文件中的如下部分删除：
mac mysql 修改密码 IXHONG mysql
$ sudo /usr/local/mysql/bin/mysqld_safe –user=root & //启动MySQL(也可以通过偏好设置面板来启动)$ sudo /usr/local/mysql/bin/mysqladmin -uroot password yourpassword //设置MySQL密码（注意，这是第一次MySQL密码为空的时候的设置命令，如果是修改密码，还需在-
设计模式--抽象工厂模式 kerryg 设计模式
抽象工厂模式：工厂模式有一个问题就是，类的创建依赖于工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则。我们采用抽象工厂模式，创建多个工厂类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。总结：这个模式的好处就是，如果想增加一个功能，就需要做一个实现类，
评"高中女生军训期跳楼” nannan408
首先，先抛出我的观点，各位看官少点砖头。那就是，中国的差异化教育必须做起来。孔圣人有云：有教无类。不同类型的人，都应该有对应的教育方法。目前中国的一体化教育，不知道已经扼杀了多少创造性人才。我们出不了爱迪生，出不了爱因斯坦，很大原因，是我们的培养思路错了，我们是第一要“顺从”。如果不顺从，我们的学校，就会用各种方法，罚站，罚写作业，各种罚。军
scala如何读取和写入文件内容？ qindongliang1922 java jvm scala
直接看如下代码： package file import java.io.RandomAccessFile import java.nio.charset.Charset import scala.io.Source import scala.reflect.io.{File, Path} /** * Created by qindongliang on 2015/
C语言算法之百元买百鸡 qiufeihu c 算法
中国古代数学家张丘建在他的《算经》中提出了一个著名的“百钱买百鸡问题”，鸡翁一，值钱五，鸡母一，值钱三，鸡雏三，值钱一，百钱买百鸡，问翁，母，雏各几何？代码如下： #include <stdio.h> int main() { int cock,hen,chick; /*定义变量为基本整型*/ for(coc
Hadoop集群安全性：Hadoop中Namenode单点故障的解决方案及详细介绍AvatarNode wyz2009107220 NameNode
正如大家所知，NameNode在Hadoop系统中存在单点故障问题，这个对于标榜高可用性的Hadoop来说一直是个软肋。本文讨论一下为了解决这个问题而存在的几个solution。 1. Secondary NameNode 原理：Secondary NN会定期的从NN中读取editlog，与自己存储的Image进行合并形成新的metadata image 优点：Hadoop较早的版本都自带，