MyBatis使用

Writing by Tor小黑 —-心中藏之，无日忘之

MyBatis使用

一、基本使用

1、pom.xml

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.4</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.20</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
</dependencies>


<!--加该build配置是为了解决java包中的xml文件无法读取-->
<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

2、配置文件

<?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>
    
    <!--打印SQL-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    
    <!--配置MyBatis运行环境 environments配置多个数据源，通过default-id指定当前需要使用的数据源 -->
    <environments default="development">
        <environment id="development">
            <!--配置JDBC的事务管理-->
            <transactionManager type="JDBC"></transactionManager>
            <!--POOLED配置JDBC数据源连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/learn_mybatis?serverTimezone=CTT&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;allowMultiQueries=true"/>
                <property name="username" value="root"/>
                <property name="password" value="aiyaya"/>
            </dataSource>
        </environment>
    </environments>
	<!--注册Mapper-->
    <mappers>
        <mapper resource="com/huan/mapper/AccountMapper.xml"></mapper>
        <mapper resource="com/huan/dao/AccountDaoMapper.xml"></mapper>
    </mappers>

</configuration>

3、实体类Account.java

package com.huan.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Account {
    private Long id;
    private String username;
    private String password;
    private int age;
}

4、Dao层AccountDao.java

package com.huan.dao;

import com.huan.entity.Account;

import java.util.List;

public interface AccountDao {
    public int save(Account account);

    public int update(Account account);

    public int deleteById(long id);

    public List<Account> findAll();
    //基本数据类型
    public Account findById(long id);
    //包装类
    public Account findById2(Long id);

    public Account findByName(String xxxxxx);

    //通过username（String）和age（int）查询，也就是传递多个参数，此时的问题使parameterType怎样处理(解决方法为直接不写，只用写resultType)
    public Account findByNameAndAge(String name,int age);

    //基本数据类型统计总数
    public int count();

    //包装类统计总数
    public Integer count2();

    //通过id查询name
    public String findNameById(long id);

}

5、AccountDaoMapper.xml

