MyBatis 基础知识二

第一：MyBatis 整体架构

第二： MyBatis CRUD操作:

2.1 查询

2.1.1 持久层接口中添加 getBookById 方法

/** 
	 * 根据图书编号获得图书对象 
	 */ 
	public Book getBookById(@Param("id") int id); 

2.1.2 映射配置文件中配置

    <!--获得图书对象通过编号 --> 
	<select id="getBookById" resultType="Book"> 
		select 
		id,title,price,publishDate from books where id=#{id} 
	</select> 
 
    resultType 属性： 
	    用于指定结果集的类型。 
    parameterType 属性： 
	    用于指定传入参数的类型。 
 
    select 标签： 
    id属性：当前名称空间下的statement的唯一标识。必须。要求id和mapper接口中的方法的名字一致。 
    resultType：将结果集映射为java的对象类型。必须（和 resultMap 二选一） 
    resultMap: 将结果集映射为Java的Map对象类型。必须（和resultType 二选一） 
    parameterType：传入参数类型。 

2.2 新增

2.2.1 在持久层接口中添加新增方法

    /** 
	 * 添加图书 
	 */ 
	public int add(Book entity);

2.2.2 映射配置文件中配置

    <!-- 增加 --> 
	<insert id="add" parameterType="com.zzg.sm.entity.Book"> 
		insert into books(title,price,publishDate) 
		values(#{title},#{price},#{publishDate}) 
	</insert> 
 
    parameterType 属性： 
        代表参数的类型，因为我们要传入的是一个类的对象，所以类型就写类的全名称。 
 
    sql 语句中使用#{}字符：  
        它代表占位符，相当于原来 jdbc 部分所学的?，都是用于执行语句时替换实际的数据。具体的数据是由                 
    #{}里面的内容决定的。 
 
    #{}中内容的写法： 
       由于我们保存方法的参数是 一个 User 对象，此处要写 User 对象中的属性名称。它用的是 ognl 表  
    达式。

insert 标签：

id：唯一标识，在同一个命名空间下保持唯一，使用动态代理之后要求和方法名保持一致
parameterType：参数的类型，使用动态代理之后和方法的参数类型一致
useGeneratedKeys:开启主键回写
keyColumn：指定数据库的主键
keyProperty：主键对应的pojo属性名

2.3 更新

2.3.1 在持久层接口中添加更新方法

    /** 
	 * 更新图书 
	 */ 
	public int update(Book entity); 

2.3.2 映射配置文件中配置

<!-- 更新 --> 
	<update id="update" parameterType="Book"> 
		update books 
		<set> 
			<if test="title != null and title != ''"> 
				title=#{title}, 
			</if> 
			<if test="price != null"> 
				price=#{price}, 
			</if> 
			<if test="publishDate != null"> 
				publishDate=#{publishDate}, 
			</if> 
		</set> 
		where id=#{id} 
	</update> 
 

update 标签：

id属性：当前名称空间下的statement的唯一标识(必须属性)；
parameterType：传入的参数类型，可以省略。

2.4 删除

2.4.1 在持久层接口中添加删除方法

	/** 
	 * 根据图书编号删除图书 
	 */ 
	public int delete(int id);

2.4.2 映射配置文件中配置

    <!-- 删除 --> 
	<delete id="delete"> 
		delete from books where id=#{id} 
	</delete>

delete 标签

id属性：当前名称空间下的statement的唯一标识(必须属性)；
parameterType：传入的参数类型，可以省略。

2.5 模糊查询

2.5.1 在持久层接口中添加模糊查询方法

    /** 
	 * 根据图书名称获取图书对象 
	 * @param name 
	 * @return 
	 */ 
	public Book getBookByName(String name);

2.5.2 映射配置文件中配置

<!--根据图书名称获取图书对象  --> 
	<select id="getBookByName" resultType="Book" parameterType="java.lang.String"> 
		select 
		id,title,price,publishDate from books where title like #{name} 
	</select>

2.5.3 模糊查询测试方法：

public class SMTest { 
	 
	public static void main(String[] args) { 
		 ApplicationContext ctx=new ClassPathXmlApplicationContext("sm.xml"); 
		 BookService  bookservice=ctx.getBean(BookService.class); 
 
         Book object = bookservice.getBookByName("Java%"); 
		 if(object != null) { 
			 System.out.println(object.getId()); 
			 System.out.println(object.getTitle()); 
		 } 
		  
	} 
}

2.5.4 模糊查询优化查询配置方式

/** 
	 * 根据图书名称获取图书对象 
	 * @param name 
	 * @return 
	 */ 
	public Book getBookByName(@Param(value = "name") String name);

    <!--根据图书名称获取图书对象  --> 
	<select id="getBookByName" resultType="Book" parameterType="String"> 
		select 
		id,title,price,publishDate from books where title like '%${name}%' 
	</select>

2.5.5 #{}与${}的区别

#{}表示一个占位符号 
    通过#{}可以实现 preparedStatement 向占位符中设置值，自动进行 java 类型和 jdbc 类型转换， 
#{}可以有效防止 sql 注入。 #{}可以接收简单类型值或 pojo 属性值。 如果 parameterType 传输单个简单类型值，#{}括号中可以是 value 或其它名称。 
 
${}表示拼接 sql 串 
    通过${}可以将 parameterType 传入的内容拼接在 sql 中且不进行 jdbc 类型转换， ${}可以接收简 
单类型值或 pojo 属性值，如果 parameterType 传输单个简单类型值，${}括号中只能是 value。

2.6 聚合函数

2.6.1 在持久层接口中添加聚合函数方法

    /** 
	 * 图书总数统计 
	 * @return 
	 */ 
	public int getTotal();

2.6.2 映射配置文件中配置

    <!--图书总数统计  --> 
	<select id="getTotal" resultType="Integer"> 
		select count(1) from books; 
	</select>

第三： MyBatis SqlMapConfig.xml配置文件

3.1 SqlMapConfig.xml 中配置的内容和顺序

-properties（属性） 
    --property 
-settings（全局配置参数） 
    --setting 
-typeAliases（类型别名） 
    --typeAliase 
    --package 
-typeHandlers（类型处理器） 
-objectFactory（对象工厂） 
-plugins（插件） 
-environments（环境集合属性对象） 
    --environment（环境子属性对象） 
        ---transactionManager（事务管理） 
        ---dataSource（数据源） 
-mappers（映射器） 
    --mapper 
    --package

3.2 properties 配置方式

3.2.1 配置方式一：

在 classpath 下定义 jdbc.properties 文件

jdbc.driverClass=com.mysql.cj.jdbc.Driver 
jdbc.url=jdbc:mysql://localhost:3306/myblog?useSSL=false&serverTimezone=UTC&&allowPublicKeyRetrieval=true 
jdbc.username=root 
jdbc.password=123456

properties 标签配置

<!-- 配置连接数据库的信息 
resource 属性：用于指定 properties 配置文件的位置，要求配置文件必须在类路径下 
resource="jdbcConfig.properties" 
 
url 属性： 
URL： Uniform Resource Locator 统一资源定位符 
http://localhost:8080/mystroe/CategoryServlet URL 
协议 主机 端口 URI 
URI：Uniform Resource Identifier 统一资源标识符 
/mystroe/CategoryServlet 
它是可以在 web 应用中唯一定位一个资源的路径 
--> 
 
<properties resource="jdbc.properties"></properties>

此时我们的 dataSource 标签就变成了引用上面的配置

<?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> 
 
	<properties resource="jdbc.properties"></properties> 
	 
	<!-- 配置 mybatis 的环境 --> 
	<environments default="mysql"> 
		<!-- 配置 mysql 的环境 --> 
		<environment id="mysql"> 
			<!-- 配置事务的类型 --> 
			<transactionManager type="JDBC"></transactionManager> 
			<!-- 配置连接数据库的信息：用的是数据源(连接池) --> 
			<dataSource type="POOLED"> 
				<property name="driver" value="${jdbc.driverClass}" /> 
				<property name="url" 
					value="${jdbc.url}" /> 
				<property name="username" value="${jdbc.username}" /> 
				<property name="password" value="${jdbc.password}" /> 
			</dataSource> 
		</environment> 
	</environments> 
	<!-- 告知 mybatis 映射配置的位置 --> 
	<mappers> 
		<!-- 基础版本 --> 
		<!-- <mapper resource="com/zzg/jdbc/mybatis/dao/IUserDao.xml" /> --> 
		<!-- 注解版本 --> 
		<mapper class="com.zzg.jdbc.mybatis.dao.IUserDao" /> 
	</mappers> 
</configuration>

3.2.1 配置方式二：

<?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> 
 
	<properties>  
		<property name="jdbc.driverClass" value="com.mysql.cj.jdbc.Driver"/> 
		<property name="jdbc.url" value="jdbc:mysql://localhost:3306/myblog?useSSL=false&amp;serverTimezone=UTC&amp;allowPublicKeyRetrieval=true"/> 
		<property name="jdbc.username" value="root"/> 
		<property name="jdbc.password" value="123456"/> 
	</properties> 
	 
	<!-- 配置 mybatis 的环境 --> 
	<environments default="mysql"> 
		<!-- 配置 mysql 的环境 --> 
		<environment id="mysql"> 
			<!-- 配置事务的类型 --> 
			<transactionManager type="JDBC"></transactionManager> 
			<!-- 配置连接数据库的信息：用的是数据源(连接池) --> 
			<dataSource type="POOLED"> 
				<property name="driver" value="${jdbc.driverClass}" /> 
				<property name="url" 
					value="${jdbc.url}" /> 
				<property name="username" value="${jdbc.username}" /> 
				<property name="password" value="${jdbc.password}" /> 
			</dataSource> 
		</environment> 
	</environments> 
	<!-- 告知 mybatis 映射配置的位置 --> 
	<mappers> 
		<!-- 基础版本 --> 
		<!-- <mapper resource="com/zzg/jdbc/mybatis/dao/IUserDao.xml" /> --> 
		<!-- 注解版本 --> 
		<mapper class="com.zzg.jdbc.mybatis.dao.IUserDao" /> 
	</mappers> 
</configuration>

3.3 settings配置说明：

MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。 下表描述了设置中各项设置的含义、默认值等

设置名	描述	有效值	默认值
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。	true | false	true
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态。	true | false	false
aggressiveLazyLoading	开启时，任一方法的调用都会加载该对象的所有延迟加载属性。 否则，每个延迟加载属性会按需加载（参考 lazyLoadTriggerMethods)。	true | false	false （在 3.4.1 及之前的版本中默认为 true）
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 执行器会重用预处理语句（PreparedStatement）； BATCH 执行器不仅重用语句还会执行批量更新。	SIMPLE REUSE BATCH	SIMPLE
defaultStatementTimeout	设置超时时间，它决定数据库驱动等待数据库响应的秒数。	任意正整数	未设置 (null)
defaultFetchSize	为驱动的结果集获取数量（fetchSize）设置一个建议值。此参数只可以在查询设置中被覆盖。	任意正整数	未设置 (null)
defaultResultSetType	指定语句默认的滚动策略。（新增于 3.5.2）	FORWARD_ONLY | SCROLL_SENSITIVE | SCROLL_INSENSITIVE | DEFAULT（等同于未设置）	未设置 (null)
safeRowBoundsEnabled	是否允许在嵌套语句中使用分页（RowBounds）。如果允许使用则设置为 false。	true | false	False
safeResultHandlerEnabled	是否允许在嵌套语句中使用结果处理器（ResultHandler）。如果允许使用则设置为 false。	true | false	True
mapUnderscoreToCamelCase	是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn。	true | false	False
localCacheScope	MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 默认值为 SESSION，会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。	SESSION | STATEMENT	SESSION
jdbcTypeForNull	当没有为参数指定特定的 JDBC 类型时，空值的默认 JDBC 类型。 某些数据库驱动需要指定列的 JDBC 类型，多数情况直接用一般类型即可，比如 NULL、VARCHAR 或 OTHER。	JdbcType 常量，常用值：NULL、VARCHAR 或 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会返回一个空实例。 请注意，它也适用于嵌套的结果集（如集合或关联）。（新增于 3.4.2）	true | false	false
logPrefix	指定 MyBatis 增加到日志名称的前缀。	任何字符串	未设置
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找。	SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING | NO_LOGGING	未设置
proxyFactory	指定 Mybatis 创建可延迟加载对象所用到的代理工具。	CGLIB | JAVASSIST	JAVASSIST （MyBatis 3.3 以上）
vfsImpl	指定 VFS 的实现	自定义 VFS 的实现的类全限定名，以逗号分隔。	未设置
useActualParamName	允许使用方法签名中的名称作为语句参数名称。 为了使用该特性，你的项目必须采用 Java 8 编译，并且加上 -parameters 选项。（新增于 3.4.1）	true | false	true
configurationFactory	指定一个提供 Configuration 实例的类。 这个被返回的 Configuration 实例用来加载被反序列化对象的延迟加载属性值。 这个类必须包含一个签名为static Configuration getConfiguration() 的方法。（新增于 3.2.3）	一个类型别名或完全限定类名。	未设置

