备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

MyBatis学习笔记(二) 关联关系

2018-08-30 2400
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

一、一对一关系

还是通过例子来解释说明。（一个妻子对应一个丈夫）。

1)数据库信息
create table t_wife(
id int primary key auto_increment,
wife_name varchar(20),
fk_husband_id int
);

create table t_husband(
id int primary key auto_increment,
husband_name varchar(20)
);

insert into t_husband values (null,'hello');
insert into t_wife values(null,'kitty',1)

2）对应的JavaBean代码

虽然在数据库里只有一方配置的外键，但是这个一对一是双向的关系。

HusbandBean.java
package com.cy.mybatis.beans;

import java.io.Serializable;
/**
* one to one
* @author acer
*
*/
public class HusbandBean implements Serializable{


private static final long serialVersionUID = 1L;
 
private Integer id;
private String name;
private WifeBean wife;
public HusbandBean() {
super();
}
public HusbandBean(Integer id, String name, WifeBean wife) {
super();
this.id = id;
this.name = name;
this.wife = wife;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public WifeBean getWife() {
return wife;
}
public void setWife(WifeBean wife) {
this.wife = wife;
}
@Override
public String toString() {
return "Husband [id=" + id + ", name=" + name + ", wife=" + wife + "]";
}
}

WifeBean.java
package com.cy.mybatis.beans;

import java.io.Serializable;
/**
* one to one
* @author acer
*
*/
public class WifeBean implements Serializable{
 
private static final long serialVersionUID = 1L;
private Integer id;
private String name;
private HusbandBean husband;
public WifeBean() {
super();
}
public WifeBean(Integer id, String name, HusbandBean husband) {
super();
this.id = id;
this.name = name;
this.husband = husband;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public HusbandBean getHusband() {
return husband;
}
public void setHusband(HusbandBean husband) {
this.husband = husband;
}
@Override
public String toString() {
return "Wife [id=" + id + ", name=" + name + ", husband=" + husband
+ "]";
}
}

3）接下来建立两个接口，HusbandMapper,WifeMapper.

HusbandMapper
package com.cy.mybatis.mapper;

import com.cy.mybatis.beans.HusbandBean;

public interface HusbandMapper {
/**
* 根据id查询丈夫信息
* @param id
* @return
* @throws Exception
*/
public HusbandBean selectHusbandById (int id) throws Exception;
 
/**
* 根据id查询丈夫与妻子信息
* @param id
* @return
* @throws Exception
*/
public HusbandBean selectHusbandAndWife(int id) throws Exception;

}

4）定义HusbandMapper.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cy.mybatis.mapper.HusbandMapper">

<resultMap type="HusbandBean" id="husbandAndWife">
<id property="id" column="id" javaType="java.lang.Integer"/>
<result property="name" column="name" javaType="java.lang.String"/>
 
<!-- association – 一个复杂的类型关联；许多结果将包成这种类型
嵌入结果映射 – 结果映射自身的关联，或者参考一个
column="id" 这里的id指的是在t_wife表来的主键id 
这个查询妻子，所以在妻子mapper里有个方法 -->
<association property="wife" column="id" javaType="WifeBean" select="com.cy.mybatis.mapper.WifeMapper.selectWifeByHusbandId" ></association>
</resultMap>

<!-- resultType 返回类型 从这条语句中返回的期望类型的类的完全限定名或别名
。-->
<select id="selectHusbandById" resultType="HusbandBean">
select * from t_husband where id=#{id}
</select> 

<!-- resultMap 命名引用外部的 resultMap。返回的是一个集合。-->
<select id="selectHusbandAndWife" resultMap="husbandAndWife">
select * from t_husband where id=#{id}
</select>




</mapper>

在WifeMapper.xml里有个方法
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.cy.mybatis.mapper.WifeMapper">
<select id="selectWifeByHusbandId" resultType="WifeBean">
select * from t_wife where fk_husband_id = #{id}

</select> 
</mapper>

5）写个实现
package com.cy.mybatis.service;

import org.apache.ibatis.session.SqlSession;

import com.cy.mybatis.beans.HusbandBean;
import com.cy.mybatis.mapper.HusbandMapper;
import com.cy.mybatis.tools.DBTools;




public class OneToOneService {
 
public static void main(String[] args) {
selectHusbandAndWife();

}


private static void selectHusbandAndWife() {
SqlSession session = DBTools.getSession();
HusbandMapper hm = session.getMapper(HusbandMapper.class);
try {
HusbandBean husband = hm.selectHusbandAndWife(1);
System.out.println(husband);
session.commit();
} catch (Exception e) {
e.printStackTrace();
}
}

}

注意：那个工具类还是前一章那样写的，就相当与在昨天的基础上建立的。

924c058a6889636baffee4eaa91f89817b36e5c7

注意：

mybatis实际是对XML进行操作，我们所有的方法都直接定义在XML中，写个接口只是为了更好的符合我们3层的思想，如果不写接口，直接通过session也可以直接操作xml中的方法 ，

XML中只要有方法，就可以使用，而调用的方式就是：namespace+方法名；

例外使用resultType时，一定要保证，你属性名与字段名相同；

如果不相同，就使用resultMap 。

二、一对多关系

还是通过例子来解释说明。（一把锁对应多把钥匙）。

2.1）数据库信息 这里没有添加数据了，我们用批量添加数据
create table t_key(
id int primary key auto_increment,
key_name varchar(20),
fk_lock_id int 
);


create table t_lock(
id int primary key auto_increment,
lock_name varchar(20)
);

2.2) 实体类

KeyBean.java
package com.cy.mybatis.beans;

import java.io.Serializable;
/**
* manyTOone
* 
*
*/
public class KeyBean implements Serializable {


private static final long serialVersionUID = 3712545874604618746L;

private Integer id;
private String key;
 
private LockBean lock;

public KeyBean() {
super();
}

public KeyBean(Integer id, String key, LockBean lock) {
super();
this.id = id;
this.key = key;
this.lock = lock;
}

public Integer getId() {
return id;
}

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

public String getKey() {
return key;
}

public void setKey(String key) {
this.key = key;
}

public LockBean getLock() {
return lock;
}

public void setLock(LockBean lock) {
this.lock = lock;
}

@Override
public String toString() {
return "KeyBean [id=" + id + ", key=" + key + ", lock=" + lock + "]";
} 
}

LockBean.java
package com.cy.mybatis.beans;

import java.io.Serializable;
import java.util.List;
/**
* oneTOmany
* 
*
*/
public class LockBean implements Serializable{

private static final long serialVersionUID = 7092410462131162665L;

private Integer id;
private String lock;
 
private List<KeyBean> keys;

public LockBean() {
super();
}

public LockBean(Integer id, String lock, List<KeyBean> keys) {
super();
this.id = id;
this.lock = lock;
this.keys = keys;
}

public Integer getId() {
return id;
}

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

public String getLock() {
return lock;
}

public void setLock(String lock) {
this.lock = lock;
}

public List<KeyBean> getKeys() {
return keys;
}

public void setKeys(List<KeyBean> keys) {
this.keys = keys;
}

@Override
public String toString() {
return "LockBean [id=" + id + ", keys=" + keys + ", lock=" + lock + "]";
} 
}

2.3) 建立接口

