MyBatis之多表之间的联系与缓存

最新推荐文章于 2023-04-17 14:10:55 发布
最新推荐文章于 2023-04-17 14:10:55 发布
阅读量2.4k 收藏 1
点赞数
分类专栏： 框架(SS2H MyBatis) Java从入门到高级编程 文章标签： mybatis 缓存 多表之间的联系 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zuosixiaonengshou/article/details/54909302
版权

多表之间的联系：

注：本文章的演示都是在上篇文章项目的基础上进行的，所以有的代码变动不大的就不再重复贴了，以免太过冗余。点明一点：每写一个映射文件都要配置在mybatis-config.xml 的 <mappers>中

一对多：查询哪些人有哪些车

Demo3.java

package cn.hncu.demo;

import java.sql.SQLException;
import java.util.List;
import java.util.Set;

import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import cn.hncu.domain.Card;
import cn.hncu.domain.Person;
import cn.hncu.domain.Role;
import cn.hncu.domain.User;
import cn.hncu.utils.SqlSessionUtils;

//演示表与表之间的关系：一对一，一对多和多对多
public class Demo3 {
	
	//一对多：一个人(person)多辆车(car)
	@Test
	public void test1() throws SQLException{
		//查询哪些人有哪些车-----innor join
		SqlSession s=SqlSessionUtils.getSqlSession();
		List<Person> persons=s.selectList("persons.person1");
		s.close();
		for(Person person:persons)
		System.out.println("person: "+person);
	}


Person.java

package cn.hncu.domain;

import java.util.ArrayList;
import java.util.List;

//一方
public class Person {
	private String id;
	private String name;
	
	//建一个集合表示多方
	private List<Car> cars=new ArrayList<Car>();
	
	//为了实现表之间关系中的“一对一”，在此必须添加一个对方的值对象
	private Card card;
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public List<Car> getCars() {
		return cars;
	}
	public void setCars(List<Car> cars) {
		this.cars = cars;
	}
	
	public Card getCard() {
		return card;
	}
	public void setCard(Card card) {
		this.card = card;
	}
	@Override
	public String toString() {
		return "Person [id=" + id + ", name=" + name + ", cars=" + cars + "]";
	}
	
}


Car.java

package cn.hncu.domain;

//多方
public class Car {
	private String id;
	private String name;
	private Double price;
	
	//声明一个值对象表示一方
	private Person person;
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Double getPrice() {
		return price;
	}
	public void setPrice(Double price) {
		this.price = price;
	}
	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
	@Override
	public String toString() {
		return "Car [id=" + id + ", name=" + name + ", price=" + price + "]";
	}
	
}


Person.xml

<?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="persons">
	
	<!-- 一对多：inner join-->
	<!-- 自定义复杂类型用resultMap -->
	<resultMap type="cn.hncu.domain.Person" id="ps">
		<id property="id" column="pid"/><!-- 使用id是为了更加精确，使用result也可 -->
		<result property="name" column="pname"/>
		
		<!-- 一方中的多方集合(这里的property用car值对象的变量，column用下面select语句的查询结果的表头) -->
		<collection property="cars" javaType="cn.hncu.domain.Car">
			<id property="id" column="cid"/>
			<result property="name" column="cname" javaType="string" jdbcType="VARCHAR"/>
			<result property="price" column="cprice" javaType="_double" jdbcType="NUMERIC"/>
		</collection>
		