3.4  typeAliases（类型别名）

3.4.1 自定义别名

在 SqlMapConfig.xml 中配置： 
<typeAliases> 
<!-- 单个别名定义 -->  
<typeAlias alias="user" type="com.zzg.jdbc.mybatis.entity.User"/> 
<!-- 批量别名定义，扫描整个包下的类，别名为类名（首字母大写或小写都可以） -->  
<package name="com.zzg.jdbc.mybatis.entity"/> 
<package name="其它包"/> 
</typeAliases>

3.5  mappers（映射器）

3.5.1 <mapper resource=" " />
使用相对于类路径的资源
如：<mapper resource="com/itheima/dao/IUserDao.xml" />

3.5.2 <mapper class=" " />
使用 mapper 接口类路径
如：<mapper class="com.itheima.dao.UserDao"/>
注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

 
3.5.3 <package name=""/>
注册指定包下的所有 mapper 接口
如：<package name="cn.itcast.mybatis.mapper"/>
注意：此种方法要求 mapper 接口名称和 mapper 映射文件名称相同，且放在同一个目录中。

 

3.6  typeHandlers（类型处理器）

       无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。可以重写类型处理器或创建你自己的类型处理器来处理不支持的或非标准的类型。

 

3.7 plugins（插件）拦截器

MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed) 
 
