MyBatis-入门版本.02

MyBatis

作者：宇哥 WeChat/QQ: Warmheart170712 / 939638113
整理不易，重在分享，欢迎转发收藏，助力面试上岸，学编程找宇哥！
demo1

1、MyBatis简介 1.1 MyBatis历史

MyBatis最初是Apache的一个开源项目iBatis。之后迁移到Goole Code，
iBatis3.x正式更名为MyBatis，代码之后迁移到Github。
iBatis是一个基于Java的持久层框架，iBatis提供的持久层框架包括：
SQL、Maps和Data Access Objects(DAO)

1.2 MyBatis特性

1 MyBatis是支持定制化SQL。存储过程以及高级映射的优秀的持久层框架
2 MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集
3 MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和java的POJO（普通的java对象 Plain Old Java Objects）映射成数据库中的记录。
4 MyBatis是一个半自动的ORM框架（Object Relation Mapping）

1.3 MyBatis下载

MyBatis的下载地址：https://github.com/mybatis/mybatis-3

1.4 和其他持久层技术对比

1 JDBC：
	SQL夹杂在java代码中，耦合度高，导致硬编码内伤
	维护不易且实际开发中SQL有变化，频繁修改的情况多见
	代码冗长，开发效率低

2 Hibernate 和 JPA
	操作简便，开发效率高
	程序中的长难复杂SQL需要绕过框架
	内部自动产生的SQL，不容易做特殊优化
	基于全映射的全自动框架，大量字段的POJO进行部分映射时比较困难
	反射操作太多，导致数据库性能下降

3 MyBatis
	轻量级，性能出色
	SQL和java代码分开，功能边界清晰，java代码专注业务，SQL语句专注数据
	开发效率稍逊于Hibernate，但是完全能够接受

2、搭建MyBatis 2.1 开发环境

IDEA 2920.1
Maven:3.6.3
MariaDB:10.3.
MyBatis:5.3.7

2.2 创建maven工程 (jar包，引入依赖)

1 打包方式jar
	jar

2 引入依赖
    
        
        
            org.mybatis
            mybatis
            3.5.7
        

        
        
            junit
            junit
            4.12
            test
        

        
        
            mysql
            mysql-connector-java
            8.0.28
        
    

2.3 创建数据库配置文件jdbc.properties

习惯命名为：jdbc.properties
配置文件存放的位置是：src/main/resources目录下

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/sggmybatis?characterEncoding=UTF-8
jdbc.username=root
jdbc.password=root

2.4 创建MyBatis的核心配置文件

习惯上命名为mybatis-config.xml,这个文件名仅仅是建议，并非强制要求，
将来整合spring之后，这个配置文件可以省略，所以大家操作时可以直接复制粘贴

核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息
核心配置文件存放的位置是：src/main/resources目录下

2.5 创建mapper接口

MyBatis中的mapper接口相当于以前的Dao
区别在于：mapper仅仅是接口，我们不需要提供实现类

public interface UserMapper {
    //添加用户
    int insertUser();
}

2.6 创建MyBatis的映射文件

1 相关概念：
	ORM（Object Relationship mapping）对象关系映射
	对象：Java的实体类对象
	关系：关系型数据库
	映射：二者之间的对应关系

2 映射文件的命名规则
	表对应的实体类的类名+Mapper.xml
	一个映射文件对应一个实体类，对应一张表的操作
	MyBatis的映射文件用于编写SQL，访问以及操作表中的数据
	MyBatis的映射文件存放的目录是：src/resources/mappers目录下

3 MyBatis中可以向面向接口操作数据，要保证两个一致
	mapper接口的全类名和映射文件的命名空间（namespace）保持一致
	mapper接口中方法的方法名和映射文件中编写SQL的标签的id属性一致

备注：一般情况下习惯操作
	1)mapper接口的名称与mapper.xml映射文件的名称保持一致
	2)mapper接口的包类路径（src/main/java下）与
			mapper.xml映射文件的路径（src/main/resources下）保持一致
	3) mapper接口的层级包是以点分隔的
	4) mapper.xml文件的层级包是以正斜杠分隔的

UserMapper.xml映射文件：




    
    
        insert into t_user values (null,'tom','123456',22,'man','123456@qq.com')
    

2.7 通过junit测试功能

1 SqlSession的创建步骤：
	1 读取MyBatis的核心配置文件
	2 创建SqlSessionFactoryBuilder对象
	3 通过核心配置文件对应的输入流，创建工厂类SqlSessionFactory 
	4 创建sqlSession对象
	5 通过代理模式创建自定义mapper接口的代理实现类对象
	6 调用自定义mapper接口的中的方法，
		就会根据自定义mapper的全类名匹配映射文件，
		通过调用的方法名匹配映射文件中SQL标签中的id属性值，
		并执行标签中的SQL语句
	7 sqlSession提交事务
	8 关闭sqlSession会话


解释：
	SqlSession：代表Java程序和数据库之间的会话
	HttpSession是Java程序和浏览器之间的会话
	SqlSessionFactory：是生产SqlSession对象的工厂
	工厂模式：
		如果创建一个对象，使用的过程都是基本固定的，
		那么我们就可以把创建这个对象的相关代码封装到一个工厂类中，
		以后使用这个工厂类来生产我们想要的对象

2 关于sqlSession提交事务的问题：
	 MyBatis对于增删改的业务需要操作事务，
	 如果未设置事务，则测试运行不报错，但数据库数据未发生变化
	 
	 sqlSession提交事务的两种方式：
		 方式一：手动提交
		 	通过sqlSession.commit()方法提交事务
		 方式二：自动提交
		 	在创建SqlSession对象时，参数设置为true，进行事务提交
		 	SqlSession sqlSession = 
		 				sessionFactory.openSession(true);

    @Test
    public void testMyBatis1() throws IOException {
        //1.加载核心配置文件
        InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");
        //2.获取会化工厂的构建对象SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                new SqlSessionFactoryBuilder();
        //3.获取会话工厂对象SqlSessionFactory
        SqlSessionFactory sessionFactory = sqlSessionFactoryBuilder.build(stream);
        //4.获取SqlSession--代表java程序和数据库之间的会话
        SqlSession sqlSession = sessionFactory.openSession(true);
        //5.获取mapper接口对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        //6.调用方法
        int result = userMapper.insertUser();
        //7.提交事务
        sqlSession.commit();
        System.out.println(result);
    }

运行结果
查看数据库：数据添加成功

2.8 加入log4j日志功能

1 添加依赖
		
            log4j
            log4j
            1.2.17
        

2 加入log4j配置文件
  位置：src/main/resources 目录下
	
日志的级别：：从左到右打印的越老越详细
FATAL(致命) > ERROR（错误 > WARN（警告）> INFO（信息）> DEBUG(调试)

2.9 MyBatis 的执行流程

3、MyBatis的增删改查 3.1 搭建MyBatis框架—添加功能

    //添加用户
    int insertUser();

    
        insert into t_user values (null,'tom','123456',22,'man','123456@qq.com')
    

3.2 搭建MyBatis框架—优化功能

1 创建工具类SqlSessionUtils，封装SqlSession的创建过程

public class SqlSessionUtils {
    public static SqlSession getSqlSession() throws IOException {
        SqlSession sqlSession = null;
        try {
            InputStream stream = 
            		Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    new SqlSessionFactoryBuilder();
            SqlSessionFactory build = 
            		sqlSessionFactoryBuilder.build(stream);
            //true表示自动提交事务
            sqlSession = build.openSession(true);
        }catch (Exception e){
            e.printStackTrace();
        }
        return sqlSession;
    }
}

3.3 搭建MyBatis框架—修改和删除功能

    //修改用户信息
    void updateUser();

    //删除用户信息
    void deleteUserById();

	
    
        update t_user set username = '尼古拉斯' where id = 4
    

    
    
        delete from t_user where id=7
    

