mybatis详细总结

缺乏、安全感 2022-02-19 07:45 158阅读 0赞

[mybatis教程][mybatis]  
[mybatis驱动参数问题][mybatis 1]

### mybatis详细总结： ###

*  一. 开发第一个MyBatis程序
 *   *  1. 获取MyBatis驱动包
     *   *  1). 下载过程
         *  2). 导入jar包
     *  2. 创建person类
     *  3. 创建表格person，还有数据
     *  4. 在person同级目录中创建personMapper.xml
     *  5. 在src下创建conf.xml
     *  6. 创建测试类 TestMyBatis
 *  二. mybatis提示信息配置
 *   *  1. 联网状态，xml文件中有提示信息：alt + /;
     *  2. 不联网需要导入
     *   *  1）. ctrl+ 点击链接，下载mybatis-3-config.dtd.
         *  2). 进入配置 window => preferences
         *  3). 将下载的文件配置进入
         *  4). 此时在不联网的时候也会有提示
 *  三.使用MyBatis实现CRUD
 *   *  1. conf.xml
     *  2. studentMapper.xml
     *  3. test.java
 *  四. 使用Mapper动态代理优化程序(重要)
 *   *  1. studentMapper.xml
     *  2. StudentMapper 接口，和studentMapper.xml内容一一对应
     *  3. 测试类
 *  五. 配置文件
 *   *  1. properties属性，将数据库信息独立出来
     *   *  1）新建db.properties
         *  2） 修改conf.xml
     *  2. settings全局参数配置
     *  2. 为实体类自定义别名
     *   *  1. 单个别名定义
         *  1. 多个别名定义
     *  3. typeHandlers类型处理器
     *   *  1). 自定义类型处理器BooleanAndIntConverter类
         *  2)配置自定义类型处理器到conf.xml
         *  3)使用自定义类型处理器
         *   *  (1)Student.java
             *  (2)自定义SQL映射文件：studentMapper.xml
         *  4）总结
     *  4. 输入参数 （重点）
     *   *  1） 输入参数为简单类型(8个基本类型+String)
         *  2）输入参数为实体类的对象
         *  3）输入参数为嵌套对象
         *  4）输入参数为HashMap对象
     *  5. 输出参数 （重点）
     *   *  1）输出参数为简单类型或实体对象类型
         *  2）输出HashMap类型
         *  3）使用resultMap指定输出类型及映射关系
     *  6. 动态SQL
     *   *  1）标签
         *   *  (1) \`\`标签
             *  (2) \`\`标签
             *  (3) \`\`标签
             *   *  (3).1 将集合或数组以对象属性的形式传入
                 *  (3).2 传入List类型的集合
                 *  (3).3 传入简单类型的数组
                 *  (3).4 传入对象数组
         *  2）SQL片段
 *  六. 关联查询（重点）
 *   *  1. 一对一查询
     *   *  1.1 使用扩展类实现一对一查询
         *  1.2 使用resultMap实现一对一查询 (常用)
     *  2. 一对多查询
     *  3. 多对一查询与多对多查询
     *  4. 延迟加载
     *   *  1. 日志输出
         *   *  (1)加入log4j驱动包
             *  (2)指定日志输出
             *  (3)配置日志输出文件
         *  2. 延迟加载详解
         *   *  (1)一对一延迟加载
             *  (2)一对多延迟加载
 *  七. 查询缓存
 *   *  1. 一级缓存
     *  2. 二级缓存
     *   *  1）. 使用二级缓存
         *   *  (1)开启二级缓存
             *  (2)实现序列化
             *  (3)测试二级缓存
         *  2）. 禁用二级缓存
         *  3）. 清理二级缓存
         *   *  1.清理二级缓存
             *  2.不清理二级缓存
         *  2）. 整合第三方提供的二级缓存
         *   *  (1)导入Ehcache相关JAR文件
             *  (2)创建并编写Ehcache配置文件
             *  (3) 开启Ehcache
             *  (4) 测试Ehcache
 *  八. 逆向工程
 *   *  1. 准备工作
     *  2. 下载工具
     *  3. 创建并编写配置文件
     *  4. 编写生成代码

# 一. 开发第一个MyBatis程序 #

## 1. 获取MyBatis驱动包 ##

可以在官网[http://blog.mybatis.org/][http_blog.mybatis.org]或[https://github.com/mybatis/mybatis-3/releases][https_github.com_mybatis_mybatis-3_releases]中下载MyBatis的资源文件mybatis-3.x.x.zip

### 1). 下载过程 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 1]

### 2). 导入jar包 ###

![在这里插入图片描述][20190416085651469.png]

## 2. 创建person类 ##

package org.wajpzywj.entity;
    
    public class Person { 
    	
    	private int id;
    	private String name;
    	private int age;
    	public Person() { 
    		super();
    	}
    	public Person(int id, String name, int age) { 
    		super();
    		this.id = id;
    		this.name = name;
    		this.age = age;
    	}
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		this.name = name;
    	}
    	public int getAge() { 
    		return age;
    	}
    	public void setAge(int age) { 
    		this.age = age;
    	}
    	@Override
    	public String toString() { 
    		return "Person [id=" + id + ", name=" + name + ", age=" + age + "]";
    	}
    	
    
    }

## 3. 创建表格person，还有数据 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][20190416084930436.png]

## 4. 在person同级目录中创建personMapper.xml ##

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="org.wajpzywj.entity.personMapper">
    	<select id="queryPersonById" resultType="org.wajpzywj.entity.Person" parameterType="int">
    		select * from person where id=#{id}
    	</select>
    </mapper>

## 5. 在src下创建conf.xml ##

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    	<typeAliases>
    		<package name="org.wajpzywj.entity" />
    	</typeAliases>
    	<environments default="development">
    		<environment id="development">
    			<transactionManager type="JDBC"/>
    			<dataSource type="POOLED">
    				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
    				<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false"/>
    				<property name="username" value="root"/>
    				<property name="password" value="root"/>
    			</dataSource>
    		</environment>
    	</environments>
    	 
    	<mappers>
    		<mapper resource="org/wajpzywj/entity/personMapper.xml" />
    	</mappers>
    	
    </configuration>

## 6. 创建测试类 TestMyBatis ##

package org.wajpzywj.entity;
    
    import java.io.IOException;
    import java.io.Reader;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    public class TestMyBatis { 
    	public static void main(String[] args) throws IOException { 
    		// 加载MyBatis配置文件(为了访问数据库)
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		 // 创建sqlSession 的工厂
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		// 创建能够执行SQL映射文件中sql语句的sqlSession对象
    		SqlSession session = sessionFactory.openSession();
    		// 指定sql语句对应的标识字符串：namespace+id
    		String statement = "org.wajpzywj.entity.personMapper.queryPersonById";
    		// 执行查询，返回一个id为2的person对象
    		Person person = session.selectOne(statement, 2);
    		System.out.println(person);
    		session.close();
    	}
    }

流程：

> 1.  MyBatis应用程序根据XML配置文件（conf.xml）创建SqlSessionFactory，
> 2.  再由SqlSessionFactory创建一个SqlSession对象。
> 3.  SqlSession对象包含了执行SQL所需要的所有方法，可以直接运行映射的SQL语句，完成对数据的增删改查等操作。  
>     其中映射的SQL语句存放在一个SQL映射文件中（如personMapper.xml），应用程序可以通过SQL映射文件中的namespace+id找到对应的SQL语句。

# 二. mybatis提示信息配置 #

## 1. 联网状态，xml文件中有提示信息：alt + /; ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 3]

## 2. 不联网需要导入 ##

### 1）. ctrl+ 点击链接，下载mybatis-3-config.dtd. ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 4]

### 2). 进入配置 window => preferences ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 5]

### 3). 将下载的文件配置进入 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 6]

### 4). 此时在不联网的时候也会有提示 ###

# 三.使用MyBatis实现CRUD #

## 1. conf.xml ##

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
    	<typeAliases>
    		<package name="org.wajpzywj.entity" />
    	</typeAliases>
    	<environments default="development">
    		<environment id="development">
    		
    			
    			<transactionManager type="JDBC"/>
    			
    			
    			<dataSource type="POOLED">
    				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
    				<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false"/>
    				<property name="username" value="root"/>
    				<property name="password" value="root"/>
    			</dataSource>
    		</environment>
    	</environments>
    	<mappers>
    		<mapper resource="org/wajpzywj/entity/studentMapper.xml" />
    	</mappers>
    	
    </configuration>

## 2. studentMapper.xml ##

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    
    <mapper namespace="org.wajpzywj.entity.studentMapper">
    	
    	
    	 <select id="queryStudentByNo" parameterType="int" resultType="org.wajpzywj.entity.Student">
    	  	select * from student where stuNo=#{stuNo}
    	 </select>
    	 
    	 <insert id="addStudent" parameterType="org.wajpzywj.entity.Student">
    	 	insert into student(stuNo, stuName,stuAge,graName) values(#{stuNo},#{stuName},#{stuAge},#{graName})
    	 </insert>
    	 
    	 <delete id="deleteStudentByStuNo" parameterType="int">
    	 	delete from student where stuNo=#{stuNo}
    	 </delete>
    	 
    	 <update id="updateStudentByStuNo" parameterType="org.wajpzywj.entity.Student">
    	 	update student set stuName=#{stuName}, stuAge=#{stuAge},graName=#{graName} where stuNo=#{stuNo}
    	 </update>
    	 
    	 <select id="queryAllStudents" resultType="org.wajpzywj.entity.Student">
    	 	select * from student
    	 </select> 
    </mapper>

## 3. test.java ##

package org.wajpzywj.test;
    
    import java.io.IOException;
    import java.io.Reader;
    import java.util.List;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.wajpzywj.entity.Student;
    
    public class Test { 
    	public static void queryStudentByNo() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		String statement = "org.wajpzywj.entity.studentMapper.queryStudentByNo";
    		Student student = session.selectOne(statement,1);
    		System.out.println(student);
    		session.close();
    	}
    	
    	public static void queryAllStudent() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		String statement = "org.wajpzywj.entity.studentMapper.queryAllStudents";
    		List<Student> students = session.selectList(statement);
    		System.out.println(students);
    		session.close();
    	}
    	
    	public static void addStudent() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		String statement = "org.wajpzywj.entity.studentMapper.addStudent";
    		Student student = new Student(3,"zhangsan",45, "xiaohognshu");
    		System.out.println(student);
    		int count = session.insert(statement,student);
    		session.commit();
    		System.out.println("增加"+count+"个数据");
    		session.close();
    	}
    	
    	public static void updateStudentByStuNo() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		String statement = "org.wajpzywj.entity.studentMapper.updateStudentByStuNo";
    		Student student = new Student(3,"zha",5, "lisi");
    		System.out.println(student);
    		int count = session.update(statement,student);
    		session.commit();
    		System.out.println("修改"+count+"个数据");
    		session.close();
    	}
    	
    	public static void deleteStudentByStuNo() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		String statement = "org.wajpzywj.entity.studentMapper.deleteStudentByStuNo";
    		int count = session.delete(statement,1);
    		session.commit();
    		System.out.println("删除"+count+"个数据");
    		session.close();
    	}
    	
    	public static void main(String[] args) throws IOException { 
    // queryStudentByNo();
    // queryAllStudent();
    // addStudent();
    // updateStudentByStuNo();
    		deleteStudentByStuNo();
    	}
    }

# 四. 使用Mapper动态代理优化程序(重要) #

约定的目标：省略掉statement，即根据约定 直接可以定位出SQL语句

## 1. studentMapper.xml ##

<?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    
    
    <mapper namespace="org.wajpzywj.mapper.StudentMapper">
    
    	<select id="queryStudentByNo" parameterType="int" resultType="org.wajpzywj.entity.Student">
    	  	select * from student where stuNo=#{stuNo}
    	 </select>
    	 
    	 <insert id="addStudent" parameterType="org.wajpzywj.entity.Student">
    	 	insert into student(stuNo, stuName,stuAge,graName) values(#{stuNo},#{stuName},#{stuAge},#{graName})
    	 </insert>
    	 
    	 <delete id="deleteStudentByStuNo" parameterType="int">
    	 	delete from student where stuNo=#{stuNo}
    	 </delete>
    	 
    	 <update id="updateStudentByStuNo" parameterType="org.wajpzywj.entity.Student">
    	 	update student set stuName=#{stuName}, stuAge=#{stuAge},graName=#{graName} where stuNo=#{stuNo}
    	 </update>
    	 
    	 <select id="queryAllStudents" resultType="org.wajpzywj.entity.Student">
    	 	select * from student
    	 </select> 
    </mapper>

## 2. StudentMapper 接口，和studentMapper.xml内容一一对应 ##

package org.wajpzywj.mapper;
    
    import java.util.List;
    
    import org.wajpzywj.entity.Student;
    
    //操作Mybatis的接口
    public interface StudentMapper { 
    	/** * 1. 方法名和mapper.xml文件中标签的id值相同 * 2. 方法的输入参数和mapper.xml文件中的标签paramterType类型一致 * 3. 方法的返回值和mapper.xml文件中的标签resultType类型一致 */
    	Student queryStudentByNo(int stuNO);
    	
    	int addStudent(Student student);
    	
    	int deleteStudentByStuNo(int stuNO);
    	
    	int updateStudentByStuNo(Student student);
    	
    	List<Student> queryAllStudents();
    
    }

## 3. 测试类 ##

package org.wajpzywj.test;
    
    import java.io.IOException;
    import java.io.Reader;
    import java.util.List;
    
    import org.apache.ibatis.io.Resources;
    import org.apache.ibatis.session.SqlSession;
    import org.apache.ibatis.session.SqlSessionFactory;
    import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    import org.wajpzywj.entity.Student;
    import org.wajpzywj.mapper.StudentMapper;
    
    public class Test { 
    	public static void queryStudentByNo() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		// 传入StudentMapper接口，返回该接口的mapper代理对象studentMapper
    		StudentMapper studentMapper = session.getMapper(StudentMapper.class);
    		// 通过mapper代理对象studentMapper，来调用IStudentMapper接口中的方法
    		Student student = studentMapper.queryStudentByNo(2);
    		System.out.println(student);
    		session.close();
    	}
    	
    	public static void queryAllStudent() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		StudentMapper studentMapper = session.getMapper(StudentMapper.class);
    		List<Student> students = studentMapper.queryAllStudents();
    		System.out.println(students);
    		session.close();
    	}
    	
    	public static void addStudent() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		StudentMapper studentMapper = session.getMapper(StudentMapper.class);
    		Student student = new Student(1,"zhangsan",45, "xiaohognshu");
    		int count = studentMapper.addStudent(student);
    		System.out.println(student);
    		session.commit();
    		System.out.println("增加"+count+"个数据");
    		session.close();
    	}
    	
    	public static void updateStudentByStuNo() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		StudentMapper studentMapper = session.getMapper(StudentMapper.class);
    		Student student = new Student(3,"zhasdf",54, "li");
    		int count = studentMapper.updateStudentByStuNo(student);
    		System.out.println(student);
    		session.commit();
    		System.out.println("修改"+count+"个数据");
    		session.close();
    	}
    	
    	public static void deleteStudentByStuNo() throws IOException { 
    		Reader reader = Resources.getResourceAsReader("conf.xml");
    		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(reader);
    		SqlSession session = sessionFactory.openSession();
    		StudentMapper studentMapper = session.getMapper(StudentMapper.class);
    		int count = studentMapper.deleteStudentByStuNo(2);
    		session.commit();
    		System.out.println("删除"+count+"个数据");
    		session.close();
    	}
    	
    	public static void main(String[] args) throws IOException { 
    // queryStudentByNo();
    // queryAllStudent();
    // addStudent();
    // updateStudentByStuNo();
    		deleteStudentByStuNo();
    	}
    	
    
    }

# 五. 配置文件 #

## 1. properties属性，将数据库信息独立出来 ##

### 1）新建db.properties ###

url参数连接用 &

driver=com.mysql.cj.jdbc.Driver
    url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
    username=root
    password=root

### 2） 修改conf.xml ###

…
    <configuration>
        
     <properties resource="db.properties"/>
     <environments default="development">
      <environment id="development">
       <transactionManager type="JDBC" />
       
       <dataSource type="POOLED">
                     
        <property name="driver" value="${driver}" />
        <property name="url" value="${url}" />
        <property name="username" value="${username}" />
        <property name="password" value="${password}" />
       </dataSource>
      </environment>
     </environments>
     …
    </configuration>

## 2. settings全局参数配置 ##

> 标签下有一个子标签，可以用来设置mybatis框架的运行参数，比如设置二级缓存、延迟加载等。修改这些配置，会影响到MyBatis整体的运行行为，因此需要谨慎操作。常见的配置参数介绍如下表，

参数类型的意义，参考：[https://lanqiao.coding.me/mybatis框架/MyBatis-lesson13][https_lanqiao.coding.me_mybatis_MyBatis-lesson13]  
例子：conf.xml

…
    <configuration>
     <properties resource="db.properties"/>
     <settings>
      <setting name="cacheEnabled" value="true"/>
      <setting name="defaultStatementTimeout" value="25"/>
      <setting name="mapUnderscoreToCamelCase" value="false"/>
      <setting name="localCacheScope" value="SESSION"/>
      <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
             …
     </settings>
     …
    </configuration>

## 2. 为实体类自定义别名 ##

别名不区分大小写

### 1. 单个别名定义 ###

### 1. 多个别名定义 ###

## 3. typeHandlers类型处理器 ##

### 1). 自定义类型处理器BooleanAndIntConverter类 ###

使用MyBatis开发自定义类型处理器，需要实现TypeHandler接口（或继承BaseTypeHandler抽象类）。  
BaseTypeHandler底层实现了TypeHandler接口，并对接口中的方法做了简单处理以方便我们使用，所以我们可以直接继承BaseTypeHandler抽象类

package org.wajpzywj.converter;
    
    import java.sql.CallableStatement;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    import org.apache.ibatis.type.BaseTypeHandler;
    import org.apache.ibatis.type.JdbcType;
    
    public class BooleanAndIntConverter extends BaseTypeHandler<Boolean>{ 
    	 /** * java类型(booean)-->JDBC类型(NUMBER) * * @param ps: * 当前的PreparedStatement对象 * @param i * :当前参数的位置 * @param parameter: * 当前参数值 */
    	@Override
    	public void setNonNullParameter(PreparedStatement ps, int i, Boolean parameter, JdbcType jdbcType)
    			throws SQLException { 
    		/* * 如果Java类型的parameter==true，则在数据库中存储jdbc类型的数字1； * 如果Java类型的parameter==false，则在数据库中存储jdbc类型的数字0； */
    		if(parameter) { 
    			ps.setInt(i, 1);
    		}else { 
    			ps.setInt(i, 0);
    		}
    	}
    	/** * JDBC类型(NUMBER)-->java类型(booean) */
    	@Override
    	public Boolean getNullableResult(ResultSet rs, String columnName) throws SQLException { 
    		/* * 通过字段名获取值 */
    		int num = rs.getInt(columnName);
    		return num==1?true:false;
    	}
    	/** * JDBC类型(NUMBER)-->java类型(booean) */
    	@Override
    	public Boolean getNullableResult(ResultSet rs, int columnIndex) throws SQLException { 
    		 /* * 通过字段的索引获取值 */
    		int num = rs.getInt(columnIndex);
    		return num==1?true:false;
    	}
    	/** * JDBC类型(NUMBER)-->java类型(booean) */
    	@Override
    	public Boolean getNullableResult(CallableStatement cs, int columnIndex) throws SQLException { 
    		/* * 通过调用存储过程获取值 */
    		int num = cs.getInt(columnIndex);
    		return num==1?true:false;
    	}
    }

### 2)配置自定义类型处理器到conf.xml ###

### 3)使用自定义类型处理器 ###

#### (1)Student.java ####

// 学号
    private int stuNo;
    // 姓名
    private String stuName;
    // 年龄
    private int stuAge;
    // 年级名称
    private String graName;
    // 性别 true男， false 女
    private Boolean stuSex;

#### (2)自定义SQL映射文件：studentMapper.xml ####

<select id="queryStudentByNo" parameterType="int" resultMap="queryStudentByNoResult">
      	select * from student where stuNo=#{stuNo}
     </select>
     
     <resultMap id="queryStudentByNoResult" type="org.wajpzywj.entity.Student">  
        <id property="stuNo" column="id"/>
     	<result property="stuName" column="stuName"/>
     	<result property="stuAge" column="stuAge"/>
     	<result property="graName" column="graName"/>
    	<result property="stuSex" column="stuSex" javaType="java.lang.Boolean" jdbcType="INTEGER"/>  
    </resultMap>

### 4）总结 ###

1. 如果类中属性类型和表中的字段类型能够合理识别(String-varchar)，则可以使用resultType，否则(boolean-number)使用resultMap  
2. 如果类中属性名 和表中的字段名能够合理识别(stuNo-stuno)，则可以使用resultType，否则(id-stuno)使用resultMap

## 4. 输入参数 （重点） ##

### 1） 输入参数为简单类型(8个基本类型+String) ###

使用： **\#\{任意值\} 或者 $\{value\},**  
注意： $\{value\} 其中的 标识符只能是value

**问：\#\{\} 和$\{\} 的区别？**

1.  \#\{\}自动给**String类型加上""**; (自动类型转换)  
    $\{\}**原样输出**， 但是适合于 动态排序(动态字段)
2.  \#\{\} 防止自动注入  
    $\{\}不能防止

> 以下两种等价  
> select \* from student where stuName = \#\{stuName\}  
> select \* from student where stuName = ‘$\{value\}’

$\{\} 的主要应用场景

> 动态排序：select \* from student order by $\{value\} asc

**模糊查询时候两种处理方式：**

1. like #{stuName}
    传值：student.setStuName("%w%")     ； 相当于 like '%w%'
    2. like '%${stuName}%'

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 7]

### 2）输入参数为实体类的对象 ###

参数是一个实体类对象，$\{\}或\#\{\}中的参数名必须是实体类的属性名。

### 3）输入参数为嵌套对象 ###

传入一个Student对象，并且Student对象中包含了一个Address类型的属性，SQL配置文件中仍然可以使用\#\{\}或$\{\}来获取传入的Student对象的嵌套属性address.homeAddress和address.schoolAddress。

…
    <select id="queryStudentsIncludeCascadeProperties" parameterType="student" resultType="address">
     select * from address where homeAddress 
    like '%${address.homeAddress}%' 
    or schoolAddress = #{address.schoolAddress} 
    </select>
    …

### 4）输入参数为HashMap对象 ###

还可以给SQL配置文件传入一个HashMap类型的参数，并通过 $\{key值\} 或 \#\{ key值\} 获取对应的value值，如下，  
SQL映射文件：studentMapper.xml

…
    
    <select id=" queryStudentsWithHashMap " parameterType="HashMap" resultType="student">
     select * from student where stuName like '%${stuName}%'
     and stuAge = #{stuAge} 
    </select>
    …

动态代理接口：IStudentMapper.java

public interface IStudentMapper
    { 
     Student queryStudentsWithHashMap(Map<String, Object> map);
    }

测试方法：TestMyBatis.java

public static void testQueryStudentsWithHashMap() 
    throws IOException
    { 
     …
     Map<String, Object> studentMap = new HashMap<String, Object>();
     studentMap.put("stuName", "张三");
     studentMap.put("stuAge", new Integer(23));
     IStudentMapper studentMapper 
    = session.getMapper(IStudentMapper.class);
     // 执行查询，输入一个HashMap类型的参数
     Student student =studentMapper
    .queryStudentsWithHashMap(studentMap); 
    …
    }

**通过queryStudentsWithHashMap()传入一个HaspMap对象，再在SQL配置文件中通过$\{\}或\#\{\}获取key对应的value值。**

## 5. 输出参数 （重点） ##

### 1）输出参数为简单类型或实体对象类型 ###

在SQL配置文件中，使用**resultType指定输出的参数类型**。

…
    
    <select id=" queryStudentsCount " resultType="int">
      select count(*) from student 
    </select>
    …

### 2）输出HashMap类型 ###

指定输出类型为HashMap，并给每个字段都起上别名，如下：

**SQL映射文件studentMapper.xml**

<select id="queryStudentOutByHashMap" parameterType="int" resultType="HashMap">
     select stuNo "no",stuName "name",stuAge "age" 
    from student  where stuNo = #{stuNo}
    </select>

### 3）使用resultMap指定输出类型及映射关系 ###

**数据表中的字段依次改名为：no, name, age, gname，  
实体类中的属性仍然使用: stuNo,stuName,stuAge,graName：**

解决方案：

1.  SQL语句中定义别名

select no "stuNo",name "stuName" ,age "stuAge", gName "graName" from student

1.  使用元素指定字段和属性的对应关系  
    SQL映射文件：studentMapper

…
     
      <select id="queryStudentByNo" parameterType="int" 
    resultMap ="studentResultMap"> 
          select no, name, age, gName from student 
    where no=#{stuNo}
     </select>  
     
     <resultMap type="student" id="studentResultMap">
            <!—数据表主键no对应于属性stuNo -->
      <id column="no" property="stuNo"/>
            
      <result column="name" property="stuName"/>
      <result column="age" property="stuAge"/>
      <result column="gName" property="graName"/>
     </resultMap>

## 6. 动态SQL ##

### 1）标签 ###

#### (1) `<if>`标签 ####

<select id="testQueryStudentByNoWithOGNL" parameterType="student" resultType="student"> 
           select stuNo,stuName,stuAge,graName from student where 1=1
    		 <if  test="graName != null and graName !='' ">
    		    and graName like '%${graName}%'  
    		 </if>
    		 <if  test="stuAge != null and stuAge !='' ">
    		       and stuAge = #{stuAge}
    		 </if>
     </select>

#### (2) `<where>`标签 ####

即使用标签来替代SQL中的where关键字，并且标签可以根据情况自动帮我们处理开头的“and”关键字。

<select id="testQueryStudentByNoWithOGNL" parameterType="student" resultType="student"> 
      select stuNo,stuName,stuAge,graName from student   
      <where>
       <if test="graName != null and graName !='' ">
        and graName like '%${graName}%'  
       </if>
       <if test="stuAge != null and stuAge !='' ">
        and stuAge = #{stuAge}
       </if>
      </where>
    </select>

#### (3) `<foreach>`标签 ####

parameterType来指定输入的参数类型; 如果输入参数是集合或数组类型，就需要使用标签来完成输入参数的处理。

**如果实现如下sql:**

select * from student  where stuNo in(第一个学号, 第二个学号, 第三个学号)

##### (3).1 将集合或数组以对象属性的形式传入 #####

<select id="queryStudentWithForeach"  parameterType="grade" resultType="student">
        select * from student  
     <where>
      <if test="stuNos !=null and stuNos.size>0 " >
                   
        <foreach collection="stuNos" open=" stuNo in("  close=")" item="stuNo" separator=",">
         #{stuNo}
        </foreach>
       </if>
     </where>
    </select>

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 8]

##### (3).2 传入List类型的集合 #####

将parameterType指定为List，并且必须用 “list”名字来接收传来的List集合，如下：

<select id="queryStudentWithForeachAndList" parameterType="java.util.List" resultType="student">
      select * from student  
     <where>
      <if test="list !=null and list.size>0" >
       <foreach collection="list" open=" stuNo in(" close=")" item="stuNo" separator=",">
         #{stuNo}
       </foreach>
      </if>
     </where>
    </select>

##### (3).3 传入简单类型的数组 #####

将parameterType指定为数组类型，并且必须用 “array”名字来接收传来的数组

<select id="queryStudentWithForeachAndArray" parameterType="int[]" resultType="student">
      select * from student  
      <where>
       <if test="array !=null and array.length>0" >
        <foreach collection="array" open=" stuNo in("  close=")" item="stuNo" separator=",">
         #{stuNo}
        </foreach>
       </if>
      </where>
    </select>

##### (3).4 传入对象数组 #####

将parameterType的值固定写成“Object\[\]”，并且可以通过OGNL获取迭代对象的属性

<select id="queryStudentWithForeachAndObjectArray" parameterType="Object[]" resultType="student">
      select * from student  
     <where>
      <if test="array !=null and array.length>0" >
       <foreach collection="array" open=" stuNo in("  close=")" item="student" separator=",">
        #{student.stuNo}
       </foreach>
      </if>
     </where>
    </select>

### 2）SQL片段 ###

<select id="testQueryStudentByNoWithOGNL" parameterType="student" resultType="student"> 
      select stuNo,stuName,stuAge,graName from student   
     <where>
      <if test="graName != null and graName !='' ">
       and graName like '%${graName}%'  
      </if>
      <if test="stuAge != null and stuAge !='' ">
       and stuAge = #{stuAge}
      </if>
     </where>
    </select>

我们可以将`<where>`中的if判断提取出来，然后在需要使用的地方使用导入即可，如下：

<sql id="queryWithGranameAndAge">
     <if test="graName != null and graName !='' ">
      and graName like '%${graName}%'  
     </if>
     <if test="stuAge != null and stuAge !='' ">
      and stuAge = #{stuAge}
     </if>
    </sql>
     
    <select id="testQueryStudentByNoWithOGNL" parameterType="student"  resultType="student"> 
      select stuNo,stuName,stuAge,graName from student   
     <where>
            <!—导入SQL片段 -->
      <include refid="queryWithGranameAndAge"/>
     </where>
    </select>

说明： 如果导入的是其它SQL映射文件中的SQL片段，则需要在引用时加上namespace，如：`<include refid="namespace值.sql片段的id值”/>`。

