第一章 初始MyBatis

---

第一章 初始MyBatis

---

一、Mybatis介绍
　　
　　MyBatis是一个支持普通SQL查询，存储过程和高级映射的优秀持久层框架。MyBatis消除了几乎所有的JDBC代码和参数的手工设置以及对结果集的检索封装。MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和Java的POJO（Plain Old Java Objects，普通的Java对象）映射成数据库中的记录。
　　二、mybatis快速入门
2.1、准备开发环境
1、创建测试项目，普通java项目或者是JavaWeb项目均可，如下图所示：

2、添加相应的jar包
　　【mybatis】
　　mybatis-3.1.1.jar
　　【MYSQL驱动包】
　　　　mysql-connector-java-5.1.7-bin.jar
　　　　
　　　
3、创建数据库和表，针对MySQL数据库
　　SQL脚本如下：
create database mybatis;
use mybatis;
CREATE TABLE users(id INT PRIMARY KEY AUTO_INCREMENT, NAME VARCHAR(20), age INT);
INSERT INTO users(NAME, age) VALUES(‘孤傲苍狼’, 27);
INSERT INTO users(NAME, age) VALUES(‘白虎神皇’, 27);
　　将SQL脚本在MySQL数据库中执行，完成创建数据库和表的操作，如下：
　　
　　到此，前期的开发环境准备工作全部完成。
2.2、使用MyBatis查询表中的数据
　　1、添加Mybatis的配置文件conf.xml
　　在src目录下创建一个conf.xml文件，如下图所示：
　　
　　conf.xml文件中的内容如下：
　　
2、定义表所对应的实体类，如下图所示：

　User类的代码如下：

　3、定义操作users表的sql映射文件userMapper.xml
　　创建一个me.gacl.mapping包，专门用于存放sql映射文件，在包中创建一个userMapper.xml文件，如下图所示：
　　　userMapper.xml文件的内容如下：
　　　
　　　4、在conf.xml文件中注册userMapper.xml文件
　　　　5、编写测试代码：执行定义的select语句
　　创建一个Test1类，编写如下的测试代码：
　　

MyBatis学习总结(二)——使用MyBatis对表执行CRUD操作

　　一、使用MyBatis对表执行CRUD操作——基于XML的实现
1、定义sql映射xml文件
　　userMapper.xml文件的内容如下：

    1 
     2 
 3 
 6 
 7     
12     
15     
17         select * from users where id=#{id}
18     
19     
20     
21     
22         insert into users(name,age) values(#{name},#{age})
23     
24     
25     
26     
27         delete from users where id=#{id}
28     
29     
30     
31     
32         update users set name=#{name},age=#{age} where id=#{id}
33     
34     
35     
36     
37         select * from users
38     
39     
40 

单元测试类代码如下：

 1 package me.gacl.test;
 2 
 3 import java.util.List;
 4 import me.gacl.domain.User;
 5 import me.gacl.util.MyBatisUtil;
 6 import org.apache.ibatis.session.SqlSession;
 7 import org.junit.Test;
 8 
 9 public class TestCRUDByXmlMapper {
10 
11     @Test
12     public void testAdd(){
13         //SqlSession sqlSession = MyBatisUtil.getSqlSession(false);
14         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);
15         /**
16          * 映射sql的标识字符串，
17          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值，
18          * addUser是insert标签的id属性值，通过insert标签的id属性值就可以找到要执行的SQL
19          */
20         String statement = "me.gacl.mapping.userMapper.addUser";//映射sql的标识字符串
21         User user = new User();
22         user.setName("用户孤傲苍狼");
23         user.setAge(20);
24         //执行插入操作
25         int retResult = sqlSession.insert(statement,user);
26         //手动提交事务
27         //sqlSession.commit();
28         //使用SqlSession执行完SQL之后需要关闭SqlSession
29         sqlSession.close();
30         System.out.println(retResult);
31     }
32     
33     @Test
34     public void testUpdate(){
35         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);
36         /**
37          * 映射sql的标识字符串，
38          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值，
39          * updateUser是update标签的id属性值，通过update标签的id属性值就可以找到要执行的SQL
40          */
41         String statement = "me.gacl.mapping.userMapper.updateUser";//映射sql的标识字符串
42         User user = new User();
43         user.setId(3);
44         user.setName("孤傲苍狼");
45         user.setAge(25);
46         //执行修改操作
47         int retResult = sqlSession.update(statement,user);
48         //使用SqlSession执行完SQL之后需要关闭SqlSession
49         sqlSession.close();
50         System.out.println(retResult);
51     }
52     
53     @Test
54     public void testDelete(){
55         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);
56         /**
57          * 映射sql的标识字符串，
58          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值，
59          * deleteUser是delete标签的id属性值，通过delete标签的id属性值就可以找到要执行的SQL
60          */
61         String statement = "me.gacl.mapping.userMapper.deleteUser";//映射sql的标识字符串
62         //执行删除操作
63         int retResult = sqlSession.delete(statement,5);
64         //使用SqlSession执行完SQL之后需要关闭SqlSession
65         sqlSession.close();
66         System.out.println(retResult);
67     }
68     
69     @Test
70     public void testGetAll(){
71         SqlSession sqlSession = MyBatisUtil.getSqlSession();
72         /**
73          * 映射sql的标识字符串，
74          * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值，
75          * getAllUsers是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL
76          */
77         String statement = "me.gacl.mapping.userMapper.getAllUsers";//映射sql的标识字符串
78         //执行查询操作，将查询结果自动封装成List返回
79         List lstUsers = sqlSession.selectList(statement);
80         //使用SqlSession执行完SQL之后需要关闭SqlSession
81         sqlSession.close();
82         System.out.println(lstUsers);
83     }
84 }