ParameterHandler (getParameterObject, setParameters) 
 
ResultSetHandler (handleResultSets, handleOutputParameters) 
 
StatementHandler (prepare, parameterize, batch, update, query) 
 

现在一些MyBatis 插件比如PageHelper都是基于这个原理，有时为了监控sql执行效率，也可以使用插件机制原理：

自定义分页插件

package com.zzg.jdbc.mybatis.plugins; 
 
public class Page{ 
	private int offset; 
	private int limit; 
 
	public Page(int offset, int limit) { 
		super(); 
		this.offset = offset; 
		this.limit = limit; 
	} 
	 
	public int getOffset() { 
		return offset; 
	} 
	public void setOffset(int offset) { 
		this.offset = offset; 
	} 
	public int getLimit() { 
		return limit; 
	} 
	public void setLimit(int limit) { 
		this.limit = limit; 
	} 
} 
 
 
package com.zzg.jdbc.mybatis.plugins; 
 
public class PageUtil { 
	private static final ThreadLocal<Page> LOCAL_PAGE = new ThreadLocal<Page>(); 
 
    public static void setPagingParam(int offset, int limit) { 
        Page page = new Page(offset, limit); 
        LOCAL_PAGE.set(page); 
    } 
 
    public static void removePagingParam() { 
        LOCAL_PAGE.remove(); 
    } 
 
