BlogJava-陈于喆的技术博客-随笔分类-spring

动态切换多数据源的配置

陈于喆 — Mon, 23 Aug 2010 08:22:00 GMT

前段时间我们的系统接到新增多一个频道的需求,原本我们的系统只是针对于广州的业务,现在需要新增另一个城市上海,经过和产品人员沟通和分析,城市之间的业务逻辑除了一些小差异基本还是一样的,数据库的结构经过整合两个城市也可以达到一样的结构,但上海需要独立出另一个数据库.

我们以前发布器的做法是用作为方法的一个参数由调用者一直传到访问对象(索引或数据库),虽然这种做法一样可以很快的实现,但是将数据库,索引的选择和业务逻辑混搭在一起的设计在感觉上是比较混乱,并且不利于将来多个城市(频道)的建立,所以选了通过ThreadLocal来实现多数据源的动态切换.

ThreadLocal 是一个依赖于执行线程的存储器，对它就只有简单的一个set和get方法，不同线程之间是相互独立的。简单地讲，就是：这个线程set了一个对象入去，只有这个线程自己可以把它get出来，其它线程是get不出来的。

好了,下面是具体显示的方式

首先定义一个filter,通过filter取得域名,因为我们的域名中带有城市的标志,如广州是http://gz.***.com,上海是http://sh.***.com,通过取得的域名,我们取得城市的表示放进ThreadLocal.set(city);

public class DataSourceFilter extends HttpServlet implements Filter {

public void doFilter(ServletRequest request, ServletResponse response,
      FilterChain filterChain) {
      HttpServletRequest req = (HttpServletRequest) request;
      String servername = req.getServerName();
      SpObserver.putCityByDomain(servername);
      filterChain.doFilter(request, response);
  }

}

public class SpObserver {
    private static ThreadLocal<String> local = new ThreadLocal<String>();

    public static void putCityByDomain(String domain) {
        String city = publicconfig.getCityMap().get(domain);//拆分domain,获取城市名
        local.set(city);
    }
    public static String getCity() {
        String city = (String) local.get();
        return city;
    }

}

建立多个与之对应的数据源

    <bean id="atomDataSource_gz"
        class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init"
        destroy-method="close">
        <property name="uniqueResourceName">
            <value>mysql/gzvalue>
        property>
        <property name="xaDataSourceClassName">
            <value>com.mysql.jdbc.jdbc2.optional.MysqlXADataSourcevalue>
        property>
        <property name="xaProperties">
            <props>
                <prop key="URL">${jdbc_gz.url}]]>prop>
                <prop key="user">${jdbc_gz.username}]]>prop>
                <prop key="password">${jdbc_gz.password}]]>prop>
            props>
        property>
        <property name="maxPoolSize">
            <value>50value>
        property>
        <property name="minPoolSize">
            <value>5value>
        property>
        <property name="loginTimeout">
            <value>20value>
        property>
        <property name="testQuery">
            <value>SELECT 1value>
        property>
    bean>

<bean id="atomDataSource_sh"
        class="com.atomikos.jdbc.AtomikosDataSourceBean" init-method="init"
        destroy-method="close">
        <property name="uniqueResourceName">
            <value>mysql/shvalue>
        property>
        <property name="xaDataSourceClassName">
            <value>com.mysql.jdbc.jdbc2.optional.MysqlXADataSourcevalue>
        property>
        <property name="xaProperties">
            <props>
                <prop key="URL">${jdbc_sh.url}]]>prop>
                <prop key="user">${jdbc_sh.username}]]>prop>
                <prop key="password">${jdbc_sh.password}]]>prop>
            props>
        property>
        <property name="maxPoolSize">
            <value>50value>
        property>
        <property name="minPoolSize">
            <value>5value>
        property>
        <property name="loginTimeout">
            <value>20value>
        property>
        <property name="testQuery">
            <value>SELECT 1value>
        property>
    bean>

    <bean id="dataSource" class="com.***.shine.constant.MultiDataSource">
        <property name="dataSource" ref="atomDataSource_gz" />
    bean>