3.4 搭建MyBatis框架—查询功能

查询功能的标签必须设置resultType和resultMap
        	resultType：设置默认的映射关系
        	resultMap:设置自定义的映射关系

    //查询用户信息
    List findAll();

    //查询用户通过id
    User findUserBId();

    
    
        select * from t_user
    

    
    
        select * from t_user where id=5
    

4、核心配置文件详解

核心配置文件的标签必须按照固定顺序：
	properties
	settings
	typeAliases
	objectFactory
	objectWrapperFactory
	reflectorFactory
	plugins
	environments
	databaseIdProvider
	mappers

4.1 核心配置文件— environments

environments的作用：配置多个连接数据库的环境
	属性：default="development"：用来设置默认使用环境的id，为开发环境
	
environment：配置某个具体的环境
	属性：id="development"：表示连接数据库环境的唯一标识，不能重复
	
transactionManager：设置事务管理方式
	属性：type=“JDBC/MANAGED”
	     JDBC：表示当前环境中，执行SQL时，使用的是JDBC中原生的事务管理方式，
			   事务的提交和回滚需要手动处理
         MANAGED：被管理，例如spring

dataSource：配置数据源
	属性：type：设置数据源的类型
		 type=“POOLED/UNPOOLED/JNDI”
         		POOLED：表示使用数据库连接池缓存数据库连接
                UNPOOLED：表示不使用数据库连接池
                JNDI：表示使用上下文中的数据源
              
设置数据库的连接驱动

设置数据库的连接地址

设置数据库的连接用户名

设置数据库的连接密码
		

4.2 核心配置文件— properties

 用于引入外部的后缀名为properties的文件
 数据部原配置中，使用${key}来获取其对应的value值
 
 

4.3 核心配置文件— typeAliases

typeAlias 设置某个类型的别名
       属性：
           type="设置需要设置别名的类型"
           alias=“设置某个类型的别名，若不设置该属性，
                    那么该类型拥有默认的别名，即类名，不区分大小写 ”

方式一：
	设置具体的包类全路径，以及设置别名，默认设置类名或类名小写，
	也可以自定义

		



方式二：
	以包为单位，将包下所有的类型设置默认的类型别名，
	即类的名称，不区分大小写

		

4.4 核心配置文件— mappers

方式一：
	设置映射文件资源全路径全名
		要求：
			在resources目录下不能使用点，需要使用全名称
	使用斜杠分隔：
			resource="com/zzy/mapper/UserMapper.xml"
			
方式二：
	以包未单位引入映射文件
		要求：
		1 mapper接口所在的包和映射文件所在的包路径一致,
		  且目录之间使用/分隔，不使用点
		2 mapper接口要和映射文件的名称一致
	使用点分隔：
			name="com.zzy.mapper"

方式一：
	设置映射文件资源全路径全名

    


方式二：
	以包未单位引入映射文件

    

思考：
	mapper.xml文件在java目录下和在resource目录下的场景如何使用

demo02

5、MyBatis获取参数值的两种方式(重点)

MyBatis获取参数值的两种方式：${}和#{}
    ${}：本质是字符串拼接，加引号
    #{}：本质是占位符赋值

面试题：#和$的区别

5.1 单个字面量类型的参数

情况1、
   mapper接口方法的参数为单个字面量类型
   可以通过${}和#{}以任意的名称获取参数值，
   但是要注意${}的单引号问题
   
方法：根据用户名查询用户信息
	 User findUserByUserName(String username);

方式一：使用#{}

        select * from t_user where username = #{username};-
   

方式一：使用${},注意引号问题

        select * from t_user where username = "${username}";

5.2 多个字面量类型的参数

情况2：
  mapper接口方法的参数为多个个字面量类型
 	此时mybatis会将这些参数存储在一个map集合中，以两种方式进行存储
    1、以arg0.arg1...为键，以参数为值
    2、以param1，param2...为键，以参数为值
       因此只需要通过#{}和${}以键的方式访问即可，
       但是需要注意${}的单引号问题

方法：使用mybatis默认的map集合
	User checkLogin(String username,String password);

程序传递过来的参数1和参数2会维护在map集合中，
        map的key为：arg0,arg1 或者param1,param2
        需要使用map的key(arg0,arg1 或者 param1,param2，
        或者二者混合使用 arg0,param1)获取参数的值。
        故条件使用：
        	username=#{arg0} and password=#{arg1}

如果使用username=#{username} and password=#{password}
	则会出现binding异常，会报‘username’ no found
	报错的原因是：传递进来的参数维护在map中，
			map的key有四个值，分别是arg0,arg1,param1,param1，
			value是：username和password的真实值           

错误写法SQL：


    select * from t_user where username=#{username} and password=#{password}

 
正确写法SQL：


    select * from t_user where username=#{arg0} and password=#{arg1}

5.3 map集合类型的参数

情况3：
  mapper接口方法的参数有多个时，可以手动将参数放在一个map中存储
  此时map中的键值自行手动设置的，不是默认的
  因此只需要通过#{}和${}以键的方式访问，获得key对应的value值，
  但是需要注意${}的单引号问题

方法：
	User checkLoginMap(Map map);

        select * from t_user where username=#{username} and password=#{password}

 
测试代码：
	@Test
    public void testCheckLoginMap() throws IOException {
        SqlSession sqlSession = 
        			SqlSessionUtils.getSqlSession();
        ParemeterMapper mapper = 
        			sqlSession.getMapper(ParemeterMapper.class);
        Map map = new HashMap<>();
        //将数据以k-v的形式放在map中
        map.put("username", "tom");
        map.put("password", "123456");
        User user = mapper.checkLoginMap(map);
        System.out.println(user);
    }
 
 
 
 
 
5.4 实体类类型的参数 
情况4：
    mapper接口方法的参数是一个实体类类型的参数
    因此只需要通过#{}和${}以属性的方式获取属性值即可，
    		但是需要注意${}的单引号问题
方法：
	int addUser(User user);
 

        insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email});

 
5.5 使用@Paran标识参数 
情况5：
    使用@Param注解命名参数
    此时mybatis会将这些参数存储在一个map集合中，以两种方式进行存储
     	1、以@param注解的值为键，以参数为值
        2、以param1，param2...为键，以参数为值
  	MyBatis默认会将传递的参数存储在map集合中，
  		以当前@Param注解中的值为map的键，来获取属性值，
  		即：map中的键的值是注解中的值
	因此只需要通过#{}和${}以属性的方式获取属性值即可，
		但是需要注意${}的单引号问题

方法：
	User checkLoginByParam(@Param("username") String usernme, @Param("password") String password);
 

     select * from t_user where username=#{username} and password=#{password}

测试代码：
	 @Test
    public void testLoginByParam() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        ParemeterMapper mapper = sqlSession.getMapper(ParemeterMapper.class);
        User user = mapper.checkLoginByParam("lucy", "123456");
        System.out.println(user);
    }

6、MyBatis的各种查询功能 6.1 查询一个实体类对象

情况1：
    MyBatis的各种查询功能--查询返回一个实体类对象
    若查询出的数据只有一条，可以通过实体类对象接收,或者集合接收

方法：
	User getUserById(@Param("id") Integer id);

        select * from t_User;

 
6.2 查询一个list集合 
MyBatis的各种查询功能--查询返回一个list集合
   若查询出的数据由多条，可以通过list集合接收
   一定不能通过实体类来接收，会报异常TooManyResulrsException

方法：
	List getAllUser();
 

        select * from t_User;

6.3 查询单个数据

情况3：
    MyBatis的各种查询功能--查询单个数据
    MyBatis设置了默认的类型别名
	    java.lang.Integer  -  int/Intefer
	    int ---- _int/_Integer
	    Map --- map
	    
方法：查询总记录数
	Integer getCount();

        select count(*) from t_user

 
