MyBatis 入门
1 Mybatis是什么？
MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis，实质上Mybatis对ibatis进行一些改进。
MyBatis是一个优秀的持久层框架，它对jdbc的操作数据库的过程进行封装，使开发者只需要关注 SQL 本身，而不需要花费精力去处理例如注册驱动、创建connection、创建statement、手动设置参数、结果集检索等jdbc繁杂的过程代码。
Mybatis通过xml或注解的方式将要执行的各种statement（statement、preparedStatemnt、CallableStatement）配置起来，并通过java对象和statement中的sql进行映射生成最终执行的sql语句，最后由mybatis框架执行sql并将结果映射成java对象并返回。
2 分析原生态jdbc程序中存在的问题
2.1 原生态Jdbc程序代码
public static void main(String[] args) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
//1、加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
//2、通过驱动管理类获取数据库链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis?characterEncoding=utf-8", "root", "root");
//3、定义sql语句 ?表示占位符
String sql = "select * from user where username = ?";
//4、获取预处理statement
preparedStatement = connection.prepareStatement(sql);
//5、设置参数，第一个参数为sql语句中参数的序号（从1开始），第二个参数为设置的参数值
preparedStatement.setString(1, "王五");
//6、向数据库发出sql执行查询，查询出结果集
resultSet = preparedStatement.executeQuery();
//7、遍历查询结果集
while(resultSet.next()){
System.out.println(resultSet.getString("id")+" "+resultSet.getString("username"));
}
} catch (Exception e) {
e.printStackTrace();
}finally{
//8、释放资源
if(resultSet!=null){
try {
resultSet.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(preparedStatement!=null){
try {
preparedStatement.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(connection!=null){
try {
connection.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
2.2 Jdbc问题总结
1、 数据库连接频繁开启和关闭，会严重影响数据库的性能。
2、 代码中存在硬编码，分别是数据库部分的硬编码和SQL执行部分的硬编码。
3 Mybatis框架原理（核心）
3.1 框架图
3.2 分析结论
1、 mybatis配置文件，包括Mybatis全局配置文件和Mybatis映射文件，其中全局配置文件配置了数据源、事务等信息；映射文件配置了SQL执行相关的 信息。
2、 mybatis通过读取配置文件信息（全局配置文件和映射文件），构造出SqlSessionFactory，即会话工厂。
3、 通过SqlSessionFactory，可以创建SqlSession即会话。Mybatis是通过SqlSession来操作数据库的。
4、 SqlSession本身不能直接操作数据库，它是通过底层的Executor执行器接口来操作数据库的。Executor接口有两个实现类，一个是普通执行器，一个是缓存执行器（默认）。
5、 Executor执行器要处理的SQL信息是封装到一个底层对象MappedStatement中。该对象包括：SQL语句、输入参数映射信息、输出结果集映射信息。其中输入参数和输出结果的映射类型包括java的简单类型、HashMap集合对象、POJO对象类型。
4 Mybatis入门程序
Mybatis课程的所有代码程序将通过一个订单商品案例来进行讲解。
4.1 需求
对用户信息的增删改查操作。
1、 根据用户ID来查询用户信息；
2、 根据用户名称来模糊查询用户信息列表；
3、 添加用户
4、 删除用户（练习）
5、 修改用户（练习）
4.2 环境准备
l Jdk环境：jdk1.7.0_72
l Ide环境：eclipse indigo
l 数据库环境：MySQL 5.1
l Mybatis：3.2.7
4.2.1 数据库初始化
4.2.1.1 数据库脚本
1、 执行sql_table.sql脚本，创建数据库表；
2、 执行sql_data.sql初始化测试数据。
4.2.1.2 数据库表
订单商品案例的数据库脚本中，总共包含四张表，其中入门程序只使用user表：
用户表的表结构如下：
4.2.2 下载mybatis
mybaits的代码由github.com管理，下载地址：https://github.com/mybatis/mybatis-3/releases
Lib：mybatis的依赖包
Mybatis-3.2.7.jar：mybatis的核心包
Mybatis-3.2.7.pdf：mybatis的使用指南
4.3 工程搭建（三步）
4.3.1 第一步：创建java工程
用eclipse创建一个java工程，jdk使用1.7.0_72。
4.3.2 第二步：加入jar包
加入以下四部分jar包，其中junit的jar包，是非必须的。
l Mybatis核心包
l Mybatis依赖包
l MySQL驱动包
l Junit单元测试包（单元测试需要的包）
4.3.3 第三步：添加log4j.properties文件
Mybatis使用的日志包是log4j的，所以需要添加log4j.properties。
在classpath下创建log4j.properties如下：
文件内容可以从mybatis-3.2.7.pdf中拷贝
# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n
日志级别在开发阶段设置成DEBUG，在生产阶段设置成INFO或者ERROR。
4.4 编程步骤
1、 创建PO类，根据需求创建；
2、 创建全局配置文件SqlMapConfig.xml；
3、 编写映射文件；
4、 加载映射文件，在SqlMapConfig.xml中进行加载；
5、 编写测试程序，即编写Java代码，连接并操作数据库。
思路：
a) 读取配置文件；
b) 通过SqlSessionFactoryBuilder创建SqlSessionFactory会话工厂。
c) 通过SqlSessionFactory创建SqlSession。
d) 调用SqlSession的操作数据库方法。
e) 关闭SqlSession。
4.5 代码开发
4.5.1 创建PO类
创建的po类的属性要和数据库中表的列名一致（如果表中的列名是带有下划线，那么po类中对应的的属性名要采用驼峰式命名）
User.java类如下：
Public class User {
private int id;
private String username;// 用户姓名
private String sex;// 性别
private Date birthday;// 生日
private String address;// 地址
get/set……
4.5.2 创建SqlMapConfig.xml配置文件
在classpath下，创建SqlMapConfig.xml文件
SqlMapConfig.xml（文件头可以从mybatis-3.2.7.pdf文档的2.1.2小节中拷贝）：
xml version="1.0" encoding="UTF-8" ?>
DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">transactionManager>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
dataSource>
environment>
environments>
configuration>
4.5.3 需求开发
在classpath下，创建sqlmap文件夹。在sqlmap目录下，创建User.xml映射文件。
Mybatis的映射文件头（可以从mybatis-3.2.7.pdf文件中拷贝）：
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">
4.5.3.1 根据用户ID来查询用户信息
4.5.3.1.1 编写映射文件
在User.xml中添加以下代码：
<mapper namespace="test">
<select id="findUserById" parameterType="int" resultType="cn.itcast.mybatis.po.User">
SELECT * FROM USER WHERE id = #{id}
select>
mapper>
4.5.3.1.2 加载映射文件
在SqlMapConfig.xml中，添加以下代码：
<mappers>
<mapper resource="sqlmap/User.xml"/>
mappers>
4.5.3.1.3 编写测试程序
public class MybatisFirst {
@Test
public void findUserByIdTest() throws Exception{
//1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
//2、根据配置文件创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
//3、SqlSessionFactory创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
//4、SqlSession执行statement，并返回映射结果
//第一个参数：statement的id，建议：namespace.statementId（确保唯一）
//第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
User user = sqlSession.selectOne("findUserById", 1);
//打印输出结果集
System.out.println(user);
//5、关闭SqlSession
sqlSession.close();
}
}
4.5.3.2 根据用户名称来模糊查询用户信息列表
4.5.3.2.1 编写映射文件
在User.xml中，添加以下内容：
<select id="findUsersByName" parameterType="String" resultType="cn.itcast.mybatis.po.User">
SELECT * FROM USER WHERE username LIKE '%${value}%'
select>
4.5.3.2.2 加载映射文件
已配置，此处无需再次配置。
4.5.3.2.3 编写测试程序
@Test
public void findUsersByNameTest() throws Exception {
// 1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 3、SqlSessionFactory创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4、SqlSession执行statement，并返回映射结果
// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
List
// 打印输出结果集
System.out.println(users);
// 5、关闭SqlSession
sqlSession.close();
}
4.5.3.3 添加用户
4.5.3.3.1 编写映射文件
<insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">
INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
insert>
4.5.3.3.2 加载映射文件
已配置，此处无需再次配置。
4.5.3.3.3 编写测试程序
注意：增删改操作要对SqlSession执行commit操作。
@Test
public void insertUserTest() throws Exception {
// 1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
.build(inputStream);
// 3、SqlSessionFactory创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4、SqlSession执行statement，并返回映射结果
//构建user参数，没有赋值的属性采取默认值
User user = new User();
user.setUsername("东哥1");
user.setAddress("清河宝盛西里");
// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
sqlSession.insert("insertUser", user);
//切记：增删改操作时，要执行commit操作
sqlSession.commit();
// 5、关闭SqlSession
sqlSession.close();
}
4.5.3.3.4 主键返回之MySQL自增主键
思路：
Ø MySQL自增主键，是指在insert之前MySQL会自动生成一个自增的主键。
Ø 我们可以通过MySQL的函数获取到刚插入的自增主键:
LAST_INSERT_ID()
Ø 这个函数是在insert语句之后去调用。
修改映射文件：
<insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">
<selectKey keyProperty="id" resultType="int" order="AFTER">
SELECT LAST_INSERT_ID()
selectKey>
INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
insert>
4.5.3.3.5 主键返回之MySQL函数UUID（自己练习）
注意：使用mysql的uuid()函数生成主键，需要修改表中id字段类型为string，长度设置成35位。
<insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">
<selectKey keyProperty="id" resultType="string" order="BEFORE">
SELECT UUID()
selectKey>
INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
insert>
4.5.3.3.6 主键返回之Oracle序列返回（自己练习）
<insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">
<selectKey keyProperty="id" resultType="int" order="BEFORE">
SELECT user_seq.nextval() FROM dual
selectKey>
INSERT INTO USER(id,username,sex,birthday,address) VALUES (#{id},#{username},#{sex},#{birthday},#{address})
insert>
4.5.3.4 删除用户
4.5.3.4.1 编写映射文件
<delete id="deleteUser" parameterType="int">
DELETE FROM USER WHERE id= #{id}
delete>
4.5.3.4.2 加载映射文件
已配置，此处无需再次配置。
4.5.3.4.3 编写测试程序
@Test
public void deleteUserTest() throws Exception{
// 1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
.build(inputStream);
// 3、SqlSessionFactory创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4、SqlSession执行statement，并返回映射结果
// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
sqlSession.delete("test.deleteUser", 30);
//切记：增删改操作时，要执行commit操作
sqlSession.commit();
// 5、关闭SqlSession
sqlSession.close();
}
4.5.3.5 修改用户
4.5.3.5.1 编写映射文件
<update id="updateUser" parameterType="cn.itcast.mybatis.po.User">
UPDATE USER SET username = #{username},sex=#{sex} WHERE id=#{id}
update>
4.5.3.5.2 加载映射文件
已配置，此处无需再次配置。
4.5.3.5.3 编写测试程序
@Test
public void updateUserTest() throws Exception{
// 1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 3、SqlSessionFactory创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4、SqlSession执行statement，并返回映射结果
//构建user参数，没有赋值的属性采取默认值
User user = new User();
user.setId(28);
user.setUsername("东哥11");
user.setAddress("清河宝盛西里");
// 第一个参数：statement的id，建议：namespace.statementId（确保唯一）
// 第二个参数：入参的值，它的类型要和映射文件中对应的statement的入参类型一致
sqlSession.update("test.updateUser", user);
//切记：增删改操作时，要执行commit操作
sqlSession.commit();
// 5、关闭SqlSession
sqlSession.close();
}
4.6 小结
4.6.1 parameterType和resultType
parameterType指定输入参数的java类型，可以填写别名或Java类的全限定名。
resultType指定输出结果的java类型，可以填写别名或Java类的全限定名。
4.6.2 #{}和${}
#{}：相当于预处理中的占位符？。
#{}里面的参数表示接收java输入参数的名称。
#{}可以接受HashMap、简单类型、POJO类型的参数。
当接受简单类型的参数时，#{}里面可以是value，也可以是其他。
#{}可以防止SQL注入。
${}：相当于拼接SQL串，对传入的值不做任何解释的原样输出。
${}会引起SQL注入，所以要谨慎使用。
${}可以接受HashMap、简单类型、POJO类型的参数。
当接受简单类型的参数时，${}里面只能是value。
4.6.3 selectOne和selectList
selectOne：只能查询0或1条记录，大于1条记录的话，会报错：
selectList：可以查询0或N条记录
5 Mybatis开发dao
Mybatis在项目中主要使用的地方就是开发dao（数据访问层），所以下面讲解一下mybatis开发dao的方法。有两种方式：原始dao开发方式、mapper代理开发方式（推荐）。
5.1 需求
1、 根据用户ID来查询用户信息；
2、 根据用户名称来模糊查询用户信息列表；
3、 添加用户；
5.2 原始dao开发方式
5.2.1 思路
程序员需要写dao接口和dao实现类。
5.2.2 编程步骤
1、 根据需求创建po类
2、 编写全局配置文件
3、 根据需求编写映射文件
4、 加载映射文件
5、 编写dao接口
6、 编写dao实现类
7、 编写测试代码
5.2.3 程序编写
步骤中的1、2、3、4都在入门程序中进行了编写，此处不需要重新编写。
5.2.3.1 开发dao接口
public interface UserDao {
//根据用户ID来查询用户信息
public User findUserById(int id);
//根据用户名称来模糊查询用户信息列表
public List
//添加用户
public void insertUser(User user);
}
5.2.3.2 开发dao实现类
5.2.3.2.1 SqlSession使用范围
通过入门程序，大家可以看出，在测试代码中，有大量的重复代码。所以我们第一反应就是想给它抽取出共性的部分，但是SqlSession、SqlSessionFactory、SqlSessionFactoryBuilder有着各自的生命周期，因为这些生命周期的不同，抽取时要有针对性的处理。
所以在抽取之前，我们先来了解并总结下它们三个的生命周期。
5.2.3.2.1.1 SqlSessionFactoryBuilder
它的作用只是通过配置文件创建SqlSessionFactory，所以只要创建出SqlSessionFactory，它就可以销毁了。所以说，它的生命周期是在方法之内。
5.2.3.2.1.2 SqlSessionFactory
它的作用是创建SqlSession的工厂，工厂一旦创建，除非应用停掉，不要销毁。
所以说它的生命周期是在应用范围内。这里可以通过单例模式来管理它。
在mybatis整合spring之后，最好的处理方式是把SqlSessionFactory交由spring来做单例管理。
5.2.3.2.1.3 SqlSession
SqlSession是一个面向用户（程序员）的接口，它的默认实现是DefaultSqlSession。
Mybatis是通过SqlSession来操作数据库的。SqlSession中不仅包含要处理的SQL信息，还包括一些数据信息，所以说它是线程不安全的，因此它最佳的生命周期范围是在方法体之内。
5.2.3.2.2 Dao实现类代码
需要向dao实现类中注入SqlSessionFactory，在方法体内通过SqlSessionFactory创建SqlSession
要注意SqlSession和SqlSessionFactory的生命周期。
public class UserDaoImpl implements UserDao {
//注入SqlSessionFactory
private SqlSessionFactory sqlSessionFactory;
//使用构造方法来初始化SqlSessionFactory
public UserDaoImpl(SqlSessionFactory sqlSessionFactory){
this.sqlSessionFactory = sqlSessionFactory;
}
@Override
public User findUserById(int id) {
//通过工厂，在方法内部获取SqlSession，这样就可以避免线程不安全
SqlSession sqlSession = sqlSessionFactory.openSession();
//返回结果集
return sqlSession.selectOne("test.findUserById", id);
}
@Override
public List
//通过工厂，在方法内部获取SqlSession，这样就可以避免线程不安全
SqlSession sqlSession = sqlSessionFactory.openSession();
return sqlSession.selectList("test.findUsersByName", username);
}
@Override
public void insertUser(User user) {
//通过工厂，在方法内部获取SqlSession，这样就可以避免线程不安全
SqlSession sqlSession = sqlSessionFactory.openSession();
sqlSession.insert("test.insertUser", user);
}
}
5.2.3.3 编写测试代码
public class UserDaoTest {
//声明全局的SqlSessionFactory
private SqlSessionFactory sqlSessionFactory;
@Before
public void setUp() throws Exception {
// 1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
}
@Test
public void testFindUserById() {
//构造UserDao对象
UserDao userDao = new UserDaoImpl(sqlSessionFactory);
//调用UserDao对象的方法
User user = userDao.findUserById(1);
System.out.println(user);
}
@Test
public void testFindUsersByName() {
//构造UserDao对象
UserDao userDao = new UserDaoImpl(sqlSessionFactory);
//调用UserDao对象的方法
List
System.out.println(list);
}
@Test
public void testInsertUser() {
//构造UserDao对象
UserDao userDao = new UserDaoImpl(sqlSessionFactory);
//构造User对象
User user = new User();
user.setUsername("东哥3");
user.setAddress("清河宝盛西里3");
//调用UserDao对象的方法
userDao.insertUser(user);
System.out.println(user.getId());
}
}
5.2.4 问题总结
原始dao开发存在一些问题：
Ø 存在一定量的模板代码。比如：通过SqlSessionFactory创建SqlSession；调用SqlSession的方法操作数据库；关闭Sqlsession。
Ø 存在一些硬编码。调用SqlSession的方法操作数据库时，需要指定statement的id，这里存在了硬编码。
5.3 Mapper代理开发方式（推荐）
Mapper代理的开发方式，程序员只需要编写mapper接口（相当于dao接口）即可。Mybatis会自动的为mapper接口生成动态代理实现类。
不过要实现mapper代理的开发方式，需要遵循一些开发规范。
5.3.1 开发规范
1、 mapper接口的全限定名要和mapper映射文件的namespace的值相同。
2、 mapper接口的方法名称要和mapper映射文件中的statement的id相同；
3、 mapper接口的方法参数只能有一个，且类型要和mapper映射文件中statement的parameterType的值保持一致。
4、 mapper接口的返回值类型要和mapper映射文件中statement的resultType值或resultMap中的type值保持一致；
通过规范式的开发mapper接口，可以解决原始dao开发当中存在的问题：
1、 模板代码已经去掉；
2、 剩下去不掉的操作数据库的代码，其实就是一行代码。这行代码中硬编码的部分，通过第一和第二个规范就可以解决。
5.3.2 编程步骤
1、 根据需求创建po类
2、 编写全局配置文件
3、 根据需求编写映射文件
4、 加载映射文件
5、 编写mapper接口
6、 编写测试代码
5.3.3 程序编写
步骤中的1、2都在入门程序中进行了编写，此处不需要重新编写。
5.3.3.1 编写mapper映射文件
重新定义mapper映射文件UserMapper.xml（内容同Users.xml，除了namespace的值），放到新创建的目录mapper下。
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="cn.itcast.mybatis.mapper.UserMapper">
<select id="findUserById" parameterType="int" resultType="cn.itcast.mybatis.po.User">
SELECT * FROM USER WHERE id = #{id}
select>
<select id="findUsersByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">
SELECT * FROM USER WHERE username LIKE '%${value}%'
select>
<insert id="insertUser" parameterType="cn.itcast.mybatis.po.User">
<selectKey keyProperty="id" resultType="int" order="AFTER">
SELECT LAST_INSERT_ID()
selectKey>
INSERT INTO USER(username,sex,birthday,address) VALUES (#{username},#{sex},#{birthday},#{address})
insert>
mapper>
5.3.3.2 加载mapper映射文件
<mappers>
<mapper resource="sqlmap/User.xml"/>
<mapper resource="mapper/UserMapper.xml"/>
mappers>
5.3.3.3 编写mapper接口
内容同UserDao接口一样：
public interface UserMapper {
//根据用户ID来查询用户信息
public User findUserById(int id);
//根据用户名称来模糊查询用户信息列表
public List
//添加用户
public void insertUser(User user);
}
5.3.3.4 编写测试代码
public class UserMapperTest {
// 声明全局的SqlSessionFactory
private SqlSessionFactory sqlSessionFactory;
@Before
public void setUp() throws Exception {
// 1、读取配置文件
String resource = "SqlMapConfig.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
// 2、根据配置文件创建SqlSessionFactory
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
}
@Test
public void testFindUserById() {
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession，获取mapper接口的动态代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 调用mapper对象的方法
User user = userMapper.findUserById(1);
System.out.println(user);
// 关闭SqlSession
sqlSession.close();
}
@Test
public void testFindUsersByName() {
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession，获取mapper接口的动态代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 调用mapper对象的方法
List
System.out.println(list);
// 关闭SqlSession
sqlSession.close();
}
@Test
public void testInsertUser() {
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession，获取mapper接口的动态代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//构造User对象
User user = new User();
user.setUsername("东哥4");
user.setAddress("清河宝盛西里4");
// 调用mapper对象的方法
userMapper.insertUser(user);
System.out.println(user.getId());
//执行SqlSession的commit操作
sqlSession.commit();
// 关闭SqlSession
sqlSession.close();
}
}
6 Mybatis全局配置文件
SqlMapConfig.xml是mybatis的全局配置文件，它的名称可以是任意命名的。
6.1 全部配置内容
SqlMapConfig.xml的配置内容和顺序如下（顺序不能乱）：
Properties（属性）
Settings（全局参数设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境信息集合）
environment（单个环境信息）
transactionManager（事物）
dataSource（数据源）
mappers（映射器）
6.2 常用配置详解
6.2.1 Properties
SqlMapConfig.xml文件中可以引用java属性文件中的配置信息
db.properties配置信息如下：
db.driver=com.mysql.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=utf8
db.username=root
db.password=root
SqlMapConfig.xml使用properties标签后，如下所示：
<properties resource="db.properties" />
<environments default="development">
<environment id="development">
<transactionManager type="JDBC">transactionManager>
<dataSource type="POOLED">
<property name="driver" value="${db.driver}"/>
<property name="url" value="${db.url}"/>
<property name="username" value="${db.username}"/>
<property name="password" value="${db.password}"/>
dataSource>
environment>
environments>
使用${}，可以引用已经加载的java配置文件中的信息。
注意：mybatis将按照下面的顺序加载属性：
u Properties标签体内定义的属性首先被读取
u Properties引用的属性会被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值
u parameterType接收的值会最后被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值
所以说，mybatis读取属性的顺序由高到低分别是：parameterType接收的属性值、properties引用的属性、properties标签内定义的属性。
6.2.2 Settings
mybatis全局配置参数，全局参数将会影响mybatis的运行行为。
| Setting(设置) | Description（描述） | Valid Values(验证值组) | Default(默认值) |
| cacheEnabled | 在全局范围内启用或禁用缓存配置任何映射器在此配置下。 | true | false | TRUE |
| lazyLoadingEnabled | 在全局范围内启用或禁用延迟加载。禁用时，所有协会将热加载。 | true | false | TRUE |
| aggressiveLazyLoading | 启用时，有延迟加载属性的对象将被完全加载后调用懒惰的任何属性。否则，每一个属性是按需加载。 | true | false | TRUE |
| multipleResultSetsEnabled | 允许或不允许从一个单独的语句（需要兼容的驱动程序）要返回多个结果集。 | true | false | TRUE |
| useColumnLabel | 使用列标签，而不是列名。在这方面，不同的驱动有不同的行为。参考驱动文档或测试两种方法来决定你的驱动程序的行为如何。 | true | false | TRUE |
| useGeneratedKeys | 允许JDBC支持生成的密钥。兼容的驱动程序是必需的。此设置强制生成的键被使用，如果设置为true，一些驱动会不兼容性，但仍然可以工作。 | true | false | FALSE |
| autoMappingBehavior | 指定MyBatis的应如何自动映射列到字段/属性。NONE自动映射。 PARTIAL只会自动映射结果没有嵌套结果映射定义里面。 FULL会自动映射的结果映射任何复杂的（包含嵌套或其他）。 | NONE, PARTIAL, FULL | PARTIAL |
| defaultExecutorType | 配置默认执行人。SIMPLE执行人确实没有什么特别的。 REUSE执行器重用准备好的语句。 BATCH执行器重用语句和批处理更新。 | SIMPLE REUSE BATCH | SIMPLE |
| defaultStatementTimeout | 设置驱动程序等待一个数据库响应的秒数。 | Any positive integer | Not Set (null) |
| safeRowBoundsEnabled | 允许使用嵌套的语句RowBounds。 | true | false | FALSE |
| mapUnderscoreToCamelCase | 从经典的数据库列名A_COLUMN启用自动映射到骆驼标识的经典的Java属性名aColumn。 | true | false | FALSE |
| localCacheScope | MyBatis的使用本地缓存，以防止循环引用，并加快反复嵌套查询。默认情况下（SESSION）会话期间执行的所有查询缓存。如果localCacheScope=STATMENT本地会话将被用于语句的执行，只是没有将数据共享之间的两个不同的调用相同的SqlSession。 | SESSION | STATEMENT | SESSION |
| dbcTypeForNull | 指定为空值时，没有特定的JDBC类型的参数的JDBC类型。有些驱动需要指定列的JDBC类型，但其他像NULL，VARCHAR或OTHER的工作与通用值。 | JdbcType enumeration. Most common are: NULL, VARCHAR and OTHER | OTHER |
| lazyLoadTriggerMethods | 指定触发延迟加载的对象的方法。 | A method name list separated by commas | equals,clone,hashCode,toString |
| defaultScriptingLanguage | 指定所使用的语言默认为动态SQL生成。 | A type alias or fully qualified class name. | org.apache.ibatis.scripting.xmltags.XMLDynamicLanguageDriver |
| callSettersOnNulls | 指定如果setter方法或地图的put方法时，将调用检索到的值是null。它是有用的，当你依靠Map.keySet（）或null初始化。注意原语（如整型，布尔等）不会被设置为null。 | true | false | FALSE |
| logPrefix | 指定的前缀字串，MyBatis将会增加记录器的名称。 | Any String | Not set |
| logImpl | 指定MyBatis的日志实现使用。如果此设置是不存在的记录的实施将自动查找。 | SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING | Not set |
| proxyFactory | 指定代理工具，MyBatis将会使用创建懒加载能力的对象。 | CGLIB | JAVASSIST |
6.2.3 typeAliases
别名是使用是为了在映射文件中，更方便的去指定入参和结果集的类型，不再用写很长的一段全限定名。
6.2.3.1 mybatis支持的别名
| 别名 |
映射的类型 |
| _byte |
byte |
| _long |
long |
| _short |
short |
| _int |
int |
| _integer |
int |
| _double |
double |
| _float |
float |
| _boolean |
boolean |
| string |
String |
| byte |
Byte |
| long |
Long |
| short |
Short |
| int |
Integer |
| integer |
Integer |
| double |
Double |
| float |
Float |
| boolean |
Boolean |
| date |
Date |
| decimal |
BigDecimal |
| bigdecimal |
BigDecimal |
6.2.3.2 自定义别名
SqlMapConfig.xml配置信息如下：
<typeAliases>
<typeAlias type="cn.itcast.mybatis.po.User" alias="user"/>
<package name="cn.itcast.mybatis.po"/>
typeAliases>
6.2.4 mappers
6.2.4.1 ’’/>
使用相对于类路径的资源
如：
6.2.4.2
使用完全限定路径
如：
6.2.4.3
使用mapper接口的全限定名
如：
注意：此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下；
6.2.4.4
注册指定包下的所有映射文件
如：
注意：此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下；
7 Mybatis映射文件（核心）
7.1 输入映射
7.1.1 ParameterType
指定输入参数的java类型，可以使用别名或者类的全限定名。它可以接收简单类型、POJO、HashMap。
7.1.1.1 传递简单类型
参考入门需求：根据用户ID查询用户信息。
7.1.1.2 传递POJO对象
参考入门需求：添加用户。
7.1.1.3 传递POJO包装对象
开发中通过pojo传递查询条件 ，查询条件是综合的查询条件，不仅包括用户查询条件还包括其它的查询条件（比如将用户购买商品信息也作为查询条件），这时可以使用包装对象传递输入参数。
7.1.1.3.1 需求
综合查询用户信息，需要传入查询条件复杂，比如（用户信息、订单信息、商品信息）。
7.1.1.3.2 定义包装对象
一般User.java类要和数据表表字段一致，最好不要在这里面添加其他字段，第二天学习mybatis的逆向工程时，会根据表结构，生成po类，如果在po类中扩展字段，此时会被覆盖掉。
所以针对要扩展的po类，我们需要创建一个扩展类，来继承它。
定义POJO包装类：
7.1.1.3.3 编写Mapper接口
//通过包装类来进行复杂的用户信息综合查询
public List
7.1.1.3.4 编写mapper映射文件
<select id="findUserList" parameterType="userQueryVO" resultType="userExt">
SELECT * FROM USER WHERE sex=#{userExt.sex} AND username LIKE '%${userExt.username}%'
select>
注意：入参的类型变为UserQueryVO、结果集的类型变为UserExt，#{}里面的参数变为UserQueryVO对象中的userExt属性的sex和username子属性。
7.1.1.3.5 编写测试代码
@Test
public void findUserListTest() {
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession，获取mapper接口的动态代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//构造userQueryVO对象
UserQueryVO userQueryVO = new UserQueryVO();
// 构造UserExt对象
UserExt userExt = new UserExt();
userExt.setSex("1");
userExt.setUsername("小明");
userQueryVO.setUserExt(userExt);
// 调用mapper对象的方法
List
System.out.println(list);
// 关闭SqlSession
sqlSession.close();
}
7.1.1.4 传递HashMap（练习）
同传递POJO对象一样，map的key相当于pojo的属性。
7.1.1.4.1 映射文件
<select id="findUserByHashmap" parameterType="hashmap" resultType="user">
select * from user where id=#{id} and username like '%${username}%'
select>
上边红色标注的是hashmap的key。
7.1.1.4.2 测试代码
Public void testFindUserByHashmap()throws Exception{
//获取session
SqlSession session = sqlSessionFactory.openSession();
//获限mapper接口实例
UserMapper userMapper = session.getMapper(UserMapper.class);
//构造查询条件Hashmap对象
HashMap
map.put("id", 1);
map.put("username", "管理员");
//传递Hashmap对象查询用户列表
List
//关闭session
session.close();
}
异常测试：
传递的map中的key和sql中解析的key不一致。
测试结果没有报错，只是通过key获取值为空。
7.2 输出映射
7.2.1 resultType
先带着同学们看下原先resultType作为输出结果映射时，它的特点，如何再把列名改为别名，看看是否还能不能映射成功。
7.2.1.1 使用方法
使用resultType进行结果映射时，查询的列名和映射的pojo属性名完全一致，该列才能映射成功。
如果查询的列名和映射的pojo属性名全部不一致，则不会创建pojo对象；
如果查询的列名和映射的pojo属性名有一个一致，就会创建pojo对象。
7.2.1.2 输出简单类型
当输出结果只有一列时，可以使用ResultType指定简单类型作为输出结果类型。
7.2.1.2.1 需求
综合查询用户总数，需要传入查询条件复杂，比如（用户信息、订单信息、商品信息）。
7.2.1.2.2 Mapper映射文件
<select id="findUsersCount" parameterType="UserQueryVO"
resultType="int">
SELECT count(1) FROM USER WHERE sex = #{userExt.sex} AND username LIKE '%${userExt.username}%'
select>
7.2.1.2.3 Mapper接口
//综合查询用户信息总数。学习：resultType输出简单类型
public int findUsersCount(UserQueryVO vo);
7.2.1.2.4 测试代码
@Test
public void testFindUsersCount() {
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession，获取mapper接口的动态代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//构造userQueryVO对象
UserQueryVO userQueryVO = new UserQueryVO();
// 构造UserExt对象
UserExt userExt = new UserExt();
userExt.setSex("1");
userExt.setUsername("小明");
userQueryVO.setUserExt(userExt);
int count = mapper.findUsersCount(userQueryVO);
System.out.println(count); // 关闭SqlSession
sqlSession.close();
}
7.2.1.3 输出POJO单个对象和列表
注意：输出单个pojo对象和pojo列表（盛放pojo对象）时，mapper映射文件中的resultType的类型是一样的，mapper接口的方法返回值不同。
7.2.1.3.1 Mapper映射文件
Mapper映射文件是同一个
<select id="findUsersByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">
SELECT * FROM USER WHERE username LIKE '%${value}%'
select>
7.2.1.3.2 Mapper接口
下面看下mapper接口的不同之处
1、 输出单个pojo对象
//根据用户名称来模糊查询用户信息
public User findUsersByName(String username);
2、 输出pojo列表
//根据用户名称来模糊查询用户信息列表
public List
总结：同样的mapper映射文件，返回单个对象和对象列表时，mapper接口在生成动态代理的时候，会根据返回值的类型，决定调用selectOne方法还是selectList方法。
7.2.2 resultMap
resultMap可以进行高级结果映射（一对一、一对多映射，第二天讲解）。
7.2.2.1 使用方法
如果查询出来的列名和属性名不一致，通过定义一个resultMap将列名和pojo属性名之间作一个映射关系。
1、 定义resultMap
2、 使用resultMap作为statement的输出映射类型。
7.2.2.2 需求
把下面SQL的输出结果集进行映射
SELECT id id_,username username_,sex sex_ FROM USER WHERE id = 1
7.2.2.3 Mapper映射文件
定义resultMap：
<resultMap type="user" id="userResultMap">
<id column="id_" property="id"/>
<result column="username_" property="username"/>
<result column="sex_" property="sex"/>
resultMap>
定义statement：
<select id="findUserByIdResultMap" parameterType="int" resultMap="userResultMap">
SELECT id id_,username username_,sex sex_ FROM USER WHERE id = #{id}
select>
7.2.2.4 Mapper接口定义
//根据ID查询用户信息（学习resultMap）
public User findUserByIdResultMap(int id);
定义Statement使用resultMap映射结果集时，Mapper接口定义方法的返回值类型为mapper映射文件中resultMap的type类型。
7.2.2.5 测试代码
@Test
public void findUserByIdResultMapTest() {
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession，获取mapper接口的动态代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 调用mapper对象的方法
User user = userMapper.findUserByIdResultMap(1);
System.out.println(user);
// 关闭SqlSession
sqlSession.close();
}
7.3 动态SQL（重点）
通过Mybatis提供的各种动态标签实现动态拼接sql，使得mapper映射文件在编写SQL时更加灵活，方便。常用动态SQL标签有：if、where、foreach；
7.3.1 If和where
Ø If标签：作为判断入参来使用的，如果符合条件，则把if标签体内的SQL拼接上。
注意：用if进行判断是否为空时，不仅要判断null，也要判断空字符串‘’；
Ø Where标签：会去掉条件中的第一个and符号。
7.3.1.1 需求
用户信息综合查询列表和用户信息综合查询总数这两个statement的定义使用动态SQL。
7.3.1.2 映射文件
<select id="findUsersByQueryVO" parameterType="cn.itcast.mybatis.po.QueryUserVO"
resultType="User">
SELECT * FROM USER
<where>
<if test="userExt != null">
<if test="userExt.sex != null and userExt.sex != ''">
AND sex = #{userExt.sex}
if>
<if test="userExt.username != null and userExt.username != ''">
AND username LIKE '%${userExt.username}%'
if>
if>
where>
select>
<select id="findUsersCount" parameterType="QueryUserVO"
resultType="int">
SELECT count(1) FROM USER
<where>
<if test="userExt != null">
<if test="userExt.sex != null and userExt.sex != ''">
AND sex = #{userExt.sex}
if>
<if test="userExt.username != null and userExt.username != ''">
AND username LIKE '%${userExt.username}%'
if>
if>
where>
select>
7.3.1.3 Mapper接口
//通过包装类来进行复杂的用户信息综合查询
public List
//综合查询用户总数
public int findUsersCount(UserQueryVO userQueryVO);
7.3.1.4 测试代码
不传用户名：
输出的SQL如下（也不包含用户名）：
通过测试可以得知，打印出的SQL语句确实会随着条件的满足情况而不一样。
7.3.2 SQL片段
Mybatis提供了SQL片段的功能，可以提高SQL的可重用性。
7.3.2.1 定义SQL片段
使用sql标签来定义一个SQL片段：
<sql id="select_user_where">
<if test="userExt != null">
<if test="userExt.sex != null and userExt.sex != ''">
AND sex = #{userExt.sex}
if>
<if test="userExt.username != null and userExt.username != ''">
AND username LIKE '%${userExt.username}%'
if>
if>
sql>
7.3.2.2 引用SQL片段
使用
<select id="findUserList" parameterType="userQueryVO" resultType="userExt">
SELECT * FROM USER
<where>
<include refid="select_user_where"/>
where>
select>
<select id="findUsersCount" parameterType="QueryUserVO"
resultType="int">
SELECT count(1) FROM USER
<where>
<include refid="select_user_where"/>
where>
select>
7.3.3 Foreach
向sql传递数组或List时，mybatis使用foreach解析数组里的参数并拼接到SQL中。
7.3.3.1 传递pojo对象中的List集合
7.3.3.1.1 需求
在用户查询列表和查询总数的statement中增加多个id输入查询。
7.3.3.1.2 SQL
SELECT * FROM user WHERE id IN (1,10,16)
7.3.3.1.3 定义pojo中的List属性
7.3.3.1.4 映射文件
<if test="idList != null and idList.size > 0">
<foreach collection="idList" item="id" open="AND id IN (" close=")" separator=",">
#{id}
foreach>
if>
7.3.3.1.5 Mapper接口
//根据用户ID的集合查询用户列表（学习foreach标签之通过POJO对象传ID集合）
public List
7.3.3.1.6 测试代码
@Test
public void testFindUserList() {
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession，获取mapper接口的动态代理对象
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
// 构造QueryUserVO对象
QueryUserVO vo = new QueryUserVO();
// UserExt ext = new UserExt();
// ext.setUsername("小明");
// ext.setSex("1");
// vo.setUserExt(ext);
// 创建用户ID集合，然后设置到QueryUserVO对象中
List
idList.add(1);
idList.add(10);
idList.add(16);
vo.setIdList(idList);
// 调用mapper代理对象的方法
List
System.out.println(list);
// 关闭SqlSession
sqlSession.close();
}
7.3.3.2 直接传递List集合（自学）
7.3.3.2.1 需求
根据用户ID的集合查询用户列表
7.3.3.2.2 SQL
SELECT * FROM user WHERE id IN (1,10,16)
7.3.3.2.3 映射文件
<select id="findUsersByIdList" parameterType="java.util.List" resultType="user">
SELECT * FROM USER
<where>
<if test="list != null and list.size > 0">
<foreach collection="list" item="id" open="AND id IN (" close=")" separator=",">
#{id}
foreach>
if>
where>
select>
7.3.3.2.4 Mapper接口
//根据用户ID的集合查询用户列表（学习foreach标签之直接传ID集合）
public List
7.3.3.2.5 测试代码
@Test
public void findUsersByIdListTest() {
// 创建SqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession，获取mapper接口的动态代理对象
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 构造List
List
idList.add(1);
idList.add(10);
idList.add(16);
// 调用mapper对象的方法
List
System.out.println(list);
// 关闭SqlSession
sqlSession.close();
}
8 mybatis与hibernate的区别及各自应用场景
Mybatis技术特点：
通过直接编写SQL语句，可以直接对SQL进行性能的优化；
学习门槛低，学习成本低。只要有SQL基础，就可以学习mybatis，而且很容易上手；
由于直接编写SQL语句，所以灵活多变，代码维护性更好。
不能支持数据库无关性，即数据库发生变更，要写多套代码进行支持，移植性不好。
需要编写结果映射。
Hibernate技术特点：
标准的orm框架，程序员不需要编写SQL语句。
具有良好的数据库无关性，即数据库发生变化的话，代码无需再次编写。
学习门槛高，需要对数据关系模型有良好的基础，而且在设置OR映射的时候，需要考虑好性能和对象模型的权衡。
程序员不能自主的去进行SQL性能优化。
Mybatis应用场景：
需求多变的互联网项目，例如电商项目。
Hibernate应用场景：
需求明确、业务固定的项目，例如OA项目、ERP项目等。
9 关联查询映射
9.1 分析数据模型
9.1.1 思路
1、 每张表记录的数据内容
分模块对每张表记录的内容进行熟悉，相当于你学习系统需求（功能）的过程。
2、 每张表重要的字段
主键、外键、非空字段
3、 数据库级别表与表的关系
外键关系
4、 表与表之间的业务关系
在分析表与表之间的业务关系时一定要建立 在某个业务意义基础上去分析。
9.1.2 图形分析
9.1.3 数据库表之间有外键关系的业务关系
user和orders：
user---->orders：一个用户可以创建多个订单，一对多
orders--->user：一个订单只由一个用户创建，一对一
orders和orderdetail：
orders-àorderdetail：一个订单可以包括 多个订单明细，因为一个订单可以购买多个商品，每个商品的购买信息在orderdetail记录，一对多关系
orderdetail--> orders：一个订单明细只能包括在一个订单中，一对一
orderdetail和itesm：
orderdetail---》itesms：一个订单明细只对应一个商品信息，一对一
items--> orderdetail:一个商品可以包括在多个订单明细 ，一对多
9.1.4 数据库表之间没有外键关系的业务关系
Orders和items：
这两张表没有直接的外键关系，通过业务及数据库的间接关系分析出它们是多对多的关系。
Ordersà orderdetail –>items：一个订单可以有多个订单明细，一个订单明细对应一个商品，所以一个订单对应多个商品
Items-àorderdetailàorders：一个商品可以对应多个订单明细，一个订单明细对应一个订单，所以一个商品对应多个订单
User和items：
这两张表没有直接的外键关系，通过业务及数据库的间接关系分析出它们是多对多的关系。
Useràordersàorderdetailàitems：一个用户有多个订单，一个订单有多个订单明细、一个订单明细对应一个商品，所以一个用户对应多个商品
Itemsàorderdetailàordersàuser：一个商品对应多个订单明细，一个订单明细对应一个订单，一个订单对应一个用户，所以一个商品对应多个用户
9.2 一对一查询
9.2.1 需求
查询订单信息，关联查询创建订单的用户信息
9.2.2 SQL语句
确定查询的主表：订单表
确定查询的关联表：用户表
关联查询使用内链接？还是外链接？
Select
Orders.id,
Orders.user_id,
orders.number,
orders.createtime,
orders.note,
user.username,
user.address
from orders,user
where orders.user_id = user.id
9.2.3 resultType
复杂查询时，单表对应的po类已不能满足输出结果集的映射。
所以要根据需求建立一个扩展类来作为resultType的类型。
9.2.3.1 创建po类
//通过此类映射订单和用户查询的结果，让此类继承包括 字段较多的pojo类
public class OrdersExt extends Orders{
//添加用户属性
/*USER.username,
USER.address */
private String username;
private String address;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
9.2.3.2 编写mapper接口
创建OrdersMapper接口类，在类中添加以下内容：
// 进行订单信息查询，包括用户的名称和地址信息
public List
9.2.3.3 编写映射文件
<mapper namespace="cn.itcast.mybatis.mapper.OrdersMapper">
<sql id="select_orders">
Orders.id,
Orders.user_id,
orders.number,
orders.createtime,
orders.note
sql>
<sql id="select_user">
user.username,
user.address
sql>
<select id="findOrdersUser" resultType="OrdersExt">
Select
<include refid="select_orders" />
<include refid="select_user">include>
from orders,user
where orders.user_id = user.id
select>
mapper>
9.2.3.4 加载映射文件
<package name="cn.itcast.mybatis.mapper"/>
9.2.3.5 编写测试代码
@Test
public void testFindOrdersUser() {
// 创建sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession构造usermapper的代理对象
OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
// 调用usermapper的方法
List
System.out.println(list);
// 释放SqlSession
sqlSession.close();
}
9.2.4 resultMap
9.2.4.1 修改po类
在Orders类中，添加User对象
public class Orders {
private Integer id;
private Integer userId;
private String number;
private Date createtime;
private String note;
//用户信息
private User user;
9.2.4.2 编写mapper接口
// 进行订单信息查询，包括用户的名称和地址信息（resultMap）
public List
9.2.4.3 编写映射文件
<select id="findOrdersUserRstMap" resultMap="OrdersUserRstMap">
Select
<include refid="select_orders" />
,
<include refid="select_user">include>
from orders,user
where orders.user_id = user.id
select>
<resultMap type=" cn.itcast.mybatis.po.Orders" id="OrdersUserRstMap">
<id column="id" property="id" />
<result column="user_id" property="userId" />
<result column="number" property="number" />
<result column="createtime" property="createtime" />
<result column="note" property="note" />
<association property="user" javaType="cn.itcast.mybatis.po.User">
<id column="user_id" property="id" />
<result column="username" property="username" />
<result column="address" property="address" />
association>
resultMap>
9.2.4.4 编写测试代码
@Test
public void testFindOrdersUserRstMap() {
// 创建sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession构造usermapper的代理对象
OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
// 调用usermapper的方法
List
//此处我们采用debug模式来跟踪代码，然后验证结果集是否正确
System.out.println(list);
// 释放SqlSession
sqlSession.close();
}
9.2.5 一对一小结
实现一对一查询：
resultType：使用resultType实现较为简单，如果pojo中没有包括查询出来的列名，需要增加列名对应的属性，即可完成映射。
如果没有查询结果的特殊要求建议使用resultType。
resultMap：需要单独定义resultMap，实现有点麻烦，如果对查询结果有特殊的要求，使用resultMap可以完成将关联查询映射pojo的对象属性中。
resultMap可以实现延迟加载，resultType无法实现延迟加载。
9.3 一对多查询
一对多查询和一对一查询的配置基本类似。只是如果使用resultMap的话，映射一对多关联关系要使用collection标签。
9.3.1 需求
查询订单信息及订单明细信息
9.3.2 SQL语句
确定主查询表：订单表
确定关联查询表：订单明细表
在一对一查询基础上添加订单明细表关联即可。
Select
Orders.id,
Orders.user_id,
orders.number,
orders.createtime,
orders.note,
user.username,
user.address,
orderdetail.id detail_id,
orderdetail.items_id,
orderdetail.items_num
from orders,user,orderdetail
where orders.user_id = user.id
and orders.id = orderdetail.orders_id
9.3.3 分析
使用resultType将上边的 查询结果映射到pojo中，订单信息将会重复。
要求：
对orders映射不能出现重复记录。
在orders.java类中添加List<Orderdetail> detailList属性。
最终会将订单信息映射到orders中，订单所对应的订单明细映射到orders中的detailList属性中。
映射成的orders记录数为两条（orders信息不重复）
每个orders中的detailList属性存储了该订单所对应的订单明细集合。
9.3.4 修改PO类
在Orders类中添加以下属性，并提供get/set方法：
//订单明细
private List
9.3.5 编写mapper接口
// 查询订单信息及订单明细信息（一对多映射之使用resultMap）
public List
9.3.6 编写映射文件
<resultMap type="Orders" id="OrdersAndOrderdetailRstMap"
extends="OrdersUserRstMap">
<collection property="detailList" ofType="Orderdetail">
<id column="detail_id" property="id" />
<result column="items_id" property="itemsId" />
<result column="items_num" property="itemsNum" />
collection>
resultMap>
<select id="findOrdersAndOrderdetailRstMap" resultMap="OrdersAndOrderdetailRstMap">
Select
<include refid="select_orders" />
,
<include refid="select_user"/>
,
orderdetail.id detail_id,
orderdetail.items_id,
orderdetail.items_num
from orders,user,orderdetail
where orders.user_id = user.id
and
orders.id = orderdetail.orders_id
select>
resultMap的extends属性：可以用此属性来继承一个已有的resultmap。但是它继承的resultMap的type和它本身的type要保持一致。
9.3.7 编写测试代码
@Test
public void testFindOrdersAndOrderdetailRstMap() {
// 创建sqlSession
SqlSession sqlSession = sqlSessionFactory.openSession();
// 通过SqlSession构造usermapper的代理对象
OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
// 调用usermapper的方法
List
//此处我们采用debug模式来跟踪代码，然后验证结果集是否正确
System.out.println(list);
// 释放SqlSession
sqlSession.close();
}
9.3.8 一对多小结
mybatis使用resultMap的collection对关联查询的多条记录映射到一个list集合属性中。
使用resultType实现：
需要对结果集进行二次处理。
将订单明细映射到orders中的orderdetails中，需要自己处理，使用双重循环遍历，去掉重复记录，将订单明细放在orderdetails中。
9.4 多对多查询
9.4.1 需求
查询用户信息及用户购买的商品信息，要求将关联信息映射到主pojo的pojo属性中
9.4.2 SQL语句
查询主表：user
查询关联表：orders、orderdetail、items
Select
Orders.id,
Orders.user_id,
orders.number,
orders.createtime,
orders.note,
user.username,
user.address,
orderdetail.id detail_id,
orderdetail.items_id,
orderdetail.items_num
items.name items_name,
items.detail items_detail
FROM
orders,
USER,
orderdetail,
items
WHERE user.`id` = orders.`user_id`
AND orders.`id` = orderdetail.`orders_id`
AND orderdetail.`items_id` = items.`id`
9.4.3 映射思路
将用户信息映射到user中。
在user类中添加订单列表属性List
在Orders中添加订单明细列表属性List
在Orderdetail中添加Items属性，将订单明细所对应的商品映射到Items
9.4.4 修改PO类
在user类中添加List
// 订单信息
private List
在Orders类中添加List
//订单明细
private List
在Orderdetail类中添加Items属性
//商品信息
private Items items;
9.4.5 编写mapper接口
//查询用户及用户购买商品信息（多对多映射之使用resultMap）
public List
9.4.6 编写映射文件
<resultMap type="User" id="UserAndItemsRstMap">
<id column="user_id" property="id" />