在创建一个数据库时, 一部分表用MyISAM引擎, 另一部分表用InnoDB引擎, 这样可以吗?

答案当然是可以的，在创建表的时候,设定引擎即可。因为存储引擎是针对表的。
 CREATE TABLE `test` (
`ID` varchar(40) NOT NULL default '',
`Name` varchar(40) NOT NULL default ''
) ENGINE=InnoDB


 CREATE TABLE `test` (
`ID` varchar(40) NOT NULL default '',
`Name` varchar(40) NOT NULL default ''
) ENGINE=MyISAM

mysql的最大特点就是插件式存储引擎，你用到什么引擎，就指定什么引擎

创建表
我们先创建三个表，之后的查询均以这三个表为例

 根据如图所示的字段及属性建立三张表，建立过程省略。注意sno,cno,在每张表中的格式要一致，就是我们所说的学号和课程号是固定的，一个学生只能有一个学号，一个课程只能有一个课程号。
 插入后的数据格式如下（可以自行改变）：
 course：

 score表：

 student表：
表和表之间的对应关系
一对一
 在一对一关系中，关系表的每一边都只能存在一条记录，每个数据表中的关键字在 对应的关系表中只能存在一条记录或者没有对应的记录。这种关系类似于现实生活中配 偶的关系，如果一个人已经结婚，那么只有一个配偶，如果没有结婚，那么没有配偶。
 假设我们已经创建如图所示的两张表

 从图6.1中可以看到，user表和user_text表是一对一的关系。此处使用一对一的意 义实际上是数据库优化，用户备注字段utext--般有比较多的文字，属于大文本字段，但 这个字段又不是每次都要用到，如果存放到user表中，在查询用户数据的时候会影响user表的查询效率，因此将utext字段单独拆分出来，放到从表中，当需要utext字段时 进行两张表的关联查询即可。
一对多和多对一
 在一对多关系中，主键数据表中只能含有一个记录，而在其关系表中这条记录可以 与一个或者多个记录相关，也可以没有记录与之相关。这种关系类似于现实生活中父母 与子女的关系，每个孩子都有一个父亲，但一个父亲可能有多个孩子，也可能没有孩子。 多对一是从不同的角度来看问题，例如从孩子的角度来看，一个孩子只能有一个父亲， 多个孩子也可能是同一个父亲。
 假设创建如图所示的表：

 从图6.2中可以看到，student表和score表是一对多的关系，每个学生可能有多个 成绩，但一个成绩只能属于一个学生，这就是一对多的关系。如果从score表来看问题, 多个成绩可以属于一个学生，但一个成绩不能属于多个学生，这就是多对一的关系。
多对多的关系
 在多对多关系中，两个数据表里的每条记录都可以和另一个数据表里任意数量的记 录相关。这种关系类似于现实生活中学生与选修课的关系，一个学生可以选择多门选修 课，一门选修课也可以供多个学生选择。
 假设已创建如下图所示的表：

 从图6.3中可以看到，teacher表和stu表都与中间表tea stu关联，且都是一对多的关系，因此teacher表和stu表是多对多的关系，即一个老师可以有多个学生，一个学生 也可以有多个老师，这就是多对多关系的应用场景。
合并结果集
使用UNION关键字合并
 在多表查询中，有时可能需要将两条查询语句的结果合并到一起，MySQL提供了 UNION关键字用于合并结果集。
 （注意：UNION只能合并两个表中相同的字段及类型，对于两个表中不同的字段UNION将无法使用）
 例：
SELECT tname FROM student UNION SELECT tname FROM course
结果：

 由合并结果可知，两表中均有小明和小胡，但是合并后自动过滤掉了重复的数据。
使用UNION ALL 合并
 前面学习了 UNION关键字的用法，UNION ALL关键字与之类似，但使用UNION ALL关键字查询出两张表的数据合并结果集后不会过滤掉重复的数据。
 例：
SELECT tname FROM student UNION ALL SELECT tname FROM course

 可以看到并没有过滤掉重复部分。
