【Mybatis】Mybatis 学习笔记

不念不忘少年蓝@ 2023-05-21 15:23 18阅读 0赞

**目录**

一、MyBatis 基本知识

1.1 什么是 MyBatis

1.2 MyBatis 的优点

1.3 MyBatis 的缺点

1.4 MyBatis 适用场合

1.5 MyBatis 和 Hibernate 对比

二、MyBatis 基本使用

2.1 基本使用

2.2 POJO

2.3 配置指定dao包地址

2.4 配置类型别名，减少不断写类路径的麻烦

三、MyBatis 连接池和事务

3.1 MyBatis 连接池提供的三种方式：

3.2 MyBatis 事务

3.3 MyBatis 一对一关系和多对多关系

四、MyBatis 加载和缓存

4.1 延迟加载和立即加载

4.2 缓存

五、MyBatis 的注解用法

--------------------

## 一、MyBatis 基本知识 ##

### 1.1 什么是 MyBatis ###

*  MyBatis 是一个基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程
 *  MyBatis 通过 xml 或者注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和 statement 中 sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 MyBatis 框架执行 sql 并将结果映射为 java 对象并返回
 *  采用了 ORM 思想解决了实体和数据库的映射关系，对 jdbc 做了封装，屏蔽了 jdbc api 底层访问细节，使我们不用跟 jdbc api 打交道，就可以完成对数据库的持久化操作

### 1.2 MyBatis 的优点 ###

*  耦合性低：不会对应用程序或数据库的现有设计造成任何影响，可以选择将 SQL 写在 XML 中或是程序代码中，实现统一管理。提供 XML 标签，支持编写动态 SQL 语句，并可重用
 *  专注于sql：与传统的 jdbc 框架相比，消除了 JDBC 的大量冗余代码，使开发人员专注于 sql 语句的编写，而不用将精力花在 jdbc api的使用好管理上。
 *  兼容性好：由于 MyBatis 使用 JDBC 来连接数据库，所以只要 JDBC 支持的数据库 MyBatis 都支持
 *  集成：能与 Spring 很好的集成

### 1.3 MyBatis 的缺点 ###

*  SQL 编写工作量较大，尤其当字段多、关联表多时，多 SQK 技能要求高
 *  SQL 语句依赖数据库，导致数据库移植性差，不能随意更换数据库

### 1.4 MyBatis 适用场合 ###

*  MyBatis 专注于 SQL 本身，是一个灵活高效的持久层解决方案，适用于快速开发的项目
 *  MyBatis 适用于性能要求高，且需求变化多的项目

### 1.5 MyBatis 和 Hibernate 对比 ###

<table> 
 <tbody> 
  <tr> 
   <td style="width:185px;">&nbsp;</td> 
   <td style="width:277px;"><strong>MyBatis</strong></td> 
   <td style="width:363px;"><strong>Hibernate</strong></td> 
  </tr> 
  <tr> 
   <td style="width:185px;"><strong>学习成本</strong></td> 
   <td style="width:277px;">&nbsp;</td> 
   <td style="width:363px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:185px;"><strong>开发速度</strong></td> 
   <td style="width:277px;">&nbsp;</td> 
   <td style="width:363px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:185px;"><strong>工作量</strong></td> 
   <td style="width:277px;">&nbsp;</td> 
   <td style="width:363px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:185px;"><strong>SQL 优化</strong></td> 
   <td style="width:277px;">&nbsp;</td> 
   <td style="width:363px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:185px;"><strong>对象管理</strong></td> 
   <td style="width:277px;">&nbsp;</td> 
   <td style="width:363px;">&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:185px;"><strong>缓存</strong></td> 
   <td style="width:277px;">&nbsp;</td> 
   <td style="width:363px;">&nbsp;</td> 
  </tr> 
 </tbody> 
</table>

## 二、MyBatis 基本使用 ##

POJO OGNL

### 2.1 基本使用 ###

**2.1.1 导入相关依赖**

pom.xml

<dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.4</version>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.11</version>
    </dependency>
    
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.14</version>
    </dependency>
    
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.10</version>
    </dependency>

**2.1.2 增加配置文件**