    public static Page getPaingParam() { 
        return LOCAL_PAGE.get(); 
    } 
 
} 
 
 
package com.zzg.jdbc.mybatis.plugins; 
 
import org.apache.ibatis.mapping.BoundSql; 
import org.apache.ibatis.mapping.SqlSource; 
 
public class BoundSqlSqlSource implements SqlSource { 
	private BoundSql boundSql; 
 
	public BoundSqlSqlSource(BoundSql boundSql) { 
		this.boundSql = boundSql; 
	} 
 
	@Override 
	public BoundSql getBoundSql(Object parameterObject) { 
		// TODO Auto-generated method stub 
		return boundSql; 
	} 
 
} 
 
 
package com.zzg.jdbc.mybatis.plugins; 
 
import java.util.Properties; 
 
import org.apache.ibatis.executor.Executor; 
import org.apache.ibatis.mapping.BoundSql; 
import org.apache.ibatis.mapping.MappedStatement; 
import org.apache.ibatis.plugin.Interceptor; 
import org.apache.ibatis.plugin.Intercepts; 
import org.apache.ibatis.plugin.Invocation; 
import org.apache.ibatis.plugin.Plugin; 
import org.apache.ibatis.plugin.Signature; 
import org.apache.ibatis.session.ResultHandler; 
import org.apache.ibatis.session.RowBounds; 
 
