14.MyBatis中使用注解实现一对多以及多对多（注解的一级缓存二级缓存）

最新推荐文章于 2024-07-23 15:38:42 发布
最新推荐文章于 2024-07-23 15:38:42 发布
阅读量217 收藏
点赞数
分类专栏： mybatis学习 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/actores/article/details/110294293
版权

1.结构图

2.实体类User(解决属性名和数据库字段名不匹配)

package com.itheima.pojo;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable {
    private Integer Id;
    private String userName;
    private String Sex;
    private String addRess;
    private Date birThday;

    /*一个用户有多个账户:一对多*/
    private List<Account> accounts;
    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    public Integer getId() {
        return Id;
    }

    public void setId(Integer id) {
        Id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getSex() {
        return Sex;
    }

    public void setSex(String sex) {
        Sex = sex;
    }

    public String getAddRess() {
        return addRess;
    }

    public void setAddRess(String addRess) {
        this.addRess = addRess;
    }

    public Date getBirThday() {
        return birThday;
    }

    public void setBirThday(Date birThday) {
        this.birThday = birThday;
    }

    @Override
    public String toString() {
        return "User{" +
                "Id=" + Id +
                ", userName='" + userName + '\'' +
                ", Sex='" + Sex + '\'' +
                ", addRess='" + addRess + '\'' +
                ", birThday=" + birThday +
                '}';
    }
}

3.实体类Account

package com.itheima.pojo;

import java.io.Serializable;

public class Account implements Serializable {
    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 +
                '}';
    }
}

4.实体类接口IUserDao

package com.itheima.dao;

import com.itheima.pojo.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

//开启二级缓存
@CacheNamespace(blocking = true)
public interface IUserDao {
    //查询所有
    //id就是让其他的来一起使用：唯一标识
    @Select(value = "select * from user")
    @Results(id = "userMap",value = {
            @Result(id = true,column = "id",property = "Id"),
            @Result(column = "username",property = "userName"),
            @Result(column = "sex",property = "Sex"),
            @Result(column = "address",property = "addRess"),
            @Result(column = "birthday",property = "birThday"),
            @Result(property = "accounts",column = "id" ,
                    many = @Many(select = "com.itheima.dao.IAccountDao.findAccountByUid",
                            fetchType= FetchType.LAZY))
    })
    List<User> findUser();

    //查询根据id
    @Select("select * from user where id = #{id}")
    //@ResultMap("userMap")//可以使用多个map，这里是只有一个
    @ResultMap(value = {"userMap"})//标准写法
    User findById(Integer id);


    //模糊查询
    @Select("select * from user where username like #{username}")
    @ResultMap(value = {"userMap"})//标准写法
    List<User> findByName(String username);


}

5.实体类接口AccountDao

package com.itheima.dao;

import com.itheima.pojo.Account;
import com.itheima.pojo.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;

import java.util.List;

public interface IAccountDao {
    //查询所有
    /*查询所有账户，并且获取每个账户所属的用户信息*/
    @Select("select * from account")
    @Results(id = "accountMap",value = {
            @Result(id = true,column = "id",property = "id"),
            @Result(column = "uid",property = "uid"),
            @Result(column = "money",property = "money"),
            @Result(property = "user",column = "uid",one = @One(select="com.itheima.dao.IUserDao.findById",fetchType = FetchType.EAGER))
        }
    )
    List<Account> findAll();

    /*
    * 根据用户id查询账户信息
    * */
    @Select("select * from account where uid = #{Id}")
    List<Account> findAccountByUid(Integer userId);
}

6.外部数据库jdbcConfig.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_mybatis
jdbc.username=root
jdbc.password=123456

7.主配置文件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>
    <!--p配置外部数据库-->
    <properties resource="jdbcConfig.properties"></properties>
    <!--配置开启二级缓存-->
    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>
    
    <!--配置别名-->
    <typeAliases>
        <!--自定义别名 实体类所在位置-->
        <package name="com.itheima.pojo"/>
    </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="com.itheima.dao"/>
    </mappers>