6.4 查询一条数据为map集合 
情况4：
    MyBatis的各种查询功能 --查询一条数据为map集合
    查询结果为map集合：以字段为键，以字段所对应的值为值

方法：根据id查询结果返回为map集合
	Map getUserByIdToMap(@Param("id") Integer id);
 

        select * from t_user where id = #{id}

测试代码：

	@Test
    public void getUserByIdTpMap() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        Map map = mapper.getUserByIdToMap(16);
        System.out.println(map);
        System.out.println(map.get("username"));
    }

6.5 查询多条数据为map集合

情况5：
   MyBatis的各种查询功能--查询多条数据为map集合
   方式一：封装成List>
   方式二：封装成Map嵌套Map
     @MapKey注解，将每条数据转换成map集合作为值，
     以某个字段的值作为键，
     放在同一个map集合中
     
方法1：
	查询多条数据 封装到List-map集合中
    List> getAllUserToListMap();

方法2：
	查询多条数据 封装到map集合中
		将表中的id字段作为map的key，将查询的每条数据封装到map中作为value
    	最后存储到map中，相当于map嵌套map
    	
	注解中的id表示map的key，value是每天数据封装到map 
		即Map<"id","map">
    @MapKey("id")
    Map getAllUserToMap();

List集合map：
 
        select * from t_user
 
 
Map集合map：
 
        select * from t_user
 

	方式一：查询多条数据为list-Map集合
 	@Test
    public void getUserToListMap() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        List> listMap = mapper.getAllUserToListMap();
        listMap.forEach(map -> System.out.println(map));
    }


    方式二：查询多条数据为Map集合
    @Test
    public void getUserToMap() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
        Map map = mapper.getAllUserToMap();
        System.out.println(map);
    }

7、特殊SQL的执行—使用${} 7.1 模糊查询

情况1、根据用户名模糊查询用户信息
		  方式一：使用${}进行字符串拼接
		  放肆二：使用concat关键字拼接以及#{)占位符
		  使用#{}占位符操作

方法：根据用户名模糊查询用户信息
       List getUserByLike(@Param("username")String username);

     模糊查询：三种方式
     方案一：使用${}进行字符串拼接
     原始SQL：select * from t_user where username like "%${username}%"
     解析SQL：Preparing: select * from t_user where username like "%a%"

     方案二：常用方式-使用concat关键字拼接以及#{)占位符
     原始SQL：select * from t_user where username like concat('%',#{username},'%')
     解析SQL：Preparing: select * from t_user where username like concat('%',?,'%')

     方案三：常用方式-使用#{}占位符操作
     原始SQL：select * from t_user where username like "%"#{username}"%"
     解析SQL后Preparing: select * from t_user where username like "%"?"%"

测试代码：

	@Test
    public void testGetUserByLike() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlLikeMapper mapper = sqlSession.getMapper(SqlLikeMapper.class);
        List list = mapper.getUserByLike("a");
        list.forEach(user -> System.out.println(user));
    }

7.2 批量删除

批量删除
	方法：
	int deleteMore(@Param("ids") String ids);
	
  	批量删除只能使用${},以字符串形式拼接进行删除，
		delete from t_user where id in (${ids})
		Preparing: delete from t_user where id in (13,14,15)
		
    不能使用#{}，会自动添加单引号。只会删除第一条，其余不删除
		delete from t_user where id in (#{ids})
		Preparing: delete from t_user where id in (?)

        delete from t_user where id in (${ids})

7.3 动态设置表名

情况3：动态设置表名
		只能使用${},不能使用#{}，因为表名不能加单引号

方法：
List getUserByTableName(@Param("tableName") String tableName);

	使用${}解析后的SQL：
		Preparing: select * from t_user;
	使用#{}解析后的SQL：
		Preparing: select * from ?;
		此时会报错。会给表名添加单引号，报错如下
		Caused by: java.sql.SQLSyntaxErrorException:You have an error in your SQL syntax;check the manual that corresponds to your MariaDB server versionfor the right syntax to use near ''t_user'' at line 1

        select * from #{tableName};

测试代码：

 	@Test
    public void testSetTableName() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlLikeMapper mapper = sqlSession.getMapper(SqlLikeMapper.class);
        List list = mapper.getUserByTableName("t_user");
        list.forEach(user -> System.out.println(user));
    }

7.4 添加功能获取自增的主键

情况4：添加功能获取自增的主键

方法：
	int insertUser(User user);	

      新增用户信息同时获取新增数据的主键
		useGeneratedKeys="true"：
			设置当前标签中的SQL使用了自增的id
		keyProperty="id"：
			将自增的主键的值，赋值给传输到映射文件中参数的某个属性

 
        insert into t_user values (null,#{username},#{password},#{age},#{sex},#{email})

测试代码：

    @Test
    public void TestInsertUserGetAutoPrimaryKey() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        SqlLikeMapper mapper = sqlSession.getMapper(SqlLikeMapper.class);
        User user = new User(null, "孙悟空","11111" , 33, "man", "12345@qq.com");
        mapper.insertUser(user);
        System.out.println(user.getId());
    }

demo03

8、自定义映射resultMap 8.1 resultMap处理字段和属性的映射关系（三种方式）

1 解决字段名和属性名不一致
    方式一：为字段起别名，保持和属性名一致
    方式二：核心配置文件中配置全局驼峰命名，将_自动映射成驼峰命名
      
    方式三：取消核心配置文件的驼峰命名，使用resultMap，
    		设置自定义之间的关系，使用字段名映射属性名

注意：如果属性名和字段名不一致，不对其进行以上三种方式操作
	 别名设置，或开启核心配置文件全局驼峰，或者自定义关系映射
	 那么查询结果中，此属性的值为null

1.1 方式一：为字段起别名
	数据库字段名：emp_name
	实体类属性名：empName
	要求：为字段起别名，其别名必须和实体类的属性名一致
	
	SQL案例如下：
		select eid,emp_name empName,age,sex,email from t_emp

1.2 方式二：MyBatis核心配置文件中配置全局驼峰命名，将_自动映射成驼峰命名
	
	
	SQL案例如下：直接查询，不需要别名
		select eid,emp_name,age,sex,email from t_emp

1.3 方式三：取消核心配置文件的驼峰命名，使用resultMap，
		设置自定义之间的关系，使用字段名映射属性名
		
方法：
	List findAllEmp2();
属性：
    id:设置主键的映射关系
    result：设置其他普通属性的映射关系
    property：设置映射关系的属性名，必须是type属性所设置的实体类类型中的属性名
    column：设置数据映射关系的字段名，必须是SQL查询出来的表的字段名
    resultMap：设置自动以映射关系
    resultMap中的id：设置唯一标识，不能重复
    type：设置映射关系中的实体类类型

1.3 方式三：resultType自定义关系，解决字段名属性名不一致的SQL

	
        
        
        
        
        
    
    
        select * from t_emp;
    

1.3 方式三：测试代码

	@Test
    public void testResultMap2() throws IOException {
        SqlSession sqlSession = 
        				SqlSessionUtils.getSqlSession();
        EmpMapper mapper = 
        				sqlSession.getMapper(EmpMapper.class);
        List list = mapper.findAllEmp2();
        list.forEach(emp -> System.out.println(emp));
    }

1.3 方式三：测试结果

8.2 resultType 多对一映射处理（三种方式）

实体类Emp1 ：员工表和部门表示多对一的关系

8.2.1 级联方式处理映射关系

需求：根据员工eid查询对应员工信息，以及员工的部门信息，
	 员工表和部门表的关系维护在多的一方，也就是员工表中的did字段

1 方式一：级联属性赋值
            多对一查询：
            查询员工以及员工做对应的部门信息，
            即：多个员工对应一个部分，关联关系在多的一方
            
            方式一：级联属性赋值
    		Emp1 getEmpAndDept(@Param("eid") Integer eid);