二、使用MyBatis对表执行CRUD操作——基于注解的实现
　　1、定义sql映射的接口
　　UserMapperI接口的代码如下：

 1 package me.gacl.mapping;
 2 
 3 import java.util.List;
 4 import me.gacl.domain.User;
 5 import org.apache.ibatis.annotations.Delete;
 6 import org.apache.ibatis.annotations.Insert;
 7 import org.apache.ibatis.annotations.Select;
 8 import org.apache.ibatis.annotations.Update;
 9 
10 /**
11  * @author gacl
12  * 定义sql映射的接口，使用注解指明方法要执行的SQL
13  */
14 public interface UserMapperI {
15 
16     //使用@Insert注解指明add方法要执行的SQL
17     @Insert("insert into users(name, age) values(#{name}, #{age})")
18     public int add(User user);
19     
20     //使用@Delete注解指明deleteById方法要执行的SQL
21     @Delete("delete from users where id=#{id}")
22     public int deleteById(int id);
23     
24     //使用@Update注解指明update方法要执行的SQL
25     @Update("update users set name=#{name},age=#{age} where id=#{id}")
26     public int update(User user);
27     
28     //使用@Select注解指明getById方法要执行的SQL
29     @Select("select * from users where id=#{id}")
30     public User getById(int id);
31     
32     //使用@Select注解指明getAll方法要执行的SQL
33     @Select("select * from users")
34     public List getAll();
35 }

　　需要说明的是，我们不需要针对UserMapperI接口去编写具体的实现类代码，这个具体的实现类由MyBatis帮我们动态构建出来，我们只需要直接拿来使用即可。
　　2、在conf.xml文件中注册这个映射接口

 1 
 2 
 3 
 4     
 5         
 6             
 7             
 8             
 9                 
10                 
11                 
12                 
13             
14         
15     
16     
17     
18         
20         
21         
22         
23     
24     
25 

　　单元测试类的代码如下：

 1 package me.gacl.test;
 2 
 3 import java.util.List;
 4 import me.gacl.domain.User;
 5 import me.gacl.mapping.UserMapperI;
 6 import me.gacl.util.MyBatisUtil;
 7 import org.apache.ibatis.session.SqlSession;
 8 import org.junit.Test;
 9 
