java 配置多数据源切换主从

不念不忘少年蓝@ 2022-05-27 10:57 294阅读 0赞

# [从零开始学 Java - Spring AOP 实现主从读写分离][Java - Spring AOP] #

# 深刻讨论为什么要读写分离？ #

为了服务器承载更多的用户？提升了网站的响应速度？分摊数据库服务器的压力？就是为了双机热备又不想浪费备份服务器？上面这些回答，我认为都不是错误的，但也都不是完全正确的。「读写分离」并不是多么神奇的东西，也带不来多么大的性能提升，也许更多的作用的就是数据安全的备份吧。

从一个库到读写分离，从理论上对服务器压力来说是会带来一倍的性能提升，但你仔细思考一下，你的应用服务器真的很需要这一倍的提升么？那倒不如你去试着在服务器使用一下缓存系统，如 Memcached、Redis 这些分布式缓存，那性能可能是几十倍的提升。而且，在服务器硬件异常强悍及性能廉价的今天，完全更没必要了，所以，在今天，我认为它更多的职责就是为了数据安全而设计的，同时又提升了一些性能，这样也挺好。

可能我们更应该称之为`主从分离`。

# 利用 AOP 实现读写分离 #

读写分离方式很简单，就是在你读数据是去连接**从库**，在你写数据的时候去连接**主库**，具体代码实现当然就是连接时候去操作了，这没什么难度，在代码里写就是了。可是，有追求的程序猿都是不是这么解决问题的呢！  
其实通过上篇的 [从零开始学 Java - Spring AOP 拦截器的基本实现][Java - Spring AOP 1] 我们知道 AOP 可以实现在方法开始执行前后插入执行我们想要的代码，那这样，我们是不是可以在**执行数据库操作前根据业务来动态切换数据源**呢？  
思考一下这个方式理论上好像是可行的，这种方式首先不需要在业务代码中去做切换，二是可能以后我们不需要读写分离了，把 AOP 切换的代码去掉就行了，三是可能就是拓展性好了。

# 等不了了，开始撸代码 #

你可能想深入的了解的话，我这里给你几个程序里用到的关键字`enum（枚举）`、`annotation（自定义注解）`、`JoinPoint（注入点）`、`AbstractRoutingDataSource（数据源接口子类）`，你理解了这些就知道了，其实你并不需要深入某些深层的东西，了解下即可。

\*\*一、建立`JdbcContextHolder.java`类

public class JdbcContextHolder {
    
        private static final ThreadLocal<String> contextHolder = new ThreadLocal<String>();
    
        public static void setJdbcType(String jdbcType) {
            contextHolder.set(jdbcType);
        }
    
        public static void setSlave() {
            setJdbcType("slave");
        }
    
        public static void setMaster() {
            clearJdbcType();
        }
    
        public static String getJdbcType() {
            return (String) contextHolder.get();
        }
    
        public static void clearJdbcType() {
            contextHolder.remove();
        }
    }

这个类的作用就是用来**设置、获取数据源连接**

**二、新建`DynamicDataSource.java`类，继承于`AbstractRoutingDataSource`**

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
    
    import cn.mayongfa.common.JdbcContextHolder;
    
    public class DynamicDataSource extends AbstractRoutingDataSource {
    
        @Override
        protected Object determineCurrentLookupKey() {
            // 获取当前数据源连接
            return JdbcContextHolder.getJdbcType();
        }
    }

通过研究，我们知道`determineCurrentLookupKey`方法是获取相关数据源连接的，所以重写`determineCurrentLookupKey`方法就可以啦，然后我们去通过刚刚我们建立的`JdbcContextHolder`类去获取。那怎么设置呢？

**三、建立数据源`DataSourceType.java`枚举类**

public enum DataSourceType {
    
        //主库
        Master("master"),
    
        //从库
        Slave("slave");
    
        private DataSourceType(String name) {
            this.name = name;
        }
    
        private String name;
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    }

这个枚举类的作用其实就是为了设置数据源而生的，它的目的就是让设置数据源时更方便，如丝般顺滑。

\*\*四、新建`DataSource.java`Annotation（自定义注解）类

import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Retention(RetentionPolicy.RUNTIME)  
    @Target(ElementType.METHOD)
    @Documented
    public @interface DataSource {  
    
        DataSourceType value() default DataSourceType.Master;
    
    }

自定义注解的意义不再过多讨论，一句话来说就是可以让你**在类或方法名上以打标签的形式让该方法变得不一样**。具体怎么「不一样」，这个在于你。

**五、新建`DataSourceChoose.java`数据库切换类**

import java.lang.reflect.Method;
    
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.reflect.MethodSignature;
    
    import cn.mayongfa.common.JdbcContextHolder;
    
    public class DataSourceChoose {
    
    //方法执行前
    public void before(JoinPoint point){
        Object target = point.getTarget();  
            String method = point.getSignature().getName();  
            Class<?>[] classz = target.getClass().getInterfaces();  
            MethodSignature methodSignature = (MethodSignature)point.getSignature();
            Class<?>[] parameterTypes = methodSignature.getMethod().getParameterTypes();
            try {
                Method m = classz[0].getMethod(method, parameterTypes);  
                if (m!=null && m.isAnnotationPresent(DataSource.class)) {  
                    DataSource data = m.getAnnotation(DataSource.class);  
                    JdbcContextHolder.clearJdbcType();
                    JdbcContextHolder.setJdbcType(data.value().getName());
                }  
            } catch (Exception e) {  
                // TODO: handle exception 
            } 
    }
    }

这个其实是一个拦截器类，主要作用就是拦截那些方法名上有`@DataSource`这个自定义注解的，完了根据获取注解的`value()`值，来做相应的数据源切换。

到这里，整个读写分离的分析及业务逻辑和具体代码都完了，代码都可以访问我的 Github 看到 [https://github.com/mafly/SpringDemo][https_github.com_mafly_SpringDemo] 。接下来就是配置文件配置多个数据源、拦截器，这部分就相对固定以及没难度，放在下一篇文章中：

[从零开始学 Java - Spring 一主多从、多主多从 数据库配置][Java - Spring _]

[Java - Spring AOP]: http://www.cnblogs.com/mafly/p/master_slave.html
[Java - Spring AOP 1]: http://blog.mayongfa.cn/86.html
[https_github.com_mafly_SpringDemo]: https://github.com/mafly/SpringDemo
[Java - Spring _]: http://blog.mayongfa.cn/129.html