+ * 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 com.github.yiuman.citrus.support.datasource;
+
+import lombok.NonNull;
+import org.aopalliance.aop.Advice;
+import org.springframework.aop.ClassFilter;
+import org.springframework.aop.MethodMatcher;
+import org.springframework.aop.Pointcut;
+import org.springframework.aop.support.AbstractPointcutAdvisor;
+import org.springframework.aop.support.AopUtils;
+import org.springframework.aop.support.ComposablePointcut;
+import org.springframework.aop.support.StaticMethodMatcher;
+import org.springframework.aop.support.annotation.AnnotationMatchingPointcut;
+import org.springframework.beans.BeansException;
+import org.springframework.beans.factory.BeanFactory;
+import org.springframework.beans.factory.BeanFactoryAware;
+import org.springframework.core.annotation.AnnotatedElementUtils;
+import org.springframework.util.Assert;
+
+import javax.annotation.Nonnull;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+/**
+ * DataSource注解的切面
+ *
+ * @author yiuman
+ * @date 2020/11/30
+ */
+public class DynamicDataSourceAnnotationAdvisor extends AbstractPointcutAdvisor implements BeanFactoryAware {
+
+ private final Advice advice;
+
+ private final Pointcut pointcut;
+
+ public DynamicDataSourceAnnotationAdvisor(@NonNull DynamicDataSourceAnnotationInterceptor dynamicDataSourceAnnotationInterceptor) {
+ this.advice = dynamicDataSourceAnnotationInterceptor;
+ this.pointcut = buildPointcut();
+ }
+
+ @Nonnull
+ @Override
+ public Pointcut getPointcut() {
+ return this.pointcut;
+ }
+
+ @Nonnull
+ @Override
+ public Advice getAdvice() {
+ return this.advice;
+ }
+
+ @Override
+ public void setBeanFactory(@Nonnull BeanFactory beanFactory) throws BeansException {
+ if (this.advice instanceof BeanFactoryAware) {
+ ((BeanFactoryAware) this.advice).setBeanFactory(beanFactory);
+ }
+ }
+
+ private Pointcut buildPointcut() {
+ Pointcut cpc = new AnnotationMatchingPointcut(DataSource.class, true);
+ Pointcut mpc = new AnnotationMethodPoint(DataSource.class);
+ return new ComposablePointcut(cpc).union(mpc);
+ }
+
+ /**
+ * In order to be compatible with the spring lower than 5.0
+ */
+ private static class AnnotationMethodPoint implements Pointcut {
+
+ private final Class annotationType;
+
+ public AnnotationMethodPoint(Class annotationType) {
+ Assert.notNull(annotationType, "Annotation type must not be null");
+ this.annotationType = annotationType;
+ }
+
+ @Nonnull
+ @Override
+ public ClassFilter getClassFilter() {
+ return ClassFilter.TRUE;
+ }
+
+ @Nonnull
+ @Override
+ public MethodMatcher getMethodMatcher() {
+ return new AnnotationMethodMatcher(annotationType);
+ }
+
+ private static class AnnotationMethodMatcher extends StaticMethodMatcher {
+ private final Class annotationType;
+
+ public AnnotationMethodMatcher(Class annotationType) {
+ this.annotationType = annotationType;
+ }
+
+ @Override
+ public boolean matches(@Nonnull Method method, @Nonnull Class targetClass) {
+ if (matchesMethod(method)) {
+ return true;
+ }
+ // Proxy classes never have annotations on their redeclared methods.
+ if (Proxy.isProxyClass(targetClass)) {
+ return false;
+ }
+ // The method may be on an interface, so let's check on the target class as well.
+ Method specificMethod = AopUtils.getMostSpecificMethod(method, targetClass);
+ return (specificMethod != method && matchesMethod(specificMethod));
+ }
+
+ private boolean matchesMethod(Method method) {
+ return AnnotatedElementUtils.hasAnnotation(method, this.annotationType);
+ }
+ }
+ }
+}
diff --git a/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceAnnotationInterceptor.java b/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceAnnotationInterceptor.java
new file mode 100644
index 00000000..b25ed8e6
--- /dev/null
+++ b/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceAnnotationInterceptor.java
@@ -0,0 +1,36 @@
+
+package com.github.yiuman.citrus.support.datasource;
+
+import com.baomidou.mybatisplus.core.toolkit.StringUtils;
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+
+/**
+ * DataSource注解的代理方法拦截器
+ *
+ * @author yiuman
+ * @date 2020/11/30
+ */
+public class DynamicDataSourceAnnotationInterceptor implements MethodInterceptor {
+
+ private final DataSourceClassResolver dataSourceClassResolver;
+
+ public DynamicDataSourceAnnotationInterceptor() {
+ dataSourceClassResolver = new DataSourceClassResolver(true);
+ }
+
+ @Override
+ public Object invoke(MethodInvocation invocation) throws Throwable {
+ try {
+ String dsKey = dataSourceClassResolver.findDSKey(invocation.getMethod(), invocation.getThis());
+ if(StringUtils.isNotBlank(dsKey)){
+ DynamicDataSourceHolder.push(dsKey);
+ }
+
+ return invocation.proceed();
+ } finally {
+ DynamicDataSourceHolder.poll();
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceHolder.java b/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceHolder.java
new file mode 100644
index 00000000..9bf4e2cd
--- /dev/null
+++ b/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceHolder.java
@@ -0,0 +1,75 @@
+package com.github.yiuman.citrus.support.datasource;
+
+import org.springframework.core.NamedThreadLocal;
+import org.springframework.util.StringUtils;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * 数据源切换持有者
+ * 用于动态切换数据源以及多数据源事务管理
+ *
+ * @author yiuman
+ * @date 2020/12/1
+ */
+public final class DynamicDataSourceHolder {
+
+ /**
+ * 后进先出
+ */
+ private final static ThreadLocal> LOOKUP_KEY_HOLDER = new NamedThreadLocal>("dynamic-datasource") {
+ @Override
+ protected Deque initialValue() {
+ return new ArrayDeque<>();
+ }
+ };
+
+ private DynamicDataSourceHolder() {
+ }
+
+ /**
+ * 获得当前线程数据源
+ *
+ * @return 数据源名称
+ */
+ public static String peek() {
+ return LOOKUP_KEY_HOLDER.get().peek();
+ }
+
+ /**
+ * 设置当前线程数据源
+ *
+ * 如非必要不要手动调用，调用后确保最终清除
+ *
+ *
+ * @param ds 数据源名称
+ */
+ public static void push(String ds) {
+ LOOKUP_KEY_HOLDER.get().push(StringUtils.isEmpty(ds) ? "" : ds);
+ }
+
+ /**
+ * 清空当前线程数据源
+ *
+ * 如果当前线程是连续切换数据源 只会移除掉当前线程的数据源名称
+ *
+ */
+ public static void poll() {
+ Deque deque = LOOKUP_KEY_HOLDER.get();
+ deque.poll();
+ if (deque.isEmpty()) {
+ LOOKUP_KEY_HOLDER.remove();
+ }
+ }
+
+ /**
+ * 强制清空本地线程
+ *
+ * 防止内存泄漏，如手动调用了push可调用此方法确保清除
+ *
+ */
+ public static void clear() {
+ LOOKUP_KEY_HOLDER.remove();
+ }
+}
diff --git a/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceProperties.java b/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceProperties.java
new file mode 100644
index 00000000..9736c289
--- /dev/null
+++ b/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicDataSourceProperties.java
@@ -0,0 +1,64 @@
+package com.github.yiuman.citrus.support.datasource;
+
+import org.springframework.boot.autoconfigure.jdbc.DataSourceProperties;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+
+import java.util.Map;
+
+/**
+ * 动态数据源配置
+ *
+ * @author yiuman
+ * @date 2020/11/30
+ */
+@ConfigurationProperties(prefix = "spring.datasource")
+public class DynamicDataSourceProperties {
+
+ /**
+ * 主数据源
+ * 默认为spring.datasource
+ */
+ private String primary = "";
+
+ /**
+ * 是否严格模式，若为true找不到数据源抛出异常
+ */
+ private boolean strict = true;
+
+ /**
+ * 数据源名称与数据源配置
+ */
+ private Map multiples;
+
+ public DynamicDataSourceProperties() {
+ }
+
+ public String getPrimary() {
+ return primary;
+ }
+
+ public void setPrimary(String primary) {
+ this.primary = primary;
+ }
+
+ public boolean isStrict() {
+ return strict;
+ }
+
+ public void setStrict(boolean strict) {
+ this.strict = strict;
+ }
+
+ public Map getMultiples() {
+ return multiples;
+ }
+
+ public void setMultiples(Map multiples) {
+ this.multiples = multiples;
+ }
+
+ public Map getDatasource() {
+ return multiples;
+ }
+
+}
diff --git a/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicSqlSessionTemplate.java b/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicSqlSessionTemplate.java
new file mode 100644
index 00000000..416aa5f5
--- /dev/null
+++ b/citrus-support/src/main/java/com/github/yiuman/citrus/support/datasource/DynamicSqlSessionTemplate.java
@@ -0,0 +1,289 @@
+package com.github.yiuman.citrus.support.datasource;
+
+import org.apache.ibatis.cursor.Cursor;
+import org.apache.ibatis.exceptions.PersistenceException;
+import org.apache.ibatis.executor.BatchResult;
+import org.apache.ibatis.session.*;
+import org.mybatis.spring.MyBatisExceptionTranslator;
+import org.mybatis.spring.SqlSessionTemplate;
+import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.util.List;
+import java.util.Map;
+
+import static java.lang.reflect.Proxy.newProxyInstance;
+import static org.apache.ibatis.reflection.ExceptionUtil.unwrapThrowable;
+import static org.mybatis.spring.SqlSessionUtils.*;
+
+/**
+ * 动态数据源SqlSessionTemplate，拷贝原SqlSessionTemplate
+ *
+ * @author yiuman
+ * @date 2020/12/2
+ */
+public class DynamicSqlSessionTemplate extends SqlSessionTemplate {
+
+ /**
+ * 是否使用严格模式
+ */
+ private Boolean strict = false;
+
+ private final SqlSessionFactory sqlSessionFactory;
+
+ private final ExecutorType executorType;
+
+ private final SqlSession sqlSessionProxy;
+
+ private final PersistenceExceptionTranslator exceptionTranslator;
+
+ private Map targetSqlSessionFactories;
+
+ private SqlSessionFactory defaultTargetSqlSessionFactory;
+
+ public DynamicSqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
+ this(sqlSessionFactory, sqlSessionFactory.getConfiguration().getDefaultExecutorType());
+ }
+
+ public DynamicSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType) {
+ this(sqlSessionFactory, executorType, new MyBatisExceptionTranslator(sqlSessionFactory.getConfiguration()
+ .getEnvironment().getDataSource(), true));
+ }
+
+ public DynamicSqlSessionTemplate(SqlSessionFactory sqlSessionFactory, ExecutorType executorType,
+ PersistenceExceptionTranslator exceptionTranslator) {
+
+ super(sqlSessionFactory, executorType, exceptionTranslator);
+
+ this.sqlSessionFactory = sqlSessionFactory;
+ this.executorType = executorType;
+ this.exceptionTranslator = exceptionTranslator;
+
+ this.sqlSessionProxy = (SqlSession) newProxyInstance(
+ SqlSessionFactory.class.getClassLoader(),
+ new Class[]{SqlSession.class},
+ new SqlSessionInterceptor());
+
+ this.defaultTargetSqlSessionFactory = sqlSessionFactory;
+ }
+
+ public void setTargetSqlSessionFactories(Map targetSqlSessionFactories) {
+ this.targetSqlSessionFactories = targetSqlSessionFactories;
+ }
+
+ public void setDefaultTargetSqlSessionFactory(SqlSessionFactory defaultTargetSqlSessionFactory) {
+ this.defaultTargetSqlSessionFactory = defaultTargetSqlSessionFactory;
+ }
+
+ public void setStrict(Boolean strict) {
+ this.strict = strict;
+ }
+
+ /***
+ * 获取当前使用数据源对应的会话工厂
+ */
+ @Override
+ public SqlSessionFactory getSqlSessionFactory() {
+ String dataSourceKey = DynamicDataSourceHolder.peek();
+ SqlSessionFactory targetSqlSessionFactory = targetSqlSessionFactories.get(dataSourceKey);
+
+ if (!StringUtils.isEmpty(dataSourceKey) && strict && targetSqlSessionFactory == null) {
+ throw new IllegalArgumentException(String.format("can not find DataSource %s,please check your datasource settings", dataSourceKey));
+ }
+
+ if (targetSqlSessionFactory != null) {
+ return targetSqlSessionFactory;
+ } else if (defaultTargetSqlSessionFactory != null) {
+ return defaultTargetSqlSessionFactory;
+ } else {
+ Assert.notNull(targetSqlSessionFactories, "Property 'targetSqlSessionFactories' or 'defaultTargetSqlSessionFactory' are required");
+ Assert.notNull(defaultTargetSqlSessionFactory, "Property 'defaultTargetSqlSessionFactory' or 'targetSqlSessionFactories' are required");
+ }
+ return this.sqlSessionFactory;
+ }
+
+
+ /**
+ * 这个方法的实现和父类的实现是基本一致的，唯一不同的就是在getSqlSession方法传参中获取会话工厂的方式
+ */
+ private class SqlSessionInterceptor implements InvocationHandler {
+
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ //在getSqlSession传参时候，用我们重写的getSqlSessionFactory获取当前数据源对应的会话工厂
+ final SqlSession sqlSession = getSqlSession(
+ DynamicSqlSessionTemplate.this.getSqlSessionFactory(),
+ DynamicSqlSessionTemplate.this.executorType,
+ DynamicSqlSessionTemplate.this.exceptionTranslator);
+ try {
+ Object result = method.invoke(sqlSession, args);
+ if (!isSqlSessionTransactional(sqlSession, DynamicSqlSessionTemplate.this.getSqlSessionFactory())) {
+ sqlSession.commit(true);
+ }
+ return result;
+ } catch (Throwable t) {
+ Throwable unwrapped = unwrapThrowable(t);
+ if (DynamicSqlSessionTemplate.this.exceptionTranslator != null && unwrapped instanceof PersistenceException) {
+ Throwable translated = DynamicSqlSessionTemplate.this.exceptionTranslator
+ .translateExceptionIfPossible((PersistenceException) unwrapped);
+ if (translated != null) {
+ unwrapped = translated;
+ }
+ }
+ throw unwrapped;
+ } finally {
+ closeSqlSession(sqlSession, DynamicSqlSessionTemplate.this.getSqlSessionFactory());
+ }
+ }
+ }
+
+ @Override
+ public ExecutorType getExecutorType() {
+ return this.executorType;
+ }
+
+ @Override
+ public PersistenceExceptionTranslator getPersistenceExceptionTranslator() {
+ return this.exceptionTranslator;
+ }
+
+ @Override
+ public T selectOne(String statement) {
+ return this.sqlSessionProxy.selectOne(statement);
+ }
+
+ @Override
+ public T selectOne(String statement, Object parameter) {
+ return this.sqlSessionProxy.selectOne(statement, parameter);
+ }
+
+ @Override
+ public Map selectMap(String statement, String mapKey) {
+ return this.sqlSessionProxy.selectMap(statement, mapKey);
+ }
+
+ @Override
+ public Map selectMap(String statement, Object parameter, String mapKey) {
+ return this.sqlSessionProxy.selectMap(statement, parameter, mapKey);
+ }
+
+ @Override
+ public Map selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
+ return this.sqlSessionProxy.selectMap(statement, parameter, mapKey, rowBounds);
+ }
+
+ @Override
+ public Cursor selectCursor(String statement) {
+ return this.sqlSessionProxy.selectCursor(statement);
+ }
+
+ @Override
+ public Cursor selectCursor(String statement, Object parameter) {
+ return this.sqlSessionProxy.selectCursor(statement, parameter);
+ }
+
+ @Override
+ public Cursor selectCursor(String statement, Object parameter, RowBounds rowBounds) {
+ return this.sqlSessionProxy.selectCursor(statement, parameter, rowBounds);
+ }
+
+ @Override
+ public List selectList(String statement) {
+ return this.sqlSessionProxy.selectList(statement);
+ }
+
+ @Override
+ public List selectList(String statement, Object parameter) {
+ return this.sqlSessionProxy.selectList(statement, parameter);
+ }
+
+ @Override
+ public List selectList(String statement, Object parameter, RowBounds rowBounds) {
+ return this.sqlSessionProxy.selectList(statement, parameter, rowBounds);
+ }
+
+ @Override
+ public void select(String statement, ResultHandler handler) {
+ this.sqlSessionProxy.select(statement, handler);
+ }
+
+ @Override
+ public void select(String statement, Object parameter, ResultHandler handler) {
+ this.sqlSessionProxy.select(statement, parameter, handler);
+ }
+
+ @Override
+ public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
+ this.sqlSessionProxy.select(statement, parameter, rowBounds, handler);
+ }
+
+ @Override
+ public int insert(String statement) {
+ return this.sqlSessionProxy.insert(statement);
+ }
+
+ @Override
+ public int insert(String statement, Object parameter) {
+ return this.sqlSessionProxy.insert(statement, parameter);
+ }
+
+ @Override
+ public int update(String statement) {
+ return this.sqlSessionProxy.update(statement);
+ }
+
+ @Override
+ public int update(String statement, Object parameter) {
+ return this.sqlSessionProxy.update(statement, parameter);
+ }
+
+ @Override
+ public int delete(String statement) {
+ return this.sqlSessionProxy.delete(statement);
+ }
+
+ @Override
+ public int delete(String statement, Object parameter) {
+ return this.sqlSessionProxy.delete(statement, parameter);
+ }
+
+ @Override
+ public T getMapper(Class type) {
+ return getConfiguration().getMapper(type, this);
+ }
+
+ @Override
+ public void clearCache() {
+ this.sqlSessionProxy.clearCache();
+ }
+
+ @Override
+ public Configuration getConfiguration() {
+ SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
+ Configuration configuration = sqlSessionFactory.getConfiguration();
+ //Spring初始化Bean只会给默认的一个Configuration进行Mapper扫描及注入
+ // 这里如果调用了其他的数据源，是没有初始化MappedStatement的，需要从默认的进行初始化后再调用
+ //不然会出现 Invalid bound statement (not found) 异常
+ if (sqlSessionFactory != defaultTargetSqlSessionFactory && CollectionUtils.isEmpty(configuration.getMappedStatements())) {
+ defaultTargetSqlSessionFactory.getConfiguration().getMapperRegistry()
+ .getMappers().forEach(configuration::addMapper);
+ }
+ return configuration;
+ }
+
+ @Override
+ public Connection getConnection() {
+ return this.sqlSessionProxy.getConnection();
+ }
+
+ @Override
+ public List flushStatements() {
+ return this.sqlSessionProxy.flushStatements();
+ }
+
+}
diff --git a/citrus-support/src/main/java/com/github/yiuman/citrus/support/utils/SpringUtils.java b/citrus-support/src/main/java/com/github/yiuman/citrus/support/utils/SpringUtils.java
index c427a8e9..4d8217f1 100644
--- a/citrus-support/src/main/java/com/github/yiuman/citrus/support/utils/SpringUtils.java
+++ b/citrus-support/src/main/java/com/github/yiuman/citrus/support/utils/SpringUtils.java
@@ -50,4 +50,14 @@ public static T getBean(Class tClass, String name) {
return context.getBean(name, tClass);
}
+ public static T getBean(Class tClass, String name, boolean force) {
+ T bean;
+ try {
+ bean = context.getBean(name, tClass);
+ } catch (NoSuchBeanDefinitionException ex) {
+ bean = force ? context.getAutowireCapableBeanFactory().createBean(tClass) : null;
+ }
+ return bean;
+ }
+
}
diff --git a/citrus-system/pom.xml b/citrus-system/pom.xml
index b2291065..4075b15c 100644
--- a/citrus-system/pom.xml
+++ b/citrus-system/pom.xml
@@ -5,7 +5,7 @@
citrus
com.github.yiuman
- 0.0.7
+ 0.0.8
4.0.0
@@ -22,12 +22,12 @@
com.github.yiuman
citrus-security
- ${citrus.security.version}
+ ${citrus.version}
com.github.yiuman
citrus-support
- ${citrus.security.version}
+ ${citrus.version}
diff --git a/citrus-system/src/main/java/com/github/yiuman/citrus/system/entity/UserOrgan.java b/citrus-system/src/main/java/com/github/yiuman/citrus/system/entity/UserOrgan.java
index 5b7fb889..97474223 100644
--- a/citrus-system/src/main/java/com/github/yiuman/citrus/system/entity/UserOrgan.java
+++ b/citrus-system/src/main/java/com/github/yiuman/citrus/system/entity/UserOrgan.java
@@ -23,7 +23,6 @@ public class UserOrgan {
@TableField(exist = false)
private User user;
- @TableId
private Long organId;
@TableField(exist = false)
diff --git a/pom.xml b/pom.xml
index 1b7aa017..2ff97cb0 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
com.github.yiuman
citrus
- 0.0.7
+ 0.0.8
citrus
springboot-开发脚手架
https://github.com/Yiuman/citrus
@@ -48,15 +48,16 @@
${java.version}
2.3.2.RELEASE
28.2-jre
- 3.3.1
+ 3.4.1
1.8
1.8
1.8
- 0.0.7
+ 0.0.8
2.1.6
0.11.0
2.6
3.25.0-GA
+ 1.2.3