logo头像

一路过来，不过游牧自己。。

SSM之MyBatis（三）

MyBatis 2017/05/14


在一般的开发中，很多小细节我们还是要去注意的，其中就有一个问题，例如：就是如果字段名和实体类的属性名不一致，这就会造成冲突问题，那如何去解决这种冲突问题呢？其次我们还要处理下表中的一对一和一对多的问题！

一、解决字段名与实体类属性名不相同的冲突

我们就通过代码示例去看看如何处理这种问题：
首先我们准备一下数据库中的表：

1
2
3
4
5
6
7
8
CREATE TABLE orders(
	order_id INT PRIMARY KEY AUTO_INCREMENT,
	order_no VARCHAR(20),
	order_price FLOAT
);
INSERT INTO orders(order_no, order_price) VALUES('aaaa', 23);
INSERT INTO orders(order_no, order_price) VALUES('bbbb', 33);
INSERT INTO orders(order_no, order_price) VALUES('cccc', 22);

这是在数据库中创建了一张orders表，这张表有order_id，order_no，order_price三个元素！
相应的 ，我们也需要这个实体类：

1
2
3
4
5
public class Order {
	private int id;
	private String orderNo;
	private float price;
}

这样就定义的Order的对象类！那，一般的思路都是要将这个类的属性与表中的属性有一个映射关系，但是，我们可以看到属性名他们并不一样：
id与order_id，orderNo与order_no，price与order_price，这些属性名都是不同的，那如何去同步这个名字呢？解决方法有两种：

方式一: 通过在sql语句中定义别名

1
2
3
<select id="selectOrder" parameterType="int" resultType="_Order">
	select order_id id, order_no orderNo,order_price price from orders where order_id=#{id}
</select>

这就是第一种方式，直接在语句中去定义一个别名！这些别名就是类中的属性名！

方式二: 通过

1
2
3
4
5
6
7
8
<select id="selectOrderResultMap" parameterType="int" resultMap="orderResultMap">
	select * from orders where order_id=#{id}
</select>
<resultMap type="_Order" id="orderResultMap">
	<id property="id" column="order_id"/>
	<result property="orderNo" column="order_no"/>
	<result property="price" column="order_price"/>
</resultMap>

这里我们可以看到，我们是把他作为一个结果去处理的，在resultmap中去将这个冲突去解决，注意为什么resultmap中第一行是id呢，这是一个规定，主键用的id,其余统一用的result!

二、实现关联表查询

一对一查询：

关联表问题：很多时候我们查询的表都不单单是一张表，牵涉到多张表的信息，那么就要去解决这种这种关联问题！下面还是通过一个代码示例去解决！

1、提出问题需求：

根据班级id查询班级信息(带老师的信息)，合理设计就是要设计两张表，一张是班级表，一张是老师表，班级表里有老师id的信息，对应着老师的一个id信息！

2、创建表和数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
CREATE TABLE teacher(
	t_id INT PRIMARY KEY AUTO_INCREMENT,
	t_name VARCHAR(20)
);
CREATE TABLE class(
	c_id INT PRIMARY KEY AUTO_INCREMENT,
	c_name VARCHAR(20),
	teacher_id INT
);
ALTER TABLE class ADD CONSTRAINT fk_teacher_id FOREIGN KEY (teacher_id) REFERENCES teacher(t_id);

INSERT INTO teacher(t_name) VALUES('LS1');
INSERT INTO teacher(t_name) VALUES('LS2');

INSERT INTO class(c_name, teacher_id) VALUES('bj_a', 1);
INSERT INTO class(c_name, teacher_id) VALUES('bj_b', 2);

这里就是简单创建了两张表，class表中的teacher_id对应着的就是teacher表中的t_id!

3、定义实体类

接着我们定义两个实体类class和teacher:

1
2
3
4
public class Teacher {
	private int id;
	private String name;
}

和Classes类

1
2
3
4
5
public class Classes {
	private int id;
	private String name;
	private Teacher teacher;
}

4、定义sql映射文件ClassMapper.xml

方式一：嵌套结果：使用嵌套结果映射来处理重复的联合结果的子集封装联表查询的数据(去除重复的数据)

1
2
3
4
5
6
7
8
9
10
11
<select id="getClass" parameterType="int" resultMap="ClassResultMap">
	select * from class c, teacher t where c.teacher_id=t.t_id and  c.c_id=#{id}
</select>
<resultMap type="_Classes" id="ClassResultMap">
	<id property="id" column="c_id"/>
	<result property="name" column="c_name"/>
	<association property="teacher" javaType="_Teacher">
		<id property="id" column="t_id"/>
		<result property="name" column="t_name"/>
	</association>
</resultMap>

讲解下这是什么意思，首先我们得到的是一个resultMap的结果集，然后再结果集中我们注意的是其链接的是teacher对象，关键字用的是association，property是teacher，后面是类型javaType，这里最主要的就是这个association！

方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型
SELECT FROM class WHERE c_id=1;
SELECT FROM teacher WHERE t_id=1 //1 是上一个查询得到的teacher_id的值
这里我们可以知道，分成了两步，第一步找到了class,第二步根据id去找teacher的信息，事先没有链接！

1
2
3
4
5
6
7
8
9
10
11
12
<select id="getClass2" parameterType="int" resultMap="ClassResultMap2">
	select * from class where c_id=#{id}
 </select>
 <resultMap type="_Classes" id="ClassResultMap2">
	<id property="id" column="c_id"/>
	<result property="name" column="c_name"/>
	<association property="teacher" column="teacher_id" select="getTeacher">
