MyBatis基础总结

一、基础配置文件

在MyBatis中的XML分为两类，一类是基础配置文件，通常只有一个，主要是配置一些基本的上下文参数和运行环境；另一类是映射文件，它可以配置映射关系、SQL、参数等信息。

MyBatis配置文件元素清单：

<?xml version="1.0" encoding="UTF-8"?>
<configuration><!-- 配置 -->
	<properties/><!-- 属性 -->
	<settings/><!-- 设置 -->
	<typeAliases/><!-- 类型命名 -->
	<typeHandlers/><!--类型处理器-->
	<objectFactory/><!--对象工厂-->
	<plugins/><!--插件-->
	<environments><!--配置环境-->
		<environment><!--环境变量-->
			<transactionManager/><!--事务管理器-->
			<dataSource/><!--数据源-->
		</environment>
	</environments>

	<databaseIdProvider/><!--数据库厂商标识-->
	<mappers/><!--映射器-->
</configuration>

MyBatis配置项的顺序不能颠倒，如果颠倒了他们的顺序，那么在MyBatis的启动阶段就会发生异常，导致程序无法运行。

1、properties 属性

MyBatis提供了三种方式供我们使用properties:
（1）property子元素

<properties>
	<property name="database.driver" value="com.mysql.jdbc.Driver"/>
	<property name="database.url" value="jdbc:mysql://localhost:3306/ssm"/>
	<property name="database.username" value="root"/>
	<property name="database.password" value="123456"/>
</properties>
<!-- 数据库环境 -->
<environments default="development">
	<environment id="development">
		<transactionManager type="JDBC" />
		<dataSource type="POOLED">
			<property name="driver" value="${database.driver}" />
			<property name="url" value="${database.url}" />
			<property name="username" value="${database.username}" />
			<property name="password" value="${database.password}" />
		</dataSource>
	</environment>
</environments>

（2）使用properties文件（推荐）
properties文件：jdbc.properties

database.driver=com.mysql.jdbc.Driver
database.url=jdbc:mysql://localhost:3306/ssm
database.username=root
database.password=123456

然后将配置文件中的<properties>修改为

<properties resource="jdbc.properties"/>

（3）使用程序传递方式传递参数
假设用户名和密码已经加密，并且系统提供了CodeUtils.decode(str)进行解密

String resource = "mybatis-config.xml";
InputStream inputStream;
//读取jdbc.properties文件
InputStream in = Resources.getResourceAsStream("jdbc.properties");
Properties props = new Properties();
props.load(in);
String username = props.getProperty("database.username");
String password = props.getProperty("database.password");
// 解密用户和密码，并在属性中重置
props.put("database.username", CodeUtils.decode(username));
props.put("database.password", CodeUtils.decode(password));
inputStream = Resources.getResourceAsStream(resource);
// 使用程序传递的方式覆盖原有的properties属性参数
sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream, props);

2、setting 设置

全样setting配置样例

<settings>
	<setting name="cacheEnabled" value="true"/>
	<setting name="lazyLoadingEnabled" value="true"/>
	<setting name="multipleResultSetsEnabled" value="true"/>
	<setting name="useColumnLabel" value="true"/>
	<setting name="useGeneratedKeys" value="false"/>
	<setting name="autoMappingBehavior" value="PARTIAL"/>
	<setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
	<setting name="defaultExecutorType" value="SIMPLE"/>
	<setting name="defaultStatementTimeout" value="25"/>
	<setting name="defaultFetchSize" value="100"/>
	<setting name="safeRowBoundsEnabled" value="false"/>
	<setting name="mapUnderscoreToCamelCase" value="false"/>
	<setting name="localCacheScope" value="SESSION"/>
	<setting name="jdbcTypeForNull" value="OTHER"/>
	<setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

setting配置项说明

