mybatis笔记

已于 2022-02-18 20:54:43 修改
阅读量710 收藏
点赞数
分类专栏： javaEE 文章标签： maven java apache mybatis
于 2022-02-18 19:42:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51654746/article/details/123009973
版权

1、mybatis项目的搭建

一般我们都使用Maven来构建项目，那我们就不需要进行jar包的导入，只需要在pom文件中进行配置即可，在这里学习mybatis只需要用到mybatis、junit和mysql-connector-java这三个jar包即可

**注意：**由于我们使用mybatis后，会有一些配置文件的产生，有时会生成不到target目录中，导致程序无法运行，只需要在pom文件中加入以下配置即可解决问题

<!--在build中配置resources，来防止我们资源导出失败的问题-->
<build>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.xml</include>
            </includes>
        </resource>
    </resources>
</build>

2、mybatis的使用

案例：对一张用户表进行增删改查的操作

1、在resources目录下写一个mybatis-config.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>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!--这里的配置一般使用配置文件的形式引入-->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?serverTimezone=Asia/Shanghai"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--这里配置的信息就是dao类的信息，需要将所有的dao或者说是mapper的信息都需要在这里进行配置-->
    <mappers>
        <mapper resource="com/hty/dao/UserMapper.xml"/>
    </mappers>
</configuration>

2、写一个util包，里面写一个MybatisUtil工具类，用来获取sqlSessionFactory来进行后续操作

package com.hty.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static{
        //使用mvbatis第一步  获取sqlSessionFactory对象
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory对象之后，就可以获得SqlSession的实例
    //SqlSession完全包含了面向数据库执行SQL命令所需要的所有方法
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

3、写一个表对应的实体类

package com.hty.entity;

public class User {
    private Integer id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(Integer id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

4、写dao(mapper)接口 以后我们就将dao都叫做mapper

package com.hty.dao;

import com.hty.entity.User;

import java.util.List;
import java.util.Map;

public interface UserMapper {
    //查询
    List<User> getUser();
    //根据id查询用户
    User getUserById(int id);
    //插入一个用户
    int addUser(User user);
    //修改用户
    int updateUser(User user);
    //删除用户
    int deleteUser(int id);

    //万能的map
    int addUser2(Map<String,Object> map);

    //模糊查询
    List<User> getUserLike(String value);
}

5、将这个接口进行配置 配置文件的位置和当前接口的包一样，名字为接口名+.xml namespace就是要使用的接口的全类名

<?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">
<!--namespace需要绑定一个DAO/Mapper接口-->
<mapper namespace="com.hty.dao.UserMapper">
    <!-- id对应Dao接口中的方法名 resultType一定要从包名开始写 parameterType参数类型-->
    <select id="getUser" resultType="com.hty.entity.User">
        select * from user;
    </select>

    <select id="getUserById" resultType="com.hty.entity.User" parameterType="int">
        select * from user where id=#{id};
    </select>

    <insert id="addUser" parameterType="com.hty.entity.User">
        insert into user(id,name,pwd) value(#{id},#{name},#{pwd});
    </insert>

    <update id="updateUser" parameterType="com.hty.entity.User">
        update user set name=#{name},pwd=#{pwd} where id=#{id};
    </update>

    <delete id="deleteUser" parameterType="int">
        delete from user where id=#{id};
    </delete>


    <insert id="addUser2" parameterType="map">
        insert into user(id,name,pwd) value(#{userid8/},#{username},#{userpwd});
    </insert>


    <select id="getUserLike" resultType="com.hty.entity.User">
        select * from user where name like #{value};
    </select>
</mapper>

6、在test目录下编写测试类，包的路径要和mapper的路径要一样 注:这个测试一定要是导入了junit的jar包，不然无法进行测试 测试的时候在方法上面加上注解@Test

package com.hty.dao;

import com.hty.entity.User;
import com.hty.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.HashMap;
import java.util.List;

public class UserDaooTest {
    //查询
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

//        List<User> users = mapper.getUser();
//        for (User user : users) {
//            System.out.println(user);
//        }


        User users = mapper.getUserById(2);

        System.out.println(users);

        sqlSession.close();
    }
    //增删改需要提交事务
    //增加
    @Test
    public void addUserTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User u = new User(1,"李四","123");

        mapper.addUser(u);
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }
    //修改
    @Test
    public void updateTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        User u = new User(1,"李四","123345");

        mapper.updateUser(u);

        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }
    //删除
    @Test
    public void deleteTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        mapper.deleteUser(1);

        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }




    //Map测试
    @Test
    public void addUser2Test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        HashMap<String, Object> map = new HashMap<>();
        map.put("userid",1);
        map.put("username","李四");
        map.put("userpwd","123");

        mapper.addUser2(map);
        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }


    //模糊查询
    @Test
    public void getUserLikeTest(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        List<User> users = mapper.getUserLike("%李%");
        for (User user : users) {
            System.out.println(user);
        }

        //提交事务
        sqlSession.commit();
        sqlSession.close();
    }
}

