第一章 初始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 <?xml version="1.0" encoding="UTF-8" ?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <!-- 为这个mapper指定一个唯一的namespace,namespace的值习惯上设置成包名+sql映射文件名,这样就能够保证namespace的值是唯一的
4 例如namespace="me.gacl.mapping.userMapper"就是me.gacl.mapping(包名)+userMapper(userMapper.xml文件去除后缀)
5 -->
6 <mapper namespace="me.gacl.mapping.userMapper">
7 <!-- 在select标签中编写查询的SQL语句, 设置select标签的id属性为getUser,id属性值必须是唯一的,不能够重复
8 使用parameterType属性指明查询时使用的参数类型,resultType属性指明查询返回的结果集类型
9 resultType="me.gacl.domain.User"就表示将查询结果封装成一个User类的对象返回
10 User类就是users表所对应的实体类
11 -->
12 <!--
13 根据id查询得到一个user对象
14 -->
15 <select id="getUser" parameterType="int"
16 resultType="me.gacl.domain.User">
17 select * from users where id=#{id}
18 </select>
19
20 <!-- 创建用户(Create) -->
21 <insert id="addUser" parameterType="me.gacl.domain.User">
22 insert into users(name,age) values(#{name},#{age})
23 </insert>
24
25 <!-- 删除用户(Remove) -->
26 <delete id="deleteUser" parameterType="int">
27 delete from users where id=#{id}
28 </delete>
29
30 <!-- 修改用户(Update) -->
31 <update id="updateUser" parameterType="me.gacl.domain.User">
32 update users set name=#{name},age=#{age} where id=#{id}
33 </update>
34
35 <!-- 查询全部用户-->
36 <select id="getAllUsers" resultType="me.gacl.domain.User">
37 select * from users
38 </select>
39
40 </mapper>
单元测试类代码如下:
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<User>返回
79 List<User> 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<User> getAll();
35 }
需要说明的是,我们不需要针对UserMapperI接口去编写具体的实现类代码,这个具体的实现类由MyBatis帮我们动态构建出来,我们只需要直接拿来使用即可。
2、在conf.xml文件中注册这个映射接口
1 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
3 <configuration>
4 <environments default="development">
5 <environment id="development">
6 <transactionManager type="JDBC" />
7 <!-- 配置数据库连接信息 -->
8 <dataSource type="POOLED">
9 <property name="driver" value="com.mysql.jdbc.Driver" />
10 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
11 <property name="username" value="root" />
12 <property name="password" value="XDP" />
13 </dataSource>
14 </environment>
15 </environments>
16
17 <mappers>
18 <!-- 注册userMapper.xml文件,
19 userMapper.xml位于me.gacl.mapping这个包下,所以resource写成me/gacl/mapping/userMapper.xml-->
20 <mapper resource="me/gacl/mapping/userMapper.xml"/>
21 <!-- 注册UserMapper映射接口-->
22 <mapper class="me.gacl.mapping.UserMapperI"/>
23 </mappers>
24
25 </configuration>
单元测试类的代码如下:
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<User>返回
72 List<User> 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 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
3 <configuration>
4 <environments default="development">
5 <environment id="development">
6 <transactionManager type="JDBC" />
7 <!-- 配置数据库连接信息 -->
8 <dataSource type="POOLED">
9 <property name="driver" value="com.mysql.jdbc.Driver" />
10 <property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
11 <property name="username" value="root" />
12 <property name="password" value="XDP" />
13 </dataSource>
14 </environment>
15 </environments>
16
17 </configuration>
其实我们完全可以将数据库的连接配置信息写在一个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 <?xml version="1.0" encoding="UTF-8"?>
2 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
3 <configuration>
4
5 <!-- 引用db.properties配置文件 -->
6 <properties resource="db.properties"/>
7 <!--
8 development : 开发模式
9 work : 工作模式
10 -->
11 <environments default="development">
12 <environment id="development">
13 <transactionManager type="JDBC" />
14 <!-- 配置数据库连接信息 -->
15 <dataSource type="POOLED">
16 <!-- value属性值引用db.properties配置文件中配置的值 -->
17 <property name="driver" value="${driver}" />
18 <property name="url" value="${url}" />
19 <property name="username" value="${name}" />
20 <property name="password" value="${password}" />
21 </dataSource>
22 </environment>
23 </environments>
24
25 </configuration>
二、为实体类定义别名,简化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来代替,这就达到了一个简化实体类引用的目的。
除了可以使用这种方式单独为某一个实体类设置别名之外,我们还可以使用如下的方式批量为某个包下的所有实体类设置别名,如下:
<!-- 配置实体类的别名,配置实体类别名的目的是为了在引用实体类时可以使用实体类的别名来代替实体类,达到简写的目的 -->
<typeAliases>
<!-- 为实体类me.gacl.domain.User配置一个别名_User -->
<!-- <typeAlias type="me.gacl.domain.User" alias="_User"/> -->
<!-- 为me.gacl.domain包下的所有实体类配置别名,MyBatis默认的设置别名的方式就是去除类所在的包后的简单的类名
比如me.gacl.domain.User这个实体类的别名就会被设置成User
-->
<package name="me.gacl.domain"/>
</typeAliases>
<package name="me.gacl.domain"/>就表示为这个包下面的所有实体类设置别名。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 <?xml version="1.0" encoding="UTF-8" ?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <!-- 为这个mapper指定一个唯一的namespace,namespace的值习惯上设置成包名+sql映射文件名,这样就能够保证namespace的值是唯一的
4 例如namespace="me.gacl.mapping.orderMapper"就是me.gacl.mapping(包名)+orderMapper(orderMapper.xml文件去除后缀)
5 -->
6 <mapper namespace="me.gacl.mapping.orderMapper">
7
8 <!--
9 根据id查询得到一个order对象,使用这个查询是查询不到我们想要的结果的,
10 这主要是因为实体类的属性名和数据库的字段名对应不上的原因,因此无法查询出对应的记录
11 -->
12 <select id="getOrderById" parameterType="int"
13 resultType="me.gacl.domain.Order">
14 select * from orders where order_id=#{id}
15 </select>
16
17 <!--
18 根据id查询得到一个order对象,使用这个查询是可以正常查询到我们想要的结果的,
19 这是因为我们将查询的字段名都起一个和实体类属性名相同的别名,这样实体类的属性名和查询结果中的字段名就可以一一对应上
20 -->
21 <select id="selectOrder" parameterType="int"
22 resultType="me.gacl.domain.Order">
23 select order_id id, order_no orderNo,order_price price from orders where order_id=#{id}
24 </select>
25
26 <!--
27 根据id查询得到一个order对象,使用这个查询是可以正常查询到我们想要的结果的,
28 这是因为我们通过<resultMap>映射实体类属性名和表的字段名一一对应关系 -->
29 <select id="selectOrderResultMap" parameterType="int" resultMap="orderResultMap">
30 select * from orders where order_id=#{id}
31 </select>
32 <!--通过<resultMap>映射实体类属性名和表的字段名对应关系 -->
33 <resultMap type="me.gacl.domain.Order" id="orderResultMap">
34 <!-- 用id属性来映射主键字段 -->
35 <id property="id" column="order_id"/>
36 <!-- 用result属性来映射非主键字段 -->
37 <result property="orderNo" column="order_no"/>
38 <result property="price" column="order_price"/>
39 </resultMap>
40
41 </mapper>
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 <?xml version="1.0" encoding="UTF-8" ?>
2 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
3 <!-- 为这个mapper指定一个唯一的namespace,namespace的值习惯上设置成包名+sql映射文件名,这样就能够保证namespace的值是唯一的
4 例如namespace="me.gacl.mapping.classMapper"就是me.gacl.mapping(包名)+classMapper(classMapper.xml文件去除后缀)
5 -->
6 <mapper namespace="me.gacl.mapping.classMapper">
7
8 <!--
9 根据班级id查询班级信息(带老师的信息)
10 ##1. 联表查询
11 SELECT * FROM class c,teacher t WHERE c.teacher_id=t.t_id AND c.c_id=1;
12
13 ##2. 执行两次查询
14 SELECT * FROM class WHERE c_id=1; //teacher_id=1
15 SELECT * FROM teacher WHERE t_id=1;//使用上面得到的teacher_id
16 -->
17
18 <!--
19 方式一:嵌套结果:使用嵌套结果映射来处理重复的联合结果的子集
20 封装联表查询的数据(去除重复的数据)
21 select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=1
22 -->
23 <select id="getClass" parameterType="int" resultMap="ClassResultMap">
24 select * from class c, teacher t where c.teacher_id=t.t_id and c.c_id=#{id}
25 </select>
26 <!-- 使用resultMap映射实体类和字段之间的一一对应关系 -->
27 <resultMap type="me.gacl.domain.Classes" id="ClassResultMap">
28 <id property="id" column="c_id"/>
29 <result property="name" column="c_name"/>
30 <association property="teacher" javaType="me.gacl.domain.Teacher">
31 <id property="id" column="t_id"/>
32 <result property="name" column="t_name"/>
33 </association>
34 </resultMap>
35
36 <!--
37 方式二:嵌套查询:通过执行另外一个SQL映射语句来返回预期的复杂类型
38 SELECT * FROM class WHERE c_id=1;
39 SELECT * FROM teacher WHERE t_id=1 //1 是上一个查询得到的teacher_id的值
40 -->
41 <select id="getClass2" parameterType="int" resultMap="ClassResultMap2">
42 select * from class where c_id=#{id}
43 </select>
44 <!-- 使用resultMap映射实体类和字段之间的一一对应关系 -->
45 <resultMap type="me.gacl.domain.Classes" id="ClassResultMap2">
46 <id property="id" column="c_id"/>
47 <result property="name" column="c_name"/>
48 <association property="teacher" column="teacher_id" select="getTeacher"/>
49 </resultMap>
50
51 <select id="getTeacher" parameterType="int" resultType="me.gacl.domain.Teacher">
52 SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
53 </select>
54
55 </mapper>
在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:使用另一个查询封装的结果
二、一对多关联
2.1、提出需求
根据classId查询对应的班级信息,包括学生,老师
2.2、创建表和数据
在上面的一对一关联查询演示中,我们已经创建了班级表和教师表,因此这里再创建一张学生表
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(‘student_A’, 1);
INSERT INTO student(s_name, class_id) VALUES(‘student_B’, 1);
INSERT INTO student(s_name, class_id) VALUES(‘student_C’, 1);
INSERT INTO student(s_name, class_id) VALUES(‘student_D’, 2);
INSERT INTO student(s_name, class_id) VALUES(‘student_E’, 2);
INSERT INTO student(s_name, class_id) VALUES(‘student_F’, 2);
2.3、定义实体类
1、Student类
1 package me.gacl.domain;
2
3 /**
4 * @author gacl
5 * 定义student表所对应的实体类
6 */
7 public class Student {
8
9 //定义属性,和student表中的字段对应
10 private int id; //id===>s_id
11 private String name; //name===>s_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 “Student [id=” + id + “, name=” + name + “]”;
32 }
33 }
2、修改Classes类,添加一个List students属性,使用一个List集合属性表示班级拥有的学生,如下:
1 package me.gacl.domain;
2
3 import java.util.List;
4
5 /**
6 * @author gacl
7 * 定义class表对应的实体类
8 */
9 public class Classes {
10
11 //定义实体类的属性,与class表中的字段对应
12 private int id; //id===>c_id
13 private String name; //name===>c_name
14
15 /**
16 * class表中有一个teacher_id字段,所以在Classes类中定义一个teacher属性,
17 * 用于维护teacher和class之间的一对一关系,通过这个teacher属性就可以知道这个班级是由哪个老师负责的
18 */
19 private Teacher teacher;
20 //使用一个List集合属性表示班级拥有的学生
21 private List students;
22
23 public int getId() {
24 return id;
25 }
26
27 public void setId(int id) {
28 this.id = id;
29 }
30
31 public String getName() {
32 return name;
33 }
34
35 public void setName(String name) {
36 this.name = name;
37 }
38
39 public Teacher getTeacher() {
40 return teacher;
41 }
42
43 public void setTeacher(Teacher teacher) {
44 this.teacher = teacher;
45 }
46
47 public List getStudents() {
48 return students;
49 }
50
51 public void setStudents(List students) {
52 this.students = students;
53 }
54
55 @Override
56 public String toString() {
57 return “Classes [id=” + id + “, name=” + name + “, teacher=” + teacher
58 + “, students=” + students + “]”;
59 }
60 }
2.4、修改sql映射文件classMapper.xml
添加如下的SQL映射信息
1
4
8
9 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}
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
31
32 select * from class where c_id=#{id}
33
34
35
36
37
38
39
40
41
42 SELECT t_id id, t_name name FROM teacher WHERE t_id=#{id}
43
44
45
46 SELECT s_id id, s_name name FROM student WHERE class_id=#{id}
47
2.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 Test4 {
9
10 @Test
11 public void testGetClass3(){
12 SqlSession sqlSession = MyBatisUtil.getSqlSession();
13 /**
14 * 映射sql的标识字符串,
15 * me.gacl.mapping.classMapper是classMapper.xml文件中mapper标签的namespace属性的值,
16 * getClass3是select标签的id属性值,通过select标签的id属性值就可以找到要执行的SQL
17 */
18 String statement = “me.gacl.mapping.classMapper.getClass3”;//映射sql的标识字符串
19 //执行查询操作,将查询结果自动封装成Classes对象返回
20 Classes clazz = sqlSession.selectOne(statement,1);//查询class表中id为1的记录
21 //使用SqlSession执行完SQL之后需要关闭SqlSession
22 sqlSession.close();
23 //打印结果:Classes [id=1, name=class_a, teacher=Teacher [id=1, name=teacher1], students=[Student [id=1, name=student_A], Student [id=2, name=student_B], Student [id=3, name=student_C]]]
24 System.out.println(clazz);
25 }
26
27 @Test
28 public void testGetClass4(){
29 SqlSession sqlSession = MyBatisUtil.getSqlSession();
30 /**
31 * 映射sql的标识字符串,
32 * me.gacl.mapping.classMapper是classMapper.xml文件中mapper标签的namespace属性的值,
33 * getClass4是select标签的id属性值,通过select标签的id属性值就可以找到要执行的SQL
34 */
35 String statement = “me.gacl.mapping.classMapper.getClass4”;//映射sql的标识字符串
36 //执行查询操作,将查询结果自动封装成Classes对象返回
37 Classes clazz = sqlSession.selectOne(statement,1);//查询class表中id为1的记录
38 //使用SqlSession执行完SQL之后需要关闭SqlSession
39 sqlSession.close();
40 //打印结果:Classes [id=1, name=class_a, teacher=Teacher [id=1, name=teacher1], students=[Student [id=1, name=student_A], Student [id=2, name=student_B], Student [id=3, name=student_C]]]
41 System.out.println(clazz);
42 }
43 }
2.6、MyBatis一对多关联查询总结
MyBatis中使用collection标签来解决一对多的关联查询,ofType属性指定集合中元素的对象类型。
MyBatis学习总结(六)——调用存储过程
一、提出需求
查询得到男性或女性的数量, 如果传入的是0就女性否则是男性
二、准备数据库表和存储过程
1 create table p_user(
2 id int primary key auto_increment,
3 name varchar(10),
4 sex char(2)
5 );
6
7 insert into p_user(name,sex) values(‘A’,”男”);
8 insert into p_user(name,sex) values(‘B’,”女”);
9 insert into p_user(name,sex) values(‘C’,”男”);
10
11 – 创建存储过程(查询得到男性或女性的数量, 如果传入的是0就女性否则是男性)
12 DELIMITER
13CREATEPROCEDUREmybatis.gesusercount(INsexidINT,OUTusercountINT)14BEGIN15IFsexid=0THEN16SELECTCOUNT(∗)FROMmybatis.puserWHEREpuser.sex=′女′INTOusercount;17ELSE18SELECTCOUNT(∗)FROMmybatis.puserWHEREpuser.sex=′男′INTOusercount;19ENDIF;20END21
13
C
R
E
A
T
E
P
R
O
C
E
D
U
R
E
m
y
b
a
t
i
s
.
g
e
s
u
s
e
r
c
o
u
n
t
(
I
N
s
e
x
i
d
I
N
T
,
O
U
T
u
s
e
r
c
o
u
n
t
I
N
T
)
14
B
E
G
I
N
15
I
F
s
e
x
i
d
=
0
T
H
E
N
16
S
E
L
E
C
T
C
O
U
N
T
(
∗
)
F
R
O
M
m
y
b
a
t
i
s
.
p
u
s
e
r
W
H
E
R
E
p
u
s
e
r
.
s
e
x
=
′
女
′
I
N
T
O
u
s
e
r
c
o
u
n
t
;
17
E
L
S
E
18
S
E
L
E
C
T
C
O
U
N
T
(
∗
)
F
R
O
M
m
y
b
a
t
i
s
.
p
u
s
e
r
W
H
E
R
E
p
u
s
e
r
.
s
e
x
=
′
男
′
I
N
T
O
u
s
e
r
c
o
u
n
t
;
19
E
N
D
I
F
;
20
E
N
D
21
22
23 – 调用存储过程
24 DELIMITER ;
25 SET @user_count = 0;
26 CALL mybatis.ges_user_count(1, @user_count);
27 SELECT @user_count;
三、编辑userMapper.xml
编辑userMapper.xml文件,添加如下的配置项
1
4
5 CALL mybatis.ges_user_count(?,?)
6
7
8
12
13
14
15
四、编写单元测试代码
1 package me.gacl.test;
2
3 import java.util.HashMap;
4 import java.util.List;
5 import java.util.Map;
6
7 import me.gacl.custom.model.ConditionUser;
8 import me.gacl.domain.User;
9 import me.gacl.util.MyBatisUtil;
10 import org.apache.ibatis.session.SqlSession;
11 import org.junit.Test;
12
13 /**
14 * @author gacl
15 * 测试调用存储过程
16 */
17 public class Test6 {
18
19 @Test
20 public void testGetUserCount(){
21 SqlSession sqlSession = MyBatisUtil.getSqlSession();
22 /**
23 * 映射sql的标识字符串,
24 * me.gacl.mapping.userMapper是userMapper.xml文件中mapper标签的namespace属性的值,
25 * getUserCount是select标签的id属性值,通过select标签的id属性值就可以找到要执行的SQL
26 */
27 String statement = “me.gacl.mapping.userMapper.getUserCount”;//映射sql的标识字符串
28 Map