public class MultiDataSource extends AtomikosDataSourceBean implements ApplicationContextAware {
    private ApplicationContext applicationContext = null;
    private DataSource dataSource = null;
    public Connection getConnection() throws SQLException {
        return getDataSource().getConnection();
    }
    public Connection getConnection(String arg0, String arg1)
            throws SQLException {
        return getDataSource().getConnection(arg0, arg1);
    }
    ..

    //通过适配者的设计模式动态的切换实现类,这样就实现了在DataSourceBean中,我们是要注入atomDataSource_gz还是atomDataSource_sh
    public DataSource getDataSource(String dataSourceName) {
        try{
            if(dataSourceName==null||dataSourceName.equals("")){
                return this.dataSource;
            }
            return (DataSource)this.applicationContext.getBean(dataSourceName);
        }catch(NoSuchBeanDefinitionException ex){
            throw new DaoException("There is not the dataSource "+dataSourceName+"> in the applicationContext!");
        }
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }
    //主要是下面这一段,通过SpObserver.getCity() 获取相应的城市(频道)名字
    public DataSource getDataSource(){
        String city = SpObserver.getCity();
        if(city == null || city.equals("") || city.equals("null"))
            city = "gz";
        return getDataSource("atomDataSource_"+city);
    }
    ...
}

这样在各个层中的实现我们就不需去关注究竟是哪个城市的接口,因为每个请求都附带了ThreadLocal的相应信息

关于ThreadLocal具体可看-->通通透透理解ThreadLocal

陈于喆 2010-08-23 16:22 发表评论

使用自定义annotation接口进行aspectj动态缓存

陈于喆 — Mon, 23 Aug 2010 02:35:00 GMT