# 六. 关联查询（重点） #

## 1. 一对一查询 ##

### 1.1 使用扩展类实现一对一查询 ###

public class StudentAndCardBusiness extends Student
    { 
      //学生证号
      private int cardId;
      //学生证的相关信息
      private String cardInfo;
      //setter、getter
    }

<select id="queryStudentAndCardBusinessByStuNo" 
    parameterType="int" resultType="StudentAndCardBusiness"> 
      select s*,c.* from student s 
               inner join studentCard c  on  s.cardId = c.cardId
               where s.stuNo = #{stuNO} 
    </select>

### 1.2 使用resultMap实现一对一查询 (常用) ###

Student类

public class Student
    { 
     private int stuNo;
     private String stuName;
     private int stuAge;
     //学生证
     private StudentCard card ;
        …
     //setter、getter
    }

StudentCard类

public class StudentCard
    { 
     //学生证号
     private int cardId;
     //学生证的相关信息
     private String cardInfo;
     //getter、setter
    }

studentMapper.xml

<select id="queryStudentAndCardByStuNoWithResultMap" parameterType="int" resultMap="student_card_map"> 
      select s.*,c.* from student s 
               inner join studentCard c
               on  s.cardId = c.cardId
               where s.stuNo = #{stuNO} 
     </select> 
     
     <resultMap type="org.lanqiao.entity.Student" id="student_card_map">
      <id property="stuNo" column="stuNo"/>
      <result property="stuName" column="stuName"/>
      <result property="stuAge" column="stuAge"/>
      
      <association property="card" javaType="studentCard">
       <id property="cardId" column="cardId"/>
       <result property="cardInfo" column="cardInfo"/>
      </association>
    </resultMap>