</association>
 </resultMap>
 <select id="getTeacher" parameterType="int" resultType="_Teacher">
	SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
 </select>

这里我们仔细看resultMap中最后的association标签后面的，column得到的是teacher的id,select表示他要去哪查询！

5、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
 @Test
public void testOO() {
	SqlSession sqlSession = factory.openSession();
	Classes c = sqlSession.selectOne("com.day03_mybatis.test5.OOMapper.getClass", 1);
	System.out.println(c);
}

@Test
public void testOO2() {
	SqlSession sqlSession = factory.openSession();
	Classes c = sqlSession.selectOne("com.day03_mybatis.test5.OOMapper.getClass2", 1);
	System.out.println(c);
}

这里我们对关键字做个总结：
1、assosiation:用于一对一的关联查询
2、property:对象属性的名称
3、javaType:对象属性的类型
4、column:所对应的外间字段名称
5、select:使用另一个查询分装的结果

一对多关联

1、提出需求：

根据classId查询对应的班级信息,包括学生,老师，我们知道一个班级中有多个学生，一个老师对应一个班级！这是他们之间的关系！

2、数据库建表

在原来的基础上创建一张学生表：

1
2
3
4
5
6
7
8
9
10
11
CREATE TABLE student(
	s_id INT PRIMARY KEY AUTO_INCREMENT,
	s_name VARCHAR(20),
	class_id INT
);
INSERT INTO student(s_name, class_id) VALUES('xs_A', 1);
INSERT INTO student(s_name, class_id) VALUES('xs_B', 1);
INSERT INTO student(s_name, class_id) VALUES('xs_C', 1);
INSERT INTO student(s_name, class_id) VALUES('xs_D', 2);
INSERT INTO student(s_name, class_id) VALUES('xs_E', 2);
INSERT INTO student(s_name, class_id) VALUES('xs_F', 2);

如上，ABC属1班，DEF属于2班！

3、定义实体类：

1
2
3
4
5
6
7
8
9
10
11
public class Student {
	private int id;
	private String name;
}

public class Classes {
	private int id;
	private String name;
	private Teacher teacher;
	private List<Student> students;
}

4、定义sql映射文件ClassMapper.xml

这个也有两种方式，道理都是和上面一样的

(1)方式一: 嵌套结果: 使用嵌套结果映射来处理重复的联合结果的子集

SELECT * FROM class c, teacher t,student s WHERE c.teacher_id=t.t_id AND c.C_id=s.class_id AND c.c_id=1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<select id="getClass3" parameterType="int" resultMap="ClassResultMap3">
	select * from class c, teacher t,student s where c.teacher_id=t.t_id and c.C_id=s.class_id and  c.c_id=#{id}
</select>
<resultMap type="_Classes" id="ClassResultMap3">
	<id property="id" column="c_id"/>
	<result property="name" column="c_name"/>
	<association property="teacher" column="teacher_id" javaType="_Teacher">
		<id property="id" column="t_id"/>
		<result property="name" column="t_name"/>
	</association>
	<!-- ofType指定students集合中的对象类型 -->
	<collection property="students" ofType="_Student">
		<id property="id" column="s_id"/>
		<result property="name" column="s_name"/>
	</collection>
</resultMap>

如上所示，老师和班级是一对一的关系，而班级和学生是一对多的关系，所以我们用了collection关键字，这是个集合，ofType指定students集合中的对象类型，
后面是一样的映射！

（2）方式二：嵌套查询：通过执行另外一个SQL映射语句来返回预期的复杂类型

SELECT * FROM class WHERE c_id=1;
SELECT * FROM teacher WHERE t_id=1   //1 是上一个查询得到的teacher_id的值
SELECT * FROM student WHERE class_id=1  //1是第一个查询得到的c_id字段的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<select id="getClass4" parameterType="int" resultMap="ClassResultMap4">
	select * from class where c_id=#{id}
 </select>
 <resultMap type="_Classes" id="ClassResultMap4">
	<id property="id" column="c_id"/>
	<result property="name" column="c_name"/>
	<association property="teacher" column="teacher_id" javaType="_Teacher" select="getTeacher2"></association>
	<collection property="students" ofType="_Student" column="c_id" select="getStudent"></collection>
 </resultMap>
 <select id="getTeacher2" parameterType="int" resultType="_Teacher">
	SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
 </select>
 <select id="getStudent" parameterType="int" resultType="_Student">
	SELECT s_id id, s_name name FROM student WHERE class_id=#{id}
 </select>

如上所示定义的是不同的select,传过去的column是teacher_id和c_id，其余都差不多！

5、测试

1
2
3
4
5
6
7
8
9
10
11
12
13
 @Test
public void testOM() {
	SqlSession sqlSession = factory.openSession();
	Classes c = sqlSession.selectOne("com.day03_mybatis.test5.OOMapper.getClass3", 1);
	System.out.println(c);
}

@Test
public void testOM2() {
	SqlSession sqlSession = factory.openSession();
	Classes c = sqlSession.selectOne("com.day03_mybatis.test5.OOMapper.getClass4", 1);
	System.out.println(c);
}

关键字解释：
1、collection:做一对多关联查询的
2、ofType:指定集合中元素对象的类型！

多走路，多思考，越努力，越幸运！
———————————————YoungerFary

赏
微信打赏

赞赏是不耍流氓的鼓励

转载声明：商业转载请联系作者获得授权,非商业转载请注明出处 © YoungerFary
Copyright © 2017 | Powered by Hexo | Theme by Snippet