框架 day65 Mybatis入门(基础知识:框架原理,入门[curd],开发dao层,全局与映射配置)

最新推荐文章于 2022-11-09 16:05:13 发布

飛白

最新推荐文章于 2022-11-09 16:05:13 发布

阅读量3.5k

点赞数 3

分类专栏：笔记文章标签： web 笔记 mybatis 框架

本文链接：https://blog.csdn.net/opopopwqwqwq/article/details/51771163

版权

笔记专栏收录该内容

157 篇文章 1 订阅

订阅专栏

Mybatis

基础知识(一)

第一天：基础知识（重点）
mybatis介绍
mybatis框架原理(掌握)
mybaits入门程序(掌握)
用户信息进行增、删、改、查

mybatis开发dao层方法：(掌握)
原始dao开发方法（dao接口和实现类需要程序员编写）
mapper代理开发方法（程序员只需要编写接口）

SqlMapConfig.xml（mybatis全局配置文件）(掌握)

mybatis输入映射(掌握)
mybatis输出映射(掌握)
mybatis动态sql(掌握)

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数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。

解决：在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。

2Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

解决：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。

3向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。

解决：Mybatis自动将java对象映射至sql语句，通过statement中的parameterType定义输入参数的类型。

4对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。

解决：Mybatis自动将sql执行结果映射至java对象，通过statement中的resultType定义输出结果的类型。

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 数据库脚本

sql_table.sql：创建表语句、存储过程、触发器

sql_data.sql：系统初始化数据

4.2.1.2 数据库表

订单商品案例的数据库脚本中，总共包含四张表，其中入门程序只使用user表：

4.2.2 下载mybatis

mybaits的代码，由github.com管理
下载地址：https://github.com/mybatis/mybatis-3/releases

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>
<!-- 配置mybatis的环境信息 -->
<environments default="development">
	<environment id="development">
		<!-- 配置JDBC事务控制，由mybatis进行管理 -->
		<transactionManager type="JDBC"></transactionManager>
		<!-- 配置数据源，采用dbcp连接池 -->
		<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中添加以下代码：

<!-- 
	namespace：命名空间，它的作用就是对SQL进行分类化管理，可以理解为SQL隔离
	注意：使用mapper代理开发时，namespace有特殊且重要的作用
 -->
<mapper namespace="test">

	<!-- 根据用户ID，查询用户信息 -->
	<!-- 
		[id]：statement的id，要求在命名空间内唯一  
		[parameterType]：入参的java类型
		[resultType]：查询出的单条结果集对应的java类型
		[#{}]： 表示一个占位符?
		[#{id}]：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
	 -->
	<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中，添加以下代码：

<!-- 加载mapper -->
<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中，添加以下内容：

<!-- 根据用户名称模糊查询用户信息列表 -->
<!-- 
		[${}]：表示拼接SQL字符串
	 	[${value}]：表示要拼接的是简单类型参数。
		 注意：
		1、如果参数为简单类型时，${}里面的参数名称必须为value 
		2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}
-->
<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<User> users = sqlSession.selectList("test.findUsersByName", "小明");

	// 打印输出结果集
	System.out.println(users);

	// 5、关闭SqlSession
	sqlSession.close();
}

4.5.3.3 添加用户

4.5.3.3.1 编写映射文件

<!-- 添加用户 -->
<!-- 如果主键的值是通过MySQL自增机制生成的，那么我们此处不需要再显示的给ID赋值 -->
<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自增主键，是指在insert之前MySQL会自动生成一个自增的主键。

Ø 我们可以通过MySQL的函数获取到刚插入的自增主键:

LAST_INSERT_ID()

Ø 这个函数是在insert语句之后去调用。

修改映射文件：

<!-- 添加用户之自增主键返回（selectKey方式） -->
<!-- 
		[selectKey标签]：通过select查询来生成主键
		[keyProperty]：指定存放生成主键的属性
		[resultType]：生成主键所对应的Java类型
		[order]：指定该查询主键SQL语句的执行顺序，相对于insert语句
		[last_insert_id]：MySQL的函数，要配合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 非自增主键返回之UUID

注意：使用mysql的uuid()函数生成主键，需要修改表中id字段类型为string，长度设置成35位。

<!-- 添加用户之UUID主键返回 -->
<!-- 
	[uuid]：MySQL的函数，生成的主键是35位的字符串，所以使用它时要修改id的类型为字符类型
	注意：
		1、此时order采用BEFORE，因为需要先生成出主键，再执行insert语句
		2、显式的给ID赋值
