学习：狂神

MyBatis

搭建环境

创建user表，添加数据
创建模块，导入坐标
编写M小yBatis核心配置文件->替换连接信息解决硬编码问题
编写SQL映射文件->统一管理sq语句，解决硬编码问题
编码
1. 定义entity类
2. 加载核心配置文件，获取SqlSessionFactory对象
3. 获取SqlSession对象，执行SQL语句
4. 释放资源

导jar包
核心包：mybatis
依赖包：
commons-logging 日志包
log4j 日志包
驱动包：mysql-connector-java

注册实体类

public class User {
    private int id;
    private String name;
    private String pwd;
}
//mybatis通过映射实现，不需要set方法

注册配置文件

<?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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql:///mybatis?serverTimezone=GMT%2B8&amp;useSSL=false"/>
                <property name="username" value="root"/>
                <property name="password" value="000000"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

注册映射文件

<?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="test">
    <select id="findAll" resultType="User">
        select * from user;
    </select>
</mapper>

测试类

@Test
public void test1() throws IOException {

    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    //获取session工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    // 获取session回话对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //执行操作
    List<User> userList = sqlSession.selectList("test.findAll");

    System.out.println(userList);
	//释放资源
    sqlSession.close();
}

增删改查

字符串替换（类似于泛型的属性）

替换前

@Select("select * from user where id = #{id}")
User findById(@Param("id") long id);

@Select("select * from user where name = #{name}")
User findByName(@Param("name") String name);

@Select("select * from user where email = #{email}")
User findByEmail(@Param("email") String email);

// 其它的 "findByXxx" 方法

优化后（方便简洁但不安全）

1 2	@Select("select * from user where ${column} = #{value}") User findByColumn(@Param("column") String column, @Param("value") String value);

sql片段

<sql id="if-id-name">
    <if test="id!=null">
        id=#{id}
    </if>
    <if test="name!=null">
        and name=#{name}
    </if>
</sql>

<select id="findOne" resultMap="UserPwd">
    select * from user
    <where>
        <include refid="if-id-name"></include>
    </where>
</select>

forEach

1	select * from `user` where id in (1,2,3);

<select id="findForEach" resultMap="UserPwd" parameterType="map">
    select * from user where id in
    <foreach collection="items" item="id" open="(" separator="," close=")">
        #{id}
    </foreach>
</select>
// foreach: 遍历集合collection中的内容
// index : 下标	item：元素
// open，close : 开始，结束符
// separator : 自定义分割符（ , or and ...)

@Test
public void Test2() throws IOException {
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    Map map=new HashMap<>();
    ArrayList<Integer> items = new ArrayList<>();
    items.add(1);
    items.add(2);
    items.add(3);
    map.put("items",items);

    List<User> userList = mapper.findForEach(map);
    for (User user : userList) {
        System.out.println(user);
    }

}

配置解析

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。配置文档的顶层结构如下：

configuration（配置）
- properties（属性）
- settings（设置）
- typeAliases（类型别名）
- typeHandlers（类型处理器）
- objectFactory（对象工厂）
- plugins（插件）
- environments（环境配置）
  - environment（环境变量）
    - transactionManager（事务管理器）
    - dataSource（数据源）
- databaseIdProvider（数据库厂商标识）
- mappers（映射器）

1、属性（properties）

可以直接引入外部文件
可以在其中增加一些属性配置

如果两个文件有同一个字段，优先使用外部配置文件的！

配置属性文件config.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql:///mybatis?serverTimezone=GMT%2B8&useSSL=false
username=root
password=000000

引入外部配置文件（如果两个文件有同一个字段，优先使用外部配置文件的！）

   <properties resource="config.properties"/>
  
<properties resource="config.properties">
       <property name="password" value="优先读取属性文件"/>
   </properties>

<dataSource type="POOLED">
	<property name="driver" value="${driver}"/>
	<property name="url" value="${url}"/>
	<property name="username" value="${username}"/>
	<property name="password" value="${password}"/>
</dataSource>

2、设置（settings）

settings（设置）

日志工厂

STDOUT_LOGGING

<settings>
    // mybatis 自带
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

log4j

1
2
3

<settings>
    <setting name="logImpl" value="log4j"/>
</settings>

public class MybatisTest03 {
	
    //日志对象，参数为当前类的class  （反射）
    static Logger logger = Logger.getLogger(MybatisTest03.class);
    
    @Test
    //日志级别
    public void log4jTest(){
        logger.info("info->日志");
        logger.debug("debug->日志");
        logger.error("error->日志");
    }
}