通过`<resultMap>`元素将学生表的字段与类中简单类型的属性绑定起来，并通过`<association>`将学生类中的学生证成员card中的各个属性与字段绑定起来。其中，对于  
简单类型的属性，`<id>`映射主键列，`<result>`映射其他列；  
**非简单类型的属性（card属性），需要用`<association>`来映射，并用javaType来指定该属性的类型。**

## 2. 一对多查询 ##

StudentClass.java

public class StudentClass
    { 
     private int classId ; 
     private String className;
     private List<Student> students ;
     //setter、getter
    }

studentMapper.xml

<select id="queryClassAndStudnetsByClassId" parameterType="int" resultMap="classAndStudentMap"> 
      select s.*,sc.* from student s
        inner join studentClass sc
        on s.classid=sc.classid
        where sc.classid = #{classId}
    </select> 
     
    <resultMap type="studentClass" id="classAndStudentMap">
      <id property="classId" column="classId" />
      <result property="className" column="className" />
      
      <collection property="students" ofType="student">
       <id property="stuNo" column="stuNo" />
       <result property="stuName" column="stuName" />
       <result property="stuAge" column="stuAge" />
      </collection>
    </resultMap>

通过`<select>`执行一对一的查询SQL，并将查询结果通过`<resultMap>`映射到StudentClass类中的各个属性中：  
普通类型通过`<id>`、`<result>`映射，  
List类型的属性students通过`<collection>`映射，并通过`ofType`指定List中元素的类型。

