Mybatis笔记

已于 2022-07-07 08:59:00 修改
阅读量584 收藏 1
点赞数 1
分类专栏： SSM 文章标签： database java
于 2022-06-01 23:48:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43372150/article/details/125092639
版权

1.1、简介

  • MyBatis 是一款优秀的持久层框架
  • 一个半 ORM（对象关系映射）框架
  • 它支持定制化 SQL、存储过程以及高级映射。
  • MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。

1.2、持久化

持久化就是将程序的数据在持久状态和瞬时状态转化的过程

1.3、为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？

ORM（Object Relational Mapping），对象关系映射，是一种为了解决关系型数据库数据与简单Java对象（POJO）的映射关系的技术。

Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。

Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具。

1.4、JDBC编程有哪些不足之处，MyBatis是如何解决这些问题的？

  1. 频繁创建、释放数据库连接对象，容易造成系统资源浪费，影响系统性能。可以使用连接池解决这个问题。
    解决：在mybatis-config.xml中配置数据库连接池，使用连接池管理数据库连接。

  2. Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。
    解决：将Sql语句配置在XXXXmapper.xml文件中，与java代码分离。

  3. 向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。
    解决：Mybatis自动将java对象映射至sql语句。

  4. 对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。
    解决：Mybatis自动将sql执行结果映射至java对象。

1.3、优点与缺点

优点

  • 传统的JDBC代码太复杂了，方便将数据存入到数据库中。
  • sql和代码的分离，提高了可维护性。
  • 提供映射标签，支持对象与数据库的orm字段关系映射

缺点

  • SQL语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写SQL语句的功底有一定要求

2.1、实例

1、Dao接口

public interface UserDao {
    List<User> getUserList();
}

2、接口实现类由原来的UserDaoImpl转变为一个 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">
        <!--namespace=绑定一个对应的Dao/Mapper接口-->
        <!-- namespace中的包名要和 Dao/mapper 接口的包名一致！--> 
<mapper namespace="com.kuang.dao.UserDao">
<!--select查询语句-->
		id : 就是对应的namespace中的方法名；
		resultType：Sql语句执行的返回值！
		parameterType ： 参数类型！
   <select id="getUserList" resultType="com.kuang.pojo.User">
       select * from mybatis.user
   </select>
</mapper>

