MyBatis入门四

最新推荐文章于 2024-11-15 22:11:31 发布
最新推荐文章于 2024-11-15 22:11:31 发布
阅读量141 收藏
点赞数
分类专栏： Java框架 文章标签： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pine_e3/article/details/108268388
版权

文章目录

1 MyBatis 延迟加载迟略

延迟加载：需要用到数据时才进行加载，不需要数据时就不加载。延迟加载也称懒加载。优点：先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。缺点：只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。

1.1 使用 association 实现一对一延迟加载

​ 查询账户(Account)信息并且关联查询用户(User)信息。当我们需要查询用户(User)信息时再查询用户(User)信息。把对用户(User)信息的按需去查询就是延迟加载。

1.1.1 账户的持久层DAO接口

//在Account里添加User属性
public interface IAccountDao {
    List<Account> findAllAccountUser();
}

1.1.2 账户的持久层映射配置

<resultMap id="accountMap" type="cn.pine.domain.Account">
    <id column="id" property="id"/>
    <result column="uid" property="uid"/>
    <result column="money" property="money"/>
    <association property="user" javaType="cn.pine.domain.User"
                 select="cn.pine.dao.IUserDao.findById"
                 column="uid">
    </association>
</resultMap>
<select id="findAllAccountUser" resultMap="accountMap">
    SELECT * FROM account
</select>

1.1.3 在 SqlMapConfig.xml 中开启延迟加载策略

<settings>
    <!--注意标签顺序，在typeAliases前-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading"value="false"></setting>
</settings>

1.1.4 测试

@Test
public void testFindAllAccountUser(){
    List<Account> allAccountUser = accountDao.findAllAccountUser();
}

由于只查询 Account 对象并没有取User对象，所以返回的结果中没有发出关联查询的语句

DEBUG IAccountDao.findAllAccountUser  - ==>  Preparing: SELECT * FROM account 
IAccountDao.findAllAccountUser  - ==> Parameters: 
IAccountDao.findAllAccountUser  - <==      Total: 3

在测试中取 User 对象时，返回结果便发出关联查询。

DEBUG IAccountDao.findAllAccountUser  - ==>  Preparing: SELECT * FROM account 
DEBUG IAccountDao.findAllAccountUser  - ==> Parameters: 
DEBUG IAccountDao.findAllAccountUser  - <==      Total: 3
DEBUG  cn.pine.dao.IUserDao.findById  - ==>  Preparing: SELECT * FROM USER WHERE id = ? 
DEBUG  cn.pine.dao.IUserDao.findById  - ==> Parameters: 46(Integer)
DEBUG  cn.pine.dao.IUserDao.findById  - <==      Total: 1
User{id=46, username='赵六', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='杭州'}
DEBUG  cn.pine.dao.IUserDao.findById  - ==>  Preparing: SELECT * FROM USER WHERE id = ? 
DEBUG  cn.pine.dao.IUserDao.findById  - ==> Parameters: 45(Integer)
DEBUG  cn.pine.dao.IUserDao.findById  - <==      Total: 1
User{id=45, username='李四', birthday=Sun Mar 04 12:04:06 CST 2018, sex='男', address='深圳'}
User{id=46, username='赵六', birthday=Wed Mar 07 17:37:26 CST 2018, sex='男', address='杭州'}

1.2 使用 Collection 实现一对多延迟加载

查询用户(User)信息并且关联查询账户(Account)信息。

1.2.1 在 User 中加入List<Account>属性