即List类型的属性，需要通过`<resultMap>`中的`<collection>`元素来映射到数据表中的各个列。

## 3. 多对一查询与多对多查询 ##

> 一对多和多对一的本质是一样的，只是参照的对象不同。  
> “多对多”的本质就是组合了两个“一对多”。

小结：关联查询主要是在元素中，用配置一对一、用配置一对多。

## 4. 延迟加载 ##

现在先给MyBatis加入日志输出功能，用于观察MyBatis执行时的SQL语句，便于我们以后更好的理解延迟加载。

### 1. 日志输出 ###

#### (1)加入log4j驱动包 ####

将log4j的驱动包log4j-1.2.15.jar加入项目的构建目录（Build Path）。

#### (2)指定日志输出 ####

conf.xml

…
    <configuration>
     <properties resource="db.properties" />
      <settings>
                 …
           <setting name="logImpl" value="LOG4J"/>  
     </settings>
    …
    </configuration>

如果不进行此项设置，MyBatis就会按照SLF4J →Apache Commons Logging →Log4j 2 → Log4j →JDK logging的顺序进行查找，查找项目中是否集成了相应的日志功能，如果都没找到就会禁用日志功能。

#### (3)配置日志输出文件 ####

最后，在src下新建一个log4j.properties文件，用于配置日志输出的级别、格式等，如下