2.2、万能Map

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

    <!--对象中的属性，可以直接取出来    传递map的key-->
    <insert id="addUser2" parameterType="map">
        insert into mybatis.user (id, pwd) values (#{userid},#{passWord});
    </insert>

    @Test
    public void addUser2(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

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


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

        map.put("userid",5);
        map.put("passWord","2222333");

        mapper.addUser2(map);

        sqlSession.close();
    }

2.3、模糊查询

  1. Java代码执行的时候，传递通配符 % %

    List<User> userList = mapper.getUserLike("%李%");

  2. 在sql拼接中使用通配符！

    select * from mybatis.user where name like "%"#{value}"%"

    注意：因为#{…}解析成sql语句时候，会在变量外侧自动加单引号’ '，所以这里 % 需要使用双引号" "，不能使用单引号 ’ '，不然会查不到任何结果。

  3. CONCAT(‘%’,#{question},‘%’) 使用CONCAT()函数，推荐

3、配置解析

3.1、映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件；
方式一： 【推荐使用】

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->
<mappers>
    <mapper resource="com/kuang/dao/UserMapper.xml"/>
</mappers>

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

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->
<mappers>
    <mapper class="com.kuang.dao.UserMapper"/>
</mappers>

注意点：

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

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

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->
<mappers>
    <package name="com.kuang.dao"/>
</mappers>

注意点：

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

3.2、生命周期和作用域

在这里插入图片描述
生命周期，和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题。
SqlSessionFactoryBuilder：

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

SqlSessionFactory：

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

SqlSession：

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

在这里插入图片描述

3.3、什么是MyBatis的接口绑定？有哪些实现方式？

接口绑定，就是在MyBatis中任意定义接口，然后把接口里面的方法和SQL语句绑定，我们直接调用接口方法就可以，这样比起原来了SqlSession提供的方法我们可以有更加灵活的选择和设置。
接口绑定有两种实现方式：

  • 通过注解绑定，就是在接口的方法上面加上 @Select、@Update等注解，里面包含Sql语句来绑定；
  • 通过xml里面写SQL来绑定， 在这种情况下，要指定xml映射文件里面的namespace必须为接口的全路径名。
  • 当Sql语句比较简单时候，用注解绑定， 当SQL语句比较复杂时候，用xml绑定，一般用xml绑定的比较多。

3.4、使用MyBatis的mapper接口调用时有哪些要求？

  1. Mapper.xml文件中的namespace即是mapper接口的类路径。
  2. Mapper接口方法名和mapper.xml中定义的每个sql的id相同。
  3. Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql 的parameterType的类型相同。
  4. Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同。

3.5、最佳实践中，通常一个Xml映射文件，都会写一个Dao接口与之对应，请问，这个Dao接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗

  • Dao接口，就是人们常说的Mapper接口；
  • 接口的全限定名（全限定名 = 包名 + 类型名），就是映射文件中的namespace的值；
  • 接口的方法名，就是映射文件中MappedStatement的id值；
  • 接口方法内的参数，就是传递给sql的参数。
  • Mapper接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为key值，可唯一定位一个MappedStatement

举例：

com.mybatis3.mappers.StudentDao.findStudentById，可以唯一找到namespace为com.mybatis3.mappers.StudentDao下面id = findStudentById的MappedStatement。
在Mybatis中，每一个、、、标签，都会被解析为一个MappedStatement对象。

Dao接口里的方法，是不能重载的，因为是全限定名+方法名的保存和寻找策略。

Dao接口的工作原理是JDK动态代理，Mybatis运行时会使用JDK动态代理为Dao接口生成代理proxy对象，代理对象proxy会拦截接口方法，转而执行MappedStatement所代表的sql，然后将sql执行结果返回。

## 3.6、Mybatis的Xml映射文件中，不同的Xml映射文件，id是否可以重复？

不同的Xml映射文件，如果配置了namespace，那么id可以重复；如果没有配置namespace，那么id不能重复；毕竟namespace不是必须的，只是最佳实践而已。

4、解决数据库属性名 和 实体类字段名 不一致的问题

4.1、起别名

通过在查询的SQL语句中定义字段名的别名，让字段名的别名和实体类的属性名一致。

<select id="getUserById" resultType="com.kuang.pojo.User">
    select id,name,pwd as password from mybatis.user where id = #{id}
</select>

4.2、resultMap

结果集映射

> id   name   pwd
> id   name   password

通过来映射字段名和实体类属性名的一一对应的关系。

<!--结果集映射-->
 <!--id：唯一即可，type：指定实体类-->
<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" resultMap="UserMap">
    select * from mybatis.user where id = #{id}
</select>

5、日志

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的助手！

5.1日志工厂

SLF4J
LOG4J 【掌握】
STDOUT_LOGGING 【掌握】

在mybatis核心配置文件中，配置我们的日志！

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

6、分页

6.1、使用Limit分页

语法：SELECT * from user limit startIndex,pageSize;
SELECT * from user limit 3;  #[0,n]

使用Mybatis实现分页，核心SQL

  1. 接口

    //分页
List<User> getUserByLimit(Map<String,Integer> map);

  2. Mapper.xml

    <!--//分页-->
<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
    select * from  mybatis.user limit #{startIndex},#{pageSize}
</select>

6.2、RowBounds分页

不再使用SQL实现分页

  1. 接口

    //分页2
List<User> getUserByRowBounds();

  2. mapper.xml

    <!--分页2-->
<select id="getUserByRowBounds" resultMap="UserMap">
    select * from  mybatis.user
</select>

  3. 测试

    @Test
public void getUserByRowBounds(){
SqlSession sqlSession = MybatisUtils.getSqlSession();

//RowBounds实现
RowBounds rowBounds = new RowBounds(1, 2);

//通过Java代码层面实现分页
List<User> userList = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds",null,rowBounds);

    for (User user : userList) {
    System.out.println(user);
    }

    sqlSession.close();
    }

6.3、分页插件（PageHelper）

7、使用注解开发

7.1注解开发

  1. 注解在接口上实现
@Select("select * from user")
List<User> getUsers();

  1. 需要再核心配置文件中绑定接口！

    <!--绑定接口-->
<mappers>
    <mapper class="com.kuang.dao.UserMapper"/>
</mappers>

底层：动态代理！
本质：反射机制实现

7.2 Mybatis详细的执行流程！

在这里插入图片描述
在这里插入图片描述

7.3、Mybatis工作原理

  1. 读取 MyBatis 配置文件
  2. 加载映射文件
  3. 构造会话工厂
  4. 创建会话对象
  5. Executor 执行器
  6. MappedStatement 对象
  7. 输入参数映射
  8. 输出结果映射

7.3、CRUD

我们可以在工具类创建的时候实现自动提交事务！

public static SqlSession  getSqlSession(){
    return sqlSessionFactory.openSession(true);
}

编写接口，增加注解

public interface UserMapper {

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

    // 方法存在多个参数，所有的参数前面必须加上 @Param("id")注解
    @Select("select * from user where id = #{id}")
    User getUserByID(@Param("id") int id);


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

    
    @Update("update user set name=#{name},pwd=#{password} where id = #{id}")
    int updateUser(User user);

    
    @Delete("delete from user where id = #{uid}")
    int deleteUser(@Param("uid") int id);
}

7.4、@MapperScan

作用：指定要变成实现类的接口所在的包，然后包下面的所有接口在编译之后都会生成相应的实现类
添加位置：是在Springboot启动类上面添加，另外，使用@MapperScan注解可以作用到多个包

@SpringBootApplication
@MapperScan("cn.mybatis.mappers")
public class SpringbootMybatisDemoApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(SpringbootMybatisDemoApplication.class, args);
    }
}