public class User implements Serializable {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
    private List<Account> accounts;
｝

1.2.2 用户和账户持久层接口的方法

List<User> lazyFindAllUserAccount();
List<Account> findByUid(Integer uid);

1.2.3 用户持久层映射配置

<resultMap id="lazyUserMap" type="user">
    <id column="id" property="id"/>
    <result column="username" property="username"/>
    <result column="address" property="address"/>
    <result column="sex" property="sex"/>
    <result column="birthday" property="birthday"/>
    <collection property="acccounts" ofType="cn.pine.domain.Account"
                select="cn.pine.dao.IAccountDao.findById"
                column="id">
    </collection>
</resultMap>
<select id="lazyFindAllUserAccount" resultMap="lazyUserMap">
    SELECT * FROM user
</select>

1.2.4 账户持久层映射配置

<select id="findById" resultType="cn.pine.domain.Account" parameterType="int">
    SELECT * FROM account WHERE uid = #{uid}
</select>

测试

不取 User 中的 Account 集合时，返回结果中不发送关联查询

@Test
public void testLazyFindAllUserAccount(){
    List<User> users = userDao.lazyFindAllUserAccount();
}

DEBUG UserDao.lazyFindAllUserAccount-=Preparing: SELECT* FROM user
DEBUG UserDao.lazyFindAllUserAccount -=> Parameters:
DEBUG UserDao.lazyFindAllUserAccount -<== Total: 6

2 MyBatis 缓存

​ MyBatis 通过缓存策略减少数据库的查询次数，提高性能，其中分为一级缓存与二级缓存。

2.1 一级缓存

​ 一级缓存是SqlSession范围的缓存，当调用SqlSession的修改，添加，删除，commit()，close()方法时，清空一级缓存。

设置useCache为true

<?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="cn.pine.dao.IUserDao">
    <select id="findById" resultType="user" parameterType="int" useCache="true">
        SELECT * FROM USER WHERE id = #{id}
    </select>
</mapper>

2.1.2 测试

@Test
public void testFindByID(){
    User user1 = userDao.findById(41);
    System.out.println("第一次查询：" + user1);
    User user2 = userDao.findById(41);
    System.out.println("第一次查询：" + user2);
    System.out.println(user1==user2);
}

这里查询两次，但是返回结果只发出一次查询，并且两次查询结果，地址值相同。由此可见缓存存在。

第一次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 41 的用户信息，如果没有，从数据库查询用户信息。

得到用户信息，将用户信息存储到一级缓存中。如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

第二次发起查询用户 id 为 1 的用户信息，先去找缓存中是否有 id 为 41 的用户信息，缓存中有，直接从缓存中获取用户信息。

-==> Preparing: SELECT*FROM USER WHERE id = ?
-> Parameters: 41(Integer)
-<== Total: 1
第一次查询：cn.pine.domain.User@4fcd19b3
第一次查询：cn.pine.domain.User@4fcd19b3
true

2.2 二级缓存

二级缓存是 mapper 映射级别的缓存，多个SqlSession 去操作同一个 Mapper 映射的SQL 语句，多个SqlSession 可以共用二级缓存，二级缓存是跨SqlSession的。

首先开启二级缓存。

SqlSession1去查询用户信息，查询到用户信息会将查询数据存储到二级缓存中。

SqlSession2去查询与SqlSession1相同的用户信息，首先会去缓存中找是否存在数据，如果存在直接从缓存中取出数据

如果SqlSession3去执行相同 mapper 映射下SQL，执行commit提交，将会清空该mapper映射下的二级缓存区域的数据。

2.2.1 SqlMapConfig.xml 开启二级缓存

<settings>
	<!-- 开启二级缓存，默认开启 -->
    <setting name="cacheEnabled" value="true"/>
</settings>

2.2.2 配置相关 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="cn.pine.dao.IUserDao">
    <!-- 开启二级缓存的支持 -->
    <cache></cache>
    <select id="findById" resultType="user" parameterType="int" useCache="true">
        SELECT * FROM USER WHERE id = #{id}
    </select>
</mapper>

2.2.3 测试

在执行第一次查询后关闭`SqlSession

public class MybatisTest {

    private InputStream in;
    private SqlSessionFactory factory;

    @Before
    public void init() throws Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);

    }

    @After
    public void destroy() throws Exception{
        in.close();
    }

    @Test
    public void testFindByID(){
        SqlSession session1 = factory.openSession();
        SqlSession session2 = factory.openSession();
        IUserDao dao1 = session1.getMapper(IUserDao.class);
        IUserDao dao2 = session2.getMapper(IUserDao.class);
        User user1 = dao1.findById(41);
        System.out.println(user1);
        session1.close();
        User user2 = dao2.findById(41);
        System.out.println(user2);
        session2.close();
        System.out.println(user1 == user2);
    }
}


- ==> Preparing:SELECT* FROM USER WHERE id = ?
- ==> Parameters: 41(Integer)
- <== Total: 1

3 MyBatis 注解

3.1 常用注解

@Insert:实现新增
@Update:实现更新
@Delete:实现删除
@Select:实现查询
@Result:实现结果集封装
@Results:可以与 @Result 一起使用，封装多个结果集
@ResultMap:实现引用 @Results 定义的封装
@One:实现一对一结果集封装
@Many:实现一对多结果集封装
@SelectProvider:实现动态 SQL 映射
@CacheNamespace:实现注解二级缓存的使用

3.2 使用注解实现 CRUD 操作

3.2.1 实体类

public class User implements Serializable {
	//与数据库列名不一致，省略getter,setter,toString
    private Integer userId;
    private String userName;
    private Date userBirthday;
    private String userSex;
    private String userAddress;
}

3.2.2 注解方式开发持久层接口

public interface IUserDao {

    @Select("select * from user")
    @Results(id = "userMap",
                value = {
                        @Result(id=true, column = "id",property = "userId"),
                        @Result(column="username",property="userName"),
                        @Result(column="sex",property="userSex"),
                        @Result(column="address",property="userAddress"),
                        @Result(column="birthday",property="userBirthday")
                })
    List<User> findAll();

    @Select("select * from user where id = #{uid}")
    @ResultMap("userMap")
    User findById(Integer userId);

    @Insert("insert into user(username,sex,birthday,address) values (#{userName},#{userSex},#{userBirthday},#{userAddress})")
    @SelectKey(keyColumn = "id",keyProperty = "userId", resultType = Integer.class, before = false, statement = {"select last_insert_id()"})
    int saveUser(User user);

    @Update("update user set username=#{userName},address=#{userAddress},sex=#{userSex},birthday=#{userBirthday} where id =#{userId} ")
    int updateUser(User user);

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

    @Select("select count(*) from user")
    int findTotal();

    @Select("select * from user where username like #{username}")
    List<User> findByName(String name);
}

3.2.3 测试代码

public class MybatisTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IUserDao userDao;

    @Before
    public void init()throws Exception{
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        session = factory.openSession();
        userDao = session.getMapper(IUserDao.class);
    }
    @After
    public void destroy()throws Exception {
        session.commit();
        session.close();
        in.close();
    }

    @Test
    public void testFindAll(){
        List<User> users = userDao.findAll();
        for (User user : users) {
            System.out.println(user);
        }
    }

    @Test
    public void testSave(){
        User user = new User();
        user.setUserName("Test_Save");
        user.setUserSex("男");
        user.setUserAddress("哈尔滨");
        user.setUserBirthday(new Date());

        int res = userDao.saveUser(user);
        System.out.println("数据库影响行数---" + res);
        System.out.println("插入的主键值---" + user.getUserId());
    }
    @Test
    public void testUpdate() {
        User user = userDao.findById(48);
        user.setUserBirthday(new Date());
        user.setUserSex("男");
        int res = userDao.updateUser(user);
        System.out.println(res);
    }

    @Test
    public void testDelete() {
        int res = userDao.deleteUser(51);
        System.out.println(res);
    }

    @Test
    public void testFindTotal(){
        int res = userDao.findTotal();
        System.out.println(res);
    }

    @Test
    public void testFindByName() {
        List<User> users = userDao.findByName("%四%");
        for(User user : users) {
            System.out.println(user);
        } 
    }
}

3.3 使用注解实现复杂关系映射开发

@Results 注解
代替的是标签<resultMap>
该注解中可以使用单个@Result 注解，也可以使用@Result 集合
@Results（{@Result（），@Result（）}）或@Results（@Result（））

@Result 注解
代替了 <id>标签和<result>标签
@Result 属性
id 是否是主键字段
column 数据库的列名
property 需要装配的属性名
one 需要使用的@One 注解（@Result（one=@One）（）））
many 需要使用的@Many 注解（@Result（many=@many）（）））

@One 注解（一对一）
代替了<assocation>标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。
@One 注解属性介绍：
select 指定用来多表查询的 sqlmapper
fetchType 会覆盖全局的配置参数 lazyLoadingEnabled。。
使用格式：
@Result(column=" ",property="",one=@One(select=""))

@Many 注解（多对一）
代替了<Collection>标签,是是多表查询的关键，在注解中用来指定子查询返回对象集合。
注意：聚集元素用来处理“一对多”的关系。需要指定映射的 Java 实体类的属性，属性的 javaType
（一般为 ArrayList）但是注解中可以不定义；
使用格式：
@Result(property="",column="",many=@Many(select=""))

3.3.1 使用注解实现一对一复杂关系映射和延迟加载

​ 加载账户信息延迟加载用户信息。

3.3.2.1 Account 实体类

​ Account 类中添加 User 属性

public class Account implements Serializable {
    private Integer id;
    private Integer uid;
    private Double money;
    private User user;
}
3.3.2.2 账户的持久层接口使用注解配置
public interface IAccountDao {

    @Select("select * from account")
    @Results(id="acountMap", value={
            @Result(id = true,column = "id",property = "id"),
            @Result(column="uid",property="uid"),
            @Result(column="money",property="money"),
            @Result(column="uid",
                    property="user",
                    one=@One(select="cn.pine.dao.IUserDao.findById",
                            fetchType= FetchType.LAZY))
    })
    List<Account> findAll();
}
3.3.2.3 测试
@Test
public void testFindAll(){
    List<Account> accounts =  accountDao.findAll();
    /* 开启注释，只发送3次查询语句 
       关闭后，多发两次查询
    for (Account account : accounts) {
        System.out.println(account);
        System.out.println(account.getUser());
    }
    */
}

3.3.2 使用注解实现一对多复杂关系映射和延迟加载

​ 加载用户信息，延迟加载账户信息。

3.3.2.1 User 类加入List<Account>
public class User implements Serializable {

    private Integer userId;
    private String userName;
    private Date userBirthday;
    private String userSex;
    private String userAddress;
    private List<Account> accounts;
}
3.3.2.2 注解配置用户持久层
public interface IUserDao {

    @Select("select * from user")
    @Results(id = "userMap",
                value = {
                        @Result(id=true, column = "id",property = "userId"),
                        @Result(column="username",property="userName"),
                        @Result(column="sex",property="userSex"),
                        @Result(column="address",property="userAddress"),
                        @Result(column="birthday",property="userBirthday"),
                        @Result(column = "id",property = "accounts",
                            many = @Many(
                                    select = "cn.pine.dao.IAccountDao.findByUid",
                                    fetchType = FetchType.LAZY
                            ))
                })
    List<User> findAll();
}
3.3.2.3 注解配置账户持久层
public interface IAccountDao {
    
    @Select("select * from account where uid = #{uid}")
    List<Account> findByUid(Integer userId);
}
3.3.2.4 测试
@Test
public void testFindAll(){
    List<User> users = userDao.findAll();
   /* for (User user : users) {
        System.out.println("----每个用户的信息-----");
        System.out.println(user);
        System.out.println(user.getAccounts());
    }*/
}

3.4 基于注解的二级缓存

3.4.1 SqlMapConfig.xml 开启二级缓存支持

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

3.4.2 持久层接口使用注解配置耳机缓存

@CacheNamespace
public interface IUserDao {}
MyBatis入门配置
qq_53317005的博客
03-21 2476
Mybatis映射文件详解
MyBatis 入门教程详解
不迁怒，不贰过。小知识，大智慧。
02-09 1785
MyBatis 入门教程详解
一步一步搭建Mybatis开发环境，实现CRUD增删改查操作
shang_0122的博客
05-25 3811
从零搭建Mybatis开发环境，一步一步实现CRUD操作，助你更好使用Mybatis
mybatis动态SQL
Hello_MAOSONG的博客
05-17 222
条件查询if标签 IUserDao /** * 根据传入参数条件查询 * @return 查询条件：可能有用户名，有可能有性别，也有可能有地址，还有可能是都有 */ List<User> findUserByCondition(User user); IUserDao.xml <select id="findUserByCon...
Mybatis入门
2301_80425226的博客
07-27 1064
Mybatis中文网官方介绍：Mybatis 是一款优秀的持久层框架，它支持自定义SQL，存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码，以及设置参数和获取结果集的工作。MyBatis可以通过简单的XML或注解来配置和映射原始类型。接口和 java POJO（Plain Old Java Objects，普通老式Java对象）为数据库中的记录。简单理解：MyBatis是Apache的一个Java开源项目，是一个支持动态SQL语句的持久层框架。
Mybatis快速入门
m0_62036548的博客
06-12 1021
Mybatis快速入门
Mybatis入门案例【超详细】
qq_53317005的博客
03-23 2453
Mybatis入门案例，对数据库进行增删查改的操作
Mybatis （入门程序）
weixin_68576312的博客
10-11 663
在pom.xml文件中依赖org.springframework.boot、org.mybatis.spring.boot的版本分别修改为：2.7.5、2.2.2修改以及的版本改为自己java版本。注意：2023年版本的idea这里java的版本最低是17，若你JDK版本不是17，可以将java的版本调到最高兼容，后面在设置和里面进行调配。二：在实体类中创建上面Mysql中User表以每个字段为一个属性，并生成对应的set/get/无参、全参构造/toString方法。
Mybatis的入门
m0_58375976的博客
06-30 801
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录...
MyBatis入门教程（入门看这一篇就够了）
m0_75210816的博客
06-05 1738
MyBatis是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。MyBatis的运行原理晦涩难懂，我的建议是要学会用，运行原理尽量理解就行。如果在读取的过程中发现错误，欢迎在评论区讨论。
MyBatis入门.pdf
09-24
MyBatis入门 MyBatis是一个优秀的持久层框架，使用XML将SQL与程序解耦，便于维护。MyBatis学习简单，执行高效，是JDBC的延伸。MyBatis提供了数据库增删改查的便捷操作，极大提高了开发效率、统一的编码规则、利于...
MyBatis入门到精通
02-28
这篇“MyBatis入门到精通”的学习资料是针对初学者设计的，旨在帮助新手快速掌握MyBatis的基本用法和高级特性。 1. **MyBatis简介** MyBatis是由Clinton Begin创建的开源项目，它是一个基于Java的持久层框架，消除...
Mybatis入门到精通
06-08
Mybatis介绍、单独使用jdbc编程问题总结、Mybatis架构、Mybatis入门程序、Mybatis开发Dao、SqlMapConfig.xml配置、ParameterType输入映射、ResultType及ResultMap输出映射、动态sql、商品订单数据模型、关联查询（一...
mybatis入门程序
09-16
【标题】"mybatis入门程序"是一个针对初学者的教程，旨在引导他们进入SSM（Spring、SpringMVC和MyBatis）框架的学习。MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射，极大地简化了Java开发...
0772-Mybatis入门
12-24
Mybatis入门
redhat 7.6 oracle 19c 单机离线安装（文末附安装的虚拟机，可以直接运行）
hf191850699的专栏
11-11 711
Oracle 19c离线单机的安装，包括补丁，后期的配置和维护等常用命令记录，文末有实验的虚拟机，下载就可以打开。
MySQL 8.0特性-自增变量的持久化
myneth的博客
11-13 398
在MySQL 8.0之前，自增主键AUTO_INCREMENT的值如果大于max(primary key)+1，在MySQL重启后，会重置AUTO_INCREMENT=max(primary key)+1，这种现象在某些情况下会导致业务主键冲突或者其他难以发现的问题。下面通过案例来对比不同的版本中自增变量是否持久化。
Mybatis
庸不易的博客
11-15 394
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
Qt 的 QThread：多线程编程的基础
最新发布
Z1tai的博客
11-15 478
是 Qt 框架中实现多线程的基础类，它允许开发者创建新的线程，并在其中执行任务。当线程执行任务时，可能会出现阻塞，尤其是在进行 I/O 操作或等待外部资源时。在 Qt 中，线程间的通信通过信号与槽机制来实现。通过信号，子线程可以将数据或事件传递给主线程，或者主线程可以通知子线程执行某些操作。对象代表一个线程，线程之间的独立执行有助于分担主线程的压力，避免主界面的阻塞。Qt 中的多线程模型基于事件驱动机制，因此线程的管理通常通过事件循环来进行，方法会在新线程中执行，因此你可以将具体的工作逻辑放在该方法中。
MyBatis入门教程：配置与SqlSessionFactory详解
"这篇文档是关于MyBatis入门教程的第二部分，主要涵盖MyBatis的基本概念、所需jar包的引入、以及如何从XML配置文件创建SqlSessionFactory。文档旨在为初学者提供参考和实践价值。" MyBatis是一个流行的Java持久层...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值