log4j.properties.java

log4j.rootLogger=DEBUG, stdout
    log4j.appender.stdout=org.apache.log4j.ConsoleAppender
    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
    log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

一般来讲，在开发、调试程序期间，建议把日志级别设置为DEBUG。

至此，我们就给MyBatis加入了日志功能，以后再执行MyBatis时，就可以在控制台看到MyBatis执行时的SQL语句。

### 2. 延迟加载详解 ###

解延迟加载的意义:

> 在使用“一对多”查询时，很多时候我们只需要“一”的一方，而并不需要立即将“多”的一方查询出来。例如，班级是“一”，学生是“多”，有时候我们只需要查询出班级中的信息，而并没必要立即查询出班级中的所有学生。也就是说，最好能够将查询“多”的操作进行延迟，即首次查询只查询主要信息（例如“一”的一方），关联信息（例如“多”的一方）等需要时再加载，以减少不必要的数据库查询开销，从而提升了程序的效率，这就称为“延迟加载”。

前提：在MyBatis中使用延迟加载前，必须先将MyBatis配置文件中的延迟加载开关打开，具体是在元素中加入以下配置

conf.xml

#### (1)一对一延迟加载 ####

学生和学生证之间是“一对一”的关系，现在通过延迟加载来实现：学生表一对一关联查询学生证表，要求默认只查学生表，学生证表只有当需要时再查询，即按需查询学生证表。