连接查询
在关系型数据库中建立数据表时不必确定各个数据之间的关系，通常将每个实体的 所有信息存放在一个表中。当两个或多个表中存在相同意义的字段时，便可以通过这些 字段对不同的表进行连接查询。
笛卡尔积
 笛卡儿积在SQL中的实现方式是交叉连接(cross join),所有连接方式都会先生成 临时笛卡儿积表。笛卡儿积是关系代数里的一个概念，表示两个表中的每一行数据任意 组合。接下来通过一个案例演示笛卡儿积问题，此处使用交叉査询来演示，其语法格式 如下。
SELECT 査询所属表字段 FROM 表 1 CROSS JOIN 表 2;
例：
SELECT s.Sno,s.Sname,ss.Cno,ss.Degree FROM score ss CROSS JOIN student s
（score ss,是给score字段起别名，方便书写用的）
 通过查询我们可以查询到两个表的数据组合，但这并没有实际意义，因为得到的数据是随意排列的。
 只有加上限制条件才会有实际意义。
 例：
SELECT s.Sno,s.Sname,ss.Cno,ss.Degree FROM score ss CROSS JOIN student s 
WHERE ss.sno=s.sno
需要两个表中有相同的字段类型，这样才能建立关系来加上限制条件。
 结果如图：

 可以看到此时查询的数据已经有了对应关系
内连接
内连接的连接杳询结果集中仅包含满足条件的行，在MySQL中默认的连接方式就是内连接。前面学习了交叉连接的语法，但该语法并不是SQL标准中的查询方式，可以 理解为方言。SQL标准中的内连接的语法格式如下。
SELECT 査询所属表字段 FROM 表 1 [INNER] JOIN 表 2
ON表1.关系字段=表2 .关系字段      WHERE查询条件；
在以上语法格式中，INNER JOIN用于连接两个表，其中INNER可以省略，因为 MySQL默认的连接方式就是内连接，ON用来指定连接条件，类似于WHERE关键字。
 例：查询一名学生的课程名、课程号、成绩。
SELECT c.Cno,c.Cname,s.Degree FROM course c JOIN score s 
ON c.`Cno`=s.Cno
分析，该查询 要求查询课成名，课称号以及成家，分别分布在score表和course表中，通过观察两个表中有相同字段CNO，这样我们就可以建立关系来实现内连接。
 查询结果：
外连接
检面讲解了内连接的查询，返回的结果只包含符合査询条件和连接条件的数据，然 而有时还需要包含没有关联的数据，返回的查询结果中不仅包含符合条件的数据，还包 含左表或右表或两个表中的所有数据，此时就需要用到外连接查询。外连接查询包括左 外连接和右外连接两种查询类型，接下来进行详细讲解。
左外连接
 左外连接是以左表中的数据为基准，若左表中有数据且右表中没有数据，则显示左表中的数据，右表中的数据显示为空。左外连接的语法格式如下。
SELECT 查询字段 FROM 表 1 LEFT [OUTER] JOIN 表 2
ON表1.关系字段=表2 .关系字段WHERE查询条件；
例：
 查询学生的姓名，学号，成绩，所学课程的课程号
SELECT stu.Sno,stu.Sname,s.Degree,s.Cno FROM student stu LEFT JOIN score s 
ON stu.Sno=s.Sno
结果：

 其中student为左表，所以最后一行显示左表的数据而右表的数据为空。
右外连接，和左外连接相似，只是右外连接显示多余的右表中的数据，左表中没有的数据显示为空。
 格式：