3、配置解析

mybatis的配置文件包含了会深深影响mybatis行为的设置和属性信息，而且这些配置在mybatis-config文件中都有特定的顺序，如果不按照这个顺序来的话就会报错

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

3.1、environments（环境配置）

environments标签下可以写多个environment每一个environment就是一个环境，通过修改environments中default的属性值来更改环境，通过修改environment标签中的id值可以对当前环境就行命名

3.2、数据源（dataSource）

dataSource 元素使用标准的 JDBC 数据源接口来配置 JDBC 连接对象的资源。

有三种内建的数据源类型（也就是 type="[UNPOOLED|POOLED|JNDI]"）

UNPOOLED– 这个数据源的实现会每次请求时打开和关闭连接。虽然有点慢，但对那些数据库连接可用性要求不高的简单应用程序来说，是一个很好的选择。 性能表现则依赖于使用的数据库，对某些数据库来说，使用连接池并不重要，这个配置就很适合这种情形。UNPOOLED 类型的数据源仅仅需要配置以下 5 种属性：

  • driver – 这是 JDBC 驱动的 Java 类全限定名（并不是 JDBC 驱动中可能包含的数据源类）。
  • url – 这是数据库的 JDBC URL 地址。
  • username – 登录数据库的用户名。
  • password – 登录数据库的密码。
  • defaultTransactionIsolationLevel – 默认的连接事务隔离级别。
  • defaultNetworkTimeout – 等待数据库操作完成的默认网络超时时间（单位：毫秒）。查看 java.sql.Connection#setNetworkTimeout() 的 API 文档以获取更多信息。

作为可选项，你也可以传递属性给数据库驱动。只需在属性名加上“driver.”前缀即可，例如：

  • driver.encoding=UTF8

这将通过 DriverManager.getConnection(url, driverProperties) 方法传递值为 UTF8 的 encoding 属性给数据库驱动。

POOLED– 这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来，避免了创建新的连接实例时所必需的初始化和认证时间。 这种处理方式很流行，能使并发 Web 应用快速响应请求。

除了上述提到 UNPOOLED 下的属性外，还有更多属性用来配置 POOLED 的数据源：

  • poolMaximumActiveConnections – 在任意时间可存在的活动（正在使用）连接数量，默认值：10
  • poolMaximumIdleConnections – 任意时间可能存在的空闲连接数。
  • poolMaximumCheckoutTime – 在被强制返回之前，池中连接被检出（checked out）时间，默认值：20000 毫秒（即 20 秒）
  • poolTimeToWait – 这是一个底层设置，如果获取连接花费了相当长的时间，连接池会打印状态日志并重新尝试获取一个连接（避免在误配置的情况下一直失败且不打印日志），默认值：20000 毫秒（即 20 秒）。
  • poolMaximumLocalBadConnectionTolerance – 这是一个关于坏连接容忍度的底层设置， 作用于每一个尝试从缓存池获取连接的线程。 如果这个线程获取到的是一个坏的连接，那么这个数据源允许这个线程尝试重新获取一个新的连接，但是这个重新尝试的次数不应该超过 poolMaximumIdleConnections 与 poolMaximumLocalBadConnectionTolerance 之和。 默认值：3（新增于 3.4.5）
  • poolPingQuery – 发送到数据库的侦测查询，用来检验连接是否正常工作并准备接受请求。默认是“NO PING QUERY SET”，这会导致多数数据库驱动出错时返回恰当的错误消息。
  • poolPingEnabled – 是否启用侦测查询。若开启，需要设置 poolPingQuery 属性为一个可执行的 SQL 语句（最好是一个速度非常快的 SQL 语句），默认值：false。
  • poolPingConnectionsNotUsedFor – 配置 poolPingQuery 的频率。可以被设置为和数据库连接超时时间一样，来避免不必要的侦测，默认值：0（即所有连接每一时刻都被侦测 — 当然仅当 poolPingEnabled 为 true 时适用）。

JNDI – 这个数据源实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置一个 JNDI 上下文的数据源引用。这种数据源配置只需要两个属性：

  • initial_context – 这个属性用来在 InitialContext 中寻找上下文（即，initialContext.lookup(initial_context)）。这是个可选属性，如果忽略，那么将会直接从 InitialContext 中寻找 data_source 属性。
  • data_source – 这是引用数据源实例位置的上下文路径。提供了 initial_context 配置时会在其返回的上下文中进行查找，没有提供时则直接在 InitialContext 中查找。

和其他数据源配置类似，可以通过添加前缀“env.”直接把属性传递给 InitialContext。

3.3、transactionManager（事务管理器）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）

  • JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
  • MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。 默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。

例如

<transactionManager type="MANAGED">
  <property name="closeConnection" value="false"/>
</transactionManager>

3.4、properties(属性优化)

<?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="db.properties"/>

    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/hty/dao/UserMapper.xml"/>
    </mappers>
</configuration>

