Mybatis笔记（一）

MyBatis简介

MyBatis作用

• MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。
• MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
• MyBatis可以使用简单的XML用于配置和原始映射，将接口和Java的POJO类映射成数据库中的记录
• 使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。

历史

• 原是apache的一个开源项目iBatis
• 2010年6月这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。
• iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。

为什么要使用MyBatis？

JDBC

• SQL夹在Java代码块里，耦合度高导致硬编码内伤
• 维护不易且实际开发需求中sql是有变化，频繁修改的情况多见
• 要自已创建connection、创建statement、手动设置参数、结果集检索等

Hibernate

• 长难复杂SQL，对于Hibernate而言处理也不容易
• 内部自动生产的SQL，不容易做特殊优化。
• 基于全映射的全自动框架，javaBean存在大量字段时无法只映射部分字段。导致数据库性能下降。

Mybatis

• 对开发人员而言，核心sql还是需要自己优化
• MyBatis是一个半自动化的持久化层框架。
• MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架。

MyBatis入门程序

1.下载Mybatis核心包

​ http://www.mybatis.org/mybatis-3/getting-started.html
​ https://github.com/mybatis/mybatis-3/releases

2.创建工程,引入MyBatis核心包及依赖包

​

ant-1.9.6.jar
ant-launcher-1.9.6.jar
asm-5.2.jar
cglib-3.2.5.jar
commons-logging-1.2.jar
javassist-3.22.0-GA.jar
junit-4.9.jar
log4j-1.2.17.jar
log4j-api-2.3.jar
log4j-core-2.3.jar
lombok.jar
mybatis-3.4.6.jar
mysql-connector-java-5.1.7-bin.jar
ognl-3.1.16.jar
slf4j-api-1.7.25.jar
slf4j-log4j12-1.7.25.jar

3.创建customer表,建立与表对象的domain

package com.le.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Setter@Getter@ToString
public class Customer {
    private Integer cust_id;
    private String cust_name;
    private String cust_profession;
    private String cust_phone;
    private String email;
}

4.创建MyBatis核心配置文件SqlMappingConfig.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>
    <!-- spring整合后 environments配置将废除 使用spring中的连接池 -->
    <environments default="development">
        <environment id="development">
            <!-- 使用jdbc事务管理 -->
            <transactionManager type="JDBC" />
            <!-- 数据库连接池 -->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url"
                          value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
                <property name="username" value="root" />
                <property name="password" value="1234" />
            </dataSource>
        </environment>
    </environments>
</configuration>

	<!DOCTYPE configuration
			PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
			"http://mybatis.org/dtd/mybatis-3-config.dtd">
	<configuration>
		<!-- spring整合后 environments配置将废除 使用spring中的连接池 -->
		<environments default="development">
			<environment id="development">
				<!-- 使用jdbc事务管理 -->
				<transactionManager type="JDBC" />
				<!-- 数据库连接池 -->
				<dataSource type="POOLED">
					<property name="driver" value="com.mysql.jdbc.Driver" />
					<property name="url"
							  value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
					<property name="username" value="root" />
					<property name="password" value="1234" />
				</dataSource>
			</environment>
		</environments>
	</configuration>

5.创建与表对象的关系映射Mapping文件编写sql语句

​

<?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="myTest">
    <!--根据cust_id查询客户-->
    <select   parameterType="Int" resultType="com.le.domain.Customer">
	  SELECT * FROM `customer` WHERE cust_id  = #{cust_id}
	</select>
</mapper>

6.在SqlMappingConfig.xml核心配置文件当中引入Mapping

<!--加载映射文件-->
<mappers>
      <mapper resource="com/le/domain/Customer.xml"></mapper>
</mappers>

7.创建工厂,执行sql语句

@Test
public void test() throws IOException {
   /* //1.sqlSessionFactoryBuilder 加载配置文件
	SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
	
	//2.读取配置文件
	InputStream resourceAsStream = Resources.getResourceAsStream("SqlMappingConfig.xml");
	
	//3.获取session工厂
	SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream);
	
	//4.获取会话   ---JDBC 连接
	SqlSession sqlSession = sessionFactory.openSession();*/
	SqlSession sqlSession = MybatisUtils.openSession();
	
	//5.执行sql
	Customer customer = sqlSession.selectOne("queryCustomerById", 2);
	System.out.println(customer);
	
	//6.关闭session
	sqlSession.close();
}

MyBatis核心Api

SqlSessionFactoryBuilder

• SqlSessionFactoryBuilder用于创建SqlSessionFacoty
• SqlSessionFacoty一旦创建完成就不需要SqlSessionFactoryBuilder了
• 因为SqlSession是通过SqlSessionFactory创建的
• 所以可以将SqlSessionFactoryBuilder当成一个工具类使用，最佳使用范围是方法范围即方法体内局部变量。

SqlSessionFactory

• 创建sqlSession的工厂,是一个接口
• 接口中定义了openSession的不同重载方法
• SqlSessionFactory的最佳使用范围是整个应用运行期间，一旦创建后可以重复使用，通常以单例模式管理SqlSessionFactory。

SqlSession

• 连接到数据库的一个会话
• sqlSession中定义了数据库操作方法。
• 每个线程都应该有它自己的SqlSession实例
• SqlSession的实例不能共享使用，它也是线程不安全的。因此最佳的范围是请求或方法范围
• 绝对不能将SqlSession实例的引用放在一个类的静态字段或实例字段中。

MyBatis架构

MyBatis-查询

MybatisUtils工具类

package com.le.utils;

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 java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    public static final  SqlSessionFactory sessionFactory;
    static {
        //1.sqlSessionFactoryBuilder 加载配置文件
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //2.读取配置文件
        InputStream resourceAsStream = null;
        try {
            resourceAsStream = Resources.getResourceAsStream("SqlMappingConfig.xml");
        } catch (IOException e) {
            e.printStackTrace();
        }
        //3.获取session工厂
        sessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream);
    }

    public static SqlSession openSession(){
        return sessionFactory.openSession();
    }
}

