基于Mybatis注解多表以及缓存

最新推荐文章于 2022-06-20 17:58:05 发布
最新推荐文章于 2022-06-20 17:58:05 发布
阅读量144 收藏
点赞数
分类专栏： MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40055163/article/details/108668866
版权

基于Mybatis注解多表以及缓存

1 mybatis注解建立实体类属性和数据库表中列的对应关系
1.点击File选择New并点击Project。如图所示：在这里插入图片描述
2.选择Maven工程和JDK的版本，点击Next。如图所示：在这里插入图片描述
3.填写项目名称和保存的地址，并点击Finish。如图所示：在这里插入图片描述
4.导入相应的依赖jar包的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.txw</groupId>
    <artifactId>day04_04annoOne2Many</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--打包的方式-->
    <packaging>jar</packaging>
    <dependencies>
        <!--导入mybatis的依赖jar包的坐标-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
        </dependency>
        <!--导入mysql的依赖jar包的坐标-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.6</version>
        </dependency>
        <!--导入log4j的依赖jar包的坐标-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!--导入junit的依赖jar包的坐标-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <!--导入lombok的依赖jar包的坐标-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.12</version>
        </dependency>
    </dependencies>
</project>

5.编写用户的实体类的代码如下：

package com.txw.domain;

import lombok.Data;
import lombok.ToString;
import java.io.Serializable;
import java.util.Date;
/**
 * 用户的实体类
 * @author：Adair
 * @QQ：1578533828
 */
@Data // 自动生成set和get方法
@ToString  // 重写toString方法
@SuppressWarnings("all")      // 注解警告信息
public class User implements Serializable {
    private Integer userId;   // 用户的id
    private String userName;  // 用户的名称
    private String userAddress; // 用户的地址
    private String userSex;     // 用户的性别
    private Date userBirthday;  // 用户的地址
}

6.编写用户的实体类持久层接口的代码如下：

package com.txw.dao;

import com.txw.domain.User;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import java.util.List;
/**
 * 用户实体类持久层接口
 * 在mybatis中针对,CRUD一共有四个注解
 *  @Select @Insert @Update @Delete
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public interface UserDao {
    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    List<User> findAll();
    /**
     * 根据id查询用户
     * @param userId
     * @return
     */
    @Select("select * from user  where id=#{id} ")
    User findById(Integer userId);
    /**
     * 根据用户名称模糊查询
     * @param username
     * @return
     */
    @Select("select * from user where username like #{username} ")
    List<User> findUserByName(String username);
}

7.在resources目录创建jdbcConfig.properties的代码如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://192.168.59.132:3306/mybatis?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

8.在resources目录创建SqlMapConfig.xml的代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 引入外部配置文件-->
    <properties resource="jdbcConfig.properties"></properties>
    <!--配置别名-->
    <typeAliases>
        <package name="com.txw.domain"></package>
    </typeAliases>
    <!-- 配置环境-->
    <environments default="mysql">
        <environment id="mysql">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"></property>
                <property name="url" value="${jdbc.url}"></property>
                <property name="username" value="${jdbc.username}"></property>
                <property name="password" value="${jdbc.password}"></property>
            </dataSource>
        </environment>
    </environments>
    <!-- 指定带有注解的dao接口所在位置 -->
    <mappers>
        <package name="com.txw.dao"/>
    </mappers>
</configuration>

9.编写测试代码如下：

package com.txw.test;

import com.txw.dao.UserDao;
import com.txw.domain.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;
/**
 * 注解CRUD的测试
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public class AnnotationCRUDTest {
    private InputStream in;
    private SqlSession sqlSession;
    private UserDao userDao;
    @Before // 用于在测试方法执行之前执行
    public void init()throws Exception{
        // 1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        // 3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        // 4.获取dao的代理对象
        userDao = sqlSession.getMapper(UserDao.class);
    }
    @After // 用于在测试方法执行之后执行
    public void destroy()throws Exception{
        // 提交事务
        sqlSession.commit();
        // 6.释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * 测试查询所有
     */
    @Test
    public  void testFindAll(){
        List<User> users = userDao.findAll();
        for(User user : users){
            System.out.println("---每个用户的信息----");
            System.out.println(user);
        }
    }
    /**
     * 测试根据id查询用户
     */
    @Test
    public void testFindOne(){
        User user = userDao.findById(2);
        System.out.println(user);
    }
    /**
     * 测试根据用户名称模糊查询
     */
    @Test
    public  void testFindByName(){
        List<User> users = userDao.findUserByName("%mybatis%");
        for(User user : users){
            System.out.println(user);
        }
    }
}