3、类型别名（typeAliases）

根据属性

1
2
3

<typeAliases>
    <typeAlias type="com.entity.User" alias="User"/>
</typeAliases>

扫描实体类的包，它的默认别名就为这个类的类名，首字母小写！
1
2
3
<typeAliases>
<package name="com.entity"/>
</typeAliases>

在实体类中使用注解（优先级最高）

@Alias("Candy")
public class User {
    ....
}

4、其他配置

类型处理器（typeHandlers）
对象工厂（objectFactory）
插件（plugins）
数据库厂商标识

5、环境配置（environments）

环境配置

6、映射器（mappers）

<!-- 方式一：使用相对于类路径的资源引用 -->
<mappers>
  	<mapper resource="org/mybatis/builder/UserMapper.xml"/>
</mappers>

<!-- 方式二：使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.UserMapper"/>
</mappers>

<!-- 方式三：将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

使用方式二、三时注意：

接口和他的Mapper配置文件必须同名！
接口和他的Mapper配置文件必须在同一个包下！

ResultMap

实体类中属性名与数据库中字段不一致（属性名字段名不一致解决方案）

1
2
3

private int id;	
private String name;
private String password;  (数据库中为 pwd )

数据库查询原理（可用起别名解决）

<select id="findOne" resultType="User">
<!--  select * from user where id=#{id}		-->
      select id,name,pwd as password from user where id=#{id}
</select>

ResultMap

<!--    结果集映射  column 数据库字段； property 实体类属性-->
<resultMap id="UserMap" type="user">
      <result column="pwd" property="password"/>
</resultMap>

<select id="findOne" resultMap="UserMap">
     select * from user where id=#{id}
</select>

结果映射（resultMap）

constructor —用于在实例化类时，注入结果到构造方法中
- idArg - ID 参数；标记出作为 ID 的结果可以帮助提高整体性能
- arg - 将被注入到构造方法的一个普通结果
id –一个 ID 结果；标记出作为 ID 的结果可以帮助提高整体性能
result – 注入到字段或 JavaBean 属性的普通结果
association —— 一个复杂类型的关联；许多结果将包装成这种类型
- 嵌套结果映射 – 关联可以是 resultMap 元素，或是对其它结果映射的引用
collection —— 一个复杂类型的集合
- 嵌套结果映射 – 集合可以是 resultMap 元素，或是对其它结果映射的引用
discriminator ——使用结果值来决定使用哪个 resultMap
- case —— 基于某些值的结果映射
  - 嵌套结果映射 – case 也是一个结果映射，因此具有相同的结构和元素；或者引用其它的结果映射

分页

Limit 分页

mysql 代码

1	select * from user limit #{startIndex},#{num}

接口层

1	public List<User> findOfLimit(Map<String,Integer> map);

测试

Map<String,Integer> map= new HashMap<>();
map.put("startIndex",0);
map.put("num",2);
List<User> userList = mapper.findOfLimit(map);

RowBounds 分页

mysql 代码

1	select * from user;

接口层

1	public List<User> findByRowBounds();

测试层

// RowBounds实现类
RowBounds rowBounds = new RowBounds(2,3);
// 基于 java代码层面实现 （limit分页 基于sql层）
List<User> userList = sqlSession.selectList("com.dao.UserMapper.findByRowBounds",null,rowBounds);

插件分页

PageHelper

注解开发

@Select("select * from user")
public List<User> findAll();

@Select("select * from user where id=#{uid} and name=#{uname}")
public List<User> findOne(@Param("uid") int id, @Param("uname") String name);

@Insert("insert into user value (#{id},#{name},#{password})")
public int addUser(User user);

@Delete()

@Param（）设置传入形参对接sql的限定名

复杂查询

多对一

Teacher

1 2	private int id; private String name;

Student

1
2
3

private int id;
private String name;
private Teacher teacher;

association —n. 协会，联盟，社团；联合；联想

    <select id="findStu2" resultMap="StuMap">
        select s.id sid,s.name sname,t.name tname		// sql字段取别名，防止编译混淆
        from student s ,teacher t
        where s.tid =t.id ;
    </select>

    <resultMap id="StuMap" type="com.entity.Student">   //推荐使用类型别名，避免全限定名
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="com.entity.Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

<!--    ========================================================== 	 -->

    <select id="findStu" resultMap="StuTeacher">
        select * from student;
    </select>
    <resultMap id="StuTeacher" type="com.entity.Student">  
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <association property="teacher" column="tid" javaType="com.entity.Teacher" select="findTch"/>
    </resultMap>
    <select id="findTch" resultType="com.entity.Teacher">   // 根据tid查询老师
        select * from teacher where id=#{tid}
    </select>