	</resultMap>
	<select id="person1" resultMap="ps">
		select p.pid as pid,p.pname as pname,c.id as cid,c.name as cname,c.price as cprice
		from person p inner join car c on p.pid =c.pid
	</select>


数据库查询结果：

 

控制台查询结果：

 

一对多：查询每个人的车辆信息-----left join

@Test
	public void test2() throws SQLException{
		//查询每个人的车辆信息-----left join
		SqlSession s=SqlSessionUtils.getSqlSession();
		List<Person> persons=s.selectList("persons.person2");
		s.close();
		for(Person person:persons)
			System.out.println("person: "+person);
	}


 

<!-- 一对多：按照上面的方法用left join即可，这里学习一下嵌套查询 -->
	<select id="person2" resultMap="ps2">
		select pid,pname from person
	</select>
	<resultMap type="cn.hncu.domain.Person" id="ps2">
		<id property="id" column="pid"/>
		<result property="name" column="pname"/>
		<collection property="cars" column="pid" select="cars1"></collection>
	</resultMap>
	<select id="cars1" resultType="cn.hncu.domain.Car" parameterType="string">
		select * from car where pid=#{value}
	</select>


数据库：

控制台：

 

一对一：一个人对应一张身份证

@Test
	public void test3() throws SQLException{
		//查询每个人的车辆信息-----left join
		SqlSession s=SqlSessionUtils.getSqlSession();
		List<Card> cards=s.selectList("persons.card1");
		s.close();
		for(Card card:cards)
			System.out.println("card: "+card);
	}


 

<!-- 一对一演示：一张身份证对应一个人 -->
	<select id="card1" resultMap="c1">
		select c.card_id as id,c.card_gov as gov,p.pid as pid,p.pname as pname
		from cards c inner join person p on c.pid=p.pid
	</select>
	<resultMap type="cn.hncu.domain.Card" id="c1">
		<!-- 以指定构造方法来初始化对象 -->
		<constructor>
			<idArg column="id" javaType="string" jdbcType="VARCHAR"/>
		</constructor>
		<result property="gov" column="gov" javaType="string" jdbcType="VARCHAR"/>
		<association property="person"  javaType="cn.hncu.domain.Person">
			<result property="id" column="pid"/>
			<result property="name" column="pname"/>
			<collection property="cars" select="cars1" column="pid"></collection>
		</association>
	</resultMap>
</mapper>


数据库：

 

控制台：

 

多对多：人---角色的关系

//多对多：人---角色的关系    开发步骤：1.建数据库表  2.写值对象(体现表之间关系)  3.写调用的java代码(在业务流程不熟悉的情况下，可先从需求下手) 4.写映射文件
	@Test
	public void test4() throws SQLException{
		//查询哪些人有哪些角色-----inner join
		SqlSession s=SqlSessionUtils.getSqlSession();
		List<User> users=s.selectList("roles.user");
		s.close();
		for(User user:users)
			System.out.println("user: "+user);
		for(User u:users){
			String name=u.getName();
			Set<Role> roles=u.getRoles();
			String r="";
			for(Role role:roles){
				r+=role.getName()+",";
			}
			System.out.println(name+","+r);
		}
	}


Role.xml

<?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="roles">
	<!-- 如果当前映射文件中的所有操作都要使用(二级)缓存，只需加<cache/>标记即可 -->
	<cache/>
	
	<!-- 多对多：采用 inner join -->
	<select id="user" resultMap="us">
	select u.id as id , u.name as name , u.pwd as pwd , r.id as rid , r.name as rname
		from users u inner join userrole ur on u.id=ur.uid inner join roles r on ur.rid=r.id
	</select>
	<resultMap type="cn.hncu.domain.User" id="us">
	<id property="id" column="id"/>
	<result property="name" column="name" javaType="string" jdbcType="VARCHAR"/>
	<result property="pwd" column="pwd"/>
	<collection property="roles" javaType="cn.hncu.domain.Role">
		<id property="id" column="rid"/>
		<result property="name" column="rname"/>
	</collection>
	</resultMap>

 

两个值对象：


User.java

package cn.hncu.domain;

import java.util.HashSet;
import java.util.Set;

public class User {
	private String id;
	private String name;
	private String pwd;
	
	//专为多对多建立一个  保存对方的集合--用List或Set都可以
	private Set<Role> roles=new HashSet<Role>();
	public String getId() {
		return id;
	}
	public void setId(String 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;
	}
	
	public Set<Role> getRoles() {
		return roles;
	}
	public void setRoles(Set<Role> roles) {
		this.roles = roles;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", pwd=" + pwd
				+ ", roles=" + roles + "]";
	}
	
}


Role.java

package cn.hncu.domain;

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

public class Role implements Serializable{
	private String id;
	private String name;
	
	//专为多对多建立一个保存对方的集合 -----用list或set 都可以
	private List<User> users=new ArrayList<User>();