7.5、在mapper中如何传递多个参数

方法1：顺序传参法

public User selectUser(String name, int deptId);

<select id="selectUser" resultMap="UserResultMap">
    select * from user
    where user_name = #{0} and dept_id = #{1}
</select>

#{}里面的数字代表传入参数的顺序。

这种方法不建议使用，sql层表达不直观，且一旦顺序调整容易出错。

方法2：@Param注解传参法

public User selectUser(@Param("userName") String name, int @Param("deptId") deptId);

<select id="selectUser" resultMap="UserResultMap">
    select * from user
    where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是注解@Param括号里面修饰的名称。

这种方法在参数不多的情况还是比较直观的，推荐使用。

方法3：Map传参法

public User selectUser(Map<String, Object> params);

<select id="selectUser" parameterType="java.util.Map" resultMap="UserResultMap">
    select * from user
    where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是Map里面的key名称。

这种方法适合传递多个参数，且参数易变能灵活传递的情况。

方法4：Java Bean传参法

public User selectUser(User user);

<select id="selectUser" parameterType="com.jourwon.pojo.User" resultMap="UserResultMap">
    select * from user
    where user_name = #{userName} and dept_id = #{deptId}
</select>

#{}里面的名称对应的是User类里面的成员属性。

这种方法直观，需要建一个实体类，扩展不容易，需要加属性，但代码可读性强，业务逻辑处理方便，推荐使用。

7.6、 @Param

概述
首先明确这个注解是为SQL语句中参数赋值而服务的。

@Param的作用就是给参数命名，比如在mapper里面某方法A（int id），当添加注解后A（@Param(“userId”) int id），也就是说外部想要取出传入的id值，只需要取它的参数名userId就可以了。将参数值传如SQL语句中，通过#{userId}进行取值给SQL的参数赋值。

注意点

基本类型的参数或者String类型，需要加上
引用类型不需要加
如果只有一个基本类型的话，可以忽略，但是建议大家都加上！

当使用了@Param注解来声明参数的时候，SQL语句取值使用#{}，${}取值都可以。


当不使用@Param注解声明参数的时候，必须使用的是#{}来取参数。使用${}方式取值会报错。


不使用@Param注解时，参数只能有一个，并且是Javabean。在SQL语句里可以引用JavaBean的属性，而且只能引用JavaBean的属性。

7.6、Mybatis如何执行批量操作

使用foreach标签
foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach标签的属性主要有item，index，collection，open，separator，close。

  • item　　表示集合中每一个元素进行迭代时的别名，随便起的变量名；
  • index　　指定一个名字，用于表示在迭代过程中，每次迭代到的位置，不常用；
  • open　　表示该语句以什么开始，常用“(”；
  • separator表示在每次进行迭代之间以什么符号作为分隔符，常用“,”；
  • close　　表示以什么结束，常用“)”。