/resources/SqlMapConfig.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    
    
    <configuration>
        
        <properties resource="jdbcConfig.properties">
        </properties>
        
        
    
        
        <typeAliases>
            
            
            <package name="xyz.tom.www.domain"/>
        </typeAliases>
    
        
        <environments default="mysql">
            
            <environment id="mysql">
                
                <transactionManager type="JDBC"></transactionManager>
                
                <dataSource type="POOLED">
                    
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>
    
        
        <mappers>
            
            <package name="xyz/tom/www/dao"/>
        </mappers>
    </configuration>

/resources/jdbcConfig.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
    jdbc.url=jdbc:mysql://www.xxxxxxx.xyz:3306/testdb?useSSL=false&useUnicode=true&characterEncoding=utf8
    jdbc.username=root
    jdbc.password=root

/resources/log4j.properties

#log4j.rootLogger=DEBUG, CONSOLE, LOGFILE
    #
    #log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
    #
    ##Console
    #log4j.appender.CONSOLE=org.apache.log4j.DailyRollingFileAppender
    #log4j.appender.Console.layout=org.apache.log4j.PatternLayout
    #log4j.appender.Console.layout.ConversionPattern=%d[ISO8601] %-6r [%15.15t] %-5p %30.30c %x -%m\n
    #
    #log4j.appender.LOGFILE=org.apache.log4j.FileAppender
    #log4j.appender.LOGFILE.File=e:/axis.log
    #log4j.appender.LOGFILE.Append=true
    #log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
    #log4j.appender.LOGFILE.layout.ConversionPattern=%d[ISO8601] %-6r [%15.15t] %-5p %30.30c %x -%m\n
    
    
    log4j.rootLogger=ERROR,A1
    log4j.appender.A1=org.apache.log4j.ConsoleAppender
    log4j.appender.A1.layout=org.apache.log4j.PatternLayout
    log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n
    
    #log4j.appender.BROWSE=org.apache.log4j.DailyRollingFileAppender
    #log4j.appender.BROWSE.DatePattern='.'yyyy-MM-dd
    #log4j.appender.BROWSE.file=${catalina.home}/logs/browse.log
    #log4j.appender.BROWSE.layout=org.apache.log4j.PatternLayout
    #log4j.appender.BROWSE.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH\:mm\:ss,SSS} method\:%l%n%m%n
    
    #log4j.logger.com.telin.develop.displaytag=DEBUG
    
    
    log4j.appender.Spring=org.apache.log4j.ConsoleAppender
    log4j.appender.Spring.layout=org.apache.log4j.PatternLayout
    log4j.appender.Spring.layout.ConversionPattern=[Spring]\: %-5p %d{yyyy-MM-dd HH\:mm\:ss,SSS} %C{1}\:%M - %m%n
    
    #log4j.appender.Hibernate=org.apache.log4j.ConsoleAppender
    #log4j.appender.Hibernate.layout=org.apache.log4j.PatternLayout
    #log4j.appender.Hibernate.layout.ConversionPattern=[Hibernate]: %-5p %d{yyyy-MM-dd HH:mm:ss,SSS} %C{1}:%M - %m%n
    
    log4j.appender.Ehcache=org.apache.log4j.ConsoleAppender
    log4j.appender.Ehcache.layout=org.apache.log4j.PatternLayout
    log4j.appender.Ehcache.layout.ConversionPattern=[Ehcache]: %-5p %d{yyyy-MM-dd HH:mm:ss,SSS} %C{1}:%M - %m%n
    
    log4j.logger.com.ibatis=DEBUG
    #log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=DEBUG
    #log4j.logger.com.ibatis.common.jdbc.ScriptRunner=DEBUG
    #log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG
    log4j.logger.java.sql.Connection=DEBUG
    log4j.logger.java.sql.Statement=DEBUG
    log4j.logger.java.sql.PreparedStatement=DEBUG
    log4j.logger.java.sql.ResultSet=DEBUG

**2.1.3 使用**