-->
<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)返回（了解）

<!-- 添加用户之sequence返回 -->
<!-- 
	通过Oracle的sequence获取主键方式与MySQL的uuid方式基本一致	
-->
<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 编写映射文件

<!-- 根据ID删除用户 -->
<delete id="deleteUser" parameterType="int">
	DELETE FROM USER WHERE id= #{id}
</delete>

4.5.3.4.2 加载映射文件

已配置，此处无需再次配置。

4.5.3.4.3 编写测试程序

略

4.5.3.5 修改用户

4.5.3.5.1 编写映射文件

<!-- 根据传入的用户信息修改用户 -->
<update id="updateUser" parameterType="cn.itcast.mybatis.po.User">
	UPDATE USER SET username LIKE ‘%${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条记录

4.7 mybatis与hibernate的区别及各自应用场景

Mybatis技术特点：

通过直接编写SQL语句，可以直接对SQL进行性能的优化；

学习门槛低，学习成本低。只要有SQL基础，就可以学习mybatis，而且很容易上手；

由于直接编写SQL语句，所以灵活多变，代码维护性更好。

不能支持数据库无关性，即数据库发生变更，要写多套代码进行支持，移植性不好。

需要编写结果映射。

Hibernate技术特点：

标准的orm框架，程序员不需要编写SQL语句。

具有良好的数据库无关性，即数据库发生变化的话，代码无需再次编写。

学习门槛高，需要对数据关系模型有良好的基础，而且在设置OR映射的时候，需要考虑好性能和对象模型的权衡。

程序员不能自主的去进行SQL性能优化。

Mybatis应用场景：

需求多变的互联网项目，例如电商项目。

Hibernate应用场景：

需求明确、业务固定的项目，例如OA项目、ERP项目等。

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<User> findUsersByName(String username);
	//添加用户
	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<User> findUsersByName(String username) {
		//通过工厂，在方法内部获取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 编写测试代码

略

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">
<!-- namespace：此时用mapper代理方式，它的值必须等于对应mapper接口的全限定名  -->
<mapper namespace="cn.itcast.mybatis.mapper.UserMapper">

	<!-- 根据用户ID，查询用户信息 -->
	<!-- 
		[id]：statement的id，要求在命名空间内唯一  
		[parameterType]：入参的java类型，可是是简单类型、POJO、HashMap
		[resultType]：查询出的单条结果集对应的java类型
		[#{}]： 表示一个占位符?
		[#{id}]：表示该占位符待接收参数的名称为id。注意：如果参数为简单类型时，#{}里面的参数名称可以是任意定义
	 -->
	<select id="findUserById" parameterType="int" resultType="cn.itcast.mybatis.po.User">
		SELECT * FROM USER WHERE id = #{id}
	</select>
	
	
	<!-- 根据用户名称模糊查询用户信息列表 -->
	<!-- 
		[${}]：表示拼接SQL字符串，即不加解释的原样输出
	 	[${value}]：表示要拼接的是简单类型参数。
		 注意：
		1、如果参数为简单类型时，${}里面的参数名称必须为value 
		2、${}会引起SQL注入，一般情况下不推荐使用。但是有些场景必须使用${}，比如order by ${colname}
	-->
	<select id="findUsersByName" parameterType="java.lang.String" resultType="cn.itcast.mybatis.po.User">
		SELECT * FROM USER WHERE username LIKE '%${value}%'
	</select>
	
	<!-- 添加用户之自增主键返回（selectKey方式） -->
	<!-- 
		[selectKey标签]：通过select查询来生成主键
		[keyProperty]：指定存放生成主键的属性
		[resultType]：生成主键所对应的Java类型
		[order]：指定该查询主键SQL语句的执行顺序，相对于insert语句，此时选用AFTER
		[last_insert_id]：MySQL的函数，要配合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>
	
</mapper>

5.3.3.2 加载mapper映射文件

<!-- 加载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<User> findUsersByName(String username);
	//添加用户
	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<User> list = userMapper.findUsersByName("小明");

		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标签，读取java配置文件的内容 -->
<properties resource="db.properties" />

<!-- 配置mybatis的环境信息 -->
<environments default="development">
	<environment id="development">
		<!-- 配置JDBC事务控制，由mybatis进行管理 -->
		<transactionManager type="JDBC"></transactionManager>
		<!-- 配置数据源，采用dbcp连接池 -->
		<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将按照下面的顺序加载属性：

* Properties标签体内定义的属性首先被读取

* Properties引用的属性会被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值

* parameterType接收的值会最后被读取，如果发现上面已经有同名的属性了，那后面会覆盖前面的值

所以说，mybatis读取属性的顺序由高到低分别是：parameterType接收的属性值、properties引用的属性、properties标签内定义的属性。

6.2.2 Settings

mybatis全局配置参数，全局参数将会影响mybatis的运行行为。

6.2.3 typeAliases

别名是使用是为了在映射文件中，更方便的去指定入参和结果集的类型，不再用写很长的一段全限定名。

6.2.3.1 mybatis支持的别名

6.2.3.2 自定义别名

SqlMapConfig.xml配置信息如下：

<!-- 定义别名 -->
	<typeAliases>
		<!-- 单个定义别名 -->
		<typeAlias type="cn.itcast.mybatis.po.User" alias="user"/>
		
		<!-- 批量定义别名（推荐） -->
		<!-- [name]：指定批量定义别名的类包，别名为类名（首字母大小写都可） -->
		<package name="cn.itcast.mybatis.po"/>
	</typeAliases>

6.2.4 mappers

映射器的配置有四种方式

6.2.4.1 <mapper resource=’’/>

使用相对于类路径的资源

如：<mapperresource="sqlmap/User.xml" />

6.2.4.2 <mapper url=’’/>

使用完全限定路径

如：<mapperurl="file:///D:\workspace_spingmvc\mybatis_01\config\sqlmap\User.xml"/>

6.2.4.3 <mapper class=’’/>

使用mapper接口的全限定名

如：<mapperclass="cn.itcast.mybatis.mapper.UserMapper"/>

注意：此种方法要求mapper接口和mapper映射文件要名称相同，且放到同一个目录下；

6.2.4.4 <package name=’’/>（推荐）

注册指定包下的所有映射文件

如：<packagename="cn.itcast.mybatis.mapper"/>

注意：此种方法要求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<UserExt> findUserList(UserQueryVO userQueryVO);

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<UserExt> list = userMapper.findUserList(userQueryVO);

	System.out.println(list);
	// 关闭SqlSession
	sqlSession.close();
}

7.1.1.4 传递HashMap（）

同传递POJO对象一样，map的key相当于pojo的属性。

7.1.1.4.1 映射文件

<!-- 传递hashmap综合查询用户信息 -->
	<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<String, Object> map = new HashMap<String, Object>();
		map.put("id", 1);
		map.put("username", "管理员");
		
		//传递Hashmap对象查询用户列表
		List<User>list = userMapper.findUserByHashmap(map);
		//关闭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="QueryUserVO"
		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(QueryUserVO 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<User> findUsersByName(String username);

总结：同样的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 -->
<!-- 
	[id]：定义resultMap的唯一标识
	[type]：定义该resultMap最终映射的pojo对象
	[id标签]：映射结果集的唯一标识列，如果是多个字段联合唯一，则定义多个id标签
	[result标签]：映射结果集的普通列
	[column]：SQL查询的列名，如果列有别名，则该处填写别名
	[property]：pojo对象的属性名
-->
<resultMap type="user" id="userResultMap">
	<id column="id_" property="id"/>
	<result column="username_" property="username"/>
	<result column="sex_" property="sex"/>
</resultMap>

定义statement：

<!-- 根据ID查询用户信息（学习resultMap） -->
<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<UserExt> findUserList(UserQueryVO userQueryVO);
//综合查询用户总数
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片段 -->
<!-- 
	[sql标签]：定义一个SQL片段
	[id]：SQL片段的唯一标识
	建议：
		1、SQL片段中的内容最好是以单表来定义
		2、如果是查询字段，则不要写上SELECT
		3、如果是条件语句，则不要写上WHERE
 -->
<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片段

使用<include refid=’’ /> 来引用SQL片段：

<!-- 根据用户id来查询用户信息（使用SQL片段） -->
<!-- 
	[include标签]：引用已经定义好的SQL片段
	[refid]：引用的SQL片段id
-->
<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 映射文件

<!-- [foreach标签]：表示一个foreach循环 -->
<!-- [collection]：集合参数的名称，如果是直接传入集合参数，则该处的参数名称只能填写[list]。 -->
<!-- [item]：每次遍历出来的对象 -->
<!-- [open]：开始遍历时拼接的串 -->
<!-- [close]：结束遍历时拼接的串 -->
<!-- [separator]：遍历出的每个对象之间需要拼接的字符 -->
<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<UserExt> findUserList(UserQueryVO vo);

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<Integer> idList = new ArrayList<Integer>();
	idList.add(1);
	idList.add(10);
	idList.add(16);
	vo.setIdList(idList);

	// 调用mapper代理对象的方法
	List<UserExt> list = mapper.findUserList(vo);
	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 映射文件

传递List类型在编写mapper.xml没有区别，唯一不同的是只有一个List参数时它的参数名为list。

<!-- 根据用户ID的集合查询用户列表（学习foreach标签之直接传ID集合） -->
<!-- 
	[foreach标签]：表示一个foreach循环
	[collection]：集合参数的名称，如果是直接传入集合参数，则该处的参数名称只能填写[list]。
	[item]：定义遍历集合之后的参数名称
	[open]：开始遍历之前需要拼接的SQL串
	[close]：结束遍历之后需要拼接的SQL串
	[separator]：遍历出的每个对象之间需要拼接的字符
 -->
<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<User> findUsersByIdList (List<Integer> idList);

7.3.3.2.5 测试代码

@Test
public void findUsersByIdListTest() {
	// 创建SqlSession
	SqlSession sqlSession = sqlSessionFactory.openSession();
	// 通过SqlSession，获取mapper接口的动态代理对象
	UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

	// 构造List<Integer>集合
	List<Integer> idList = new ArrayList<Integer>();
	idList.add(1);
	idList.add(10);
idList.add(16);

	// 调用mapper对象的方法
	List<User> list = userMapper.findUsersByIdList (idList);
	System.out.println(list);
	// 关闭SqlSession
	sqlSession.close();
}

1.1.1.1 递单个数组（数组中是pojo）：

Mapper.xml

<!-- 传递数组综合查询用户信息 -->
	<select id="selectUserByArray" parameterType="Object[]" resultType="user">
		select * from user 
		<where>
		<!-- 传递数组 -->
		<if test="array!=null">
		<foreach collection="array" index="index" item="item" open="and id in("separator=","close=")">
		    #{item.id} 
		</foreach>
		</if>
		</where>
	</select>

sql只接收一个数组参数，这时sql解析参数的名称mybatis固定为array，如果数组是通过一个pojo传递到sql则参数的名称为pojo中的属性名。

index：为数组的下标。

item：为数组每个元素的名称，名称随意定义

open：循环开始

close：循环结束

separator：中间分隔输出

Mapper接口：

public List<User> selectUserByArray(Object[] userlist) throws Exception;

测试：

public void testselectUserByArray()throws Exception{
		//获取session
		SqlSession session = sqlSessionFactory.openSession();
		//获限mapper接口实例
		UserMapper userMapper = session.getMapper(UserMapper.class);
		//构造查询条件List
		Object[] userlist = new Object[2];
		User user = new User();
		user.setId(1);
		userlist[0]=user;
		user = new User();
		user.setId(2);
		userlist[1]=user;
		//传递user对象查询用户列表
		List<User>list = userMapper.selectUserByArray(userlist);
		//关闭session
		session.close();
	}

1.1.1.2 传递单个数组（数组中是字符串类型）：

Mapper.xml

<!-- 传递数组综合查询用户信息 -->
	<select id="selectUserByArray" parameterType="Object[]" resultType="user">
		select * from user 
		<where>
		<!-- 传递数组 -->
		<if test="array!=null">
		<foreach collection="array"index="index"item="item"open="and id in("separator=","close=")">
		    #{item} 
		</foreach>
		</if>
		</where>
	</select>

如果数组中是简单类型则写为#{item}，不用再通过ognl获取对象属性值了。

Mapper接口：

public List<User> selectUserByArray(Object[] userlist) throws Exception;

测试：

public void testselectUserByArray()throws Exception{
		//获取session
		SqlSession session = sqlSessionFactory.openSession();
		//获限mapper接口实例
		UserMapper userMapper = session.getMapper(UserMapper.class);
		//构造查询条件List
		Object[] userlist = new Object[2];
		userlist[0]=”1”;
		userlist[1]=”2”;
		//传递user对象查询用户列表
		List<User>list = userMapper.selectUserByArray(userlist);
		//关闭session
		session.close();
	}

飛白

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
4
评论
框架 day65 Mybatis入门(基础知识:框架原理,入门[curd],开发dao层,全局与映射配置)

Mybatis基础知识(一)第一天：基础知识（重点）mybatis介绍 mybatis框架原理(掌握) mybaits入门程序(掌握) 用户信息进行增、删、改、查 mybatis开发dao层方法：(掌握) 原始dao开发方法（dao接口和
复制链接

扫一扫

专栏目录