Mybatis的使用

package zhang.mybatis.dao;

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

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

import zhang.mybatis.entities.Customer;

public interface CustomerMapper {
	/**
	 * 更具id获取custoer对象
	 * @param id
	 * @return
	 */
	public Customer getCustomer(Integer id);
	/**
	 * 批量保存customer对象,使用foreach标签进行遍历
	 * @param customers
	 */
	public void saveCustomers(@Param("customers")List<Customer> customers);
	/**
	 *	更新customer对象
	 * @param customer
	 */
	public void updateCustomer(Customer customer);
	/**
	 * 根据departmenti获取customer对象的集合
	 * @param deptid
	 * @return
	 */
	public List<Customer> getcustomers(Integer deptid);
	
	/**
	 * 根据customername获取customer对象
	 * @param customername
	 * @return
	 */
	public Customer getCustomerByCustomerName(String customername);
	/**
	 * 根据id获取customer对象
	 * @param id
	 * @return
	 */
	public Customer getCustomerByIdpus(Integer id);
	/**
	 * 获取customer的map,key:customer的主键值
	 * value:customer对象
	 * @param id
	 * @return
	 */
	@MapKey("id")
	public Map<Integer, Customer> getCustomerMap(Integer id);
	
	/**
	 * 获取customer和他关联的department对象
	 * @param id
	 * @return
	 */
	public Customer getCustomerAndDept(Integer id);
	/**
	 * 根据id获取customer对象
	 * @param id
	 * @return
	 */
	public Customer getCustomerById(Integer id);
	
	/**
	 * 获取所有的Customer
	 * @return
	 */
	public List<Customer> getAllCustomer();
	
	/**
	 * 保存customer对象
	 * @param customer
	 */
	public void saveCustomer(Customer customer);
}
package zhang.mybatis.dao;

import java.util.List;

import zhang.mybatis.entities.Customer;

public interface CustomerMapperDynamicSql {

	/**
	 * 查询customer对象OGNL中的if
	 * @param customer
	 * @return
	 */
	public List<Customer> getCustomerConditionIf(Customer customer);
	
}
package zhang.mybatis.dao;

import java.util.List;

import org.apache.ibatis.annotations.Param;

import zhang.mybatis.entities.Department;

public interface DepartmentMapper {
	
	/**
	 * 获取department对象和其关联的empployee对象的集合(使用分部查询的方法)
	 * @param id
	 * @return
	 */
	public Department getDepartmentWithEmpStep(Integer id);
	/**
	 * 获取department对象和其关联的empployee对象的集合
	 * @param id
	 * @return
	 */
	public Department getDepartmentWithEmployee(Integer id);
	/**
	 * 根据department获取department对象,使用choose标签
	 * @param department
	 * @return
	 */
	public Department getDepartmentChoose(Department department);
	/**
	 * 获取department对象使用trim标签的使用
	 * @param department
	 * @return
	 */
	public Department getDepartmentTrim(Department department);
	/**
	 * 获取department对象
	 * @param department
	 * @return
	 */
	public Department getDepartmentWhere(Department department);
	/**
	 * 传入一组id,,获取department的集合
	 * @param list
	 * @return
	 */
	public List<Department> getDepartments(@Param("ids")List<Integer> list);
	/**
	 *	获取department对象
	 * @param department
	 * @return
	 */
	public Department getDepartment(Department department);
	/**
	 * 根据departmentname获取department的对象
	 * @param departmentname
	 * @return
	 */
	public Department getDepartmentByName(String departmentname);
	/**
	 * 分部查询department的方法
	 * @return
	 */
	public Department getDepartmentStep(Integer id);
	/**
	 * 获取部门的时候,将部门中的员工一起获取
	 * @param id
	 * @return
	 */
	public Department getDepartmentPuls(Integer id);
	/**
	 * 根据id获取department
	 * @param id
	 * @return
	 */
	public Department getDepartmentById(Integer id);

	
	/**
	 * 获取所有的部门
	 * @return
	 */
	public List<Department> getAllDepartments();
}
package zhang.mybatis.dao;

import java.util.List;

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

import zhang.mybatis.entities.Employee;

public interface EmployeeMapper {

	/**
	 * 查询name的模糊查询
	 * @param name
	 * @return
	 */
	public List<Employee> getEmployeeLikeName(Employee employee);
	/**
	 * 批量插入员工信息
	 * @param emps
	 */
	public void saveEmployees(@Param("emps")List<Employee> emps);
	/**
	 * 使用choose标签查询employee对象
	 * @param employee
	 */
	public Employee getEmployeeByChoose(Employee employee);
	/**
	 *	使用分部查询的方法查询employee对象和其关联的department
	 * @param id
	 * @return
	 */
	public List<Employee> getemployeesstep(Integer id);
	/**
	 * 使用if标签查询
	 * @param employee
	 * @return
	 */
	public Employee getEmployeeByIf(Employee employee);
	/**
	 * 分部查询employee
	 * @param id
	 * @return
	 */
	public Employee getEmployeeWithDepartmentStep(Integer id);
	/**
	 * 级联查询employee和department
	 * @param id
	 * @return
	 */
	public Employee getEmployeeWithDepartment(Integer id);
	/*
	 * 根据id获取employee对象
	 */
	public Employee getEmployeeById(Integer id);
	