<?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="com.huan.dao.AccountDao">
    <insert id="save" parameterType="com.huan.entity.Account">
        insert into t_account(username,password,age)values(#{username},#{password},#{age})
    </insert>
    <update id="update" parameterType="com.huan.entity.Account">
        update t_account set username=#{username},password=#{password},age=#{age} where id=#{id}
    </update>
    <delete id="deleteById" parameterType="Long"><!--参数类型写包装类（java.lang.Long）和基本参数类型（long）都可以-->
        delete from t_account where id=#{id}
    </delete>
    <select id="findAll" resultType="com.huan.entity.Account">
        select * from t_account
    </select>
    <select id="findById" parameterType="long" resultType="com.huan.entity.Account">
        select * from t_account where id=#{id}
    </select>
    <select id="findById2" parameterType="java.lang.Long" resultType="com.huan.entity.Account">
        select * from t_account where id=#{id}
    </select>
    <select id="findByName" parameterType="java.lang.String" resultType="com.huan.entity.Account">
        select * from t_account where username=#{username}
    </select>
    <select id="findByNameAndAge" resultType="com.huan.entity.Account">
        select * from t_account where username=#{param1} and age=#{param2}
    </select>
    <select id="count" resultType="int">
        select count(id) from t_account
    </select>
    <select id="count2" resultType="java.lang.Integer">
        select count(id) from t_account
    </select>
    <select id="findNameById" parameterType="long" resultType="java.lang.String">
        select username from t_account where id=#{id}
    </select>


</mapper>

6、测试

package com.huan.test;

import com.huan.dao.AccountDao;
import com.huan.entity.Account;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

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

public class Test2 {
    public static void main(String[] args) {
        //加载mybatis配置文件
        InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("MyBatisConfig.xml");
        //创建SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        //获取SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取实现接口的代理对象
        AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
        //查询全部对象
//        List<Account> list = accountDao.findAll();
//        for (Account account:list){
//            System.out.println(account);
//        }
//        sqlSession.close();

        //添加对象
//        Account a = new Account(10L,"wnagwu","123311",32);
//        accountDao.save(a);
//        sqlSession.commit();  //修改、添加、删除对数据库数据有变化的操作一定要提交事务，否则不生效，查询操作不需要提交
//        sqlSession.close();

        //通过基本数据类型id查询
//        Account account = accountDao.findById(5);
//        System.out.println(account);
//        sqlSession.close();

        //通过包装类id查询
//        Long id = Long.parseLong("5");
//        System.out.println(accountDao.findById2(id));
//        sqlSession.close();

        //修改对象,需要先查出对象，然后修改
//        Account account = accountDao.findById(4);
//        account.setUsername("狗子");
//        account.setAge(99);
//        accountDao.update(account);
//        sqlSession.commit();
//        sqlSession.close();

        //删除
//        int result = accountDao.deleteById(4);
//        sqlSession.commit();
//        System.out.println(result);
//        sqlSession.close();

        //通过name查询
//        System.out.println(accountDao.findByName("李三"));
//        sqlSession.close();

        //通过username和age两个参数查询
//        System.out.println(accountDao.findByNameAndAge("李三",32));
//        sqlSession.close();

        //统计总数
//        System.out.println(accountDao.count());
//        sqlSession.close();
        //包装类查询总数
//        System.out.println(accountDao.count2());
//        sqlSession.close();

        //通过id查询username
        System.out.println(accountDao.findNameById(5));
        sqlSession.close();

    }
}

二、多表级联查询(一对多关系)

A、一对多关系，从一查多（查学生的时候带出班级）

1、实体类Student.java

package com.huan.entity;

import lombok.Data;

@Data
public class Student {
    private long id;
    private String name;
    private Classes classes; //一个学生只能对应一个班级
}

2、实体类Classes.java

package com.huan.entity;

import lombok.Data;

import java.util.List;

@Data
public class Classes {
    private long id;
    private String name;
    private List<Student> students;  //一个班级对应多个学生
}

3、StudentDao.java

package com.huan.dao;

import com.huan.entity.Student;

public interface StudentDao {
    //通过id查询学生
    public Student findById(long id);
}

4、StudentDaoMapper.xml

<?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="com.huan.dao.StudentDao">
    <!--resultMap处理多表查询的间接映射 id可以自定义 type为映射之后的结果-->
    <resultMap id="studentMap" type="com.huan.entity.Student">
        <id column="id" property="id"></id>  <!--映射主键-->
        <result column="name" property="name"></result> <!--映射其他字段 column为数据库查询语句的结果集，propery为实体类字段-->
        <!--association将cid，cname两个整合成一个calsses，property指实体类的字段，javaType指property数据类型-->
        <association property="classes" javaType="com.huan.entity.Classes">
            <id column="cid" property="id"></id>
            <result column="cname" property="name"></result>
        </association>
    </resultMap>

    <!--通过resultMap间接映射，此处需要使用resultMap-->
    <select id="findById" parameterType="long" resultMap="studentMap">
        select s.id,s.name,c.id as cid,c.name as cname from student s,classes c where s.id=#{id} and s.cid=c.id
    </select>
</mapper>

5、公共配置文件注册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>
    <!--配置MyBatis运行环境 environments配置多个数据源，通过default-id指定当前需要使用的数据源 -->
    <environments default="development">
        <environment id="development">
            <!--配置JDBC的事务管理-->
            <transactionManager type="JDBC"></transactionManager>
            <!--POOLED配置JDBC数据源连接池-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/learn_mybatis?serverTimezone=CTT&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;allowMultiQueries=true"/>
                <property name="username" value="root"/>
                <property name="password" value="aiyaya"/>
            </dataSource>
        </environment>
    </environments>

    <mappers>
        <mapper resource="com/huan/mapper/AccountMapper.xml"></mapper>
        <mapper resource="com/huan/dao/AccountDaoMapper.xml"></mapper>
        <mapper resource="com/huan/dao/StudentDaoMapper.xml"></mapper>
    </mappers>

</configuration>

6、测试

package com.huan.test;

import com.huan.dao.StudentDao;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.InputStream;

public class Test3 {
    public static void main(String[] args) {
        //加载mybatis配置文件
        InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("MyBatisConfig.xml");
        //创建SqlSessionFactoryBuilder
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        //创建SqlSessionFactory
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
        //获取SqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //获取实现接口的代理对象
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);

        //通过id多表关联查询
        System.out.println(studentDao.findById(1));
        sqlSession.close();
    }
}