这样做的好处就是可以将一些会修改的信息写在配置文件中，以后只需要修改配置文件即可完成程序的修改，这样做的前提就是要先使用properties标签引入外部配置文件

3.5、类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>

这个别名一般是用在Mapper.xml，中的resultType属性中使用

另外也可以指定一个包名，MyBatis会在包名下面搜索需要的JavaBean实体类，扫描实体类的包，他的默认别名就是这个类的类名首字母小写，如果在JavaBean实体类上面加@Alias(“别名”) 那么当前类的别名就是注解上的别名

<typeAliases>
    <package name="com.hty.entity"/>
</typeAliases>

一般建议使用第二种方法

mybatis还给java的内置类型起了别名，可以查看mybatis的网站来进行查阅

3.6、设置（settings）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等。

设置名描述有效值默认值
cacheEnabled全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。true | falsetrue
lazyLoadingEnabled延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。true | falsefalse
aggressiveLazyLoading开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。true | falsefalse （在 3.4.1 及之前的版本中默认为 true）
multipleResultSetsEnabled是否允许单个语句返回多结果集（需要数据库驱动支持）。true | falsetrue
useColumnLabel使用列标签代替列名。实际表现依赖于数据库驱动，具体可参考数据库驱动的相关文档，或通过对比测试来观察。true | falsetrue
useGeneratedKeys允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）。true | falseFalse
autoMappingBehavior指定 MyBatis 应如何自动映射列到字段或属性。 NONE 表示关闭自动映射；PARTIAL 只会自动映射没有定义嵌套结果映射的字段。 FULL 会自动映射任何复杂的结果集（无论是否嵌套）。NONE, PARTIAL, FULLPARTIAL
autoMappingUnknownColumnBehavior指定发现自动映射目标未知列（或未知属性类型）的行为。NONE: 不做任何反应WARNING: 输出警告日志（'org.apache.ibatis.session.AutoMappingUnknownColumnBehavior' 的日志等级必须设置为 WARN）FAILING: 映射失败 (抛出 SqlSessionException)NONE, WARNING, FAILINGNONE
defaultExecutorType配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。SIMPLE REUSE BATCHSIMPLE
defaultStatementTimeout设置超时时间，它决定数据库驱动等待数据库响应的秒数。任意正整数未设置 (null)
defaultFetchSize为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。任意正整数未设置 (null)
defaultResultSetType指定语句默认的滚动策略。（新增于 3.5.2）FORWARD_ONLY | SCROLL_SENSITIVE | SCROLL_INSENSITIVE | DEFAULT（等同于未设置）未设置 (null)
safeRowBoundsEnabled是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。true | falseFalse
safeResultHandlerEnabled是否允许在嵌套语句中使用结果处理器（ResultHandler）。如果允许使用则设置为 false。true | falseTrue
mapUnderscoreToCamelCase是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。true | falseFalse
localCacheScopeMyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 默认值为 SESSION，会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。SESSION | STATEMENTSESSION
jdbcTypeForNull当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。 某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。JdbcType 常量，常用值：NULL、VARCHAR 或 OTHER。OTHER
lazyLoadTriggerMethods指定对象的哪些方法触发一次延迟加载。用逗号分隔的方法列表。equals,clone,hashCode,toString
defaultScriptingLanguage指定动态 SQL 生成使用的默认脚本语言。一个类型别名或全限定类名。org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler指定 Enum 使用的默认 TypeHandler 。（新增于 3.4.5）一个类型别名或全限定类名。org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls指定当结果集中值为 null 的时候是否调用映射对象的 setter（map 对象时为 put）方法，这在依赖于 Map.keySet() 或 null 值进行初始化时比较有用。注意基本类型（int、boolean 等）是不能设置成 null 的。true | falsefalse
returnInstanceForEmptyRow当返回行的所有列都是空时，MyBatis默认返回 null。 当开启这个设置时，MyBatis会返回一个空实例。 请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）true | falsefalse
logPrefix指定 MyBatis 增加到日志名称的前缀。任何字符串未设置
logImpl指定 MyBatis 所用日志的具体实现，未指定时将自动查找。SLF4J | LOG4J(deprecated since 3.5.9) | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING未设置
proxyFactory指定 Mybatis 创建可延迟加载对象所用到的代理工具。CGLIB | JAVASSISTJAVASSIST （MyBatis 3.3 以上）
vfsImpl指定 VFS 的实现自定义 VFS 的实现的类全限定名，以逗号分隔。未设置
useActualParamName允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。（新增于 3.4.1）true | falsetrue
configurationFactory指定一个提供 Configuration 实例的类。 这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。 这个类必须包含一个签名为static Configuration getConfiguration() 的方法。（新增于 3.2.3）一个类型别名或完全限定类名。未设置
shrinkWhitespacesInSql从SQL中删除多余的空格字符。请注意，这也会影响SQL中的文字字符串。 (新增于 3.5.5)true | falsefalse
defaultSqlProviderTypeSpecifies an sql provider class that holds provider method (Since 3.5.6). This class apply to the type(or value) attribute on sql provider annotation(e.g. @SelectProvider), when these attribute was omitted.A type alias or fully qualified class nameNot set
nullableOnForEachSpecifies the default value of ‘nullable’ attribute on ‘foreach’ tag. (Since 3.5.9)true | falsefalse