配置项	说明	配置选项	默认值
cacheEnabled	全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存。	true，false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。	true，false	false
aggressiveLazyLoading	当开启时，任何方法调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考lazyLoadTriggerMethods）	true，false	版本3.4.1（不包含）之前true，之后false
multipleResultSetsEnabled	是否允许单一语句返回多结果集（需要兼容驱动）	true，false	true
useColumnLabel	使用列标签代替列名。不同的驱动在这方面会有不同的表现，具体可参考相关驱动文档或通过测试这两种不同的模式来观察所用驱动的结果。	true，false	true
useGeneratedKeys	允许JDBC支持自动生成主键，需要驱动兼容。如果设置为true则这个设置强制使用自动生成主键，尽管一些驱动不能兼容但仍可正常工作（比如Derby）	true，false	false
autoMappingBehavior	指定MyBatis应如何自动映射列到字段或属性。NONE表示取消自动映射；PARTIAL只会自动映射没有定义嵌套结果集映射的结果集。FULL会自动映射任意复杂的结果集（无论是否嵌套）	NONE,PARTIAL,FULL	PARTIAL
autoMappingUnknownColumnBehavior	指定发现自动映射目标未知列（或者未知属性类型）的行为。NONE：不做任何反应 WARNING：输出提醒日志 (‘org.apache.ibatis.session.AutoMappingUnknownColumnBehavior’的日志等级必须设置为WARN) FAILING：映射失败（抛出SqlSessionException）	NONE,WARNING,FAILING	NONE
defaultExecutorType	配置默认的执行器。SIMPLE就是普通的执行器；REUSE执行器会重用预处理语句（prepared statements）；BATCH执行器将重用语句并执行批量更新。	SIMPLE,REUSE,BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定驱动等待数据库响应的秒数	任意正整数	Not Set(null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个提示值。此参数只可以在查询设置中被覆盖。	任意正整数	Not Set(null)
safeRowBoundsEnabled	允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为false。	true ，false	False
safeResultHandlerEnabled	允许在嵌套语句中使用分页（ResultHandler）。如果允许使用则设置为false。	true ，false	True
mapUnderscoreToCamelCase	是否开启自动驼峰命名规则（camel case）映射，既从经典数据库列名A_COLUMN到经典java属性名aColumn的类似映射。	true ， false	False
localCacheScope	MyBatis利用本地缓存机制（Local Cache）防止循环引用（circular references）和加速重复嵌套查询。默认值为SESSION，这种情况下会缓存一个会话中执行的所有查询。若设置值为STATEMENT，本地会话仅用在语句执行上，对相同SqlSession的不同调用将不会共享数据。	SESSION ， STATEMENT	SESSION
jdbcTypeForNull	当没有为参数提供特定的JDBC类型时，为空值指定JDBC类型。某些驱动需要指定列的JDBC类型，多数情况直接用一般类型即可，比如NULL，VARCHAR或OTHER。	jdbc Type 常量，大多都为：NULL，VARCHAR and OTHER	OTHER
lazyLoadTriggerMethods	指定哪个对象的方法触发一次延迟加载。	用逗号分隔的方法列表	equals,clone,hashCode,toString
defaultScriptingLanguage	指定动态SQL生成的默认语言。	一个类型别名或完全限定类名	org.apache.ibatis.scripting.xmltags.XMLLanguageDriver
defaultEnumTypeHandler	指定Enum使用的默认TypeHandler.（从3.4.5开始）	一个类型别名或完全限定类名	org.apache.ibatis.type.EnumTypeHandler
callSettersOnNulls	指定当结果集中值为null的时候是否调用映射对象的setter（map对象时为put）方法，这对于有Map.keySet()依赖或null值初始化的时候是有用的。注意基本类型（int，boolean等）是不能设置成null的。	true ， false	false
returnInstanceForEmptyRow	当返回行的所有列都是空时，MyBatis默认返回null。当开启这个设置时，MyBatis会返回一个空实例。请注意，它也适用于嵌套的结果集（i.e.collection and association）。（从3.4.2开始）	true ，false	false
logPrefix	指定MyBatis增加到日志名称的前缀。	任何字符串	Not set
logImpl	指定MyBatis所用日志的具体实现，未指定时将自动查找。	SLF4J ， LOG4J ， LOG4J2 ，JDK_LOGGING ，COMMONS_LOGGING ， STDOUT_LOGGING ， N0_LOGGING	Not set
proxyFactory	指定MyBatis创建具有延迟加载能力的对象所用到的代理工具。	CGLIB ， JAVASSIST	JAVASSIST(MyBatis 3.3 or above)
vfsImpl	指定VFS的实现	自定义VFS的实现的类全限定名，以逗号分隔	Not set
useActualParamName	允许使用方法签名中的名称作为语句参数名称。为了使用该特性，工程必须采用java 8编译，并加上-parameters选项（从3.4.1开始）	true ，false	true
configurationFactory	指定一个提供Configuration实例的类。这个被返回的Configuration实例用来加载被反序列化对象的懒加载属性值。这个类必须包含一个签名方法static Configuration getConfiguration()。（从3.2.3版本开始）	类型别名或者全类名	Not set

3、typeAliases 别名

由于类的全限定名很长，总写那么长的名称不方便，MyBatis中允许定义一个简写来代表这个类，这就是别名。
在MyBatis中，别名不区分大小写。
自定义别名有两种方法：
（1）配置文件定义

<typeAliases><!--别名-->
	<typeAlias alias="role" type="com.learn.ssm.chapter4.pojo.Role"/>
	<typeAlias alias="user" type="com.learn.ssm.chapter4.pojo.User"/>
</typeAliases>

（2）扫描别名

<typeAliases><!--别名-->
	<typeAlias name="com.learn.ssm.chapter4.pojo"/>
</typeAliases>

MyBatis将扫描这个包里面的类，将其第一个字母变为小写作为其别名

有时会出现重名，可以使用注解进行区分：

@Alias("user3")
public Class User{
......
}

4、typeHandler 类型转换器

在typeHandler中，分为jdbcType和javaType，其中jdbcType用于定义数据库类型，而javaType用于定义java类型，那么typeHandler的作用就是承担jdbcType和javaType之间的相互转换。

自定义typeHandler
要实现typeHandler就需要实现接口typeHandler，或者继承BaseTypeHandler
步骤1：实现typeHandler

public class MyTypeHandler implements TypeHandler<String> {

	Logger logger = Logger.getLogger(MyTypeHandler.class);

	@Override
	//使用typeHandler通过PreparedStatement对象进行设置SQL参数的时候使用的具体方法
	//四个参数：ps -- ，i -- 参数在SQL的下标，parameter -- 参数，jdbcType -- 数据库类型	
	public void setParameter(PreparedStatement ps, int i, String parameter, JdbcType jdbcType) throws SQLException {
		logger.info("设置string参数【" + parameter+"】");
		ps.setString(i, parameter);
	}

	@Override
	//使用列名（columnName）从jdbc结果集中获取数据进行转换	
	public String getResult(ResultSet rs, String columnName)throws SQLException {
		String result = rs.getString(columnName);
		logger.info("读取string参数1【" + result+"】");
		return result;
	}

	@Override
	//使用下标（columnIndex）从jdbc结果集中获取数据进行转换	
	public String getResult(ResultSet rs, int columnIndex) throws SQLException {
		String result = rs.getString(columnIndex);
		logger.info("读取string参数2【" + result+"】");
		return result;
	}

	@Override
	//从jdbc结果集中获取数据进行转换（存储过程专用）
	public String getResult(CallableStatement cs, int columnIndex) throws SQLException {
		String result = cs.getString(columnIndex);
		logger.info("读取string参数3【" + result+"】");
		return result;
	}
}

步骤2：配置

<typeHandlers>
	<typeHandler jdbcType="VARCHAR" javaType="string" handler="com.learn.ssm.chapter4.typehandler.MyTypeHandler"/>
</typeHandlers>

步骤3：两种使用方法（在映射器中）

方法1：指定与自定义typeHandler一致的jdbcType和javaType

<resultMap id="roleMapper" type="role">
	<result property="id" column="id" />
	<result property="roleName" column="role_name" jdbcType="VARCHAR" javaType="string" />
</resultMap>

<select id="findRoles" parameterType="string" resultMap="roleMapper">
	select id, role_name, note from t_role where role_name like concat('%', #{roleName, jdbcType=VARCHAR, javaType=string}, '%')
</select>

方法2：直接使用typeHandler指定具体的实现类

<resultMap id="roleMapper" type="role">
	<result property="id" column="id" />
	<result property="note" column="note" typeHandler="com.learn.ssm.chapter4.typehandler.MyTypeHandler" />
</resultMap>

<select id="findRoles2" parameterType="string" resultMap="roleMapper">
select id, role_name, note from t_role where note like concat('%', #{note, typeHandler=com.learn.ssm.chapter4.typehandler.MyTypeHandler}, '%')
</select>

5、ObjectFactory 对象工厂

6、plugins 插件

7、environments 配置环境

在MyBatis中，配置环境的主要作用就是配置数据库信息，它可以配置多个数据库。

运行环境配置：

<environment default="development">
	<environment id="development">
		<transactionManager type="JDBC">
		<dataSource type="POOLED"> 
			<property name="driver" value="${database.driver}"/>
			<property name="url" value="${database.url}"/>
			<property name="username" value="${database.username}"/>
			<property name="password" value="${database.password}"/>
		</dataSource>
	</environment>
</environment>

8、databaseIdProvider 数据库厂商标识

使用系统默认的databaseIdProvider
步骤1：配置databaseIdProvider属性

<databaseIdProvider type="DB_VENDOR">
	<property name="Oracle" value="oracle"/>
	<property name="MySQL" value="mysql"/>
	<property name="DB2" value="db2"/>
</databaseIdProvider>

步骤2：标识SQL适用何种数据库

<select id="getRole" parameterType="long" resultType="role" databaseId="oracle">
	select id,role_name as roleName, note from t_role where id = #{id}
</select>
<select id="getRole" parameterType="long" resultType="role" databaseId="mysql">
	select id,role_name as roleName, note from t_role where i=i and id = #{id}
</select>

当databaseIdProvider属性被配置时，系统会优先取到和数据库配置一致的SQL，如果没有，则取没有databaseId的SQL，可以把它当做默认值。

9、mappers 映射器

映射器由一个接口加上XML文件（或者注解）组成。

映射器的配置元素

元素名称	描述	备注
select	查询语句
insert	插入语句	执行后返回一个整数，代表插入的条数
update	更新语句	执行后返回一个整数，代表更新的条数
delete	删除语句	执行后返回一个整数，代表删除的条数
sql	允许定义一部分sql，然后在各个地方引用它
resultMap	用来描述从数据库结果集中来加载对象	提供映射规则
cache	给定命名空间的缓存配置
cache-ref	其它命名空间缓存配置的引用

(1）映射器的构造

——select元素（查询语句）
select的配置元素：

元素	说明	备注
id	它和Mapper的命名空间组合起来是一致的，供MyBatis调用。	如果命名空间和id组合起来不唯一，MyBatis将抛出异常。
parameterType	将会传入这条语句的参数类的完全限定名或别名。
resultType	从这条语句中返回的期望类型的类的完全限定名或别名。注意集合情形，那应该是集合可以包含的类型，而不能是集合本身。使用 resultType或 resultMap，但不能同时使用。	统计总条数时可以把它的值设为int。
resultMap	它是映射集的引用，将执行强大的映射功能。使用 resultType或 resultMap，但不能同时使用。
flushCache	它的作用是在调用SQL之后，是否要求MyBatis清空之前查询本地缓存和二级缓存	取值为布尔值，默认为false
useCache	启动二级缓存的开关	取值为布尔值，默认为true
timeout	设置超时参数，超时将抛出异常，单位为秒	默认值是数据厂商提供的JDBC驱动所设置的秒数
fetchSize	获取记录的总条数设定	默认值是数据库厂商提供的JDBC驱动所设置的条数
statementType	告诉MyBatis使用哪个JDBC的Statement工作，STATEMENT,PREPARED 或 CALLABLE 的一种。这会让 MyBat is使用选择使用Statement，PreparedStatement或 CallableStatement。	默认值为PREPARED
resultSetType	FORWARD_ONLY（游标允许向前访问），SCROLL_SENSITIVE（双向滚动，但不及时更新），SCROLL_INSENSITIVE（双向滚动，并及时更新）中的一种。	默认值是数据库厂商提供的JDBC驱动所设置的
databaseId	数据库厂商标识	表示用于哪种数据库
resultOrdered	这个设置仅适用于嵌套结果select语句	取值为布尔值，默认为false
resultSets	适合于多个结果集的情况，它将列出执行SQL后每个结果集的名称，每个名称之间用逗号分割	——

在基础配置文件的setting中打开自动映射的开关，则如果编写的SQL列名和属性名保持一致，那么它就会形成自动映射。
自动映射的简单例子：

<select id="getRole" parameterType="long" resultType="role">
	select id, role_name as roleName, note from t_role where id=#{id}
</select>

如果系统严格按照驼峰命名法（比如，数据库字段为role_name，POJO属性名为roleName），则SQL语句可以改为:

select id, role_name, note from t_role where id=#{id}

如果sql需要传入多个参数，则可以使用注解@Param定义映射器的参数名称，接口方法如下：

public List<Role> findRolesByAnnotation(@Param("roleName") String rolename, @Param("note") String note);

则映射文件代码可以修改为：

<select id="findRolesByAnnotation" resultType="role">
	select id, role_name as roleName, note from t_role where role_name like concat('%', #{roleName}, '%') and note like concat('%', #{note}, '%')
</select>

此时不需要给出parameterType属性

——insert元素（插入语句）
insert使用的简单例子：

<insert id="insertRole" parameterType="role">
	insert into t_role(role_name, note) values(#{roleName}, #{note})
</insert>

JDBC中的Statement对象在执行插入的SQL后，可以通过getGeneratedKeys方法获得数据库生成的主键，这样便能达到获取主键的功能。
示例代码如下：

<insert id="insertRole" parameterType="role" useGeneratedKeys="true" keyProperty="id">
	insert into t_role(role_name, note) values(#{roleName}, #{note})
</insert>

useGeneratedKeys代表采用JDBC的Statement对象的getGeneratedKeys方法返回主键，而keyProperty则代表用哪个POJO的属性去匹配这个主键。

——update元素（更新语句）
update的简单使用：

<update id="updateRole" parameterType="role">
	update t_role set role_name = #{roleName}, note = #{note}
	 where id = #{id}
</update>

执行完毕会返回一个整数，代表该SQL语句影响了数据库的记录行数。

——delete元素（删除语句）
delete的简单使用：

<update id="updateRole" parameterType="long">
	delete from t_role where id = #{id}
</update>

与update类似，执行完毕会返回一个整数，代表该SQL语句影响了数据库的记录行数。

——sql元素
sql元素用于定义一条SQL的一部分，方便后面的SQL引用它。

简单使用：

<sql id="roleCols">
	id, role_name, note
</sql>
<select id="getRole" parameterType="long" resultMap="roleMap">
	select <include refid="roleCols"/> from t_role where id = #{id}
</select>

——resultMap元素
resultMap元素定义的主要是一个结果集的映射关系，也就是SQL到Java Bean的映射关系定义。

resultMap元素的子元素清单

<resultMap>
	<constructor>
		<idArg/>
		<arg/>
	</constructor>
	<id/>
	<result/>
	<association/>
	<collection/>
	<discriminator>
		<case/>
	</discriminator>
</resultMap>

一个POJO可能不存在没有参数的构造方法，需要使用constructor进行配置:

<constructor>
	<idArg column="id" javaType="int"/>
	<arg column="role_name" javaType="string"/>
</constructor>

使用resultMap映射结果集：

<mapper namespace="com.learn.ssm.chapter5.mapper.RoleMapper">
	<resultMap id="roleMap" type="role">
		<id property="id" column="id"/>
		<result property="roleName" column="role_name"/>
		<result property="note" column="note"/>
	</resultMap>
	<select id="getRoleUseResultMap" parameterType="long" resultMap="roleMap">
		select id, role_name, note from t_role where id = #{id}
	</select>
</mapper>

resultMap中type代表使用哪个类作为映射的类，id代表主键，result代表其属性，property代表POJO的属性名称，column代表SQL的列名；select中的resultMap代表采用哪个resultMap作为映射规则。

——级联

——cache 缓存
MyBatis分为一级缓存和二级缓存，一级缓存是在SqlSession上的缓存，二级缓存是在SqlSessionFactory上的缓存，默认情况下MyBatis会开启一级缓存。
开启二级缓存需要在映射文件中加入代码：

<cache/>

——存储过程

——动态SQL
动态SQL带来了极大的灵活性，减少了许多工作量。

if元素：

<select id="findRoles" parameterType="string" resultMap="roleResultMap">
	select role_no, role_name, note from t_role where 1=1
	<if test="roleName != null and roleName != ''">
		and role_name like concat('%', #{roleName}, '%')
	</if>
</select>

choose、when、otherwise元素（类似于switch…case…default…）：

<select id="findRoles" parameterType="role" resultMap="roleResultMap">
	select role_no, role_name, note from t_role where 1=1
	<choose>
		<when test="roleNo != null and roleNo != ''">
			and role_no = #{roleNo}
		</when>
		<when test="roleName != null and roleName != ''">
			and role_name like concat('%', #{roleName}, '%')
		</when>
		<otherwise>
			and note is not null
		</otherwise>
	</choose>
</select>

trim、where、set元素：

foreach元素（循环,用于遍历集合）：

<select id="findUserBySex" resultType="user">
	select * from t_role where role_no in 
	<foreach item="roleNo" index="index" collection="roleNoList" open="(" separator="," close=")">
		#{roleNo}
	</foreach>
</select>

collection配置的是传递进来的参数名称，可以是一个数组、List、Set等集合。
item配置的是循环中当前的元素。
index配置的是当前元素在集合的位置下标。
open和close配置的是以什么元素将这些集合元素包装起来。
separator是各个元素的间隔符。

bind元素：
bind元素的作用是通过OGNL表达式去自定义一个上下文变量，方便使用。

<select id="findRole" parameterType="string" resultType="role">
	<bind name="pattern" value="'%' + _parameter + '%'"/>
		select id, role_name as roleName, create_date as createDate,end_date as endFlag, end_flag as endFlag, note FROM t_role
		where role_name like #{pattern}
</select>

(2）引入映射器的方法

——方法1：用文件路径引入映射器

<mappers>
	<mapper resource="com/learn/ssm/chapter4/mapper/roleMapper.xml"/>
</mappers>

——方法2：用包名引入映射器

<mappers>
	<package name="com.learn.ssm.chapter4.mapper"/>
</mappers>

——方法3：用类注册引入映射器

<mappers>
	<mapper class="com.learn.ssm.chapter4.mapper.UserMapper"/>
	<mapper class="com.learn.ssm.chapter4.mapper.RoleMapper"/>
</mappers>

二、MyBatis核心组件

MyBatis的核心组件分为4个部分：

1. SqlSessionFactoryBuilder（构造器）：它会根据配置或者代码来生成SqlSessionFactory,采用的是分步构建的建造者模式。
2. SqlSessionFactory（工厂接口）：依靠它来生成SqlSession，使用的是工厂模式。
3. SqlSession（会话）：一个既可以发送SQL执行返回结果，也可以获取Mapper的接口。
4. SQL Mapper（映射器）：由一个Java接口和XML文件（或注解）构成，需要给出对应的SQL和映射规则，它负责发送SQL去执行，并返回结果。

1、SqlSessionFactory（工厂接口）

每个基于MyBatis的应用都是以一个SqlSessionFactory的实例为中心的，而SqlSessionFactory唯一的作用就是生产SqlSession，所以通常以单例模式处理它

通过XML构建SqlSessionFactory：

SqlSessionFactory SqlSessionFactory = null;
//读取基础配置文件
String resource = "mybatis-config.xml";
InputStream inputStream;
try {
	inputStream = Resources.getResourceAsStream(resource);
	//创建SqlSessionFactory
	sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
} catch (IOException e) {
	e.printStackTrace();
}

2、SqlSession（会话）

SqlSession的作用类似于一个JDBC中的Connection对象，代表着一个连接资源的启用。

创建SqlSession:

SqlSession sqlSession = SqlSessionFactory.openSession();

SqlSession事务控制代码：

//定义SqlSession
SqlSession sqlSession = null;
try{
	//打开sqlSession会话
	sqlSession = SqlSessionFactory.openSession();
	//some code....
	sqlSession.commit();//提交事务
}catch(Exception ex){
	sqlSession.rollback();//回滚事务
}finally{
	//在finally语句中确保资源被顺利关闭
	if(sqlSession != null){
		sqlSession.close();
	}
}

3、SQL Mapper（映射器）

映射器由一个接口和对应的XML文件构成。
映射器的主要作用就是将SQL查询到的结果映射为一个POJO，或者将POJO的数据插入到数据库中。

先定义一个POJO：

public class Role{
	private Long id;
	private String roleName;
	private String note;
}

定义一个映射器接口：

public interface RoleMapper{
	public Role getRole(Long id);
}

创建对应的xml文件：

<!-- namespace所对应的是一个映射器接口的全限定名 -->
<mapper namespace="com.learn.ssm.chapter3.mapper.RoleMapper">
	<select id="getRole" parameterType="long" resultType="role">
		select id, role_name as roleName, note from t_role where id = #{id}
	</select>
</mapper>

这时可以将映射器接口引入基础配置文件中：

<mapper resource="com/learn/ssm/chapter3/mapper/RoleMapper.xml"/>

此时就完成了映射器的构建与配置。

用映射器接口发送SQL：

RoleMapper roleMapper = sqlSession.getMapper(RoleMapper.class);
Role role = roleMapper.getRole(1L);

——————————————————————未完待续