运行查询所有的方法的结果如图所示：在这里插入图片描述
用户实体类的属性与数据库字段名字，封装不成功！
@Resutl 注解
代替了 标签和标签
@Result 中 属性介绍：
id 是否是主键字段
column 数据库的列名
property 需要装配的属性名
one 需要使用的@One 注解（@Result（one=@One）（）））
many 需要使用的@Many注解（@Result（many=@many）（）））

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

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

package com.txw.dao;

import com.txw.domain.User;
import org.apache.ibatis.annotations.*;
import java.util.List;
/**
 * 用户实体类持久层接口
 * 在mybatis中针对,CRUD一共有四个注解
 *  @Select @Insert @Update @Delete
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public interface UserDao {
    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id="userMap",value= {
            @Result(id = true, column = "id", property = "userId"),
            @Result(column = "username", property = "userName"),
            @Result(column = "address", property = "userAddress"),
            @Result(column = "sex", property = "userSex"),
            @Result(column = "birthday", property = "userBirthday"),
    })
     List<User> findAll();
    /**
     * 根据id查询用户
     * @param userId
     * @return
     */
    @Select("select * from user  where id=#{id} ")
    @ResultMap("userMap")
    User findById(Integer userId);
    /**
     * 根据用户名称模糊查询
     * @param username
     * @return
     */
    @Select("select * from user where username like #{username} ")
    @ResultMap("userMap")
    List<User> findUserByName(String username);
}

在次运行查询所有的方法结果如图所示：说明封装成功！在这里插入图片描述
2 mybatis注解开发一对一的查询配置
1.编写账户的实体类的代码如下：

package com.txw.domain;

import lombok.Data;
import lombok.ToString;
import java.io.Serializable;
/**
 * Account的实体类
 * @author：Adair
 * @QQ：1578533828
 */
@Data // 自动生成set和get方法
@ToString  // 重写toString方法
@SuppressWarnings("all")      // 注解警告信息
public class Account implements Serializable {
    private Integer id;    // 账户的id
    private Integer uid;    // 用户的id
    private Double money;  // 账户的余额
    // 多对一（mybatis中称之为一对一）的映射：一个账户只能属于一个用户
    private User user;
}

2.编写账户的实体类持久层接口的代码如下：

package com.txw.dao;

import com.txw.domain.Account;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.FetchType;
import java.util.List;
/**
 * Account的实体类持久层接口
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public interface AccountDao {
    /**
     * 查询所有账户，并且获取每个账户所属的用户信息
     * @return
     */
    @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.txw.dao.UserDao.findById",fetchType= FetchType.EAGER))
    })
    List<Account> findAll();
}

3.编写测试的代码如下：

package com.txw.test;

import com.txw.dao.AccountDao;
import com.txw.domain.Account;
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;
/**
 * 注解CRUD的测试
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public class AccountTest {
    private InputStream in;
    private SqlSession sqlSession;
    private AccountDao accountDao;
    @Before // 用于在测试方法执行之前执行
    public void init()throws Exception{
        // 1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        // 3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        // 4.获取dao的代理对象
        accountDao = sqlSession.getMapper(AccountDao.class);
    }
    @After // 用于在测试方法执行之后执行
    public void destroy()throws Exception{
        // 提交事务
        sqlSession.commit();
        // 6.释放资源
        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());
        }
    }
}

运行结果如图所示：在这里插入图片描述
3 Mybatis注解开发一对多的查询配置
1.修改用户的实体类的代码如下：

package com.txw.domain;

import lombok.Data;
import lombok.ToString;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
 * 用户的实体类
 * @author：Adair
 * @QQ：1578533828
 */
@Data // 自动生成set和get方法
@ToString  // 重写toString方法
@SuppressWarnings("all")      // 注解警告信息
public class User implements Serializable {
    private Integer userId;   // 用户的id
    private String userName;  // 用户的名称
    private String userAddress; // 用户的地址
    private String userSex;     // 用户的性别
    private Date userBirthday;  // 用户的地址
    // 一对多关系映射：一个用户对应多个账户
    private List<Account> accounts;
}

