MyBatis核心技术

1.MyBatis_简介

2.MyBatis_下载

3.MyBatis_HelloWorld

(environments配置环(配置数据源)&SqlSessionFactory(通过sqlSessionFactoryBuilder()获取sqlSessionFactory.openSession()获取sqlSession.selectOne(“selectEmp”,1)可以直接执行已经映射的sql语句)&SqlSession&使用resultType实现(返回的数据类型)&mappers配置分析(#{id}从传递过来得到参数中取出id值，将写好的sql映射文件注册到全局mappers中，resource=”EmployeeMapper.xml”)&使用typeAliases配置别名)

mybatis-config.xml

EmployeeMapper.xml

	
		select id,last_name lastName,email,gender from tbl_employee where id = #{id}
	

log4j.xml

package com.atguigu.mybatis.bean;

public class Employee {
	
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
	
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", gender=" + gender + "]";
	}
	
	

}

package com.atguigu.mybatis.dao;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapper {
	
	public Employee getEmpById(Integer id);

}

package com.atguigu.mybatis.test;

import java.io.IOException;
import java.io.InputStream;

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.junit.Test;

import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.EmployeeMapper;

/**
 * 1、接口式编程
 * 	原生：		Dao		====>  DaoImpl
 * 	mybatis：	Mapper	====>  xxMapper.xml
 * 
 * 2、SqlSession代表和数据库的一次会话；用完必须关闭；
 * 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
 * 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。
 * 		（将接口和xml进行绑定）
 * 		EmployeeMapper empMapper =	sqlSession.getMapper(EmployeeMapper.class);
 * 5、两个重要的配置文件：
 * 		mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
 * 		sql映射文件：保存了每一个sql语句的映射信息：
 * 					将sql抽取出来。	
 * 
 * 
 * @author lfy
 *
 */
public class MyBatisTest {
	

	public SqlSessionFactory getSqlSessionFactory() throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		return new SqlSessionFactoryBuilder().build(inputStream);
	}

	/**
	 * 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
	 * 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。 
	 * 3、将sql映射文件注册在全局配置文件中
	 * 4、写代码：
	 * 		1）、根据全局配置文件得到SqlSessionFactory；
	 * 		2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
	 * 			一个sqlSession就是代表和数据库的一次会话，用完关闭
	 * 		3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
	 * 
	 * @throws IOException
	 */
	@Test
	public void test() throws IOException {

		// 2、获取sqlSession实例，能直接执行已经映射的sql语句
		// sql的唯一标识：statement Unique identifier matching the statement to use.
		// 执行sql要用的参数：parameter A parameter object to pass to the statement.
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

		SqlSession openSession = sqlSessionFactory.openSession();
		try {
			Employee employee = openSession.selectOne(
					"com.atguigu.mybatis.EmployeeMapper.selectEmp", 1);
			System.out.println(employee);
		} finally {
			openSession.close();
		}

	}

	@Test
	public void test01() throws IOException {
		// 1、获取sqlSessionFactory对象
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		// 2、获取sqlSession对象
		SqlSession openSession = sqlSessionFactory.openSession();
		try {
			// 3、获取接口的实现类对象
			//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			Employee employee = mapper.getEmpById(1);
			System.out.println(mapper.getClass());
			System.out.println(employee);
		} finally {
			openSession.close();
		}

	}

}

4.MyBatis_接口式编程

(MyBatis注解配置(getSqlSessionFactory(),openSession.getMapper(EmployeeMappers.class)，mapper.getEmpById(1)象)&命名空间：Namespace (namespace指定接口的全类名，select的id要与方法进行绑定，通过生成代理对象，通过代理对象进行增删改查)&)

5.MyBatis_小结(1)

(Connection(非线程安全，不能写在成员变量里，每次使用获取新的对象)&)

6.MyBatis_全局配置文件_引入dtd约束

(为Web 资源设置安全约束(window perferences xm xml Catalog 添加进Mybatis的约束，以后在xml文件中就会有提示)&)

7.MyBatis_全局配置文件_properties_引入外部配置文件

(修改db.properties文件(通过url获取网络或者类路径下的配置文件，类路径通过resource引入，com/)&)

8.MyBatis_全局配置文件_settings_运行时行为设置

(用驼峰法命名属性(在settings中设置，mapUnderscoreToCamelCase不用起别名)&使用resultType实现&alias标签的解析&)

9.MyBatis_全局配置文件_typeAliases_别名

(typeAliases类型命名( ，默认别名为类名小写,package name=”” 为包下的类批量起别名。通过@Alias(“”)为类指定类的别名)&)

10.MyBatis_全局配置文件_typeHandlers_类型处理器简介

(typeHandlers类型处理器(Java类型与数据库类型一一对应，)&)

11.MyBatis_全局配置文件_plugins_插件简介

(plugins配置分析(Executor执行器的方法，query，commit，update，rollback可以通过插件机制在executor执行增删改前执行默认的行为，ParameterHandler参数处理器，预编译需要设置参数，ResultSetHandler结果集处理器，StatementHandler对sql语句进行处理，插件可以拦截四大对象的方法)&)

12.MyBatis_全局配置文件_enviroments_运行环境

( default访问修饰符(通过environments的default指定某个环境进行切换)&DataSource(id是environment唯一标识，)&配置多个连接数据库环境(可以配置多个environment标签，environment中有和两种标签，JDBC事务与Managed使用J2EE容器的事物处理方式，dataSource type=”POOLED”使用连接池技术)&)

13.MyBatis_全局配置文件_databaseIdProvider_多数据库支持

(databaseIdProvider数据库厂商标识(为不同数据库厂商起别名 )&在SQL映射的id值相同的情况下有无databaseId的优先级判断(，只需要告诉mysql，对应的sql语句是在什么环境下的))

14.MyBatis_全局配置文件_mappers_sql映射注册

(使用Mapper接口对查询的数据进行分页(resource引用类路径下的sql映射文件，url应用网络或者磁盘路径下的资源，class直接引用接口，接口全类名，xml必须和接口放在同一目录下并且文件名一致，也可以直接将sql语句写在接口上，@Select,重要的需要映射文件 批量注册)&)

15.MyBatis_小结(2)

(@Configuration创世纪(映射文件的中标签要有一定的前后顺序，里面的一些标签可以没有)&)

EmployeeMapper.xml

 	
		select * from tbl_employee where id = #{id}
	
	
		select * from tbl_employee where id = #{id}
	
	
		select EMPLOYEE_ID id,LAST_NAME	lastName,EMAIL email 
		from employees where EMPLOYEE_ID=#{id}
	

dbconfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=123456

orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456

mybatis-config.xml

log4j.xml

package com.atguigu.mybatis.bean;

import org.apache.ibatis.type.Alias;

@Alias("emp")
public class Employee {
	
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
	
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", gender=" + gender + "]";
	}
	
	

}

package com.atguigu.mybatis.dao;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapper {
	
	public Employee getEmpById(Integer id);

}

package com.atguigu.mybatis.dao;

import org.apache.ibatis.annotations.Select;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapperAnnotation {
	
	@Select("select * from tbl_employee where id=#{id}")
	public Employee getEmpById(Integer id);
}

package com.atguigu.mybatis.test;

import java.io.IOException;
import java.io.InputStream;

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.junit.Test;

import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.EmployeeMapper;
import com.atguigu.mybatis.dao.EmployeeMapperAnnotation;