</configuration>

8.测试类TestAccountCRUD（测试一对多）

package com.itheima;

import com.itheima.dao.IAccountDao;
import com.itheima.dao.IUserDao;
import com.itheima.pojo.Account;
import com.itheima.pojo.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class TestAccountCRUD {
    private  InputStream in;
    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private IAccountDao accountDao;
    //初始化
    @Before
    public void init() throws Exception {
        //1.获取字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.根据字节输入流构建SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(in);
        //3.根据SqlSessionFactory生产一个SqlSession
        sqlSession = factory.openSession();
        //4.使用SqlSession获取Dao的代理对象
        accountDao = sqlSession.getMapper(IAccountDao.class);
    }
    @After
    public void destroy() throws Exception{
        //6.释放资源..
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    //查询所有 一对多的测试
    @Test
    public void testFindAll(){
        List<Account> accounts = accountDao.findAll();
        for (Account account:accounts){
            System.out.println("-----查询账户信息下的用户信息-----");
            System.out.println(account);
            System.out.println(account.getUser());
        }
    }

}

9.测试类TestCRUD（多对多）

package com.itheima;

import com.itheima.dao.IUserDao;
import com.itheima.pojo.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class TestCRUD {
    private  InputStream in;
    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private IUserDao userDao;
    //初始化
    @Before
    public void init() throws Exception {
        //1.获取字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.根据字节输入流构建SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(in);
        //3.根据SqlSessionFactory生产一个SqlSession
        sqlSession = factory.openSession();
        //4.使用SqlSession获取Dao的代理对象
        userDao = sqlSession.getMapper(IUserDao.class);
    }
    @After
    public void destroy() throws Exception{
        //6.释放资源..
        sqlSession.commit();
        sqlSession.close();
        in.close();
    }
    //查询所有
    @Test
    public void testFindAll(){
        /*查询用户下的账户信息*/
        List<User> users = userDao.findUser();
        for (User user:users){
            System.out.println("查询用户信息--------------");
            System.out.println(user);
            System.out.println(user.getAccounts());
        }
    }

    //查询一个
    @Test
    public void testFindOne(){
        User user = userDao.findById(8);
        System.out.println("查询成功---"+user);
    }
    //模糊查询
    @Test
    public void testFindName(){
        /*多条数据用list*/
        List<User> users = userDao.findByName("%王%");
        for (User user:users){
            System.out.println("模糊查询成功---"+user);
        }
    }

}

10.测试类（一级缓存和二级缓存）

package com.itheima;

import com.itheima.dao.IUserDao;
import com.itheima.pojo.User;
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 org.junit.After;
import org.junit.Before;
import org.junit.Test;

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

public class TestSecondLevelCache {
    private  InputStream in;
    private SqlSessionFactory factory;
    //初始化
    @Before
    public void init() throws Exception {
        //1.获取字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2.根据字节输入流构建SqlSessionFactory
        factory = new SqlSessionFactoryBuilder().build(in);
    }
    @After
    public void destroy() throws Exception{
        //6.释放资源
        in.close();
    }
    //查询一个
    @Test
    public void testFindOne(){
        SqlSession session1 = factory.openSession();
        IUserDao userDao1 = session1.getMapper(IUserDao.class);
        User user1 = userDao1.findById(7);
        System.out.println(user1);
        session1.close();//释放一级缓存

        SqlSession session2 = factory.openSession();
        IUserDao userDao2 = session2.getMapper(IUserDao.class);
        User user2 = userDao2.findById(7);
        System.out.println(user2);
        session2.close();//使用二级缓存
    }
}

11.依赖pom.xml

<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.40</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

总结：各有各的好处：注解和配置文件都差不多，用熟悉一种最好（加油小伙伴）

 

 

小周日记
关注
专栏目录
mybatis的一对多映射collection
林高禄
10-28 3665
简单映射（一对一） 一对多映射 方式1：按照查询嵌套处理 方式2：按照结果嵌套处理 简单映射（一对一） mybatis结果集映射ResultMap 一对多映射 我们有2个类，一个班级类ClassRoom，一个学生类Student 班级类代码如下 package com.lingaolu.pojo; /** * @author 林高禄 * @create 2020-10-26-20:17 */ public class ClassRoom { p.
mybatis查询缓存之一级缓存和二级缓存详细解析
热门推荐
eleven的博客
07-21 1万+
一：本文将涉及到的如下几方面的知识点 mybatis基本增删改查 Java序列化和反序列化 JDBC和sqlsession基本理论 spring事务管理 二：mybatis查询缓存基本介绍 缓存：将相同查询条件的sql语句执行一遍后所得到的结果存在内存或者某种缓存介质当中，当下次遇到一模一样的查询sql时候不在执行sql与数据库交互，而是直接从缓存中获取结果，减少服务器的压力； myb...
mybatis一级缓存二级缓存
生命不息，奋斗不止
11-06 258
mybatis一级缓存二级缓存 mybatis缓存概述 mybatis一级缓存 mybatis二级缓存 mybatis缓存概述CacheKey: hashcode(哈希值)，checksum，namespace+id(namespace为mapper文件的命名空间，id为sql的id)，.sql(查询sql), parameter（查询sql的参数）; 以上字段，用于从缓存中查询值的
Mybatis缓存机制详解(一级缓存+二级缓存)
weixin_44284160的博客
10-25 1192
什么是一级缓存 MyBatis 包含了一个非常强大的 查询缓存特性,它可以非常方便地配置和定制。MyBatis 3 中的缓存实现的很多改进都已经实现了，使得它更加强大而且易于配置。mybatis 默认情况下只会开启一级缓存，也就是局部的 session 会话缓存。 首先我们要知道什么是查询缓存？查询缓存又有什么作用？ 功能：mybatis提供查询缓存，用于减轻数据压力，提高数据库性能。 如下图，每一个 session 会话都会有各自的缓存，这缓存是局部的，也就是所谓的一级缓存： 什么情况下会命中一级
mybatis中的缓存（一级缓存、二级缓存）
最新发布
m0_62943934的博客
07-23 6472
在计算机的世界中，缓存无处不在，重要性不言而喻。作为一款优秀的ORM框架，MyBatis中又岂能少得了缓存，本博客基于mybatis 3.5.11版本，全面介绍mybatis一级缓存、二级缓存以及自定义缓存的使用方法、实现原理、应用场景、优缺点等，并进行验证，带你彻底掌握MyBatis缓存。
Mybatis如何通过注解开启使用二级缓存
08-25
"Mybatis 中通过注解开启使用二级缓存" Mybatis 是一个基于 Java 的持久层框架，它提供了一个简单易用的方式来访问数据库。二级缓存是 Mybatis 中的一种缓存机制，它可以将查询结果缓存起来，减少数据库的访问次数...
mybatis plus使用redis作为二级缓存的方法
08-25
使用 MyBatis Plus 的二级缓存非常简单，只需要在 Mapper 接口中添加 `@CacheNamespace` 注解，指定缓存的命名空间。例如： ```java @Mapper public interface UserMapper { @CacheNamespace(ref = "userCache") ...
Mybatis-plus基于redis实现二级缓存过程解析
08-18
在本文中，我们将介绍如何使用Mybatis-plus基于Redis实现二级缓存过程解析。 首先，我们需要在application.properties或application.yml文件中配置Redis连接信息： ```properties redis: host: 39.104.203.155 ...
Mybatis注解与 延时加载(懒加载) 二级缓存注解配置
01-06
注解： ...9.@CacheNamespace(blocking = true)：开启二级缓存 环境： 无映射文件 示例一 CRUD操作 示例 二 多对一 延时加载（懒加载） 根据id查询员工及其员工的部门信息 1.1 User类结构 2.注解配置
深入了解MyBatis二级缓存共6页.pdf.zip
10-31
MyBatis作为一款流行的Java持久层框架，以其灵活的SQL映射和优秀的性能深受开发者喜爱。...然而，正确使用二级缓存需要对缓存策略、并发控制以及MyBatis框架有深入理解，这也是每一个高级MyBatis开发者必备的技能。
使用注解的一对多和多对多
11-14
hib1_使用注解的一对多和多对多的源码包
MyBatis注解配置映射器：一对多关系的实现
08-22
java工程，练习通过MyBatis注解的方式配置SQL映射器，实现一对多关系.
MyBati-xmlMyBatis增删改查&注解MyBatis增删改查&MyBatis一级缓存和二级缓存
小咖成长之路
08-21 348
MyBatis(第3天)xmlMyBatis增删改查&注解MyBatis增删改查&MyBatis一级缓存和二级缓存 回顾 说说核心配置文件中这些标签的作用 配置标签名称 功能 properties 导入外部的properties文件 typeAliases(重要) 给自定义的类取别名 mappers 导入接口映射文件 说说下面映射文件中标签的作用 标签 子标签 说明 <select> 查询数据 <insert>
MyBatis注解方式与映射文件方式配合实现一对一，一对多，多对多（一）
程序人生
11-06 1584
MyBatis注解方式与xml文件方式配合实现单表操作、一对一首先，配置文件configuration.xml&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; ?&gt; &lt;!DOCTYPE configuration PUBLIC &quot;-//mybatis.org//DTD Config 3.0//EN&quot; &quot;http://m
Mybatis使用注解一对一，一对多，多对多
EEstefan的博客
08-16 1475
mybatis的概述 mybatis是一个持久层框架，用java编写的。 它封装了jdbc操作的很多细节，使开发者只需要关注sql语句本身，而无需关注注册驱动，创建连接等繁杂过程 它使用了ORM思想实现了结果集 ORM：Object Relational Mappging 对象关系映射 简单的说： 就是把数据库表和实体类及实体类的属性对应起来 让我们可以操作实体类就实现操作数据库表。 Mybatis环境搭建 • 创建maven工程并导入坐标 <dependency>
一对多、多对多（注解）
qq1424035130的博客
06-11 1186
1.一对多用户和账户 @Select("select * from user") @Results(id = "resultMap",value = { @Result(id = true,property = "userId",column ="id"), @Result(property = "userName",column ...
Mybatis学习笔记——四、缓存，注解实现一对多、多对一和动态sql
ajacker的博客
10-16 350
@[to c] 13、缓存 当我们执行查询的时候，查询的结果会同时存入到SqlSession为我们提供的一块区域中。 该区域的结构是一个Map。当我们再次查询同样的数据，mybatis会先去查询SqlSession中是否有，有的话直接拿来用。 当SqlSession对象消失时，mybatis的一级缓存也就消失了。 二级缓存： 它指的是mybatis中SqlSessionFactory对象的缓存。...
MyBatis关联查询缓存配置（一对一、一对多、延迟加载）
Kiko_Fan的博客
12-28 217
package com.dao; import java.util.List; import com.model.User; public interface IuserDao { //学生表和学生明细表关联查询 List<User> selectAll(); //一对一 List<User> UserAndDet(); //一对多 List<User&gt...
ibatis 实现一对一和一对多(2)
pingguonjb的专栏
07-07 602
ibatis 实现一对一和一对多(2)   select id,lockId,keyName from key ]]> select id,lockName from lock where id = #value# ]]> se
MyBatis整合Redis实现二级缓存步骤与示例
"本文将详细介绍如何使用MyBatis框架整合Redis实现二级缓存，并提供相关示例代码。通过这种方式，可以提高应用的性能，减少数据库访问。在实际操作中，需要注意防止缓存穿透、缓存雪崩和缓存击穿等问题，确保缓存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值