	public String getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public List<User> getUsers() {
		return users;
	}

	public void setUsers(List<User> users) {
		this.users = users;
	}

	@Override
	public String toString() {
		return "Role [id=" + id + ", name=" + name + "]";
	}
	
}


数据库：

 

控制台：

 

mybatis缓存技术演示

//※※mybatis缓存技术演示：
	//※※注意：被放入缓存的值对象必须实现serizable接口
	@Test
	public void caseDemo() throws SQLException{
		
		//同一个session用的是一级缓存
		SqlSession ss=SqlSessionUtils.getSqlSession();
		System.out.println("ss: "+ss);
		Role role=ss.selectOne("roles.cacheDemo","R001");//查单
		System.out.println(role.hashCode());
		Role role2=ss.selectOne("roles.cacheDemo","R001");//查单
		System.out.println(role2.hashCode());
		ss.close();
		
		System.out.println("----------------------------");
		//第二个session
		SqlSession ss2=SqlSessionUtils.getSqlSession();
		System.out.println("ss2: "+ss2);
		Role role22=ss2.selectOne("roles.cacheDemo","R001");//查单
		System.out.println(role22.hashCode());
		Role role222=ss2.selectOne("roles.cacheDemo","R001");//查单
		System.out.println(role222.hashCode());
		
	}
}


<!-- 下面的查询操作专用于演示缓存   useCache可指定某条语句不使用缓存-->
	<select id="cacheDemo" useCache="false" resultType="cn.hncu.domain.Role" parameterType="string">
		select * from roles where id=#{value}
	</select>
</mapper>


不带缓存：

 

带缓存：

 

这里对缓存再个人总结一下：

 1.  缓存有一级和二级缓存。SqlSession自己带有一级缓存，所有同一个缓存得到的对象的hash地址是相同的，不同的session拿到的对象hash地址不同。

 2.  mybatis(hibernate也一样)有二级缓存。mytbatis中默认情况下是没有开启缓存的，当不同session查询时，都要去数据库中去查询，效率降低。

   当开启mybatis缓存时，session第一次查询时没有缓存，会到数据库中查询，并将查询结果放到mybatis二级缓存和本session缓存中，当再存查询时，会到本session缓存池中寻找，找到即返回结果。

    所以带缓存的图中，两次的hashCode值是一样的。    而当第二个session去查询时，到mybatis的二级缓存池中找到结果，就会把结果克隆一份结果返回，并且不把结果放进本session缓存池中，再次查询时，依然到mybatis的二级缓存池中中克隆结果。所以两次结果的hashCode值不同。

 3.  只有session到数据库中查询，才会把查询结果放进session的缓存池中。

 

贴出一下我用mysql建的表格的代码，以供日后参考：

ALTER TABLE car 
	ADD CONSTRAINT stud_fk FOREIGN KEY(pid) REFERENCES person(pid);
INSERT INTO person(pid,pname) VALUES("P001","Jack");
INSERT INTO person(pid,pname) VALUES("P002","Rose");
INSERT INTO person(pid,pname) VALUES("P003","Tom");
INSERT INTO car(id,NAME,price,pid) VALUES("C001","Benz",100,"P001");
INSERT INTO car(id,NAME,price,pid) VALUES("C002","BMW",150,"P001");
INSERT INTO car(id,NAME,price,pid) VALUES("C003","QQ",10,"P003");
DROP TABLE person;
DROP TABLE car;
CREATE TABLE car(
id VARCHAR(32) PRIMARY KEY,
NAME VARCHAR(128),
price NUMERIC,
pid VARCHAR(32)
);
SELECT pid,pname FROM person


SELECT p.pid AS pid,p.pname AS pname,c.id AS cid,c.name AS cname,c.price AS cprice
		FROM person p INNER JOIN car c ON p.pid =c.pid
		
SELECT p.pid AS pid,p.pname AS pname,c.id AS cid,c.name AS cname,c.price AS cprice
		FROM person p LEFT JOIN car c ON p.pid =c.pid


CREATE TABLE cards(
card_id VARCHAR(32) PRIMARY KEY,
card_gov VARCHAR(128),
pid VARCHAR(32)
)
ALTER TABLE cards 
	ADD CONSTRAINT fk_pid FOREIGN KEY (pid) REFERENCES person(pid);