import com.google.common.base.Joiner; 
 
/** 
 * 分页插件  
 * @author Administrator 
 * 
 */ 
@Intercepts({ 
    @Signature( 
            type = Executor.class, 
            method = "query", 
            args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class} 
    ) 
}) 
public class PageInterceptor implements Interceptor { 
	private static int MAPPEDSTATEMENT_INDEX = 0; 
 
    private static int PARAMETER_INDEX = 1; 
 
    private static int ROWBOUNDS_INDEX = 2; 
 
    @Override 
    public Object intercept(Invocation invocation) throws Throwable { 
 
        // 从 Invocation 中获取参数 
        final Object[] queryArgs = invocation.getArgs(); 
        final MappedStatement ms = (MappedStatement) queryArgs[MAPPEDSTATEMENT_INDEX]; 
        final Object parameter = queryArgs[PARAMETER_INDEX]; 
 
        //  获取分页参数 
        Page paingParam = PageUtil.getPaingParam(); 
        if (paingParam != null) { 
 
            // 构造新的 sql, select xxx from xxx where yyy limit offset,limit 
            final BoundSql boundSql = ms.getBoundSql(parameter); 
            String pagingSql = getPagingSql(boundSql.getSql(), paingParam.getOffset(), paingParam.getLimit()); 
 
            // 设置新的 MappedStatement 
            BoundSql newBoundSql = new BoundSql(ms.getConfiguration(), pagingSql, 
                    boundSql.getParameterMappings(), boundSql.getParameterObject()); 
            MappedStatement mappedStatement = newMappedStatement(ms, newBoundSql); 
            queryArgs[MAPPEDSTATEMENT_INDEX] = mappedStatement; 
 
            // 重置 RowBound 
            queryArgs[ROWBOUNDS_INDEX] = new RowBounds(RowBounds.NO_ROW_OFFSET, RowBounds.NO_ROW_LIMIT); 
        } 
        Object result = invocation.proceed(); 
        PageUtil.removePagingParam(); 
        return result; 
    } 
 
    @Override 
    public Object plugin(Object o) { 
        return Plugin.wrap(o, this); 
    } 
 
    @Override 
    public void setProperties(Properties properties) { 
 
    } 
 
    /** 
     * 创建 MappedStatement 
     * @param ms 
     * @param newBoundSql 
     * @return 
     */ 
    private MappedStatement newMappedStatement(MappedStatement ms, BoundSql newBoundSql) { 
        MappedStatement.Builder builder = new MappedStatement.Builder(ms.getConfiguration(), ms.getId(), 
                new BoundSqlSqlSource(newBoundSql), ms.getSqlCommandType()); 
        builder.keyColumn(delimitedArrayToString(ms.getKeyColumns())); 
        builder.keyGenerator(ms.getKeyGenerator()); 
        builder.keyProperty(delimitedArrayToString(ms.getKeyProperties())); 
        builder.lang(ms.getLang()); 
        builder.resource(ms.getResource()); 
        builder.parameterMap(ms.getParameterMap()); 
        builder.resultMaps(ms.getResultMaps()); 
        builder.resultOrdered(ms.isResultOrdered()); 
        builder.resultSets(delimitedArrayToString(ms.getResultSets())); 
        builder.resultSetType(ms.getResultSetType()); 
        builder.timeout(ms.getTimeout()); 
        builder.statementType(ms.getStatementType()); 
        builder.useCache(ms.isUseCache()); 
        builder.cache(ms.getCache()); 
        builder.databaseId(ms.getDatabaseId()); 
        builder.fetchSize(ms.getFetchSize()); 
        builder.flushCacheRequired(ms.isFlushCacheRequired()); 
        return builder.build(); 
    } 
 