studentMapper.xml

<select id="queryStudentLazyLoadCard" resultMap="studentAndCardLazyLoadMap">
      select * from student 
    </select>
     
    <resultMap type="org.lanqiao.entity.Student" id="studentAndCardLazyLoadMap">
     <id property="stuNo" column="stuNo"/>
     <result property="stuName" column="stuName"/>
     
     <association property="card" javaType="org.lanqiao.entity.StudentCard" <!—通过namespace+id指定延迟加载执行的SQL语句 -->
     select="org.lanqiao.mapper.IStudentCardMapper.queryCardById" column="cardId"/>
    </resultMap>

SQL映射文件2：

studentCardMapper.xml

<mapper namespace="org.lanqiao.mapper.IStudentCardMapper">
      
      <select id="queryCardById" parameterType="int" resultType="student"> 
      select * from studentCard where cardId=#{cardId}
    </select>

先通过主查询`“select * from student”`查询学生信息，然后通过一对一映射元素`<association>`关联查询学生证表，  
并通过`select`属性指定延迟加载的SQL语句`“select * from studentCard where cardId=#{cardId}”`。  
也就是说，在一对一查询中，是通过`<association>`的`select`属性指定延迟加载的。

结果分析：

1.  当程序执行到`studentMapper.queryStudentLazyLoadCard()`（即查询学生信息的方法）时，MyBatis只发出了查询学生的SQL语句`“select * from student”`；
2.  但当程序执行到`student.getCard()`（即查询学生对象关联的学生证信息）时，
3.  才会发出查询学生证的SQL语句`“select * from studentCard where cardId=?”`。
4.  这就是使用了延迟加载的效果：首次查询时，只查询目前需要的信息，其他信息等到需要时再去查询。

#### (2)一对多延迟加载 ####

一对多延迟加载的配置方法与一对一基本相同，不同的是将`<association>`换成了`<collection>`元素，即一对多延迟加载是在`<collection>`元素中配置`select`属性。可以自行尝试。

# 七. 查询缓存 #