SELECT 查询字段 FROM 表 1 RIGHT [OUTER] JOIN 表 2
ON表1.关系字段=表2 .关系字段WHERE查询条件；
例：
SELECT stu.Sno,stu.Sname,s.Degree,s.Cno FROM student stu RIGHT JOIN score s 
ON stu.Sno=s.Sno
结果：
多表连接
前面学习了内连接和外连接，它们都是两张表之间的连接查询。实际上随着业务的 复杂，可能需要连接更多的表（3张、4张甚至更多），但表若连接过多会严重影响查询 效率，因此连接查询一般不超出7张表的连接。多表连接的语法格式如下。
SELECT査询字段FROM表1 ［别名］
JOIN表2 ［别名］ON 表1 .关系字段=表2 .关系字段  JOIN 表 m  ON—;
多表的连接方式可以类比内连接，内连接的建立需要两个表中有相同的字段及类型这样才能建立关系。而多表，比如3个表中，若要建立起关系，就需要三个表有相同的字段或者至少有一个表包含其他两个表的字段。
 比如我们的例子中，score表中既有student表的Sno，又有course表中的cno,所有就可以通过score这个表将三个表联系起来。
 例：
 查询一个学生的姓名、出生年月、所学课程名称、成绩。
SELECT stu.Sname,stu.Sbirthday,s.Degree,c.Cname FROM student stu  JOIN score s 
ON stu.Sno=s.Sno JOIN course c ON s.Cno=c.Cno
结果：
自然连接
前面学习了表的连接查询，需要指定表与表之间的连接字段。在SQL标准中还有一种自然连接，不需要指定连接字段，表与表之间列名和数据类型相同的字段会被自动匹 配。自然连接默认按内连接的方式进行查询，语法格式如下。
SELECT查询字段FROM表1 ［别名］NATURAL JOIN表2 ［别名］;
在以上语法格式中，通过NATURAL关键字使两张表进行自然
 连接，默认按内连接 的方式进行查询。
 例：
SELECT stu.Sname,stu.Sbirthday,s.Cno FROM student stu NATURAL JOIN  score s
结果：
子查询
子查询就是嵌套査询，即在SELECT中包含SELECT,子查询可以在WHERE关键字后面作
 为査询条件，也可以在FROM关键字后面作为表来使用。
 例1：
 查询学生出生日期大于1997年的所有信息：
SELECT * FROM student 
WHERE YEAR(Sbirthday)> YEAR((SELECT Sbirthday FROM student WHERE YEAR(Sbirthday)=1997))
该语句会先执行括号里的语句，及查询出生日期在1997年----的学生，然后利用year函数转化为整型后再执行下一个查询语句并执行where条件。
 结果：

 例2：查询和姓名为“li”同学同一个班级同学的所有信息
SELECT * FROM student 
WHERE class= (SELECT class FROM student WHERE Sname ='li')
子查询作为表
前面讲解了将子查询作为査询条件来使用，子査询还可以作为表来使用，即把 SELECT子句放在FROM关键字的后面。在执行查询语句时，首先会执行子查询中的语句，然后将返回结果作为外层查询的数据源使用。
 例：
 查询学号为103学生的姓名，性别，成绩，以及所学课程的课程号
SELECT stu.Sname ,stu.Ssex,s.Cno,s.Degree FROM student stu,(SELECT Cno,Sno, Degree FROM score) s
WHERE  stu.Sno=s.Sno AND stu.Sno='103'
结果：
但是这样不如直接用内连接方便，其实原理是是相似的

	

何为多租户?
多租户这个概念并不是12C的新特性,而是体系架构,多租户架构使得oracle 数据库成为了一个多租户的容器数据库，也就是container database，也就是CDB。
而一个CDB可以包含0个、一个或者多个用户创建的可插入的数据库，也就是pluggable database，也就是PDB，也就是所谓的“租户”。这就像合租房一样，每个租户可以获得其所需的各种资源。也可以说CDB就是各PDB的母体。
多租户架构
         一个CDB包括零个，一个或多个用户创建的可插拔数据库(PDBs)。PDB是模式、模式对象和非模式对象的可移植集合，在Oracle NET客户机看来，Oracle数据库12c之前的所有Oracle数据库都是非CDB。
　　  ORACLE  12C 是世界上第一款基于云计算设计的多租户数据库,底层为一个多租户的架构,支持云计算(共享软硬件资源,降低成本),等同于把多个数据块当成一个数据块来管理,即共享服务器,共享操作系统,共享数据块。
CDB容器
容器是多租户体系结构中数据或元数据的逻辑集合。　