    public String getPagingSql(String sql, int offset, int limit) { 
        StringBuilder result = new StringBuilder(sql.length() + 100); 
        result.append(sql).append(" limit "); 
 
        if (offset > 0) { 
            result.append(offset).append(",").append(limit); 
        }else{ 
            result.append(limit); 
        } 
        return result.toString(); 
    } 
 
    public String delimitedArrayToString(String[] array) { 
 
        if (array == null || array.length == 0) { 
            return ""; 
        } 
        Joiner joiner = Joiner.on(","); 
        return joiner.join(array); 
    } 
 
 
} 
 
 
<?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> 
 
	<properties>  
		<property name="jdbc.driverClass" value="com.mysql.cj.jdbc.Driver"/> 
		<property name="jdbc.url" value="jdbc:mysql://localhost:3306/myblog?useSSL=false&amp;serverTimezone=UTC&amp;allowPublicKeyRetrieval=true"/> 
		<property name="jdbc.username" value="root"/> 
		<property name="jdbc.password" value="123456"/> 
	</properties> 
	 
	 
	<plugins> 
    	<plugin interceptor="com.zzg.jdbc.mybatis.plugins.PageInterceptor"> 
    	</plugin>   	  
	</plugins>  
	 
	<!-- 配置 mybatis 的环境 --> 
	<environments default="mysql"> 
		<!-- 配置 mysql 的环境 --> 
		<environment id="mysql"> 
			<!-- 配置事务的类型 --> 
			<transactionManager type="JDBC"></transactionManager> 
			<!-- 配置连接数据库的信息：用的是数据源(连接池) --> 
			<dataSource type="POOLED"> 
				<property name="driver" value="${jdbc.driverClass}" /> 
				<property name="url" 
					value="${jdbc.url}" /> 
				<property name="username" value="${jdbc.username}" /> 
				<property name="password" value="${jdbc.password}" /> 
			</dataSource> 
		</environment> 
	</environments> 
	<!-- 告知 mybatis 映射配置的位置 --> 
	<mappers> 
		<!-- 基础版本 --> 
		<mapper resource="com/zzg/jdbc/mybatis/dao/IUserDao.xml" />  
		<!-- 注解版本 --> 
		<!-- <mapper class="com.zzg.jdbc.mybatis.dao.IUserDao" /> --> 
	</mappers> 
	  
 
</configuration> 
 
package com.zzg.jdbc.mybatis.test; 
 
import java.io.IOException; 
import java.io.InputStream; 
import java.util.List; 
 
import org.apache.ibatis.io.Resources; 
import org.apache.ibatis.session.SqlSession; 
import org.apache.ibatis.session.SqlSessionFactory; 
import org.apache.ibatis.session.SqlSessionFactoryBuilder; 
 
import com.zzg.jdbc.mybatis.dao.IUserDao; 
import com.zzg.jdbc.mybatis.entity.User; 
import com.zzg.jdbc.mybatis.plugins.PageUtil; 
 
public class MybatisTest { 
 
	public static void main(String[] args) throws IOException { 
		//1.读取配置文件 
		InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml"); 
		//2.创建 SqlSessionFactory 的构建者对象 
		SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); 
		//3.使用构建者创建工厂对象 SqlSessionFactory 
		SqlSessionFactory factory = builder.build(in); 
		//4.使用 SqlSessionFactory 生产 SqlSession 对象 
		SqlSession session = factory.openSession(); 
		PageUtil.setPagingParam(1, 2); 
		//5.使用 SqlSession 创建 dao 接口的代理对象 
		IUserDao userDao = session.getMapper(IUserDao.class); 
		//6.使用代理对象执行查询所有方法 
		List<User> users = userDao.findAll(); 
		for(User user : users) { 
		System.out.println(user); 
		} 
		//7.释放资源 
		session.close(); 
		in.close(); 
 
	} 
 
} 

3.8 environments(环境)

MyBatis 可以配置成适应多种环境，例如，开发、测试和生产环境需要有不同的配置；尽管可以配置多个环境，SqlSessionFactory 实例只能选择其一。虽然，这种方式也可以做到很方便的分离多个环境，但是实际使用场景下，我们更多的是选择使用spring来管理数据源，来做到环境的分离。