在使用foreach的时候最关键的也是最容易出错的就是collection属性，该属性是必须指定的，但是在不同情况下，该属性的值是不一样的，主要有一下3种情况：

  1. 如果传入的是单参数且参数类型是一个List的时候，collection属性值为list
  2. 如果传入的是单参数且参数类型是一个array数组的时候，collection的属性值为array
  3. 如果传入的参数是多个的时候，我们就需要把它们封装成一个Map了，当然单参数也可以封装成map，实际上如果你在传入参数的时候，在MyBatis里面也是会把它封装成一个Map的，map的key就是参数名，所以这个时候collection属性值就是传入的List或array对象在自己封装的map里面的key

具体用法如下：

<!-- 批量保存(foreach插入多条数据两种方法)
       int addEmpsBatch(@Param("emps") List<Employee> emps); -->
<!-- MySQL下批量保存，可以foreach遍历 mysql支持values(),(),()语法 --> //推荐使用
<insert id="addEmpsBatch">
    INSERT INTO emp(ename,gender,email,did)
    VALUES
    <foreach collection="emps" item="emp" separator=",">
        (#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
    </foreach>
</insert>

<!-- 这种方式需要数据库连接属性allowMutiQueries=true的支持
 如jdbc.url=jdbc:mysql://localhost:3306/mybatis?allowMultiQueries=true -->  
<insert id="addEmpsBatch">
    <foreach collection="emps" item="emp" separator=";">                                 
        INSERT INTO emp(ename,gender,email,did)
        VALUES(#{emp.eName},#{emp.gender},#{emp.email},#{emp.dept.id})
    </foreach>
</insert>

7.6、{} 与 ${} 的区别

  • #{}是占位符，预编译处理，可以防止SQL注入；像传进来的数据会加个" "（#将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号）
  • ${}是拼接符，字符串替换，没有预编译处理，不能防止SQL注入。这个方式一般用于传入数据库对象，例如传入表名.

使用 ${} 的话会导致 sql 注入。所以为了防止 SQL 注入，能用 #{} 的不要去用 ${}

7.7、如何获取生成的主键

对于支持主键自增的数据库（MySQL）

<insert id="insertUser" useGeneratedKeys="true" keyProperty="userId" >
    insert into user( 
    user_name, user_password, create_time) 
    values(#{userName}, #{userPassword} , #{createTime, jdbcType= TIMESTAMP})
</insert>
属性描述
keyPropertyselectKey 语句结果应该被设置的目标属性。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
keyColumn匹配属性的返回结果集中的列名称。如果希望得到多个生成的列，也可以是逗号分隔的属性名称列表。
resultType结果的类型，MyBatis 通常可以推算出来。MyBatis 允许任何简单类型用作主键的类型，包括字符串。如果希望作用于多个生成的列，则可以使用一个包含期望属性的 Object 或一个 Map。

8、动态 SQL

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

Mybatis动态sql可以让我们在Xml映射文件内，以标签的形式编写动态sql，完成逻辑判断和动态拼接sql的功能，Mybatis提供了9种动态sql标签trim|where|set|foreach|if|choose|when|otherwise|bind。

执行原理：使用OGNL从sql参数对象中计算表达式的值，根据表达式的值动态拼接sql，以此来完成动态sql的功能。

8.1、动态 SQL格式

8.1.1、IF

<select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from mybatis.blog where 1=1
    <if test="title != null">
        and title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</select>

8.1.2、choose (when, otherwise)

    <select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from mybatis.blog
        <where>
            <choose>
                <when test="title != null">
                    title = #{title}
                </when>
                <when test="author != null">
                    and author = #{author}
                </when>
                <otherwise>
                    and views = #{views}
                </otherwise>
            </choose>
        </where>
    </select>

8.1.3、trim (where,set)

select * from mybatis.blog
<where>
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</where> 

<update id="updateBlog" parameterType="map">
    update mybatis.blog
    <set>
        <if test="title != null">
            title = #{title},
        </if>
        <if test="author != null">
            author = #{author}
        </if>
    </set>
    where id = #{id}
</update>

if
where
set
choose
when

8.2、SQL片段

有的时候，我们可能会将一些功能的部分抽取出来，方便复用！

  • 使用SQL标签抽取公共的部分

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

  • 在需要使用的地方使用Include标签引用即可

    <select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from mybatis.blog
    <where>
        <include refid="if-title-author"></include>
    </where>
</select>

注意事项：

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

9、缓存 （了解）

9.1、简介

查询 ： 连接数据库 ，耗资源！
一次查询的结果，给他暂存在一个可以直接取到的地方！–> 内存 ： 缓存

我们再次查询相同数据的时候，直接走缓存，就不用走数据库了

什么是缓存？

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

为什么使用缓存？

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

什么样的数据能使用缓存？

  • 经常查询并且不经常改变的数据。【可以使用缓存】

9.2、Mybatis缓存

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

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

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

9.3、一级缓存

一级缓存也叫本地缓存： SqlSession

  • 与数据库同一次会话期间查询到的数据会放在本地缓存中。

  • 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；

缓存失效的情况：

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

总结：

  • 一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段！
  • 一级缓存就是一个Map

9.4、二级缓存

  • 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
  • 基于namespace级别的缓存，一个名称空间，对应一个二级缓存；
  • 工作机制：
    • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
    • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
    • 新的会话查询信息，就可以从二级缓存中获取内容；
    • 不同的mapper查出的数据会放在自己对应的缓存（map）中；

步骤：

  • 开启全局缓存

    <!--显示的开启全局缓存-->
<setting name="cacheEnabled" value="true"/>

  • 在要使用二级缓存的Mapper中开启

    <!--在当前Mapper.xml中使用二级缓存-->
<cache/>

    也可以自定义参数

    <!--在当前Mapper.xml中使用二级缓存-->
<cache  eviction="FIFO"
       flushInterval="60000"
       size="512"
       readOnly="true"/>

  • 测试
    出问题：我们需要将实体类序列化！否则就会报错！

    Caused by: java.io.NotSerializableException: com.kuang.pojo.User

总结：

  • 只要开启了二级缓存，在同一个Mapper下就有效
  • 所有的数据都会先放在一级缓存中；
  • 只有当会话提交，或者关闭的时候，才会提交到二级缓冲中！

9.5、缓存原理

在这里插入图片描述

为什么说 Mybatis 是半自动 ORM 映射工具？它与全自动的区别在哪里？
weixin_30883271的博客
05-08 1568
为什么说 Mybatis 是半自动 ORM 映射工具？它与全自动的区别在哪里？ Hibernate 属于全自动 ORM 映射工具，使用 Hibernate 查询关联对象或者关联集合对象 时，可以根据对象关系模型直接获取，所以它是全自动的。而 Mybatis 在查询关联对象或关联集合对象时，需要手动编写 sql 来完成，所以，称之为半自动 ORM 映射工具。Mybatis 是否支持延迟加...
Mybatis补充知识
youngbird1998的博客
11-05 1211
mybatis中的一些问题
MyBatis
小太阳
07-18 345
1、什么是MyBatis？ （1）MyBatis是一个半自动的ORM（对象关系映射）框架；他内部封装了JDBC，开发者只需要考虑SQL语句本身，不需要考虑驱动加载，创建连接，创建statement等过程； （2）MyBatis通过XML或注解来配置和映射原生信息，将POJO（Plain Ordinary Java Object，普通java对象）映射成数据库中的记录； （3）通过XML或注解...
Mybatis注解
最新发布
m0_63016075的博客
08-28 1017
MyBatis基础(2)
为什么说 Mybatis 是半自动 ORM 映射工具？它与全自动 的区别在哪里？
G_whang的博客
10-28 859
Xml 映射文件中，除了常见的 select|insert|updae|delete标签之外，还有哪些标签？ <resultMap>、<parameterMap>、<sql>、<include>、<selectKey>，加上动态 sql 的 9 个标签，其中<sql>为 sql 片段标签，通过<include>标签引入 sql 片段,<selectKey>为不支持自增的主键生成策略标签。 Mybatis 的 X
Mybatis——半自动化的ORM框架
weixin_46757133的博客
07-29 1048
Mybatis自己的知识梳理
mybatis笔记.zip
04-13
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC ...通过阅读这份“mybatis笔记”，你可以更深入地了解如何使用 MyBatis 进行数据访问，提升你的开发效率。
mybatis笔记
06-27
### MyBatis 笔记详解 #### 一、概述与概念 **MyBatis** 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用...
Mybatis-Plus快速入门|比Mybatis更简单好用的ORM框架
一一哥
09-23 1346
我们知道Mybatis属于一个半自动的ORM框架，之所以说Mybatis是一个半自动的ORM框架，原因是它还需要我们自己在注解或是映射文件中编写SQL语句，并没有实现完全的自动化。SQL语句的编写虽然增加了项目和业务需求实现的灵活性，但对一些基本表的操作而言，无疑增加了数据库操作的复杂度，显得没有那么方便。而Mybatis-Plus则是属于全自动的ORM框架，按照开闭原则，在不影响Mybatis现有功能的情况下，实现了对Mybatis的增强。今天要带大家来学习一下Mybatis-Plus框架。
简单名、全限定名、描述符、签名、符号引用、直接引用的不同
gg1229505432的博客
11-18 1511
1.简单名称（Simple Name） 没有类型和参数修饰的方法或字段名称 例如inc方法和字段name 2.全限定名（Fully Qualified Name） 一个类的全限定名是将类全名的.全部替换为/ 例如com/itheima/dao/IUserDao.xml 3.描述符（Descriptor） A descriptor is a string representing the type of a field or method. 4.签名（Signatures） Java代码层面的方法特征签
什么叫做java类的全限定名
weixin_36873225的博客
05-20 1万+
什么叫做java类的全限定名 所谓全限定名 = 包名 + 类型名 （Java）全限定类名和非限定类名的区别 全限定类名：就是类名全称，带包路径的用点隔开，例如: java.lang.String。 即全限定名 = 包名+类型，又如： 在这里插入图片描述 这里的 T 就是类名，即非限定类名，mybatis.T 就是全限定类名 非限定类名也叫短名，就是我们平时说的类名，不带包的，例如：String。 非限定类名是相对于限定类名来说的，在Java中有很多类，不同的类之间会存在相同的函数或者方法，所以有时候
myabtis中为什么说 MyBatis 是半自动 ORM 映射工具？它与全自动的区别在哪里
程序员朱永胜
01-07 408
全自动的ORM工具，如Hibernate，通常提供了一全套的解决方案，它能够完全自动地管理SQL语句以及对象关系映射，开发者只需要定义好实体类和关系，ORM工具就能自动进行CRUD操作。在某些情况下，全自动ORM会由于其“全自动”的特性导致生成的SQL语句不是最优的，而MyBatis允许开发者手动优化这些SQL语句，从而可能获得更好的性能。由于MyBatis比全自动ORM工具需要更多的SQL和配置输入，因此它的学习曲线可能会略显陡峭，特别是对于那些对SQL不太熟悉的开发者来说。
关于Mybatis里的mapper映射文件namespace属性及其他属性的知识总结
TDSSS的博客
05-29 3231
总结mybatis里的各个属性作用
ORM简介
qq_45533968的博客
03-25 8048
ORM简介ORM概念什么是“持久化”什么是持久层什么是ORMORM作用ORM的优劣处优点提高开发效率解耦合缺点减低程序性能 ORM概念 什么是“持久化” 即把数据（如内存中的对象）保存的磁盘的某一文件中。 什么是持久层 持久层（Persistence Layer）,即实现数据持久化应用领域的一个逻辑层面，将数据使用者和数据实体相关联。 什么是ORM ORM，即Object Relational Mapping，它是对象关系模型的简称。它的作用是在关系型数据库和对象之间作一个映射。使程序能够通过操纵描述对象方
myBatis ->半自动化的ORM 框架
萧十一郎博客
09-30 6081
1:myBatis ->半自动化的ORM 框架 前身 iBatimyBatis 灵活方便 轻量级的ORM 框架configuration 配置信息 environments 应用程序的环境 如果一个应用程序对应多个数据库就需要配置多个环境 environment 单个
MyBatis简介——半自动的持久化层框架（SQL映射框架）|| 支持定制化sql
qq_39368007的博客
03-18 1420
MyBatis简介 1、MyBatis；和数据库进行交互；持久化层框架（SQL映射框架）； 1）、从原始的JDBC-----dbutils(QueryRunner)-------JdbcTemplate----xxx；不用的 称为工具； 工具：一些功能的简单封装 框架：某个领域的整体解决方案； 缓存，考虑异...
【半ORM框架】MyBatis
IN THE ZONE
01-06 1284
MyBatis
（Java）全限定类名和非限定类名的区别
热门推荐
南淮北安的博客
04-26 1万+
全限定类名：就是类名全称，带包路径的用点隔开，例如: java.lang.String。 即全限定名 = 包名+类型，又如： 这里的 T 就是类名，即非限定类名，mybatis.T 就是全限定类名 非限定类名也叫短名，就是我们平时说的类名，不带包的，例如：String。 非限定类名是相对于限定类名来说的，在Java中有很多类，不同的类之间会存在相同的函数或者方法，所以有时候就需要限定类名来调包。...
老杜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、付费专栏及课程。

余额充值