每个CDB都有以下容器：　　
只有一个CDB根容器(也称为根容器)　　　　
cdb根是所有pdb所属的模式、模式对象和非模式对象的集合。根存储Oracle提供的元数据和普通用户。元数据的一个例子是Oracle提供的PL/SQL包的源代码。公共用户是每个容器中已知的数据库用户。根容器名为cdb$root。
只有一个系统容器
系统容器包括根CDB和CDB中的所有PDB。因此，系统容器是CDB本身的逻辑容器。
零个或多个应用程序容器
应用程序容器仅由一个应用程序根组成，PDB插入到该根。虽然系统容器包含cdb根目录和cdb中的所有pdb，但是应用程序容器只包含插入到应用程序根目录中的pdb。应用程序根属于cdb根，没有其他容器。
零个或多个用户创建的PDB
PDB包含特定功能集所需的数据和代码。例如，PDB可以支持特定的应用程序，例如人力资源或销售应用程序。创建CDB时不存在PDB。您可以根据业务需求添加PDB。
PDB正好属于零或一个应用程序容器。如果PDB属于应用程序容器，则它是应用程序PDB。例如，Cust1_PDB和Cust2_PDB应用程序PDB可能属于SaaS_Sales_AC应用程序容器，在这种情况下，它们不属于其他应用程序容器。应用程序种子是可选的应用程序PDB，充当用户创建的PDB模板，使您能够快速创建新的应用程序PDB。
只有一个SEED pdb
SEED PDB是由系统提供的模板，CDB可以使用它来创建新的PDB。SEED pdb被命名为pdb$seed。不能在pdb$seed中添加或修改对象。　　
 多租户的优势
使用多租户体系结构进行数据库整合优势:
降低成本
通过将硬件和数据库基础结构整合到一组后台进程，并高效地共享计算和内存资源，可以降低硬件和维护成本。例如，单个服务器上的100个PDB共享一个数据库实例。
更容易、更快速地移动数据和代码
通过设计，您可以快速地将PDB插入CDB，从CDB中拔下PDB，然后将此PDB插入不同的CDB。您还可以在PDB保持可用时克隆它们。您可以使用任何字符集插入PDB，并在不进行字符集转换的情况下访问它。如果cdb的字符集是cdb的字符集是al32utf8，那么同一cdb中可以存在具有不同数据库字符集的pdb。
更容易管理和监控物理数据库
CDB管理员可以通过为所有托管租户和CDB根执行单个操作(如修补或执行RMAN备份)将环境作为聚合进行管理。简化了备份策略和灾难恢复。
数据和代码分离
虽然PDB合并到一个物理数据库中，但它模拟了非CDB的行为。例如，如果用户错误丢失了关键数据，那么PDB管理员可以使用Oracle Flashback或时间点恢复来检索丢失的数据，而不会影响其他PDB。
确保行政职责分离
普通用户可以连接到其具有足够权限的任何容器，而本地用户仅限于特定的PDB。管理者可以按如下方式划分职责：
管理员使用公用帐户管理CDB或应用程序容器。因为权限包含在授予它的容器中，所以一个PDB上的本地用户对同一个CDB中的其他PDB没有权限。
管理员使用本地帐户管理单个PDB。
易于性能调整
收集单个数据库的性能指标比收集多个数据库的性能指标更容易。一个SGA的尺寸比100个SGA的尺寸更容易。
 更少的数据库补丁和升级
对一个数据库应用补丁比对100个数据库应用补丁更容易，对一个数据库进行升级也比对100个数据库进行升级更容易。
多租户架构对可管理性的好处
 更容易升级数据和代码
