MYBATIS

​ 针对jdbc进行了封装，整个项目叫做框架，功能就是jdbc的功能，学习是mybatis的新语法。

反射机制

面向对象的基本语法：
	通常都是通过new关键字创建对象，通过对象.的语法调用属性和方法。
	类名  对象名  =  new 类名();
	对象名.属性或者方法()调用。
	
	EmpDao empDao = new EmpDao();
	empDao.test();
	
反射机制：另外一种调用属性和方法的语法。作用：依然是创建对象调用属性和方法，在特定情况下可以利用反射机				制来调用。
		特定的情况：大概率只有字符串类型的类名、属性名、方法名时，可以使用反射来执行
		String name1 = "com.woniu.dao.EmpDao";
		String name2 = "addEmp";
		String name3 = "esex;

加载类，获得类对象

//内容中加载该类信息，不是创建对象,获得该类的类对象(字节码对象)
方式1：
	Class c1 = Class.forName(String  className);
方式2:
	Class c1 = 类型.class
方式3：
	//获得系统类加载器对象
	ClassLoader classLoader = ClassLoader.getSystemClassLoader();
	Class c1 = classLoader.loadClass(String className);
方式4：
	Class c1 = 对象.getClass();
	
注意：	
	Class.forName加载类时会执行static内容
	类加载器加载类时，不会执行静态代码

创建对象

//创建c1类型的对象，就是new EmpDao()
Object obj = c1.newInstance();

获得属性对象

//在字节码对象中根据字符串类型的属性名获得属性对象
Field f1 = c1.getDeclaredField(fieldName1);
Field f2 = c1.getDeclaredField(fieldName2);
System.out.println(f1);
System.out.println(f2);

f1.setAccessible(true); //是否忽略访问权限
f2.setAccessible(true);

//给f1属性对象赋值，参数1：当前f1对象所属对象，参数2：属性值
f1.set(obj, "abc");
f2.set(obj, 10);


//获得f1对象的属性值，参数：f1对象所属对象
Object value1 = f1.get(obj);
Object value2 = f2.get(obj);
System.out.println(value1);
System.out.println(value2);

获得方法对象

//参数1:该方法的名字，参数2：该方法的形参Class类型,
Method method1 = c1.getDeclaredMethod(methodName1);
Method method2 = c1.getDeclaredMethod(methodName2,String.class,int.class);
System.out.println(method1);
System.out.println(method2);


//执行method1方法对象，参数1：当前方法对象所属对象，参数2:动态数组，当前方法对象的实参
//invoke方法的返回值：就是method1方法的返回值
Object obj2 = method1.invoke(obj);
System.out.println(obj2);
Object obj2 = method2.invoke(obj, "abc",100);
System.out.println(obj2);

xml文件

xml：可扩展性标记语言：可以自定义标签的标记语言，作用：将项目中的常量和频繁可修改的变量统一定义在xml文件中，发生变化时直接修改xml文件，不需要修改程序。项目的核心配置文件


<configuration>
	<!-- 定义开发环境，当前环境使用default属性值 -->
	<environments default="d1">
	
		<!--定义环境1，名字叫做d1  -->
		<environment id="=d1">
			<transactionManager type="JDBC"/>
			<!-- jdbc环境1的常量 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.mysql.cj.jdbc.Driver"/>
				<property name="url" value="jdbc:mysql://localhost:3306/test1?serverTimezone=Asia/Shanghai"/>
				<property name="username" value="root"/>
				<property name="password" value="123456"/>
			</dataSource>	
		</environment>
		
		<!--定义环境2，名字叫做d2  -->
		<environment id="=d2">
			<transactionManager type="JDBC"/>
			<!-- jdbc环境1的常量 -->
			<dataSource type="POOLED">
				<property name="driver" value="com.oracle.cj.jdbc.Driver"/>
				<property name="url" value="jdbc:mysql://192.168.11.23:3306/xxx?serverTimezone=Asia/Shanghai"/>
				<property name="username" value="admin"/>
				<property name="password" value="666"/>
			</dataSource>	
		</environment>
		
	</environments>

</configuration>

读取xml文件