2 多对一-级联赋值查询SQL语句

    
        
        
        
        
        
        
        
        
    
    
        select * from t_emp1 left join t_dept on t_emp1.did = t_dept.did where t_emp1.eid = #{eid}
    
 
3 测试代码
	@Test
    public void testEmpDept() throws IOException {
        SqlSession sqlSession = 
        				SqlSessionUtils.getSqlSession();
        EmpMapper mapper = 
        				sqlSession.getMapper(EmpMapper.class);
        Emp1 emp1 = mapper.getEmpAndDept(5);
        System.out.println(emp1);
    }
 
 
 
4 测试结果
 
 
 
8.2.2 使用association处理映射关系 
需求：根据员工eid查询对应员工信息，以及员工的部门信息，
	 员工表和部门表的关系维护在多的一方，也就是员工表中的did字段
 
1 方式二：对一查新，映射使用association标签

	方法：
	Emp1 getEmpAndDept2(@Param("eid") Integer eid);

	association：联合，即处理多对一的映射关系
	property：需要处理的映射关系的属性名
	javaTyoe:该property属性的java类型

	property="dept" javaType="Dept"
	  dept是emp1中的属性名称
	  将查询到的字段did与java类型Dept中的did属性进行映射
	  将查询到的字段dept_name与java类型Dept中的deptName属性进行映射
	  映射完毕之后得到java的Dept类型的dept对象
	  再将此dept对象赋值给java类型Emp1中的dept属性
 
2 多对一查询使用association标签SQL语句

    
        
        
        
        
        
        
            
            
        
    
    
        select * from t_emp1 left join t_dept on t_emp1.did = t_dept.did where t_emp1.eid = #{eid}
    

3 测试代码

	@Test
    public void testEmpDept2() throws IOException {
        SqlSession sqlSession = 
        			SqlSessionUtils.getSqlSession();
        EmpMapper mapper = 
        			sqlSession.getMapper(EmpMapper.class);
        Emp1 emp1 = mapper.getEmpAndDept2(5);
        System.out.println(emp1);
    }

4 测试结果

8.2.3 分步查询

需求：根据员工eid查询对应员工信息，以及员工的部门信息，
	 员工表和部门表的关系维护在多的一方，也就是员工表中的did字段

1 方式三：分步查询： 

	方法：
	Emp1Mapper方法：第一步
		Emp1 getEmpAndDept3(@Param("eid") Integer eid);
	DeptMapper方法：第二步
		Dept getDeptByEmp1Did(@Param("did") Integer did);

	数据库表emp1表维护对多一的关系，即部门的did主键作为emp1的外键存在
	步骤1：现根据eid查询得到员工信息，包括员工对应的did的值
	步骤2：通过did的值，映射到DeptMapper中，
		  执行根据did查询部门此案系的操作
    最后通过association标签进行联合
	
属性：
property="dept" ：
	表示Emp1中的属性
select="com.zzy.mapper.DeptMapper.getDeptByEmp1Did"：
	设置分步查询的SQL的唯一标识
	即：(namespace.sqlId,或者mapper接口的全类名.方法名)
	表示用DeptMapper中的方法，即通过Emp1中的did获取对应的Dept部门信息
column="did" :
	设置分步查询的条件，即did指的是员工表和部门的关系字段
	即通过查询得到的员工信息Emp1中的did的值，去dept表中查询对应部门信息
	再将部门的信息赋值给属性dept
fetchType=“lazy/eager”: 
	当开启全局延迟加载之后，可通过此属性设置延迟加载的效果
	
	lazy 表示延迟加载   eager表示立即加载

3 多对一关系分步查询SQL

第一步：Emp1Mapper.xml中书写

    
        
        
        
        
        
        
        
    
    
        select * from t_emp1 where eid = #{eid}
    

第二步：DeptMapper.xml中书写
    
    
        select * from t_dept where did = #{did}
    

3 测试代码
	@Test
    public void testEmpDept3() throws IOException {
        SqlSession sqlSession = 
        			SqlSessionUtils.getSqlSession();
        EmpMapper mapper = 
        			sqlSession.getMapper(EmpMapper.class);
        Emp1 emp1 = mapper.getEmpAndDept3(5);
        //System.out.println(emp1);
        //查看延时加载的效果
        System.out.println(emp1.getEmpName());
        System.out.println(emp1.getDept());
    }

4 测试结果

8.2.4 分布查询的延迟加载

1 MyBatis核心配置文件中配置延迟加载

2 延迟加载、紧急加载

	FetchType.LAZY：
		懒加载，加载一个实体时，定义懒加载的属性不会马上从数据库中加载。
	FetchType.EAGER：
		急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载

8.3 resultType 一对多映射处理

实体类Dept ：部门表和员工表示一对多的关系

8.3.1 collection

需求：根据部门did查询对应部门信息，以及部门下的员工信息，
	 员工表和部门表的关系维护在多的一方，也就是员工表中的did字段

1 一对多查询collection标签

    查询部门信息以及部门信息中的员工信息，使用集合属性设置员工信息
    
	方法：
	Dept getDeptAndEmp(@Param("did") Integer did);

	属性：
     collection:用来处理一对多的关系
     property="emp1s"：表示Dept实体类中的emp1s属性
     ofType：表示该属性所对应的集合中存储的数据的类型

2  一对多collection标签的SQL

   
        
        
        
            
            
            
            
            
        
    
    
        select * from t_dept left join t_emp1 on t_dept.did = t_emp1.did where t_dept.did = #{did}
    
 
3 测试代码

 	@Test
    public void testDeptEmp() throws IOException {
        SqlSession sqlSession = 
        			SqlSessionUtils.getSqlSession();
        DeptMapper mapper = 
        			sqlSession.getMapper(DeptMapper.class);
        Dept dept = mapper.getDeptAndEmp(2);
        System.out.println(dept);
    }
 
 
 
4 测试结果
 
 
 
8.3.2 分步查询 
需求：根据部门did查询对应部门信息，以及部门下的员工信息，
	 员工表和部门表的关系维护在多的一方，也就是员工表中的did字段
 
1 一对多分布查询
方法：
	DeptMapper方法：第一步
		Dept getDeptAndEmp2(@Param("did") Integer did);
	Emp1Mapper方法：第二步
		Emp1 getEmpByDeptDid(@Param("did") Integer did);

属性：
	property="emp1s" :
		Dept实体类中的emp1s属性
	select="com.zzy.mapper.EmpMapper.getEmpByDeptDid"
		表示应用EmpMapper中的方法，即通过Dept中的did对应Emp1中的did获取对应的emp的信息
	column="did" :
		did指的是员工表和部门的关系字段
		即通过查询Dept中的did的值，去emp1表中查询对应员工信息
		再将员工的信息赋值给属性emp1s
	fetchType=“lazy/eager”: 
		当开启全局延迟加载之后，可通过此属性设置延迟加载的效果
     	
        lazy 表示延迟加载   eager表示立即加载
 
2 一对多分步查询SQL

第一步：DeptMapper.xml中书写
	
        
        
        
    
    
        select * from t_dept where did = #{did}
    
    
第二步：Emp1Mapper.xml中书写
	
        select * from t_emp1 where did = #{did}
    
 
3 测试代码

	@Test
    public void testDeptEmp2() throws IOException {
        SqlSession sqlSession = 
        			SqlSessionUtils.getSqlSession();
        DeptMapper mapper = 
        			sqlSession.getMapper(DeptMapper.class);
        Dept dept = mapper.getDeptAndEmp2(1);
        //System.out.println(dept);
        //测试验延迟加载
        System.out.println(dept.getDeptName());
        System.out.println(dept.getEmp1s());
    }
 
 
 
4 测试结果
 
 
 