例如，不需要将CDB从一个数据库版本升级到另一个数据库版本，您可以从现有CDB中快速拔出PDB，然后将其从更高版本插入到新创建的CDB中。
更容易在服务器之间迁移
要执行负载平衡或满足SLA，您可以将应用程序数据库从本地数据中心迁移到云，或者在同一环境中的两个服务器之间迁移。
防止PDB中的数据损坏
您可以将PDB闪存回特定于SCN或PDB的还原点，而不影响其他PDB。此功能类似于非CDB的闪回数据库功能。
能够在单个位置安装、管理和升级特定于应用程序的数据和元数据
您可以将一组特定于应用程序的PDB定义为单个组件，称为应用程序容器。然后可以在此容器中定义一个或多个应用程序。每个应用程序都是此应用程序容器中共享的一组命名的、版本控制的通用元数据和数据。
例如，SaaS供应商的每个客户都可以拥有自己的应用程序PDB。每个应用程序PDB可能都有相同定义的表，名为sales-mlt，每个PDB中有不同的数据。PDB可以共享一个名为“国家”的数据链接公共对象，每个PDB中都有相同的数据。作为应用程序管理员，您可以管理主应用程序定义，以便每个新客户都获得具有相同对象的PDB，并且对现有模式的每个更改(例如，添加新表或更改表的定义)都适用于共享应用程序定义的所有PDB。
 与Oracle数据库资源管理器集成
在多租户环境中，一个问题是运行在同一服务器上的PDB之间的系统资源争用。另一个问题是限制资源使用以获得更一致、可预测的性能。要解决此类资源争用、使用和监视问题，请使用Oracle数据库资源管理器。
CREATE PLUGGABLE DATABASE hrpdb
 ADMIN USER dba1 IDENTIFIED BY password;
CREATE PLUGGABLE DATABASE salespdb FROM hrpdb;
CREATE PLUGGABLE DATABASE salespdb USING '/disk1/usr/salespdb.xml' NOCOPY;
CREATE PLUGGABLE DATABASE hrpdb FROM hrpdb@lnk_to_source RELOCATE;
CREATE PLUGGABLE DATABASE pdb1 AS PROXY FROM pdb1@pdb1_link;
Containers in a CDB
SQL> COL NAME FORMAT A15
SQL> SELECT NAME, CON_ID, DBID, CON_UID, GUID FROM V$CONTAINERS ORDER BY CON_ID;
NAME                CON_ID       DBID    CON_UID GUID
--------------- ---------- ---------- ---------- --------------------------------
CDB$ROOT                 1 1895287725          1 2003321EDD4F60D6E0534E40E40A41C5
PDB$SEED                 2 2795386505 2795386505 200AC90679F07B55E05396C0E40A23FE
SAAS_SALES_AC            3 1239646423 1239646423 200B4CE0A8DC1D24E05396C0E40AF8EE
SALESPDB                 4 3692549634 3692549634 200B4928319C1BCCE05396C0E40A2432
HRPDB                    5 3784483090 3784483090 200B4928319D1BCCE05396C0E40A2432
Creating a Proxy PDB
CONNECT sales_admin@saas_sales_ac
Password: ***********
CREATE PLUGGABLE DATABASE sales_sync_pdb AS PROXY FROM saas_sales_test_ac@cdb_dev_rem;
Database Link Between PDBs
Unmixed Data Dictionary Metadata in a Non-CDB
Mixed Data Dictionary Metadata in a Non-CDB
Data Dictionary Architecture in a CDB
User Accounts in a CDB
Users and Schemas in a CDB
 Saas Use Case
Creating an Application Root
-- Create the application container called saas_sales_ac
CREATE PLUGGABLE DATABASE saas_sales_ac AS APPLICATION CONTAINER
  ADMIN USER saas_sales_ac_adm IDENTIFIED BY manager; 
-- Open the application root
ALTER PLUGGABLE DATABASE saas_sales_ac OPEN;
-- Set the current container to saas_sales_ac
ALTER SESSION SET CONTAINER = saas_sales_ac;
COL NAME FORMAT a15
COL ROOT FORMAT a4
SELECT CON_ID, NAME, APPLICATION_ROOT AS ROOT, 
       APPLICATION_PDB AS PDB,
FROM   V$CONTAINERS;
    CON_ID NAME            ROOT PDB
