文章目录
- 前言
- 自定义插件实战
-
- 需求
- 实现过程
- 测试
- 总结
- Spring与Mybatis整合
-
- 整合过程
- 实现原理
-
- @MapperScan
- MapperScannerConfigurer
- MapperFactoryBean
- SqlSessionFactoryBean
- 总结
前言
学习一个框架除了搞清楚核心原理外，还有很关键的需要知道如何去扩展它，而对Mybatis来说，它提供了插件的方式帮助我们进行功能扩展，所以学习如何自定义一个插件也是非常有必要的，本文介绍一个基于插件如何实现一个分表的操作，相信从这个示例的学习，读者会有些收获的。本文还介绍了Spring如何与Mybatis整合的原理，帮助读者更多的了解Mybatis。
自定义插件实战
需求
插件能够改变或者扩展Mybatis的原有的功能，像Mybatis涉及到分页操作，通常就会去引用分页插件来实现分页功能，所以搞懂插件还是非常有必要的。下面通过一个简单的自定义插件来实战一个分片功能，来让读者对插件有更深的了解。
实现过程
首先，自定义一个分片路由插件，通过@Intercepts定义插件的拦截的目标类型，当前插件主要拦截StatementHandler类型，对query、update、prepare方法进行拦截
@Intercepts(
{
@Signature(type=StatementHandler.class,method="prepare",args={ Connection.class,Integer.class}),
@Signature(type=StatementHandler.class,method="query",args={ Statement.class,ResultHandler.class}),
@Signature(type=StatementHandler.class,method="update",args={ Statement.class})
}
)
public class MyRoutePlugin implements Interceptor{
@Autowired
private RouteConfig routeConfig;
@Autowired
private DataSource datasouce;
}
同时定义一个分片规则配置类，其中routeKey为分片字段，决定当前执行的SQL语句是否需要分片
@ConfigurationProperties(prefix="route")
@Component
@Data
public class RouteConfg {
private boolean enabled=true;
//分片字段
private String routeKey;
//分片表的数量
private int tableCount;
}
接下来，重写intercept方法，定义路由插件的实现逻辑，核心逻辑就是根据StatementHandler一步步通过反射拿到当前执行的SQL语句，然后确认是否开启路由分片，开启之后就会进行后续分片处理
public Object intercept(Invocation invocation) throws Throwable {
//先判断拦截的目标类型是否为StatementHandler
if(invocation.getTarget() instanceof StatementHandler){
//获得具体statementHandler实现，这里拿到的是RoutingStatementHandler
StatementHandler statementHandler=(StatementHandler) invocation.getTarget();
//通过RoutingStatementHandler，反射拿到它内部的属性delegate，这个delegate就是具体的statementHandler实现
Field delegate= getField(statementHandler,"delegate");
//获得statementHandler实现
PreparedStatementHandler preparedStatementHandler= (PreparedStatementHandler) delegate.get(statementHandler);
//拿到boundSql
BoundSql boundSql= preparedStatementHandler.getBoundSql();
//拿到它内部sql语句
Field sqlF=getField(boundSql, "sql");
String sql=(String) sqlF.get(boundSql);
if(routeConfig.isEnabled()){
//处理分片
return handlerRoute(sql,boundSql,preparedStatementHandler,invocation,sqlF);
}
}
return invocation.proceed();
}
//获得实例中指定name的field
public Field getField(Object obj,String fieldName){
Field field=ReflectionUtils.findField(obj.getClass(), fieldName);
//设置访问权限
ReflectionUtils.makeAccessible(field);
return field;
}
接下来，根据不同的SQL语句类型进行不同分片处理，这里只实现了对查询和插入的分片
//处理路由分片
private Object handlerRoute(String sql, BoundSql boundSql,
PreparedStatementHandler preparedStatementHandler,Invocation invocation,Field sqlF) throws InvocationTargetException, IllegalAccessException, IllegalArgumentException, SQLException {
//判断查询类型
if(sql.contains("select")||sql.contains("SELECT")){
return hanlderSelectRoute(sql,boundSql,preparedStatementHandler,invocation,sqlF);
}
if(sql.contains("insert")||sql.contains("INSERT")){
return handlerInsertRoute(sql,boundSql,preparedStatementHandler,invocation,sqlF);
}
return invocation.proceed();
}
查询的分片处理流程: 先根据执行的SQL语句获得旧的表名，接下来判断是否配置了路由分片字段，如果配置的话，那么会通过当前SQL语句的入参信息，确认SQL语句的查询参数中是否有包含分片字段。如果查询参数满足分片，那么就会根据对应的参数值计算它的hash值，然后基于hash值根据分片表数进行求余，确认分片后的表名，最后通过反射将当前执行的BoundSql中SQL语句替换为新的SQL语句，最终查询就会基于新的SQL语句进行查询，实现了分片效果。
//获得查询语句的表名
private String getSelectName(String sql) {
String from = sql.substring(sql.indexOf("from") + 4);
String tableName = from.substring(0, from.indexOf("where")).trim();
return tableName;
}
//查询语句的路由分片
private Object hanlderSelectRoute(String sql, BoundSql boundSql,
PreparedStatementHandler preparedStatementHandler, Invocation invocation, Field sqlF) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException, SQLException {
//获得表名
String tableName=getSelectName(sql);
//从boundSql里面的参数映射中，找到是否有按当前路由分配规则进行分片的字段
//分场景
//存在路由分片规则
if(routeConfig.getRouteKey()!=null){
Long hashcode=0L;
List<ParameterMapping> list=boundSql.getParameterMappings();
for(ParameterMapping bean:list){
//判断查询的字段是否为分片字段
if(bean.getProperty().equals(routeConfig.getRouteKey())){
hashcode= (long) boundSql.getParameterObject().toString().hashCode();
break;
}
}
if(0!=hashcode){
int tableCount = (int) (hashcode%(long) routeConfig.getTableCount())+1;
tableName=tableName+tableCount;
sqlF.set(boundSql, replaceSelectSql(sql,tableName));
return invocation.proceed();
}
}
//判断是否是prepare方法
if("prepare".equals(invocation.getMethod().getName())){
//直接向后传递
return invocation.proceed();
}
//不按路由分片规则，就需要查所有表来查出数据
List<Object> result=new ArrayList<Object>();
for(int i=1;i<=routeConfig.getTableCount();i++){
//修改它的Statement入参
Statement statement=getStatement(preparedStatementHandler, sqlF, tableName + i, boundSql, sql);
//修改它的入参
invocation.getArgs()[0]=statement;
//调用结果
List<Object> tmp=(List<Object>) invocation.proceed();
if(tmp!=null&&!tmp.isEmpty()){
result.add(tmp);
}
}
return result;
}
//替换查询语句的表名
private Object replaceSelectSql(String sql, String tableName) {
String from = sql.substring(0, sql.indexOf("from") + 4);
String where = sql.substring(sql.indexOf("where"));
return from + " " + tableName + " " + where;
}
如果当前未配置分片字段或者不满足分片策略时，此时就需要通过所有表来查数据。要查询所有分片表的数据，此时需要调用getStatement方法，为每个表的查询构造一个新的StatementHandler实例，然后再通过新的StatementHandler去查询分片表的数据，最终将查询结果汇总到List集合中并返回。
//创建一个新的StatementHandler
private Statement getStatement(StatementHandler preparedStatementHandler, Field sqlF, String tableName,
BoundSql boundSql, String sql) throws IllegalArgumentException, IllegalAccessException, SQLException {
//修改sql语句
sqlF.set(boundSql, replaceSelectSql(sql, tableName));
//先获得连接对象
Connection connection=DataSourceUtils.getConnection(datasouce);
//获得statementLog
Log statementLog=getStatementLog(preparedStatementHandler);
//获得连接日志代理对象
if (statementLog.isDebugEnabled()) {
connection= ConnectionLogger.newInstance(connection, statementLog, 1);
}
//获得具体StatementHandler
Statement statement=preparedStatementHandler.prepare(connection, null);
//参数设置
preparedStatementHandler.parameterize(statement);
//返回最终具体的statement实例
return statement;
}
private Log getStatementLog(StatementHandler preparedStatementHandler) throws IllegalArgumentException, IllegalAccessException {
Field mp=getField(preparedStatementHandler, "mappedStatement");
//实例化
MappedStatement mappedStatement = (MappedStatement) mp.get(preparedStatementHandler);
return mappedStatement.getStatementLog();
}
插入的分片处理流程，也是类似的，这里就不分析了。
//处理插入的分片
private Object handlerInsertRoute(String sql, BoundSql boundSql,
PreparedStatementHandler preparedStatementHandler, Invocation invocation,Field sqlF) throws InvocationTargetException, IllegalAccessException {
if(routeConfig.getRouteKey()!=null){
Long hashcode=0L;
List<ParameterMapping> list=boundSql.getParameterMappings();
for(ParameterMapping bean:list){
if(bean.getProperty().equals(routeConfig.getRouteKey())){
Field field=ReflectionUtils.findField(boundSql.getParameterObject().getClass(), bean.getProperty());
//设置访问权限
ReflectionUtils.makeAccessible(field);
hashcode=(long) field.get(boundSql.getParameterObject()).toString().hashCode();
break;
}
}
Long primaryId=hashcode;
int tableCount = (int) (primaryId%(long) routeConfig.getTableCount())+1;
//获得表名
String tableName=getSqlName(sql);
tableName=tableName+tableCount;
//修改sql
sqlF.set(boundSql, replaceSql(sql,tableName));
}
return invocation.proceed();
}
//获得新的插入sql语句
private Object replaceSql(String sql,String tableName) {
//前部分
String head=sql.substring(0,sql.indexOf("into")+4);
//后部分
String low=sql.substring(sql.indexOf("values"));
return head+" "+tableName+" "+low;
}
//获得插入语句的表名
private String getSqlName(String sql) {
String tableName=sql.substring(sql.indexOf("into")+4,sql.indexOf("values"));
if(tableName.contains("(")){
tableName=tableName.substring(0,tableName.indexOf("("));
}
return tableName.trim();
}
测试
定义一个Mapper接口
@Mapper
public interface TUserMapper {
@Select("select user_id as userId,user_name as userName,seqfrom tb_user where user_id = #{userId}")
TbUser selectByPrimaryKey(Integer userId);
@Select("select user_id as userId,user_name as userName,seqfrom tb_user where user_name = #{userName}")
List<TbUser> selectByUserName(String userName);
@Insert("insert into tb_user (user_id,user_name,seq) values(#{userId},#{userName},#{seq})")
void addT_user(TbUser user);
}
数据库中两张分片表
配置文件中指定路由分片策略
route.enabled=true
route.routeKey=userId
route.tableCount=2
第一种情况，向先表中插入10条数据
@Test
public void test5() {
Random random = new Random();
for (int i = 1; i < 11; i++) {
TbUser user = new TbUser();
user.setUserId((long)random.nextInt(1000));
user.setUserName("test" + i);
user.setSeq(i);
tuserMapper.addT_user(user);
}
}
从结果可以看到，插入时它会根据userId值进行分片，将数据分别保存到两张表中
第二种情况，指定userId查询一条记录
@Test
public void test7() {
TbUser tbUser = tuserMapper.selectByPrimaryKey(99);
System.out.println("tbUser: "+tbUser.toString());
}
从结果可以看到，根据指定userId的值进行了分片，从tb_user1表查到了数据
第三种情况，不通过分片键查询数据
@Test
public void test7() {
List<TbUser> list=tuserMapper.selectByUserName("test5");
System.out.println("tbUser: "+list.toString());
}
从结果可以看到，查询了两个表，汇总了结果，并且从tb_user1表中查到了数据
总结
需要明确一点，上述的分片逻辑不是重点，毕竟真正做分库分表的还是需要去引用数据库中间件的。上述示例实现中应该去关注如何一步步进行SQL的改造，以及Mybatis执行过程中一些重要的组件是如何创建的，知道了这些才能对Mybatis有更深的了解。
后续补充一张流程图（需要源码工程的，可以在评论区回复）
Spring与Mybatis整合
整合过程
引入mybatis-spring依赖包
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.1</version>
</dependency>
定义Mybatis的配置类，指定要扫描的Mapper接口包路径，同时指定一个SqlSessionFactoryBean的实例。整合的主要配置就这些，非常简单，但是我们应该关注这些配置背后做的事情。
@Configuration
@MapperScan(basePackages="com.stu",annotationClass=Mapper.class)
public class MybatisConfig {
@Bean
public DataSource dataSource() {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setDriverClassName(Driver.class.getName());
dataSource.setUsername("root");
dataSource.setPassword("123456");
dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/test");
return dataSource;
}
@Bean
public SqlSessionFactoryBean sessionFactoryBean(@Autowired DataSource dataSource) {
SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
sqlSessionFactory.setDataSource(dataSource);
return sqlSessionFactory;
}
}
实现原理
@MapperScan
首先，从上面的配置类可以看到它定义了一个@MapperScan注解，这个注解目的向Spring容器中注册了一个Mapper接口的扫描类
@Import(MapperScannerRegistrar.class)
@Repeatable(MapperScans.class)
public @interface MapperScan {
而MapperScan的功能是基于@Import注解定义的属性类MapperScannerRegistrar完成的，由于它实现了ImportBeanDefinitionRegistrar这个Spring的扩展点，因此当该类被Spring解析后就会触发执行registerBeanDefinitions这个方法
public class MapperScannerRegistrar implements ImportBeanDefinitionRegistrar, ResourceLoaderAware {
...
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
//获得mapperscan注解的属性
AnnotationAttributes mapperScanAttrs = AnnotationAttributes
.fromMap(importingClassMetadata.getAnnotationAttributes(MapperScan.class.getName()));
if (mapperScanAttrs != null) {
//向Spring容器中注册Mybatis的扫描类
registerBeanDefinitions(importingClassMetadata, mapperScanAttrs, registry,
generateBaseBeanName(importingClassMetadata, 0));
}
}
之后又会执行到registerBeanDefinitions这个核心方法，而这个方法就会将Mapper接口的扫描类MapperScannerConfigurer封装成BeanDefinition对象注册到Spring容器中，到这里@MapperScan注解的功能就完成了。
//核心： 向Spring注册mybatis的核心组件
void registerBeanDefinitions(AnnotationMetadata annoMeta, AnnotationAttributes annoAttrs,
BeanDefinitionRegistry registry, String beanName) {
//创建一个类型为MapperScannerConfigurer的BeanDefinition对象
BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
builder.addPropertyValue("processPropertyPlaceHolders", true);
//获得注解类型： annotationClass = Mapper.class；在Repository包下所有的接口都会带上@Mapper接口
Class<? extends Annotation> annotationClass = annoAttrs.getClass("annotationClass");
if (!Annotation.class.equals(annotationClass)) {
builder.addPropertyValue("annotationClass", annotationClass);
}
...
List<String> basePackages = new ArrayList<>();
basePackages.addAll(
Arrays.stream(annoAttrs.getStringArray("value")).filter(StringUtils::hasText).collect(Collectors.toList()));
basePackages.addAll(Arrays.stream(annoAttrs.getStringArray("basePackages")).filter(StringUtils::hasText)
.collect(Collectors.toList()));
basePackages.addAll(Arrays.stream(annoAttrs.getClassArray("basePackageClasses")).map(ClassUtils::getPackageName)
.collect(Collectors.toList()));
if (basePackages.isEmpty()) {
basePackages.add(getDefaultBasePackage(annoMeta));
}
builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(basePackages));
//注册
registry.registerBeanDefinition(beanName, builder.getBeanDefinition());
}
}
MapperScannerConfigurer
这个类的是真正实现扫描Mapper接口的，查看这个类的类图可以发现它实现了BeanDefinitionRegistryPostProcessor这个Spring的扩展点，因此Spring容器启动过程就会先调用该类的postProcessBeanDefinitionRegistry方法
public class MapperScannerConfigurer
implements BeanDefinitionRegistryPostProcessor, InitializingBean, ApplicationContextAware, BeanNameAware {
....
//核心方法：扫描指定注解的类，封装成BeanDefinition对象，添加到spring容器中
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
if (this.processPropertyPlaceHolders) {
processPropertyPlaceHolders();
}
//创建一个mapper扫描器
ClassPathMapperScanner scanner = new ClassPathMapperScanner(registry);
scanner.setAddToConfig(this.addToConfig);
scanner.setAnnotationClass(this.annotationClass);//标识扫描的注解类型
scanner.setMarkerInterface(this.markerInterface);
scanner.setSqlSessionFactory(this.sqlSessionFactory);
scanner.setSqlSessionTemplate(this.sqlSessionTemplate);
scanner.setSqlSessionFactoryBeanName(this.sqlSessionFactoryBeanName);
scanner.setSqlSessionTemplateBeanName(this.sqlSessionTemplateBeanName);
scanner.setResourceLoader(this.applicationContext);
scanner.setBeanNameGenerator(this.nameGenerator);
scanner.setMapperFactoryBeanClass(this.mapperFactoryBeanClass);
if (StringUtils.hasText(lazyInitialization)) {
scanner.setLazyInitialization(Boolean.valueOf(lazyInitialization));
}
//这里注册扫描的接口类型
scanner.registerFilters();
//执行扫描
scanner.scan(
StringUtils.tokenizeToStringArray(this.basePackage, ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS));
}
}
这个方法中主要创建了一个ClassPathMapperScanner扫描器，而这个扫描器又继承了Spring的ClassPathBeanDefinitionScanner这个扫描器。在执行scan方法扫描时，会先通过ClassPathBeanDefinitionScanner父类扫描器将配置的basePackages包（Mapper接口）路径下所有Mapper接口变成BeanDefinition对象注册到Spring容器中
public Set<BeanDefinitionHolder> doScan(String... basePackages) {
//将basePackages路径下所有Mapper接口，变成BeanDefinition对象注册到Spring容器中
Set<BeanDefinitionHolder> beanDefinitions = super.doScan(basePackages);
if (beanDefinitions.isEmpty()) {
LOGGER.warn(() -> "No MyBatis mapper was found in '" + Arrays.toString(basePackages)
+ "' package. Please check your configuration.");
} else {
//处理扫描得到的beanDefinitionholder集合，将集合中的每一个mapper接口转换成mapperfactorybean后，注册到spring容器中
processBeanDefinitions(beanDefinitions);
}
return beanDefinitions;
}
之后当前ClassPathMapperScanner扫描器又会执行到processBeanDefinitions这个方法，对扫描得到的beanDefinitionholder集合进行处理，将集合中的每一个Mapper接口对应的BeanDefinition对象对应的BeanClass替换为mapperFactoryBeanClass，并为当前BeanDefinition对象的构造函数属性中添加一个以Mapper接口做为入参构造函数（这样当前BeanDefinition对象被实例化时，就会通过该构造函数进行实例化）。最终每一个扫描的Mapper接口注册到Spring容器中，都是对应一个类型为MapperFactoryBean的BeanDefinition对象。
private void processBeanDefinitions(Set<BeanDefinitionHolder> beanDefinitions) {
GenericBeanDefinition definition;
for (BeanDefinitionHolder holder : beanDefinitions) {
definition = (GenericBeanDefinition) holder.getBeanDefinition();
String beanClassName = definition.getBeanClassName();
LOGGER.debug(() -> "Creating MapperFactoryBean with name '" + holder.getBeanName() + "' and '" + beanClassName
+ "' mapperInterface");
// the mapper interface is the original class of the bean
// but, the actual class of the bean is MapperFactoryBean
//增加一个构造方法，接口类型作为构造函数的入参
definition.getConstructorArgumentValues().addGenericArgumentValue(beanClassName); // issue #59
//设置当前bean的类型
definition.setBeanClass(this.mapperFactoryBeanClass);
definition.getPropertyValues().add("addToConfig", this.addToConfig);
boolean explicitFactoryUsed = false;
if (StringUtils.hasText(this.sqlSessionFactoryBeanName)) {
definition.getPropertyValues().add("sqlSessionFactory",
new RuntimeBeanReference(this.sqlSessionFactoryBeanName));
explicitFactoryUsed = true;
} else if (this.sqlSessionFactory != null) {
//添加sqlsessionfactory属性
definition.getPropertyValues().add("sqlSessionFactory", this.sqlSessionFactory);
explicitFactoryUsed = true;
}
....
}
}
MapperFactoryBean
Mapper接口扫描完成后，在应用程序中通过@Autowired注解注入一个Mapper接口时，实际上会注入MapperFactoryBean这个实例，查看MapperFactoryBean类图可以看到它实现了Spring的FactoryBean接口，因此最终注入的会是getObject()方法返回的实例，getObject()方法做的事情就是通过sqlSession获得当前Mapper接口的代理对象，因此最终依赖注入的就是一个Mapper接口的代理对象。
public class MapperFactoryBean<T> extends SqlSessionDaoSupport implements FactoryBean<T>{
public T getObject() throws Exception {
//获得mapper的代理对象
return getSqlSession().getMapper(this.mapperInterface);
}
}
还有一个关键点，Mybatis为Mapper接口创建代理对象时，需要先向Mybatis的Configuration配置类中注册每一个Mapper接口的代理工厂，之后通过代理工厂才能创建Mapper接口代理对象。而代理工厂的创建是在MapperFactoryBean的checkDaoConfig()方法执行的，触发的时机是由于MapperFactoryBean继承了SqlSessionDaoSupport，该类又继承了DaoSupport,而DaoSupport又实现了InitializingBean接口，当MapperFactoryBean实例化过程就会触发执行afterPropertiesSet方法，然后就会调用到checkDaoConfig()方法，完成为Mapper接口创建代理工厂对象的过程。
@Override
protected void checkDaoConfig() {
super.checkDaoConfig();
notNull(this.mapperInterface, "Property 'mapperInterface' is required");
Configuration configuration = getSqlSession().getConfiguration();
if (this.addToConfig && !configuration.hasMapper(this.mapperInterface)) {
try {
//为当前接口添加代理工厂对象
configuration.addMapper(this.mapperInterface);
} catch (Exception e) {
logger.error("Error while adding the mapper '" + this.mapperInterface + "' to configuration.", e);
throw new IllegalArgumentException(e);
} finally {
ErrorContext.instance().reset();
}
}
}
SqlSessionFactoryBean
前面的Mybatis配置类中，可以看到通过@Bean方式注入了一个SqlSessionFactoryBean的实例，而SqlSessionFactoryBean有什么作用呢？查看这个类的类图可以发现它实现了InitializingBean和FactoryBean两个接口。实现InitializingBean接口，那么当前bean被实例化过程中，就会调用到afterPropertiesSet方法，而该方法内部主要调用了buildSqlSessionFactory()方法，在这个buildSqlSessionFactory()方法中，目的就是创建Mybatis中SqlSessionFactory的实例。
public void afterPropertiesSet() throws Exception {
Assert.notNull(this.dataSource, "Property 'dataSource' is required");
Assert.notNull(this.sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
this.sqlSessionFactory = this.buildSqlSessionFactory();
}
而实现FactoryBean接口，那么Spring获取SqlSessionFactoryBean实例时实际上获得的是getObject方法返回的实例，而getObject方法返回的就是前面创建好的SqlSessionFactory这个实例。通过这两个接口就完成了SqlSessionFactory的实例化，并注册到Spring容器中。
public SqlSessionFactory getObject() throws Exception {
if (this.sqlSessionFactory == null) {
this.afterPropertiesSet();
}
return this.sqlSessionFactory;
}
总结
最后上一张简单时序图