/**
 * 1、接口式编程
 * 	原生：		Dao		====>  DaoImpl
 * 	mybatis：	Mapper	====>  xxMapper.xml
 * 
 * 2、SqlSession代表和数据库的一次会话；用完必须关闭；
 * 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
 * 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。
 * 		（将接口和xml进行绑定）
 * 		EmployeeMapper empMapper =	sqlSession.getMapper(EmployeeMapper.class);
 * 5、两个重要的配置文件：
 * 		mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
 * 		sql映射文件：保存了每一个sql语句的映射信息：
 * 					将sql抽取出来。	
 * 
 * 
 * @author lfy
 *
 */
public class MyBatisTest {
	

	public SqlSessionFactory getSqlSessionFactory() throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		return new SqlSessionFactoryBuilder().build(inputStream);
	}

	/**
	 * 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
	 * 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。 
	 * 3、将sql映射文件注册在全局配置文件中
	 * 4、写代码：
	 * 		1）、根据全局配置文件得到SqlSessionFactory；
	 * 		2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
	 * 			一个sqlSession就是代表和数据库的一次会话，用完关闭
	 * 		3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
	 * 
	 * @throws IOException
	 */
	@Test
	public void test() throws IOException {

		// 2、获取sqlSession实例，能直接执行已经映射的sql语句
		// sql的唯一标识：statement Unique identifier matching the statement to use.
		// 执行sql要用的参数：parameter A parameter object to pass to the statement.
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

		SqlSession openSession = sqlSessionFactory.openSession();
		try {
			Employee employee = openSession.selectOne(
					"com.atguigu.mybatis.EmployeeMapper.selectEmp", 1);
			System.out.println(employee);
		} finally {
			openSession.close();
		}

	}

	@Test
	public void test01() throws IOException {
		// 1、获取sqlSessionFactory对象
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		// 2、获取sqlSession对象
		SqlSession openSession = sqlSessionFactory.openSession();
		try {
			// 3、获取接口的实现类对象
			//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			Employee employee = mapper.getEmpById(1);
			System.out.println(mapper.getClass());
			System.out.println(employee);
		} finally {
			openSession.close();
		}

	}
	
	@Test
	public void test02() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		try{
			EmployeeMapperAnnotation mapper = openSession.getMapper(EmployeeMapperAnnotation.class);
			Employee empById = mapper.getEmpById(1);
			System.out.println(empById);
		}finally{
			openSession.close();
		}
	}
	
	
}

16.MyBatis_映射文件_增删改查