INSERT INTO cards(card_id,card_gov,pid) VALUES("C001","湖南长沙","P001");
INSERT INTO cards(card_id,card_gov,pid) VALUES("C002","湖南益阳","P002");
INSERT INTO cards(card_id,card_gov,pid) VALUES("C003","北京朝阳","P003");

SELECT c.card_id AS id,c.card_gov AS gov,p.pid AS pid,p.pname AS pname
		FROM cards c INNER JOIN person p ON c.pid=p.pid

CREATE TABLE roles(
id VARCHAR(32) PRIMARY KEY,
NAME VARCHAR(128)
)
INSERT INTO roles(id,NAME) VALUES('R001','教师');
INSERT INTO roles(id,NAME) VALUES('R002','学生');
INSERT INTO roles(id,NAME) VALUES('R003','后勤');
INSERT INTO roles(id,NAME) VALUES('R004','暂无');
CREATE TABLE userRole(
uid VARCHAR(32),
rid VARCHAR(32)
)
ALTER TABLE userrole 
	ADD CONSTRAINT fk_uid FOREIGN KEY (uid) REFERENCES users(id);
ALTER TABLE userrole 
	ADD CONSTRAINT fk_rid FOREIGN KEY (rid) REFERENCES roles(id);

INSERT INTO userrole(uid,rid) VALUES('1',"R002");
INSERT INTO userrole(uid,rid) VALUES('1',"R003");
INSERT INTO userrole(uid,rid) VALUES('2',"R002");
INSERT INTO userrole(uid,rid) VALUES('3',"R004");
INSERT INTO userrole(uid,rid) VALUES('4',"R001");

SELECT u.id AS id , u.name AS NAME , u.pwd AS pwd , r.id AS rid , r.name AS rname
FROM users u INNER JOIN userrole ur ON u.id=ur.uid INNER JOIN roles r ON ur.rid=r.id


 

