springboot mybatis 热加载mapper.xml文件(最简单)
大家好，我是烤鸭:
今天介绍一下springboot mybatis 热加载mapper.xml文件。
本来不打算写的，看到网上比较流行的方式都比较麻烦，想着简化一下。
网上流行的版本。
https://www.cnblogs.com/oskyhg/p/8587701.html
总结一下需要：mybatis-config，mybatis-refresh.properties，MapperRefresh.java，SqlSessionFactoryBean.java
按照这个博客写的，确实挺好用的。但是，springboot简便就是简便在没有配置文件。
于是看看能不能优化一下。优化后只需要mybatis-refresh.properties，MapperRefresh.java+一行代码
环境：
springboot 2.0.0.RELEASE
mybatis 3.4.4
mybatis-spring-boot-starter 1.3.0
1. MapperRefresh.java(同上，复制)
定时读取指定目录下的mapper.xml文件，是否被修改
package com.xxx.web.common.config.mybatis;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.builder.xml.XMLMapperBuilder;
import org.apache.ibatis.executor.ErrorContext;
import org.apache.ibatis.session.Configuration;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.NestedIOException;
import org.springframework.core.io.Resource;
import com.google.common.collect.Sets;
/**
* 刷新MyBatis Mapper XML 线程
* @author ThinkGem
* @version 2016-5-29
*/
public class MapperRefresh implements java.lang.Runnable {
public static Logger log = LoggerFactory.getLogger(MapperRefresh.class);
private static String filename = "mybatis-refresh.properties";
private static Properties prop = new Properties();
private static boolean enabled; // 是否启用Mapper刷新线程功能
private static boolean refresh; // 刷新启用后，是否启动了刷新线程
private Set location; // Mapper实际资源路径
private Resource[] mapperLocations; // Mapper资源路径
private Configuration configuration; // MyBatis配置对象
private Long beforeTime = 0L; // 上一次刷新时间
private static int delaySeconds; // 延迟刷新秒数
private static int sleepSeconds; // 休眠时间
private static String mappingPath; // xml文件夹匹配字符串，需要根据需要修改
static {
// try {
// prop.load(MapperRefresh.class.getResourceAsStream(filename));
// } catch (Exception e) {
// e.printStackTrace();
// System.out.println("Load mybatis-refresh “"+filename+"” file error.");
// }
URL url = MapperRefresh.class.getClassLoader().getResource(filename);
InputStream is;
try {
is = url.openStream();
if (is == null) {
log.warn("applicationConfig.properties not found.");
} else {
prop.load(is);
}
} catch (IOException e) {
e.printStackTrace();
}
String value = getPropString("enabled");
System.out.println(value);
enabled = "true".equalsIgnoreCase(value);
delaySeconds = getPropInt("delaySeconds");
sleepSeconds = getPropInt("sleepSeconds");
mappingPath = getPropString("mappingPath");
delaySeconds = delaySeconds == 0 ? 50 : delaySeconds;
sleepSeconds = sleepSeconds == 0 ? 3 : sleepSeconds;
mappingPath = StringUtils.isBlank(mappingPath) ? "mappings" : mappingPath;
log.debug("[enabled] " + enabled);
log.debug("[delaySeconds] " + delaySeconds);
log.debug("[sleepSeconds] " + sleepSeconds);
log.debug("[mappingPath] " + mappingPath);
}
public static boolean isRefresh() {
return refresh;
}
public MapperRefresh(Resource[] mapperLocations, Configuration configuration) {
this.mapperLocations = mapperLocations;
this.configuration = configuration;
}
@Override
public void run() {
beforeTime = System.currentTimeMillis();
log.debug("[location] " + location);
log.debug("[configuration] " + configuration);
if (enabled) {
// 启动刷新线程
final MapperRefresh runnable = this;
new Thread(new java.lang.Runnable() {
@Override
public void run() {
if (location == null){
location = Sets.newHashSet();
log.debug("MapperLocation's length:" + mapperLocations.length);
for (Resource mapperLocation : mapperLocations) {
String s = mapperLocation.toString().replaceAll("\\\\", "/");
s = s.substring("file [".length(), s.lastIndexOf(mappingPath) + mappingPath.length());
if (!location.contains(s)) {
location.add(s);
log.debug("Location:" + s);
}
}
log.debug("Locarion's size:" + location.size());
}
try {
Thread.sleep(delaySeconds * 1000);
} catch (InterruptedException e2) {
e2.printStackTrace();
}
refresh = true;
System.out.println("========= Enabled refresh mybatis mapper =========");
while (true) {
try {
for (String s : location) {
runnable.refresh(s, beforeTime);
}
} catch (Exception e1) {
e1.printStackTrace();
}
try {
Thread.sleep(sleepSeconds * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}, "MyBatis-Mapper-Refresh").start();
}
}
/**
* 执行刷新
* @param filePath 刷新目录
* @param beforeTime 上次刷新时间
* @throws NestedIOException 解析异常
* @throws FileNotFoundException 文件未找到
* @author ThinkGem
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
private void refresh(String filePath, Long beforeTime) throws Exception {
// 本次刷新时间
Long refrehTime = System.currentTimeMillis();
// 获取需要刷新的Mapper文件列表
List fileList = this.getRefreshFile(new File(filePath), beforeTime);
if (fileList.size() > 0) {
log.debug("Refresh file: " + fileList.size());
}
for (int i = 0; i < fileList.size(); i++) {
InputStream inputStream = new FileInputStream(fileList.get(i));
String resource = fileList.get(i).getAbsolutePath();
try {
// 清理原有资源，更新为自己的StrictMap方便，增量重新加载
String[] mapFieldNames = new String[]{
"mappedStatements", "caches",
"resultMaps", "parameterMaps",
"keyGenerators", "sqlFragments"
};
for (String fieldName : mapFieldNames){
Field field = configuration.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
Map map = ((Map)field.get(configuration));
if (!(map instanceof StrictMap)){
Map newMap = new StrictMap(StringUtils.capitalize(fieldName) + "collection");
for (Object key : map.keySet()){
try {
newMap.put(key, map.get(key));
}catch(IllegalArgumentException ex){
newMap.put(key, ex.getMessage());
}
}
field.set(configuration, newMap);
}
}
// 清理已加载的资源标识，方便让它重新加载。
Field loadedResourcesField = configuration.getClass().getDeclaredField("loadedResources");
loadedResourcesField.setAccessible(true);
Set loadedResourcesSet = ((Set)loadedResourcesField.get(configuration));
loadedResourcesSet.remove(resource);
//重新编译加载资源文件。
XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(inputStream, configuration,
resource, configuration.getSqlFragments());
xmlMapperBuilder.parse();
} catch (Exception e) {
throw new NestedIOException("Failed to parse mapping resource: '" + resource + "'", e);
} finally {
ErrorContext.instance().reset();
}
// System.out.println("Refresh file: " + mappingPath + StringUtils.substringAfterLast(fileList.get(i).getAbsolutePath(), mappingPath));
if (log.isDebugEnabled()) {
log.debug("Refresh file: " + fileList.get(i).getAbsolutePath());
log.debug("Refresh filename: " + fileList.get(i).getName());
}
}
// 如果刷新了文件，则修改刷新时间，否则不修改
if (fileList.size() > 0) {
this.beforeTime = refrehTime;
}
}
/**
* 获取需要刷新的文件列表
* @param dir 目录
* @param beforeTime 上次刷新时间
* @return 刷新文件列表
*/
private List getRefreshFile(File dir, Long beforeTime) {
List fileList = new ArrayList();
File[] files = dir.listFiles();
if (files != null) {
for (int i = 0; i < files.length; i++) {
File file = files[i];
if (file.isDirectory()) {
fileList.addAll(this.getRefreshFile(file, beforeTime));
} else if (file.isFile()) {
if (this.checkFile(file, beforeTime)) {
fileList.add(file);
}
} else {
System.out.println("Error file." + file.getName());
}
}
}
return fileList;
}
/**
* 判断文件是否需要刷新
* @param file 文件
* @param beforeTime 上次刷新时间
* @return 需要刷新返回true，否则返回false
*/
private boolean checkFile(File file, Long beforeTime) {
if (file.lastModified() > beforeTime) {
return true;
}
return false;
}
/**
* 获取整数属性
* @param key
* @return
*/
private static int getPropInt(String key) {
int i = 0;
try {
i = Integer.parseInt(getPropString(key));
} catch (Exception e) {
}
return i;
}
/**
* 获取字符串属性
* @param key
* @return
*/
private static String getPropString(String key) {
return prop == null ? null : prop.getProperty(key).trim();
}
/**
* 重写 org.apache.ibatis.session.Configuration.StrictMap 类
* 来自 MyBatis3.4.0版本，修改 put 方法，允许反复 put更新。
*/
public static class StrictMap extends HashMap {
private static final long serialVersionUID = -4950446264854982944L;
private String name;
public StrictMap(String name, int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
this.name = name;
}
public StrictMap(String name, int initialCapacity) {
super(initialCapacity);
this.name = name;
}
public StrictMap(String name) {
super();
this.name = name;
}
public StrictMap(String name, Map m) {
super(m);
this.name = name;
}
@SuppressWarnings("unchecked")
public V put(String key, V value) {
// ThinkGem 如果现在状态为刷新，则刷新(先删除后添加)
if (MapperRefresh.isRefresh()) {
remove(key);
// MapperRefresh.log.debug("refresh key:" + key.substring(key.lastIndexOf(".") + 1));
}
// ThinkGem end
if (containsKey(key)) {
throw new IllegalArgumentException(name + " already contains value for " + key);
}
if (key.contains(".")) {
final String shortKey = getShortName(key);
if (super.get(shortKey) == null) {
super.put(shortKey, value);
} else {
super.put(shortKey, (V) new Ambiguity(shortKey));
}
}
return super.put(key, value);
}
public V get(Object key) {
V value = super.get(key);
if (value == null) {
throw new IllegalArgumentException(name + " does not contain value for " + key);
}
if (value instanceof Ambiguity) {
throw new IllegalArgumentException(((Ambiguity) value).getSubject() + " is ambiguous in " + name
+ " (try using the full name including the namespace, or rename one of the entries)");
}
return value;
}
private String getShortName(String key) {
final String[] keyparts = key.split("\\.");
return keyparts[keyparts.length - 1];
}
protected static class Ambiguity {
private String subject;
public Ambiguity(String subject) {
this.subject = subject;
}
public String getSubject() {
return subject;
}
}
}
}
2. mybatis-refresh.properties(同上，复制)
设置读取配置文件的参数，定时和频率，是否多线程
enabled=true
delaySeconds=30
sleepSeconds=10
mappingPath=mybatis3. 关于sqlSessionFactory
网上大多的实现方式都是重新创建SqlSessionFactory，然后再注入。
类似这样：
我的疑问：
1. MapperRefresh需要当前sqlSessionBean的configuration。既然springboot都已经sqlSessionFactory把创建好了，直接获取sqlSessionBean的configuration不就好了么。
2. yml配置mybatis的时候，没有sqlMapConfig(myabtis-config).xml这个配置文件，还得先创建一个，很不方便。试着把配置文件那行注释掉，会报错，Location 不能为空。
4. 改进
只需要在mybatis的sqlSessionFactory创建完成，注入SqlSession，调用MapperRefresh启动。
RootConfiguration.java
package com.xxx.web.common.config;
import java.io.IOException;
import java.util.concurrent.Executors;
import javax.annotation.PostConstruct;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.stereotype.Controller;
import com.xxx.web.common.config.mybatis.MapperRefresh;
@Configuration
@ComponentScan(value = "com.xxx", excludeFilters = { @Filter(Controller.class),
@Filter(type = FilterType.ASSIGNABLE_TYPE, value = { RootConfiguration.class }) })
@MapperScan({"com.xxx.web.**.dao"})
public class RootConfiguration extends SpringBootServletInitializer {
@Autowired
private SqlSession sqlSession;
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
application.registerShutdownHook(false);
return application.sources(RootConfiguration.class);
}
@PostConstruct
public void postConstruct() throws IOException {
//Constant.threadPool = Executors.newFixedThreadPool(20);
Resource[] resources = new PathMatchingResourcePatternResolver().getResources("classpath*:mybatis/**/*Mapper.xml");
new MapperRefresh(resources, sqlSession.getConfiguration()).run();
}
}启动类：
MainApplication.java
package com.xxx.web;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.xxx.web.common.config.RootConfiguration;
@SpringBootApplication
public class MainApplication {
public static void main(String[] args) {
SpringApplication.run(RootConfiguration.class, args);
}
}
application.yml
spring:
thymeleaf:
prefix: classpath:/templates/
datasource:
type: com.alibaba.druid.pool.DruidDataSource
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/xxx?allowMultiQueries=true&useUnicode=true&characterEncoding=utf-8
username: admin
password: admin@2017
initialSize: 1
minIdle: 3
maxActive: 20
# 配置获取连接等待超时的时间
maxWait: 60000
# 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
timeBetweenEvictionRunsMillis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
minEvictableIdleTimeMillis: 50000
validationQuery: select 'x'
testWhileIdle: true
testOnBorrow: false
testOnReturn: false
# 打开PSCache，并且指定每个连接上PSCache的大小
poolPreparedStatements: true
maxPoolPreparedStatementPerConnectionSize: 20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙 #,wall
filters: stat,slf4j
# 通过connectProperties属性来打开mergeSql功能；慢SQL记录
connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
# 合并多个DruidDataSource的监控数据
useGlobalDataSourceStat: true
mybatis:
configuration:
map-underscore-to-camel-case: true
#打印日志
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
mapper-locations: mybatis/**/*Mapper.xml
typeAliasesPackage: com.xxx.entity.*
#配置缓存和session存储方式，默认ehcache,可选redis
cacheType: ehcache5. 多说一句
关于mybatis-refresh.properties中mappingPath
指的是src/main/resources的最父级的mybatis文件夹，按下图的话：
mappingPath=mybatis