2.修改用户的实体类持久层接口的代码如下：

package com.txw.dao;

import com.txw.domain.User;
import org.apache.ibatis.annotations.*;
import org.apache.ibatis.mapping.FetchType;
import java.util.List;
/**
 * 用户实体类持久层接口
 * 在mybatis中针对,CRUD一共有四个注解
 *  @Select @Insert @Update @Delete
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public interface UserDao {
    /**
     * 查询所有用户
     * @return
     */
    @Select("select * from user")
    @Results(id="userMap",value= {
            @Result(id = true, column = "id", property = "userId"),
            @Result(column = "username", property = "userName"),
            @Result(column = "address", property = "userAddress"),
            @Result(column = "sex", property = "userSex"),
            @Result(column = "birthday", property = "userBirthday"),
            @Result(property = "accounts",column = "id",
                    many = @Many(select = "com.txw.dao.AccountDao.findAccountByUid",
                            fetchType = FetchType.LAZY))
    })
     List<User> findAll();
    /**
     * 根据id查询用户
     * @param userId
     * @return
     */
    @Select("select * from user  where id=#{id} ")
    @ResultMap("userMap")
    User findById(Integer userId);
    /**
     * 根据用户名称模糊查询
     * @param username
     * @return
     */
    @Select("select * from user where username like #{username} ")
    @ResultMap("userMap")
    List<User> findUserByName(String username);
}

3.在Account的实体类持久层接口添加如下：

package com.txw.dao;

import com.txw.domain.Account;
import org.apache.ibatis.annotations.One;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.mapping.FetchType;
import java.util.List;
/**
 * Account的实体类持久层接口
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public interface AccountDao {
    /**
     * 查询所有账户，并且获取每个账户所属的用户信息
     * @return
     */
    @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.txw.dao.UserDao.findById",fetchType= FetchType.EAGER))
    })
    List<Account> findAll();
    /**
     * 根据用户id查询账户信息
     * @param userId
     * @return
     */
    @Select("select * from account where uid = #{userId}")
    List<Account> findAccountByUid(Integer userId);
}

4.编写测试的代码如下：

package com.txw.test;

import com.txw.dao.UserDao;
import com.txw.domain.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;
/**
 * 注解的测试
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public class UserTest {
    private InputStream in;
    private SqlSession sqlSession;
    private UserDao userDao;
    @Before // 用于在测试方法执行之前执行
    public void init()throws Exception{
        // 1.读取配置文件，生成字节输入流
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2.获取SqlSessionFactory
        SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
        // 3.获取SqlSession对象
        sqlSession = factory.openSession(true);
        // 4.获取dao的代理对象
        userDao = sqlSession.getMapper(UserDao.class);
    }
    @After // 用于在测试方法执行之后执行
    public void destroy()throws Exception{
        // 提交事务
        sqlSession.commit();
        // 6.释放资源
        sqlSession.close();
        in.close();
    }
    /**
     * 测试查询所有
     */
    @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());
        }
    }
    /**
     * 测试根据id查询用户
     */
    @Test
    public void testFindOne(){
        User user = userDao.findById(2);
        System.out.println(user);
    }
    /**
     * 测试根据用户名称模糊查询
     */
    @Test
    public  void testFindByName(){
        List<User> users = userDao.findUserByName("%mybatis%");
        for(User user : users){
            System.out.println(user);
        }
    }
}

@Many:
相当于的配置
select属性：代表将要执行的sql语句
fetchType 属性：代表加载方式，一般如果要延迟加载都设置为 LAZY的值
运行结果如图所示：在这里插入图片描述
4 mybatis注解开发使用二级缓存
1.如下代码：

/**
 * 测试根据id查询用户
 */
@Test
public void testFindOne(){
    User user1 = userDao.findById(2);
    System.out.println(user1);
    User user2 = userDao.findById(2);
    System.out.println(user2);
    System.out.println(user1 == user2);
}

运行结果如图所示：说明是一级缓存，没必要去过多关注！在这里插入图片描述
2.在SqlMapConfig.xml配置如图所示开启二级缓存的代码：在这里插入图片描述
代码如下：

<!--配置开启二级缓存-->
<settings>
   <setting name="cacheEnabled" value="true"/>