案例

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

3.7、映射器（mappers）

定义 SQL 映射语句,我们需要告诉 MyBatis 到哪里去找到这些语句。 在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。 你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等。

一共有四种方式可以进行映射

方式一：推荐使用这种方式

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

方式二：这种方式不推荐使用

<!-- 使用完全限定资源定位符（URL）(一般不使用这个) -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

方式三：使用class文件绑定注册

<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

注：

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

方式四：使用扫描包进行注入绑定

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

注：

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

8、生命周期和作用域

生命周期和作用域是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了。 因此 SqlSessionFactoryBuilder 实例的最佳作用域是方法作用域（也就是局部方法变量）。 你可以重用 SqlSessionFactoryBuilder 来创建多个 SqlSessionFactory 实例，但最好还是不要一直保留着它，以保证所有的 XML 解析资源可以被释放给更重要的事情。

  • 一旦创建了SqlSessionFactory就不载需要它了
  • 局部变量
SqlSessionFactory

SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

  • 说白了就是数据库连接池
  • SqlSessionFactory一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或者重新创建另一个实例
  • 最简单的就是使用单例模式或者静态单例模式
SqlSession

每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。 绝对不能将 SqlSession 实例的引用放在一个类的静态域，甚至一个类的实例变量也不行。 也绝不能将 SqlSession 实例的引用放在任何类型的托管作用域中，比如 Servlet 框架中的 HttpSession。 如果你现在正在使用一种 Web 框架，考虑将 SqlSession 放在一个和 HTTP 请求相似的作用域中。 换句话说，每次收到 HTTP 请求，就可以打开一个 SqlSession，返回一个响应后，就关闭它。 这个关闭操作很重要，为了确保每次都能执行关闭操作，你应该把这个关闭操作放到 finally 块中。

  • 连接到连接池的一个请求
  • SqlSession的实例不是线程安全的，因此是不能被共享的，所以他的最佳作用域是请求或方法作用域
  • 用完之后需要赶紧关闭，否则资源就会被占用

4、ResultMap(解决属性名和字段名不一致的问题)

在实体类中的属性名如果和数据库中的属性名不一致就会在查询时查不出来名称不一致的数据

例如我们数据库中的数据名为pwd但是实体类中写的是password，那么在按照其他字段查询后，查询出来的password属性就会为null，因为mybatis在查询出来结果后，查到的是pwd属性，就会在实体类中寻找pwd属性，由于在实体类中没有找到，所以pwd的值不会赋给任何属性，password属性也不会被赋值

解决办法 在Mapper.xml中进行配置

1、起别名

最基础的办法就是

select pwd as password from user where id=#{id};

<select id="getUserById" resultType="User">
    select pwd as password from user where id=#{id};
</select>

2、使用ResultMap

结果集映射

<!--前提是已经在mybatis-config配置文件中起了别名-->
<resultMap id="UserMap" type="User">
    <!--column是数据库中的字段  property是实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>
<select id="getUserById" resultType="User">
    select pwd as password from user where id=#{id};
</select>

resultMap 元素是 MyBatis 中最重要最强大的元素

ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

5、日志

5.1、日志工厂

如果一个数据库操作出现异常，我们需要进行排错，日志就是最好的排错方式

这里使用到的就是settings设置中的logImpl属性

在mybatis中具体使用哪个日志实现，在设置中设定

STDOUT_LOGGING:标准日志输出

在mybatis核心配置文件中，配置日志

<settings>
    <!--标准的日志工厂-->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

5.2、log4j

什么是log4j？

  • Log4j是Apache的一个开源项目，通过使用log4j我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
  • 我们可以控制每一条日志的输出格式
  • 通过定义每一条日志信息的级别， 我们能够更加细致的控制日志的生成过程
  • 通过一个配置文件来灵活的进行配置，而不需要修改应用代码

第一步：导入log4j的jar包

<!--pom文件中导入-->
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

第二步：在resources下建一个log4j.properties的文件 并写入一下内容

#将等级为DEBUG的日志信息输出到console和file两个目的地
log4j.rootLogger=DEBUG,console,file

#控制台输出的相关设置
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.out
log4j.appender.console.Threshold=DEBUG
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=[%c]-%m%n

#文件输出的相关配置
log4j.appender.file=org.apache.log4j.RollingFileAppender

#设置输出的位置
log4j.appender.file.File=./log/hty.log
#设置每个日志文件的分割大小 达到这个大小就会自动新建一个日志文件
log4j.appender.file.MaxFileSize=10mb
log4j.appender.file.Threshold=DEBUG
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}[%c]%m%n

#日志输出级别
log4j.logger.org.mybatis=DEBUG
log4j.logger.java.sql=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG

第三步：在mybatis的配置文件中加入设置

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