KeyMapper.java
package com.cy.mybatis.mapper;

import java.util.List;

import org.apache.ibatis.annotations.Param;

import com.cy.mybatis.beans.KeyBean;

public interface KeyMapper {
/**
* 批量添加钥匙
* @return
* 提倡 这样使用 @Param("keys")
*/
public int batchSaveKeys(@Param("keys")List<KeyBean> keys);
}

LockMapper.java
package com.cy.mybatis.mapper;

import org.apache.ibatis.annotations.Param;

import com.cy.mybatis.beans.LockBean;

public interface LockMapper {
/**
* 添加锁
* @param lock
* @return
*/
public int saveLock(@Param("lock")LockBean lock);
 
/**
* 根据ID查询锁的资料
* @param id
* @return
*/
public LockBean findLockById(int id);
 
/**
* 根据ID查询锁与钥匙的资料
* one2many
* @param id
* @return
*/
public LockBean findLockAndKeys(int id);

}

2.4) 建立xml文件

KeyMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cy.mybatis.mapper.KeyMapper">

<resultMap id="keyMap" type="KeyBean">
<id property="id" column="id" javaType="java.lang.Integer"/>
<result property="key" column="key_name" javaType="java.lang.String"/>
</resultMap>
 

<!--collection 为用于遍历的元素（必选），支持数组、List、Set -->
<!-- item 表示集合中每一个元素进行迭代时的别名. -->
<!--separator表示在每次进行迭代之间以什么符号作为分隔 符. -->
<insert id="batchSaveKeys">
insert into t_key values 
<foreach collection="keys" item="key" separator=",">
(null,#{key.key},#{key.lock.id})
</foreach>
</insert>

<select id="findKeysByLockId" resultMap="keyMap">
select * from t_key where fk_lock_id = #{id}
</select>

</mapper>

LockMapper.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org/DTD Mapper 3.0" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.cy.mybatis.mapper.LockMapper">
<!--自定义返回类型 -->
<resultMap id="lockMap" type="LockBean">
<id property="id" column="id" javaType="java.lang.Integer"/>
<result property="lock" column="lock_name" javaType="java.lang.String"/>
</resultMap>

 <!--自定义返回类型 -->
<resultMap id="lockAndKeysMap" type="LockBean">
<id property="id" column="id" javaType="java.lang.Integer"/>
<result property="lock" column="lock_name" javaType="java.lang.String"/>

<collection property="keys" column="id" select="com.cy.mybatis.mapper.KeyMapper.findKeysByLockId"></collection>
</resultMap>

<insert id="saveLock">
insert into t_lock values (null,#{lock.lock}) 
</insert>

<select id="findLockById" resultMap="lockMap">
select * from t_lock where id= #{id}
</select>

<select id="findLockAndKeys" resultMap="lockAndKeysMap">
select * from t_lock where id= #{id}
</select>

</mapper>

2.5 ） 实现
package com.cy.mybatis.service;

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

import org.apache.ibatis.session.SqlSession;

import com.cy.mybatis.beans.KeyBean;
import com.cy.mybatis.beans.LockBean;
import com.cy.mybatis.mapper.KeyMapper;
import com.cy.mybatis.mapper.LockMapper;
import com.cy.mybatis.tools.DBTools;

public class OneToManyService {
public static void main(String[] args) {
// saveLock();
// batchSaveKeys();
findLockAndKeys();
}

private static void findLockAndKeys() {

SqlSession session = DBTools.getSession();
LockMapper lm = session.getMapper(LockMapper.class);
LockBean lock = lm.findLockAndKeys(1);
System.out.println(lock);
}

private static void batchSaveKeys() {

SqlSession session = DBTools.getSession();
LockMapper lm = session.getMapper(LockMapper.class);
KeyMapper km = session.getMapper(KeyMapper.class);

LockBean lock = lm.findLockById(1);
List<KeyBean> keys = new ArrayList<KeyBean>();
for(int i = 0; i < 5; i++){
KeyBean key = new KeyBean(null, "钥匙"+i, lock);
keys.add(key);
}
km.batchSaveKeys(keys);
session.commit();
}

private static void saveLock() {
SqlSession session = DBTools.getSession();
LockMapper lm = session.getMapper(LockMapper.class);
LockBean lock = new LockBean(null, "锁1", null);
lm.saveLock(lock);
session.commit();
}
}

结果显示：

dd4db7c2e0545d386de27b7ed124b8ebf338eea7

原文发布时间为：2018-08-30本文来自云栖社区合作伙伴“ 全栈开发者社区”，了解相关信息可以关注“ 全栈开发者社区”。
文章标签：
Java
数据格式
XML
mybatis
数据库连接
关键词：
MyBatis学习笔记
MyBatis关联关系
MyBatis学习笔记关联关系
技术小能手
目录
相关文章
匿瘾
|
6月前
|
SQL Java 数据库连接
MyBatis中一对一、一对多和多对多关联关系的配置详解
MyBatis中一对一、一对多和多对多关联关系的配置详解
匿瘾
147 1
游客cquxq7ohwraeq
|
7月前
|
SQL Java 数据库连接
mybatis学习笔记（第二部分）
自学笔记
游客cquxq7ohwraeq
34 0
hhzz
|
1月前
|
SQL Java 关系型数据库
MyBatisPlus学习笔记（SpringBoot版）
MyBatisPlus学习笔记（SpringBoot版）
hhzz
98 0
姿势不太差
|
4月前
|
SQL Java 数据库连接
MyBatis 的关联关系配置 一对多，一对一，多对多 关系的映射处理
MyBatis 的关联关系配置 一对多，一对一，多对多 关系的映射处理
姿势不太差
73 0
懒大王o
|
4月前
|
Java 数据库连接 数据库
Mybatis的关联关系配置一对一，一对多，多对多的映射关系
Mybatis的关联关系配置一对一，一对多，多对多的映射关系
懒大王o
59 0
i46usca74mzt4
|
6月前
|
XML Java 数据库连接
“MyBatis中的关联关系配置与多表查询“
“MyBatis中的关联关系配置与多表查询“
i46usca74mzt4
25 0
瑶大头*^_^*
|
6月前
|
SQL XML 数据格式
mybatis-关联关系&一对多关联&多对一关联&多对多
mybatis-关联关系&一对多关联&多对一关联&多对多
瑶大头*^_^*
33 0
游客cquxq7ohwraeq
|
7月前
|
SQL Java 关系型数据库
Mybatis-plus学习笔记
自学笔记
游客cquxq7ohwraeq
148 0
Mybatis-plus学习笔记
游客cquxq7ohwraeq
|
7月前
|
SQL 缓存 Java
mybatis学习笔记（第四部分）
自学笔记
游客cquxq7ohwraeq
29 0
mybatis学习笔记（第四部分）
游客cquxq7ohwraeq
|
7月前
|
SQL Java 关系型数据库
mybatis学习笔记（第三部分）
自学笔记
游客cquxq7ohwraeq
30 0