9、动态SQL 
9.1 if 标签 
1 if标签-----动态SQL多条件查询

    方法：
    List getEmpByMoreConndition(Emp1 emp1);
    
    标签含义：
    if:判断标签
      根据test属性对应的表达式决定标签中的内容是否需要拼接到SQL中，
      
      1=1 恒成立的条件，如果后续的都不成立，那么1=1的作用就体现出来了，
      select * from t_emp1 where 1=1
      如果if判断的条件均不满足，则SQL执行后where关键字后面无内容，
      即：select * from t_emp1 where
      所以需要拼接1=1 绝对成立的条件，达到符合SQL语法的目的。如：
      select * from t_emp1 
      				where 1=1 
		      				and emp_name = ? 
		      				and age = ? 
		      				and sex = ? 
		      				and email = ?
 
2 if标签SQL语句


        select * from t_emp1 where
        
        
            emp_name = #{empName}
        
        
            and age = #{age}
        
        
            and sex = #{sex}
        
        
            and email = #{email}
        
    
 
3 测试if标签

    @Test
    public void testMoreConndition() throws IOException {
        SqlSession sqlSession = 
        		SqlSessionUtils.getSqlSession();
        DynamicSqlMapper mapper = 
        		sqlSession.getMapper(DynamicSqlMapper.class);
        Emp1 emp1 =  new Emp1();
        emp1.setEmpName("tom");
        emp1.setAge(22);
        emp1.setSex("男");
        emp1.setEmail("111@qq.com");
        List list =
                mapper.getEmpByMoreCondition(emp1);
        System.out.println(list);
    }
 
 
 
4 测试结果
 
 
 
9.2 where 标签 
1 动态SQL标签-where动态生成
	方法：
	List getEmpByMoreCondition2(Emp1 emp1);
	
	标签含义：
    where:当where标签中有内容时，且内容满足条件时，
    	   		会自动生成关键字where，并且将内部多余的and或or去掉
          当where标签中有内容时，且内容不满足条件时，
                不会生成where关键字，此时where标签没有恩和效果
    注意：where标签不能将内容后的and去掉，只能将内容前面的and去掉
 
2 where标签SQL语句


        select * from t_emp1
        
            
                emp_name = #{empName}
            
            
                and age = #{age}
            
            
                and sex = #{sex}
            
            
                and email = #{email}
            
        
    

3 测试动态生成where标签

	@Test
    public void testMoreConndition2() throws IOException {
        SqlSession sqlSession = 
        		SqlSessionUtils.getSqlSession();
        DynamicSqlMapper mapper = 
        		sqlSession.getMapper(DynamicSqlMapper.class);
        Emp1 emp1 =  new Emp1();
        emp1.setEmpName("");
        emp1.setAge(null);
        emp1.setSex("男");
        emp1.setEmail("111@qq.com");
        List list =
                mapper.getEmpByMoreCondition2(emp1);
        System.out.println(list);
    }

4 测试结果

9.3 trim 标签

1 动态SQL标签-trim

     方法：
     List getEmpByMoreCondition3(Emp1 emp1);
     属性：
         prefix：在trim标签中的内容前面添加指定的内容
         suffix：在trim标签中的内容后面添加指定的内容
         prefixOverrides：在trim标签中的内容前面去掉指定的内容
         suffixOverrides：在trim标签中的内容前面去掉指定的内容
     如果标签中的内容无效，那么 trim标签也没有任何效果，
     解析后的SQL语句是：select * from t_emp1

2 trim标签SQL语句

 
        select * from t_emp1
        
                
                    emp_name = #{empName} and
                
                
                    age = #{age} or
                
                
                    sex = #{sex} and
                
                
                    email = #{email}
                
        
    

3 测试trim标签的功能

	@Test
    public void testMoreConndition2() throws IOException {
        SqlSession sqlSession = 
        		SqlSessionUtils.getSqlSession();
        DynamicSqlMapper mapper = 
        		sqlSession.getMapper(DynamicSqlMapper.class);
        Emp1 emp1 =  new Emp1();
        emp1.setEmpName("");
        emp1.setAge(null);
        emp1.setSex("男");
        emp1.setEmail("111@qq.com");
        List list =
                mapper.getEmpByMoreCondition2(emp1);
        System.out.println(list);
    }

4 测试trim结果

9.4 choose when otherwise 标签

1 动态SQL标签--- choose when otherwise

	方法：
	List getEmpByChoose(Emp1 emp1);
	
	属性：
	when：当满足条件时，执行内容，相当于java中的if或else if语句
	otherwise：当不满足条件时，执行内容，相当于java中的else语句

	注意：
	如果第一个非主键字段值满足条件，后面的when中的内容将不再判断
	如果when中的条件都不满足，则会执行otherwise的内容

2 动态标签choose when otherwise SQL语句


        select * from t_emp1
        
            
                
                    emp_name = #{empName}
                
                
                    age = #{age}
                
                
                    sex = #{sex}
                
                
                    email = #{email}
                
                
                    did = 6
                
            
         

 
3 测试代码

	@Test
    public void testChoose() throws IOException {
        SqlSession sqlSession = 
        		SqlSessionUtils.getSqlSession();
        DynamicSqlMapper mapper = 
        		sqlSession.getMapper(DynamicSqlMapper.class);
        		
        List list = mapper.getEmpByChoose(new Emp1(null,"" ,null ,"" ,"" , null));
        System.out.println(list);
    }
 
 
 
4 测试结果：
 
 
 
 
9.5 foreach 标签 
9.5.1 通过数组实现批量删除（in，or） 
1 动态SQL-foreach。通过数组实现批量删除 in

	方法：
	in关键字：
	int deleteMoreByArray(@Param("eids") Integer[] eids);
	or关键字：
	int deleteMoreByArray2(@Param("eids") Integer[] eids);
	
	属性：
		collection="eids" ：集合数组的名称
		item="eid" ：数组中的元素
		separator="," ：元素之间以逗号隔开
		open="(" :以左括号开始
		close=")"：以右括号结束
 	    
	SQL：in关键字
	delete from t_emp1 where eid in ( ? , ? , ? , ?)     
	SQL：or关键字
	delete from t_emp1 where eid = ? or eid = ?            
 
2 动态标签foreach--批量删除的SQL语句

 

		delete from t_emp1 where eid in
       (
         
                #{eid}
         
        )
 



	
            #{eid}
    




        delete from t_emp1 where
        
            eid = #{eid}
        

 
3 测试代码

	//测试 批量删除 in关键字
    @Test
    public void testDeleteMoreByArray() throws IOException {
        SqlSession sqlSession = 
        				SqlSessionUtils.getSqlSession();
        DynamicSqlMapper mapper = 
        				sqlSession.getMapper(DynamicSqlMapper.class);
        int i = mapper.deleteMoreByArray(new Integer[]{11,12,13,14});
        System.out.println(i);
    }


    //测试批量删除 or关键字
    @Test
    public void testDeleteMoreByArray2() throws IOException {
        SqlSession sqlSession = 
        				SqlSessionUtils.getSqlSession();
        DynamicSqlMapper mapper = 
        				sqlSession.getMapper(DynamicSqlMapper.class);
        int i = mapper.deleteMoreByArray2(new Integer[]{33,34});
        System.out.println(i);
    }
 
 
 
4 测试结果
 
 
 
 
9.5.2 通过集合实现批量添加 
1 动态SQL-foreach 通过集合实现批量添加

	方法：
	int InsertMoreByList(@Param("emp1s") List emp1s);

	属性：
		collection:设置需要循环的数组或者集合
    	item:表示数组或者集合中的每一个数据
    	separator：循环体之间的分隔符
    	open：foreach标签所循环的所有内容的开始符
    	close：foreach标签所循环的所有内容的结束符