第四步：log4j的使用 在需要输出日志的类的方法中加入如下代码 这些语句就会输出在控制台也会保存在日志文件中，这三种方式也代表了信息的三种状态，如果程序在这里可能会出错，那么就可以打印一个error形式的日志信息

Logger logger = Logger.getLogger(当前的类名.class);//这个语句一般写在类的属性中，并且是一个静态的属性
logger.info("以info方式");
logger.debug("以debug方式");
logger.error("以error方式");

6、分页

分页的意义：减少数据的处理量

6.1、使用limit分页

select * from user limit startIndex,pageSize;
select * from user limit pageSize;

6.2、使用mybatis实现分页，核心就是sql

<!--分页实现查询-->
<!--里面的startIndex和pageSize都是将来在map中存的key 用这个key来找到value-->
<select id="getUserByLimit" resultType="User" parameterType="map">
    select * from user limit #{startIndex},#{pageSize};
</select>

测试类中的代码

@Test
public void getUserByLimitTest(){
    SqlSession sqlSession = MybatisUtil.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    Map<String,Integer> map = new HashMap<>();

    map.put("startIndex",0);
    map.put("pageSize",1);

    List<User> userByLimit = mapper.getUserByLimit(map);

    for (User user : userByLimit) {
        System.out.println(user);
    }
    sqlSession.close();
}

7、使用注解开发

对于一些接口里面的方法，我们不需要使用xml配置，可以使用注解直接在方法上面写sql语句

案例：

public interface BlogMapper {
  @Select("SELECT * FROM blog WHERE id = #{id}")
  Blog selectBlog(int id);
}

使用注解来映射简单语句会使代码显得更加简洁，但对于稍微复杂一点的语句，Java 注解不仅力不从心，还会让你本就复杂的 SQL 语句更加混乱不堪。 因此，如果你需要做一些很复杂的操作，最好用 XML 来映射语句。

注：我们对数据库进行增删改查操作之后，需要手动进行事务的提交，这个时候就会很麻烦，于是我们可以在获取SqlSession进行设置

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static{
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static SqlSession getSqlSession(){
        //传递true进去就可以实现自动提交
        return sqlSessionFactory.openSession(true);
    }
}

使用注解进行增删改查

接口的写法

param中的内容就是sql语句中需要的参数的名字

package com.hty.dao;

import com.hty.pojo.User;

import java.util.List;
import java.util.Map;

public interface UserMapper {
	//查询用户
    @Select("select * from user")
    List<User> getUsers();
    
    //按照id查询用户 方法存在多个参数，所有的参数前面必须加上@Param()注解 注解括号内的名称对应的就是sql语句中的#{}中的内容
    @Select("select * from user where id=#{id}")
    User getUserByID(@Param("id") int id);
    
	//添加操作
    @Insert("insert into user(id,name,pwd) value(#{id},#{name},#{pwd})")
    int addUser(User user);//注意当前括号内没有@Param()这个注解
    
    //修改
    @Update("Update user set name=#{name},pwd=#{pwd} where id=#{id}")
    int updateUser(User user);
    
    //删除
    @Delete("delete from user where id=#{id}")
    public int deleteUser(@Param("id") int id);
}

注意：当参数是引用类型的时候，可以不使用param注解，直接使用其中的属性，如果要使用param注解，那么就需要在sql语句中加上param中的参数名.属性名

例：

//添加操作
@Insert("insert into user(id,name,pwd) value(#{user.id},#{user.name},#{user.pwd})")
int addUser(@Param("user") User user);

关于@Param()注解的一些注意点

  • 基本类型的参数或者String类型需要加上
  • 引用类型不需要加
  • 如果之后一个基本类型，可以不加，但是一般建议都加上

面试题

#{}与${}注入属性之间的区别

#{}实现的是向prepareStatement中的预处理语句中设置参数值，sql语句中#{}表示一个占位符即?

#{} : 采用预编译方式,可以防止SQL注入
${}: 采用直接赋值方式,无法阻止SQL注入攻击

需要动态的指定查询中的排序字段,此时也只能使用 , 即 就 是 使 用 o r d e r b y 的 时 候 只 能 使 用 {},即就是使用order by的时候只能使用 ,即就是使用orderby的时候只能使用{}

8、多对一与一对多处理

多对一：多个学生对应一个老师

一对多：一个老师对应多个学生

案例：多个学生对应的老师(多对一)

<?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.hty.dao.StudentMapper">

    <select id="getStudent" resultMap="StudentTeacher">
        select * from student;
    </select>
    <resultMap id="StudentTeacher" type="com.hty.entity.Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--复杂的属性(引用类型)
            对象使用 association
            集合使用 collection
            property就是student类中的属性名
            column就是查询语句中的字段名，如果没有进行重命名 那么就是原数据库当中的字段名，如果有重命名，那么字段名就是重命名之后的名字
            javaType 就是他的类型
            select 就是嵌套的查询语句 就是在下面写的另一个select标签的id
        -->
        <association property="teacher" column="tid" javaType="com.hty.entity.Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="com.hty.entity.Teacher">
        select * from teacher where id=#{id};
    </select>