10 public class TestCRUDByAnnotationMapper {
11 
12     @Test
13     public void testAdd(){
14         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);
15         //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
16         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);
17         User user = new User();
18         user.setName("用户xdp");
19         user.setAge(20);
20         int add = mapper.add(user);
21         //使用SqlSession执行完SQL之后需要关闭SqlSession
22         sqlSession.close();
23         System.out.println(add);
24     }
25     
26     @Test
27     public void testUpdate(){
28         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);
29         //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
30         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);
31         User user = new User();
32         user.setId(3);
33         user.setName("孤傲苍狼_xdp");
34         user.setAge(26);
35         //执行修改操作
36         int retResult = mapper.update(user);
37         //使用SqlSession执行完SQL之后需要关闭SqlSession
38         sqlSession.close();
39         System.out.println(retResult);
40     }
41     
42     @Test
43     public void testDelete(){
44         SqlSession sqlSession = MyBatisUtil.getSqlSession(true);
45         //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
46         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);
47         //执行删除操作
48         int retResult = mapper.deleteById(7);
49         //使用SqlSession执行完SQL之后需要关闭SqlSession
50         sqlSession.close();
51         System.out.println(retResult);
52     }
53     
54     @Test
55     public void testGetUser(){
56         SqlSession sqlSession = MyBatisUtil.getSqlSession();
57         //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
58         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);
59         //执行查询操作，将查询结果自动封装成User返回
60         User user = mapper.getById(8);
61         //使用SqlSession执行完SQL之后需要关闭SqlSession
62         sqlSession.close();
63         System.out.println(user);
64     }
65     
66     @Test
67     public void testGetAll(){
68         SqlSession sqlSession = MyBatisUtil.getSqlSession();
69         //得到UserMapperI接口的实现类对象，UserMapperI接口的实现类对象由sqlSession.getMapper(UserMapperI.class)动态构建出来
70         UserMapperI mapper = sqlSession.getMapper(UserMapperI.class);
71         //执行查询操作，将查询结果自动封装成List返回
72         List lstUsers = mapper.getAll();
73         //使用SqlSession执行完SQL之后需要关闭SqlSession
74         sqlSession.close();
75         System.out.println(lstUsers);
76     }
77 }

　　用到的MyBatisUtil工具类代码如下：

 1 package me.gacl.util;
 2 
 3 import java.io.InputStream;
 4 
 5 import org.apache.ibatis.session.SqlSession;
 6 import org.apache.ibatis.session.SqlSessionFactory;
 7 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 8 
 9 public class MyBatisUtil {
10 
11     /**
12      * 获取SqlSessionFactory
13      * @return SqlSessionFactory
14      */
15     public static SqlSessionFactory getSqlSessionFactory() {
16         String resource = "conf.xml";
17         InputStream is = MyBatisUtil.class.getClassLoader().getResourceAsStream(resource);
18         SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(is);
19         return factory;
20     }
21     
22     /**
23      * 获取SqlSession
24      * @return SqlSession
25      */
26     public static SqlSession getSqlSession() {
27         return getSqlSessionFactory().openSession();
28     }
29     
30     /**
31      * 获取SqlSession
32      * @param isAutoCommit 
33      *         true 表示创建的SqlSession对象在执行完SQL之后会自动提交事务
34      *         false 表示创建的SqlSession对象在执行完SQL之后不会自动提交事务，这时就需要我们手动调用sqlSession.commit()提交事务
35      * @return SqlSession
36      */
37     public static SqlSession getSqlSession(boolean isAutoCommit) {
38         return getSqlSessionFactory().openSession(isAutoCommit);
39     }
40 }                    

MyBatis学习总结(三)——优化MyBatis配置文件中的配置
一、连接数据库的配置单独放在一个properties文件中
　　之前，我们是直接将数据库的连接配置信息写在了MyBatis的conf.xml文件中，如下：

 1 
 2 
 3 
 4     
 5         
 6             
 7             
 8             
 9                 
10                 
11                 
12                 
13             
14         
15     
16     
17 

　　其实我们完全可以将数据库的连接配置信息写在一个properties文件中，然后在conf.xml文件中引用properties文件，具体做法如下：
　　1、在src目录下新建一个db.properties文件，如下图所示：
　　

    　在db.properties文件编写连接数据库需要使用到的数据库驱动，连接URL地址，用户名，密码，如下：
1 driver=com.mysql.jdbc.Driver
2 url=jdbc:mysql://localhost:3306/mybatis
3 name=root
4 password=XDP
　　2、在MyBatis的conf.xml文件中引用db.properties文件，如下：

 1 
 2 
 3 
 4 
 5     
 6     
 7     