b、一对多关系，从多查一（查班级的时候带出学生）

1、ClassesDao.java

package com.huan.dao;

import com.huan.entity.Classes;

public interface ClassesDao {
    public Classes findById(long id);
}

2、ClassesDaoMapper.xml

<?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="com.huan.dao.ClassesDao">
    <!--resultMap处理多表查询的间接映射 id可以自定义 type为映射之后的结果-->
    <resultMap id="classesMap" type="com.huan.entity.Classes">
        <id column="cid" property="id"></id>  <!--映射主键-->
        <result column="cname" property="name"></result> <!--映射其他字段 column为数据库查询语句的结果集，propery为实体类字段-->
        <!--collection映射一个集合List，property指实体类的字段，ofType指集合里面的泛型-->
        <collection property="students" ofType="com.huan.entity.Student">
            <id column="id" property="id"></id>
            <result column="name" property="name"></result>
        </collection>
    </resultMap>

    <!--通过resultMap间接映射，此处需要使用resultMap-->
    <select id="findById" parameterType="long" resultMap="classesMap">
        select s.id,s.name,c.id as cid,c.name as cname from student s,classes c where c.id=#{id} and s.cid=c.id
    </select>
</mapper>

3、注册Mapper

<mapper resource="com/huan/dao/ClassesDaoMapper.xml"></mapper>

4、测试

public static void main(String[] args) {
    //加载mybatis配置文件
    InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("MyBatisConfig.xml");
    //创建SqlSessionFactoryBuilder
    SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
    //创建SqlSessionFactory
    SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
    //获取SqlSession
    SqlSession sqlSession = sqlSessionFactory.openSession();

    ClassesDao classesDao = sqlSession.getMapper(ClassesDao.class);
    System.out.println(classesDao.findById(3));
    sqlSession.close();

}

三、多表级联查询(多对多关系)

A、查找用户购买所有商品

Customer.java

package com.huan.entity;

import lombok.Data;

import java.util.List;

@Data
public class Customer {
    private long id;
    private String name;
    private List<Goods> goods;
}

Goods.java

package com.huan.entity;

import lombok.Data;

import java.util.List;

@Data
public class Goods {
    private long id;
    private String name;
    private List<Customer> customers;
}

CustomerDao.java

package com.huan.dao;

import com.huan.entity.Customer;

public interface CustomerDao {
    public Customer findById(long id);
}

CustomerDaoMapper.xml

<?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="com.huan.dao.CustomerDao">
    <!--resultMap处理多表查询的间接映射 id可以自定义 type为映射之后的结果-->
    <resultMap id="customerMap" type="com.huan.entity.Customer">
        <id column="cid" property="id"></id>  <!--映射主键-->
        <result column="cname" property="name"></result> <!--映射其他字段 column为数据库查询语句的结果集，propery为实体类字段-->
        <!--collection映射一个集合List，property指实体类的字段，ofType指集合里面的泛型-->
        <collection property="goods" ofType="com.huan.entity.Goods">
            <id column="gid" property="id"></id>
            <result column="gname" property="name"></result>
        </collection>
    </resultMap>

    <!--通过resultMap间接映射，此处需要使用resultMap-->
    <select id="findById" parameterType="long" resultMap="customerMap">
        select c.Id cid,c.name cname,g.id gid,g.name gname from customer c,goods g,customer_goods cg where c.id=#{id} and cg.cid=c.id and cg.gid=g.id
    </select>
