激情懂色av一区av二区av,另类视频一区二区三区,中文在线观看视频

动态切换多数据源的配置

Mon, 23 Aug 2010 08:22:00 GMT

前段旉��我们的系�l�接到新增多一个频道的需�?原本我们的系�l�只是针对于�q�州的业�?现在需要新增另一个城市上��?�l�过和��品�h员沟通和分析,城市之间的业务逻辑除了一些小差异基本�q�是一��L��,数据库的�l�构�l�过整合两个城市也可以达��C��L��l�构,但上��需要独立出另一个数据库.

我们以前发布器的做法是用作�ؓ�Ҏ��的一个参数由调用者一直传到访问对�?索引或数据库),虽然�q�种做法一样可以很快的实现,但是��数据库,索引的选择和业务逻辑��h��在一��L��设计在感觉上是比较�؜�?�q�且不利于将来多个城�?频道)的徏�?所以选了通过ThreadLocal来实现多数据源的动态切�?

ThreadLocal 是一个依赖于执行�U�程的存储器�Q�对它就只有��单的一个set和get�Ҏ��Q�不同线�E�之间是�怺�独立的。简单地�Ԍ��是�Q�这个线�E�set了一个对象入去，只有�q�个�U�程自己可以把它get出来�Q�其它线�E�是get不出来的�?br />
好了,下面是具体显�C�的方式

首先定义一个filter,通过filter取得域名,因�ؓ我们的域名中带有城市的标�?如广州是http://gz.***.com,上�v是http://sh.***.com,通过取得的域�?我们取得城市的表�C�放�q�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,获取城市�?/span>
        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);
    }
    ..

    //通过适配者的设计模式动态的切换实现�c?�q�样��实��C��在DataSourceBean�?我们是要注入atomDataSource_gz�q�是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;
    }
    //主要是下面这一�D?通过SpObserver.getCity() 获取相应的城�?频道)名字
    public DataSource getDataSource(){
        String city = SpObserver.getCity();
        if(city == null || city.equals("") || city.equals("null"))
            city = "gz";
        return getDataSource("atomDataSource_"+city);
    }
    ...
}

�q�样在各个层中的实现我们��׃��需��d��注究竟是哪个城市的接�?因�ؓ每个��h��都附带了ThreadLocal的相应信�?br />
关于ThreadLocal具体可看-->通通透透理解ThreadLocal

陈于�?/a> 2010-08-23 16:22 发表评论

Mon, 23 Aug 2010 02:35:00 GMT

�׃��pȝ��需求需要对各个接口�q�行key-value�~�存(以参��Cؓkey,�q�回的对象�ؓvalue),当然对于�q�种情况首先考虑到的是��用aop,前段旉��看过 aspectj的一些介�l?借此��Z��正好加以应用和体会一�?aspectj是AOP最早成熟的java实现,它稍微扩展了一下java语言,增加了一�? keyword�{?具体的aspectj的基本语法见[ur=http://today.java.net/pub/a/today/2003/12 /26/ch3AspectJSyntaxBasics.html]�q�里[/url],�q�行�~�存的框架��用较成熟的ehcache.
下面开始进行配�|?br /> 首先是ehcache的配�|�文�?br />

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>

�q�个的DEFAULT_CACHE是默认配�|?最大的�~�存��Cؓ10000,旉��Z��个小�?br />
接下来的是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下开启自动动态代�?br /> 指定刚刚的ehcache配置文�g

接下来编写一个自定义的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�q�行Pointcuts和Advice的类需注入methodCache

package com.***.shine.aspectj;

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

     private Cache cache;

     /**
      * 讄��~�存�?nbsp;
      */
     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中自定义�?nbsp;
                         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�q�行注解的方法进行横切面拦截
@Around("methodCachePointcut()")
�q�在Advice中处理这个Pointcut,�q�里的的Advice使用的是Around(环绕通知)
String cacheKey = getCacheKey(targetName, methodName, arguments);
接下来��用类�?�Ҏ��?参数为key�q�入�~�存处理
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);
如果非零则重新设�|�缓存时�?br />

@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

陈于�?/a> 2010-08-23 10:35 发表评论