</mapper>

案例：一个老师对应多个学生(一对多)

<?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.hty.dao.TeacherMapper">
    <select id="getTeacher" resultMap="TeacherStudent">
        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=#{tid};
    </select>
    <resultMap id="TeacherStudent" type="com.hty.entity.Teacher">
        <result property="id" column="tid"></result>
        <result property="name" column="tname"></result>
        <!--注意这里的是 ofType 指的是当前属性映射的实体类-->
        <collection property="students" ofType="com.hty.entity.Student">
            <result property="id" column="sid"></result>
            <result property="name" column="sname"></result>
        </collection>
    </resultMap>
</mapper>

9、动态SQL

动态SQL就是指，根据不同的条件生成不同的SQL语句

动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。

动态SQL很类似于JSTL，使用标签书写逻辑代码

9.1、if标签的使用

使用动态 SQL 最常见情景是根据条件包含 where 子句的一部分,使用if就可以将所有满足if条件下的sql语句自动进行拼接，注意这里是所有的if都会进行判断，并且将所有条件为true的if标签下的语句都拼接上去

案例：我们要查询所有以张三为作者的博客，如果传入了ID那么就联合之前的条件一起查询，这个案例中的ID就是一个动态的参数，有可能传入也有可能不传,那么我们就需要使用if标签来进行判断

<select id="queryBlogIF" parameterType="map" resultType="com.hty.entity.Blog">
    <!--这里的1=1实际相当于是占位符-->
    select * from blog where 1=1
    <!--test属性就是一个判断语句  title就是接口中方法的参数-->
    <if test="title != null">
        and title=#{title}
    </if>
</select>

9.2、choose(when,otherwise)

这个和if相似，但是只会选择其中一个满足条件的进行拼接，类似于java中的switch语句，otherwise表示的就是当所有的when都不满足的时候，就会拼接otherwise中的sql

案例：查询所有以张三为作者的博客，如果传入了ID那么就联合ID查询，如果传入了博客题目那就联合博客题目查询，如果都没有传，就全部都查

<select id="queryBlogIF" parameterType="map" resultType="com.hty.entity.Blog">
    <!--这里的1=1实际相当于是占位符-->
    select * from blog where 1=1   
    <!--test属性就是一个判断语句  title就是接口中方法的参数-->
    <choose>
        <when test="ID != null">
            AND ID = #{ID}
        </when>
        <when test="title != null">
            AND title = #{title}
        </when>
        <otherwise>
            AND 1=1
        </otherwise>
    </choose>
</select>

9.3、where

在if标签中，如果我们这样写

<select id="queryBlogIF" parameterType="map" resultType="com.hty.entity.Blog">
    select * from blog where
    <if test="title != null">
        and title=#{title}
    </if>
</select>

当if条件为假时，sql语句就会变成

select * from blog where

这就会导致查询失败，解决方法是使用where标签

<select id="queryBlogIF" parameterType="map" resultType="com.hty.entity.Blog">
    select * from blog
    <where>
        <if test="title != null">
            title=#{title}
        </if>
        <if test="state != null">
            and state = #{state}
        </if>
    </where>
</select>

若上述查询第一个条件不成立，sql语句就会变为

select * from blog where and state = #{state}

where标签就会自动将and去掉来保证程序的正确性

9.4、set

用于动态更新语句的类似解决方案叫做 set。set 元素可以用于动态包含需要更新的列，忽略其它不更新的列。

<update id="updateAuthorIfNecessary">
  update Author
    <set>
      <if test="username != null">username=#{username},</if>
      <if test="password != null">password=#{password},</if>
      <if test="email != null">email=#{email},</if>
      <if test="bio != null">bio=#{bio}</if>
    </set>
  where id=#{id}
</update>

这个一般用于update语句中，防止逗号缺失产生问题，

set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号（这些逗号是在使用条件语句给列赋值时引入的）。

9.5、SQL片段

我们可以将一部分的mapper.xml中的一些动态SQL语句提取出来，以便后续进行复用

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hty.dao.BlogMapper">

    <!--id可以随便取-->
    <sql id="if-title-author">
        <if test="title != null">
            and title=#{title}
        </if>
        <if test="author != null">
            and  author = #{author}
        </if>

    </sql>
    <select id="queryBlogIF" parameterType="map" resultType="com.hty.entity.Blog">
        select * from blog
        <where>
            /*这里的refid就是上面SQL片段中的id*/
            <include refid="if-title-author"/>
        </where>
    </select>
</mapper>
  • 使用SQL标签抽取公共的部分
  • 在需要使用的地方使用include标签引用即可

注：

  • 最好基于单表来定义SQL片段
  • 不要存在where标签

9.6、foreach

动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符

案例

sql语句为   select * from user where 1=1 and (id=1 or id=2 or id=3);