11     
12         
13             
14             
15             
16                 
17                 
18                 
19                 
20                 
21             
22         
23     
24     
25 

二、为实体类定义别名，简化sql映射xml文件中的引用
　　之前，我们在sql映射xml文件中的引用实体类时，需要写上实体类的全类名(包名+类名)，如下：


insert into users(name,age) values(#{name},#{age})

　　parameterType=”me.gacl.domain.User”这里写的实体类User的全类名me.gacl.domain.User，每次都写这么一长串内容挺麻烦的，而我们希望能够简写成下面的形式

insert into users(name,age) values(#{name},#{age})

　　parameterType=”_User”这样写就简单多了，为了达到这种效果，我们需要在conf.xml文件中为实体类=”me.gacl.domain.User”定义一个别名为”_User”，具体做法如下：
　　在conf.xml文件中标签中添加如下配置：



　　这样就可以为me.gacl.domain.User类定义了一个别名为_User，以后_User就代表了me.gacl.domain.User类，这样sql映射xml文件中的凡是需要引用me.gacl.domain.User类的地方都可以使用_User来代替，这就达到了一个简化实体类引用的目的。
　　除了可以使用这种方式单独为某一个实体类设置别名之外，我们还可以使用如下的方式批量为某个包下的所有实体类设置别名，如下：

    
        
            
            
            
            
        

　　就表示为这个包下面的所有实体类设置别名。MyBatis默认的设置别名的方式就是去除类所在的包后的简单的类名，比如me.gacl.domain.User这个实体类的别名就会被设置成User。
　　MyBatis学习总结(四)——解决字段名与实体类属性名不相同的冲突

　　在平时的开发中，我们表中的字段名和表对应实体类的属性名称不一定都是完全相同的，下面来演示一下这种情况下的如何解决字段名与实体类属性名不相同的冲突。
一、准备演示需要使用的表和数据

    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);

二、定义实体类

 1 package me.gacl.domain;
 2 
 3 /**
 4  * @author gacl
 5  * 定义orders表对应的实体类
 6  */
 7 public class Order {
 8     /**
 9      * 
10     CREATE TABLE orders(
11         order_id INT PRIMARY KEY AUTO_INCREMENT,
12         order_no VARCHAR(20), 
13         order_price FLOAT
14     );
15      */
16     
17     //Order实体类中属性名和orders表中的字段名是不一样的
18     private int id;                //id===>order_id
19     private String orderNo;        //orderNo===>order_no
20     private float price;        //price===>order_price
21 
22     public int getId() {
23         return id;
24     }
25 
26     public void setId(int id) {
27         this.id = id;
28     }
29 
30     public String getOrderNo() {
31         return orderNo;
32     }
33 
34     public void setOrderNo(String orderNo) {
35         this.orderNo = orderNo;
36     }
37 
38     public float getPrice() {
39         return price;
40     }
41 
42     public void setPrice(float price) {
43         this.price = price;
44     }
45 
46     @Override
47     public String toString() {
48         return "Order [id=" + id + ", orderNo=" + orderNo + ", price=" + price+ "]";
49     }
50 }

三、编写测试代码
3.1、编写SQL的xml映射文件
　　1、创建一个orderMapper.xml文件，orderMapper.xml的内容如下：

 1 
 2 
 3 
 6 
 7     
 8     
12     
14         select * from orders where order_id=#{id}
15     
16     
17     
21     
23         select order_id id, order_no orderNo,order_price price from orders where order_id=#{id}
24     
25     
26     
29     
30         select * from orders where order_id=#{id}
31     
32     
33     
34         
35         
36         
37         
38         
39     
40     
41 

　　2、在conf.xml文件中注册orderMapper.xml映射文件




3.2、编写单元测试代码

 1 package me.gacl.test;
 2 
 3 import me.gacl.domain.Order;
 4 import me.gacl.util.MyBatisUtil;
 5 import org.apache.ibatis.session.SqlSession;
 6 import org.junit.Test;
 7 
 8 public class Test2 {
 9     
10     @Test
11     public void testGetOrderById(){
12         SqlSession sqlSession = MyBatisUtil.getSqlSession();
13         /**
14          * 映射sql的标识字符串，
15          * me.gacl.mapping.orderMapper是orderMapper.xml文件中mapper标签的namespace属性的值，
16          * getOrderById是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL
17          */
18         String statement = "me.gacl.mapping.orderMapper.getOrderById";//映射sql的标识字符串
19         //执行查询操作，将查询结果自动封装成Order对象返回
20         Order order = sqlSession.selectOne(statement,1);//查询orders表中id为1的记录
21         //使用SqlSession执行完SQL之后需要关闭SqlSession
22         sqlSession.close();
23         System.out.println(order);//打印结果：null，也就是没有查询出相应的记录
24     }
25     
26     @Test
27     public void testGetOrderById2(){
28         SqlSession sqlSession = MyBatisUtil.getSqlSession();
29         /**
30          * 映射sql的标识字符串，
31          * me.gacl.mapping.orderMapper是orderMapper.xml文件中mapper标签的namespace属性的值，
32          * selectOrder是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL
33          */
34         String statement = "me.gacl.mapping.orderMapper.selectOrder";//映射sql的标识字符串
35         //执行查询操作，将查询结果自动封装成Order对象返回
36         Order order = sqlSession.selectOne(statement,1);//查询orders表中id为1的记录
37         //使用SqlSession执行完SQL之后需要关闭SqlSession
38         sqlSession.close();
39         System.out.println(order);//打印结果：Order [id=1, orderNo=aaaa, price=23.0]
40     }
41     
42     @Test
43     public void testGetOrderById3(){
44         SqlSession sqlSession = MyBatisUtil.getSqlSession();
45         /**
46          * 映射sql的标识字符串，
47          * me.gacl.mapping.orderMapper是orderMapper.xml文件中mapper标签的namespace属性的值，
48          * selectOrderResultMap是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL
49          */
50         String statement = "me.gacl.mapping.orderMapper.selectOrderResultMap";//映射sql的标识字符串
51         //执行查询操作，将查询结果自动封装成Order对象返回
52         Order order = sqlSession.selectOne(statement,1);//查询orders表中id为1的记录
53         //使用SqlSession执行完SQL之后需要关闭SqlSession
54         sqlSession.close();
55         System.out.println(order);//打印结果：Order [id=1, orderNo=aaaa, price=23.0]
56     }
57 }

　　执行单元测试的结果：
　　1、testGetOrderById方法执行查询后返回一个null。
　　2、testGetOrderById2方法和testGetOrderById3方法执行查询后可以正常得到想要的结果。
四、总结
　　上面的测试代码演示当实体类中的属性名和表中的字段名不一致时，使用MyBatis进行查询操作时无法查询出相应的结果的问题以及针对问题采用的两种办法：
　　解决办法一: 通过在查询的sql语句中定义字段名的别名，让字段名的别名和实体类的属性名一致，这样就可以表的字段名和实体类的属性名一一对应上了，这种方式是通过在sql语句中定义别名来解决字段名和属性名的映射关系的。
　　解决办法二: 通过来映射字段名和实体类属性名的一一对应关系。这种方式是使用MyBatis提供的解决方式来解决字段名和属性名的映射关系的。
MyBatis学习总结(五)——实现关联表查询
一、一对一关联
1.1、提出需求
　　根据班级id查询班级信息(带老师的信息)
1.2、创建表和数据
　　创建一张教师表和班级表，这里我们假设一个老师只负责教一个班，那么老师和班级之间的关系就是一种一对一的关系。

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

　表之间的关系如下：
1.3、定义实体类
　　1、Teacher类，Teacher类是teacher表对应的实体类。

 1 package me.gacl.domain;
 2 
 3 /**
 4  * @author gacl
 5  * 定义teacher表对应的实体类
 6  */
 7 public class Teacher {
 8 
 9     //定义实体类的属性，与teacher表中的字段对应
10     private int id;            //id===>t_id
11     private String name;    //name===>t_name
12 
13     public int getId() {
14         return id;
15     }
16 
17     public void setId(int id) {
18         this.id = id;
19     }
20 
21     public String getName() {
22         return name;
23     }
24 
25     public void setName(String name) {
26         this.name = name;
27     }
28 
29     @Override
30     public String toString() {
31         return "Teacher [id=" + id + ", name=" + name + "]";
32     }
33 }

　　2、Classes类，Classes类是class表对应的实体类

 1 package me.gacl.domain;
 2 
 3 /**
 4  * @author gacl
 5  * 定义class表对应的实体类
 6  */
 7 public class Classes {
 8 
 9     //定义实体类的属性，与class表中的字段对应
10     private int id;            //id===>c_id
11     private String name;    //name===>c_name
12     
13     /**
14      * class表中有一个teacher_id字段，所以在Classes类中定义一个teacher属性，
15      * 用于维护teacher和class之间的一对一关系，通过这个teacher属性就可以知道这个班级是由哪个老师负责的
16      */
17     private Teacher teacher;
18 
19     public int getId() {
20         return id;
21     }
22 
23     public void setId(int id) {
24         this.id = id;
25     }
26 
27     public String getName() {
28         return name;
29     }
30 
31     public void setName(String name) {
32         this.name = name;
33     }
34 
35     public Teacher getTeacher() {
36         return teacher;
37     }
38 
39     public void setTeacher(Teacher teacher) {
40         this.teacher = teacher;
41     }
42 
43     @Override
44     public String toString() {
45         return "Classes [id=" + id + ", name=" + name + ", teacher=" + teacher+ "]";
46     }
47 }

1.4、定义sql映射文件classMapper.xml

 1 
 2 
 3 
 6 
 7 
 8     
17 
18     
23     
24         select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=#{id}
25     
26     
27     
28         
29         
30         
31             
32             
33         
34     
35     
36     
41      
42         select * from class where c_id=#{id}
43      
44      
45      
46         
47         
48         
49      
50      
51      
52         SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
53      
54 
55 

　　在conf.xml文件中注册classMapper.xml




1.5、编写单元测试代码

 1 package me.gacl.test;
 2 
 3 import me.gacl.domain.Classes;
 4 import me.gacl.util.MyBatisUtil;
 5 import org.apache.ibatis.session.SqlSession;
 6 import org.junit.Test;
 7 
 8 public class Test3 {
 9     
10     @Test
11     public void testGetClass(){
12         SqlSession sqlSession = MyBatisUtil.getSqlSession();
13         /**
14          * 映射sql的标识字符串，
15          * me.gacl.mapping.classMapper是classMapper.xml文件中mapper标签的namespace属性的值，
16          * getClass是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL
17          */
18         String statement = "me.gacl.mapping.classMapper.getClass";//映射sql的标识字符串
19         //执行查询操作，将查询结果自动封装成Classes对象返回
20         Classes clazz = sqlSession.selectOne(statement,1);//查询class表中id为1的记录
21         //使用SqlSession执行完SQL之后需要关闭SqlSession
22         sqlSession.close();
23         System.out.println(clazz);//打印结果：Classes [id=1, name=class_a, teacher=Teacher [id=1, name=teacher1]]
24     }
25     
26     @Test
27     public void testGetClass2(){
28         SqlSession sqlSession = MyBatisUtil.getSqlSession();
29         /**
30          * 映射sql的标识字符串，
31          * me.gacl.mapping.classMapper是classMapper.xml文件中mapper标签的namespace属性的值，
32          * getClass2是select标签的id属性值，通过select标签的id属性值就可以找到要执行的SQL
33          */
34         String statement = "me.gacl.mapping.classMapper.getClass2";//映射sql的标识字符串
35         //执行查询操作，将查询结果自动封装成Classes对象返回
36         Classes clazz = sqlSession.selectOne(statement,1);//查询class表中id为1的记录
37         //使用SqlSession执行完SQL之后需要关闭SqlSession
38         sqlSession.close();
39         System.out.println(clazz);//打印结果：Classes [id=1, name=class_a, teacher=Teacher [id=1, name=teacher1]]
40     }
41 }

1.6、MyBatis一对一关联查询总结
　　MyBatis中使用association标签来解决一对一的关联查询，association标签可用的属性如下：
property:对象属性的名称
javaType:对象属性的类型
column:所对应的外键字段名称
select:使用另一个查询封装的结果