依靠jdom.jar,调用jar包中的类方法实现读取xml文件属性值

dtd协议

dtd文件，给xml文件引入dtd协议，给xml定义语法规范

mybatis基本应用

1：引入mysql.jar和mybatis.jar
2：src根目录引入mybatisConfig.xml，mybatis核心配置文件，名字随便改，赋值粘贴会改即可。
		定义了数据源与实体映射配置文件(EmpMapper.xml)
3：自定义定义所需实体类，与操作类接口:只需要定义操作类的接口
4：在dao包中针对EmpMapper创建一个EmpMapper.xml文件：实体映射文件，定义所有的sql语句，
	注意必须全手写，dtd协议中核心配置文件中贴过来，修改3处，将config改成mapper，注意大小写
	所有内容重中之重						
5：在EmpMapper接口中定义方法，在EmpMapper.xml文件中定义每个方法的sql语句，注意名字必须匹配
	
	<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<!-- 当前xml文件，与EmpMapper匹配，理解为当前xml文件就是EmpMapper接口的实现类 -->
<mapper namespace="com.woniu.dao.EmpMapper">
	<!-- 该方法的返回值：resultType:查询一行，返回实体对象，查询多行封装成集合 
		该方法无无参，有参数使用：parameterType
	-->
	<select id="selAll" resultType="com.woniu.entity.Emp">select * from emp</select>
</mapper>

注意：mybatis核心配置文件需要加载当前配置文件的路径
            <mappers>
                <!-- 加载实体映射文件的路径 
                <mapper resource="com/woniu/mapper/StuMapper.xml"/>
                <mapper resource="com/woniu/mapper/KechengMapper.xml"/>
                <mapper resource="com/woniu/mapper/XuankeMapper.xml"/>
                -->
                <!-- 一次性加载该包中所有的xml文件 -->
                <package name="com.woniu.mapper"/>
            </mappers>


main:
	SqlSession session = null;
		try {
			InputStream in = Test.class.getResourceAsStream("/MyBatisConfig.xml");
			//build:读取xml文件中的数据源，封装在factory对象的map中
			SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
			
			//创建SqlSession对象，并创建链接对象
			session = factory.openSession();
			
			//getMapper:根据反射、代理模式，创建了EmpMapper接口的代理类对象
			//代理对象向上转型成EmpMapper父类对象
			EmpMapper empMapper = session.getMapper(EmpMapper.class);
			
			List<Emp> list = empMapper.selAll();
			
			System.out.println(list);
			
			session.commit();
		} catch (Exception e) {
			e.printStackTrace();
			session.rollback();
		}finally {
			session.close();
		}

SqlSessionFactory

SqlSessionFactory
	作用：封装数据源，那么整个项目就使用一个SqlSessionFactory对象即可，使用单例模式
SqlSession：创建数据库链接，并控制事务。
	每个方法都使用自己的SqlSession链接对象，并控制事务。