使用forearch进行拼接  open就是开始的字符 close就是结束的字符 separator就是分隔符  collection就是集合名  index就是下标
<foreach item="id" index="index" collection="ids"
         open="(" separator="or" close=")">
	#{id}
</foreach>

10、缓存

什么是缓存？

  • 存在内存中的临时数据
  • 将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上查询，从缓存中查询，从而提高查询效率， 解决高并发系统的性能问题

为什么使用缓存？

  • 减少和数据库交互的次数，减少系统开销，提高系统效率

10.1、mybatis缓存

mybatis包含一个非常强大的查询缓存特性，他可以非常方便的定制和配置缓存，缓存可以极大的提升查询效率

mybatis系统中默认定义了两级缓存：一级缓存和二级缓存

  • 默认情况下，只有一级缓存开启(SqlSession级别的缓存，也叫本地缓存)
  • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存
  • 为了提高扩展性，mybatis定义了缓存接口Cache，我们可以通过实现Cache接口来定义二级缓存

10.2、一级缓存

一级缓存也叫本地缓存

  • 与数据库同一次会话期间查询到的数据会放在本地缓存中
  • 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库

其实就是我们在测试类中会获取SqlSession，从SqlSession开启到关闭之间，这个缓存都可以使用

测试：

@Test
public void test1(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    User user1 = mapper.queryUserById(1);

    User user2 = mapper.queryUserById(1);
	//查询到的是同一个用户，所以就会在缓存中进行查找，那么查找出来的user对象的地址就相同
    System.out.println(user1==user2);//true

    sqlSession.close();
}
  • 映射语句文件中的所有 select 语句的结果将会被缓存。
  • 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
  • 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
  • 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
  • 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
  • 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

缓存失效(刷新)的情况：

  • 查询不同的东西
  • 增删改操作，可能会改变原来的数据，所以必定会刷新缓存
  • 查询不同的mapper.xml
  • 手动清除

手动清除的方法

sqlSession.clearCache();

小结：一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到了连接到关闭这个区间段，一级缓存相当于一个Map

10.3、二级缓存

二级缓存也叫全局缓存，一级缓存作用域太低了，所以有了二级缓存

基于namespace级别的缓存，一个名称空间，对应一个二级缓存

工作机制：

  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
  • 如果当前会话关闭了，这个会话对应的一级缓存就没了，但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中
  • 新的会话查询信息，就可以从二级缓存中获取内容
  • 不同的mapper查出的数据会放在自己对应的缓存map中

默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行

<cache/>

缓存的清除策略

  • LRU – 最近最少使用：移除最长时间不被使用的对象。
  • FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
  • SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
  • WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

默认的清除策略是 LRU。

启动二级缓存步骤

  1. 开启全局缓存

    在mybatis配置文件中加入设置 (默认是开启状态)

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

  2. 在mapper文件中进行配置

    <?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hty.dao.UserMapper">
    <!--在当前mapper使用二级缓存-->
    <cache
        eviction="FIFO"
        flushInterval="60000"
        size="512"
        readOnly="true"/>

    <select id="queryUserById" resultType="user">
        select * from user where id=#{id};
    </select>
</mapper>

  3. 在测试类中进行测试

    package com.hty.dao;

import com.hty.pojo.User;
import com.hty.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

public class UserMapperTest {
    @Test
    public void test1(){
        SqlSession sqlSession1 = MybatisUtils.getSqlSession();
        UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
        User user1 = mapper1.queryUserById(1);
        sqlSession1.close();

        SqlSession sqlSession2 = MybatisUtils.getSqlSession();
        UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
        User user2 = mapper2.queryUserById(1);
		
        //虽然sqlSession关闭，一级缓存已经失效，但是由于二级缓存的开启，所以最后查询到的对象仍然是相同的
        System.out.println(user1 == user2);//true
    }
}

问题：如果不在cache标签中加入任何配置，直接就是一个单标签<cache/>那么就会报错，是因为实体类没有进行序列化，只需要让实体类实现Serializable接口就可以了

10.4、mybatis缓存原理图

在这里插入图片描述

10.5、自定义缓存-ehcache

ehcache是一种广泛使用的开源Java分布式缓存，主要面向通用缓存

要在程序中使用ehcache要先导包

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.1.0</version>
</dependency>

在mapper配置文件中加入

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hty.dao.UserMapper">
    <!--自定义缓存-->
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
</mapper>

在resources下新建ehcache.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    
    <diskStore path="./tmpdir/Tmp_EhCache"/>

    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>

    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