</mapper>

注册Mapper+测试

CustomerDao customerDao = sqlSession.getMapper(CustomerDao.class);
System.out.println(customerDao.findById(1));
sqlSession.close();

B、通过商品查找所有购买的用户

GoodsDao.java

package com.huan.dao;

import com.huan.entity.Goods;

public interface GoodsDao {
    public Goods findById(long id);
}

GoodsDaoMapper.xml

<?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="com.huan.dao.GoodsDao">
    <!--resultMap处理多表查询的间接映射 id可以自定义 type为映射之后的结果-->
    <resultMap id="goodsMap" type="com.huan.entity.Goods">
        <id column="gid" property="id"></id>  <!--映射主键-->
        <result column="gname" property="name"></result> <!--映射其他字段 column为数据库查询语句的结果集，propery为实体类字段-->
        <!--collection映射一个集合List，property指实体类的字段，ofType指集合里面的泛型-->
        <collection property="customers" ofType="com.huan.entity.Customer">
            <id column="cid" property="id"></id>
            <result column="cname" property="name"></result>
        </collection>
    </resultMap>

    <!--通过resultMap间接映射，此处需要使用resultMap-->
    <select id="findById" parameterType="long" resultMap="goodsMap">
        select c.Id cid,c.name cname,g.id gid,g.name gname from customer c,goods g,customer_goods cg where g.id=#{id} and cg.cid=c.id and cg.gid=g.id
    </select>
</mapper>

注册Mapper+测试

GoodsDao goodsDao = sqlSession.getMapper(GoodsDao.class);
System.out.println(goodsDao.findById(1));
sqlSession.close();

四、MyBatis逆向工程

MyBatis需要：实体类、自定义Mapper接口、接口对应的Mapper.xml

传统的开发过程中，上述的三个组件需要开发者自己手动创建，逆向工程可以帮助开发者来自动创建这三个组件。 减轻开发者的工作量，提高工作效率。

MyBatis Generator(生成器) 简称MBG（逆向工程），是一个专门为MyBatis框架开发者定制的代码生成器，可自动生成MyBatis框架所需的实体类、Mapper接口、Mapper.xml,支持基本的CRUD操作，但是一些相对复杂的SQL需要开发者自己实现

1、新建Maven工程。pom.xml

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.4</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.20</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis.generator</groupId>
        <artifactId>mybatis-generator-core</artifactId>
        <version>1.4.0</version>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.12</version>
    </dependency>
</dependencies>

2、创建MBG配置文件，名字可自定义GeneratorConfig.xml

• jdbcConnection 配置数据库连接信息
• javaModelGenerator 配置JavaBean的生成策略（实体类）
• sqlMapGenerator 配置SQL映射文件生成策略
• javaclientGenerator 配置自定义Mapper接口的生成策略
• table 配置目标数据表（tableName：表名，domainObjectName：JavaBean实体类名）

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <context id="testTables" targetRuntime="MyBatis3">  <!--id可以自定义，后面必须写MyBatis3-->
        <jdbcConnection
                driverClass="com.mysql.cj.jdbc.Driver"
                connectionURL="jdbc:mysql://localhost:3306/learn_mybatis?serverTimezone=CTT&amp;useUnicode=true&amp;characterEncoding=utf-8&amp;allowMultiQueries=true"
                userId="root"
                password="aiyaya"
        ></jdbcConnection>
        <javaModelGenerator targetPackage="com.huan.entity" targetProject="./src/main/java"></javaModelGenerator> <!--自动创建实体类-->
        <sqlMapGenerator targetPackage="com.huan.dao" targetProject="./src/main/java"></sqlMapGenerator>
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.huan.dao" targetProject="./src/main/java"></javaClientGenerator>
        <table tableName="t_user" domainObjectName="User"></table>
    </context>