---------- --------------- ---- ---
         3 SAAS_SALES_AC   YESNO
SQL> SELECT NAME, CDB, CON_ID FROM V$DATABASE;
select name ,open_mode from v$pdbs ; 查看状态
结束语：
人生就像一滴水，非要落下才后悔！
	

目录
resultMap的作用
创建一对一数据库表
创建实体对象
一对一  级联属性  使用
延迟加载
创建一对多数据库
创建实体Bean对象
 一对多，立即加载
一对多，懒加载
双向关联

resultMap的作用
原来我们查询都是返回一个简单的JavaBean对象。我们可以直接使用ResultType定义返回在的类型。
但是如果我们查询的结果返回在的JavaBean中，又包含一个javaBean，或者包含一个javaBean对象的集合。
那么这个时候，只能使用ResultMap来自定义返回的结果。

创建一对一数据库表
## 一对一数据表
## 创建锁表
create table t_lock(
	`id` int primary key auto_increment,
	`name` varchar(50)
);


## 创建钥匙表
create table t_key(
	`id` int primary key auto_increment,
	`name` varchar(50),
	`lock_id` int ,
	foreign key(`lock_id`) references t_lock(`id`)
);

## 插入初始化数据
insert into t_lock(`name`) values('淘宝');
insert into t_lock(`name`) values('京东');
insert into t_lock(`name`) values('拼多多');

insert into t_key(`name`,`lock_id`) values('天猫',1);
insert into t_key(`name`,`lock_id`) values('狗东',2);
insert into t_key(`name`,`lock_id`) values('拼夕夕',3);


创建实体对象
锁实体Bean
public class Lock {

	private int id;
private String name;

钥匙实体Bean
public class Key {

	private int id;
	private String name;
	private Lock lock;


一对一  级联属性  使用
1、创建KeyMapper接口
public interface KeyMapper {

	public Key queryKeyByIdForSample(int id);

}

2、创建KeyMapper.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="com.ddh.dao.KeyMapper">

	<!-- resultMap标签可以自定义结果集。定义成你需要的bean对象的结果
			type属性表示当前这个ResultMap会封装什么对象返回
			id	属性定义一个唯一的标识，方便别人使用。
			
	 -->
	<resultMap type="com.ddh.pojo.Key" id="queryKeyByIdForSample_resultMap">
		<!-- 
			id专门用来映射id主键列
		 -->
		<id column="id" property="id"/>
		<!-- 
			result标签映射非主键列
		 -->
		<result column="name" property="name"/>
		<!-- 级联映射 -->
		<result column="lock_id" property="lock.id"/>
		<result column="lock_name" property="lock.name"/>
	</resultMap>

<!-- 	public Key queryKeyByIdForSample(int id); -->
	<!-- 
		当前select查询，结果是 resultMap所指向的id对应的resultMap集合
	 -->
	<select id="queryKeyByIdForSample" resultMap="queryKeyByIdForSample_resultMap">
		select 
			t_key.*,t_lock.name lock_name
		from 
			t_key left join t_lock
		on 
			t_key.lock_id = t_lock.id
		where 
			t_key.id = #{id}
	</select>
	
</mapper>

3、<association /> 嵌套结果集映射配置
	<resultMap type="com.ddh.pojo.Key" id="queryKeyByIdForSample_resultMap2">
		<!-- 
			id专门用来映射id主键列
		 -->
		<id column="id" property="id"/>
		<!-- 
			result标签映射非主键列
		 -->
		<result column="name" property="name"/>
		<!-- association 标签专门 映射Bean对象中的子对象（一个Bean）
				专门用来配置一对一标签
		 -->
		<association property="lock" javaType="com.ddh.pojo.Lock">
			<!-- 把lock_id列注入到lock属性对象中的id属性值 -->
			<id column="lock_id" property="id"/>
			<!-- 把查询的lock_name列的值给lock子对象中的name属性 -->
			<result column="lock_name" property="name"/>
		</association>
	</resultMap>


4、<association /> 定义分步查询
在KeyMapper接口中创建一个分步查询方法：