查询所有客户

<!--查询所有-->
<select   resultType="com.le.domain.Customer">
   SELECT * FROM `customer`
</select>

@Test
public void test2() {
	SqlSession sqlSession = MybatisUtils.openSession();
	/*查询所有的用户*/
	List<Customer> queryAllCustomer = sqlSession.selectList("queryAllCustomer");
	for (Customer customer : queryAllCustomer) {
		System.out.println(customer);
	}
	sqlSession.close();
}

​

根据用户名模糊查询客户

方式1

<!--根据用户名模糊查询客户-->
<select   parameterType="String" resultType="com.le.domain.Customer">
	select * from customer where cust_name like '%{value}%';
</select>

​

@Test
public void test3(){
	SqlSession sqlSession = MybatisUtils.openSession();
	List<Customer> customers = sqlSession.selectList("querytCustomerByName", "%李%");
	for (Customer customer : customers) {
		System.out.println(customer);
	}
	sqlSession.close();
}

​
​

方式2

<!--根据用户名模糊查询客户-->
<select   parameterType="String" resultType="com.le.domain.Customer">
	select * from customer where cust_name like #{name};
</select>		

​

总结

parameterType
	指定输入参数类型
	mybatis通过ognl从输入对象中获取参数值拼接在sql中
resultType
	指定输出结果类型
	mybatis将sql查询结果的一行记录数据映射为resultType指定类型的对象。如果有多条数据，则分别进行映射，并把对象放到容器List中
selectOne
	查询一条记录
	如果使用selectOne查询多条记录则抛出异常
selectList
	可以查询一条或多条记录
#{}和${}
	#{}
		表示一个占位符号，通过#{}可以实现preparedStatement向占位符中设置值
		自动进行java类型和jdbc类型转换
		#{}可以有效防止sql注入
		#{}可以接收简单类型值或pojo属性值
		如果parameterType传输单个简单类型值,#{}括号中可以是value或其它名称
	${}
		表示拼接sql串
		通过${}可以将parameterType 传入的内容拼接在sql中且不进行jdbc类型转换
		${}可以接收简单类型值或pojo属性值
		如果parameterType传输单个简单类型值，${}括号中只能是value

保存更新删除

添加客户，返回添加过后自增的主键