(＜parameter＞标签和其处理类(parameterType参数类型可以指定全类名或者别名，#{email}取出对象中的属性值)&＜sql:update＞标签(更新可以不写parameter，mybatis允许增删改直接定义以下类型的返回值 Integer，Long，Boolean)&)

17.MyBatis_映射文件_insert_获取自增主键的值

(sqlSessionFactory创建(ssqlSessionFactory.openSession(true)自动提交，)&获取后一个自动生成的ID值的函数(useGeneratedKeys=”true” keyProperty=”id” 指定属性对应的主键值,Oracle不支持自增)&)

18.MyBatis_映射文件_insert_Oracle使用序列生成主键演示

19.MyBatis_映射文件_insert_获取非自增主键的值_selectKey

(序列对象(oracle序列就是自增， 查询主键的sql语句，写sql不能带分号)&)

20.MyBatis_映射文件_参数处理_单个参数&多个参数&命名参数

(　参数（Parameters）(mybatis单个参数不会做特殊处理#{absa}，多个参数时mybatis会封装成一个Map，#{param1}获取指定的key，命名参数在接口方法上test(@Param(“id”) Integer id，@Param(“lastName”)String lastName) #{id})¶meters 指令支持的参数类型&请求参数与返回对象()&)

21.MyBatis_映射文件_参数处理_POJO&Map&TO

(POJO映射(直接传入POJO，通过#{属性名}获取POJO的值，也可以直接传入Map test(Map map)，#{key}取出key的值)&)

22.MyBatis_映射文件_参数处理_参数封装扩展思考

(ids日志源(test(@Param(“e”)Employee emp)e.lastName  test(List ids) 如果是数组或者集合类型会特殊处理，collection或者list或者array作为key #{list[0})&模糊查询((%ss%))&)

mybatis-config.xml

log4j.xml

dbconfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=123456

orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456

DepartmentMapper.xml

	
	
		select id,dept_name departmentName from tbl_dept where id=#{id}
	
	
	
	
	
	 
	
	
		
		
		
		
			
			
			
			
			
		
	
	
	
		SELECT d.id did,d.dept_name dept_name,
				e.id eid,e.last_name last_name,e.email email,e.gender gender
		FROM tbl_dept d
		LEFT JOIN tbl_employee e
		ON d.id=e.d_id
		WHERE d.id=#{id}
	
	
	
	
		
		
		
	
	
	
		select id,dept_name from tbl_dept where id=#{id}
	
	
	

EmployeeMapper.xml

 
 	
 	
 		select * from tbl_employee where last_name like #{lastName}
 	
 
 	
 	
 		select * from tbl_employee where id=#{id}
 	
 
	
	
	
		select * from tbl_employee where last_name like #{lastName}
	

 	
 	
 		select * from ${tableName} where id=${id} and last_name=#{lastName}
 	
 
 	
 	
 		select * from tbl_employee where id = #{id} and last_name=#{lastName}
 	
 	
 	
		select * from tbl_employee where id = #{id}
	
	
		select * from tbl_employee where id = #{id}
	
	
		select EMPLOYEE_ID id,LAST_NAME	lastName,EMAIL email 
		from employees where EMPLOYEE_ID=#{id}
	
	
	
	
	
		insert into tbl_employee(last_name,email,gender) 
		values(#{lastName},#{email},#{gender})
	
	
	
	
		
		
			
			
			select EMPLOYEES_SEQ.nextval from dual 
			
		
		
		
		
		insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
		values(#{id},#{lastName},#{email}) 
		
	
	
	
	
		update tbl_employee 
		set last_name=#{lastName},email=#{email},gender=#{gender}
		where id=#{id}
	
	
	
	
		delete from tbl_employee where id=#{id}
	
	
	

EmployeeMapperPlus.xml

	
	
		
		
		
		
		
		
		
	
	
	
	
	
		select * from tbl_employee where id=#{id}
	
	
	
	 
	 
	
	
		
		
		
		
		
	


	
	
		
		
		
		
		
		
			
			
		
	
	
	
		SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
		d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
		WHERE e.d_id=d.id AND e.id=#{id}
	
	
	
	 
	 
	 
	 	
	 	
	 	
	 	
	 	
 		
 		
	 
	 
	 
	 	select * from tbl_employee where id=#{id}
	 	
	 		and 1=1
	 	
	 
	 
	 
	
	
	
	
	
		select * from tbl_employee where d_id=#{deptId}
	
	
	
	
	
	
	 
	 	
	 	
	 	
	 	
	 	
	 	
	 		
	 		
	 			
		 		
	 		
	 		
	 		
		 		
			 	
			 	
			 	
	 		
	 	
	 

package com.atguigu.mybatis.bean;

import java.util.List;

public class Department {
	
	private Integer id;
	private String departmentName;
	private List emps;
	
	
	
	public List getEmps() {
		return emps;
	}
	public void setEmps(List emps) {
		this.emps = emps;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName
				+ "]";
	}
	
	

}

package com.atguigu.mybatis.bean;

import org.apache.ibatis.type.Alias;

@Alias("emp")
public class Employee {
	
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
	private Department dept;
	
	public Employee() {
		super();
	}
	
	public Employee(Integer id, String lastName, String email, String gender) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
	}
	
	
	

	public Department getDept() {
		return dept;
	}

	public void setDept(Department dept) {
		this.dept = dept;
	}

	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", gender=" + gender + "]";
	}
	
	

}

package com.atguigu.mybatis.dao;

import com.atguigu.mybatis.bean.Department;

public interface DepartmentMapper {
	
	public Department getDeptById(Integer id);
	
	public Department getDeptByIdPlus(Integer id);

	public Department getDeptByIdStep(Integer id);
}

package com.atguigu.mybatis.dao;

import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapper {
	
	//多条记录封装一个map：Map:键是这条记录的主键，值是记录封装后的javaBean
	//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
	@MapKey("lastName")
	public Map getEmpByLastNameLikeReturnMap(String lastName);
	
	//返回一条记录的map；key就是列名，值就是对应的值
	public Map getEmpByIdReturnMap(Integer id);
	
	public List getEmpsByLastNameLike(String lastName);
	
	public Employee getEmpByMap(Map map);
	
	public Employee getEmpByIdAndLastName(@Param("id")Integer id,@Param("lastName")String lastName);
	
	public Employee getEmpById(Integer id);

	public Long addEmp(Employee employee);

	public boolean updateEmp(Employee employee);

	public void deleteEmpById(Integer id);
	
}

package com.atguigu.mybatis.dao;

import org.apache.ibatis.annotations.Select;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapperAnnotation {
	
	@Select("select * from tbl_employee where id=#{id}")
	public Employee getEmpById(Integer id);
}

package com.atguigu.mybatis.dao;

import java.util.List;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapperPlus {
	
	public Employee getEmpById(Integer id);
	
	public Employee getEmpAndDept(Integer id);
	
	public Employee getEmpByIdStep(Integer id);
	
	public List getEmpsByDeptId(Integer deptId);

}

23.MyBatis_源码分析_参数处理_参数封装map的过程

()

24.MyBatis_映射文件_参数处理_#与$取值区别

(预编译(#{}会进行预编译处理，${}直接将值拼到sql中会有sql注入风险，大多分库分表的情况下，表名不能使用占位符需要使用${year}_salary,order by ${f_name} asc ${order})&防止SQL注入&分库分表解决方案&)

25.MyBatis_映射文件_参数处理_#取值时指定参数相关规则

(插入null值的第 1种方法——JdbcType(mybatis对于所有null映射为jdbcType为OTHER类型，#{jdbcType=null}处理null值，也可以全局配置 为null的时候oracle识别)&)

26.MyBatis_映射文件_select_返回List

(使用resultType实现(如果返回值为List，resultType要写集合中封装的类型，mybatis会自动封装集合返回)&)

27.MyBatis_映射文件_select_记录封装map

(主键(返回类型为map，resultType为map类型单个记录，多条记录封装一个map，Map ，resultType始终是封装集合中元素的类型，接口上使用@MapKey(“id”)告诉Mybatis封装map时使用哪个属性做为主键)&)

28.MyBatis_映射文件_select_resultMap_自定义结果映射规则

(＜resultMap＞标签(如果列名与属性名不一致的情况下，resultMap=”MyEmp”可以自定义映射规则与resultType只能使用一个，@Alias(“emp”) )& COLUMN命令(指定哪一列对应哪一个property，非主键使用result定义)&)

29.MyBatis_映射文件_select_resultMap_关联查询_环境搭建

(使用外键需要注意的问题(外键级联属性， )&)

30.MyBatis_映射文件_select_resultMap_关联查询_级联属性封装结果

(联合查询(指定javaBean中的属性值，JavaType指定联合主键的类型 sql查询来的did,对应JavaBean的属性值)&)

31.MyBatis_映射文件_select_resultMap_关联查询_association定义关联对象封装规则

32.MyBatis_映射文件_select_resultMap_关联查询_association分步查询

(排序查询(分布查询 当前属性是调用select指定的方法查出的结果，column指定将哪一列的值传给该方法,最后封装给dept)&)

33.MyBatis_映射文件_select_resultMap_关联查询_分步查询&延迟加载

(提前加载和延迟加载(分段查询希望使用的时候再去查询，节省资源，，)&)

34.MyBatis_映射文件_select_resultMap_关联查询_collection定义关联集合封装规则

(一对多查询(left Join 定义关联集合类型的属性的封装规则，ofType指定集合里面元素额类型，在里面定义集合元素的封装对象规则)&)

35.MyBatis_映射文件_select_resultMap_关联查询_collection分步查询&延迟加载

(实体类定义与Mapper编写(一对多的分段查询 将查询出的id列值传递给方法进行查询)&)

36.MyBatis_映射文件_select_resultMap_分步查询传递多列值&fetchType

(Columns分区(分布查询传入多列的值 column=”{deptId=id,key2=column2}” #{deptId})&使用fetchType属性设置局部加载策略( 延迟加载)&)

37.MyBatis_映射文件_select_resultMap_discriminator鉴别器

(鉴别非法电话号码(判断某列的值，根据值进行封装， 指定封装什么类型时开始进行判断)&)

38.MyBatis_动态sql_简介&环境搭建

(Namespace类型(namespace写接口的全类名)&)

39.MyBatis_动态sql_if_判断&OGNL

( if语句( 根据参数中取值进行判断，转义字符处理特殊字符 and email.trim()!=" 会对字符串与数字进行自动转换)&)

40.MyBatis_动态sql_where_查询条件

(trim、where、set元素(where 1=1 and id=#{id}，或者通过标签包含所有动态条件，不需要用1=1，自动去除第一个多出来的and或者or )&)

41.MyBatis_动态sql_trim_自定义字符串截取

(＜trim＞、＜where＞、＜set＞元素(将后面多出来的and或if去掉，prefix=”where”指定前缀，suffixOverrides=”and”去掉整个字符串后面多余的字符 )&)

42.MyBatis_动态sql_choose_分支选择

( choose、when和otherwise标签(choose相当于case 1=1 )&)

43.MyBatis_动态sql_set_与if结合的动态更新

(Set( last_name = #{lastName}, 取出更新后的逗号，)&)

44.MyBatis_动态sql_foreach_遍历集合

(＜foreach＞标签的使用(collection指定遍历的集合， list类型的参数会封装在map中，map的key对应list，separator元素之间的分隔符，open以什么开头，index就是索引，对应map的index就是key)&)

45.MyBatis_动态sql_foreach_mysql下foreach批量插入的两种方式

(实例26：“批量插入”与“逐条插入”数据，比较性能差异(values(),() #{emp.dept.id}属性的属性，new Department(1))&JDBC连接属性(jdbc.url=3306/mybatis?allowMultiQueries=true，多个sql之间;分隔)&)

46.MyBatis_动态sql_foreach_oracle下批量插入的两种方式

(针对Oracle的CURD(oracle不支持values(),()在begin end;中定义多条insert 语句，也可以通过中间表把数据一块拿出来，from dual union 连接上之后一块插入)&)

47.MyBatis_动态sql_foreach_oracle下foreach批量保存两种方式

(批量更新(oracle添加更新 open=”begin” close=”end;” begin end;)&)

48.MyBatis_动态sql_内置参数_parameter&_databaseId

(循环的内置参数(_paramete代码传入的参数，判断传入的参数是否为null，_databaseId当前数据库的别名 )&)

49.MyBatis_动态sql_bind_绑定

(使用bind()方法绑定事件(模糊查询 ’%${lastName}%’，将OGNL表达式的值绑定在一个变量中， #{_lastName})&)

50.MyBatis_动态sql_sql_抽取可重用的sql片段

(SQL语言基础( employee_id,last_name,email ,直接使用 直接使用include引用外部定义的sql)&)

mybatis-config.xml

log4j.xml

dbconfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true
jdbc.username=root
jdbc.password=123456

orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456

DepartmentMapper.xml

	
	
		select id,dept_name departmentName from tbl_dept where id=#{id}
	
	
	
	
	
	 
	
	
		
		
		
		
			
			
			
			
			
		
	
	
	
		SELECT d.id did,d.dept_name dept_name,
				e.id eid,e.last_name last_name,e.email email,e.gender gender
		FROM tbl_dept d
		LEFT JOIN tbl_employee e
		ON d.id=e.d_id
		WHERE d.id=#{id}
	
	
	
	
		
		
		
	
	
	
		select id,dept_name from tbl_dept where id=#{id}
	
	
	

EmployeeMapper.xml

 
 	
 	
 		select * from tbl_employee where last_name like #{lastName}
 	
 
 	
 	
 		select * from tbl_employee where id=#{id}
 	
 
	
	
	
		select * from tbl_employee where last_name like #{lastName}
	

 	
 	
 		select * from ${tableName} where id=${id} and last_name=#{lastName}
 	
 
 	
 	
 		select * from tbl_employee where id = #{id} and last_name=#{lastName}
 	
 	
 	
		select * from tbl_employee where id = #{id}
	
	
		select * from tbl_employee where id = #{id}
	
	
		select EMPLOYEE_ID id,LAST_NAME	lastName,EMAIL email 
		from employees where EMPLOYEE_ID=#{id}
	
	
	
	
	
		insert into tbl_employee(last_name,email,gender) 
		values(#{lastName},#{email},#{gender})
	
	
	
	
		
		
			
			
			select EMPLOYEES_SEQ.nextval from dual 
			
		
		
		
		
		insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
		values(#{id},#{lastName},#{email}) 
		
	
	
	
	
		update tbl_employee 
		set last_name=#{lastName},email=#{email},gender=#{gender}
		where id=#{id}
	
	
	
	
		delete from tbl_employee where id=#{id}
	
	
	

EmployeeMapperDynamicSQL.xml

	
	 
	 
	 
	 	select * from tbl_employee
	 	
	 	
		 	
		 	
		 		id=#{id}
		 	
		 	
		 		and last_name like #{lastName}
		 	
		 	
		 		and email=#{email}
		 	 
		 	
		 	
		 	 	and gender=#{gender}
		 	
	 	
	 
	 
	 
	 
	 	select * from tbl_employee
	 	
	 	
	 	
	 		
		 		id=#{id} and
		 	
		 	
		 		last_name like #{lastName} and
		 	
		 	
		 		email=#{email} and
		 	 
		 	
		 	
		 	 	gender=#{gender}
		 	
		 
	 
	 
	 
	 
	 	select * from tbl_employee 
	 	
	 		
	 		
	 			
	 				id=#{id}
	 			
	 			
	 				last_name like #{lastName}
	 			
	 			
	 				email = #{email}
	 			
	 			
	 				gender = 0
	 			
	 		
	 	
	 
	 
	 
	 
	 	
	 	update tbl_employee 
		
			
				last_name=#{lastName},
			
			
				email=#{email},
			
			
				gender=#{gender}
			
		
		where id=#{id} 

	 
	 
	 
	 
	 	select * from tbl_employee
	 	
	 	
	 		#{item_id}
	 	
	 
	 
	 
	 
	 
	
	 	insert into tbl_employee(
	 		
	 	) 
		values
		
			(#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
		
	 
	 
	 
	 
	 
	 
	 
	 	
	 	
	 	
	 	
	 	insert into employees(
	 		
	 		
	 			
	 		
	 	)
	 			
	 				select #{emp.lastName} lastName,#{emp.email} email from dual
	 			
	 
	 
	 
	  
	  
	  
	  		
	  		
	  		
	  			select * from tbl_employee
	  			
	  				where last_name like #{lastName}
	  			
	  		
	  		
	  			select * from employees
	  			
	  				where last_name like #{_parameter.lastName}
	  			
	  		
	  
	  
	  
	  
	  		
	  			employee_id,last_name,email
	  		
	  		
	  			last_name,email,gender,d_id
	  		
	  
	  

EmployeeMapperPlus.xml

	
	
		
		
		
		
		
		
		
	
	
	
	
	
		select * from tbl_employee where id=#{id}
	
	
	
	 
	 
	
	
		
		
		
		
		
	


	
	
		
		
		
		
		
		
			
			
		
	
	
	
		SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
		d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
		WHERE e.d_id=d.id AND e.id=#{id}
	
	
	
	 
	 
	 
	 	
	 	
	 	
	 	
	 	
 		
 		
	 
	 
	 
	 	select * from tbl_employee where id=#{id}
	 	
	 		and 1=1
	 	
	 
	 
	 
	
	
	
	
	
		select * from tbl_employee where d_id=#{deptId}
	
	
	
	
	
	
	 
	 	
	 	
	 	
	 	
	 	
	 	
	 		
	 		
	 			
		 		
	 		
	 		
	 		
		 		
			 	
			 	
			 	
	 		
	 	
	 

package com.atguigu.mybatis.bean;

import java.util.List;

public class Department {
	
	private Integer id;
	private String departmentName;
	private List emps;
	
	
	
	
	
	public Department(Integer id) {
		super();
		this.id = id;
	}
	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}
	public List getEmps() {
		return emps;
	}
	public void setEmps(List emps) {
		this.emps = emps;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName
				+ "]";
	}
	
	

}

package com.atguigu.mybatis.bean;

import org.apache.ibatis.type.Alias;

@Alias("emp")
public class Employee {
	
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
	private Department dept;
	
	public Employee() {
		super();
	}
	
	
	
	public Employee(Integer id, String lastName, String email, String gender,
			Department dept) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.dept = dept;
	}



	public Employee(Integer id, String lastName, String email, String gender) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
	}
	
	
	

	public Department getDept() {
		return dept;
	}

	public void setDept(Department dept) {
		this.dept = dept;
	}

	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", gender=" + gender + "]";
	}
	
	

}

package com.atguigu.mybatis.dao;

import com.atguigu.mybatis.bean.Department;

public interface DepartmentMapper {
	
	public Department getDeptById(Integer id);
	
	public Department getDeptByIdPlus(Integer id);

	public Department getDeptByIdStep(Integer id);
}

package com.atguigu.mybatis.dao;

import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapper {
	
	//多条记录封装一个map：Map:键是这条记录的主键，值是记录封装后的javaBean
	//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
	@MapKey("lastName")
	public Map getEmpByLastNameLikeReturnMap(String lastName);
	
	//返回一条记录的map；key就是列名，值就是对应的值
	public Map getEmpByIdReturnMap(Integer id);
	
	public List getEmpsByLastNameLike(String lastName);
	
	public Employee getEmpByMap(Map map);
	
	public Employee getEmpByIdAndLastName(@Param("id")Integer id,@Param("lastName")String lastName);
	
	public Employee getEmpById(Integer id);

	public Long addEmp(Employee employee);

	public boolean updateEmp(Employee employee);

	public void deleteEmpById(Integer id);
	
}

package com.atguigu.mybatis.dao;

import org.apache.ibatis.annotations.Select;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapperAnnotation {
	
	@Select("select * from tbl_employee where id=#{id}")
	public Employee getEmpById(Integer id);
}

package com.atguigu.mybatis.dao;

import java.util.List;

import org.apache.ibatis.annotations.Param;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapperDynamicSQL {
	
	public List getEmpsTestInnerParameter(Employee employee);
	
	//携带了哪个字段查询条件就带上这个字段的值
	public List getEmpsByConditionIf(Employee employee);
	
	public List getEmpsByConditionTrim(Employee employee);
	
	public List getEmpsByConditionChoose(Employee employee);
	
	public void updateEmp(Employee employee);
	
	//查询员工id'在给定集合中的
	public List getEmpsByConditionForeach(@Param("ids")List ids);
	
	public void addEmps(@Param("emps")List emps);

}

package com.atguigu.mybatis.dao;

import java.util.List;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapperPlus {
	
	public Employee getEmpById(Integer id);
	
	public Employee getEmpAndDept(Integer id);
	
	public Employee getEmpByIdStep(Integer id);
	
	public List getEmpsByDeptId(Integer deptId);

}

package com.atguigu.mybatis.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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.junit.Test;

import com.atguigu.mybatis.bean.Department;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.DepartmentMapper;
import com.atguigu.mybatis.dao.EmployeeMapper;
import com.atguigu.mybatis.dao.EmployeeMapperAnnotation;
import com.atguigu.mybatis.dao.EmployeeMapperDynamicSQL;
import com.atguigu.mybatis.dao.EmployeeMapperPlus;

/**
 * 1、接口式编程
 * 	原生：		Dao		====>  DaoImpl
 * 	mybatis：	Mapper	====>  xxMapper.xml
 * 
 * 2、SqlSession代表和数据库的一次会话；用完必须关闭；
 * 3、SqlSession和connection一样她都是非线程安全。每次使用都应该去获取新的对象。
 * 4、mapper接口没有实现类，但是mybatis会为这个接口生成一个代理对象。
 * 		（将接口和xml进行绑定）
 * 		EmployeeMapper empMapper =	sqlSession.getMapper(EmployeeMapper.class);
 * 5、两个重要的配置文件：
 * 		mybatis的全局配置文件：包含数据库连接池信息，事务管理器信息等...系统运行环境信息
 * 		sql映射文件：保存了每一个sql语句的映射信息：
 * 					将sql抽取出来。	
 * 
 * 
 * @author lfy
 *
 */
public class MyBatisTest {
	

	public SqlSessionFactory getSqlSessionFactory() throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		return new SqlSessionFactoryBuilder().build(inputStream);
	}
	
	@Test
	public void testInnerParam() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		try{
			EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
			Employee employee2 = new Employee();
			employee2.setLastName("%e%");
			List list = mapper.getEmpsTestInnerParameter(employee2);
			for (Employee employee : list) {
				System.out.println(employee);
			}
		}finally{
			openSession.close();
		}
	}
	
	@Test
	public void testBatchSave() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		try{
			EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
			List emps = new ArrayList();
			emps.add(new Employee(null, "smith0x1", "smith0x1@atguigu.com", "1",new Department(1)));
			emps.add(new Employee(null, "allen0x1", "allen0x1@atguigu.com", "0",new Department(1)));
			mapper.addEmps(emps);
			openSession.commit();
		}finally{
			openSession.close();
		}
	}
	
	@Test
	public void testDynamicSql() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		try{
			EmployeeMapperDynamicSQL mapper = openSession.getMapper(EmployeeMapperDynamicSQL.class);
			//select * from tbl_employee where id=? and last_name like ?
			//测试if\where
			Employee employee = new Employee(1, "Admin", null, null);
		/*	List emps = mapper.getEmpsByConditionIf(employee );
			for (Employee emp : emps) {
				System.out.println(emp);
			}*/
			
			//查询的时候如果某些条件没带可能sql拼装会有问题
			//1、给where后面加上1=1，以后的条件都and xxx.
			//2、mybatis使用where标签来将所有的查询条件包括在内。mybatis就会将where标签中拼装的sql，多出来的and或者or去掉
				//where只会去掉第一个多出来的and或者or。
			
			//测试Trim
			/*List emps2 = mapper.getEmpsByConditionTrim(employee);
			for (Employee emp : emps2) {
				System.out.println(emp);
			}*/
			
			
			//测试choose
			/*List list = mapper.getEmpsByConditionChoose(employee);
			for (Employee emp : list) {
				System.out.println(emp);
			}*/
			
			//测试set标签
			/*mapper.updateEmp(employee);
			openSession.commit();*/
			
			List list = mapper.getEmpsByConditionForeach(Arrays.asList(1,2));
			for (Employee emp : list) {
				System.out.println(emp);
			}
			
		}finally{
			openSession.close();
		}
	}

	/**
	 * 1、根据xml配置文件（全局配置文件）创建一个SqlSessionFactory对象 有数据源一些运行环境信息
	 * 2、sql映射文件；配置了每一个sql，以及sql的封装规则等。 
	 * 3、将sql映射文件注册在全局配置文件中
	 * 4、写代码：
	 * 		1）、根据全局配置文件得到SqlSessionFactory；
	 * 		2）、使用sqlSession工厂，获取到sqlSession对象使用他来执行增删改查
	 * 			一个sqlSession就是代表和数据库的一次会话，用完关闭
	 * 		3）、使用sql的唯一标志来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。
	 * 
	 * @throws IOException
	 */
	@Test
	public void test() throws IOException {

		// 2、获取sqlSession实例，能直接执行已经映射的sql语句
		// sql的唯一标识：statement Unique identifier matching the statement to use.
		// 执行sql要用的参数：parameter A parameter object to pass to the statement.
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();

		SqlSession openSession = sqlSessionFactory.openSession();
		try {
			Employee employee = openSession.selectOne(
					"com.atguigu.mybatis.EmployeeMapper.selectEmp", 1);
			System.out.println(employee);
		} finally {
			openSession.close();
		}

	}

	@Test
	public void test01() throws IOException {
		// 1、获取sqlSessionFactory对象
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		// 2、获取sqlSession对象
		SqlSession openSession = sqlSessionFactory.openSession();
		try {
			// 3、获取接口的实现类对象
			//会为接口自动的创建一个代理对象，代理对象去执行增删改查方法
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			Employee employee = mapper.getEmpById(1);
			System.out.println(mapper.getClass());
			System.out.println(employee);
		} finally {
			openSession.close();
		}

	}
	
	@Test
	public void test02() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		try{
			EmployeeMapperAnnotation mapper = openSession.getMapper(EmployeeMapperAnnotation.class);
			Employee empById = mapper.getEmpById(1);
			System.out.println(empById);
		}finally{
			openSession.close();
		}
	}
	
	/**
	 * 测试增删改
	 * 1、mybatis允许增删改直接定义以下类型返回值
	 * 		Integer、Long、Boolean、void
	 * 2、我们需要手动提交数据
	 * 		sqlSessionFactory.openSession();===》手动提交
	 * 		sqlSessionFactory.openSession(true);===》自动提交
	 * @throws IOException 
	 */
	@Test
	public void test03() throws IOException{
		
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		//1、获取到的SqlSession不会自动提交数据
		SqlSession openSession = sqlSessionFactory.openSession();
		
		try{
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			//测试添加
			Employee employee = new Employee(null, "jerry4",null, "1");
			mapper.addEmp(employee);
			System.out.println(employee.getId());
			
			//测试修改
			//Employee employee = new Employee(1, "Tom", "jerry@atguigu.com", "0");
			//boolean updateEmp = mapper.updateEmp(employee);
			//System.out.println(updateEmp);
			//测试删除
			//mapper.deleteEmpById(2);
			//2、手动提交数据
			openSession.commit();
		}finally{
			openSession.close();
		}
		
	}
	
	
	@Test
	public void test04() throws IOException{
		
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		//1、获取到的SqlSession不会自动提交数据
		SqlSession openSession = sqlSessionFactory.openSession();
		
		try{
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			//Employee employee = mapper.getEmpByIdAndLastName(1, "tom");
			Map map = new HashMap();
			map.put("id", 2);
			map.put("lastName", "Tom");
			map.put("tableName", "tbl_employee");
			Employee employee = mapper.getEmpByMap(map);
			
			System.out.println(employee);
			
			/*List like = mapper.getEmpsByLastNameLike("%e%");
			for (Employee employee : like) {
				System.out.println(employee);
			}*/
			
			/*Map map = mapper.getEmpByIdReturnMap(1);
			System.out.println(map);*/
			/*Map map = mapper.getEmpByLastNameLikeReturnMap("%r%");
			System.out.println(map);*/
			
		}finally{
			openSession.close();
		}
	}
	
	@Test
	public void test05() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		try{
			EmployeeMapperPlus mapper = openSession.getMapper(EmployeeMapperPlus.class);
			/*Employee empById = mapper.getEmpById(1);
			System.out.println(empById);*/
			/*Employee empAndDept = mapper.getEmpAndDept(1);
			System.out.println(empAndDept);
			System.out.println(empAndDept.getDept());*/
			Employee employee = mapper.getEmpByIdStep(3);
			System.out.println(employee);
			//System.out.println(employee.getDept());
			System.out.println(employee.getDept());
		}finally{
			openSession.close();
		}
		
		
	}
	
	@Test
	public void test06() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		
		try{
			DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
			/*Department department = mapper.getDeptByIdPlus(1);
			System.out.println(department);
			System.out.println(department.getEmps());*/
			Department deptByIdStep = mapper.getDeptByIdStep(1);
			System.out.println(deptByIdStep.getDepartmentName());
			System.out.println(deptByIdStep.getEmps());
		}finally{
			openSession.close();
		}
	}	
	
}

51.MyBatis_缓存_缓存介绍

52.MyBatis_缓存_一级缓存体验

(获取本地缓存数据(一级缓存为本地缓存与数据库同一次会话查询到的数据sqlSession级别的 mapper=openSession.getMapper(Employee.class) emp = mapper.getEmpById(1)，一级缓存一直会开启。二级缓存为全局缓存)&)

53.MyBatis_缓存_一级缓存失效的四种情况

(如何解决失效问题(sqlSession不同一级缓存失效，查询条件不同，两次查询之间进行了增删改等操作，)&)

54.MyBatis_缓存_二级缓存介绍

(namespace资源隔离(二级缓存namespacec级别的缓存，会话关闭一级缓存的数据会被保存到二级缓存中，)&)

55.MyBatis_缓存_二级缓存使用&细节

(二级缓存（mapper级别）( 开启全局二级缓冲， )&)

56.MyBatis_缓存_缓存有关的设置以及属性

(测试select、insert、update和delete操作(useCache=”false” 二级缓冲不适用，增删改flushCache=”true” 查询不会再使用缓存，清除1，2级缓存的数据，每次查询之后就会清除缓存)&clear( )清空缓冲区(只是清除一级缓存)&)

57.MyBatis_缓存_缓存原理图示

(二级缓存原理阐述(会话关闭，一级缓存的数据就会保存在二级缓存中，先查找二级缓存范围较大，之后再查询一级缓存与数据库)&)

58.MyBatis_缓存_第三方缓存整合原理&ehcache适配包下载

59.MyBatis_缓存_MyBatis整合ehcache&总结

(整合Ehcache()&)

dbconfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true
jdbc.username=root
jdbc.password=123456

orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456

ehcache.xml

log4j.xml

mybatis-config.xml

DepartmentMapper.xml

	
	
	
	
		select id,dept_name departmentName from tbl_dept where id=#{id}
	
	
	
	 
	
	
		
		
		
		
			
			
			
			
			
		
	
	
	
		SELECT d.id did,d.dept_name dept_name,
				e.id eid,e.last_name last_name,e.email email,e.gender gender
		FROM tbl_dept d
		LEFT JOIN tbl_employee e
		ON d.id=e.d_id
		WHERE d.id=#{id}
	
	
	
	
		
		
		
	
	
	
		select id,dept_name from tbl_dept where id=#{id}
	
	
	

EmployeeMapper.xml

	
	
	


 
 	
 	
 		select * from tbl_employee where last_name like #{lastName}
 	
 
 	
 	
 		select * from tbl_employee where id=#{id}
 	
 
	
	
	
		select * from tbl_employee where last_name like #{lastName}
	

 	
 	
 		select * from ${tableName} where id=${id} and last_name=#{lastName}
 	
 
 	
 	
 		select * from tbl_employee where id = #{id} and last_name=#{lastName}
 	
 	
 	
		select * from tbl_employee where id = #{id}
	
	
		select * from tbl_employee where id = #{id}
	
	
		select EMPLOYEE_ID id,LAST_NAME	lastName,EMAIL email 
		from employees where EMPLOYEE_ID=#{id}
	
	
	
	
	
		insert into tbl_employee(last_name,email,gender) 
		values(#{lastName},#{email},#{gender})
	
	
	
	
		
		
			
			
			select EMPLOYEES_SEQ.nextval from dual 
			
		
		
		
		
		insert into employees(EMPLOYEE_ID,LAST_NAME,EMAIL) 
		values(#{id},#{lastName},#{email}) 
		
	
	
	
	
		update tbl_employee 
		set last_name=#{lastName},email=#{email},gender=#{gender}
		where id=#{id}
	
	
	
	
		delete from tbl_employee where id=#{id}
	
	
	

EmployeeMapperDynamicSQL.xml

	
	 
	 
	 
	 	select * from tbl_employee
	 	
	 	
		 	
		 	
		 		id=#{id}
		 	
		 	
		 		and last_name like #{lastName}
		 	
		 	
		 		and email=#{email}
		 	 
		 	
		 	
		 	 	and gender=#{gender}
		 	
	 	
	 
	 
	 
	 
	 	select * from tbl_employee
	 	
	 	
	 	
	 		
		 		id=#{id} and
		 	
		 	
		 		last_name like #{lastName} and
		 	
		 	
		 		email=#{email} and
		 	 
		 	
		 	
		 	 	gender=#{gender}
		 	
		 
	 
	 
	 
	 
	 	select * from tbl_employee 
	 	
	 		
	 		
	 			
	 				id=#{id}
	 			
	 			
	 				last_name like #{lastName}
	 			
	 			
	 				email = #{email}
	 			
	 			
	 				gender = 0
	 			
	 		
	 	
	 
	 
	 
	 
	 	
	 	update tbl_employee 
		
			
				last_name=#{lastName},
			
			
				email=#{email},
			
			
				gender=#{gender}
			
		
		where id=#{id} 

	 
	 
	 
	 
	 	select * from tbl_employee
	 	
	 	
	 		#{item_id}
	 	
	 
	 
	 
	 
	 
	
	 	insert into tbl_employee(
	 		
	 	) 
		values
		
			(#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
		
	 
	 
	 
	 
	 
	 
	 
	 	
	 	
	 	
	 	
	 	insert into employees(
	 		
	 		
	 			
	 		
	 	)
	 			
	 				select #{emp.lastName} lastName,#{emp.email} email from dual
	 			
	 
	 
	 
	  
	  
	  
	  		
	  		
	  		
	  			select * from tbl_employee
	  			
	  				where last_name like #{lastName}
	  			
	  		
	  		
	  			select * from employees
	  			
	  				where last_name like #{_parameter.lastName}
	  			
	  		
	  
	  
	  
	  
	  		
	  			employee_id,last_name,email
	  		
	  		
	  			last_name,email,gender,d_id
	  		
	  
	  

EmployeeMapperPlus.xml

	
	
		
		
		
		
		
		
		
	
	
	
	
	
		select * from tbl_employee where id=#{id}
	
	
	
	 
	 
	
	
		
		
		
		
		
	


	
	
		
		
		
		
		
		
			
			
		
	
	
	
		SELECT e.id id,e.last_name last_name,e.gender gender,e.d_id d_id,
		d.id did,d.dept_name dept_name FROM tbl_employee e,tbl_dept d
		WHERE e.d_id=d.id AND e.id=#{id}
	
	
	
	 
	 
	 
	 	
	 	
	 	
	 	
	 	
 		
 		
	 
	 
	 
	 	select * from tbl_employee where id=#{id}
	 	
	 		and 1=1
	 	
	 
	 
	 
	
	
	
	
	
		select * from tbl_employee where d_id=#{deptId}
	
	
	
	
	
	
	 
	 	
	 	
	 	
	 	
	 	
	 	
	 		
	 		
	 			
		 		
	 		
	 		
	 		
		 		
			 	
			 	
			 	
	 		
	 	
	 

package com.atguigu.mybatis.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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.junit.Test;

import com.atguigu.mybatis.bean.Department;
import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.DepartmentMapper;
import com.atguigu.mybatis.dao.EmployeeMapper;
import com.atguigu.mybatis.dao.EmployeeMapperAnnotation;
import com.atguigu.mybatis.dao.EmployeeMapperDynamicSQL;
import com.atguigu.mybatis.dao.EmployeeMapperPlus;

public class MyBatisTest {
	

	public SqlSessionFactory getSqlSessionFactory() throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		return new SqlSessionFactoryBuilder().build(inputStream);
	}
	
	/**
	 * 两级缓存：
	 * 一级缓存：（本地缓存）：sqlSession级别的缓存。一级缓存是一直开启的；SqlSession级别的一个Map
	 * 		与数据库同一次会话期间查询到的数据会放在本地缓存中。
	 * 		以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；
	 * 
	 * 		一级缓存失效情况（没有使用到当前一级缓存的情况，效果就是，还需要再向数据库发出查询）：
	 * 		1、sqlSession不同。
	 * 		2、sqlSession相同，查询条件不同.(当前一级缓存中还没有这个数据)
	 * 		3、sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)
	 * 		4、sqlSession相同，手动清除了一级缓存（缓存清空）
	 * 
	 * 二级缓存：（全局缓存）：基于namespace级别的缓存：一个namespace对应一个二级缓存：
	 * 		工作机制：
	 * 		1、一个会话，查询一条数据，这个数据就会被放在当前会话的一级缓存中；
	 * 		2、如果会话关闭；一级缓存中的数据会被保存到二级缓存中；新的会话查询信息，就可以参照二级缓存中的内容；
	 * 		3、sqlSession===EmployeeMapper==>Employee
	 * 						DepartmentMapper===>Department
	 * 			不同namespace查出的数据会放在自己对应的缓存中（map）
	 * 			效果：数据会从二级缓存中获取
	 * 				查出的数据都会被默认先放在一级缓存中。
	 * 				只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中
	 * 		使用：
	 * 			1）、开启全局二级缓存配置：
	 * 			2）、去mapper.xml中配置使用二级缓存：
	 * 				
	 * 			3）、我们的POJO需要实现序列化接口
	 * 	
	 * 和缓存有关的设置/属性：
	 * 			1）、cacheEnabled=true：false：关闭缓存（二级缓存关闭）(一级缓存一直可用的)
	 * 			2）、每个select标签都有useCache="true"：
	 * 					false：不使用缓存（一级缓存依然使用，二级缓存不使用）
	 * 			3）、【每个增删改标签的：flushCache="true"：（一级二级都会清除）】
	 * 					增删改执行完成后就会清楚缓存；
	 * 					测试：flushCache="true"：一级缓存就清空了；二级也会被清除；
	 * 					查询标签：flushCache="false"：
	 * 						如果flushCache=true;每次查询之后都会清空缓存；缓存是没有被使用的；
	 * 			4）、sqlSession.clearCache();只是清楚当前session的一级缓存；
	 * 			5）、localCacheScope：本地缓存作用域：（一级缓存SESSION）；当前会话的所有数据保存在会话缓存中；
	 * 								STATEMENT：可以禁用一级缓存；		
	 * 				
	 *第三方缓存整合：
	 *		1）、导入第三方缓存包即可；
	 *		2）、导入与第三方缓存整合的适配包；官方有；
	 *		3）、mapper.xml中使用自定义缓存
	 *		
	 *
	 * @throws IOException 
	 * 
	 */
	@Test
	public void testSecondLevelCache02() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		SqlSession openSession2 = sqlSessionFactory.openSession();
		try{
			//1、
			DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
			DepartmentMapper mapper2 = openSession2.getMapper(DepartmentMapper.class);
			
			Department deptById = mapper.getDeptById(1);
			System.out.println(deptById);
			openSession.close();
			
			
			
			Department deptById2 = mapper2.getDeptById(1);
			System.out.println(deptById2);
			openSession2.close();
			//第二次查询是从二级缓存中拿到的数据，并没有发送新的sql
			
		}finally{
			
		}
	}
	@Test
	public void testSecondLevelCache() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		SqlSession openSession2 = sqlSessionFactory.openSession();
		try{
			//1、
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);
			
			Employee emp01 = mapper.getEmpById(1);
			System.out.println(emp01);
			openSession.close();
			
			//第二次查询是从二级缓存中拿到的数据，并没有发送新的sql
			//mapper2.addEmp(new Employee(null, "aaa", "nnn", "0"));
			Employee emp02 = mapper2.getEmpById(1);
			System.out.println(emp02);
			openSession2.close();
			
		}finally{
			
		}
	}
	
	@Test
	public void testFirstLevelCache() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		SqlSession openSession = sqlSessionFactory.openSession();
		try{
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			Employee emp01 = mapper.getEmpById(1);
			System.out.println(emp01);
			
			//xxxxx
			//1、sqlSession不同。
			//SqlSession openSession2 = sqlSessionFactory.openSession();
			//EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);
			
			//2、sqlSession相同，查询条件不同
			
			//3、sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)
			//mapper.addEmp(new Employee(null, "testCache", "cache", "1"));
			//System.out.println("数据添加成功");
			
			//4、sqlSession相同，手动清除了一级缓存（缓存清空）
			//openSession.clearCache();
			
			Employee emp02 = mapper.getEmpById(1);
			//Employee emp03 = mapper.getEmpById(3);
			System.out.println(emp02);
			//System.out.println(emp03);
			System.out.println(emp01==emp02);
			
			//openSession2.close();
		}finally{
			openSession.close();
		}
	}
}

package com.atguigu.mybatis.dao;

import java.util.List;
import java.util.Map;

import org.apache.ibatis.annotations.MapKey;
import org.apache.ibatis.annotations.Param;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapper {
	
	//多条记录封装一个map：Map:键是这条记录的主键，值是记录封装后的javaBean
	//@MapKey:告诉mybatis封装这个map的时候使用哪个属性作为map的key
	@MapKey("lastName")
	public Map getEmpByLastNameLikeReturnMap(String lastName);
	
	//返回一条记录的map；key就是列名，值就是对应的值
	public Map getEmpByIdReturnMap(Integer id);
	
	public List getEmpsByLastNameLike(String lastName);
	
	public Employee getEmpByMap(Map map);
	
	public Employee getEmpByIdAndLastName(@Param("id")Integer id,@Param("lastName")String lastName);
	
	public Employee getEmpById(Integer id);

	public Long addEmp(Employee employee);

	public boolean updateEmp(Employee employee);

	public void deleteEmpById(Integer id);
	
}

60.MyBatis_整合Spring_整合适配包下载

61.MyBatis_整合Spring_所有需要的jar包导入

62.MyBatis_整合Spring_引入MyBatis之前的配置

63.MyBatis_整合Spring_SpringMVC配置文件编写

64.MyBatis_整合Spring_Spring配置文件编写

65.MyBatis_整合Spring_Spring整合MyBatis关键配置

(datasourcetransactionmanager的实现(spring与mybatis用同样的事务管理器，通过控制连接池的连接达到控制事务的目的，)&FactoryBean的使用(sqlSessionFactoryBean实现了FactoryBean接口，调用getObject()方法来创建sqlSessionFactory对象，)& 创建Configuration对象(指定全局配置文件的位置)&)

applicationContext.xml

dbconfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true
jdbc.username=root
jdbc.password=123456

orcl.driver=oracle.jdbc.OracleDriver
orcl.url=jdbc:oracle:thin:@localhost:1521:orcl
orcl.username=scott
orcl.password=123456

mybatis-config.xml

EmployeeMapper.xml

	
	
		select * from tbl_employee where id=#{id}
	
	
	
	
		select * from tbl_employee
	

package com.atguigu.mybatis.bean;

import java.io.Serializable;

import org.apache.ibatis.type.Alias;

public class Employee implements Serializable{
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private Integer id;
	private String lastName;
	private String email;
	private String gender;
	private Department dept;
	
	public Employee() {
		super();
	}
	
	
	
	public Employee(Integer id, String lastName, String email, String gender,
			Department dept) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.dept = dept;
	}



	public Employee(Integer id, String lastName, String email, String gender) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
	}
	
	
	

	public Department getDept() {
		return dept;
	}

	public void setDept(Department dept) {
		this.dept = dept;
	}

	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email="
				+ email + ", gender=" + gender + "]";
	}
	
	

}

package com.atguigu.mybatis.bean;

import java.io.Serializable;
import java.util.List;

public class Department implements Serializable{
	
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private Integer id;
	private String departmentName;
	private List emps;
	
	
	
	
	
	public Department(Integer id) {
		super();
		this.id = id;
	}
	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}
	public List getEmps() {
		return emps;
	}
	public void setEmps(List emps) {
		this.emps = emps;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName
				+ "]";
	}
	
	

}

package com.atguigu.mybatis.controller;

import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.service.EmployeeService;

@Controller
public class EmployeeController {
	
	@Autowired
	EmployeeService employeeService;
	
	@RequestMapping("/getemps")
	public String emps(Map map){
		List emps = employeeService.getEmps();
		map.put("allEmps", emps);
		return "list";
	}

}

package com.atguigu.mybatis.dao;


import java.util.List;

import com.atguigu.mybatis.bean.Employee;

public interface EmployeeMapper {
	
	public Employee getEmpById(Integer id);
	
	public List getEmps();
	

}

package com.atguigu.mybatis.service;

import java.util.List;

import org.apache.ibatis.session.SqlSession;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.atguigu.mybatis.bean.Employee;
import com.atguigu.mybatis.dao.EmployeeMapper;

@Service
public class EmployeeService {
	
	@Autowired
	private EmployeeMapper employeeMapper;
	
	@Autowired
	private SqlSession sqlSession;
	
	public List getEmps(){
		//
		//EmployeeMapper mapper = sqlSession.getMapper(EmployeeMapper.class);
		return employeeMapper.getEmps();
	}

}

web.xml

  MyBatis_06_ssm
  
  
	
		contextConfigLocation
		classpath:applicationContext.xml
	

	
	
		org.springframework.web.context.ContextLoaderListener
	
	
	
	
	
		spring
		org.springframework.web.servlet.DispatcherServlet
		1
	

	
	
		spring
		/
	
  

spring-servlet.xml

list.jsp

员工列表


	
			
				id
				lastName
				email
				gender
			
		
			
				${emp.id }
				${emp.lastName }
				${emp.email }
				${emp.gender }
			
		
	
	

index.jsp

Insert title here


查询所有员工

66.MyBatis_整合Spring_整合测试

67.MyBatis_逆向工程_mbg简介

68.MyBatis_逆向工程_mgb配置文件编写

69.MyBatis_逆向工程_使用mbg逆向生成所有代码及配置

70.MyBatis_逆向工程_测试简单查询&测试带条件复杂查询

71.MyBatis_运行原理_框架分层架构

(网络接口层（数据链路层）&Executor框架&)

72.MyBatis_运行原理_调试前注意

73.MyBatis_运行原理_SQLSessionFactory的初始化

(DeploymentBuilder对象&)

74.MyBatis_运行原理_openSession获取SqlSession对象

( Configuration介绍&使用--no-defaults选项&Statement接口&Statement接口)

75.MyBatis_运行原理_getMapper获取到接口的代理对象

76.MyBatis_运行原理_查询实现

77.MyBatis_运行原理_查询流程总结

78.MyBatis_运行原理_MyBatis原理总结

79.MyBatis_插件_插件原理

80.MyBatis_插件_插件编写&单个插件原理

81.MyBatis_插件_多个插件运行流程

82.MyBatis_插件_开发插件

83.MyBatis_扩展_分页_PageHelpler分页插件使用

84.MyBatis_扩展_批量_BatchExecutor&Spring中配置批量sqlSession

85.MyBatis_扩展_存储过程_oracle中创建一个带游标的存储过程

86.MyBatis_扩展_存储过程_MyBatis调用存储过程

87.MyBatis_扩展_自定义类型处理器_MyBatis中枚举类型的默认处理

88.MyBatis_扩展_自定义类型处理器_使用自定义的类型处理器处理枚举类型