</ehcache>
Autunomy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
阅读 MyBatis 源码：数据库连接池 PooledDataSource
Sumkor的博客
08-19 750
在 MyBatis 中，使用 PooledDataSource 数据源作为连接池对象，在连接池中存储的是 PooledConnection 对象。通过动态代理，实现对原始连接对象的复用，以及多线程间使用数据库连接的隔离。
Mybatis系列（二）配置
Chris Mao的专栏
09-29 1万+
Mybatis 配置 上一篇文章，我们简单了解了Mybatis，现在我们就来了解一下她的核心配置文件。 注：以下内容部分转载自Mybatis官方文档。 XML 映射配置文件 MyBatis 的配置文件包含了影响 MyBatis 行为甚深的设置（settings）和属性（properties）信息。 属性(properties) 这些属性都是可外部配置且可动态替换的，既可以在典型的
“自以为对的”MyBatis空闲连接探测的机制
bisal的专栏
04-12 1168
最近碰到个现象，某个应用，每天在21:00-23:00才会执行，连接数据库执行操作，间隔性出现连接超时的错误，Connectiontimedout(Readfailed) 因为应用...
mybatis自带连接池使用
热门推荐
yue_cui_wu的博客
09-12 1万+
使用mybatis自带的连接池获得数据库连接,对数据库进行操作. 获得连接和关闭连接都是用mybatis自带的连接池,节省资源.   获取连接 获得连接.在使用mapper进行数据库操作时,会使用JdbcTransaction获得连接. JdbcTransaction  protected DataSource dataSource; Connection connection =...
手撕MyBatis|第一章-通过NoXML配置看源码
snowing
10-04 222
准备工作： 1.导包 mybatis、junit、mysql-connector、log4 <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis --> <dependency> <groupId>org.mybatis</groupId> <artifa...
MyBatis源码解析（六）——DataSource数据源模块之池型数据源
weixin_30426879的博客
04-07 228
原创作品，可以转载，但是请标注出处地址：http://www.cnblogs.com/V1haoge/p/6675674.html 1 回顾 　　上一文中解读了MyBatis中非池型数据源的源码，非池型也就是只拥有单一数据连接的数据源，他只管理着一个数据连接，这种数据源现在很少使用，一般都是用池型数据源，因为单个连接的情况下，为了保证操作的正确性，针对这个连接的使用要进行同步，这样无疑会拖慢...
mybatis笔记.zip
04-13
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC ...通过阅读这份“mybatis笔记”，你可以更深入地了解如何使用 MyBatis 进行数据访问，提升你的开发效率。
mybatis笔记mybatis笔记mybatis笔记
11-06
MyBatis 是一个流行的Java持久层框架，它源自Apache的iBatis项目，后来在2010年迁移到Google Code，并在2013年进一步转移到GitHub。MyBatis的主要特点在于它允许开发者自定义SQL查询，支持存储过程，以及高级的映射...
myBatis连接超时问题
yeshengming2的博客
12-20 6039
mybatis 有时一段时间没有对数据库（sql server）进行操作，在对数据库操作时，会报错。
Mybatis jdbc连接超时解决
来吧 单刷各种经典
08-23 7478
这两天在测试Hive权限控制代码Hamza，发现每天来的时候第一次老是会报出以下错误： [html] view plain copy 2015-03-26 09:40:25.956 ERROR GroupPrivController,119 -    ### Error querying database.  Cause: org.apache
mybatils自学教程
逍遥绝情的博客
03-25 940
myBatis 什么是myBatis？ MyBatis是支持定制化SQL、存储过程以及高级映射的持久层框架 MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集 MyBatis 可以对配置和原生Map使用简单的 XML 或注解，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 安装 要使用 MyB
ibatis 源码阅读之PooledDataSource
11-05 520
        package org.apache.ibatis.datasource.pooled;   import org.apache.ibatis.datasource.unpooled.UnpooledDataSource; import org.apache.ibatis.logging.Log; import org.apache.ibatis.logging....
java中session源码_Java类org.apache.ibatis.session.Configuration的实例源码 - 编程字典
weixin_39715652的博客
02-27 678
private void settingsElement(XNode context) throws Exception {if (context != null) {Properties props = context.getChildrenAsProperties();// Check that all settings are known to the configuration class...
二、MyBatis体系结构源码解读
org_hjh的博客
07-05 165
1、MyBatis源码正确姿势 技术本质 从宏观到微观 (1) mybatis数据源的源码解析 xml(environment) > java Environment >org.apache.ibatis.session.SqlSessionFactoryBuilder.build(java.io.InputStream) >org.apache.ibati...
spring boot实现连接多数据源
hingli的博客
08-10 402
方法1 1.先配置各数据库的连接信息 在application.properties配置文件下，配置好driver、url、username、password等,配置名自定义，后面配置类获取对应的就好！ #数据库1 first.jdbc.dbType=mssql first.jdbc.driver=com.microsoft.sqlserver.jdbc.SQLServerDriver first.jdbc.url=jdbc:sqlserver://111.11.1.11:1433;databaseName
MyBatis3配置文件示例及解释
tobylxy的专栏
10-20 188
更详细说明请参阅官方MyBatis 3 User Guide 以下是示例及说明： [code="xml"] ...
老杜mybatis笔记
最新发布
05-29
很好，您想了解老杜的MyBatis笔记。老杜是一位非常资深的Java开发工程师，他在MyBatis方面有很深的研究和实践经验。他的MyBatis笔记主要包括以下内容： 1. MyBatis基础知识：包括MyBatis的架构、Mapper接口和XML...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值