	/*
	 * 一开始我只需要使用key表的信息，所以我只查key表的信息。
	 * <br/>
	 * 当我们使用时候需要用到key对象对应的Lock对象的信息的时候。我再查Lock的信息
	 * 
	 */
	public Key queryKeyByIdForTwoStep(int id);
创建LockMapper接口


public interface LocKMapper {
	public Lock queryLockById(int lockId);
}


5、在keyMapper.xml配置文件中：

	<resultMap type="com.ddh.pojo.Key" id="queryKeyByIdForTwoStep_resultMap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<!-- 
			association 标签是推荐用来映射一对一关联
			property是你要映射的子对象的变量名
			javaType 表示你要映射的这个子对象的具体类型
			select 属性表示你要执行的查询语句
			column 属性设置你要传递给select设置的查询语句用的参数列
		 -->
		<association property="lock" javaType="com.ddh.pojo.Lock" 
			select="com.ddh.dao.LocKMapper.queryLockById" column="lock_id"
		/>
	</resultMap>
	
<!-- 	public Key queryKeyByIdForTwoStep(int id); -->
	<select id="queryKeyByIdForTwoStep" resultMap="queryKeyByIdForTwoStep_resultMap">
		select id,name,lock_id from t_key where id = #{id}
	</select>


6、创建LockMapper.xml配置文件内容如下：

<!-- 	public Lock queryLockById(int lockId); -->
	<select id="queryLockById" resultType="com.ddh.pojo.Lock">
		select id,name from t_lock where id = #{id}
	</select>


延迟加载
延迟加载在一定程序上可以减少很多没有必要的查询。给数据库服务器提升性能上的优化。
要启用延迟加载，需要在mybatis-config.xml配置文件中，添加如下两个全局的settings配置。

		<!-- 打开延迟加载的开关 -->  
       <setting name="lazyLoadingEnabled" value="true" />  
       <!-- 将积极加载改为消极加载  按需加载 -->  
<setting name="aggressiveLazyLoading" value="false"/>  
懒加载功能，mybatis3.2.8版本，需要同时引入两个jar包
  cglib-2.2.2.jar   asm-3.3.1.jar


创建一对多数据库
### 创建班级表
create table t_clazz(
	`id` int primary key auto_increment,
	`name` varchar(50)
);

## 插入班级信息
insert into t_clazz(`name`) values('javaEE20170228');
insert into t_clazz(`name`) values('javaEE20170325');
insert into t_clazz(`name`) values('javaEE20170420');
insert into t_clazz(`name`) values('javaEE20170515');

## 创建学生表
create table t_student(
	`id` int primary key auto_increment,
	`name` varchar(50),
	`clazz_id` int,
	foreign key(`clazz_id`) references t_clazz(`id`)
);

## 插入班级信息
insert into t_student(`name`,`clazz_id`) values('stu0228_1',1);
insert into t_student(`name`,`clazz_id`) values('stu0228_2',1);
insert into t_student(`name`,`clazz_id`) values('stu0228_3',1);
insert into t_student(`name`,`clazz_id`) values('stu0325_1',2);
insert into t_student(`name`,`clazz_id`) values('stu0325_2',2);
insert into t_student(`name`,`clazz_id`) values('stu0420_1',3);


创建实体Bean对象
学生
public class Student {
	private int id;
	private String name;

班级
public class Clazz {
	private int id;
	private String name;
	private List<Student> stuList;


 一对多，立即加载
1、创建ClazzMapper接口
public interface ClazzMapper {