	@Select("select id,name,age,email from employee where name=#{name}")
	public Employee getEmployeeByName(String name);
	
	
}
package zhang.mybatis.dao;

import java.util.List;

import zhang.mybatis.entities.Person;

public interface PersonMapper {
	
	/**
	 * 根据id删除person对象
	 * @param id
	 */
	public void deletePersonById(Integer id);
	/**
	 * 获取所有的person封装成一个list返回
	 * @return
	 */
	public List<Person> getAllPersons();
	/**
	 * 
	 * 根据id获取person对象
	 * @param id
	 * @return
	 */
	public Person getPersonById(Integer id);
	
	/**
	 * 根据name获取person对象
	 * @param name
	 * @return
	 */
	public Person getPersonByName(String name);
	

	/**
	 * 保存person
	 * @param person
	 */
	public void savePerson(Person person);
	
}
<?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="zhang.mybatis.dao.CustomerMapper">
	<!-- 根据id获取customer对象 -->
	<resultMap type="zhang.mybatis.entities.Customer" id="myresultmap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<result column="age" property="age"/>
		<association property="department" javaType="zhang.mybatis.entities.Department">
			<id column="deptid" property="departmentId"/>
			<result column="deptname" property="departmentName"/>
		</association>		
	</resultMap>
	<select id="getCustomer" resultMap="myresultmap">
		select c.id,c.name,c.age,c.d_id ,d.deptid,d.deptname 
		from customer c,department d
		where c.d_id=d.deptid
		and c.id=#{id}
	</select>
	<!-- 批量保存:Mysql支持 values (?,?,?,?) , (?,?,?,?)的语法 -->
	<insert id="saveCustomers" parameterType="zhang.mybatis.entities.Customer">
		insert into customer(name,age,email,d_id) values
		<foreach collection="customers" item="customer" separator=",">
			(#{customer.name},#{customer.age},#{customer.email},#{customer.department.departmentId})
		</foreach>
	</insert>
	<!-- 批量保存方法二,可以发送多条语句 
	<insert id="saveCustomers" parameterType="zhang.mybatis.entities.Customer">
		<foreach collection="customers" item="customer" separator=";">
		insert into customer(name,age,email,d_id)
		values(#{customer.name},#{customer.age},#{customer.email},#{customer.department.departmentId})
		</foreach>
	</insert>
	-->
	<update id="updateCustomer" parameterType="zhang.mybatis.entities.Customer">
		Update customer 
		<set>
			<if test="name!=null">
				name=#{name},
			</if>
			<if test="age!=null">
				age=#{age},
			</if>
			<if test="email!=null">
				email=#{email}
			</if>
		</set>
		where id=#{id}
	</update>
	<!--  -->
	<select id="getCustomerByCustomerName" resultType="zhang.mybatis.entities.Customer">
		select * from customer where name=#{name}
	</select>
	<resultMap type="zhang.mybatis.entities.Customer" id="mycustomer">
		<id column="id" property="id" />
		<result column="name" property="name" />
		<result column="email" property="email" />
		<result column="age" property="age" />
		<association property="department"
			select="zhang.mybatis.dao.DepartmentMapper.getDepartmentById" column="d_id">
		</association>
	</resultMap>
	<!-- 分部查询的自定义方法 -->
	<select id="getCustomerByIdpus" resultMap="mycustomer">
		select * from customer
		where id=#{id}
	</select>
	<select id="getCustomerMap" resultType="zhang.mybatis.entities.Customer">
		select * from customer
		where id=#{id}
	</select>
	<!-- 自定义封装规则 -->
	<resultMap type="zhang.mybatis.entities.Customer" id="myemp">
		<id column="id" property="id" />
		<result column="name" property="name" />
		<result column="age" property="age" />
		<!-- 支持级联书属性的赋值 -->
		<result column="deptid" property="department.departmentId" />
		<result column="deptname" property="department.departmentName" />
	</resultMap>
	<!-- 自定义封装规则 -->
	<resultMap type="zhang.mybatis.entities.Customer" id="myemp2">
		<id column="id" property="id" />
		<result column="name" property="name" />
		<result column="age" property="age" />
		<!-- 支持级联书属性的赋值 -->
		<association property="department" javaType="zhang.mybatis.entities.Department">
			<id column="deptid" property="departmentId" />
			<result column="deptname" property="departmentName" />
		</association>
	</resultMap>
	<!-- 级联查询 -->
	<select id="getCustomerAndDept" resultMap="myemp2">
		SELECT
		id,NAME,age,email,d.deptid,d.deptname FROM customer c,department d
		WHERE c.d_id=d.deptid and id=#{id}
	</select>
	<select id="getCustomerById" resultType="zhang.mybatis.entities.Customer">
		select * from Customer
		where id = #{id}
	</select>
	<select id="getAllCustomer" resultType="zhang.mybatis.entities.Customer">
		select * from Customer
	</select>
	<insert id="saveCustomer" parameterType="zhang.mybatis.entities.Customer">
		Insert into
		Customer(id,name,age,email,d_id) values
		(#{id},#{name},#{age},#{email},#{d departmentId})
	</insert>
	<select id="getcustomers" resultType="zhang.mybatis.entities.Customer">
		select * from customer
		where d_id=#{id}
	</select>
</mapper>

<?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="zhang.mybatis.dao.CustomerMapperDynamicSql">
	<select id="getCustomerConditionIf" resultType="zhang.mybatis.entities.Customer">
		select * from customer
		where 1=1
		<if test="id">
			and id=#{id}
		</if>
		<if test="name">
			and name like #{name}
		</if>
		<if test="email">
		  and email=#{email}
		</if>
		<if test="age">
		and	age> #{age}
		</if>
	</select>
</mapper>
<?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="zhang.mybatis.dao.DepartmentMapper">
 	<!-- 引入缓存 -->
 	<cache-ref namespace="zhang.mybatis.dao.EmployeeMapper"/>
 	
 	<!-- 使用分部查询的方式查询department对象和其关联的customers集合 -->
 	<resultMap type="zhang.mybatis.entities.Department" id="mydepartmentmapstep">
 		<id column="deptid" property="departmentId"/>
 		<result column="deptname" property="departmentName"/>
 		<collection property="employees" select="zhang.mybatis.dao.EmployeeMapper.getemployeesstep"
 		column="deptid"></collection>
 	</resultMap>
 	<select id="getDepartmentWithEmpStep" resultMap="mydepartmentmapstep">
 		select deptid ,deptname from department where deptid=#{deptid}
 	</select>
 	
 	<!-- 获取department对象和他关联的employee集合属相,使用级联查询的方式 -->
 	<resultMap type="zhang.mybatis.entities.Department" id="mydepartmentmap">
 		<id column="deptid" property="departmentId"/>
 		<result column="deptname" property="departmentName"/>
 		<collection property="employees" ofType="zhang.mybatis.entities.Employee">
 			<id column="id" property="id"/>
 			<result column="name" property="name"/>
 			<result column="age" property="age"/>
 			<result column="email" property="email"/>
 		</collection>
 	</resultMap>
 	<select id="getDepartmentWithEmployee" resultMap="mydepartmentmap">
 		select d.deptid,d.deptname ,e.id,e.name,e.email,e.age 
 		from department d left join employee e
 		on e.d_id=d.deptid
 		where d.deptid=#{deptid}
 	</select>
 	
 	<select id="getDepartmentChoose" resultType="zhang.mybatis.entities.Department">
 		select deptid  departmentId,deptname departmentName from department
 		where 
		<choose>
			<when test="departmentId!=null">
				deptid=#{departmentId}
			</when>
			<when test="departmentName">
				deptname=#{departmentName}
			</when>
			<otherwise>
				1=1
			</otherwise>
		</choose> 		
 	</select>
 	<select id="getDepartmentTrim" resultType="zhang.mybatis.entities.Department">
 		select deptid departmentId ,deptname departmentName 
 		from department 
 		<trim prefix="where" >
 			<if test="departmentId!=null">
 				deptid=#{departmentId}
 			</if>
 			<if test="departmentName!=null">
 				and deptname=#{departmentName}
 			</if>
 		</trim>
 	</select>
 	<select id="getDepartmentWhere" resultType="zhang.mybatis.entities.Department">
 		select deptid departmentId,deptname departmentName
 		from department
 		<where>
 			<if test="departmentId!=null">
 				deptid=#{departmentId}
 			</if>
 			<if test="departmentName!=null">
 				 and deptname=#{departmentName}
 			</if>
 		</where>
 	</select>
 	<select id="getDepartments" resultType="zhang.mybatis.entities.Department">
 		select deptid departmentId,deptname departmentName from department
 		where deptid in(
 		<foreach  item="myItem" collection="ids" separator=",">
 			#{myItem}
 		</foreach>
 		)
 	</select>
 	<select id="getDepartment" resultType="zhang.mybatis.entities.Department">
 		select deptid departmentId,deptname departmentName from department
 		where 1=1
 		<if test="departmentId!=null">
 			and deptid=#{departmentId}
 		</if>
 		<if test="departmentName!=null">
 		  	and deptname=#{departmentName}
 		</if>
 		
 	</select>
 	<resultMap type="zhang.mybatis.entities.Department" id="mydeptstep">
 		<id column="deptid" property="departmentId" />  
 		<result column="deptname" property="departmentName"/>
 		<collection property="customers" select="zhang.mybatis.dao.CustomerMapper.getcustomers"
 		column="deptid"></collection>
 	</resultMap>
	<select id="getDepartmentByName" resultType="zhang.mybatis.entities.Department">
	select deptid departmentId,deptname departmentName from department where
	deptname=#{departmentname}
	</select>
	<select id="getDepartmentStep" resultMap="mydeptstep">
		select * from department where deptid=#{id}
	</select>
 	<select id="getDepartmentById" resultType="zhang.mybatis.entities.Department">
 		select deptid departmentId,deptname departmentName
 		from department
 		 where deptid=#{id}
 	</select>
 	<resultMap type="zhang.mybatis.entities.Department" id="mydept">
 		<id column="did" property="departmentId"/>
 		<result column="dname" property="departmentName"/>
 		<collection property="customers" ofType="zhang.mybatis.entities.Customer" >
 			<id column="eid" property="id"/>
 			<result column="ename" property="name"/>
 			<result column="eage" property="age"/>
 			<result column="email" property="email"/>
 		</collection>
 	</resultMap>
 	<select id="getDepartmentPuls" resultMap="mydept">
 		SELECT d.`deptid` did,d.`deptname` dname,c.`id` eid,c.`name` ename,c.`age` cage,c.`email` email
		 FROM department d LEFT JOIN customer c ON d.`deptid`=c.`d_id`
		WHERE d.`deptid`=#{id}
 	</select>
 </mapper>
 <?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="zhang.mybatis.dao.EmployeeMapper">
	<cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>
	<!-- 该Mapper开始二级缓存:同时pojo需要实现反序列化接口
	 <cache eviction="LRU"
           type="org.apache.ibatis.cache.impl.PerpetualCache"
           flushInterval="120000"
           size="1024"
           readOnly="false"/>
	 -->
	<!-- 
	1.eviction:缓存的回收策略 
	2.flushInterval:缓存多长时间清空一次 ,默认是不清空,单位毫秒
	3.readOnly:是否只读,默认是false
	4.size:指定缓存多少元素
	5.type:指定缓存的类型
	 -->
	<!-- 使用name进行模糊查询 -->
	<select id="getEmployeeLikeName" resultType="zhang.mybatis.entities.Employee">
		<bind name="_name" value="'%'+name+'%'"></bind>
		<include refid="sql">
			<property name="test" value="aaa"/>
		</include>
		where name like #{_name}
	</select>
	<!--1. 使用sql标签抽取可以重用的sql语句,通常用来抽取列名
		2.可以使用include标签进行引用
		3.在include标签的内部可以定义属性,这样就可以在sql标签中进行使用
	 -->
	<sql id="sql">
		select id,name,age,email from employee
	</sql>
	<!-- 批量插入 -->
	<insert id="saveEmployees" parameterType="zhang.mybatis.entities.Employee">
		insert into employee(name,age,email,d_id) values
		<foreach collection="emps" item="emp" separator=",">
			(#{emp.name},#{emp.age},#{emp.email},#{emp.department.departmentId})
		</foreach>
	</insert>

	<!-- 使用choose标签查询employee对象 -->
	<select id="getEmployeeByChoose" resultType="zhang.mybatis.entities.Employee">
		select id,name,email,age
		from employee
		where
		<choose>
			<when test="id!=null">
				id=#{id}
			</when>
			<when test="age!=null">
				age=#{age}
			</when>
			<when test="email!=null">
				email like #{email}
			</when>
		</choose>
	</select>

	<!-- 使用if标签查询employee对象 -->
	<select id="getEmployeeByIf" resultType="zhang.mybatis.entities.Employee">
		select id,name,age,email from employee
		<where>
			<if test="id!=null">
				and id=#{id}
			</if>
			<if test="name!=null">
				and name=#{name}
			</if>
			<if test="age!=null">
				and age=#{age}
			</if>
			<if test="email!=null">
				and email=#{email}
			</if>
		</where>
	</select>
	<!-- 分部查询,根据deptid查询3employee -->
	<select id="getemployeesstep" resultType="zhang.mybatis.entities.Employee">
		select
		id,name,email,age ,d_id
		from employee
		where d_id=#{deptid}
	</select>

	<!-- 使用分部查询 的方法查询employee -->
	<resultMap type="zhang.mybatis.entities.Employee" id="mapstep1">
		<id column="id" property="id" />
		<result column="name" property="name" />
		<result column="age" property="age" />
		<result column="email" property="email" />
		<association property="department"
			select="zhang.mybatis.dao.DepartmentMapper.getDepartmentById" column="d_id"></association>
	</resultMap>
	<select id="getEmployeeWithDepartmentStep" resultMap="mapstep1">
		select
		id,name,age,email,d_id
		from employee
		where id=#{id}
	</select>
	<!-- 使用级联查询的方法查询employee对象和他关联的department对象 -->
	<resultMap type="zhang.mybatis.entities.Employee" id="map1">
		<id column="id" property="id" />
		<result column="name" property="name" />
		<result column="age" property="age" />
		<result column="email" property="email" />
		<association property="department" javaType="zhang.mybatis.entities.Department">
			<id column="deptid" property="departmentId" />
			<result column="deptname" property="departmentName" />
		</association>
	</resultMap>
	<select id="getEmployeeWithDepartment" resultMap="map1">
		select
		e.id,e.name,e.age,e.email,d.deptid,d.deptname
		from employee e,department d
		where e.d_id=d.deptid
		and e.id=#{id}
	</select>

	<select id="getEmployeeById" resultType="zhang.mybatis.entities.Employee">
		select id ,name,
		age,email from employee
		where id=#{id}
	</select>
</mapper>
<?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="zhang.mybatis.dao.PersonMapper">
 	<delete id="deletePersonById" >
 		delete from person where id=#{id}
 	</delete>
 	<select id="getAllPersons" resultType="zhang.mybatis.entities.Person">
 		select id,last_Name name ,age from person 
 	</select>
 	<insert id="savePerson" parameterType="zhang.mybatis.entities.Person">
 		insert into person
 		set last_Name=#{name},age=#{age}
 	</insert>
 	 	
 	<select id="getPersonByName" resultType="zhang.mybatis.entities.Person">
 		select id,last_Name name,age from person
 		where last_Name=#{name}
 	</select>
 
 
	<resultMap type="zhang.mybatis.entities.Person" id="myperson">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<result column="age" property="age"/>
	</resultMap>
 	<select id="getPersonById" resultMap="myperson">
 		select id,last_Name name ,age from person
 		where id=#{id}
 	</select>
 </mapper>
 <?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>
	<!-- 引入外部的属性文件 -->
	<properties resource="db.properties"></properties>
	<settings>
		<!-- 在分部查询的基础之上开启延迟加载的策略 -->
		<setting name="cacheEnabled" value="true"/>
		<setting name="lazyLoadingEnabled" value="true" />
		<setting name="aggressiveLazyLoading" value="false" />
		<setting name="jdbcTypeForNull" value="OTHER" />
		<!-- 开启全局的二级缓存的配置 -->
	</settings>
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<dataSource type="POOLED">
				<property name="driver" value="${jdbc.driverclass}" />
				<property name="url" value="${jdbc.url}" />
				<property name="username" value="${jdbc.username}" />
				<property name="password" value="${jdbc.password}" />
			</dataSource>
		</environment>
	</environments>
	<mappers>
		<package name="zhang.mybatis.dao" />
	</mappers>

</configuration>
package zhang.mybatis.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Arrays;
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 zhang.mybatis.dao.CustomerMapper;
import zhang.mybatis.dao.CustomerMapperDynamicSql;
import zhang.mybatis.dao.DepartmentMapper;
import zhang.mybatis.dao.PersonMapper;
import zhang.mybatis.entities.Customer;
import zhang.mybatis.entities.Department;
import zhang.mybatis.entities.Person;

public class MybatisTest {
	private CustomerMapper customerMapper = null;
	private DepartmentMapper departmentMapper=null;
	{
		try {
			customerMapper = getSession().getMapper(CustomerMapper.class);
			departmentMapper=getSession().getMapper(DepartmentMapper.class);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	@Test
	public void testgetCustomerwithdepartment() throws IOException{
		SqlSession session = getSession();
		try {
			CustomerMapper mapper = session.getMapper(CustomerMapper.class);
			Customer customer = mapper.getCustomer(5);
			String departmentname = customer.getDepartment().getDepartmentName();
			System.out.println(departmentname);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	@Test
	public void testgetCustomer() throws IOException{
		SqlSession session = getSession();
		try {
			CustomerMapper mapper = session.getMapper(CustomerMapper.class);
			Customer customer = mapper.getCustomer(5);
			System.out.println(customer);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	
	//测试批量保存
	@Test
	public void testsaveCustomers() throws IOException{
		Department department = departmentMapper.getDepartmentById(1);
		Customer customer=new Customer("CC", 12, "cc@qq.com", department);
		Customer customer2=new Customer("DD",12 , "dd@qq.com", department);
		List<Customer> customers=new ArrayList<>();
		customers.add(customer);
		customers.add(customer2);
		SqlSession session = getSession();
		try {
			CustomerMapper mapper = session.getMapper(CustomerMapper.class);
			mapper.saveCustomers(customers);
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.commit();
			session.close();
		}
	}
	
	@Test
	public void tesetupdateCustomer2(){
		Customer customerById = customerMapper.getCustomerById(5);
		System.out.println(customerById);
	}
	@Test
	public void testupdateCustomer() throws IOException{
		SqlSession session = getSession();
		CustomerMapper mapper = session.getMapper(CustomerMapper.class);
		Customer customer=new Customer();
		customer.setId(5);
		customer.setName("updatename");
		mapper.updateCustomer(customer);
		session.commit();
	}
	@Test
	public void testgetallperson() throws IOException{
		SqlSession session = getSession();
		try {
			PersonMapper mapper = session.getMapper(PersonMapper.class);
			List<Person> allPersons = mapper.getAllPersons();
			for(Person p:allPersons){
				System.out.println(p);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
			
		}
	}
	@Test
	public void testdeletePersonById() throws IOException{
		SqlSession session = getSession();
		try {
			PersonMapper mapper = session.getMapper(PersonMapper.class);
			mapper.deletePersonById(1);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.commit();
			session.close();
		}
	}
	@Test
	public void testsavePerson() throws IOException{
		SqlSession session = getSession();
		try {
			PersonMapper mapper = session.getMapper(PersonMapper.class);
			Person person=new Person();
			person.setName("zhangyukang");
			person.setAge(12);
			mapper.savePerson(person);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
		
			session.commit();
			session.close();
		}
	}
	@Test
	public void testgetPersonByName() throws IOException{
		SqlSession session = getSession();
		try {
			PersonMapper mapper = session.getMapper(PersonMapper.class);
			Person personByName = mapper.getPersonByName("zhang");
			System.out.println(personByName);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	@Test
	public void testgetPersonById() throws IOException{
		SqlSession session = getSession();
		try {
			PersonMapper mapper = session.getMapper(PersonMapper.class);
			Person personById = mapper.getPersonById(2);
			System.out.println(personById);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	@Test
	public void testgetgetDepartmentChoose(){
		Department department=new Department();
		department.setDepartmentName("开发部");
		Department departmentChoose = departmentMapper.getDepartmentChoose(department);
		System.out.println(departmentChoose);
	}
	@Test
	public void testgetDepartmentChoose(){
		Department department=new Department();
		department.setDepartmentId(1);
		Department departmentChoose = departmentMapper.getDepartmentChoose(department);
		System.out.println(departmentChoose);
	}
	@Test
	public void testgetDepartmentTrim() throws IOException{
		SqlSession session = getSession();
		try {
			DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
			Department department=new Department();
			department.setDepartmentId(1);
			Department departmentTrim = mapper.getDepartmentTrim(department);
			System.out.println(departmentTrim);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	@Test
	public void testgetdepartmentwhere2() throws IOException{
		SqlSession session = getSession();
		try {
			DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
			Department department=new Department();
			department.setDepartmentName("开发部");
			Department departmentWhere = mapper.getDepartmentWhere(department);
			System.out.println(departmentWhere);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	
	@Test
	public void testgetDepartmentWhere(){
		Department department=new Department();
		department.setDepartmentId(1);
		Department departmentWhere = departmentMapper.getDepartmentWhere(department);
		System.out.println(departmentWhere);
	}
	@Test
	public void testgetdeparments() throws IOException{
		SqlSession session = getSession();
		try {
			DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
			List<Integer> id=Arrays.asList(1,2,3);
			List<Department> departments = mapper.getDepartments(id);
			for(Department  department:departments){
				System.out.println(department);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				session.close(); 
				
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}
	@Test
	public void testgetallcustomer(){
		List<Customer> allCustomer = customerMapper.getAllCustomer();
		for(Customer customer:allCustomer){
			System.out.println(customer);
		}
	}
	@Test
	public void testgetCustomerByCustomerName() throws IOException {
		SqlSession session = getSession();
		try {

			CustomerMapper mapper = session.getMapper(CustomerMapper.class);
			Customer customerByCustomerName = mapper.getCustomerByCustomerName("zhangyukang");
			System.out.println(customerByCustomerName);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}
	@Test
	public void testgetdepartment3(){
		SqlSession session=null ;
		try {
			session= getSession();
			DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
			Department department=new Department();
			department.setDepartmentId(2);
			Department department2 = mapper.getDepartment(department);
			System.out.println(department2);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				session.close();
				
			} catch (Exception e2) {
				e2.printStackTrace();	
			}
		}
	}
	@Test
	public void testgetdepartment2() throws IOException{
		SqlSession session = getSession();
		try {
			DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
			Department  department=new Department();
			department.setDepartmentName("开发部");
			Department department2 = mapper.getDepartment(department);
			System.out.println(department2);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			try {
				session.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
	}
	@Test
	public void testgetCustomerConditionIf() throws IOException {
		SqlSession session = getSession();
		CustomerMapperDynamicSql mapper = session.getMapper(CustomerMapperDynamicSql.class);
		Customer customer = new Customer();
		customer.setName("%a%");
		customer.setId(5);
		customer.setEmail("qq.com");
		customer.setAge(12);
		List<Customer> customerConditionIf = mapper.getCustomerConditionIf(customer);
		for (Customer c : customerConditionIf) {
			System.out.println(c);
		}
	}

	@Test
	public void testgetDepartmentStep() throws IOException {
		SqlSession session = getSession();
		try {
			DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
			Department departmentStep = mapper.getDepartmentStep(1);
			System.out.println(departmentStep.getDepartmentName());
			// System.out.println(departmentStep.getCustomers());
			System.out.println(departmentStep.getCustomers().get(1).getName());
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally {
			session.close();
		}
	}

	@Test
	public void mytest() {
		String name = "zhangyukang";
		System.out.println("97".equals(name.getBytes()[2]));

	}

	@Test
	public void testgetdepartmentwidthcustomers() throws IOException {
		SqlSession session = getSession();
		DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
		Department department = mapper.getDepartmentPuls(1);
		System.out.println(department);
		System.out.println(department.getCustomers());
	}

	@Test
	public void testgetdepartmentByname() throws IOException {
		SqlSession session = getSession();
		DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
		Department departmentByName = mapper.getDepartmentByName("开发部");
		System.out.println(departmentByName);
	}

	// 分部查询的测试
	@Test
	public void testgetCustomerById() throws IOException {
		SqlSession session = getSession();
		CustomerMapper mapper = session.getMapper(CustomerMapper.class);
		Customer customer = mapper.getCustomerByIdpus(5);
		// System.out.println(customer.getDepartment());
	}

	@Test
	public void testgetdepartment() throws IOException {
		SqlSession session = null;
		try {
			session = getSession();
			DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
			Department departmentById = mapper.getDepartmentById(2);
			System.out.println(departmentById);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if (session != null) {
				session.close();
			}
		}
	}

	// 获取所有的customer的信息
	@Test
	public void testgetcustomer() {
		List<Customer> allCustomer = customerMapper.getAllCustomer();
		for (Customer c : allCustomer) {
			System.out.println(c + "---->" + c.getName());
		}
	}

	@Test
	public void testgetCustomerMap() {
		Map<Integer, Customer> map = customerMapper.getCustomerMap(5);
		System.out.println(map);
	}

	@Test
	public void testgetcustomerandepartment() {
		Customer customerAndDept = customerMapper.getCustomerAndDept(5);
		System.out.println(customerAndDept.getDepartment());
	}

	/**
	 * 获取SqlSession
	 * 
	 * @return
	 * @throws IOException
	 */
	public SqlSession getSession() throws IOException {
		String resource = "mybatis-config.xml";
		InputStream in = Resources.getResourceAsStream(resource);
		SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);

		SqlSession session = sessionFactory.openSession();
		return session;
	}

	/**
	 * 获取customer对象
	 */
	@Test
	public void testgetcustoemr2() {
		Customer customer = customerMapper.getCustomerById(5);
		System.out.println(customer.getDepartment());
	}

	@Test
	public void testgetcustomer2() throws IOException {
		SqlSession session = getSession();
		CustomerMapper customerMapper = session.getMapper(CustomerMapper.class);
		Customer customer = customerMapper.getCustomerById(1);
		System.out.println(customer);

	}

	@Test
	public void testsaveCustoemrwithdepartment() throws IOException {
		SqlSession session = getSession();
		DepartmentMapper departmentMapper = session.getMapper(DepartmentMapper.class);
		Department department = departmentMapper.getDepartmentById(1);
		System.out.println(department);
		Customer customer = new Customer();
		customer.setName("刘杰");
		customer.setEmail("zhansam@qq");
		customer.setAge(23);
		customer.setDepartment(department);
		CustomerMapper customerMapper2 = session.getMapper(CustomerMapper.class);
		customerMapper2.saveCustomer(customer);
		session.commit();
	}

	@Test
	public void testsavecustomer() throws IOException {
		SqlSession session = getSession();

		Customer customer = new Customer();
		customer.setAge(122);
		customer.setName("justin");
		customer.setEmail("justin@");
		// customer.setId(2);
		// customerMapper.saveCustomer(customer);
		CustomerMapper mapper = session.getMapper(CustomerMapper.class);
		mapper.saveCustomer(customer);
		session.commit();
		session.close();
	}

	@Test
	public void testgetAllCustomer() {
		List<Customer> customers = customerMapper.getAllCustomer();
		System.out.println(customers);
	}

	@Test
	public void test() throws IOException {
		SqlSession session = getSession();
		try {
			Customer customer = session.selectOne("zhang.mybatis.dao.CustomerMapper.getCustomerById", 1);
			System.out.println(customer);
		} catch (Exception e) {

			// TODO: handle exception
		} finally {
			session.close();
		}

	}

}
package zhang.mybatis.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import zhang.mybatis.dao.DepartmentMapper;
import zhang.mybatis.dao.EmployeeMapper;
import zhang.mybatis.entities.Department;
import zhang.mybatis.entities.Employee;

public class TestMybatis2 {
	
	@Test
	public void testgetEmployeeLikeName() throws IOException{
		SqlSessionFactory sessionFactory = getsessfactory();
		SqlSession session = sessionFactory.openSession();
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			Employee emp=new Employee();
			emp.setName("AA");
			List<Employee> employeeLikeName = mapper.getEmployeeLikeName(emp);
			System.out.println(employeeLikeName);
		} catch (Exception e) {
			// TODO: handle exception
		}finally {
			session.close();
		}
	}
	@Test
	public void test() throws IOException{
		SqlSession session = getsqlsession();
		EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
		Employee employeeByName = mapper.getEmployeeByName("BB");
		System.out.println(employeeByName);
	}
	@Test
	public void testsaveEmployees() throws IOException{
		SqlSessionFactory getsessfactory = getsessfactory();
		SqlSession openSession = getsessfactory.openSession();
		try {
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			Department department=new Department();
			department.setDepartmentId(1);
			List<Employee> emps=new ArrayList<>();
			emps.add(new Employee("ee", 12, "aa@qq.com", department));
			emps.add(new Employee("ff", 12, "bb@qq.com", department));
			mapper.saveEmployees(emps);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			openSession.commit();
			openSession.close();
		}
	}
	@Test
	public void testgetEmployeeByChoose() throws IOException{
		SqlSessionFactory sessionFactory = getsessfactory();
		SqlSession session = sessionFactory.openSession();
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			Employee employee=new Employee();
			//employee.setId(1);
			//employee.setEmail("zyk");
//			employee.setAge(18);
			employee.setEmail("%zyk%");
			Employee employeeByChoose = mapper.getEmployeeByChoose(employee);
			System.out.println(employeeByChoose);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	@Test
	public void testgetEmployeeByIf() throws IOException{
		SqlSession session = getsqlsession();
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			Employee employee=new Employee();
			employee.setId(1);
			employee.setName("zhangyukang");
			//employee.setAge(20);
			Employee employeeByIf = mapper.getEmployeeByIf(employee);
			System.out.println(employeeByIf);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	@Test
	public void testgetemployeesstep() throws IOException{
		SqlSession getsqlsession = getsqlsession();
		EmployeeMapper mapper = getsqlsession.getMapper(EmployeeMapper.class);
		List<Employee> getemployeesstep = mapper.getemployeesstep(1);
		System.out.println(getemployeesstep);
	}
	@Test
	public void testgetDepartmentWithEmpStep() throws IOException{
		SqlSessionFactory getsessfactory = getsessfactory();
		SqlSession session = getsessfactory.openSession();
		try {
			DepartmentMapper mapper = session.getMapper(DepartmentMapper.class);
			Department department = mapper.getDepartmentWithEmpStep(1);
			System.out.println(department.getDepartmentName());
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
		
	}
	@Test
	public void testgetDepartmentWithEmployee() throws IOException {
		SqlSessionFactory getsessfactory = getsessfactory();
		SqlSession openSession = getsessfactory.openSession();
		try {
			DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
			Department departmentWithEmployee = mapper.getDepartmentWithEmployee(1);
			System.out.println(departmentWithEmployee);
			List<Employee> employees = departmentWithEmployee.getEmployees();
			for(Employee emp:employees){
				System.out.println(emp);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			openSession.close();
		}
	}

	@Test
	public void testgetEmployeeWithDepartmentStep() throws IOException {
		SqlSessionFactory sessionFactory = getsessfactory();
		SqlSession openSession = sessionFactory.openSession();
		try {
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			Employee employee = mapper.getEmployeeWithDepartmentStep(1);
			System.out.println(employee);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			openSession.close();
		}
	}

	@Test
	public void testgetEmployeeWithDepartment() throws IOException {
		SqlSession sqlsession = getsqlsession();
		EmployeeMapper mapper = sqlsession.getMapper(EmployeeMapper.class);
		try {
			Employee employee = mapper.getEmployeeWithDepartment(1);
			System.out.println(employee);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			sqlsession.close();
		}
	}

	@Test
	public void testgetEmployeeByName() throws IOException {
		SqlSession sqlsession = getsqlsession();
		try {
			EmployeeMapper mapper = sqlsession.getMapper(EmployeeMapper.class);
			Employee employeeByName = mapper.getEmployeeByName("zhangyukang");
			System.out.println(employeeByName);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			sqlsession.close();
		}
	}

	@Test
	public void testgetemployee() throws IOException {
		SqlSession session = getsqlsession();
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			Employee employee = mapper.getEmployeeById(1);
			System.out.println(employee);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			session.commit();
		}
	}

	/**
	 * 获取SqlSessionFactory对象
	 * 
	 * @return
	 * @throws IOException
	 */
	public SqlSessionFactory getsessfactory() throws IOException {
		InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
		SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
		return sqlSessionFactory;
	}

	/**
	 * 获取SqlSession对象
	 * 
	 * @return
	 * @throws IOException
	 */
	public SqlSession getsqlsession() throws IOException {
		SqlSessionFactory getsessfactory = getsessfactory();
		SqlSession session = getsessfactory.openSession();
		return session;
	}

}
package zhang.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 zhang.mybatis.dao.DepartmentMapper;
import zhang.mybatis.dao.EmployeeMapper;
import zhang.mybatis.entities.Department;
import zhang.mybatis.entities.Employee;

public class MybatisCacheTest {
	
	public SqlSessionFactory getSqlSessionFactory() throws IOException{
		InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
		SqlSessionFactory sessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
		
		return sessionFactory;
	}
	//测试整合ehcache的二级缓存
	@Test
	public void testsecondelevelcachedepartmnet() throws IOException{
		SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
		
		SqlSession openSession = sqlSessionFactory.openSession();
		SqlSession openSession2 = sqlSessionFactory.openSession();
		
		try {
			DepartmentMapper mapper = openSession.getMapper(DepartmentMapper.class);
			DepartmentMapper mapper2 = openSession2.getMapper(DepartmentMapper.class);
			
			Department departmentById = mapper.getDepartmentById(1);
			System.out.println(departmentById);
			openSession.close();
			Department departmentById2 = mapper2.getDepartmentById(1);
			System.out.println(departmentById2);
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			
			openSession2.close();
		}
		
	}
	@Test
	public void testsecondLevelCache() throws IOException{
		SqlSessionFactory sessionFactory = getSqlSessionFactory();
		
		
		SqlSession openSession = sessionFactory.openSession();
		SqlSession openSession2 = sessionFactory.openSession();
		try {
			EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
			EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);
			
			
			Employee employeeById = mapper.getEmployeeById(1);
			System.out.println(employeeById);
			
			openSession.close();
			
			Employee employeeById2 = mapper2.getEmployeeById(1);
			System.out.println(employeeById2);
			openSession2.close();
			
		} catch (Exception e) {
			// TODO: handle exception
		}
		
	}
	/**
	 * 一级缓存失效的情况:
	 * 1.两次查询是不同的sqlsession
	 * 2.sqlsession条件不同
	 * 3.在执行两次查询的时候中间有增加,删除,修改操作的时候,一级缓存会失效
	 * 4.手动清了一级缓存中的数据
	 * @throws IOException 
	 */
	@Test
	public void testdisFirstLevelCache() throws IOException{
		SqlSessionFactory sessionFactory = getSqlSessionFactory();
		SqlSession session = sessionFactory.openSession();
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			Employee employeeById = mapper.getEmployeeById(1);
			System.out.println(employeeById);
			
			//第一次查询使用新的sqlsession
			SqlSession session2 = sessionFactory.openSession();
			EmployeeMapper mapper2 = session2.getMapper(EmployeeMapper.class);
			Employee employeeById2 = mapper2.getEmployeeById(1);
			System.out.println(employeeById2);
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}
	/**
	 * mybatis的缓存分为二缓存
	 * 1.一级缓存:本地缓存(是sqlsession级别的缓存)
	 * 2.二级缓存:全局缓存:基于namespace的缓存,一个namespace对应一个二级缓存
	 * 	例如:EmployeeMapper====>employee在回话中查询的(回话结束后,会进入二级缓存中)
	 * 
	 * @throws IOException 
	 */
	@Test
	public void testfirstLevelCache() throws IOException{
		SqlSessionFactory sessionFactory = getSqlSessionFactory();
		SqlSession session = sessionFactory.openSession();
		try {
			EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);
			Employee employee = mapper.getEmployeeById(1);
			System.out.println(employee);
			//session.clearCache();
			employee=mapper.getEmployeeById(1);
			System.out.println(employee);
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			session.close();
		}
	}

}