/dao/UserDao.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="xyz.tom.www.dao.IUserDao">
        
    
    
    
    
    
    
    
    
        
    
        <select id="findAll" resultType="User">
            select * from user
        </select>
    
        
        <insert id="saveUser" parameterType="User">
            --     
            <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
                select last_insert_id();
            </selectKey>
            insert into user(username, address, birthday, sex) values(#{username},#{address},#{birthday},#{sex})
        </insert>
    
        <update id="updateUser" parameterType="User">
            update
                user
            set
                username=#{username},
                address=#{address},
                sex=#{sex},
                birthday=#{birthday}
            where
                id=#{id}
        </update>
    
        <delete id="deleteUser" parameterType="Integer">
            delete from
                user
            where
                id=#{uid}
        </delete>
    
        <select id="findById" parameterType="Integer" resultType="User">
            select
                *
            from
                user
            where
                id=#{uid}
        </select>
    
        <select id="findByName" parameterType="string" resultType="User">
            select
                *
            from
                user
            where
                username like concat('%',#{name},'%')
        </select>
    
        <select id="findTotal" resultType="int">
            select
                count(id)
            from
                user
        </select>
    
        <select id="findUserByVo" parameterType="QueryVo" resultType="User">
            select
                *
            from
                user
            where
                username like concat('%',#{user.username},'%')
        </select>
    </mapper>

测试文件: mybatistest.java

public class mybatisTest {
    
        private InputStream in;
        private SqlSession session;
        private IUserDao userDao;
    
        @Before
        public void init() throws Exception{
            // 1. 读取配置文件
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            // 2. 创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build(in);
            // 3. 使用工厂生产SqlSession对象
            session = factory.openSession();
            // 4. 使用SqlSession创建Dao接口的代理对象
            userDao = session.getMapper(IUserDao.class);
        }
    
        @After
        public void destroy() throws IOException {
            // 6. 释放资源
            session.close();
            in.close();
        }
    
        @Test
        public void testFindAll() throws Exception {
            // 5. 使用代理对象执行方法
            List<User> users = userDao.findAll();
            for (User user: users) {
                System.out.println(user);
            }
        }
    
        @Test
        public void testSave() throws IOException {
            User user = new User();
            user.setUsername("秋色");
            user.setAddress("小胡路365");
            user.setSex("女");
            user.setBirthday(new Date());
            System.out.println(user);
    
            // 5. 使用代理对象执行方法
            int count = userDao.saveUser(user);
            System.out.println(count);
            System.out.println(user);
    
            // 提交事务
            session.commit();
        }
    
        @Test
        public void testUpdate() throws IOException {
            User user = new User();
            user.setId(1);
            user.setUsername("小胡");
            user.setAddress("小茗路980");
            user.setSex("女");
            user.setBirthday(new Date());
    
            // 5. 使用代理对象执行方法
            int count = userDao.updateUser(user);
            System.out.println(count);
    
            // 提交事务
            session.commit();
        }
    
        @Test
        public void testDelete() throws IOException {
            // 5. 使用代理对象执行方法
            int count = userDao.deleteUser(2);
            System.out.println(count);
    
            // 提交事务
            session.commit();
        }
    
        @Test
        public void testFindByID() throws IOException {
            // 5. 使用代理对象执行方法
            User user = userDao.findById(1);
            System.out.println(user);
        }
    
        @Test
        public void testFindByName() throws IOException {
            // 5. 使用代理对象执行方法
            List<User> lists = userDao.findByName("胡");
            for (User user : lists) {
                System.out.println(user);
            }
        }
    
        @Test
        public void testTotal(){
            // 5. 使用代理对象执行方法
            int count = userDao.findTotal();
            System.out.println(count);
        }
    
        @Test
        public void testFindByVo(){
            QueryVo vo = new QueryVo();
            User user = new User();
            user.setUsername("胡");
            vo.setUser(user);
            // 5. 使用代理对象执行方法
            List<User> users = userDao.findUserByVo(vo);
            for(User u: users) {
                System.out.println(u);
            }
        }
    }

**2.1.4 常用标签**

判断是否存在：<if>、<where>

<select id="findAll" resultType="User">
        select * from user
        <where>
            <if test="username ！= null">
                and username=#{username}
            </if>
        </where>
    </select>

动态批量处理： <foreach>

批量查询：

<select id="findUserInIds" parameterType="QueryVo" resultType="User">
            select
                *
            from
                user
            <where>
                <if test="ids != null and ids.size()>0">
                    <foreach collection="ids" open="and id in (" close=")" item="uid" separator=",">
                        #{uid}
                    </foreach>
                </if>
            </where>
    </select>

批量增加：

<insert id="saveUserBatch" parameterType="QueryVo">
            insert into user(
                username,
                address,
                birthday,
                sex
            )
            values
            <if test="users != null and users.size()>0">
                <foreach collection="users" item="user" separator=",">
                    (
                        #{user.username},
                        #{user.address},
                        #{user.birthday},
                        #{user.sex}
                    )
                </foreach>
            </if>
        </insert>

批量删除：

<delete id="deleteUserBatch" parameterType="QueryVo">
            delete from
                user
            <where>
                <if test="ids != null and ids.size()>0">
                    <foreach collection="ids" item="uid" separator="," open="and id in(" close=")">
                        #{uid}
                    </foreach>
                </if>
            </where>
    </delete>

批量更新：

<update id="updateUserBatch" parameterType="QueryVo">
            <if test="users != null and users.size()>0">
                <foreach collection="users" item="user" separator=",">
                    update
                        user
                    set
                        username=#{user.username},
                        sex=#{user.sex},
                        birthday=#{user.birthday},
                        address=#{user.address}
                    where
                        id=#{user.id}
                </foreach>
            </if>
       </update>

### 2.2 POJO ###

开发中可以通过 pojo 传递查询条件，实现多个对象共同查询。可以使用包装对象传递输入参数。

/**
     * 通过封装多个对象，实现多个对象共同查询
     */
    public class QueryVo implements Serializable {
        public static final long serivalVersionUID=1L;
    
        private User user;
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
    }

<select id="findUserByVo" parameterType="QueryVo" resultType="xyz.tom.www.domain.User">
            select
                *
            from
                user
            where
                username like concat('%',#{user.username},'%')
    </select>

@Test
        public void testFindByVo(){
            QueryVo vo = new QueryVo();
            User user = new User();
            user.setUsername("胡");
            vo.setUser(user);
            // 5. 使用代理对象执行方法
            List<User> users = userDao.findUserByVo(vo);
            for(User u: users) {
                System.out.println(u);
            }
        }

### 2.3 配置指定dao包地址 ###

**2.3.1 先在配置文件中使用 packge 标签指定位置**

<?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>
        ...
    
        
        <mappers>
            
            <package name="xyz/tom/www/dao"/>
        </mappers>
    </configuration>

**2.3.2 修改 pom.xml 文件**

由于 idea 下的 maven 默认不会主动把 src 下除 java 文件夹外的文件打包到 classes 文件夹下，故需要在 pom.xml 中修改配置

### 2.4 配置类型别名，减少不断写类路径的麻烦 ###

通过 typeAliases 可以指定访问哪个包下的类文件，作为查询的入参和出参。

配置后的类名就是别名，且使用别名时不区分大小写

<configuration>
        
        <typeAliases>
            
            
            <package name="xyz.tom.www.domain"/>
        </typeAliases>
       
        .....
    </configuration>

使用前后对比：

配置前：
    <mapper namespace="xyz.tom.www.dao.IUserDao">
        <select id="findAll" resultType="xyz.tom.www.domain.User">
            ...
        </select>
    
        <insert id="saveUser" parameterType="xyz.tom.www.domain.User">
            ...
        </insert>
    
        <update id="updateUser" parameterType="xyz.tom.www.domain.User">
            ...
        </update>
    
        ......
    </mapper>
    
    配置后：
    <mapper namespace="xyz.tom.www.dao.IUserDao">
        <select id="findAll" resultType="User">
            ...
        </select>
    
        <insert id="saveUser" parameterType="User">
            ...
        </insert>
    
        <update id="updateUser" parameterType="User">
            ...
        </update>
    
        ......
    </mapper>

## 三、MyBatis 连接池和事务 ##

### 3.1 MyBatis 连接池提供的三种方式： ###

**3.1.1 配置的位置**

配置在主配置文件 SqlMapConfig.xml 中的 dataSource 标签，type 属性就是表示采用何种连接池方式

<environments default="mysql">
            
            <environment id="mysql">
                
                <transactionManager type="JDBC"></transactionManager>
                
                <dataSource type="POOLED">
                    
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.username}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
        </environments>

**3.1.2 type 属性取值**

<table> 
 <tbody> 
  <tr> 
   <td style="width:155px;"><strong>取值</strong></td> 
   <td style="width:684px;"><strong>描述</strong></td> 
  </tr> 
  <tr> 
   <td style="width:155px;">POOLED</td> 
   <td style="width:684px;">采用传统的 javax.sql.DataSource 中的连接池，mybatis 中有针对规范的实现</td> 
  </tr> 
  <tr> 
   <td style="width:155px;">UNPOLLED</td> 
   <td style="width:684px;">采用传统的获取连接的方式，虽然也实现 javax.sql.DataSrouce 接口，但是并没有使用池的思想</td> 
  </tr> 
  <tr> 
   <td style="width:155px;">JNDI</td> 
   <td style="width:684px;"> <p>采用服务器提供的 JNDI 技术实现，来获取 DataSource 对象，不同的服务器所能拿到的 DataSource 是不一样的。</p> <p>注意： 如果不是 web 或者 maven 的 war 工程，是不能使用的。</p> </td> 
  </tr> 
 </tbody> 
</table>

### 3.2 MyBatis 事务 ###

**3.2.1 什么是事务**

**3.2.2 事务的四大特性ACID**

**3.2.3 不考虑隔离性会产生的3个问题**

**3.2.4  解决办法：四种隔离级别**

### 3.3 MyBatis 一对一关系和多对多关系 ###

**3.3.1 一对一关系**

IAccountDao.xml

修改实体类：Account.java

public class Account implements Serializable {
    
        private static final long serivalVersionUID = 1L;
    
        private Integer id;
        private Integer uid;
        private Double money;
    
        private User user;
    
        public User getUser() {
            return user;
        }
    
        public void setUser(User user) {
            this.user = user;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public Integer getUid() {
            return uid;
        }
    
        public void setUid(Integer uid) {
            this.uid = uid;
        }
    
        public Double getMoney() {
            return money;
        }
    
        public void setMoney(Double money) {
            this.money = money;
        }
    
        @Override
        public String toString() {
            return "Account{" +
                    "id=" + id +
                    ", uid=" + uid +
                    ", money=" + money +
                    '}';
        }
    }

测试代码：

public class AccountTest {
    
        private InputStream in;
        private SqlSession session;
        private IUserDao userDao;
    
        @Before
        public void init() throws Exception{
            // 1. 读取配置文件
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            // 2. 创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build(in);
            // 3. 使用工厂生产SqlSession对象
            session = factory.openSession();
            // 4. 使用SqlSession创建Dao接口的代理对象
            userDao = session.getMapper(IUserDao.class);
        }
    
        @After
        public void destroy() throws IOException {
            // 6. 释放资源
            session.close();
            in.close();
        }
    
        @Test
        public void testFindAll() throws Exception {
            List<User> accs = userDao.findAll();
            for (User acc: accs) {
                System.out.println(acc);
                System.out.println(acc.getAccounts());
            }
        }
    }

**3.3.2 多对多关系**

## 四、MyBatis 加载和缓存 ##

### 4.1 延迟加载和立即加载 ###

**4.1.1 需求场景**

查询一批笔记本电脑的进货明细，而不直接展示每列明细对应电脑配置或者价格等的详细信息，等到用户需要取出某笔记本相关的详细信息的时候，再进行单表查询

**4.1.2 什么是延迟加载和立即加载**

**延迟加载：**在真正使用数据的时候才发起查询，不用的时候不查询关联的数据，延迟加载又叫按需查询（懒加载）

**立即加载：**只要一调用方法，马上发起查询。

**4.1.3 实现方式**

开启配置：

<settings>
        <setting name="lazyLoadingEnabled" value="true"/>
        <setting name="aggressiveLazyLoading" value="false"/>
    </settings>

一对一：

<resultMap id="accountUserMap" type="account">
            
            <id property="id" column="id"></id>
            
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
            
            <association property="user" column="uid" javaType="user" select="xyz.tom.www.dao.IUserDao.findById"></association>
        </resultMap>

一对多：

<resultMap id="userMap" type="user">
            
            <id property="id" column="id"></id>
            
            <result property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
            
            <collection property="accounts" ofType="account" select="xyz.tom.www.dao.IAccountDao.findAccountById" column="id"></collection>
        </resultMap>

### 4.2 缓存 ###

**4.2.1 什么是缓存**

缓存即存在于内存中的临时数据

**4.2.2 为什么使用缓存**

有效减少和数据库的交互次数，提高执行效率

**4.2.3 适用范围**

适用于缓存

*  经常查询且不常改变的
 *  数据的正确与否对最终结果影响不大的

不适用于缓存

*  经常改变的数据
 *  数据的正确与否对最终结果影响很大的
 *  例如：商品的库存，银行的汇率，股市的牌价

**4.2.4 一级缓存和二级缓存**

<table> 
 <tbody> 
  <tr> 
   <td style="width:97px;">&nbsp;</td> 
   <td style="width:347px;"><strong>一级缓存</strong></td> 
   <td style="width:368px;"><strong>二级缓存</strong></td> 
  </tr> 
  <tr> 
   <td style="width:97px;"><strong>概念</strong></td> 
   <td style="width:347px;">指的是 MyBatis 中 SqlSession 对象的缓存</td> 
   <td style="width:368px;">指的是 MyBatis 中 SqlSessionFactory 对象的缓存，由同一个&nbsp;SqlSessionFactory 对象创建的 SqlSession 共享其缓存</td> 
  </tr> 
  <tr> 
   <td style="width:97px;"><strong>存储方式</strong></td> 
   <td style="width:347px;">存储对象</td> 
   <td style="width:368px;">仅存储数据</td> 
  </tr> 
  <tr> 
   <td style="width:97px;"><strong>创建时间</strong></td> 
   <td style="width:347px;">当执行查询后，查询的结果会同时存入到 SqlSession 提供的一块区域中</td> 
   <td style="width:368px;">开启配置后，查询时自动存入扫 SqlSessionFactory 中</td> 
  </tr> 
  <tr> 
   <td style="width:97px;"><strong>销毁时间</strong></td> 
   <td style="width:347px;">当调用 SqlSession 的修改、添加、删除、commit()、close() 等方法时，就会清空一级缓存</td> 
   <td style="width:368px;">任何的增删改都将刷新二级缓存&nbsp;</td> 
  </tr> 
  <tr> 
   <td style="width:97px;"><strong>使用原则</strong></td> 
   <td style="width:347px;">默认开启</td> 
   <td style="width:368px;"> <p>① 只能在同一个命名空间下使用二级缓存，若多个命名空间下都存在对同一个表的操作，那么这些命名空间内的数据可能会不一致</p> <p>&nbsp;</p> <p>② 在单表上使用二级缓存。若一个表与其他表有关联，那么可能存在多个命名空间对同一数据的操作</p> <p>&nbsp;</p> <p>③ 在查询多于修改时使用。由于任何的增删改操作都将刷新二级缓存，对二级缓存的频繁刷新会降低系统性能</p> </td> 
  </tr> 
 </tbody> 
</table>

**4.2.5 二级缓存的打开方式**

SqlMapConfig.xml

<configuration>
        ...
    
        <settings>
            <setting name="cacheEnabled" value="true"/>
        </settings>
    </configuration>

IUserDao.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="xyz.tom.www.dao.IUserDao">
        
        <cache/>
    
    
        
        <select id="findById" parameterType="Integer" resultType="user" useCache="true">
            select
                *
            from
                user
            where
                id=#{uid}
        </select>
    
    </mapper>

## 五、MyBatis 的注解用法 ##

SqlMapConfig.xml

<?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>
        ....
    
        
        <mappers>
            <package name="xyz.tom.www.dao"/>
        </mappers>
    </configuration>

IUserDao.java

package xyz.tom.www.dao;
    
    import org.apache.ibatis.annotations.*;
    import xyz.tom.www.domain.AliasUser;
    import xyz.tom.www.domain.User;
    
    import java.util.List;
    
    public interface IUserDao {
    
        @Select("select * from user")
        List<User> findAll();
    
        @Select("select * from user")
        @Results(id="userMap", value = {
                @Result(id = true, column = "id", property = "uId"),
                @Result(column = "username", property = "userN"),
                @Result(column = "address", property = "userA"),
                @Result(column = "sex", property = "userS"),
                @Result(column = "birthday", property = "userB"),
    
        })
        List<AliasUser> findAliasAll();
    
        @Select("select * from user")
        @ResultMap(value = {"userMap"})
        List<AliasUser> findAliasAll2();
    
        @Insert("insert into user(username, birthday, sex, address) values(#{username},#{birthday},#{sex},#{address})")
        int saveUser(User user);
    
        @Update("update user set username=#{username}, birthday=#{birthday}, sex=#{sex}, address=#{address} where id=#{id}")
        int updateUser(User user);
    
        @Delete("delete from user where id=#{id} ")
        int deleteUser(int id);
    }