由于系统需求需要对各个接口进行key-value缓存(以参数为key,返回的对象为value),当然对于这种情况首先考虑到的是使用aop,前段时间看过 aspectj的一些介绍,借此机会正好加以应用和体会一下,aspectj是AOP最早成熟的java实现,它稍微扩展了一下java语言,增加了一些 keyword等,具体的aspectj的基本语法见[ur=http://today.java.net/pub/a/today/2003/12 /26/ch3AspectJSyntaxBasics.html]这里[/url],进行缓存的框架使用较成熟的ehcache.
下面开始进行配置
首先是ehcache的配置文件

xml version="1.0" encoding="UTF-8"?>
<ehcache>
     <diskStore path="/home/workspace/gzshine/trunk/ehcache"/>
     <cache name="DEFAULT_CACHE"
         maxElementsInMemory="10000"
         eternal="false"
         timeToIdleSeconds="3600"
         timeToLiveSeconds="3600"
         overflowToDisk="true"/>
ehcache>

这个的DEFAULT_CACHE是默认配置,最大的缓存数为10000,时间为一个小时

接下来的是spring下的配置

xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns:aop="http://www.springframework.org/schema/aop"
     xmlns:tx="http://www.springframework.org/schema/tx"
     xmlns:context="http://www.springframework.org/schema/context"
     xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-2.5.xsd">



     <aop:aspectj-autoproxy proxy-target-class="true"/>
     <bean id = "methodCacheAspectJ" class="com.***.shine.aspectj.MethodCacheAspectJ" >
         <property name="cache">
             <ref local="methodCache" />
         property>
     bean>

     <bean id="cacheManager"
         class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
         <property name="configLocation">
             <value>classpath:ehcache.xmlvalue>
         property>
     bean>



     <bean id="methodCache"
         class="org.springframework.cache.ehcache.EhCacheFactoryBean">
         <property name="cacheManager">
             <ref local="cacheManager" />
         property>
         <property name="cacheName">
             <value>DEFAULT_CACHEvalue>
         property>
     bean>

是为aspectj在所有class下开启自动动态代理
指定刚刚的ehcache配置文件

接下来编写一个自定义的annotation

package com.***.shine.cache;

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;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MethodCache {
     int second() default 0;
}

是一个aspectj进行Pointcuts和Advice的类需注入methodCache

package com.***.shine.aspectj;

@Aspect
public class MethodCacheAspectJ {
     Log logger = LogFactory.getLog(MethodCacheAspectJ.class);

     private Cache cache;

     /**
      * 设置缓存名
      */
     public void setCache(Cache cache) {
         this.cache = cache;
     }

     @Pointcut("@annotation(com.***.shine.cache.MethodCache)")
     public void methodCachePointcut(){
     }

     @Around("methodCachePointcut()")
     public Object methodCacheHold(ProceedingJoinPoint joinPoint) throws Throwable{
         String targetName = joinPoint.getTarget().getClass().getName();
         String methodName = joinPoint.getSignature().getName();
         Object[] arguments = joinPoint.getArgs();
         Object result = null;
         String cacheKey = getCacheKey(targetName, methodName, arguments);
         Element element = cache.get(cacheKey);
         if (element == null) {
             try{
                 result = joinPoint.proceed();
             }catch(Exception e){
                 logger.info(e);
             }
             if(result!=null){
                 try{
                     element = new Element(cacheKey, (Serializable) result);
                     Class targetClass = Class.forName(targetName);
                     Method[] method = targetClass.getMethods();
                     int second = 0;
                     for(Method m:method){
                         if (m.getName().equals(methodName)) {
                             Class[] tmpCs = m.getParameterTypes();
                             if(tmpCs.length==arguments.length){
                                 MethodCache methodCache = m.getAnnotation(MethodCache.class);
                                 second = methodCache.second();
                                 break;
                             }
                         }
                     }
                     if(second>0){ // annotation没有设second值则使用ehcache.xml中自定义值
                         element.setTimeToIdle(second);
                         element.setTimeToLive(second);
                     }
                     cache.put(element);
                 }catch(Exception e){
                     logger.info("!!!!!!!!!"+cacheKey+"!!!!!!!!!未能执行方法缓存"+e);
                 }
             }
         }
         return element.getValue();
     }

      private String getCacheKey(String targetName, String methodName,
             Object[] arguments) {
         StringBuffer sb = new StringBuffer();
         sb.append(targetName).append(".").append(methodName);
         if ((arguments != null) && (arguments.length != 0)) {
             for (int i = 0; i < arguments.length; i++) {
                 if (arguments[i] instanceof Date) {
                     sb.append(".").append(
                             DateUtil.datetoString((Date) arguments[i]));
                 } else {
                     sb.append(".").append(arguments[i]);
                 }
             }
         }
         return sb.toString();
     }
}

@Pointcut("@annotation(com.netease.shine.cache.MethodCache)")
对有应用com.netease.shine.cache.MethodCache进行注解的方法进行横切面拦截
@Around("methodCachePointcut()")
并在Advice中处理这个Pointcut,这里的的Advice使用的是Around(环绕通知)
String cacheKey = getCacheKey(targetName, methodName, arguments);
接下来使用类型,方法名,参数为key进入缓存处理
Element element = cache.get(cacheKey);
当然如果在cache队列中取得非null对象则直接返回该对象
MethodCache methodCache = m.getAnnotation(MethodCache.class);
second = methodCache.second();
取得second的值(缓存的时间,如在@annotation中无重写只为int second() default 0)
element.setTimeToIdle(second);
element.setTimeToLive(second);
如果非零则重新设置缓存时间

@MethodCache(second=300)
public List<Sort> getSort(int type,int parentid){
     System.out.println("!!!!!!!!!!!!!没缓存到");
     Row row = new Row();
     row.put("type", type);
     row.put("parentid", parentid);
     return (List<Sort>)gz_Template.queryForList("sort.getSort", row);
}

----------------------------------------

陈于喆
Mail: chenyz@corp.netease.com

陈于喆 2010-08-23 10:35 发表评论