D灿
关注
专栏目录
MyBatis一级缓存和二级缓存
Mr.xing的博客
04-03 1万+
Mybatis缓存
redis分布式缓存之表关联关系问题
踏 浪的博客
11-08 1459
上一章https://blog.csdn.net/u010559460/article/details/109549593 我们已经解决了 SpringBoot、Mybatis 整合 redis 实现分布式缓存的问题 项目中，如果表与表之间没有任何关联关系，那这样使用缓存是没有什么问题的。那么如果表与表之间存在关联关系的情况，缓存问题该如何解决？ 这里演示一下来说明问题。 之前已经有了个 User 模块，现在添加 Role模块 1、Role模块 1.1 创建 Role表 create ta..
Day05 关联关系，mybatis中的缓存机制，spring boot 整合mybatis ，前后端调用
m0_60585248的博客
10-05 97
关联关系 一对一案例 完成一对一映射，一个员工对应一个部门，选取方向：员工方 需要在员工中，完成部门对象的封装 如果需要封装单个对象，则使用association标签，property代表封装对象的属性，javaType指定属性的类型。 关联查询和子查询说明 关联查询：通过大量的sql语句，实现数据关联查询，其中sql语句相对复杂，但是数据封装简单 子查询：其中sql几乎都是单表查询，sql简单，但是数据封装复杂。 编辑xml映射文件：子查询说明： column=“子查询的字段信息” Slect..
Mybatis多表关联查询、懒加载、缓存
qq_42488087的博客
09-27 788
Mybatis多表关联查询、懒加载、缓存 多表关联查询： 手动处理映射关系： 数据库表格和java类之间的对应关系 自动处理映射关系 自动根据java类的属性名和数据库的字段名封装数据 要求字段名和属性名相同 手动处理映射关系 Java中的实体类和数据库表格的字段名不同 怎么处理 字段使用别名 缺点 SQL语句复用度低 无法处理多变关联查询问题 定义映射关系 映射关系可以在多...
基于Mybatis注解多表以及缓存
weixin_40055163的博客
09-18 168
基于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.
mybatis黑马：注解开发 (多表查询操作/缓存)
JH灰色的博客
02-18 283
1.jdbcConfig.properties文件的引用(配置数据库) 以后可以用配置文件 SqlMapConfig.xml文件 <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "ht...
深入理解MyBatis中的一级缓存与二级缓存
08-30
"深入理解MyBatis中的一级缓存与二级缓存" MyBatis是一种流行的持久层框架，它提供了缓存机制来提高应用程序的性能。在MyBatis中，有两种类型的缓存：一级缓存和二级缓存。下面我们将深入了解MyBatis中的一级缓存和...
Mybatis 缓存原理
YYniannian的博客
08-05 455
RedisCache在mybatis启动的时候，由MyBatis的CacheBuilder创建，创建的⽅式很简单，就是调⽤ RedisCache的带有String参数的构造⽅法，即RedisCache(String id)；⽽在RedisCache的构造⽅法中， 调⽤了 RedisConfigu rationBuilder 来创建 RedisConfig 对象，并使⽤ RedisConfig 来创建JedisPool。 RedisConfig类继承了 JedisPoolConfig，并提供了 host,po
myBatis组件教程之缓存的实现与使用
08-26
在深入探讨MyBatis缓存实现与使用之前，我们首先需要理解什么是缓存以及它在数据库操作中的作用。缓存是一种存储技术，用于暂时存储频繁访问的数据，以便快速响应请求，减少对数据库的直接访问，从而提高应用性能。...
mybatis二级缓存联表查询需要注意的问题
bossaiaboy的专栏
06-01 2128
1、在开启了mybatis二级缓存情况下，联表查询后，对表进行了update、delete、insert等操作后，再次联表查询可能会造成脏读； 假设有一条联表的sql，设定为A，在执行了A操作后，mybatis会将结果集存入缓存中，设定为A-cache，还有一条sql，设定为B，B的实际操作会影响了A的表内结果，但是由于B的操作只是更改了数据库内的值，没有更改到A-cache内的值，所以下次执行
MyBatis关联查询,其中关联表有数据更新,如解决缓存更新的问题
无知人生，记录点滴
04-10 2979
最近在做的项目中有一个消息功能，其中像系统消息的实现，就是在消息表中只有一条记录，然后对应每个用户要标记为删除或者已读，就在另一个表中用一条记录的标记。 这样设置删除或已读标记的时候，是在另一个表的 Mapper.xml 中操作的，也就不会更新消息表的缓存。 有人试图在ABMapper.xml 中采用cache-ref才解决这个问题，不好使。不知道是不是我配得不对。 ABMapper.xm...
Mybatis 缓存机制
m0_60477159的博客
11-01 85
1.Mybatis中不允许字段重复
mybatis缓存机制
五谷丰登
09-16 100
mybatis在查出一个表的内容后，就会把查询的结果进行缓存，当再次需要这个表中的数据的时候，可以直接从缓存中获取，提高了应用的效率，但是缓存的数据容易过时（当表中内容有改变的时候）。 mybatis一共有两种缓存机制： 一、一级缓存：session级别的缓存，是mybatis默认的缓存机制 UserDao.java //一级缓存 public List<User> getUsersB...
一对多，多对一，自关联，多对多，一级缓存，二级缓存
weixin_30700099的博客
10-14 59
一对多 Dad------>Son 两种方案：单条SQL <resultMap id="DadMapper" type="Dad"> <id property="fatherid" column="fatherid"></id> ...
hibernate中关于一对多，多对多的二级缓存设置和同步问题
jsczxy2
01-01 252
首先，hibernate中的二级缓存分2块，第一块是modal的class中设置，第二块是set中设置，根据测试来看，缓存在set中的内容并非是整个子对象的set，而是子对象的ID的set集合，因此当子对象有变动时候，缓存中set里该子对象拿出来也会更新，而当子对象自己删除并没有通知到主对象的时候就会发生缓存不同步的问题，也就是主对象的set中还存在子对象的ID，但是子对象实际已经删除了，这个时...
Mybatis的一级缓存和二级缓存
最新发布
hjkl761的博客
04-17 1万+
验证mybatis缓存的存在，以及一级缓存如何保证数据一致性
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值