【Mybatis】Mybatis学习笔记
目录
文章目录
- 目录
- Mybatis学习笔记
-
- 1. JDBC实现过程
-
- 1.1 步骤
- 1.2 代码
- 2. JDBC问题
-
-
- 2.1 连接建立和释放
- 2.2 SQL统一存取
- 2.3 传入的参数映射和动态sql
- 2.4 结果映射和结果缓存
- 2.5 重复sql
-
- 3. JDBC演变为Mybatis
- 4. Mybatis的使用
-
-
- 4.1 建立Mybatis配置文件
- 4.2 编写mapper(dao)层接口
- 4.3 编写mapper对应xml文件
- 4.4 service层调用获取结果
- Maybatis中SQL相关操作
-
- delete 删除
- update 修改
- select 查询
-
- 1. 单实体查询
- 2. 列表查询
- 分页实现
-
- 1.普通实现
- 2. 分页插件实现
- 各种标签的使用
-
- 1. where和if标签
- 2. foreach标签
- 3. set标签
- ResultMap 的使用
- 事务(回滚)
- sql注入问题
-
- 5.Mybatis原理
-
-
- Mybatis的一级缓存和二级缓存
-
- 一级缓存
- 二级缓存
- 5.1 TypeHandler
- 5.2 ResultSetHandler
- 5.3 ParameterHandler
- 5.4 BoundSql
- 5.5 SqlSource
- 5.6 MappedStatement
- 5.7 StatementHandler
- 5.8 Executor
- 5.9 SqlSession
-
Mybatis学习笔记
从Mybatis到Mybatis-plus,这项技术也陪伴我走过了许多spingboot项目,然而对它的是实现原理却很陌生,只是记得它大大简化了JDBC的繁琐配置,在实际开发时将sql语句与java文件进行了解耦,还能够自动的将数据库对象与java对象进行映射,去掉了大量重复工作,真的是懒人的福音.所以现就这项技术的发展进行梳理,并好好学习一下它的实现原理
1. JDBC实现过程
1.1 步骤
最基础的通过JDBC查询数据库数据，一般需要以下七个步骤：
- 加载JDBC驱动；
- 建立并获取数据库连接；
- 创建 JDBC Statements 对象；
- 设置SQL语句的传入参数；
- 执行SQL语句并获得查询结果；
- 对查询结果进行转换处理并将处理结果返回；
- 释放相关资源（关闭Connection，关闭Statement，关闭ResultSet）；
1.2 代码
public class JDBCDao {
public List<User> findUserListGtAge(int age){
//JDBC配置信息
String url = "jdbc:mysql://localhost:3306/database? serverTimezone=UTC&characterEncoding=utf-8";
String name = "root";
String password = "root";
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
//1. 加载JDBC驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//2. 建立并获取数据库连接
connection = DriverManager.getConnection(url,name,password);
//3. 设置SQL语句 创建 JDBC Statements 对象
String sql = "select * from m_user where age > ?";
preparedStatement = connection.prepareStatement(sql);
//4. 设置SQL语句的传入参数
preparedStatement.setInt(1,age);
//5. 执行SQL语句并获得查询结果
resultSet = preparedStatement.executeQuery();
List<User> userList = new ArrayList<>();
while (resultSet.next()){
//6. 对查询结果进行转换处理并将处理结果返回
long id = resultSet.getLong("id");
String username = resultSet.getString("username");
int age1 = resultSet.getInt("age");
User user = new User();
user.setId(id);
user.setUsername(username);
user.setAge(age1);
userList.add(user);
}
return userList;
} catch (Exception e) {
e.printStackTrace();
return Collections.emptyList();
}finally {
try {
//7. 释放相关资源（关闭Connection，关闭Statement，关闭ResultSet）
if (resultSet != null){
resultSet.close();
}
if (preparedStatement != null){
preparedStatement.close();
}
if (connection != null){
connection.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
2. JDBC问题
分析上述代码我们不难发现, 作为数据库交互类的仅仅一个方法已经显得十分臃肿, 真实的业务中有大量的相似的方法, 这就意味着每有一个方法这七个步骤都要重复写一遍, 可见这些代码仍有很大的优化空间, 通过分析其中的问题及解决方法, 我们对Mybatis做了什么就能有一个大致的了解
2.1 连接建立和释放
- 问题：数据库连接频繁的开启和关闭本身就造成了资源的浪费，影响系统的性能
- 解决：**数据库连接池 **
2.2 SQL统一存取
- 问题：sql散落在不同的java文件中，可读性很差，不利于维护（修改sql语句，sql调优等非常麻烦）
- 解决：不把sql写到java代码中，抽取出来，放入统一的一个地方，比如配置文件，使用id进行匹配
2.3 传入的参数映射和动态sql
- 问题：设置占位符来达到使用传入参数的目的，按照一定顺序传入参数的，要与占位符一一匹配。但是，如果我们传入的参数是不确定的（比如列表查询，根据用户填写的查询条件不同，传入查询的参数也是不同的，有时是一个参数、有时可能是三个参数），那么我们就得在后台代码中自己根据请求的传入参数去拼凑相应的SQL语句，这样的话还是避免不了在Java代码里面写SQL语句的命运。
- 动态sql问题：怎么做到能够根据前台传入参数的不同，动态生成对应的SQL语句呢？
- 解决：第一个问题，可以用一种有别于SQL的语法来嵌入变量（比如使用＃变量名＃），这样，SQL语句经过解析后就可以动态的生成符合上下文的SQL语句。第二个问题，可以在sql语句中，使用 这样的标签，通过特定的sql解析器来去解析，设定类似 在test中写对应的判断语句。
2.4 结果映射和结果缓存
- 问题：每次执行完sql语句，要从结果集获取数据，以及要对结果进行封装，要写大量的代码
- 解决：期望有一个sql处理器，只需要告诉它，1.需要返回什么类型的对象，2.需要返回的对象的数据结构和结果的映射，同时还可以对结果数据做缓存，提升性能
2.5 重复sql
- 问题：sql语句很多都是where语句后面的部分不一样，重复语句，无意义，查询的字段有很多也是重复的(select aaa,bbb from)
- 解决：提取重复的sql片段
3. JDBC演变为Mybatis
mybatis是一个持久层框架，用java编写的。
它封装了jdbc操作的很多细节，使开发者只需要关注sql语句本身，而无需关注注册驱动，创建连接等繁杂过程
它使用了ORM思想实现了结果集的封装。
ORM：
Object Relational Mappging 对象关系映射
简单的说：
就是把数据库表和实体类及实体类的属性对应起来
让我们可以操作实体类就实现操作数据库表。
4. Mybatis的使用
Mybatis的使用大致分为四个步骤:
1. 配置Mybatis
2. 编写mapper(dao)层对应接口
3. 建立mapper接口对应的xml文件将方法名和返回类型进行映射 其中统一写sql语句
4. service层直接调用接口方法(非springboot自动注入需要自行通过sql会话获取mapper对象)
以下代码配置和使用的某些步骤为 mybatis的单独使用, 了解即可, 实际应用中以与spring相结合为主
4.1 建立Mybatis配置文件
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" />
<dataSource type="POOLED">
<property name="driver" value="com.mysql.cj.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/database?serverTimezone=UTC&characterEncoding=utf-8" />
<property name="username" value="root" />
<property name="password" value="root" />
dataSource>
environment>
environments>
<mappers>
<mapper resource="com/myproject/mybatis/dao/UserDao.xml" />
mappers>
configuration>
4.2 编写mapper(dao)层接口
public interface UserDao {
public User findUser(Long id);
}
4.3 编写mapper对应xml文件
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.myproject.mybatis.dao.UserDao">
<select id="findUser" parameterType="long" resultType="com.myproject.mybatis.pojo.User">
select * from m_user where id = #{id}
select>
mapper>
4.4 service层调用获取结果
public class UserService {
public User findUser(Long id) {
SqlSession sqlSession = null;
try {
//1. 获取mybatis的配置文件并加载
Reader resourceReader = Resources.getResourceAsReader("MybatisConfig.xml");
//2. 构建sqlSession工厂
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceReader);
//3. 生产sqlSession
sqlSession = build.openSession();
//4. 获取UserMapper(UserDao)
UserMapper mapper =sqlSession.getMapper(UserMapper.class);
User user = mapper.findUser(id);
return user;
} catch(Exception e){
e.printStackTrace();
}finally{
if(sqlSession != null){
sqlSession.close();
}
}
return null;
}
}
Maybatis中SQL相关操作
#### insert 增加
<insert id="save" parameterType="com.myprojext.mybatis.pojo.User" keyProperty="id" useGeneratedKeys="true">
insert into m_user (username,age) values(#{username},#{age})
insert>
keyProperty=“id” useGeneratedKeys=“true” 代表将自增的id 辅助给User对象的id属性
delete 删除
<delete id="delete" parameterType="long">
delete from m_user where id=#{id}
delete>
update 修改
<update id="delete" parameterType="com.myprojext.mybatis.pojo.User">
update m_user
set username=#{username},
age=#{age}
where id=#{id}
update>
select 查询
1. 单实体查询
<select id="findUser" parameterType="long" resultType="com.myproject.mybatis.pojo.User">
select * from m_user where id = #{id}
select>
2. 列表查询
<select id="findUserListGtAge" parameterType="int" resultType="com.myproject.mybatis.pojo.User">
select * from m_user where age > #{age}
select>
分页实现
1.普通实现
<select id="findUserListPage" parameterType="map" resultType="com.myproject.mybatis.pojo.User">
select * from m_user limit #{index},#{size}
select>
<select id="countUserListPage" resultType="java.lang.Long">
select count(1) from m_user
select>
普通实现就是通过获取要查信息的总条数, 自行计算分页和索引, 向sql语句中传入多个参数来达到到分页的效果
2. 分页插件实现
pom.xml导入分页插件依赖
<dependency>
<groupId>com.github.pagehelpergroupId>
<artifactId>pagehelperartifactId>
<version>5.2.0version>
dependency>
MybatisConfig.xml即mybatis配置文件中添加分页拦截器
<plugins>
<plugin interceptor="com.github.pagehelper.PageInterceptor">
plugin>
plugins>
<select id="findUserList" resultType="com.myproject.mybatis.pojo.User">
select * from m_user
select>
各种标签的使用
1. where和if标签
select * from m_user where and age > 0 and age < 22
这条语句在第一个and处会报错,但使用where标签如下则不会报错, 但在Mybatis-plus中仍会报错要在第一个and前添加 1=1 进行处理使其兼容后面的 未知个***and 条件***
if标签进行判断, 若满足则标签下的语句才加入请求数据库的sql语句, 否则为空字符, 这也是前面where要兼容后面多个统一***and 条件*** 格式的原因
标签中的 ‘<’ 要用转义字符 ‘<’ 代替
<select id="findUserListByCondition" parameterType="int" resultType="com.myproject.mybatis.pojo.User">
select *from g_user
<where>
<if test="age > 0">
and age > 0
if>
<if test="age < 15">
and age < 22
if>
where>
select>
2. foreach标签
<select id="findUserListByIds" parameterType="arraylist" resultType="com.myproject.mybatis.pojo.User">
select *from g_user
<where>
<if test="userIdList != null and userIdList.size > 0">
id in
<foreach collection="userIdList" item="userId" separator="," open="(" close=")">
#{userId}
foreach>
if>
where>
select>
3. set标签
<update id="update" parameterType="com.myproject.mybatis.pojo.User">
update m_user
<set>
username=#{username},
age=#{age},
set>
where id=#{id}
update>
使用set标签，后面多一个逗号也无所谓
ResultMap 的使用
使用场景: 当数据库表中字段与实体类属性名称不一致时, 规定resultType无法自动进行数据库表与实体类的映射, 比如 实体类中属性名 idCard 表中字段 id_card 映射时需要ResultMap辅助映射,并标注resultMap
<resultMap id="user" type="com.myproject.mybatis.pojo.User">
<id column="id" property="id"/>
<result column="username" property="username"/>
<result column="age" property="age"/>
<result column="id_card" property="idCard"/>
resultMap>
<select id="findUserListByIds" parameterType="arraylist" resultMap="user">
select * from m_user
<where>
<if test="userIdList != null and userIdList.size > 0">
id in
<foreach collection="userIdList" item="userId" separator="," open="(" close=")">
#{userId}
foreach>
if>
where>
select>
事务(回滚)
public int updateUser(User user){
SqlSession sqlSession = null;
try {
//1. 获取mybatis的配置文件 并加载
Reader resourceAsReader = Resources.getResourceAsReader("MybatisConfig.xml");
//2. 构建sqlSession工厂
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsReader);
//3. 生产sqlSession true代表自动提交
sqlSession = build.openSession(true);
//4. 获取UserDao
UserDao userDao = sqlSession.getMapper(UserDao.class);
int update = userDao.update(user);
//事务处理 抛异常了
int i = 10/0;
return update;
} catch (IOException e) {
e.printStackTrace();
}finally {
if (sqlSession != null){
sqlSession.close();
}
}
return -1;
}
- 自动提交不能使用回滚
- 已经提交的数据不能回滚
public int updateUser(User user){
SqlSession sqlSession = null;
try {
//1. 获取mybatis的配置文件 并加载
Reader resourceAsReader = Resources.getResourceAsReader("MybatisConfig.xml");
//2. 构建sqlSession工厂
SqlSessionFactory build = new SqlSessionFactoryBuilder().build(resourceAsReader);
//3. 生产sqlSession true代表自动提交
sqlSession = build.openSession();
//4. 获取UserDao
UserDao userDao = sqlSession.getMapper(UserDao.class);
int update = userDao.update(user);
//事务 抛异常了
int i = 10/0;
sqlSession.commit();
return update;
} catch (Exception e) {
e.printStackTrace();
//回滚
sqlSession.rollback();
}finally {
if (sqlSession != null){
sqlSession.close();
}
}
return -1;
}
尽可能在事务最后进行提交,当捕获异常后使用sqlSession.rollback()进行数据的回滚
sql注入问题
<select id="findUserByName" parameterType="string" resultType="com.myproject.mybatis.pojo.User">
select * from m_user where username = ${username}
select>
<select id="findUserByName" parameterType="string" resultType="com.myproject.mybatis.pojo.User">
select * from m_user where username = #{username}
select>
#{}是经过预编译的, 是安全的, 会对传入的数据加一个双引号
JDBC中相当于
String sql = "select id, username, password from m_user where id=?";
PreparedStatement ps = conn.prepareStatement(sql);
ps.setString(1, id);
ResultSet rs=ps.executeUpdate();
${}是未经过预编译的, 是非安全的, 会将传入的数据直接显示生成在sql, 中存在SQL注入
JDBC中相当于
String sql = "select id,username,password,role from user where id=" + id;
//当id参数为"3;drop table user;"时，执行的sql语句如下:
//select id,username,password from m_user where id=3; drop table user;
PreparedStatement ps = conn.prepareStatement(sql);
ResultSet rs=ps.executeUpdate();
5.Mybatis原理
Mybatis的功能架构分为三层：
- 接口层：提供给外部使用的接口API，开发人员通过这些本地API来操作数据库。接口层接收到调用请求就会调用数据处理层来完成具体的数据处理。
- 数据处理层：负责具体的SQL查找、SQL解析、SQL执行和执行结果映射处理等。它主要的目的是根据调用的请求完成一次数据库操作。
- 框架支撑层：负责最基础的功能支撑，包括连接管理、事务管理、配置加载和缓存处理，这些都是共用的东西，将他们抽取出来作为最基础的组件。为上层的数据处理层提供最基础的支撑。
- SqlSession。作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能。
- Executor。MyBatis执行器，是MyBatis调度的核心，负责SQL语句的生成和查询缓存的维护。
- StatementHandler。封装了JDBC Statement操作，负责对JDBCstatement的操作，如设置参数、将Statement结果集转换成List集合。
- ParameterHandler。负责对用户传递的参数转换成JDBC Statement 所需要的参数。
- ResultSetHandler。负责将JDBC返回的ResultSet结果集对象转换成List类型的集合。
- TypeHandler 负责java数据类型和jdbc数据类型之间的映射和转换。
- MappedStatement。MappedStatement维护了一条
- SqlSource。负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回。
- BoundSql。表示动态生成的SQL语句以及相应的参数信息。
- Configuration。MyBatis所有的配置信息都维持在Configuration对象之中。
Mybatis的一级缓存和二级缓存
一级缓存
Mybatis的一级缓存的作用域为SqlSession, Mybatis默认开启一级缓存,同一个SqlSession中会缓存一个HashMap, key为hashcode+statementId+sql语句, value则为查询结果集所映射成的java对象, 第一次进行查询时会将缓存结果存入本地HashMap, 第二次查询时则直接在本地HashMap中取缓存的java对象, 当两次缓存之间进行任何insert, update, delete操作, 在commit后清空缓存, 同样SqlSession对象使用clearCache()可手动清空缓存
二级缓存
Mybatis的二级缓存的作用域为mapper, Mybatis默认不开启二级缓存, 同一个命名空间使用一个缓存空间, 缓存内容为sql查询结果集, 进行查询后在SqlSession对象commit()或close()后, 才会产生二级缓存
二级缓存配置
<settings>
<setting name = "cacheEnable" value = "true" />
settings>
5.1 TypeHandler
无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用类型处理器将获取的值以合适的方式转换成 Java 类型。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-L93saOS1-1629258986384)(E:\学习笔记\mybatis学习笔记\img\640.webp)]
以BigDecimalTypeHandler为例子:
/**
* Copyright 2009-2015 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.type;
import java.math.BigDecimal;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* @author Clinton Begin
*/
public class BigDecimalTypeHandler extends BaseTypeHandler<BigDecimal> {
@Override
public void setNonNullParameter(PreparedStatement ps, int i, BigDecimal parameter, JdbcType jdbcType)
throws SQLException {
ps.setBigDecimal(i, parameter);
}
@Override
public BigDecimal getNullableResult(ResultSet rs, String columnName)
throws SQLException {
return rs.getBigDecimal(columnName);
}
@Override
public BigDecimal getNullableResult(ResultSet rs, int columnIndex)
throws SQLException {
return rs.getBigDecimal(columnIndex);
}
@Override
public BigDecimal getNullableResult(CallableStatement cs, int columnIndex)
throws SQLException {
return cs.getBigDecimal(columnIndex);
}
}
这个类的第一个方法是对预处理语句（PreparedStatement)设置参数，之后的三个函数都是从ResultSet或者用于执行存储过程的CallableStatement语句中获取BigDecimal类型的数值，用于向BigDecimal类型的Java字段赋值。
BigDecimalTypeHandler继承的BaseTypeHandler是个泛型类，其他的TypeHandler也是通过继承这个抽象类，实现其中的抽象方法，实现类型转换的工作。
/**
* Copyright 2009-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.apache.ibatis.executor.result.ResultMapException;
import org.apache.ibatis.session.Configuration;
/**
* The base {@link TypeHandler} for references a generic type.
*
* Important: Since 3.5.0, This class never call the {@link ResultSet#wasNull()} and
* {@link CallableStatement#wasNull()} method for handling the SQL {@code NULL} value.
* In other words, {@code null} value handling should be performed on subclass.
*
*
* @author Clinton Begin
* @author Simone Tripodi
* @author Kzuki Shimizu
*/
public abstract class BaseTypeHandler<T> extends TypeReference<T> implements TypeHandler<T> {
/**
* @deprecated Since 3.5.0 - See https://github.com/mybatis/mybatis-3/issues/1203. This field will remove future.
*/
@Deprecated
protected Configuration configuration;
/**
* Sets the configuration.
*
* @param c
* the new configuration
* @deprecated Since 3.5.0 - See https://github.com/mybatis/mybatis-3/issues/1203. This property will remove future.
*/
@Deprecated
public void setConfiguration(Configuration c) {
this.configuration = c;
}
@Override
public void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException {
if (parameter == null) {
if (jdbcType == null) {
throw new TypeException("JDBC requires that the JdbcType must be specified for all nullable parameters.");
}
try {
ps.setNull(i, jdbcType.TYPE_CODE);
} catch (SQLException e) {
throw new TypeException("Error setting null for parameter #" + i + " with JdbcType " + jdbcType + " . "
+ "Try setting a different JdbcType for this parameter or a different jdbcTypeForNull configuration property. "
+ "Cause: " + e, e);
}
} else {
try {
setNonNullParameter(ps, i, parameter, jdbcType);
} catch (Exception e) {
throw new TypeException("Error setting non null for parameter #" + i + " with JdbcType " + jdbcType + " . "
+ "Try setting a different JdbcType for this parameter or a different configuration property. "
+ "Cause: " + e, e);
}
}
}
@Override
public T getResult(ResultSet rs, String columnName) throws SQLException {
try {
return getNullableResult(rs, columnName);
} catch (Exception e) {
throw new ResultMapException("Error attempting to get column '" + columnName + "' from result set. Cause: " + e, e);
}
}
@Override
public T getResult(ResultSet rs, int columnIndex) throws SQLException {
try {
return getNullableResult(rs, columnIndex);
} catch (Exception e) {
throw new ResultMapException("Error attempting to get column #" + columnIndex + " from result set. Cause: " + e, e);
}
}
@Override
public T getResult(CallableStatement cs, int columnIndex) throws SQLException {
try {
return getNullableResult(cs, columnIndex);
} catch (Exception e) {
throw new ResultMapException("Error attempting to get column #" + columnIndex + " from callable statement. Cause: " + e, e);
}
}
public abstract void setNonNullParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;
/**
* Gets the nullable result.
*
* @param rs
* the rs
* @param columnName
* Colunm name, when configuration useColumnLabel is false
* @return the nullable result
* @throws SQLException
* the SQL exception
*/
public abstract T getNullableResult(ResultSet rs, String columnName) throws SQLException;
public abstract T getNullableResult(ResultSet rs, int columnIndex) throws SQLException;
public abstract T getNullableResult(CallableStatement cs, int columnIndex) throws SQLException;
}
这个抽象类实现了TypeHandler接口，这个接口主要定义了类型转换的几种操作。
/**
* Copyright 2009-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.type;
import java.sql.CallableStatement;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
/**
* @author Clinton Begin
*/
public interface TypeHandler<T> {
void setParameter(PreparedStatement ps, int i, T parameter, JdbcType jdbcType) throws SQLException;
/**
* Gets the result.
*
* @param rs
* the rs
* @param columnName
* Colunm name, when configuration useColumnLabel is false
* @return the result
* @throws SQLException
* the SQL exception
*/
T getResult(ResultSet rs, String columnName) throws SQLException;
T getResult(ResultSet rs, int columnIndex) throws SQLException;
T getResult(CallableStatement cs, int columnIndex) throws SQLException;
}
至于这个抽象类继承的TypeReference，主要是提供了获取这个T具体是哪个类型。在判断使用使用哪个TypeHandler时有用。
/**
* Copyright 2009-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.type;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
* References a generic type.
*
* @param the referenced type
* @since 3.1.0
* @author Simone Tripodi
*/
public abstract class TypeReference<T> {
private final Type rawType;
protected TypeReference() {
rawType = getSuperclassTypeParameter(getClass());
}
Type getSuperclassTypeParameter(Class<?> clazz) {
Type genericSuperclass = clazz.getGenericSuperclass();
if (genericSuperclass instanceof Class) {
// try to climb up the hierarchy until meet something useful
if (TypeReference.class != genericSuperclass) {
return getSuperclassTypeParameter(clazz.getSuperclass());
}
throw new TypeException("'" + getClass() + "' extends TypeReference but misses the type parameter. "
+ "Remove the extension or add a type parameter to it.");
}
Type rawType = ((ParameterizedType) genericSuperclass).getActualTypeArguments()[0];
// TODO remove this when Reflector is fixed to return Types
if (rawType instanceof ParameterizedType) {
rawType = ((ParameterizedType) rawType).getRawType();
}
return rawType;
}
public final Type getRawType() {
return rawType;
}
@Override
public String toString() {
return rawType.toString();
}
}
首先Mybatis有一个默认的TypeHandler实现，这些TypeHandler是如何被Mybatis识别的呢？
答案是TypeHandlerRegistry。在Mybatis初始化配置的时候，TypeHandlerRegistry会把JdbcType和Java类型对应的映射关系注册进该类内部的Map中。
JDBC_TYPE_HANDLER_MAP中记录的是JdbcType和TypeHandler对应的关系。
TYPE_HANDLER_MAP中记录的是Java类型和对应的所有JdbcType以及其对应TypeHandler的映射关系关系。
UNKNOWN_TYPE_HANDLER是在执行BaseTypeHandler的抽象方法时，去先解析出来该用什么TypeHandler。
ALL_TYPE_HANDLERS_MAP中记录的是所有TypeHandler的Class和其实例之间的映射关系。
private final Map<JdbcType, TypeHandler<?>> jdbcTypeHandlerMap = new EnumMap<>(JdbcType.class);
private final Map<Type, Map<JdbcType, TypeHandler<?>>> typeHandlerMap = new ConcurrentHashMap<>();
private final TypeHandler<Object> unknownTypeHandler;
private final Map<Class<?>, TypeHandler<?>> allTypeHandlersMap = new HashMap<>();
public TypeHandlerRegistry(Configuration configuration) {
this.unknownTypeHandler = new UnknownTypeHandler(configuration);
register(Boolean.class, new BooleanTypeHandler());
register(boolean.class, new BooleanTypeHandler());
register(JdbcType.BOOLEAN, new BooleanTypeHandler());
register(JdbcType.BIT, new BooleanTypeHandler());
register(Byte.class, new ByteTypeHandler());
register(byte.class, new ByteTypeHandler());
register(JdbcType.TINYINT, new ByteTypeHandler());
register(Short.class, new ShortTypeHandler());
register(short.class, new ShortTypeHandler());
register(JdbcType.SMALLINT, new ShortTypeHandler());
register(Integer.class, new IntegerTypeHandler());
register(int.class, new IntegerTypeHandler());
register(JdbcType.INTEGER, new IntegerTypeHandler());
register(Long.class, new LongTypeHandler());
register(long.class, new LongTypeHandler());
register(Float.class, new FloatTypeHandler());
register(float.class, new FloatTypeHandler());
register(JdbcType.FLOAT, new FloatTypeHandler());
register(Double.class, new DoubleTypeHandler());
register(double.class, new DoubleTypeHandler());
register(JdbcType.DOUBLE, new DoubleTypeHandler());
register(Reader.class, new ClobReaderTypeHandler());
register(String.class, new StringTypeHandler());
register(String.class, JdbcType.CHAR, new StringTypeHandler());
register(String.class, JdbcType.CLOB, new ClobTypeHandler());
register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
register(String.class, JdbcType.LONGVARCHAR, new StringTypeHandler());
register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
register(JdbcType.CHAR, new StringTypeHandler());
register(JdbcType.VARCHAR, new StringTypeHandler());
register(JdbcType.CLOB, new ClobTypeHandler());
register(JdbcType.LONGVARCHAR, new StringTypeHandler());
register(JdbcType.NVARCHAR, new NStringTypeHandler());
register(JdbcType.NCHAR, new NStringTypeHandler());
register(JdbcType.NCLOB, new NClobTypeHandler());
register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
register(JdbcType.ARRAY, new ArrayTypeHandler());
register(BigInteger.class, new BigIntegerTypeHandler());
register(JdbcType.BIGINT, new LongTypeHandler());
register(BigDecimal.class, new BigDecimalTypeHandler());
register(JdbcType.REAL, new BigDecimalTypeHandler());
register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
register(JdbcType.NUMERIC, new BigDecimalTypeHandler());
register(InputStream.class, new BlobInputStreamTypeHandler());
register(Byte[].class, new ByteObjectArrayTypeHandler());
register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
register(byte[].class, new ByteArrayTypeHandler());
register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
register(JdbcType.BLOB, new BlobTypeHandler());
register(Object.class, unknownTypeHandler);
register(Object.class, JdbcType.OTHER, unknownTypeHandler);
register(JdbcType.OTHER, unknownTypeHandler);
register(Date.class, new DateTypeHandler());
register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
register(JdbcType.TIMESTAMP, new DateTypeHandler());
register(JdbcType.DATE, new DateOnlyTypeHandler());
register(JdbcType.TIME, new TimeOnlyTypeHandler());
register(java.sql.Date.class, new SqlDateTypeHandler());
register(java.sql.Time.class, new SqlTimeTypeHandler());
register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());
register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());
register(Instant.class, new InstantTypeHandler());
register(LocalDateTime.class, new LocalDateTimeTypeHandler());
register(LocalDate.class, new LocalDateTypeHandler());
register(LocalTime.class, new LocalTimeTypeHandler());
register(OffsetDateTime.class, new OffsetDateTimeTypeHandler());
register(OffsetTime.class, new OffsetTimeTypeHandler());
register(ZonedDateTime.class, new ZonedDateTimeTypeHandler());
register(Month.class, new MonthTypeHandler());
register(Year.class, new YearTypeHandler());
register(YearMonth.class, new YearMonthTypeHandler());
register(JapaneseDate.class, new JapaneseDateTypeHandler());
// issue #273
register(Character.class, new CharacterTypeHandler());
register(char.class, new CharacterTypeHandler());
}
如果自定义一个TypeHandler 如何被Mybatis识别?
Mybatis在应用中启动时，会根据XML文件初始化配置，负责解析XML生成配置类的就是XMLConfigBuilder，通过调用其中的parseConfiguration方法填充配置类。
在Mybatis中配置了 标签 那么就会识别到。
private void parseConfiguration(XNode root) {
try {
// issue #117 read properties first
propertiesElement(root.evalNode("properties"));
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(settings);
loadCustomLogImpl(settings);
typeAliasesElement(root.evalNode("typeAliases"));
pluginElement(root.evalNode("plugins"));
objectFactoryElement(root.evalNode("objectFactory"));
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
reflectorFactoryElement(root.evalNode("reflectorFactory"));
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
environmentsElement(root.evalNode("environments"));
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
typeHandlerElement(root.evalNode("typeHandlers"));
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}
5.2 ResultSetHandler
/**
* Copyright 2009-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.executor.resultset;
import java.sql.CallableStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import org.apache.ibatis.cursor.Cursor;
/**
* @author Clinton Begin
*/
public interface ResultSetHandler {
<E> List<E> handleResultSets(Statement stmt) throws SQLException;
<E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;
void handleOutputParameters(CallableStatement cs) throws SQLException;
}
5.3 ParameterHandler
/**
* Copyright 2009-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.executor.parameter;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
* A parameter handler sets the parameters of the {@code PreparedStatement}.
*
* @author Clinton Begin
*/
public interface ParameterHandler {
Object getParameterObject();
void setParameters(PreparedStatement ps) throws SQLException;
}
/**
* Copyright 2009-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.scripting.defaults;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.mapping.ParameterMode;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.type.JdbcType;
import org.apache.ibatis.type.TypeException;
import org.apache.ibatis.type.TypeHandler;
import org.apache.ibatis.type.TypeHandlerRegistry;
/**
* @author Clinton Begin
* @author Eduardo Macarron
*/
public class DefaultParameterHandler implements ParameterHandler {
private final TypeHandlerRegistry typeHandlerRegistry;
private final MappedStatement mappedStatement;
private final Object parameterObject;
private final BoundSql boundSql;
private final Configuration configuration;
public DefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
this.mappedStatement = mappedStatement;
this.configuration = mappedStatement.getConfiguration();
this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
this.parameterObject = parameterObject;
this.boundSql = boundSql;
}
@Override
public Object getParameterObject() {
return parameterObject;
}
@Override
public void setParameters(PreparedStatement ps) {
ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
if (parameterMappings != null) {
for (int i = 0; i < parameterMappings.size(); i++) {
ParameterMapping parameterMapping = parameterMappings.get(i);
if (parameterMapping.getMode() != ParameterMode.OUT) {
Object value;
String propertyName = parameterMapping.getProperty();
if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
value = boundSql.getAdditionalParameter(propertyName);
} else if (parameterObject == null) {
value = null;
} else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
value = parameterObject;
} else {
MetaObject metaObject = configuration.newMetaObject(parameterObject);
value = metaObject.getValue(propertyName);
}
TypeHandler typeHandler = parameterMapping.getTypeHandler();
JdbcType jdbcType = parameterMapping.getJdbcType();
if (value == null && jdbcType == null) {
jdbcType = configuration.getJdbcTypeForNull();
}
try {
typeHandler.setParameter(ps, i + 1, value, jdbcType);
} catch (TypeException | SQLException e) {
throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
}
}
}
}
}
}
5.4 BoundSql
/**
* Copyright 2009-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.mapping;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.reflection.property.PropertyTokenizer;
import org.apache.ibatis.session.Configuration;
/**
* An actual SQL String got from an {@link SqlSource} after having processed any dynamic content.
* The SQL may have SQL placeholders "?" and an list (ordered) of an parameter mappings
* with the additional information for each parameter (at least the property name of the input object to read
* the value from).
*
* Can also have additional parameters that are created by the dynamic language (for loops, bind...).
*
* @author Clinton Begin
*/
public class BoundSql {
private final String sql;
private final List<ParameterMapping> parameterMappings;
private final Object parameterObject;
private final Map<String, Object> additionalParameters;
private final MetaObject metaParameters;
public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
this.sql = sql;
this.parameterMappings = parameterMappings;
this.parameterObject = parameterObject;
this.additionalParameters = new HashMap<>();
this.metaParameters = configuration.newMetaObject(additionalParameters);
}
public String getSql() {
return sql;
}
public List<ParameterMapping> getParameterMappings() {
return parameterMappings;
}
public Object getParameterObject() {
return parameterObject;
}
public boolean hasAdditionalParameter(String name) {
String paramName = new PropertyTokenizer(name).getName();
return additionalParameters.containsKey(paramName);
}
public void setAdditionalParameter(String name, Object value) {
metaParameters.setValue(name, value);
}
public Object getAdditionalParameter(String name) {
return metaParameters.getValue(name);
}
}
打断点 启动调试 可以看出BoundSql 获取到的就是实际的sql语句，以及其中的参数等
5.5 SqlSource
就是构建BoundSql，根据用户传入的参数
/**
* Copyright 2009-2019 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.mapping;
/**
* Represents the content of a mapped statement read from an XML file or an annotation.
* It creates the SQL that will be passed to the database out of the input parameter received from the user.
*
* @author Clinton Begin
*/
public interface SqlSource {
BoundSql getBoundSql(Object parameterObject);
}
5.6 MappedStatement
public Builder(Configuration configuration, String id, SqlSource sqlSource, SqlCommandType sqlCommandType) {}
5.7 StatementHandler
就是对jdbc操作的一个实现
/**
* Copyright 2009-2016 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.executor.statement;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.parameter.ParameterHandler;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.session.ResultHandler;
/**
* @author Clinton Begin
*/
public interface StatementHandler {
Statement prepare(Connection connection, Integer transactionTimeout)
throws SQLException;
void parameterize(Statement statement)
throws SQLException;
void batch(Statement statement)
throws SQLException;
int update(Statement statement)
throws SQLException;
<E> List<E> query(Statement statement, ResultHandler resultHandler)
throws SQLException;
<E> Cursor<E> queryCursor(Statement statement)
throws SQLException;
BoundSql getBoundSql();
ParameterHandler getParameterHandler();
}
5.8 Executor
/**
* Copyright 2009-2015 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.executor;
import java.sql.SQLException;
import java.util.List;
import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.reflection.MetaObject;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.apache.ibatis.transaction.Transaction;
/**
* @author Clinton Begin
*/
public interface Executor {
ResultHandler NO_RESULT_HANDLER = null;
int update(MappedStatement ms, Object parameter) throws SQLException;
<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
<E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
<E> Cursor<E> queryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds) throws SQLException;
List<BatchResult> flushStatements() throws SQLException;
void commit(boolean required) throws SQLException;
void rollback(boolean required) throws SQLException;
CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
boolean isCached(MappedStatement ms, CacheKey key);
void clearLocalCache();
void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
Transaction getTransaction();
void close(boolean forceRollback);
boolean isClosed();
void setExecutorWrapper(Executor executor);
}
5.9 SqlSession
定义了对数据库操作的一系列行为
/**
* Copyright 2009-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.ibatis.session;
import java.io.Closeable;
import java.sql.Connection;
import java.util.List;
import java.util.Map;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.BatchResult;
/**
* The primary Java interface for working with MyBatis.
* Through this interface you can execute commands, get mappers and manage transactions.
*
* @author Clinton Begin
*/
public interface SqlSession extends Closeable {
/**
* Retrieve a single row mapped from the statement key.
* @param the returned object type
* @param statement
* the statement
* @return Mapped object
*/
<T> T selectOne(String statement);
/**
* Retrieve a single row mapped from the statement key and parameter.
* @param the returned object type
* @param statement Unique identifier matching the statement to use.
* @param parameter A parameter object to pass to the statement.
* @return Mapped object
*/
<T> T selectOne(String statement, Object parameter);
/**
* Retrieve a list of mapped objects from the statement key.
* @param the returned list element type
* @param statement Unique identifier matching the statement to use.
* @return List of mapped object
*/
<E> List<E> selectList(String statement);
/**
* Retrieve a list of mapped objects from the statement key and parameter.
* @param the returned list element type
* @param statement Unique identifier matching the statement to use.
* @param parameter A parameter object to pass to the statement.
* @return List of mapped object
*/
<E> List<E> selectList(String statement, Object parameter);
/**
* Retrieve a list of mapped objects from the statement key and parameter,
* within the specified row bounds.
* @param the returned list element type
* @param statement Unique identifier matching the statement to use.
* @param parameter A parameter object to pass to the statement.
* @param rowBounds Bounds to limit object retrieval
* @return List of mapped object
*/
<E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);
/**
* The selectMap is a special case in that it is designed to convert a list
* of results into a Map based on one of the properties in the resulting
* objects.
* Eg. Return a of Map[Integer,Author] for selectMap("selectAuthors","id")
* @param the returned Map keys type
* @param the returned Map values type
* @param statement Unique identifier matching the statement to use.
* @param mapKey The property to use as key for each value in the list.
* @return Map containing key pair data.
*/
<K, V> Map<K, V> selectMap(String statement, String mapKey);
/**
* The selectMap is a special case in that it is designed to convert a list
* of results into a Map based on one of the properties in the resulting
* objects.
* @param the returned Map keys type
* @param the returned Map values type
* @param statement Unique identifier matching the statement to use.
* @param parameter A parameter object to pass to the statement.
* @param mapKey The property to use as key for each value in the list.
* @return Map containing key pair data.
*/
<K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey);
/**
* The selectMap is a special case in that it is designed to convert a list
* of results into a Map based on one of the properties in the resulting
* objects.
* @param the returned Map keys type
* @param the returned Map values type
* @param statement Unique identifier matching the statement to use.
* @param parameter A parameter object to pass to the statement.
* @param mapKey The property to use as key for each value in the list.
* @param rowBounds Bounds to limit object retrieval
* @return Map containing key pair data.
*/
<K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds);
/**
* A Cursor offers the same results as a List, except it fetches data lazily using an Iterator.
* @param the returned cursor element type.
* @param statement Unique identifier matching the statement to use.
* @return Cursor of mapped objects
*/
<T> Cursor<T> selectCursor(String statement);
/**
* A Cursor offers the same results as a List, except it fetches data lazily using an Iterator.
* @param the returned cursor element type.
* @param statement Unique identifier matching the statement to use.
* @param parameter A parameter object to pass to the statement.
* @return Cursor of mapped objects
*/
<T> Cursor<T> selectCursor(String statement, Object parameter);
/**
* A Cursor offers the same results as a List, except it fetches data lazily using an Iterator.
* @param the returned cursor element type.
* @param statement Unique identifier matching the statement to use.
* @param parameter A parameter object to pass to the statement.
* @param rowBounds Bounds to limit object retrieval
* @return Cursor of mapped objects
*/
<T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds);
/**
* Retrieve a single row mapped from the statement key and parameter
* using a {@code ResultHandler}.
* @param statement Unique identifier matching the statement to use.
* @param parameter A parameter object to pass to the statement.
* @param handler ResultHandler that will handle each retrieved row
*/
void select(String statement, Object parameter, ResultHandler handler);
/**
* Retrieve a single row mapped from the statement
* using a {@code ResultHandler}.
* @param statement Unique identifier matching the statement to use.
* @param handler ResultHandler that will handle each retrieved row
*/
void select(String statement, ResultHandler handler);
/**
* Retrieve a single row mapped from the statement key and parameter using a {@code ResultHandler} and
* {@code RowBounds}.
*
* @param statement
* Unique identifier matching the statement to use.
* @param parameter
* the parameter
* @param rowBounds
* RowBound instance to limit the query results
* @param handler
* ResultHandler that will handle each retrieved row
*/
void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler);
/**
* Execute an insert statement.
* @param statement Unique identifier matching the statement to execute.
* @return int The number of rows affected by the insert.
*/
int insert(String statement);
/**
* Execute an insert statement with the given parameter object. Any generated
* autoincrement values or selectKey entries will modify the given parameter
* object properties. Only the number of rows affected will be returned.
* @param statement Unique identifier matching the statement to execute.
* @param parameter A parameter object to pass to the statement.
* @return int The number of rows affected by the insert.
*/
int insert(String statement, Object parameter);
/**
* Execute an update statement. The number of rows affected will be returned.
* @param statement Unique identifier matching the statement to execute.
* @return int The number of rows affected by the update.
*/
int update(String statement);
/**
* Execute an update statement. The number of rows affected will be returned.
* @param statement Unique identifier matching the statement to execute.
* @param parameter A parameter object to pass to the statement.
* @return int The number of rows affected by the update.
*/
int update(String statement, Object parameter);
/**
* Execute a delete statement. The number of rows affected will be returned.
* @param statement Unique identifier matching the statement to execute.
* @return int The number of rows affected by the delete.
*/
int delete(String statement);
/**
* Execute a delete statement. The number of rows affected will be returned.
* @param statement Unique identifier matching the statement to execute.
* @param parameter A parameter object to pass to the statement.
* @return int The number of rows affected by the delete.
*/
int delete(String statement, Object parameter);
/**
* Flushes batch statements and commits database connection.
* Note that database connection will not be committed if no updates/deletes/inserts were called.
* To force the commit call {@link SqlSession#commit(boolean)}
*/
void commit();
/**
* Flushes batch statements and commits database connection.
* @param force forces connection commit
*/
void commit(boolean force);
/**
* Discards pending batch statements and rolls database connection back.
* Note that database connection will not be rolled back if no updates/deletes/inserts were called.
* To force the rollback call {@link SqlSession#rollback(boolean)}
*/
void rollback();
/**
* Discards pending batch statements and rolls database connection back.
* Note that database connection will not be rolled back if no updates/deletes/inserts were called.
* @param force forces connection rollback
*/
void rollback(boolean force);
/**
* Flushes batch statements.
* @return BatchResult list of updated records
* @since 3.0.6
*/
List<BatchResult> flushStatements();
/**
* Closes the session.
*/
@Override
void close();
/**
* Clears local session cache.
*/
void clearCache();
/**
* Retrieves current configuration.
* @return Configuration
*/
Configuration getConfiguration();
/**
* Retrieves a mapper.
* @param the mapper type
* @param type Mapper interface class
* @return a mapper bound to this SqlSession
*/
<T> T getMapper(Class<T> type);
/**
* Retrieves inner database connection.
* @return Connection
*/
Connection getConnection();
}