参考：[https://lanqiao.coding.me/mybatis框架/MyBatis-lesson16][https_lanqiao.coding.me_mybatis_MyBatis-lesson16]

> 查询缓存，就是在内存或外存上建立一个存储空间，用来保存上次查询结果，下次再进行同样的查询时，就可以直接从内存或外存中读取，而不用再从数据库中查找，可以大大的提高查询效率。

## 1. 一级缓存 ##

**一级缓存的范围是一个SqlSession对象：**

1.  在同一个SqlSession对象中多次执行相同的查询SQL语句时，第一次执行完毕会就将数据库的查询结果写到内存（缓存）中，以后如果再次执行该查询时就会直接从内存中读取查询结果。
2.  但是，如果执行了增删改所需的commit()方法，那么SqlSession对象的一级缓存就会被清理（**清理是指“将缓存中的数据全部写入数据库，从而使缓存变空”**），
3.  下次再次查询时，都会重新从数据库中查询，并将查询后的结果写入SqlSession对象

当一个SqlSession对象关闭后，该SqlSession对象中的一级缓存也就随之销毁。Mybatis默认开启一级缓存。

public static void queryStudentByNoTwice() throws IOException
    { 
     …
     IStudentMapper studentMapper 
    = session.getMapper(IStudentMapper.class);
     //第一次查询学号为32的学生
     Student student1 = studentMapper.queryStudentByNo(32);
     //第二次查询学号为32的学生，直接从缓存中获取
     Student student2 = studentMapper.queryStudentByNo(32);
     session.close();
    }

第一次查询结果写到内存（缓存）中，查询结果只有一个sql语句

public static void queryStudentByNoTwiceWithUpdate() throws IOException
    { 
     …
     SqlSession session = sessionFactory.openSession();
     IStudentMapper studentMapper 
    = session.getMapper(IStudentMapper.class);
     //第一次查询学号为32的学生
     Student student1 = studentMapper.queryStudentByNo(32);
     //执行一次修改操作，并调用commit()方法，一级缓存被清理
     Student stu = new Student();
     stu.setStuNo(32);
     …
     studentMapper.updateStudentByNo(stu);
     session.commit();
     //第二次查询学号为32的学生，重新发送查询SQL
     Student student2 = studentMapper.queryStudentByNo(32);
     session.close();
    }

commit()方法，导致一级缓存被清理了，所以两次查询操作各自都发送了查询SQL

## 2. 二级缓存 ##

1.  Mybatis一级缓存的范围是同一个SqlSession对象内；
2.  而二级缓存则是可以被多个SqlSession对象共享的，范围是同一个namespace下SQL映射文件生成的动态代理mapper对象，
3.  例如我们使用的studentMapper对象。与一级缓存相同，=当执行增删改时的commit()方法时，二级缓存也会被清理。
4.  `注意;`如果两个不同的SQL映射文件有相同的namespace值，那么这两个namespace的SQL映射文件共用同一个mapper对象

### 1）. 使用二级缓存 ###

**MyBatis没有默认开启二级缓存，使用时需要在setting全局参数中开启**

#### (1)开启二级缓存 ####

**1. conf.xml**

**2. 此外，还要在SQL映射文件中添加一行： ，表示把此SQL映射文件的mapper对象的二级缓存功能打开，如下：**

#### (2)实现序列化 ####

二级缓存需要将实体类实现`java.io.Serializable`接口，以实现序列化和反序列化操作。注意，如果实体类有父类、或实体类的某个属性成员也是实体类对象类型的，则也都需要实现`java.io.Serializable`接口，  
Student.java

package org.lanqiao.entity;
    import java.io.Serializable;
    public class Student implements Serializable
    { 
     //学号
     private int stuNo;
     //姓名 
     private String stuName;
     //年龄
     private int stuAge;
     …
     //学生证
     private StudentCard card ;
     //setter、getter
    }

Student类中的属性card所属的实体类，也需要实现Serializable接口：

StudentCard.java

package org.lanqiao.entity;
    import java.io.Serializable;
    public class StudentCard  implements Serializable
    { 
     //学生证号
     private int cardId;
     //学生证的相关信息
     private String cardInfo;
     //setter、getter
    }

#### (3)测试二级缓存 ####

public static void queryStudentByNoWithSecondCache() throws IOException
    { 
     …
     //创建第一个SqlSession对象
     SqlSession session1 = sessionFactory.openSession();
     IStudentMapper studentMapper1 = session1.getMapper(IStudentMapper.class);
     //第一次查询学号为32的学生
     Student student1 = studentMapper1.queryStudentByNo(32);
     session1.close();
     //创建第二个SqlSession对象
     SqlSession session2 = sessionFactory.openSession();
     IStudentMapper studentMapper2
     = session2.getMapper(IStudentMapper.class);
     //第二次查询学号为32的学生
     Student student2 = studentMapper2.queryStudentByNo(32);
     session2.close();
    }

### 2）. 禁用二级缓存 ###

可以给某一个具体的SQL标签设置成禁用二级缓存

给`<select>`标签设置了`useCache="false"`，就可以禁用二级缓存：发送了两次SQL语句。默认情况下，`useCache="true"`表示开启二级缓存。

<select id="queryStudentByNo" parameterType="int" resultType="student" useCache="false"> 
     select stuNo,stuName,stuAge,graName from student 
    where stuNo=#{stuNo}
    </select>

### 3）. 清理二级缓存 ###

#### 1.清理二级缓存 ####

执行增删改的commit()方法，二级缓存也会随之被清理

public static void queryStudentByNoWithSecondCacheAndUpdate() throws IOException
    { 
     …
        //使用第一个SqlSession执行查询
     SqlSession session1 = sessionFactory.openSession();
     IStudentMapper studentMapper1 
    = session1.getMapper(IStudentMapper.class);
     Student student1 = studentMapper1.queryStudentByNo(32);
     session1.close();
     //执行更新方法，并调用commit()清理缓存
     SqlSession session_update = sessionFactory.openSession();
     IStudentMapper studentMapper 
    = session_update.getMapper(IStudentMapper.class);
     Student stu = new Student();
     stu.setStuNo(32);
     …
     studentMapper.updateStudentByNo(stu);
     session_update.commit();
     //使用第二个SqlSession执行查询
     SqlSession session2 = sessionFactory.openSession();
     IStudentMapper studentMapper2
     = session2.getMapper(IStudentMapper.class);
     Student student2 = studentMapper2.queryStudentByNo(32);
     session2.close();
    }

**两次查询中间执行了commit()方法，二级缓存被清理，因此向数据库发送了两条查询SQL**

#### 2.不清理二级缓存 ####

如果有特殊情况，想让执行`commit()方法`时并不清理缓存，可以在增删改的SQL标签里设置`flushCache="false"`

<update id="updateStudentByNo" parameterType="student" flushCache="false">
     update student set stuName=#{stuName},stuAge=#{stuAge},
    graName=#{graName}  where stuNo=#{stuNo}
    </update>

只向数据库发送了一次SQL，第二次是直接从缓存中获取的数据

### 2）. 整合第三方提供的二级缓存 ###

MyBatis还可以整合Ehcache、OSCache、MEMcache等由第三方厂商提供的二级缓存。以使用较多的Ehcache为例进行讲解。

MyBatis提供了用于整合二级缓存的接口Cache以及默认的实现类`PerpetualCache`

MyBatis整合Ehcache的具体步骤如下：

#### (1)导入Ehcache相关JAR文件 ####

![在这里插入图片描述][20190416182952649.png]

#### (2)创建并编写Ehcache配置文件 ####

在src下创建Ehcache配置文件Ehcache.xml，并进行以下配置：

Ehcache.xml

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 9]

