本篇内容主要讲解“如何使用spring aop实现业务层MySQL读写分离”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“如何使用spring aop实现业务层mysql读写分离”吧!

网站建设哪家好，找创新互联！专注于网页设计、网站建设、微信开发、小程序定制开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了南郑免费建站欢迎大家使用！

1.使用spring aop 拦截机制现数据源的动态选取。

import java.lang.annotation.ElementType;
    import java.lang.annotation.Target;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    /
     * RUNTIME
     * 编译器将把注释记录在类文件中，在运行时 VM 将保留注释，因此可以反射性地读取。
     * @author yangGuang
     *
     */
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.METHOD)
    public @interface DataSource {
        String value();
    }

 
 3.利用Spring的AbstractRoutingDataSource解决多数据源的问题 参考： http://blog.csdn.net/alaahong/article/details/8707915

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
   
    public class ChooseDataSource extends AbstractRoutingDataSource {

        @Override
        protected Object determineCurrentLookupKey() {
            return HandleDataSource.getDataSource();
        }
        
    }

    4.利用ThreadLocal解决线程安全问题

public class HandleDataSource {
        public static final ThreadLocal holder = new ThreadLocal();
        public static void putDataSource(String datasource) {
            holder.set(datasource);
        }
        
        public static String getDataSource() {
            return holder.get();
        }    
    }

    5.定义一个数据源切面类，通过aop访问，在spring配置文件中配置了，所以没有使用aop注解。

import java.lang.reflect.Method;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    import org.aspectj.lang.reflect.MethodSignature;
    import org.springframework.stereotype.Component;
    //@Aspect
    //@Component
    public class DataSourceAspect {
        //@Pointcut("execution(* com.apc.cms.service.*.*(..))")  
        public void pointCut(){};  
        
      //  @Before(value = "pointCut()")
         public void before(JoinPoint point)
            {
                Object target = point.getTarget();
                System.out.println(target.toString());
                String method = point.getSignature().getName();
                System.out.println(method);
                Class[] classz = target.getClass().getInterfaces();
                Class[] parameterTypes = ((MethodSignature) point.getSignature())
                        .getMethod().getParameterTypes();
                try {
                    Method m = classz[0].getMethod(method, parameterTypes);
                    System.out.println(m.getName());
                    if (m != null && m.isAnnotationPresent(DataSource.class)) {
                        DataSource data = m.getAnnotation(DataSource.class);
                        HandleDataSource.putDataSource(data.value());
                    }
                    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
    }

    
    6.配置applicationContext.xml

    
7.使用注解，动态选择数据源，分别走读库和写库。

@DataSource("write")
    public void update(User user) {
        userMapper.update(user);
    }
    
    @DataSource("read")
    public Document getDocById(long id) {
        return documentMapper.getById(id);
    }

测试写操作：可以通过应用修改数据，修改主库数据，发现从库的数据被同步更新了，所以定义的write操作都是走的写库

 测试读操作：  后台修改从库数据，查看主库的数据没有被修改，在应用页面中刷新，发现读的是从库的数据，说明读写分离ok。

 
遇到的问题总结：

  问题1：项目是maven工程，用到了Spring aop机制，除了spring的核心jar包以为，还需要用到的jar包有aspectj.jar，aspectjweaver.jar，aopalliance.jar查看项目中的pom，发现缺少依赖包，
    由于本地仓库没有这些jar，查找可以提供下载jar包的maven中央库库，配置到maven中,自动更新：

                    nexus
                    nexus
                    http://repository.sonatype.org/content/groups/public/
                    default
                

    配置项目依赖的jar，主要是缺少这两个。

                aspectj
                aspectjrt
                1.5.4
         
         
                aspectj
                aspectjweaver
                1.5.4
        

到此，相信大家对“如何使用spring aop实现业务层mysql读写分离”有了更深的了解，不妨来实际操作一番吧！这里是创新互联网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！