</settings>

3.修改用户实体类持久层接口的代码如图所示：在这里插入图片描述
4.编写测试代码如下：

package com.txw.domain;

import com.txw.dao.UserDao;
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;
/**
 * 二级缓存测试
 * @author：Adair
 * @QQ：1578533828
 */
@SuppressWarnings("all")      // 注解警告信息
public class SecondLevelCatchTest {
    private InputStream in;
    private SqlSessionFactory factory;
    private UserDao userDao;
    @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{
        in.close();
    }
    /**
     *测试二级缓存
     */
    @Test
    public void testFindOne(){
        SqlSession session = factory.openSession();
        UserDao userDao = session.getMapper(UserDao.class);
        User user = userDao.findById(2);
        System.out.println(user);
        session.close(); // 释放一级缓存
        SqlSession session1 = factory.openSession();//再次打开session
        UserDao userDao1 = session1.getMapper(UserDao.class);
        User user1 = userDao1.findById(2);
        System.out.println(user1);
        session1.close();
    }
}

运行结果如图所示：开启了二级缓存！在这里插入图片描述

学无止路
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
MyBatis注解开发（多表查询）
我要记录学习博客
05-09 1951
MyBatis注解开发 这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper 映射文件了。 常见的注解开发： @Insert：实现新增 @Update：实现更新 @Delete：实现删除 @Select：实现查询 @Result：实现结果集封装 @Results：可以与@Result 一起使用，封装多个结果集 @One：实现一对一结果集封装 @Many：实现一对多结果集封装 项目搭建 创建mybatis-anno项目
MyBatis的多表操作
我要记录学习博客
05-09 617
MyBatis的多表操作 项目搭建 创建一个order数据库表与user连接，userid作为外键被引用 创建mybatis-multiMaver模块 在main文件下创建com.zcl.domain包名创建User实体和Order实体 User实体 public class User { private int id; private String username; private String password; private Date birthd
MyBatis之多表之间的联系与缓存
fygkchina的专栏
09-08 366
多表之间的联系： 注：本文章的演示都是在上篇文章项目的基础上进行的，所以有的代码变动不大的就不再重复贴了，以免太过冗余。点明一点：每写一个映射文件都要配置在mybatis-config.xml 的 中 一对多：查询哪些人有哪些车 Demo3.java [java] view plain copy  print? package cn.hn
MyBatis实行多表查询几种实现方式
DQWERww的博客
06-20 3234
MyBatis如何实现多表查询（一对一、一对多）
MyBatis多表关联查询
IceTiger_的博客
08-10 4404
一、搭建测试环境（一对多和多对一） （一）创建测试数据库 CREATE TABLE `t_teacher` ( `id` int(10) NOT NULL AUTO_INCREMENT, `name` varchar(30) DEFAULT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8 CREATE TABLE `t_student` ( `id` int(10) NOT NUL
Mybatis-plus基于redis实现二级缓存过程解析
08-18
Mybatis-plus基于Redis实现二级缓存过程解析 Mybatis-plus是一款基于Java语言的持久层框架，旨在简化数据库交互操作。然而，在高并发、高性能的应用场景中，数据库的查询操作可能会成为性能瓶颈。为了解决这个问题...
springMybatis+redis三级缓存框架
06-12
3. **缓存雪崩**：多个缓存同时过期可能导致大量请求涌向数据库，设置合理的缓存过期时间以及采用随机过期策略可以避免这种情况。 4. **缓存击穿**：热点数据的缓存失效，导致数据库压力骤增。可以使用互斥锁（如...
Mybatis如何通过注解开启使用二级缓存
08-25
"Mybatis 中通过注解开启使用二级缓存" Mybatis 是一个基于 Java 的持久层框架，它提供了一个简单易用的方式来访问数据库。二级缓存是 Mybatis 中的一种缓存机制，它可以将查询结果缓存起来，减少数据库的访问次数...
spring boot mybatis 多数据源与缓存.zip
07-28
至于缓存，MyBatis的二级缓存是基于内存的，可以存储查询结果，减少对数据库的访问。每个Mapper接口可以有自己的缓存策略，通过在Mapper XML文件中配置元素来控制缓存行为。例如，可以设置缓存的刷新间隔、大小限制...
MyBatis基于注解简单案例
07-28
通过这个简单的MyBatis注解案例，我们可以了解到如何利用MyBatis进行基本的数据库操作，包括选择性地使用注解替代XML配置，以及如何在Spring框架下集成MyBatis。在实际项目中，还可以结合MyBatis的其他特性，如结果...
mybatis注解多表查询
weixin_46083389的博客
02-03 351
回忆：mybatis的多表查询在XML中有两种方式，一是根据根据SQL结果封装对象，二是根据调用其他接口方法的查询结果来封装对象。
Mybatis实现多表联查
热门推荐
TaoistQu的博客
05-09 3万+
一、Mybatis实现多表联查询 1、Mybatis实现多表联查询方式 业务装配对两个表写单独的sql语句，在业务(service)把查询结果进行联合。 使用Auto Mapping特性，在实现两个表联合查询时通过别名完成自动映射。 使用Mybatis的<resultMap>标签进行实现 2、多表查询时类中包含另一个对象的分类 单个对象 集合对象 二、resultM...
Mybatis多表连接(完整版)
郝啊的博客
05-06 3585
Mybatis多表连接 此博文主要是记录自己日常学习以及讲述给学弟的随堂笔记，故你可能会看不到完整的代码，考虑到你也兴趣，文章末尾会附上本文完整的业务需求代码素材，建议你先看末尾，再来看前文。 转载请附上原文链接。 河南济源...
mybatis操作多对多关系表更新缓存
weixin_43774331的博客
12-19 1061
有时候我们在对mybatis多对多关系表进行操作后，由于使用了Ehcache二级缓存，所以没有对数据库重新读取数据，导致了数据是之前的。对于这种情况，我们可以根据需要对于一些操作禁用掉二级缓存。 &lt;select id="selectUserByRoleId" parameterType="int" resultType="User" useCache="false"&gt; 所以在对数据表...
Mybatis二级缓存关于多表关联时修改被关联表数据，缓存没清空的问题
k_769915435的专栏
07-02 2616
表jieg CREATE TABLE `user` ( `id` int(11) NOT NULL AUTO_INCREMENT, `username` varchar(16) NOT NULL, PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户表'; CREATE TABLE `user_inf
mybatis二级缓存联表查询需要注意的问题
bossaiaboy的专栏
06-01 2100
1、在开启了mybatis二级缓存情况下，联表查询后，对表进行了update、delete、insert等操作后，再次联表查询可能会造成脏读； 假设有一条联表的sql，设定为A，在执行了A操作后，mybatis会将结果集存入缓存中，设定为A-cache，还有一条sql，设定为B，B的实际操作会影响了A的表内结果，但是由于B的操作只是更改了数据库内的值，没有更改到A-cache内的值，所以下次执行
Mybatis多表关联查询、懒加载、缓存
qq_42488087的博客
09-27 761
Mybatis多表关联查询、懒加载、缓存 多表关联查询： 手动处理映射关系： 数据库表格和java类之间的对应关系 自动处理映射关系 自动根据java类的属性名和数据库的字段名封装数据 要求字段名和属性名相同 手动处理映射关系 Java中的实体类和数据库表格的字段名不同 怎么处理 字段使用别名 缺点 SQL语句复用度低 无法处理多变关联查询问题 定义映射关系 映射关系可以在多...
Mybatis第四天--Mybatis的延迟加载+缓存技术+基于注解的单表和多表操作
空圆小生的博客
07-11 144
Mybatis第四天Mybatis 延迟加载策略什么是延迟加载？使用assocation实现延迟加载需求：查询所有账户信息，并延迟加载实现查询账户对应的用户信息accountDao.javaAccountDao.xmlUserDao.java和UserDao.xml在SqlMapConfig.xml文件中开启延迟加载测试类结果使用collection实现延迟加载需求：查询所有用户信息，并延迟加载实现查询用户所有的账户信息UserDao.javaUserDao.xml测试类结果 Mybatis 延迟加载策略
MyBatis整合Redis实现二级缓存步骤与示例
"本文将详细介绍如何使用MyBatis框架整合Redis实现二级缓存，并提供相关示例代码。通过这种方式，可以提高应用的性能，减少数据库访问。在实际操作中，需要注意防止缓存穿透、缓存雪崩和缓存击穿等问题，确保缓存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学无止路

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值