<!--添加-->
<insert   parameterType="com.le.domain.Customer">
	/*获取插入的最后一个id*/
	<selectKey keyColumn="cust_id" keyProperty="cust_id" resultType="Integer" order="AFTER">
		select last_insert_id()
	</selectKey>

	insert into `customer`(cust_name,cust_profession,cust_phone,email)
	values (#{cust_name},#{cust_profession},#{cust_phone},#{email})
</insert>	

/*添加客户*/
@Test
public void insert(){
    SqlSession sqlSession = MybatisUtils.openSession();
    Customer customer = new Customer();
    customer.setCust_name("后裔2");
    customer.setCust_phone("18907897879");
    sqlSession.insert("insertCustom",customer);
    //当要改动数据库当中的记录时,执行sql时要自己提交事务
    //手动提交事务
    sqlSession.commit();
    System.out.println(customer.getCust_id());
    sqlSession.close();
}

更新客户

<!--更新-->
<update   parameterType="com.le.domain.Customer">
	update `customer` set cust_name=#{cust_name} where cust_id=#{cust_id}
</update>

​

/*更新操作*/
@Test
public void update(){
    SqlSession sqlSession = MybatisUtils.openSession();
    Customer customer = sqlSession.selectOne("queryCustomerById", 12);
    customer.setCust_name("孙悟空");
    sqlSession.update("updateCustomer",customer);
    sqlSession.commit();
    sqlSession.close();
}

​

​
​

删除客户

<!--删除操作-->
<delete   parameterType="com.le.domain.Customer">
	delete from `customer` where cust_id=#{cust_id}
</delete>	

​

/*删除*/
@Test
public void delete(){
    SqlSession sqlSession = MybatisUtils.openSession();
    Customer customer = sqlSession.selectOne("queryCustomerById", 12);
    sqlSession.delete("deleteCustomer",customer);
    sqlSession.commit();
    sqlSession.close();
}

​

MyBatis开发DAO

原始Dao开发方法

package com.le.dao;

import com.le.domain.Customer;
import java.util.List;

public interface CustomerDao {
    public Customer getCustomerWithId(Integer id);
    public List<Customer> getAllCustomer();
    public void addCustomer(Customer customer);
    public void  updateCustomer(Customer customer);
}

​

package com.le.dao;

import com.le.domain.Customer;
import com.le.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;

import java.util.List;

public class CustomerDaoImpl implements CustomerDao {
    @Override
    public Customer getCustomerWithId(Integer id) {
        SqlSession sqlSession = MybatisUtils.openSession();
        Customer customer = sqlSession.selectOne("queryCustomerById", id);
        return customer;
    }

    @Override
    public List<Customer> getAllCustomer() {
        SqlSession sqlSession = MybatisUtils.openSession();
        List<Customer> customers = sqlSession.selectList("queryAllCustomer");
        return customers;
    }

    @Override
    public void addCustomer(Customer customer) {
        SqlSession sqlSession = MybatisUtils.openSession();
        sqlSession.insert("insertCustom",customer);
    }

    @Override
    public void updateCustomer(Customer customer) {
        SqlSession sqlSession = MybatisUtils.openSession();
        sqlSession.update("insertCustom",customer);
    }
}

​

@Test
public void test() throws IOException {
    //1.sqlSessionFactoryBuilder 加载配置文件
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    //2.读取配置文件
    InputStream resourceAsStream = Resources.getResourceAsStream("SqlMappingConfig.xml");
    //3.获取session工厂
    SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(resourceAsStream);
    //4.获取会话   ---JDBC 连接
    SqlSession sqlSession = sessionFactory.openSession();

    //5.执行sql
    Customer customer = sqlSession.selectOne("queryCustomerById", 2);
    System.out.println(customer);
    //6.关闭session
    sqlSession.close();
}

​
​

Mapper动态代理

要求

• namespace必须和Mapper接口类路径一致
• id必须和Mapper接口方法名一致
• parameterType必须和接口方法参数类型一致
• resultType必须和接口方法返回值类型一致

过程

package com.le.mapper;

import com.le.domain.Customer;
import java.util.List;

public interface CustomerMapper {
    //根据cust_id查询客户
    public Customer queryCustomerById(Integer id);
}	

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

<mapper namespace="com.le.mapper.CustomerMapper">
    <!--根据cust_id查询客户-->
    <select   parameterType="Integer"
            resultType="com.le.domain.Customer">
	  SELECT * FROM `customer` WHERE cust_id  = #{cust_id}
	</select>
</mapper>		

@Test
public void test(){
 SqlSession sqlSession = MybatisUtils.openSession();
        CustomerMapper mapper = sqlSession.getMapper(CustomerMapper.class);
        Customer customer = mapper.queryCustomerById(1);
        System.out.println(customer);
        sqlSession.close();
}

​

selectOne和selectList

• 动态代理对象调用sqlSession.selectOne()和sqlSession.selectList()是根据mapper接口方法的返回值决定
• 如果返回list则调用selectList方法，如果返回单个对象则调用selectOne方法。

参数传递

单个参数

• 可以接受基本类型，对象类型，集合类型的值。
• MyBatis可直接使用这个参数，不需要经过任何处理。

多个参数

• 任意多个参数，都会被MyBatis重新包装成一个Map传入。
• Map的key是param1，param2…，值就是参数的值。

​ 示例

@Test
public void test3(){
    SqlSession sqlSession = MybatisUtils.openSession();
    CustomerMapper mapper = sqlSession.getMapper(CustomerMapper.class);
	Customer customer = mapper.queryCustomerById(1,"鲁班大师");
    System.out.println(customer);
    sqlSession.close();
}

​

<!--根据cust_id 和 cust_name查询客户-->
<select  
		resultType="com.le.domain.Customer">
  SELECT * FROM `customer` WHERE cust_id  = #{arg0} and cust_name=#{arg1}
</select>

​
​

@param命名参数

• 为参数使用@Param起一个名字，
• MyBatis就会将这些参数封装进map中，key就是我们自己指定的名字

​ 示例
​

public interface CustomerMapper {
    /*
    * 根据cust_id查询客户
    * */
    public Customer queryCustomerById(@Param("cust_id") Integer id,@Param("cust_name") String cust_name);
}

<!--根据cust_id 和 cust_name查询客户-->
<select  
		resultType="com.le.domain.Customer">
  SELECT * FROM `customer` WHERE cust_id  = #{arg0} and cust_name=#{arg1}
</select>

​

@Test
public void test(){
    SqlSession sqlSession = MybatisUtils.openSession();
    CustomerMapper mapper = sqlSession.getMapper(CustomerMapper.class);
	Customer customer = mapper.queryCustomerById(1,"鲁班大师");
    System.out.println(customer);
    sqlSession.close();
}

​

POJO

• 当这些参数属于我们业务POJO时，我们直接传递POJO

​ 示例
​

public void insertCustom(Customer customer);	

​

@Test
public void insert(){
    SqlSession sqlSession = MybatisUtils.openSession();
    Customer customer = new Customer();
    customer.setCust_name("后裔2");
    customer.setCust_phone("18907897879");
    sqlSession.insert("insertCustom",customer);
    //当要改动数据库当中的记录时,执行sql时要自己提交事务
    //手动提交事务
    sqlSession.commit();
    System.out.println(customer);
    sqlSession.close();
}

​

<!--添加-->
<insert   parameterType="com.le.domain.Customer">
	insert into `customer`(cust_name,cust_profession,cust_phone,email)
	values (#{cust_name},#{cust_profession},#{cust_phone},#{email})
</insert>

​

Map

• 我们也可以封装多个参数为map，直接传递

​ 示例
​

public Customer queryCustomerById(Map<String,Object> map);

​

@Test
public void test(){
	SqlSession sqlSession = MybatisUtils.openSession();
	CustomerMapper mapper = sqlSession.getMapper(CustomerMapper.class);
	HashMap<String, Object> hashMap = new HashMap<>();
	hashMap.put("cust_id",1);
	hashMap.put("cust_name","鲁班");
	Customer customer = mapper.getCustomerWithID(hashMap);*/
	System.out.println(customer);
	sqlSession.close();
}

<!--根据cust_id 和 cust_name查询客户-->
<select  
		resultType="com.le.domain.Customer">
  SELECT * FROM `customer` WHERE cust_id  = #{cust_id} and cust_name=#{cust_name}
</select>	

参数传递源码分析

• 会把参数给放到一个数组当中

• 如果一个参数, 内部处理时,会自动把该参数范围

• 如果是多个参数,内部会做判断

• 判断是否有@param注解

​ 如果没有@param注解
​ 没有注解的话, 就直接使用arg0 arg1...为key 放到map中

​ 并且还会以param1和param2...为key放一份到map中

​ 如果有@param注解
​ 如果有注解的话, 会使用注解当中的值,替换掉默认的arg0和arg1
​ 使用@param中的值,做为key 放到一个map当中
​ 并且还会以param1和param2...为key放一份到map中

MaBatis核心配置文件

properties标签

• 定义属性及读取属性文件

​ 示例

<!-- 是用resource属性加载外部配置文件 -->
<properties resource="db.properties">
	<!-- 在properties内部用property定义属性 -->
	<!-- 如果外部配置文件有该属性，则内部定义属性被外部属性覆盖 -->
	<property name="driver" value="com.mysql.jdbc.Driver" />
	<property name="url" value="jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8" />
	<property name="username" value="root" />
	<property name="password" value="1234" />
</properties>

​

settings标签

• 这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为

​ 示例

package com.le.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Setter@Getter@ToString
public class Customer {
    private Integer cust_id;
    private String cust_name;
    private String cust_profession;
    private String cust_phone;
    private String email;
}

​

<!-- 用来配置MyBatis中一些设置 -->
<!-- 开启驼峰映射，为自定义的SQL语句服务 -->
<!-- 设置其用数据库字段下划线映射到jaba对象的驼峰式命名属性，默认为false -->
<settings>
    <!-- 打印查询语句 -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!--开启驼峰命名法-->
	<setting name="mapUnderscoreToCamelCase" value="true">
</settings>

​

typeAliases标签

• 类型别名是为 Java 类型设置一个短的名字
• 定义单个别名

<!--定义别名-->
<typeAliases>
    <!--单个别名定义-->
    <typeAlias alias="Customer" type="com.le.domain.Customer"/>
</typeAliases>		

​

<!--查询用户 ID-->
<select    resultType="Customer" >
	select * from `customers` where cust_id = #{id} and cust_name=#{name}
</select>

​

• 批量别名定义

  ​ 如果当前包类与子包类重名,会有异常
  ​ 可以在类上使用注解@Alias("别名")

<!--定义别名-->
<typeAliases>
    <!--批量定义别名, 别名为类名（大小写不敏感）-->
    <package name="com.le.domain"/>
</typeAliases>	

typeHandlers标签

• 无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，
• 还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。
• JDK1.8之后实现全部的JSR310规范
• 日期时间处理上，我们可以使用MyBatis基于JSR310（Date and Time API）
• 编写的各种日期时间类型处理器。
• MyBatis3.4以前的版本需要我们手动注册这些处理器，以后的版本都是自动注册的

Plugins标签

• 插件是MyBatis提供的一个非常强大的机制，
• MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。
• 通过插件来修改MyBatis的一些核心行为。

Environments标签

• MyBatis可以配置多种环境，比如开发、测试和生产环境需要有不同的配置。
• 每种环境使用一个environment标签进行配置并指定唯一标识符
• 可以通过environments标签中的default属性指定一个环境的标识符来快速的切换环境
• Environment子标签

​

transactionManager事务管理
	Type有以下取值
	JDBC
		使用JDBC 的提交和回滚设置，依赖于从数据源得到的连接来管理事务范围
	MANAGED
		不提交或回滚一个连接、让容器来管理事务的整个生命周期
		ManagedTransactionFactory
	自定义
		实现TransactionFactory接口 
		type=全类名/别名
		
dataSource数据源
	type有以下取值
	UNPOOLED
		不使用连接池UnpooledDataSourceFactory
	POOLED
		使用连接池PooledDataSourceFactory
	JNDI
		在EJB 或应用服务器这类容器中查找指定的数据源
	自定义
		实现DataSourceFactory接口，定义数据源的获取方式
		
实际开发
	实际开发中我们使用Spring管理数据源
	并进行事务控制的配置来覆盖上述配置 

<!-- spring整合后 environments配置将废除 使用spring中的连接池 -->
<environments default="development">
    <environment id="development">
        <!-- 使用jdbc事务管理 -->
        <transactionManager type="JDBC" />
        <!-- 数据库连接池 -->
        <dataSource type="POOLED">
            <property name="driver" value="${jdbc.driver}" />
            <property name="url" value="${jdbc.url}" />
            <property name="username" value="${jdbc.username}" />
            <property name="password" value="${jdbc.password}" />
        </dataSource>
    </environment>

    <environment id="test">
        <!-- 使用jdbc事务管理 -->
        <transactionManager type="JDBC" />
        <!-- 数据库连接池 -->
        <dataSource type="POOLED">
            <property name="driver" value="${jdbc.driver}" />
            <property name="url" value="${jdbc.url}" />
            <property name="username" value="${jdbc.username}" />
            <property name="password" value="${jdbc.password}" />
        </dataSource>
    </environment>
</environments>

databaseIDProvider标签

​ MyBatis 可以根据不同的数据库厂商执行不同的语句。
​ 可以通过databaseIDProvider标签来进行设置

<databaseIdProvider type="DB_VENDOR">
	<property name="MYSQL" value="mysql"/>
	<property name="DB2" value="db2"/>
	<property name="Oracle" value="oracle" />
	<property name="SQL Server" value="sqlserver"/>
</databaseIdProvider>

​ 示例

<!--查询用户 ID-->
<select    resultType="Customer" databaseId="mysql">
	select * from `customers`
</select>		

​

mappers标签

resource属性

​ 使用相对于类路径的资源

<!--加载映射文件-->
<mappers>
    <mapper resource="com/le/mapping/CustomerMapping.xml"></mapper>
</mappers>		

​

class属性

• 使用mapper接口类路径
• 此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中

<!--加载映射文件-->
<mappers>
    <mapper class="com.le.mapping.CustomerMapping"></mapper>
</mappers>	

​

package子标签

• 指定包下的所有mapper接口
• 此种方法要求mapper接口名称和mapper映射文件名称相同，且放在同一个目录中

<!--加载映射文件-->
<mappers>
    <package name="com.le.mapping"/>
</mappers>	

输出类型

输出简单类型

​

<!--查询总数-->
<select   resultType="Integer">
	select count(*) from customer;
</select>

Map

第1种形式

• key:是列名

• value:是列名对应的值

  示例

public Map<String,Object> getCustomerWithId(Integer id);

<select   resultType="java.util.Map">
	select * from customer where cust_id=#{id}
</select>

@Test
public void test(){
	SqlSession sqlSession = MybatisUtils.openSession();
	CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
	Map<String, Object> customer = customerMapper.getCustomerWithId(2);
	System.out.println(customer);
	sqlSession.close();
}

​

第2种形式

• Map<key,自定义对象>
• key为自己指定的数据库中的列值

​ 示例

@MapKey("cust_name")
public Map<Integer,Customer> getAllCustomer();

​

<select   resultType="com.le.domain.Customer">
	select * from customer;
</select>

​

@Test
public void test(){
	SqlSession sqlSession = MybatisUtils.openSession();
	CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
	Map<Integer, Customer> allCustomer = customerMapper.getAllCustomer();
	for(Integer integer:allCustomer.keySet())
	{
		System.out.println("key="+integer+" value="+allCustomer.get(integer));
	}
	sqlSession.close();
}

​
​

resultMap

• 只有在写输出时使用的都是resultType
• 但是resultType要求必须得要字段名称和数据库当中的名称一致时才能有值,否则为null
• 如果sql查询字段名和pojo的属性名不一致，可以通过resultMap将字段名和属性名作一个对应关系
• 表名与domain

package com.le.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Setter@Getter@ToString
public class Customer {
    private Integer cust_ids;
    private String cust_names;
    private String cust_professions;
    private String cust_phones;
    private String email;
}

​

<resultMap   type="Customer">
	<id column="cust_id" property="cust_ids"/>
	<result column="cust_name" property="cust_names"/>
	<result column="cust_profession" property="cust_professions"/>
	<result column="cust_phone" property="cust_phones"/>
	<result column="email" property="email"/>
</resultMap>

<select   resultMap="customerMap">
	select * from customer where cust_id=#{id}
</select>

​

@Test
public void test(){
	SqlSession sqlSession = MybatisUtils.openSession();
	CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
	Customer customer = customerMapper.getCustomer(2);
	System.out.println(customer);
	sqlSession.close();
}

​
​
​

多表操作

ManyToOne

关系表

查询

分步查询

第一步 先查出所有的订单

<resultMap   type="Order">
	<id property="order_id" column="order_id"/>
	<result property="order_name" column="order_name"/>
	<result property="order_num" column="order_name"/>
	<!--分步查询-->
	<association property="customer" javaType="Customer"
				 select="com.le.mapper.CustomerMapper.getCustomerWithId"
				 column="cust_id">
	</association>
</resultMap>

<select   resultMap="myOrder">
	select * from `order`
</select>				

第二步 根据id查出对应客户

<mapper namespace="com.le.mapper.CustomerMapper">
	<!--根据id获取客户-->
	<select   resultType="com.le.domain.Customer">
		SELECT * from customer WHERE cust_id = #{id}
	</select>
</mapper>		

​

左连接查询

查询所有的订单及订单所对应的客户

• 左连接
• 把左边表的数据全部查出,右边表只查出满足条件的记录

应对sql

SELECT * FROM `order` as o LEFT JOIN customer as c on o.cus_id = c.cust_id;

建立domain

package com.le.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Setter@Getter@ToString
public class Order {
    private Integer order_id;
    private String order_name;
    private String order_num;
    private Customer customer;
}

建立Mapping映射

<resultMap   type="Order">
    <id property="order_id" column="order_id"/>
    <result property="order_name" column="order_name"/>
    <result property="order_num" column="order_name"/>
    <!--关联对象赋值-->
    <association property="customer" javaType="Customer">
        <id property="cust_id" column="cust_id"/>
        <result property="cust_name" column="cust_name"/>
        <result property="cust_profession" column="cust_profession"/>
        <result property="cust_phone" column="cust_phone"/>
        <result property="email" column="email"/>
    </association>
</resultMap>

<!--查询所有订单-->
<select   resultMap="orderMap">
    SELECT * from `order` as o LEFT JOIN `customer` c on o.cust_id = c.cust_id;
</select>	

​

测试类

​

@Test
public void test(){
    SqlSession sqlSession = MybatisUtils.openSession();
    OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    List<Order> allOrders = orderMapper.getAllOrders();
    for (Order order : allOrders) {
        System.out.println(order);
    }
    sqlSession.close();
}

分部查询懒加载

​

<!--延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。-->
<setting name="lazyLoadingEnabled" value="true"/>
<!--当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载-->
<setting name="aggressiveLazyLoading" value="false"/>
<!--指定哪个对象的方法触发一次延迟加载。-->
<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode"/>

添加

添加客户

​

<!--保存客户-->
<insert   parameterType="Customer"
        useGeneratedKeys="true"
        keyColumn="cust_id"
        keyProperty="cust_id">
    insert into `customer`(cust_name,cust_profession,cust_phone,email)
    values (#{cust_name},#{cust_profession},#{cust_phone},#{email})
</insert>

设置关系（外键没有赋值上）

@Test
public void test(){
	SqlSession sqlSession = MybatisUtils.openSession();
	CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
	OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
	
	Customer customer = new Customer();
	customer.setCust_name("新客户001");
	customer.setCust_phone("137090909090");
	customer.setEmail("123123@163.com");
	customer.setCust_profession("新职业001");

	/*先添加客户  获取客户生成的id  再去添加订单*/
	customerMapper.insertCustomer(customer);

	Order order = new Order();
	order.setOrder_name("新订单001");
	order.setOrder_num("20000001001");
	/*设置关系 */
	order.setCustomer(customer);
	System.out.println(customer);
	/*保存订单*/
	orderMapper.insertOrder(order);
	sqlSession.commit();
	sqlSession.close();
}

添加订单

<!--保存订单-->
<!-- useGeneratedKeys="true"把新增加的主键赋值到自己定义的keyProperty（id）中 -->
<insert   
		parameterType="Order"
        useGeneratedKeys="true"
        keyColumn="order_id"
        keyProperty="order_id">
    insert into `order`(order_name,order_num,cust_id)
    values (#{order_name},#{order_num},#{customer.cust_id})
</insert>

OnToMany

查询

查询客户和客户订单

sql语句

SELECT * FROM customer as c LEFT JOIN `order` as o  on c.cust_id = o.cust_id;

映射

​

<resultMap   type="Customer">
    <id column="cust_id" property="cust_id"/>
    <result column="cust_name" property="cust_name"/>
    <result column="cust_profession" property="cust_profession"/>
    <result column="cust_phone" property="cust_phone"/>
    <result column="email" property="email"/>
    <collection property="orders" ofType="Order">
        <id column="order_id" property="order_id"/>
        <id column="order_name" property="order_name"/>
        <id column="order_num" property="order_num"/>
    </collection>
</resultMap>
<!--查询所有客户-->
<select   resultMap="custMap">
    select* from `customer` as c LEFT JOIN `order` as o ON c.cust_id = o.cust_id;
</select>

测试

​

@Test
public void test4(){
    /*查询所有客户*/
    SqlSession sqlSession = MybatisUtils.openSession();
    CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
    List<Customer> allCustomers = customerMapper.getAllCustomers();
    for (Customer allCustomer : allCustomers) {
        System.out.println(allCustomer);
    }
    sqlSession.close();
}

添加

保存数据

/*保存客户*/
public void insertCustomer(Customer customer);

​

<!--保存客户-->
<insert   
		parameterType="Customer"
        useGeneratedKeys="true"
        keyColumn="cust_id"
        keyProperty="cust_id">
    insert into `customer`(cust_name,cust_profession,cust_phone,email)
    values (#{cust_name},#{cust_profession},#{cust_phone},#{email})
</insert>

​

/*保存订单*/
public void insertOrder(Order order);

​

<!--保存订单-->
<!-- useGeneratedKeys="true"把新增加的主键赋值到自己定义的keyProperty（id）中 -->
<insert   
		parameterType="Order"
        useGeneratedKeys="true"
        keyColumn="order_id"
        keyProperty="order_id">
    insert into `order`(order_name,order_num,cust_id)
    values (#{order_name},#{order_num},#{customer.cust_id})
</insert>	

维护外键

​

/*更新与客户的关系*/
public void updateCustId(@Param("orderId") Integer orderId, @Param("custId") Integer custId);		

<!--更新关系-->
<update id="updateCustId">
    update `order` set `cust_id`=#{custId} where `order_id`=#{orderId}
</update>

管理关系

@Test
public void test5(){
    SqlSession sqlSession = MybatisUtils.openSession();
    CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
    OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    Customer customer = new Customer();
    customer.setCust_name("新客户");

    Order order1 = new Order();
    order1.setOrder_name("订单2");

    Order order2 = new Order();
    order2.setOrder_name("订单2");

    customer.getOrders().add(order1);
    customer.getOrders().add(order2);

    /*保存数据*/
    customerMapper.insertCustomer(customer);
    orderMapper.insertOrder(order1);
    orderMapper.insertOrder(order2);

    /*更新关系*/
    for (Order order : customer.getOrders()) {
        orderMapper.updateCustId(order.getOrder_id(),customer.getCust_id());
    }
    sqlSession.commit();
    sqlSession.close();
}			

删除

• 删除时一定要先打破关系再做删除操作

  示例

/*根据id删除客户*/
public void deleteCustomer(Integer id);		

​

<!--根据id删除客户-->
<delete id="deleteCustomer">
    delete from `customer` where cust_id=#{id}
</delete>

/*打破跟客户关系*/
public void updateRelationCustomer(Integer custId);

<!--打破跟客户关系-->
<update id="updateRelationCustomer">
    update `order` set cust_id=null where cust_id=#{custId}
</update>	

​

@Test
public void test(){
    SqlSession sqlSession = MybatisUtils.openSession();
    CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
    OrderMapper orderMapper = sqlSession.getMapper(OrderMapper.class);
    //一对多删除之前  要先打破关系
    orderMapper.updateRelationCustomer(36);
    /*删除客户*/
    customerMapper.deleteCustomer(36);
    sqlSession.commit();
    sqlSession.close();
}

​
​
​

ManyToMany

关系表

​

package com.le.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

import java.util.ArrayList;
import java.util.List;

@Setter@Getter@ToString
public class Teacher {
    private Integer teacher_id;
    private String teacher_name;
    private List<Student> students = new ArrayList<>();
}

package com.le.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Setter@Getter @ToString
public class Student {
    private Integer stu_id;
    private String stu_name;
}

查询

分步查询

查询出指定的老师

public interface TeacherMapper {
    /*查询指定的老师*/
    public Teacher getTeacherWithId(Integer id);
}

<!--查询指定的老师-->
<select   resultMap="teacherMap2">
    SELECT * from teacher WHERE teacher_id = #{id};
</select>
<resultMap   type="Teacher">
    <id column="teacher_id" property="teacher_id"/>
    <result column="teacher_name" property="teacher_name"/>
    <collection property="students" ofType="Student"
                select="com.le.mapper.StudentMapper.getStuByTeach"
                column="teacher_id"/>
</resultMap>	

根据老师id查询出所有学生

public interface StudentMapper {
    /*根据老师id查询学生*/
    public List<Student>getStuByTeach(Integer id);
}

​

<select   resultType="com.le.domain.Student">
      SELECT * from student where stu_id in(SELECT stu_id from stu_teacher_rel where teacher_id = #{id})
</select>		

​

查询

​

@Test
public void test2(){
    SqlSession sqlSession = MybatisUtils.openSession();
    TeacherMapper teacherMapper = sqlSession.getMapper(TeacherMapper.class);
    Teacher teacher = teacherMapper.getTeacherWithId(2);
    System.out.println(teacher);
    sqlSession.close();
}		

左边接查询

public interface TeacherMapper {
    /*查询老师  并且把关联的学生也查出来*/
    public List<Teacher>getAllTeachers();
}

​

<mapper namespace="com.le.mapper.TeacherMapper">
    <!-- 查询老师  并且把关联的学生也查出来 -->
    <resultMap   type="Teacher">
        <id column="teacher_id" property="teacher_id"/>
        <result column="teacher_name" property="teacher_name"/>
        <collection property="students" javaType="list" ofType="Student">
            <id column="stu_id" property="stu_id"/>
            <result column="stu_name" property="stu_name"/>
        </collection>
    </resultMap>

    <select   resultMap="teacherMap">
        SELECT*FROM teacher as t
        LEFT JOIN stu_teacher_rel as r on t.teacher_id = r.teacher_id
        LEFT JOIN student as s ON r.stu_id = s.stu_id
    </select>
</mapper>

添加

添加老师

/*保存老师*/
public void insertTeacher(Teacher teacher);

<!--保存老师-->
<insert   parameterType="Teacher"
        useGeneratedKeys="true"
        keyProperty="teacher_id"
        keyColumn="teacher_id">
    insert into`teacher`(teacher_name) values (#{teacher_name})
</insert>

添加学生

/*保存学生*/
public void insertStudent(Student student);

<!--保存学生-->
<insert   parameterType="Student"
        useGeneratedKeys="true"
        keyProperty="stu_id"
        keyColumn="stu_id">
    insert into `student` (stu_name) values (#{stu_name})
</insert>	

添加中间关系

/*插入关系表*/
public void insertRelation(@Param("stuId") Integer stuId, @Param("teacherId") Integer teacherId);

<!-- 插入关系表 -->
<insert id="insertRelation">
    insert into stu_teacher_rel (stu_id,teacher_id) values (#{stuId},#{teacherId})
</insert>	

动态sql

什么是动态sql

​ 通过mybatis提供的各种标签方法实现动态拼接sql。

if标签

需求

根据客户名和职业查询客户

/*根基客户名称和职业来查询*/
public List<Customer> getCustomer(@Param("name") String name, @Param("profession") String profession);

<select   
		resultType="com.le.domain.Customer">
	select from customer where cust_name=#{name} ad cust_profession=#{profession}
</select>	

存在问题

• 有可能传入的名称或级别为空
• 可以使用if标签来进行判断
• 如果前一个条件后面多一个and执行就会报错(也就是说需要将and分布合理)

<!--if标签:符合条件会自动把if中的内容拼接到sql之后-->
<select   						resultType="com.le.domain.Customer">
    select * from `customer` where
	<if test="name != null and name != ''">
	  `cust_name`=#{name}
	</if>
	<if test="profession != null and profession!=''">
	  and `cust_profession`=#{profession}
	</if>
</select>

Where标签

• 去掉第一个前And

<!--where标签:会自动生成和删除where  
	还能删除where后第1个and  
	条件前and去掉 -->
<select  
	resultType="com.le.domain.Customer">
	select * from `customer`
	<where>
		<if test="name != null and name != ''">
		  and `cust_name`=#{name}
		</if>
		<if test="profession != null and profession!=''">
		  and `cust_profession`=#{profession}
		</if>
	</where>
</select>

trim标签

<!--trim标签:
   prefix:设置前缀  在第一个条件之前加一个前缀
   prefixOverrides: 条件前缀覆盖 把第一个条件之前的and变成空
   suffix: 设置后缀 在最后一个条件之后加一个后缀
   suffixOverrides: 条件后缀覆盖  把最后一个条件之后的and变成空
-->
<select  
	resultType="com.le.domain.Customer">
    select * from `customer`
    <trim prefix="where" prefixOverrides="and" suffixOverrides="and" >
        <if test="name != null and name != ''">
            and `cust_name`=#{name} and
        </if>
        <if test="profession != null and profession!=''">
           `cust_profession`=#{profession} and
        </if>
    </trim>
</select>

choose标签

<!--
    choose   只要第一个条件满足,后面条件都不执行
    when
    otherwise
-->
<select   resultType="com.le.domain.Customer">
    <include refid="selectID"/>
    <where>
        <choose>
            <when test="profession != null and profession!=''">
                `cust_profession`=#{profession}
            </when>
            <when test="name != null and name != ''">
                `cust_name`=#{name}
            </when>
            <otherwise>1=1</otherwise>
        </choose>
    </where>
</select>

set标签

<!--
    set标签:会添加update 中 set  并且它会把最后一个,去掉
-->
<!--更新客户-->
<update id="updateCustomer">
    update `customer`
    <set>
        <if test="cust_name != null and cust_name !='' ">
            cust_name=#{cust_name},
        </if>
        <if test="cust_profession != null and cust_profession !='' ">
            cust_profession=#{cust_profession},
        </if>
    </set>
    where cust_id=#{cust_id}
</update>

foreach标签

查询条件值为指定的值当中

​

<select  
	resultType="com.le.domain.Customer">
	<include refid="selectID"/>where `cust_id` in(2,3,5,6);
</select>
<!--注意 在include当中定义的property 取的时候 要使用${} -->
<sql id="selectID">
	<choose>
		<when test="${lk} == 2">
			select cust_name from `customer`
		</when>
		<otherwise>
			select * from `customer`
		</otherwise>
	</choose>
</sql>

​

给定的值可以以三种形式给出

数组

​

/*根据id查询指定的客户 多个客户*/
public List<Customer> getCustomers(Integer[] array);

@Test
public void test(){
	SqlSession sqlSession = MybatisUtils.openSession();
	CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
	Integer[] ids = new Integer[4]{2,3,5,6};
	List<Customer> customers = customerMapper.getCustomers(ids);
	for (Customer customer : customers) {
		System.out.println(customer);
	}
	sqlSession.close();
}

<select   
	parameterType="Integer[]" resultType="com.le.domain.Customer">
	select * from `customer` where `cust_id` in
	<foreach collection="array" open="(" close=")" separator="," item="item">
		#{item}
	</foreach>
</select>

​

List

<select   
	parameterType="List" resultType="com.le.domain.Customer">
	select * from `customer` where `cust_id` in
	<foreach collection="list" open="(" close=")" separator="," item="item">
		#{item}
	</foreach>
</select>

@Test
public void test(){
	SqlSession sqlSession = MybatisUtils.openSession();
	CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);
	ArrayList<Integer> list = new ArrayList<>();
	list.add(2);
	list.add(3);
	list.add(4);
	list.add(6);
	List<Customer> customers = customerMapper.getCustomers(list);
	for (Customer customer : customers) {
		System.out.println(customer);
	}
	sqlSession.close();
}

​

包装类VO

​ 创建Vo

package com.le.domain;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.util.List;

@Setter@Getter@ToString
public class QueryVo {
    private Integer[] ids;
    private List<Integer> idList;
}			

​
​ 测试

<select   
	parameterType="QueryVo" resultType="com.le.domain.Customer">
	<include refid="selectID"/> where `cust_id` in
	<foreach collection="idList" open="(" close=")" separator="," item="ids">
		#{ids}
	</foreach>
</select>

@Test
public void test(){
	SqlSession sqlSession = MybatisUtils.openSession();
	CustomerMapper customerMapper = sqlSession.getMapper(CustomerMapper.class);

	QueryVo queryVo = new QueryVo();
	queryVo.setIds(new Integer[]{2,3,4,5});
	ArrayList<Integer> arrayList = new ArrayList<>();
	arrayList.add(2);
	arrayList.add(3);
	arrayList.add(4);
	arrayList.add(6);
	queryVo.setIdList(arrayList);
	List<Customer> customers = customerMapper.getCustomers(queryVo);
	for (Customer customer : customers) {
		System.out.println(customer);
	}
	sqlSession.close();
}

bind标签

<!--
    bind标签:可以取出传入的值,重新处理, 赋值给别外一个值
 -->
<select   resultType="Customer">
    <bind name="newId" value="id+2"/>
    <include refid="selectID">
        <property name="lk" value="2"/>
    </include>  where cust_id=#{newId}
</select>

Sql片段

• Sql中可将重复的sql提取出来，使用时用include引用即可，最终达到sql重用的目的。

<select   resultType="Customer">
    <include refid="selectID">
        <property name="lk" value="2"/>
    </include>  where cust_id=#{id}
</select>

<!--注意 在include当中定义的property 取的时候 要使用${} -->
<sql id="selectID">
    <choose>
        <when test="${lk} == 2">
            select cust_name from `customer`
        </when>
        <otherwise>
            select * from `customer`
        </otherwise>
    </choose>
</sql>

​

缓存

一级缓存

缓存介绍

• MyBatis中使用缓存来提高其性能。
• 当查询数据时, 会先从缓存中取出数据,如果缓存中没有,再到数据库当中查询
• MyBatis中的缓存分为两种：一级缓存和二级缓存
• 一级缓存是sqlSession级别的，二级缓存是mapper级别的

一级缓存

• 本地缓存 (默认开启)
• 在sqlSession没有关闭之前,再去查询时, 会从缓存当中取出数据,不会重新发送新的sql

一级缓存失效

• 如果在查询之前,执行了增删改 缓存就会失效
• 手动清空缓存
• 如果两次的查询条件不一样,缓存也会失效
• 如果两个查询在不同的sqlsession当中

二级缓存

二级缓存介绍

​ 全局作用域缓存 一个namespace对应一个缓存
​ 如果会话关闭,一级缓存的数据会被保存到二级缓存中
​ 不同namespace查出的数据 ,会放到自己对应的缓存中
​ 现在默认也是打开的

二级缓存使用步骤

​ 1.确保在配置文件当中开启二级缓存
​ 2.在对应的mapper中添加cache标签

eviction
	回收策略
flushInterval
	刷新间隔
	默认不清空
readOnly
	是否只读
	true
		告诉Mybatis是只读操作,不去修改数据
		Mybatis为了加快获取速度,会直接将缓存的引用将给用, 不安全, 速度快
	false
		非只读,有可能修改数据
		Mybatis会利用序列化和反序列化复制一份给你   速度慢些
size
	可以存放多少个元素
type
	可以用来指定自定义的缓存

​ 3.POJO需要实现Serializable接口

注意事项

• 查询的数据都会先放到一级缓存当中
• 只有会话关闭,一级缓存中的数据才会转称到二级缓存中

缓存相关属性

cacheEnabled
	只能控制二级缓存的开关
select中useCache
	控制的也是二级缓存是否使用
增删改标签中flushCache
	一级和二级都会被清空
	增删改flushCache默认为true
	查询flushCache默认为false
sqlSession.clearCache()
	只清除当前session的一级缓存
localCacheScope
	本地缓存作用域
	取值
		SESSION
		STATEMENT
	STATEMENT可以使用它禁用缓存

缓存使用顺序

• 先到二级缓存当中查找
• 如果二级缓存中没有,就去找一级缓存
• 如果一级缓存中也没有就去到数据库当中查询