	public Clazz queryClazzByIdForSample(int id);

}

2、编写ClazzMapper.xml配置文件：
	<resultMap type="com.ddh.pojo.Clazz" id="queryClazzByIdForSample_resultMap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<!-- 
			collection 标签专门用来映射集合属性
				property	表示你要映射的集合属性名是什么
		 -->
		<collection property="stuList" ofType="com.ddh.pojo.Student">
			<id column="stu_id" property="id"/>
			<result column="stu_name" property="name"/>
		</collection>
	</resultMap>
	
<!-- 	public Clazz queryClazzByIdForSample(int id); -->
	<select id="queryClazzByIdForSample" resultMap="queryClazzByIdForSample_resultMap">
		select 
			t_clazz.*,t_student.id stu_id,t_student.name stu_name
		from 
			t_clazz left join t_student
		on 
			t_clazz.id = t_student.clazz_id
		where 
			t_clazz.id = #{id}
	</select>

一对多，懒加载
1、再创建一个StudentMapper接口

public interface StudentMapper {
	public List<Student> queryStudentsByClazzId(int clazzId);
}


2、创建StudentMapper.xml配置文件：

<!-- 	public List<Student> queryStudentsByClazzId(int clazzId); -->
	<select id="queryStudentsByClazzId" resultType="com.ddh.pojo.Student">
		select id,name from t_student where clazz_id = #{clazzid}
	</select>


3、在ClazzMapper接口中添加一个方法实现懒加载

	/**
	 * 	我要分两次查询，
	 * 一次只查常用数据，班级信息<br/>
	 * 当我需要使用学生信息的时候。再查询一次<br/>
	 * 还要用到懒加载
	 */
	public Clazz queryClazzByIdForTwoStepLazy(int id);

4、在ClazzMapper.xml中进行配置：

	<resultMap type="com.ddh.pojo.Clazz" id="queryClazzByIdForTwoStepLazy_resultMap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<!-- 
			collection 是专门映射集合的标签
				property 属性设置你要设置和集合的属性名
				ofType是 这个集合中每个元素的具体类型
				select 是你要查询的语句
				column 属性设置你要执行的select对应的查询语句需要的参数列
		 -->
		<collection property="stuList" ofType="com.ddh.pojo.Student" 
			select="com.ddh.dao.StudentMapper.queryStudentsByClazzId"
			column="id"
		/>
	</resultMap>
<!-- 	public Clazz queryClazzByIdForTwoStepLazy(int id); -->
	<select id="queryClazzByIdForTwoStepLazy" resultMap="queryClazzByIdForTwoStepLazy_resultMap">
		select id,name from t_clazz where id = #{id}
	</select>


双向关联
1、在StudentMapper接口中添加一个懒加载的方法：

	public List<Student> queryStudentByClazzIdForLazy(int clazzId);

2、然后在StudentMapper.xml配置文件中

	<resultMap type="com.ddh.pojo.Student" id="queryStudentByClazzIdForLazy_resultMap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<!-- association标签是专门用来映射了个子对象的标签 -->
		<association property="clazz" javaType="com.ddh.pojo.Clazz" 
			select="com.ddh.dao.ClazzMapper.queryClazzByIdForTwoStepLazy"
			column="clazz_id"
		/>
	</resultMap>
<!-- public List<Student> queryStudentByClazzIdForLazy(int clazzId); -->
	<select id="queryStudentByClazzIdForLazy" resultMap="queryStudentByClazzIdForLazy_resultMap">
		select id,name,clazz_id from t_student where clazz_id = #{clazzId}
	</select>


3、再修改原来懒加载查询班级里，懒加载学生的select属性

	<resultMap type="com.ddh.pojo.Clazz" id="queryClazzByIdForTwoStepLazy_resultMap">
		<id column="id" property="id"/>
		<result column="name" property="name"/>
		<!-- 
			collection 是专门映射集合的标签
				property 属性设置你要设置和集合的属性名
				ofType是 这个集合中每个元素的具体类型
				select 是你要查询的语句
				column 属性设置你要执行的select对应的查询语句需要的参数列
		 -->
		<collection property="stuList" ofType="com.ddh.pojo.Student" 
			select="com.ddh.dao.StudentMapper.queryStudentByClazzIdForLazy"
			column="id"
		/>
	</resultMap>


如果双向关联出现死循环，如何防止双向关联呢？
1、不要调用toString方法
2、在你需要终止关联的时候，最后一次查询使用resultType