所以：
	1：将SqlSessionFactory封装成单例模式
		public class MybatisUtil {
            private static SqlSessionFactory factory;
            private MybatisUtil() {}
            static {
                try {
                    InputStream in = Test.class.getResourceAsStream("/MyBatisConfig.xml");
                    factory = new SqlSessionFactoryBuilder().build(in);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            public static SqlSessionFactory getFactory() {
                return factory;
            }
        }
	2：业务层所有方法通过该工具方法获得SqlSessionFactory对象
		public boolean delEmpByEid(int eid){
            SqlSession session = null;
            boolean flag = false;
            try {
                session = MybatisUtil.getFactory().openSession();
                EmpMapper empMapper = session.getMapper(EmpMapper.class);
                flag = empMapper.delByEid(eid);
                session.commit();
            } catch (Exception e) {
                e.printStackTrace();
                session.rollback();
            }finally {
                session.close();
            }
            return flag;
        }
问题：业务层中每个方法的重复代码是：事务处理，所以需要用到代理模式

代理模式

重点理解的是：代理模式的作用：通过一个被代理对象，可以统一给所有的被代理对象添加统一的功能

静态代理

被代理对象：一个对象，通过另外一个对象将该对象代替，被代替的对象称之为被代理对象，
代理对象：代理被被代理的对象称之为代理对象
	//代理对象:代理的是Meinv接口，
//定义一个被代理对象的类属性
//定义一个有参的构造器，创建代理对象时，必须传入一个被代理对象给类属性赋值
//重写被代理对象的方式时：调用了被代理对象的方法，方法之前和之后可以统一添加功能。
public class Meipo implements Meinv{
	private Meinv m;
	public Meipo(Meinv m) {  //参数是被代理对象
		this.m = m;
	}
	@Override
	public void makeEyes() {
		System.out.println("添加了一个功能方法：化妆");
		m.makeEyes();
		System.out.println("添加了一个功能方法：回家");
	}

	@Override
	public void makeHappy() {
		System.out.println("添加了一个功能方法：化妆");
		m.makeHappy();
		System.out.println("添加了一个功能方法：回家");
	}
}
		Meinv r = new Ruhua();
		Meinv f = new Fengjie();
		Meinv meipo = new Meipo(f);
		
		//用代理对象调用方法，现在调用的是meipo的方法，最终必须要调用的是f对象的方法
		meipo.makeEyes();
		meipo.makeHappy();

特点：必须咱们手动定义代理对象，且所有的被代理对象必须实现统一的接口。重点在于代理模式的逻辑思路，jdk代理和cglib代理逻辑与静态代理的逻辑思路一样。

jdk动态代理

jdk已经定义了一个类，依靠传入参数，来创建代理对象，被代理对象依然需要实现统一的接口


/*
		//obj：代理对象,参数1：被代理对象的类加载，参数2：被代理对象的父接口，参数3：方法拦截(接口)器对象
		//Object obj = Proxy.newProxyInstance(loader, interfaces, h);
		Meinv obj = (Meinv)Proxy.newProxyInstance(Ruhua.class.getClassLoader(), Ruhua.class.getInterfaces(),new InvocationHandler() {
			//参数1：代理对象，参数2：被代理对象的方法对象，参数3:被代理对象方法的实参
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				System.out.println(method);
				System.out.println(Arrays.toString(args));
				System.out.println("被代理对象方法执行之前统一添加功能");
				Object obj = method.invoke(Ruhua.class.newInstance(), args);
				System.out.println("被代理对象方法执行之后统一添加功能");
				return obj;
			}
		});
		
		//调用代理对象的方法，先执行代理对象自己的方法：invoke，在该invoke方法里，使用了反射执行了被代理对象的方法method
		obj.makeEyes();
		System.out.println("=============");
		int x = obj.makeHappy(10, "abc");
		System.out.println(x);
*/

cglib动态代理

需要引入cglib.jar和asm.jar
该jar包中定义了类方法，来创建代理对象，被代理对象不需要实现统一的接口，随意代理对象

		B obj = (B)Enhancer.create(B.class, new MethodInterceptor() {
			//参数2：被代理对象的方法对象
			//参数3：被代理对象的方法对象的实参
			public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
				System.out.println("被代理对象方法执行之前添加功能");
				Object value = arg1.invoke(B.class.newInstance(), arg2);
				System.out.println("被代理对象方法执行之后添加功能");
				return value;
			}
		});
		int x = obj.b1(11,"aaa");

ThreadLocal

本地线程存储对象：容器：盒子，存储Object对象
		ThreadLocal<String> local = new ThreadLocal<String>();
		local.set("aaa");
		local.set("bbb");			map.put(当前线程对象,"bbb")
		String s1 = local.get();
		String s2 = local.get();
		System.out.println(s1);
		System.out.println(s2);
	存储对象时：底层源码将要存储的对象存入map的value值，键为当前线程对象，获取对象根据当前线程对象充当键，根据键获得对象:map.get(当前线程对象)
		
		local.remove();   清楚盒子中的对象
		
作业1：完成项目改造，使用cglib代理模式,修改项目架构
作业2：测试jdk代理
作业3：测试静态代理

resultType

定义查询方法的返回类型，要求表的列名与实体类属性名必须一致
	<select id="selAll" resultType="com.woniu.entity.Emp">select * from emp</select>

parameterType

定义方法的参数类型：
<!-- 添加、修改、删除方法可以不用定义返回值类型，一定是int或者boolean -->
	<insert id="addEmp" parameterType="com.woniu.entity.Emp">
		insert into emp values(null,#{ename},#{edate},#{esex},#{eadd},2)
	</insert>
	
#{xxx}:从该方法的实参中，获得xxx的属性值：调用了getXxx();	

#{param1}

<!-- 使用param1的关键字，也不用定义参数类型,获得实参中第一个参数 -->
	<delete id="delEmp" >
		delete from emp where esex=#{param2} or  eid=#{param1}
	</delete>

${}与#{}

都是sql语句的参数赋值
${}：底层使用Statement：会将参数直接拼接在sql语句上，如果需要单引号，必须自己手动添加
#{}：底层使用PreparedStatement，使用?占位符，不需要手动添加单引号，防止sql注入

添加数据返回自增的id

<!-- 开启返回自增id功能  将列keyColumn="eid"的值赋值给实参的属性： keyProperty="eid"-->
	<insert id="addEmp" parameterType="com.woniu.entity.Emp" useGeneratedKeys="true" keyColumn="eid" keyProperty="eid">
		insert into emp values(null,'${ename}',#{eage},#{esex},#{eadd},2)
	</insert>

事务处理

	main
	 ↓
	service包		作用：事务处理：完成客户端的业务要求,替换成代理对象:统一添加事务
	 ↓
	mapper包方法		持久层包，持久层代码，完成curd

resultMap

作用：定义实体类与结果集的映射关系，所以EmpMapper.xml叫做实体映射文件
解决问题1：解决了实体类属性与列名不一致的问题，通过resultMap自定义结果集(自定义映射关系)
	<!-- 自定义映射关系，针对Emp类定义，名字叫做e1, -->
	<resultMap type="com.woniu.entity.Emp" id="e1">
		<!-- 将表中column列与property属性绑定映射 -->
		<id column="eid" property="eid"/>
		<result column="ename1" property="ename"/>
		<result column="eadd" property="eadd"/>
		<result column="esex" property="esex"/>
		<result column="eage" property="eage"/>
	</resultMap>
	<select id="selAll2" resultMap="e1">
		select * from emp
	</select>
解决问题2：封装了多表联查的结果给实体类赋值

表关系，关联查询

1对多，多对1，

1个部门，对应多个员工
多个员工，对应1个部门

多的一方：是员工
1的一方：是部门

特点：在子表中添加主表的主键列充当外键

员工端：多的一方
<resultMap type="com.woniu.entity.Emp" id="e2">
		<id column="eid" property="eid"/>
		<result column="ename1" property="ename"/>
		<result column="eadd" property="eadd"/>
		<result column="esex" property="esex"/>
		<result column="eage" property="eage"/>
		<!-- 每一个员工都关联：一个部门对象，使用association标签
		property：这个部门对象的属性名叫做property
		javaType:这个部门对象的类型是javaType
		 -->
		<association property="dept" javaType="com.woniu.entity.Dept">
			<id column="did" property="did"/>
			<result column="dname" property="dname"/>
		</association>
	</resultMap>
	
	<select id="selAllEmpAndDept" resultMap="e2">
		select * from emp left join dept on emp.did = dept.did
	</select>

部门端：1的一方：
	<resultMap type="com.woniu.entity.Dept" id="d1">
		<id column="did" property="did"/>
		<result column="dname" property="dname"/>
		<!-- 一个Dept对象中，关联了一个集合使用collection
		集合的属性名是property，集合泛型是ofType
		 -->
		<collection property="list" ofType="com.woniu.entity.Emp">
			<id column="eid" property="eid"/>
			<result column="ename1" property="ename"/>
			<result column="eadd" property="eadd"/>
			<result column="esex" property="esex"/>
			<result column="eage" property="eage"/>
		</collection>
	</resultMap>
	<select id="selAllDeptAndEmp" resultMap="d1">
			select * from dept left join emp on dept.did = emp.did
	</select>

1对1

非诚勿扰相亲节目：结果：1个人，只能牵手1个人，或者失败
	
	nv:vid		vname		nid(fk,uni)
		1		如花			3
		2		凤姐			2
		3		石榴姐			1
	
	nan:nid		nname		vid(fk,uni)
		1		张子文			3
		2		陶金			2	
		3		党银辉			1

特点：1个男生，对应1个女生
	1个女生，对应1个男生
	
	
男：
	<resultMap type="com.woniu.entity.Nan" id="n1">
		<id column="nid" property="nid"/>
		<result column="nname" property="nname"/>
		<association property="v" javaType="com.woniu.entity.Nv">
			<id column="vid" property="vid"/>
			<result column="vname" property="vname"/>
		</association>
	</resultMap>
	<select id="selOne" resultMap="n1">
		select * from nv right join nan on nv.nid = nan.nid where nan.nid = #{param1}
	</select>
女：
	<resultMap type="com.woniu.entity.Nv" id="v1">
		<id column="vid" property="vid"/>
		<result column="vname" property="vname"/>
		<association property="n" javaType="com.woniu.entity.Nan">
			<id column="nid" property="nid"/>
			<result column="nname" property="nname"/>
		</association>
	</resultMap>
	<select id="selOne" resultMap="v1">
		select * from nv left join nan on nv.nid = nan.nid where nv.vid = #{param1}
	</select>
	

多对多

1个学生选择多门课
1门课程多人选择

特点：一定是3张表，学神表和课程表没有直接关系，通过第三章表，将两张主表关联起来。

stu
	<resultMap type="com.woniu.entity.Stu" id="s1">
		<id column="sid" property="sid"/>
		<result column="sname" property="sname"/>
		<result column="sbir" property="sbir"/>
		<result column="ssex" property="ssex"/>
		<result column="sadd" property="sadd"/>
		<collection property="xs" ofType="com.woniu.entity.Xuanke">
			<id column="xid" property="xid"/>
			<result column="xnum" property="xnum"/>
			<association property="kecheng" javaType="com.woniu.entity.Kecheng">
				<id column="kid" property="kid"/>
				<result column="kname" property="kname"/>
			</association>
		</collection>
	</resultMap>

kecheng
	<resultMap type="com.woniu.entity.Kecheng" id="k1">
		<id column="kid" property="kid"/>
		<result column="kname" property="kname"/>
		<collection property="xs" ofType="com.woniu.entity.Xuanke">
			<id column="xid" property="xid"/>
			<result column="xnum" property="xnum"/>
			<association property="stu" javaType="com.woniu.entity.Stu">
				<id column="sid" property="sid"/>
				<result column="sname" property="sname"/>
				<result column="sbir" property="sbir"/>
				<result column="ssex" property="ssex"/>
				<result column="sadd" property="sadd"/>
			</association>
		</collection>
	</resultMap>
xuanke
	<resultMap type="com.woniu.entity.Xuanke" id="x1">
		<id column="xid" property="xid"/>
		<result column="xnum" property="xnum"/>
		<association property="kecheng" javaType="com.woniu.entity.Kecheng">
			<id column="kid" property="kid"/>
			<result column="kname" property="kname"/>
		</association>
		<association property="stu" javaType="com.woniu.entity.Stu">
			<id column="sid" property="sid"/>
			<result column="sname" property="sname"/>
			<result column="sbir" property="sbir"/>
			<result column="ssex" property="ssex"/>
			<result column="sadd" property="sadd"/>
		</association>
	</resultMap>

mybatis工作日志

核心配置文件：
<!-- mybatis全局参数设置 -->	
	<settings>
		<!-- 在mybatis执行过程中，控制台打印执行过程 -->
		<setting name="logImpl" value="STDOUT_LOGGING"/>
	</settings>

分页查询

方式1：自己手动分页查询
	一页3行数据
    第1页：
        select * from emp left join dept on emp.did = dept.did
        order by eid desc limit 0,3
    第2页：
        select * from emp left join dept on emp.did = dept.did
        order by eid desc limit 3,3
    第3页：
        select * from emp left join dept on emp.did = dept.did
        order by eid desc limit 6,3
    第4页：
        select * from emp left join dept on emp.did = dept.did
        order by eid desc limit 9,3
    第n页：
        select * from emp left join dept on emp.did = dept.did
        order by eid desc limit (n-1)*m,m
问题：自己写sql麻烦，且参数不容控制(能控制)，mybatis也封装好了分页的方法，就是这个原理


方式2：mybatis进行了封装
	1：引入分页jar包;jsqlparser.jar和pagehelper.jar
	2：在核心配置文件中启用分页查询
			<!-- 添加插件 -->
            <plugins>
                <!-- 添加分页插件 -->
                <plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
            </plugins>
	3：自定义mapper方法，不用分页sql，正常写sql语句
	4：在业务层调用持久层查询之前，调用分页插件的方法：
			public class EmpService {
                public List<Emp> selAllEmpAndDept3(int pageNum, int pageSize){
                    SqlSession session = MybatisUtil.getSqlSession();
                    EmpMapper empMapper = session.getMapper(EmpMapper.class);
                    //启用分页插件
                    PageHelper.startPage(pageNum, pageSize);
                    return empMapper.selAllEmpAndDept();
                }
            }
	
	注意：
	1：当调用了分页查询以后，返回类型为Page对象：extends ArrayList ，就是集合，封装了查询结果Emp
		List<Emp> list = proxy.selAllEmpAndDept3(pageNum,pageSize);
	2：通过分页插件查询以后，查询出来了数据库数据，但是页面上还需要：当前第几页，共几页等等其他数据，所以需要将查询结果Page对象(List)，再进行封装成PageInfo对象
		PageInfo<Emp> pageInfo = new PageInfo<Emp>(list);
		PageInfo<Emp> pageInfo = new PageInfo<Emp>(list);
		int pageNum2 = pageInfo.getPageNum();
		int pageSize2 = pageInfo.getPageSize();
		int pages2 = pageInfo.getPages();
		int firstPage2 = pageInfo.getFirstPage();
		int lastPage2 = pageInfo.getLastPage();
		int nextPage2 = pageInfo.getNextPage();
		List<Emp> list2 = pageInfo.getList();
		
		
新建项目
	完成1：员工部门联合分页查询
    完成2：员工部门联合分页模糊查询
    完成3：完成根据id删除部门
    	public class DeptService(int did){
    		empMapper.delEmpByDid(did);
    		deptMapper.delDeptByDid(did)
    	}注意事务控制

延迟加载(懒加载)

mybatis默认没有开启延迟加载，默认即时加载
目的1：可以实现多表联查
目的2：可以控制关联查询的时间
最终达到优化查询的功能

方式1：即时加载：可以实现多表联查
Emp:
	<resultMap type="com.woniu.entity.Emp" id="e3">
		<id column="eid" property="eid"/>
		<result column="ename1" property="ename"/>
		<result column="eadd" property="eadd"/>
		<result column="esex" property="esex"/>
		<result column="eage" property="eage"/>
		<!-- 定义当前关联对象通过select方法查询
		将当前查询emp表中的列column充当参数传递给com.woniu.mapper.DeptMapper.jishi
		方法，查询每个员工对应的部门信息
		 -->
		<association property="dept" javaType="com.woniu.entity.Dept" select="com.woniu.mapper.DeptMapper.jishi" column="did">
			<id column="did" property="did"/>
			<result column="dname" property="dname"/>
		</association>
	</resultMap>
	<select id="jishi" resultMap="e3">
		select * from emp
	</select>
Dept:
	<select id="jishi" resultType="com.woniu.entity.Dept">
			select * from dept where did=#{param1}
	</select>


方式2：侵入式延迟加载（懒加载）
	在核心配置文件中定义全局参数实现懒加载
	<!-- mybatis全局参数设置 -->	
	<settings>
		<!-- 在mybatis执行过程中，控制台打印执行过程 -->
		<setting name="logImpl" value="STDOUT_LOGGING"/>
		<!-- 启用懒加载模式 -->
		<setting name="lazyLoadingEnabled" value="true"/>
		<!-- 启动侵入式懒加载  -->
		<setting name="aggressiveLazyLoading" value="true"/>
	</settings>
	mapper映射文件配置同上。
	结果：当没有使用当前查询数据Emp时，不执行关联查询（Dept）
		  当使用当前查询数据Emp时，才去执行当前数据的关联数据


方式3：深入式延迟加载(懒加载)
	在核心配置文件中定义全局参数实现懒加载
	<!-- mybatis全局参数设置 -->	
	<settings>
		<!-- 在mybatis执行过程中，控制台打印执行过程 -->
		<setting name="logImpl" value="STDOUT_LOGGING"/>
		<!-- 启用懒加载模式 -->
		<setting name="lazyLoadingEnabled" value="true"/>
		<!-- 关闭侵入式懒加载（默认）  -->
		<setting name="aggressiveLazyLoading" value="false"/>
	</settings>
	mapper映射文件配置同上。
	结果：当没有使用当前查询数据Emp时，不执行关联查询（Dept）
		  当只使用当前查询数据Emp时，也不去执行当前数据的关联数据
		  当使用到关联数据时，采取主动查询关联数据

缓存机制

一级缓存

默认开启状态：
	一级缓存针对的是SqlSession级别的缓存，当同一个SqlSession对象执行第一次sql查询时，先在一级缓存中根据当前sql语句查询是否有记录，如果没有记录，则取执行jdbc查询，再将查询结果存入一级缓存，一级缓存原理是内存中，保存了一个map，键：当前sql语句，值：ResultSet。当同一个sqlSession对象，再次查询该sql语句时，可以直接从缓存中获取数据，不用执行jdbc。当相同的两次sql查询之间，如果执行了增、删、改该数据，则会自动删除该缓存数据。

二级缓存

默认没有开启，需要手动开启
	二级缓存针对Mapper级别，不是必须同一个mapper对象，所有的mapper对象执行相同的sql查询时，先从一级缓存中获取数据，如果没有则到二级缓存中获取数据，如果二级缓存也没有数据，则执行jdbc，查出结果后，将结果存入二级缓存，当执行第二次相同的sql语句时，可以从二级缓存中获取数据。执行增删改数据时，会自动删除二级缓存中的该数据。
	问题：一个客户端操作的不同查询越多，map中的数据越多，越占内存。
		 客户端越多，需要的map越多，越占内存
	解决：三阶段学习缓存数据库redis	 

开启二级缓存：
	1：在核心配置文件中，定义全局参数开启二级缓存
		<!-- 开启二级缓存 -->
		<setting name="cachedEnabled" value="true"/>
	2：针对哪个mapper开启二级缓存
		EmpMapper.xml:
		<mapper namespace="com.woniu.mapper.EmpMapper">
			<cache />
		<mapper>
	3：针对该mapper匹配的实体类需要实现序列化接口。
	

作业1：将员工员工系统，员工和部门的增删查改全部完成
作业2：完成购物商城的表和数据的创建

mybatis动态标签

通过动态标签，根据实参的不同数据，执行不同的sql语句条件
<where> <if>

<select id="sel1" parameterType="com.woniu.entity.Emp" resultType="com.woniu.entity.Emp">
		select * from emp
		<where>
			<if test="eid != null">and eid = #{eid}</if>
			<if test="ename != null">or ename1 = #{ename}</if>
			<if test="eage != null">and eage = #{eage}</if>
		</where>
</select>


<update id="updateEmp" parameterType="com.woniu.entity.Emp">
		update emp
		<set>
			<if test="ename != null">ename1 = #{ename},</if>
			<if test="eage != null">eage = #{eage},</if>
			<if test="esex != null">esex = #{esex},</if>
			<if test="eadd != null">eadd = #{eadd},</if>
		</set>
		<where>
			<if test="eid != null">eid = #{eid}</if>
		</where>
</update>


批量删除：
<delete id="delEmpByEid1">
	delete from emp where eid in
  <foreach collection="array" index="index"  open="(" item="xxx" separator="," close=")">
	#{xxx}
  </foreach>
</delete>

foreach：循环：
collection="array/list"		array/list关键字：该方法参数为数组/恐惧而，循环该数组/集合
index="index"  			index关键字，以下标i的方法循环  for(int i=0;i<10;i++)
open="(" 				以  (  开始拼接
item="xxx" 				数组中每一个元素起名xxx    var xxx = arr[i]
separator="," 			拼接时每一个元素用，分割
close=")"				以  )  结束拼接
delete from emp where eid in  (#{xxx},#{xxx},#{xxx},#{xxx})


批量添加：insert into emp values(值1,值2,值3),(值1,值2,值3),(值1,值2,值3),(值1,值2,值3)
	<insert id="addEmp1" >
		insert into emp values
		<foreach collection="array" index="index" item="it" separator="," >
			(null,#{it.ename},#{it.eage},#{it.esex},#{it.eadd},2)
		</foreach>
	</insert>
	
	<insert id="addEmp2" >
		insert into emp values 
		<foreach collection="list" index="index" item="it" separator="," >
			(null,#{it.ename},#{it.eage},#{it.esex},#{it.eadd},2)
		</foreach>
	</insert>
	
批量添加不允许使用for调用方法：该方法中执行一次jdbc添加数据	
//		for(int i=0;i<ee.length;i++) {
//			empMapper.addEmpx(ee[i]);    不允许，效率太低下
//		} 

逆向工程

1：新建表
2：给eclipse添加插件，将features和plugins拷贝到eclipse/dropins目录中，重启eclipse
3：新建项目，手动导入mybatis和mysql.jar包
4：src根目录上添加逆向工程的xml文件，会改即可。generatorConfig.xml
5：generatorConfig.xml修改完成后，xml文件上右键单击蝴蝶图标即可(注意jdk环境变量需要配置。)
6：文件生成完成后，可以删除。



Mapper中的方法：
	Userinfo u = userinfoMapper.selectByPrimaryKey(Integer uid);			根据id查询
	List<Userinfo> list = userinfoMapper.selectByExample(UserinfoExample e)
	
	int count = userinfoMapper.deleteByPrimaryKey(Integer uid);				根据id删除
	int count = userinfoMapper.deleteByExample(UserinfoExample e);
	
	int count = userinfoMapper.insert(Userinfo u);				每一列都插入数据
    实参属性不为null，插入表中，属性值为null,则插入默认值，没有默认值就是null
	int count = userinfoMapper.insertSelective(Userinfo u);		
	
	
	int count1 = userinfoMapper.updateByPrimaryKey(Userinfo u);			根据id修改每一列
	根据id修改不为null的列
	int count2 = userinfoMapper.updateByPrimaryKeySelective(Userinfo u) 
	//参数1：修改的新值；参数2：条件
	int count3 = userinfoMapper.updateByExample(Userinfo u,UserinfoExample e);
	//参数1：修改的新值；参数2：条件
	int count4 = userinfoMapper.updateByExampleSelective(Userinfo u,UserinfoExample e)
	
	//根据条件，同级行数
	int count = userinfoMapper.countByExample(UserinfoExample e);

UserinfoExample：
==================================================================================
//userinfo表的条件模板对象
			UserinfoExample example = new UserinfoExample();
			
			//排序
			example.setOrderByClause("uid desc");
			
			//条件标准对象1
			Criteria c1 = example.createCriteria();
//			c1.andUaccEqualTo("aaa");
//			c1.andUaccLike("%a%");
			c1.andUidBetween(10,15);
			c1.andUsexEqualTo("男");
			//条件标准对象2
			System.out.println(example);
			Criteria c2 = example.createCriteria();
			c2.andUidBetween(1, 4);
			
			//c1 || c2
			example.or(c2);
			System.out.println(example);
			
			Criteria c3 = example.createCriteria();
			c3.andUadd1IsNotNull();
			example.or(c3);
			
			List<Userinfo> list = userinfoMapper.selectByExample(example);
			System.out.println(list);	
			
注意：所有提供的方法全是单表操作，没有关联关系，没有返回自增id，没有批量添加，所以可以自定添加方法。


作业：员工与部门逆向工程，完成12个功能，（mapper中11个功能，自己添加关联查询）