解析运行后的SQL：
Preparing: insert into t_emp1 values (null,?,?,?,?,null) , 
				(null,?,?,?,?,null) , (null,?,?,?,?,null) ,
				(null,?,?,?,?,null)
 
2 动态标签foreach--批量添加的SQL语句


    insert into t_emp1 values 
    
     	(null,#{emp1.empName},#{emp1.age},#{emp1.sex},#{emp1.email},null)
    

 
3 测试代码

	@Test
    public void testAddMoreByList() throws IOException {
        SqlSession sqlSession = SqlSessionUtils.getSqlSession();
        DynamicSqlMapper mapper = sqlSession.getMapper(DynamicSqlMapper.class);
        Emp1 emp1 = new Emp1(null, "蛮王", 22, "男", "555@qq.com" , null);
        Emp1 emp2 = new Emp1(null, "三刀", 22, "男", "555@qq.com" , null);
        Emp1 emp3 = new Emp1(null, "五秒", 22, "男", "555@qq.com" , null);
        Emp1 emp4 = new Emp1(null, "真男人", 22, "男", "555@qq.com" , null);
        List list = Arrays.asList(emp1, emp2, emp3, emp4);
        int i = mapper.InsertMoreByList(list);
        System.out.println(i);
    }
 
 
 
4 测试结果
 
 
 
9.6 sql片段标签 
动态SQL- sql标签
    用于提取公共部分，引入使用
    设置SQL片段，提起公共部分代码：公共代码
    引用SQL片段，在SQL中引入公共代码：
    			
 
10 MyBatis缓存 
10.1 MyBatis的一级缓存 
一级缓存介绍：
	一级缓存是SqlSession级别的，一级缓存是默认开启的，
	通过一个SqlSession查询的额数据会被缓存，下次查询相同的数据，
	就会从缓存中直接获取，不会重新访问数据库
 
一级缓存失效的四种情况：
	1 不同的SqlSession对应不同的缓存
	2 同一个SqlSession查询条件不同
	3 同一个SqlSession两次查询期间执行了任意一次增删改查的操作
	4 同一个SqlSession两次查询期间手动清空了缓存
 
1 编写获取SqlSession的工具类：
 
public class SqlSessionUtils {
    
        public static SqlSession getSqlSession() throws IOException {
            SqlSession sqlSession = null;
            try {
                InputStream stream = 
                        Resources.getResourceAsStream("mybatis-config.xml");
                SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                        new SqlSessionFactoryBuilder();
                SqlSessionFactory sessionFactory = 
                        sqlSessionFactoryBuilder.build(stream);
                //true表示自动提交事务
                sqlSession = sessionFactory.openSession(true);
            }catch (Exception e){
                e.printStackTrace();
            }
            return sqlSession;
        }
    }
 
2 测试1：一级缓存生效
 
  一级缓存生效
  	同个sqlSession下的。同一个mapper两次查询
		SQL知执行一次
        第一次查询数据库
        第二次查询缓存
 
    @Test
    public void testCacheMapper() throws IOException {
        SqlSession sqlSession = 
        			SqlSessionUtils.getSqlSession();
        CacheMapper mapper = 
        			sqlSession.getMapper(CacheMapper.class);
        Emp1 emp1 = mapper.getEmpByEid(5);
        System.out.println(emp1);
        Emp1 emp2 = mapper.getEmpByEid(5);
        System.out.println(emp2);
    }
 
 
 
 
 
3 测试2：一级缓存生效
 
	一级缓存生效
        同个sqlSession下的。不同mapper分别查询
            SQL知执行一次
            第一次查询数据库
            第二次查询缓存
 
    @Test
    public void testCacheMapper2() throws IOException {
        SqlSession sqlSession = 
        			SqlSessionUtils.getSqlSession();
        CacheMapper mapper1 = 
        			sqlSession.getMapper(CacheMapper.class);
        CacheMapper mapper2 = 
        			sqlSession.getMapper(CacheMapper.class);
        Emp1 emp1 = mapper1.getEmpByEid(5);
        System.out.println(emp1);
        Emp1 emp2 = mapper2.getEmpByEid(5);
        System.out.println(emp1);
    }
 
 
 
 
 
4 测试3：一级缓存失效
 
一级缓存失效
         * 不同sqlSession下的mapper分别查询
         *      SQL会执行两次
         *      第一次查询数据库
         *      第二次查询数据库
         *      一级缓存是sqlSession级别的，
         *          相同的sqlSession使用的是同一个缓存
         *          不同的sqlSession使用的是不同的缓存
 
    @Test
    public void testCacheMapper3() throws IOException {
        SqlSession sqlSession1 = 
        			SqlSessionUtils.getSqlSession();
        SqlSession sqlSession2 = 
        			SqlSessionUtils.getSqlSession();
        CacheMapper mapper1 = 
        			sqlSession1.getMapper(CacheMapper.class);
        CacheMapper mapper2 = 
        			sqlSession2.getMapper(CacheMapper.class);
        Emp1 emp1 = mapper1.getEmpByEid(5);
        System.out.println(emp1);
        Emp1 emp2 = mapper2.getEmpByEid(5);
        System.out.println(emp2);
    }
 
 
 
 
 
5 测试4：一级缓存失效
 
一级缓存失效
         * 同一个sqlSession下的mapper分别查询
         *      第一次查询数据库
         *      执行新增之后，自动清理缓存
         *      此时缓存中无数据。第二次查询依然查询数据库
 
    @Test
    public void testCacheMapper4() throws IOException {
        SqlSession sqlSession1 = 
        			SqlSessionUtils.getSqlSession();
        CacheMapper mapper1 = 
        			sqlSession1.getMapper(CacheMapper.class);
        CacheMapper mapper2 = 
        			sqlSession1.getMapper(CacheMapper.class);
        //1、第一次执行查询
        Emp1 emp1 = mapper1.getEmpByEid(5);
        System.out.println(emp1);
        //2、执行新增操作
        int i = mapper1.insertEmp(new Emp1(null, "DDD", 22, "男", "111@qq.com", null));
        System.out.println(i);
        //3、第二次执行查询
        Emp1 emp2 = mapper2.getEmpByEid(5);
        System.out.println(emp2);
    }
 
 
 
 
 
6 测试5：一级缓存失效
 
一级缓存失效
         *  同个sqlSession下的。同一个mapper两次查询
         *       SQL知执行一次
         *      第一次查询数据库
         *      手动清理缓存
         *      第二次查询数据库
        
         手动清理缓存，只能清理一级缓存
         sqlSession.clearCache();
 
    @Test
    public void testCacheMappe5() throws IOException {
        SqlSession sqlSession = 
        			SqlSessionUtils.getSqlSession();
        CacheMapper mapper = 
        			sqlSession.getMapper(CacheMapper.class);
        Emp1 emp1 = mapper.getEmpByEid(5);
        System.out.println(emp1);
        //手动清理缓存，只能清理一级缓存
        sqlSession.clearCache();
        Emp1 emp2 = mapper.getEmpByEid(5);
        System.out.println(emp2);
    }
 
 
 
 
 
10.2 MyBatis的二级缓存 
二级缓存介绍：
	二级缓存是SqlSessionFactory级别的，
	通过同一个SqlSessionFactory创建的SqlSession查询的结果会被缓存，
	此后若再次执行相同的查询操作，结果会从缓存中获取
 
二级缓存开启的条件
	1 在核心配置文件中，设置全局配置属性，cacheEnable="true"，
	  默认为true，不需要设置
	2 在映射文件中设置标签
	3 二级缓存必须在SqlSession关闭或者提交之后有效
	4 查询的数据所转换的实体类类型必须实现序列化接口
 
 
 
mapper映射文件中配置
 
 
 
 
MyBatis核心配置文件中配置
 
 
二级缓存失效的情况
	两次查询期间执行了任意的增删改，会使得一级缓存和二级缓同时失效
 
1 测试1：二级缓存生效
 
二级缓存生效
         *   不同sqlSession下的mapper分别查询
         *      SQL只执行一次
         *      第一次查询数据库
         *      第一次查询二级缓存
 
 @Test
    public void secondCache(){
        try {
            InputStream stream = 
            			Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    	new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = 
            			sqlSessionFactoryBuilder.build(stream);

            SqlSession sqlSession1 = 
            			sqlSessionFactory.openSession(true);
            CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
            Emp1 emp1 = mapper1.getEmpByEid(5);
            System.out.println(emp1);
            sqlSession1.close();

            SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
            CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
            Emp1 emp2 = mapper2.getEmpByEid(5);
            System.out.println(emp2);
            sqlSession2.close();

        }catch (Exception e){
            e.printStackTrace();
        }
    }
 
 
 
 
 
2 测试2：二级缓存失效
 
二级缓存生效
         *   不同sqlSession下的mapper分别查询
         *      第一次查询数据库
         *      随机执行新增操作，此时缓存会被清理
         *      第二次查询数据库
 
    @Test
    public void secondCache2(){
        try {
            InputStream stream = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(stream);

            SqlSession sqlSession1 = sqlSessionFactory.openSession();
            SqlSession sqlSession2 = sqlSessionFactory.openSession();
            SqlSession sqlSession3 = sqlSessionFactory.openSession();

            CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
            Emp1 emp1 = mapper1.getEmpByEid(5);
            System.out.println(emp1);
            sqlSession2.commit();
            sqlSession1.close();

            CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
            int i = mapper2.insertEmp(new Emp1(null, "DDD", 22, "男", "111@qq.com", null));
            System.out.println(i);
            sqlSession2.commit();
            sqlSession1.close();

            CacheMapper mapper3 = sqlSession3.getMapper(CacheMapper.class);
            Emp1 emp3 = mapper3.getEmpByEid(5);
            System.out.println(emp3);
            sqlSession2.commit();
            sqlSession2.close();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
 
 
 
 
 
10.3 二级缓存的相关配置< cache/ >标签中的属性 
在mapper配置文件中添加的cache标签可以设置一些属性：
	eviction属性：缓存回收策略
	LRU：最近最少使用的，移除最长时间不被使用的对象
	FIFO:先进先出，按对象进入缓存的顺序来移除他们
	SOFT：软引用，移除基于垃圾回收器和软引用规则的对象
	WEAK：弱引用，更积极的移除基于垃圾回收器和弱引用规则的对象
	flushinterval：刷新间隔，单位毫秒，默认情况下不设置，
				  也就是没有刷新问题，缓存仅仅在调用增删改语句时刷新
	size：引用数目，代表缓存最多可以存储多少个对象，太大容易导致内存溢出
	readOnly：只读 true/false
	true：表示只读缓存，会给所有调用者返回缓存对象的相同实例，
	      因为这些对象不能被修改
	false：表示读写缓存，会返回缓存对象的拷贝(通过序列化)，效率低且安全
 
10.4 MyBatis缓存查询的顺序 
1 先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，
  可以拿来直接使用
2 如果二级缓存中没有命中，则查询一级缓存
3 如果一级缓存中也没有命中，则查询数据库
4 SqlSession关闭之前，从数据库查询的数据默认保存在一级缓存
5 SqlSession关闭之后，一级缓存的数据会写入二级缓存
 
10.5 整合第三方缓存EHCache 
（整合第三方缓存之后，再次执行一二级缓存的测试操作）
 1 添加依赖ENCache
 
        
        
            org.mybatis.caches
            mybatis-ehcache
            1.2.2
        
 
2 jar包功能介绍-- logback
 
        
        
            ch.qos.logback
            logback-classic
            1.3.0-alpha14
        
 
3 ENCache配置文件— 配置文件名称必须是：ehcache.xml
 


    
    
    
    

 
4 设置二级缓存的类型
 

    
 
5 加入logback日志—文件名称必须是：logback.xml
 


    
    
        
            
            
            %d{HH:mm:ss.SSS} [%-5level] [%thread] [%logger] [%msg]%n
        
    

    
    
    
        
        
    

    
    



 
6 EHCache配置文件说明
 
name:缓存名称。
maxElementsInMemory:缓存最大数目
maxElementsOnDisk：硬盘最大缓存个数。
eternal:对象是否永久有效，一但设置了，timeout将不起作用。
overflowToDisk:是否保存到磁盘，当系统当机时
timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
clearOnFlush：内存数量最大时是否清除。
memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
FIFO，first in first out，这个是大家最熟的，先进先出。
LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
 
11 Mybatis的逆向工程 
正向功能：先创建Java实体类，由框架负责根据实体类生成数据库表，
		 （Hibernate支持正向工程）
逆向工程：先创建数据库表，由框架负责根据数据库表，反向生成如下资源
		 Java实体类
		 Mapper接口
		 Mapper映射文件
 
 
 
 
 
11.1 创建逆向工程的步骤 
1 添加依赖和插件
 
 
        
        
            
                org.mybatis.generator
                mybatis-generator-maven-plugin
                1.4.1
                
                
                    
                    
                        org.mybatis.generator
                        mybatis-generator-core
                        1.4.1
                    

                    
                    
                        com.mchange
                        c3p0
                        0.9.5.5
                    

                    
                    
                        mysql
                        mysql-connector-java
                        8.0.28
                    
                
            
        
    
 
2 创建mybatis的核心配置文件
 






    
    

    
        
        
    

    
    
        
    
    
    
    
        
            
            
                
                
                
                
                
                
                
                
            
        
    

    
    
        
    


 
3 创建逆向工程的配置文件
 
逆向工程的配置文件名称必须是：generatorConfig.xml
 



    
    
        
        
        

        
        
            
            
            
        

        
        
            
        

        
        
            
        

        
        
4 执行逆向工程操作
 双击插件逆向工程生成
 
 
 
 
11.2 QNC查询 
public class TestGenerator {

    
    @Test
    public void test1(){
        try {
            InputStream stream = 
                    Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    new SqlSessionFactoryBuilder();
            SqlSessionFactory sessionFactory = 
                    sqlSessionFactoryBuilder.build(stream);
            SqlSession sqlSession = sessionFactory.openSession(true);
            Emp1Mapper mapper = sqlSession.getMapper(Emp1Mapper.class);
            List list = mapper.selectByExample(null);
            list.forEach(emp -> System.out.println(emp));
        }catch (Exception e){
            System.out.println(e);
        }
    }


    
    @Test
    public void test2(){
        try {
            InputStream stream = 
                    Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    new SqlSessionFactoryBuilder();
            SqlSessionFactory sessionFactory = 
                    sqlSessionFactoryBuilder.build(stream);
            SqlSession sqlSession = sessionFactory.openSession(true);
            Emp1Mapper mapper = sqlSession.getMapper(Emp1Mapper.class);
            //根据条件查询
            Emp1Example emp1Example = new Emp1Example();
            //添加条件
            emp1Example
                    .createCriteria()
                    .andEmpNameEqualTo("tom")
                    .andAgeGreaterThanOrEqualTo(20);
            //执行查询 根据员工的名称查询
            List list = mapper.selectByExample(emp1Example);
            list.forEach(emp -> System.out.println(emp));
        }catch (Exception e){
            System.out.println(e);
        }
    }


    
    @Test
    public void test3(){
        try {
            InputStream stream = 
                    Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    new SqlSessionFactoryBuilder();
            SqlSessionFactory sessionFactory = 
                    sqlSessionFactoryBuilder.build(stream);
            SqlSession sqlSession = sessionFactory.openSession(true);
            Emp1Mapper mapper = sqlSession.getMapper(Emp1Mapper.class);
            //执行修改操作
            int i = mapper.updateByPrimaryKey(new Emp1(26, "张三", 44, "男", "222@qq.com", 1));
            System.out.println(i);
        }catch (Exception e){
            System.out.println(e);
        }
    }


    
    @Test
    public void test4(){
        try {
            InputStream stream = 
                    Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    new SqlSessionFactoryBuilder();
            SqlSessionFactory sessionFactory = 
                    sqlSessionFactoryBuilder.build(stream);
            SqlSession sqlSession = sessionFactory.openSession(true);
            Emp1Mapper mapper = sqlSession.getMapper(Emp1Mapper.class);
            //执行选择性修改操作，某个属性值设置为null。在执行修改操作之后，对应此字段的值是原值，不会被修改成null
            //update t_emp1 SET emp_name = ?, sex = ?, email = ?, did = ? where eid = ?
            int i = mapper.updateByPrimaryKeySelective(new Emp1(27, "张三", null, "男", "222@qq.com", 1));
            System.out.println(i);
        }catch (Exception e){
            System.out.println(e);
        }
    }
}
 
12 分页插件 
12.1 分页插件的使用步骤 
1、添加分页插件依赖

        
            com.github.pagehelper
            pagehelper
            5.3.0
        
2、MyBatis的核心配置文件中设置分页插件
 
    
        
    
 
12.2 分页插件的使用 
1、分页知识点：
limit (index,pageSize)
		index:当前页的起始索引
		pageSize：每页显示的条数
 		pageNumber：当前页的页码
	  公式：
		index = (pageNumber-1)*pageSize
		
表记录：是以下标为0开始的，即inde-0.表示第1条表记录
页码：是从1开始的
2、案例1：获取指定页码中展示指定记录数的数据
方法：
需要在查询功能之前开启分页
   PageHelper.startPage(1,4);
    参数一： pageNumber 当前页的页码
    参数二： pageSize  表示当前页展示的条数
代码：
    @Test
    public void testPage(){
        try {
            //1 加载mybatis的核心配置文件
            InputStream stream = 
                    Resources.getResourceAsStream("mybatis-config.xml");
            //2 创建会话工厂构造器
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    new SqlSessionFactoryBuilder();
            //3 工厂构造器加载输入流创建会话工厂
            SqlSessionFactory sessionFactory = 
                    sqlSessionFactoryBuilder.build(stream);
            //4 获取session对象，true表示开启事务提交
            SqlSession sqlSession = sessionFactory.openSession(true);
            //5 获取接口的实现类对象
            Emp1Mapper mapper = sqlSession.getMapper(Emp1Mapper.class);
            
            //6 开启分页查询操作
            PageHelper.startPage(4, 4);
            //7 通过条件进行查询
            List list = mapper.selectByExample(null);
            //8 遍历打印
            list.forEach(emp1 -> System.out.println(emp1));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
 
 
3、案例2：获取分页性情信息
方法：
查看分页的详细信息
      PageInfo pageInfo = new PageInfo<>(list, 5);
                        参数一：每页展示的list集合数据
                        参数二：导航目录的显示的页码个数
@Test
    public void testPag2(){
        try {
            //1 加载核心配置文件
            InputStream stream =
                    Resources.getResourceAsStream("mybatis-config.xml");
            //2 创建会话工厂构造器
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder =
                    new SqlSessionFactoryBuilder();
            //3 工厂构造器加载输入流创建会话工厂
            SqlSessionFactory sessionFactory =
                    sqlSessionFactoryBuilder.build(stream);
            //4 获取session对象，true表示开启事务提交
            SqlSession sqlSession = sessionFactory.openSession(true);
            //5 获取接口的实现类对象
            Emp1Mapper mapper = sqlSession.getMapper(Emp1Mapper.class);
            //6 条件查询所有
            List list = mapper.selectByExample(null);
            
            // 7 获取分页信息并打印
            PageInfo pageInfo = new PageInfo<>(list, 5);
            System.out.println(pageInfo);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
分页信息详情：
PageInfo{
      pageNum=4,      当前页的页码
      pageSize=4,     每页显示的条数
      size=4,         当前页中的真实条数
      startRow=13,    开始的行数
      endRow=16,      结束的行数
      total=34,       总记录数
      pages=9,        总页数
      prePage=3,          上一页的页码
      nextPage=5,         下一页的页码
      isFirstPage=false,  是否是首页
      isLastPage=false,   是都是尾页
      hasPreviousPage=true,   是否有前一页
      hasNextPage=true,       是否有下一页
      navigatePages=5,        导航分页的页码数
      navigateFirstPage=2,    导航分页的首页字数
      navigateLastPage=6,     导航分页的尾页数
      navigatepageNums=[2, 3, 4, 5, 6]    导航分页的页码
  }

转载请注明：文章转载自 www.mshxw.com
本文地址：https://www.mshxw.com/it/848291.html

   上一篇  数据库锁超时解决
 
   下一篇  Java线程状态
  



Java相关栏目本月热门文章

  
1【Linux驱动开发】设备树详解（二）设备树语法详解
  
2别跟客户扯细节
  
3Springboot+RabbitMQ+ACK机制(生产方确认(全局、局部)、消费方确认)、知识盲区
  
4【Java】对象处理流（ObjectOutputStream和ObjectInputStream）
  
5【分页】常见两种SpringBoot项目中分页技巧
  
6一文带你搞懂OAuth2.0
  
7我要写整个中文互联网界最牛逼的JVM系列教程 | 「JVM与Java体系架构」章节：虚拟机与Java虚拟机介绍
  
8【Spring Cloud】新闻头条微服务项目：FreeMarker模板引擎实现文章静态页面生成
  
9JavaSE - 封装、static成员和内部类
  
10树莓派mjpg-streamer实现监控及拍照功能调试
  
11用c++写一个蓝屏代码
  
12从JDK8源码中看ArrayList和LinkedList的区别
  
13idea 1、报错java: 找不到符号 符号: 变量 log 2、转换成Maven项目
  
14在openwrt使用C语言增加ubus接口（包含C uci操作）
  
15Spring 解决循环依赖
  
16SpringMVC——基于MVC架构的Spring框架
  
17Andy‘s First Dictionary C++ STL set应用
  
18动态内存管理
  
19我的创作纪念日
  
20Docker自定义镜像-Dockerfile




热门相关搜索



路由器设置
木托盘
宝塔面板
儿童python教程
心情低落
朋友圈
vim
双一流学科
专升本
我的学校
日记学校
西点培训学校
汽修学校
情书
化妆学校
塔沟武校
异形模板
西南大学排名
最精辟人生短句
6步教你追回被骗的钱
南昌大学排名
清朝十二帝
北京印刷学院排名
北方工业大学排名
北京航空航天大学排名
首都经济贸易大学排名
中国传媒大学排名
首都师范大学排名
中国地质大学(北京)排名
北京信息科技大学排名
中央民族大学排名
北京舞蹈学院排名
北京电影学院排名
中国戏曲学院排名
河北政法职业学院排名
河北经贸大学排名
天津中德应用技术大学排名
天津医学高等专科学校排名
天津美术学院排名
天津音乐学院排名
天津工业大学排名
北京工业大学耿丹学院排名
北京警察学院排名
天津科技大学排名
北京邮电大学(宏福校区)排名
北京网络职业学院排名
北京大学医学部排名
河北科技大学排名
河北地质大学排名
河北体育学院排名






学习工具
代数计算器
三角函数
解析几何
立体几何


知识解答
教育知识
百科知识
生活知识
常识知识


写作必备
作文大全
作文素材
句子大全

实用范文


关于我们
关于我们
联系我们
网站地图


 
名师互学网交流群


名师互学网客服





名师互学网 版权所有 (c)2021-2022      ICP备案号：晋ICP备2021003244-6号
 




关于我们
文章归档
网站地图
联系我们
版权所有 (c)2021-2022 MSHXW.COM
ICP备案号：晋ICP备2021003244-6号