一对多

Student

1
2
3

private int id;
private String name;
private int tid;

Teacher

1
2
3

private int id;
private String name;
private List<Student> student;

collection

<select id="findById" parameterType="_int" resultMap="TH">
        select s.id sid,s.name sname,t.name tname ,t.id tid
        from student s ,teacher t
        where s.tid =t.id and t.id=#{id}
    </select>

    <resultMap id="TH" type="teacher">
        <id property="id" column="tid"/>
        <result property="name" column="tname"/>
<!--        javaType :指定属性的返回值类型，
            ofType : 集合中的泛型信息通常使用ofType获取-->
        <collection property="student" javaType="ArrayList" ofType="student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

<!--    ===========================================================  -->

    <select id="findById2" resultMap="TH2">
        select * from teacher where id=#{id}
    </select>

    <resultMap id="TH2" type="teacher">
        <collection property="student" javaType="ArrayList" ofType="student" select="findStu" column="id"/>
    </resultMap>

    <select id="findStu" resultType="student">
        select * from student where tid=#{tid}
    </select>

缓存

一级缓存 （本地缓存）是基于 PerpetualCache（MyBatis自带）的 HashMap 本地缓存，作用范围为 session 域内。当 session flush（刷新）或者 close（关闭）之后，该 session 中所有的 cache（缓存）就会被清空。

一级缓存失效的情况：

查询不同的东西
增删改操作，可能会改变原来的数据，所以必定会刷新缓存！
查询不同的Mapper,Xml

手动清理缓存

1	sqlSession.clearCache();

@Test
public void test2(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
    TeacherMapper mapper1 = sqlSession.getMapper(TeacherMapper.class);

    System.out.println(mapper.findById(1));
    sqlSession.clearCache();
    System.out.println(mapper1.findById(1));
    
    sqlSession.close();
}

二级缓存 是全局缓存，作用域超出 session 范围之外，可以被所有 SqlSession 共享

配置

<cache
        eviction="FIFO"
        flushInterval="60000"
        size="512"
        readOnly="true"/>

测试

@Test
public void test(){
    SqlSession sqlSession1 = sqlSessionFactory.openSession();
    SqlSession sqlSession2 = sqlSessionFactory.openSession();
    
    TeacherMapper mapper = sqlSession1.getMapper(TeacherMapper.class);
    TeacherMapper mapper1 = sqlSession2.getMapper(TeacherMapper.class);

    List<Teacher> teachers = mapper.findById(1);
    for (Teacher teacher : teachers) {
        System.out.println(teacher);
    }
    sqlSession1.close();
    sqlSession1.clearCache();   //在二级缓存中无效
    logger.info("----------------------");
    List<Teacher> teachers1 = mapper1.findById(1);
    for (Teacher teacher : teachers1) {
        System.out.println(teacher);
    }
    System.out.println(teachers == teachers1);
    sqlSession2.close();
}

二级缓存遗留问题：为什么要openSession.close();后，才能从二级缓存中查数据，不是先执行二再一么？

    @Test
    public void TowCache(){
        SqlSession sqlSession1 = sqlSessionFactory.openSession();
        SqlSession sqlSession2 = sqlSessionFactory.openSession();

        UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
        UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);

        System.out.println(mapper1.findAll());
        sqlSession1.close();                        //在此处关闭，查询只执行了1遍
//        sqlSession1.clearCache();                 //对二级缓存无效
        System.out.println(mapper2.findAll());
//        sqlSession1.close();                  //在此处关闭，查询执行了2遍
        sqlSession2.close();
    }
//注意：二级缓存需要openSession.close();后，才能从二级缓存中查数据

解决：https://blog.csdn.net/sdfgegefdg/article/details/115741737
- 二级缓存需要openSession.close();后，才能从二级缓存中查数据
- 如果openSession.close();在第二次查询之后才关闭，则第二次查询会从一级缓存中查，如果不是一个session，则查询不到数据：
- 说明：第二次又重新发送了sql，因为从二级缓存中取数据时，会话没关闭所以二级缓存中没数据，所以又去一级缓存中查询，也没有数据则发送了sql查数据库;
  所以，只有会话关闭或提交后，一级缓存中的数据才会转移到二级缓存中,然后因为是同一个namespace所以可以获取到数据；

Maven资源路径问题

<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
        
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>true</filtering>
        </resource>
    </resources>
</build>