</generatorConfiguration>

3、创建Generator执行的类

package com.huan.test;

import org.mybatis.generator.api.MyBatisGenerator;
import org.mybatis.generator.config.Configuration;
import org.mybatis.generator.config.xml.ConfigurationParser;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.exception.XMLParserException;
import org.mybatis.generator.internal.DefaultShellCallback;

import java.io.File;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> warings = new ArrayList<String>();
        boolean overwrite = true;
        String genCig = "/GeneratorConfig.xml";  /*配置文件路径，相对resourses为根路径*/
        File configFile = new File(Main.class.getResource(genCig).getFile()); /*把配置文件用面向对象的思想来处理*/
        ConfigurationParser configurationParser = new ConfigurationParser(warings);
        Configuration configuration = null;
        try {
            configuration = configurationParser.parseConfiguration(configFile);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (XMLParserException e) {
            e.printStackTrace();
        }

        DefaultShellCallback callback = new DefaultShellCallback(overwrite);
        MyBatisGenerator myBatisGenerator = null;
        try {
            myBatisGenerator = new MyBatisGenerator(configuration,callback,warings);
        } catch (InvalidConfigurationException e) {
            e.printStackTrace();
        }
        try {
            myBatisGenerator.generate(null);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

五、MyBatis延迟加载

1、什么是延迟加载？

延迟加载也叫懒加载、惰性加载，使用延迟加载可以提高程序的运行效率，针对于数据持久层的操作，在某些特定的情况下去访问特定的数据库，在其他情况下可以不访问某些表，从一定程度上减少了Java应用与数据库的交互次数。

举例：查询学生和班级时，学生和班级是两张不同的表，如果当前的需求只需要获取学生的信息，那么查询学生单表即可，如果需要通过学生获取对应的班级信息，则必须查询两张表。

不同的业务需求，需要查询不同的表，根据具体的业务需求来动态的减少数据表查询的工作就是延迟加载。

2、在主配置文件中开启延迟加载

<settings>
    <!--打印SQL-->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!--开启延迟加载-->
    <setting name="lazyLoadingEnabled" value="true"/>
</settings>

3、将多表关联查询拆分成多个单表查询

StudentDao

public Student findByIdLazy(long id);

StudentDaoMapper.xml

<!--延迟加载-->
<resultMap id="studentMapLazy" type="com.huan.entity.Student">
    <id column="id" property="id"></id>  <!--映射主键-->
    <result column="name" property="name"></result> <!--映射其他字段 column为数据库查询语句的结果集，propery为实体类字段-->
    <!--association映射一个对象，将cid，cname两个整合成一个calsses，property指实体类的字段，javaType指property数据类型-->
    <association property="classes" javaType="com.huan.entity.Classes" select="com.huan.dao.ClassesDao.findByIdLazy" column="cid"></association>
</resultMap>

<!--通过resultMap间接映射，此处需要使用resultMap-->
<select id="findByIdLazy" parameterType="long" resultMap="studentMapLazy">
    select * from student where id=#{id}
</select>

ClassesDao

public Classes findByIdLazy(long id);

ClassesDaoMapper.xml

<select id="findByIdLazy" parameterType="long" resultType="com.huan.entity.Classes">
    select * from classes where id=#{id}
</select>

六、MyBatis缓存

1、什么是MyBatis缓存

使用缓存可以减少java应用与数据库的交互次数，从而提升程序的运行效率。比如查询id=1的对象，第一次查询出之后会自动将该对象保存到缓存中，当下一次查询时，直接从缓存中取出对象即可，无需再次查询数据库。

2、MyBatis缓存分类

• 一级缓存：SqlSession级别，默认开启，并且不能关闭。操作数据库时需要创建SqlSession对象，在对象中有一个HashMap用于存储缓存数据，不同的SqlSession之间的缓存数据区域是互不影响的。

  一级缓存的作用域是SqlSession范围的，当在同一个SqlSession中执行两次相同的SQL语句时，第一次执行完毕会将结果保存到缓存中，第二次查询时直接从缓存中获取。

  需要注意的是，如果SqlSession执行了DML操作（insert、update、delete），MyBatis必须将缓存清空，以保证数据的准确性。

• 二级缓存：Mapper级别的，默认关闭，可以开启。

  使用二级缓存时，多个SqlSession使用同一个Mapper的SQL语句操作数据库，得到的数据会存在二级缓存区，同样是使用HashMap进行数据存储，相比较于一级缓存，二级缓存的范围更广，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

  二级缓存是多个SqlSession共享的，其作用域是Mapper的同一个namespase，不同的SqlSession两次执行相同的namespase下的SQL语句，参数也相等，则第一次执行成功之后会将数据保存到二级缓存中，第二次可直接从二级缓存中取出数据。

  一级缓存

  package com.huan.test;
  
  import com.huan.dao.AccountDao;
  import com.huan.entity.Account;
  import org.apache.ibatis.session.SqlSession;
  import org.apache.ibatis.session.SqlSessionFactory;
  import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  
  import java.io.InputStream;
  
  public class Test4 {
      public static void main(String[] args) {
          InputStream inputStream = Test.class.getClassLoader().getResourceAsStream("MyBatisConfig.xml");
          SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
          SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(inputStream);
          SqlSession sqlSession = sqlSessionFactory.openSession();
  
          AccountDao accountDao = sqlSession.getMapper(AccountDao.class);
          Account account = accountDao.findById(1L);
          System.out.println(account);
          sqlSession.close();
          sqlSession = sqlSessionFactory.openSession();
          accountDao = sqlSession.getMapper(AccountDao.class);
          Account account1 = accountDao.findById(1L);
          System.out.println(account1);
  
      }
  }

  二级缓存

  1. MyBatis自带的二级缓存

• config.xml中配置开启二级缓存

  <settings>
      <!--打印SQL-->
      <setting name="logImpl" value="STDOUT_LOGGING"/>
      <!--开启延迟加载-->
      <setting name="lazyLoadingEnabled" value="true"/>
      <!--开启二级缓存-->
      <setting name="cacheEnabled" value="true"/>
  </settings>

• Mapper.xml中配置二级缓存

  <mapper namespace="com.huan.dao.AccountDao">
      <cache></cache>

• 实体类实现序列化接口

  public class Account implements Serializable {
      private Long id;
      private String username;
      private String password;
      private int age;
  }

  ​ 2.第三方ehcache二级缓存

• pom.xml添加依赖

  <dependency>
      <groupId>org.mybatis</groupId>
    <artifactId>mybatis-ehcache</artifactId>
      <version>1.0.0</version>
  </dependency>
  <dependency>
      <groupId>net.sf.ehcache</groupId>
      <artifactId>ehcache-core</artifactId>
      <version>2.4.3</version>
  </dependency>

• config.xml中配置开启二级缓存

  <settings>
      <!--打印SQL-->
      <setting name="logImpl" value="STDOUT_LOGGING"/>
      <!--开启延迟加载-->
      <setting name="lazyLoadingEnabled" value="true"/>
      <!--开启二级缓存-->
      <setting name="cacheEnabled" value="true"/>
  </settings>

• Mapper.xml中配置二级缓

  <mapper namespace="com.huan.dao.AccountDao">
      <cache type="org.mybatis.caches.ehcache.EhcacheCache">
          <!--缓存创建之后，最后一次访问缓存的时间至缓存失效的时间间隔-->
          <property name="timeToIdleSeconds" value="3600"/>
          <!--缓存自创建时间起至失效的时间间隔-->
          <property name="timeToLiveSeconds" value="3600"/>
          <!--缓存的回收策略，LRU表示移除近期使用最少的对象-->
          <property name="memoryStoreEvictionPolicy" value="LRU"/>
      </cache>

• 实体类不需要实现序列化接口。

  package com.huan.entity;
  
  import lombok.AllArgsConstructor;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class Account {
      private Long id;
      private String username;
      private String password;
      private int age;
  }

七、MyBatis的动态SQL

使用动态SQL可以简化代码的开发，减少开发者的工作量，程序可以根据业务参数来决定SQL的组成。

• <1> if标签

  <select id="findByAccount" parameterType="com.huan.entity.Account" resultType="com.huan.entity.Account">
      select * from t_account where
      <if test="id!=0">
          id=#{id}
      </if>
      <if test="username!=null">
          and username=#{username}
      </if>
      <if test="password!=null">
          and password=#{password}
      </if>
      <if test="age!=null">
          and age=#{age}
      </if>
  </select>

  if标签可以自动根据表达式的结果来决定是否将对应的语句添加到SQL中，如果条件不成立则不添加，如果条件成立则添加。

• <2> where标签

  <select id="findByAccount" parameterType="com.huan.entity.Account" resultType="com.huan.entity.Account">
      select * from t_account
      <where>
          <if test="id!=null">
              id=#{id}
          </if>
          <if test="username!=null">
              and username=#{username}
          </if>
          <if test="password!=null">
              and password=#{password}
          </if>
          <if test="age!=null">
              and age=#{age}
          </if>
      </where>
  </select>

  where标签可以自动判断是否要删除语句块中的and的关键字，如果检测到where直接跟and拼接，则自动删除and，通常情况下if和where结合起来使用。

• <3> choose、when标签

  <select id="findByAccount" parameterType="com.huan.entity.Account" resultType="com.huan.entity.Account">
      select * from t_account
      <where>
          <choose>
              <when test="id!=null">
                  id=#{id}
              </when>
              <when test="username!=null">
                  and username=#{username}
              </when>
              <when test="password!=null">
                  and password=#{password}
              </when>
              <when test="age!=0">
                  and age=#{age}
              </when>
          </choose>
      </where>
  </select>

• <4> trim标签

  trim标签中的prefix和suffix属性会被用于生成实际的SQL语句，会和标签内部的语句进行拼接，如果语句前后出现了prefixOverrides或suffixOverrides属性中指定的值，MyBatis框架会自动将其删除。

  <select id="findByAccount" parameterType="com.huan.entity.Account" resultType="com.huan.entity.Account">
      select * from t_account
      <trim prefix="where" prefixOverrides="and">
          <if test="id!=null">
              id=#{id}
          </if>
          <if test="username!=null">
              and username=#{username}
          </if>
          <if test="password!=null">
              and password=#{password}
          </if>
          <if test="age">
              and age=#{age}
          </if>
      </trim>
  </select>

• <5> set标签

  set标签用于update操作，会自动根据参数选择生成SQL语句。

  <update id="update" parameterType="com.huan.entity.Account">
      update t_account
      <set>
          <if test="username!=null">
              username=#{username},
          </if>
          <if test="password!=null">
              password=#{password},
          </if>
          <if test="age!=0">
              age=#{age}
          </if>
      </set>
      where id=#{id}
  </update>

• <6> foreach标签

  foreach标签可以迭代生成一系列值，这个标签主要用于SQL的in语句，例如通过多个id查询多条记录。

  package com.huan.entity;
  
  import lombok.AllArgsConstructor;
  import lombok.Data;
  import lombok.NoArgsConstructor;
  
  import java.util.List;
  
  @Data
  @AllArgsConstructor
  @NoArgsConstructor
  public class Account {
      private Long id;
      private String username;
      private String password;
      private int age;
      private List<Long> ids;
  }

  //测试foreach标签
      public List<Account> findByIds(Account account);

  <select id="findByIds" parameterType="com.huan.entity.Account" resultType="com.huan.entity.Account">
      select * from t_account
      <where>
          <foreach collection="ids" open="id in (" close=")" item="id" separator=",">
              #{id}
          </foreach>
      </where>
  </select>

赏

谢谢你请我吃糖果

微信