#### (3) 开启Ehcache ####

前面提到过，在MyBatis中整合第三方的二级缓存，需要实现MyBatis提供的Cache接口。  
而Ehcache的JAR文件中，就有该接口的实现类

修改studentMapper.xml，将MyBatis内置的二级缓存更换为Ehcache的相关配置，如下：

studentMapper.xml

也可以在具体的SQL映射文件中配置EHCache的参数，用来覆盖ehcache.xml中的配置

#### (4) 测试Ehcache ####

再次执行重复查询同一对象的方法`queryStudentByNoWithSecondCache()`  
两次相同的查询操作只发送了一条SQL语句，即Ehcache二级缓存确实得到了使用。

# 八. 逆向工程 #

**一般的开发流程是：**

1.  先设计并创建`数据库表`（如学生表），
2.  再根据数据库表创建对应的`实体类`（如Student.java），
3.  之后再编写`SQL映射文件`（如studentMapper.xml），
4.  最后再根据SQL映射文件编写`动态代理接口`（如IStudentMapper.java）。

只设计并创建数据库表，然后利用MyBatis提供的工具来自动生成其他三个（实体类、SQL映射文件和动态代理接口），

以下是具体的步骤：

## 1. 准备工作 ##

1.  准备数据表：学生表(student)、学生证表(studentCard)、班级表(studentClass)
2.  创建JAVA项目：MyBatis\_Generator

## 2. 下载工具 ##

1.  必须先下载MyBatis官方提供的工具：mybatis-generator-core-1.3.2-bundle.zip
2.  将lib目录中的`mybatis-generator-core-1.3.2.jar`，以及数据库驱动`ojdbc.jar`和MyBatis所依赖的`mybatis-3.3.1.jar`加入项目的构建目录(Build Path)

## 3. 创建并编写配置文件 ##

在src下创建并编写配置文件，如下，

generator.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!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">
      <commentGenerator>
       
       <property name="suppressAllComments" value="true" />
      </commentGenerator>
      
      <jdbcConnection driverClass="oracle.jdbc.OracleDriver" connectionURL="jdbc:oracle:thin:@127.0.0.1:1521:XE" userId="system" password="sa">
      </jdbcConnection>
      
      <javaTypeResolver>
       <property name="forceBigDecimals" value="false" />
      </javaTypeResolver>
      
      <javaModelGenerator targetPackage="org.lanqiao.entity" targetProject=".\src">
       
       <property name="trimStrings" value="true" />
      </javaModelGenerator>
      
      <sqlMapGenerator targetPackage="org.lanqiao.mapper" targetProject=".\src">
      </sqlMapGenerator>
      
      <javaClientGenerator type="XMLMAPPER" targetPackage="org.lanqiao.mapper" targetProject=".\src">
      </javaClientGenerator>
      
      <table tableName="Student"> </table>
      <table tableName="studentCard"> </table>
      <table tableName="studentClass"> </table>
     </context>
    </generatorConfiguration>

## 4. 编写生成代码 ##

有了自动生成需要的配置文件generator.xml，就可以编写自动生成的相关代码，如下：

MyBatis\_Generator.java

…
    import org.mybatis.generator.api.MyBatisGenerator;
    import org.mybatis.generator.config.Configuration;
    import org.mybatis.generator.config.xml.ConfigurationParser;
    import org.mybatis.generator.internal.DefaultShellCallback;
    public class MyBatis_Generator
    { 
     public static void main(String[] args) throws Exception
     { 
      File f = new File("src/generator.xml");
      List<String> warnings = new ArrayList<String>();
      ConfigurationParser cp 
    = new ConfigurationParser(warnings);
      Configuration config = cp.parseConfiguration(f);
      DefaultShellCallback callBack = new DefaultShellCallback(true);
      MyBatisGenerator generator = new MyBatisGenerator(config, callBack, warnings);
      generator.generate(null);
     }
    }

执行MyBatis\_Generator.java并刷新项目

[mybatis]: https://lanqiao.coding.me/mybatis%E6%A1%86%E6%9E%B6/MyBatis-lesson12
[mybatis 1]: https://blog.csdn.net/qq_33342112/article/details/80436597
[http_blog.mybatis.org]: http://blog.mybatis.org/
[https_github.com_mybatis_mybatis-3_releases]: https://github.com/mybatis/mybatis-3/releases
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70]: /images/20220219/dd6324069bf84cb89e02425c695496e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 1]: /images/20220219/72c0ec9fbcde415f89e1b758afcc8a99.png
[20190416085651469.png]: /images/20220219/02b6d85c1d934705bc333af16f060a9d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 2]: /images/20220219/789e23cb8f934066a42cbe482b5c2004.png
[20190416084930436.png]: /images/20220219/a0f204d26349441b9e7809ec5ff377e8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 3]: /images/20220219/91f9faff04a14f0d8684585a14894f0a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 4]: /images/20220219/d9f22e84f55d4fa0a722871e5882628e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 5]: /images/20220219/d3d896ac6d7f4da59949bb6c793b833c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 6]: /images/20220219/b84c43dd7287471e9ee68cde71b5bbec.png
[https_lanqiao.coding.me_mybatis_MyBatis-lesson13]: https://lanqiao.coding.me/mybatis%E6%A1%86%E6%9E%B6/MyBatis-lesson13
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 7]: /images/20220219/9a9cb1aad81b45b9b16777fcce9909ea.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 8]: /images/20220219/f96e734204194e6b8156376df68f2fa8.png
[https_lanqiao.coding.me_mybatis_MyBatis-lesson16]: https://lanqiao.coding.me/mybatis%E6%A1%86%E6%9E%B6/MyBatis-lesson16
[20190416182952649.png]: /images/20220219/0f1e8e5694c24267a5225c1cfd7e4184.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMzAzMDMx_size_16_color_FFFFFF_t_70 9]: /images/20220219/a91d6a3b0c204847a8b4bc3c2d5cb55e.png