目录
- 一、JDBC操作数据库_问题分析
- 二、自定义持久层框架_思路分析
- 三、自定义框架_编码
- 1、加载配置文件
- 2、创建两个配置类对象
- 3、解析配置文件，填充配置类对象
- 4、创建SqlSessionFactory工厂接口及DefaultSqlSessionFactory实现类
- 5、创建SqlSession会话接口及DefaultSqlSession实现类
- 6、创建Executor执行器接口及SimpleExecutor实现类
- 7、项目使用端利用自定义框架测试
- 四、自定义框架_优化
- 1、优化思路
- 2、优化代码
- 3、优化后测试
- 五、Spring整合优化
- 六、gitee代码
一、JDBC操作数据库_问题分析
JDBC使用流程
- 加载数据库驱动
- 创建数据库连接
- 创建编译对象
- 设置入参执行SQL
- 返回结果集
代码示例
public class JDBCTest {
public static void main(String[] args) throws Exception {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
try {
// 加载数据库驱动
Class.forName("com.mysql.jdbc.Driver");
// 通过驱动管理类获取数据库链接
connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mybatis",
"root","123456789");
// 定义sql语句？表示占位符
String sql = "select * from user where name = ?";
// 获取预处理statement
preparedStatement = connection.prepareStatement(sql);
// 设置参数，第一个参数为sql语句中参数的序号(从1开始)，第二个参数为设置的参数值
preparedStatement.setString(1, "zhangsan");
// 向数据库发出sql执行查询，查询出结果集
resultSet = preparedStatement.executeQuery();
// 遍历查询结果集
while (resultSet.next()) {
int id = resultSet.getInt("id");
String username = resultSet.getString("name");
// 封装User
User user = new User();
user.setId(id);
user.setName(username);
System.out.println(user);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
// 释放资源
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (preparedStatement != null) {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
}
问题分析
| 存在问题 | 解决思路 |
|---|---|
| 数据库配置信息存在硬编码问题 | 使用配置文件 |
| 频繁创建、释放数据库连接问题 | 使用数据库连接池 |
| SQL语句 | 使用配置文件 |
| 数据库配置信息存在硬编码问题 | 使用配置文件 |
二、自定义持久层框架_思路分析
主要分两部分，项目使用端：平常写代码所说的后台服务；持久层框架：即项目使用端引入的jar包
核心接口/类重点说明：
| 类名定义 | 角色定位 | 分工协作 |
|---|---|---|
| Resources | 资源辅助类 | 负责读取配置文件转化为输入流 |
| Configuration | 数据库资源类 | 负责存储数据库连接信息 |
| MappedStatement | SQL与结果集资源类 | 负责存储SQL映射定义、存储结果集映射定义 |
| SqlSessionFactoryBuilder | 会话工厂构建者 | 负责解析配置文件，创建会话工厂SqlSessionFactory |
| SqlSessionFactory | 会话工厂 | 负责创建会话SqlSession |
| SqlSession | 会话 | 指派执行器Executor |
| Executor | 执行器 | 负责执行SQL （配合指定资源Mapped Statement） |
项目使用端：
- 引入自定义持久层框架的jar包
- sqlMapConfig.xml：数据库配置信息，以及mapper.xml的全路径
- mapper.xml：SQL配置信息，存放SQL语句、参数类型、返回值类型相关信息
注意： sqlMapConfig.xml中引入mapper.xml是为了只读取一次配置文件，否则每个实体类会有一个mapper.xml，则需要读取很多次
自定义框架本身：
- 加载配置文件：根据配置文件的路径，加载配置文件成字节输入流，存储在内存中
- 创建两个javaBean(容器对象)：存放配置文件解析出来的内容
- 解析配置文件(使用dom4j)，并创建SqlSession会话对象
- 创建SqlSessionFactory接口以及实现类DefaultSqlSessionFactory
- 创建SqlSession接口以及实现类DefaultSqlSession
SqlSession接口定义以上方法，DefaultSqlSession来决定什么操作调用对应的sql执行器
- 创建Executor执行器接口以及实现类SimpleExecutor简单执行器
三、自定义框架_编码
项目使用端
创建sqlMapConfig核心配置文件：
<configuration>
<!--配置数据库信息-->
<dataSource>
<property name="driverClassname" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/mybatis" />
<property name="username" value="root" />
<property name="password" value="123456789" />
</dataSource>
<!--引入映射配置文件，为了只加载一次xml-->
<mappers>
<mapper resource="mapper/UserMapper.xml"/>
</mappers>
</configuration>
创建映射配置文件：
获取某个sql语句的唯一标示statementId：namespace.id 如：user.selectList
<mapper namespace="user">
<!--查询所有-->
<select id="selectList" resultType="com.xc.pojo.User" >
select * from user
</select>
<!--按条件查询-->
<select id="selectOne" resultType="com.xc.pojo.User" parameterType="com.xc.pojo.User" >
select * from user where id = #{id} and name = #{name}
</select>
</mapper>
User实体：
@Data
public class User {
private Integer id;
private String name;
}
pom.xml引入自定义框架
<dependency>
<groupId>com.xc</groupId>
<artifactId>own-mybatis</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
自定义框架本身
1、加载配置文件
- 根据配置文件的路径，加载配置文件成字节输入流，存到内存中
public class Resources {
public static InputStream getResourceAsStream(String path){
return Resources.class.getClassLoader().getResourceAsStream(path);
}
}
2、创建两个配置类对象
- 映射配置类：mapper.xml解析出来内容
- 每个pojo实体都会对应一个mapper.xml文件即一个MapperStatement对象
- sqlCommandType：第四节 自定义框架_优化才会用到
@Data
public class MapperStatement {
//唯一标识 statementId：namespace.id
private String statementId;
//返回值类型
private String resultType;
//参数类型
private String parameterType;
//sql语句
private String sql;
// 判断当前是什么操作的一个属性-增删改查
private String sqlCommandType;
}
- 核心配置类：数据库配置信息以及映射配置类的map集合
- 将多个MapperStatement对象存入Map集合，statementId(namespace.id)作为key
- 将所有的配置文件都聚合到Configuration中，方便一次读取以及统一管理
@Data
public class Configuration {
//数据源对象
private DataSource dataSource;
//map.xml对象集合 key：statementId
private Map<String,MapperStatement> mapperStatementMap = new HashMap<>();
}
3、解析配置文件，填充配置类对象
- XMLConfigBuilder类的parse方法：解析核心配置类，返回Configuration对象
- 创建SqlSession工厂对象，以便之后创建SqlSession会话
public class SqlSessionFactoryBuilder {
public SqlSessionFactory build(InputStream inputStream) throws Exception {
//1.解析配置文件，封装容器对象：专门解析核心配置文件的解析类
XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder();
Configuration configuration = xmlConfigBuilder.parse(inputStream);
//2.创建SqlSessionFactory工厂对象
return new DefaultSqlSessionFactory(configuration);
}
}
- XMLConfigBuilder核心配置解析类里面嵌套着XMLMapperBuilder映射配置文件解析类
- 输入流转化为Document对象，一是根据property标签获取数据库配置信息并创建数据源添加到configuration
- 二是根据mapper标签通过XMLMapperBuilder解析类遍历解析配置文件同样添加到configuration的map集合类
public class XMLConfigBuilder {
private Configuration configuration;
public XMLConfigBuilder() {
this.configuration = new Configuration();
}
// 使用dom4j+xpath解析
public Configuration parse(InputStream inputStream) throws Exception {
//将xml转化为Document对象
Document document = new SAXReader().read(inputStream);
//获取跟节点，对于sqlMapConfig.xml来说就是<Configuration>标签
Element rootElement = document.getRootElement();
// -------------解析数据库配置文件----------------
// "//"表示从匹配选择的当前节点，而不考虑它们的位置
// 即这里获取数据源url用户密码信息
// 例：<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
List<Element> propertyList = rootElement.selectNodes("//property");
Properties properties = new Properties();
for (Element element : propertyList) {
// 获取<property>标签中，name和value属性的值
String name = element.attributeValue("name");
String value = element.attributeValue("value");
properties.setProperty(name,value);
}
// 创建数据源对象
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(properties.getProperty("driverClassName"));
dataSource.setUrl(properties.getProperty("url"));
dataSource.setUsername(properties.getProperty("username"));
dataSource.setPassword(properties.getProperty("password"));
// 将创建好的数据源添加到Configuration对象中
configuration.setDataSource(dataSource);
// -------------解析映射配置文件----------------
/*
1.获取映射配置文件路径
2.根据路径进行映射文件的加载解析
3.封装到MapperStatement，存入configuration的map集合中
*/
// 例：<mapper resource="mapper/UserMapper.xml"></mapper>
List<Element> mapperList = rootElement.selectNodes("//mapper");
for (Element element : mapperList) {
String resource = element.attributeValue("resource");
InputStream resourceAsStream = Resources.getResourceAsStream(resource);
// XMLMapperBuilder 专门解析映射配置文件的对象-最后会存入configuration的map集合对象中
XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(configuration);
xmlMapperBuilder.parse(resourceAsStream);
}
return configuration;
}
}
- 与XMLConfigBuilder解析类原理一样
- 传入configuration，并将解析好的MapperStatement对象添加到mapperStatementMap
public class XMLMapperBuilder {
private Configuration configuration;
public XMLMapperBuilder(Configuration configuration) {
this.configuration = configuration;
}
public void parse(InputStream resourceAsStream) throws Exception {
// 将输入流转化为Document对象，并获取跟节点<mapper>
Document document = new SAXReader().read(resourceAsStream);
Element rootElement = document.getRootElement();
// 例：<mapper namespace="user">
String namespace = rootElement.attributeValue("namespace");
/* 例：
<select id="selectOne" resultType="com.xc.pojo.User" parameterType="com.xc.pojo.User" >
select * from user where id = #{id} and name = #{name}
</select>
*/
List<Element> selectList = rootElement.selectNodes("//select");
for (Element element : selectList) {
String id = element.attributeValue("id");
String resultType = element.attributeValue("resultType");
String parameterType = element.attributeValue("parameterType");
String sql = element.getTextTrim();
// 封装MapperStatement对象
MapperStatement mapperStatement = new MapperStatement();
String statementId = namespace + "." + id;
mapperStatement.setStatementId(statementId);
mapperStatement.setParameterType(parameterType);
mapperStatement.setResultType(resultType);
mapperStatement.setSql(sql);
//第四节 自定义框架_优化才会用到
mapperStatement.setSqlCommandType("select");
// 添加到configurations的map集合中
configuration.getMapperStatementMap().put(statementId,mapperStatement);
}
}
}
4、创建SqlSessionFactory工厂接口及DefaultSqlSessionFactory实现类
- 为了创建SqlSession会话，调用增删改查方法
public interface SqlSessionFactory {
// 创建SqlSession对象
SqlSession openSession();
}
- 创建简单执行器，与核心配置类共同创建SqlSession会话实现类
- configuration提供数据配置和sql以及参数和结果集封装
- simpleExecutor提供JDBC执行sql底层原理
public class DefaultSqlSessionFactory implements SqlSessionFactory {
private Configuration configuration;
public DefaultSqlSessionFactory(Configuration configuration) {
this.configuration = configuration;
}
@Override
public SqlSession openSession() {
// 1.创建执行器对象-具体的包装jdbc的sql操作，关闭连接等
Executor simpleExecutor = new SimpleExecutor();
// 2.创建sqlSession对象-判断执行增删改查哪些操作等
return new DefaultSqlSession(configuration,simpleExecutor);
}
}
5、创建SqlSession会话接口及DefaultSqlSession实现类
- statementId(“namespace.id”)：定位具体Mapper.xml的sql语句以及入参和返回
- param：替换sql语句中的占位符？，可能字符串、对象、Map、集合
public interface SqlSession {
// 查询多个结果
<E> List<E> selectList(String statementId, Object param) throws Exception;
// 查询单个结果
<T> T selectOne(String statementId, Object param) throws Exception;
// 清理资源
void close();
}
- 利用聚合进来的configuration对象获取MapperStatement映射配置对象向下传给执行器
- 另外一个聚合进来的executor简单执行器来执行底层JDBC操作
- DefaultSqlSession的作用则是聚合配置类分发到不同执行器的不同方法
- 执行器种类：简单执行器、可重用执行器、批量执行器（这里只模拟第一种）
public class DefaultSqlSession implements SqlSession {
private Configuration configuration;
private Executor executor;
public DefaultSqlSession(Configuration configuration, Executor executor) {
this.configuration = configuration;
this.executor = executor;
}
@Override
public <E> List<E> selectList(String statementId, Object param) throws Exception {
// 根据StatementId获取映射配置对象MapperStatement
MapperStatement mapperStatement = configuration.getMapperStatementMap().get(statementId);
// 然后将具体的查询操作委派给SimpleExecutor执行器
// 执行底层jdbc需要：1.数据库配置，2.sql配置信息
return executor.query(configuration,mapperStatement,param);
}
@Override
public <T> T selectOne(String statementId, Object param) throws Exception {
// 调用selectList()
List<Object> selectList = selectList(statementId, param);
if (selectList.size() == 1){
return (T) selectList.get(0);
}else if (selectList.size() > 1){
throw new Exception("返回数据不止一条！！！");
}else {
return null;
}
}
@Override
public void close() {
executor.close();
}
}
6、创建Executor执行器接口及SimpleExecutor实现类
- 执行器接口定义增删改查方法，具体的JDBC底层操作由它的实现类来完成
public interface Executor {
<E> List<E> query(Configuration configuration, MapperStatement mapperStatement, Object param)
throws Exception;
void close();
}
- 执行器实现类整体流程就是JDBC那一套，从加载驱动到处理结果集
- getBoundSql方法功能：
- 一是将 <select>标签的sql语句“#{字段名}”替换成?赋值给finalSql。(这里使用的mybatis代码，不用深究就是根据正则表达式替换，最后有gitee代码链接)
- 二是将替换?时候的字段名取出来放到ParameterMapping对象中，有多个，根据?次序，放入parameterMappingList集合
- 入参根据<select>标签的parameterType属性获取全限定类名，反射获取Class对象
- 遍历parameterMappingList，获取字段名，加上Class对象获取Field属性类
- query查询方法有个param参数，即入参对象（有可能字符串，集合这里只考虑对象），通过Field属性和param对象通过反射获取属性值
- 结果集根据<select>标签的resultType属性获取全限定类名，反射获取实例对象
- 通过结果集元数据获取字段名columnName，再resultSet.getObject获取数据库中对应字段值
- 通过java实体字段名和Class对象获取对应字段的Get方法的Method
- 这里说下1和2步骤中两个字段不是一回事，如果数据库和实体中不一样，这里需要转化成一致
public class SimpleExecutor implements Executor{
private Connection connection = null;
private PreparedStatement preparedStatement = null;
private ResultSet resultSet = null;
@Override
public <E> List<E> query(Configuration configuration, MapperStatement mapperStatement, Object param)
throws Exception {
// 1.加载驱动，获取数据库连接
connection = configuration.getDataSource().getConnection();
// 2.获取preparedStatement预编译对象
// 从mapperStatement中获取sql语句
// 例：select * from user where id = #{id} and username = #{username}
String sql = mapperStatement.getSql();
// 1)需要转化为：select * from user where id = ? and username = ?
// 2)需要将替换的值保存下来，后续?赋值需要用到
BoundSql boundSql = getBoundSql(sql);
String finalSql = boundSql.getFinalSql();
preparedStatement = connection.prepareStatement(finalSql);
// 3.根据入参赋值？
// 获取入参的全限定类名 com.xc.pojo.User
String parameterType = mapperStatement.getParameterType();
// 没有入参类型，表示sql没有参数，这里不需要?赋值
if (parameterType != null){
// 入参对象Class类
Class<?> parameterTypeClass = Class.forName(parameterType);
// 获取#{}参数字段list
List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
for (int i = 0; i < parameterMappingList.size(); i++) {
// 获取字段名称
ParameterMapping parameterMapping = parameterMappingList.get(i);
String paramName = parameterMapping.getContent();
// 通过反射获取入参对象的Field属性
Field field = parameterTypeClass.getDeclaredField(paramName);
// 禁用安全检查，不用排除private，效率提升好多倍
field.setAccessible(true);
// param为User对象，通过属性反射获取到user对象id和name的属性值
Object value = field.get(param);
// 赋值占位符，占位符？数字从1开始
preparedStatement.setObject(i + 1, value);
}
}
// 4.执行sql,发起查询
resultSet = preparedStatement.executeQuery();
// 5.处理返回结果集
List<E> list = new ArrayList<>();
while (resultSet.next()){
// 通过<select>标签的返回值类型，创建返回对象
String resultType = mapperStatement.getResultType();
Class<?> resultTypeClass = Class.forName(resultType);
Object obj = resultTypeClass.newInstance();
// 结果集的元数据信息：字段名，字段值等
// resultSet: 一条结果集对应一张表的所有字段
ResultSetMetaData metaData = resultSet.getMetaData();
for (int i = 1; i <= metaData.getColumnCount(); i++) {
//数据库字段名
String columnName = metaData.getColumnName(i);
// 字段的值
Object value = resultSet.getObject(columnName);
// columnName：数据库字段，而下方需要实体中的字段，如果两边不一样，则这需要有一个转化
// 获取读写方法即get、set方法
PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName, resultTypeClass);
// 获取读方法-字段的set方法
Method writeMethod = propertyDescriptor.getWriteMethod();
// 反射为返回对象赋值
// 参数1：实例对象 参数2：要设置的值
writeMethod.invoke(obj,value);
}
list.add((E) obj);
}
return list;
}
/**
* @Description 获取?占位符的sql，以及保存#{}中的字段名称
*
* 1、将<select>标签中的sql的 "#{字段名}" 整个部分替换成？，赋值 finalSql
* 2、截取#{}中的字段名称，添加到ParameterMapping对象的content属性，多个，赋值List<ParameterMapping>
*
* @Author xuchang
* @Date 2022/10/19 16:44:51
*/
private BoundSql getBoundSql(String sql) {
// 1.创建标记处理器：配合标记解析器完成标记的处理解析工作
ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
// 2.创建标记解析器
GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
// #{}占位符替换成？ 2.解析替换的过程中 将#{}里面的值保存下来 ParameterMapping
String finalSql = genericTokenParser.parse(sql);
// #{}里面的值的一个集合 id username
List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
return new BoundSql(finalSql, parameterMappings);
}
@Override
public void close() {
// 释放资源
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (preparedStatement != null) {
try {
preparedStatement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
@Data
@AllArgsConstructor
public class BoundSql {
// 用?做占位符的sql语句
private String finalSql;
// 字段名称的集合
private List<ParameterMapping> parameterMappingList;
}
@Data
@AllArgsConstructor
public class ParameterMapping {
// 保存#{}中对于的字段名称
private String content;
}
7、项目使用端利用自定义框架测试
- 优点：完成一张表的增删改查只需要创建一个实体类。(其他类接口都是必须要有的)
- 缺点1：sqlSession会话对象创建频繁，每次需要User的CRUD，就需要创建
- 缺点2：调用方法需要手动添加参数statementId：namespace.id
@Test
public void test1() throws Exception {
// 1.根据配置文件的路径，加载成字节输入流，存到内存中 注意：配置文件还未解析
InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
// 2.解析配置文件，封装到Configuration对象，创建sqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
// 3.生产sqlSession 创建执行器对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4.调用sqlSession方法
User user = new User();
user.setId(100);
user.setName("zhangsan");
User userOne = sqlSession.selectOne("user.selectOne", user);
System.out.println("查询单个用户："+userOne);
List<User> userList = sqlSession.selectList("user.selectList",null);
System.out.println("查询所有用户："+userList.toString());
// 5.释放资源
sqlSession.close();
}
输出结果：
查询单个用户：User(id=100, name=zhangsan)
查询所有用户：[User(id=100, name=zhangsan), User(id=120, name=Lisi)]
四、自定义框架_优化
1、优化思路
- 去掉statementId硬编码：创建一个UserMapper或IUserDao接口，每个方法名、入参、返回值和mapper.xml的<select>标签的id、parameterType、resultType一一对应
- sqlSession创建频繁：通过动态代理创建IUserDao的实现类，内容则是sqlSession.selectOne和sqlSession.selectList；这样sqlSession只需要创建一次，以后每次需要User的CRUD，则调用代理对象对应方法即可
2、优化代码
在sqlSession中添加方法
public interface SqlSession {
...
// 生成代理对象
<T> T getMapper(Class<?> mapperClass);
}
对应实现类方法
- 动态代理对象：不需要编译，运行期间生成字节码，通过传入的类加载器加载，只存在于内存中
- mapperClass：UserMapper或IUserDao接口的Class对象
- 代理类调用接口中的方法，则会被拦截进入invoke方法，因为没有目标类，则具体的实现都在invoke里面了
- 通过mapperClass和方法名获取到statementId
- statementId和参数有了，但是DefaultSqlSession要有CRUD查询和更新操作，所以sqlCommandType来区分
public class DefaultSqlSession implements SqlSession {
private Configuration configuration;
private Executor executor;
public DefaultSqlSession(Configuration configuration, Executor executor) {
this.configuration = configuration;
this.executor = executor;
}
@Override
public <E> List<E> selectList(String statementId, Object param) throws Exception {
// 根据StatementId获取映射配置对象MapperStatement
MapperStatement mapperStatement = configuration.getMapperStatementMap().get(statementId);
// 然后将具体的查询操作委派给SimpleExecutor执行器
// 执行底层jdbc需要：1.数据库配置，2.sql配置信息
return executor.query(configuration,mapperStatement,param);
}
@Override
public <T> T selectOne(String statementId, Object param) throws Exception {
// 调用selectList()
List<Object> selectList = selectList(statementId, param);
if (selectList.size() == 1){
return (T) selectList.get(0);
}else if (selectList.size() > 1){
throw new Exception("返回数据不止一条！！！");
}else {
return null;
}
}
@Override
public void close() {
executor.close();
}
@Override
public <T> T getMapper(Class<?> mapperClass) {
// 使用JDK动态代理生成基于接口的对象
// 1、创建一个类(代理类)，实现目标接口，实现所有的方法实现
// 2、动态代理类：代码运行期间生成的，而非编译期
Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(),
new Class[]{mapperClass}, new InvocationHandler() {
// proxy：生成的代理对象本身，很少用
// method：调用接口中哪个方法，则执行对应代理里的对应方法
// args：调用方法的参数
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 执行底层JDBC
// 1.获取statementId
// ps:约定接口中的方法名要与<select>标签的id属性名一致，
// 这样就可以通过接口获取statementId = namespace.id
String methodName = method.getName();// 方法名 - findAll
String className = mapperClass.getName();//接口类名 - com.xc.do.IUserDao
String statementId = className + "." + methodName;
// 2.判断调用sqlSession中CRUD的什么方法
// MapperStatement类添加属性sqlCommandType-sql增删改查类型
MapperStatement mapperStatement = configuration.getMapperStatementMap().get(statementId);
// select update delete insert
String sqlCommandType = mapperStatement.getSqlCommandType();
switch (sqlCommandType){
case "select" :
// 3.判断调用selectOne还是selectList
// 获取返回值类型，
Type genericReturnType = method.getGenericReturnType();
// ParameterizedType是Type的子接口，表示一个有参数的类型，例如Collection<T>，Map<K,V>等
if(genericReturnType instanceof ParameterizedType){
if(args != null) {
return selectList(statementId, args[0]);
}
return selectList(statementId, null);
}
return selectOne(statementId,args[0]);
case "update":
// 执行更新方法调用
break;
case "delete":
// 执行delete方法调用
break;
case "insert":
// 执行insert方法调用
break;
}
return null;
}
});
return (T) proxyInstance;
}
}
3、优化后测试
- 缺点：相较于优化前，需要新添加一个接口
- 优点：不需要手动添加statementId，SqlSession不用频繁创建
@Test
public void test2() throws Exception {
// 1.根据配置文件的路径，加载成字节输入流，存到内存中 注意：配置文件还未解析
InputStream resourceAsSteam = Resources.getResourceAsStream("sqlMapConfig.xml");
// 2.解析了配置文件，封装了Configuration对象 2.创建sqlSessionFactory工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsSteam);
// 3.生产sqlSession 创建了执行器对象
SqlSession sqlSession = sqlSessionFactory.openSession();
// 4.调用sqlSession方法
IUserDao userDao = sqlSession.getMapper(IUserDao.class);
List<User> all = userDao.findAll();
for (User user : all) {
System.out.println(user);
}
// 5.释放资源
sqlSession.close();
}
五、Spring整合优化
- 与Spring整合之后，InputStream、SqlSessionFactory、SqlSession、IUserDao代理对象统统不需要自己创建
- 全都交给了spring容器管理，我们要做的就是@Autowired IUserDao userDao
- 然后就可以用代理对象调用增删改查方法了
六、gitee代码
-
手写源码框架项目: https://gitee.com/xuchang614/own-mybatis
-
测试框架项目: https://gitee.com/xuchang614/own-mybatis-test
