如何开发一个mybatis扩展框架
都说官网是最好的入门。当你参考mybatis官网执行查询发现这样：
// try 执行完后会关闭 session
try (SqlSession session = sqlSessionFactory.openSession()) {
BlogMapper mapper = session.getMapper(BlogMapper.class);
Blog blog = mapper.selectBlog(101);
}
如果你不关闭 SqlSession 会发现，执行几个后，连接池将会耗尽，因为你未关闭连接。
前提可参考这篇文章：https://lingkang.top/archives/tong-guo-dai-ma-jia-zai-mybatis-de-mapperxml
如果你要开发一个 mybatis 扩展框架，如何能反复调用呢？
如果你要开发一个 mybatis 扩展框架，如何能反复调用呢？
我们可以参考 mybatis-spring 框架源码，mybatis-spring 的SqlSessionTemplate 类实现了 mybatis 的 SqlSession 接口，在它构造函数中初始化了 SqlSessionFactory 代理处理 SqlSessionInterceptor
再查看代理实现 SqlSessionInterceptor.invoke，发现它会在执行完毕后关闭连接
基于代理 SqlSessionFactory 开发一个框架
基于这篇文章搭建的环境：https://lingkang.top/archives/tong-guo-dai-ma-jia-zai-mybatis-de-mapperxml
编写一个 SqlSession 代理处理
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.cursor.Cursor;
import org.apache.ibatis.executor.BatchResult;
import org.apache.ibatis.session.*;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.sql.Connection;
import java.util.List;
import java.util.Map;
/**
* @Author lingkang
* @Date 2024/2/29 9:25
*/
@Slf4j
public class MySqlSession implements SqlSession {
private SqlSessionFactory sqlSessionFactory;
private ExecutorType executorType;
private SqlSession sessionProxy;
public MySqlSession(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
this.sqlSessionFactory = sqlSessionFactory;
this.executorType = executorType;
// 创建我们的代理，以扩展更多功能
sessionProxy = (SqlSession) Proxy.newProxyInstance(getClass()
.getClassLoader(),
new Class[]{SqlSession.class},
new SqlSessionProxy()
);
}
@Override
public <T> T selectOne(String statement) {
return sessionProxy.selectOne(statement);
}
@Override
public <T> T selectOne(String statement, Object parameter) {
return sessionProxy.selectOne(statement, parameter);
}
@Override
public <E> List<E> selectList(String statement) {
return sessionProxy.selectList(statement);
}
@Override
public <E> List<E> selectList(String statement, Object parameter) {
return sessionProxy.selectList(statement, parameter);
}
@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
return sessionProxy.selectList(statement, parameter, rowBounds);
}
@Override
public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
return sessionProxy.selectMap(statement, mapKey);
}
@Override
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
return sessionProxy.selectMap(statement, mapKey, mapKey);
}
@Override
public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
return sessionProxy.selectMap(statement, mapKey, mapKey, rowBounds);
}
@Override
public <T> Cursor<T> selectCursor(String statement) {
return sessionProxy.selectCursor(statement);
}
@Override
public <T> Cursor<T> selectCursor(String statement, Object parameter) {
return sessionProxy.selectCursor(statement, parameter);
}
@Override
public <T> Cursor<T> selectCursor(String statement, Object parameter, RowBounds rowBounds) {
return sessionProxy.selectCursor(statement);
}
@Override
public void select(String statement, Object parameter, ResultHandler handler) {
sessionProxy.select(statement, parameter, handler);
}
@Override
public void select(String statement, ResultHandler handler) {
sessionProxy.select(statement, handler);
}
@Override
public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
sessionProxy.select(statement, parameter, rowBounds, handler);
}
@Override
public int insert(String statement) {
return sessionProxy.insert(statement);
}
@Override
public int insert(String statement, Object parameter) {
return sessionProxy.insert(statement, parameter);
}
@Override
public int update(String statement) {
return sessionProxy.update(statement);
}
@Override
public int update(String statement, Object parameter) {
return sessionProxy.update(statement, parameter);
}
@Override
public int delete(String statement) {
return sessionProxy.delete(statement);
}
@Override
public int delete(String statement, Object parameter) {
return sessionProxy.delete(statement, parameter);
}
@Override
public void commit() {
throw new UnsupportedOperationException("不支持的方法，已经交由 final-magic 管理事务");
}
@Override
public void commit(boolean force) {
throw new UnsupportedOperationException("不支持的方法，已经交由 final-magic 管理事务");
}
@Override
public void rollback() {
throw new UnsupportedOperationException("不支持的方法，已经交由 final-magic 管理事务");
}
@Override
public void rollback(boolean force) {
throw new UnsupportedOperationException("不支持的方法，已经交由 final-magic 管理事务");
}
@Override
public List<BatchResult> flushStatements() {
return sessionProxy.flushStatements();
}
@Override
public void close() {
throw new UnsupportedOperationException("不支持的方法，已经交由 final-magic 管理连接");
}
@Override
public void clearCache() {
sessionProxy.clearCache();
}
@Override
public Configuration getConfiguration() {
// 从会话工厂中获取
return sqlSessionFactory.getConfiguration();
}
@Override
public <T> T getMapper(Class<T> type) {
return getConfiguration().getMapper(type, this);
}
@Override
public Connection getConnection() {
return sessionProxy.getConnection();
}
private class SqlSessionProxy implements InvocationHandler {
private int countNumber = 0;
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 例如创建时将 session 存储到线程变量中，线程处理结束就关闭此会话
SqlSession session = sqlSessionFactory.openSession(executorType);
countNumber++;
log.info("获取会话");
System.out.println("获取连接: " + countNumber);
// 如果存在事务时，开启事务
// session.getConnection().setAutoCommit(false);
Object result = null;
try {
result = method.invoke(session, args);
// 事务处理 如果不存在事务就提交操作
// AOP 结束、 请求处理结束、提交事务
} catch (Exception e) {
// 事务处理 如果存在事务就要回滚
// session.rollback();
// log.info("事务回滚");
throw new RuntimeException(e);
} finally {
// 判断是否存在事务，不存在就关闭连接
session.close();
countNumber--;
System.out.println("关闭连接: " + countNumber);
}
return result;
}
}
}
调用
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.mapping.Environment;
import org.apache.ibatis.session.Configuration;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.apache.ibatis.transaction.TransactionFactory;
import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
import top.lingkang.solonweb.mapper.UserMapper;
import java.io.InputStream;
/**
* @author lingkang
* Created by 2024/2/29
*/
@Slf4j
public class Demo01 {
public static boolean isOk = false;
public static void main(String[] args) throws Exception {
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/test?useSSL=true&serverTimezone=UTC");
config.setUsername("root");
config.setPassword("123456");
config.setMaximumPoolSize(3);
HikariDataSource dataSource = new HikariDataSource(config);
Configuration configuration = new Configuration();
// 用for循环加载所有 xml
InputStream inputStream = Resources.getResourceAsStream("mapper/UserMapper.xml");
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, "mapper/UserMapper.xml",
configuration.getSqlFragments());
mapperParser.parse();
// 配置
TransactionFactory transactionFactory = new JdbcTransactionFactory();
Environment environment = new Environment("dev", transactionFactory, dataSource);
configuration.setEnvironment(environment);
configuration.setMapUnderscoreToCamelCase(true);// 下划线转化驼峰
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(configuration);
// 模拟aop生命周期，session可以存储到线程变量中，线程处理结束就关闭此会话
MySqlSession session = new MySqlSession(sqlSessionFactory, null);
UserMapper mapper = session.getMapper(UserMapper.class);
System.out.println(mapper.selectAll());// 查询所有
System.out.println(mapper.selectOne());
System.out.println(mapper.selectOne());
System.out.println(mapper.selectOne());
System.out.println(mapper.selectOne());
}
}
输出如下
