基于memcached的SNA实现

系统要集群，使用SNA方案。
一、 缓存的处理
缓存要使用统一的缓存服务器，集中式缓存。
原先的实现采用ehcache。
在spring里的配置，以资源缓存为例：

1. <!-- EhCache Manager -->
2.      < bean   id = "cacheManager"   class = "org.springframework.cache.ehcache.EhCacheManagerFactoryBean" >
3.          < property   name = "configLocation" >
4.              < value > classpath:ehcache.xml </ value >
5.          </ property >
6. </ bean >
8. < bean   id = "resourceCacheBackend"
9.            class = "org.springframework.cache.ehcache.EhCacheFactoryBean" >
10.          < property   name = "cacheManager"   ref = "cacheManager" />
11.          < property   name = "cacheName"   value = "resourceCache" />
12.      </ bean >
14.      < bean   id = "resourceCache"
15.            class = "com.framework.extcomponent.security.authentication.services.acegi.cache.EhCacheBasedResourceCache"
16.            autowire = "byName" >
17.          < property   name = "cache"   ref = "resourceCacheBackend" />
18.      </ bean >

 

 

cacheManager负责对ehcache进行管理，初始化、启动、停止。
resourceCacheBackend负责实际执行缓存操作，put 、get、remove。
resourceCache实现具有业务语义的业务应用层面的缓存操作，内部调用resourceCacheBackend操作。

现在采用memcached。
关于客户端，采用文初封装的客户端，地址在http://code.google.com/p/memcache-client-forjava/ 。
使用spring的FactoryBean进行二次封装。同理：
memcachedManager负责对memcached进行管理，初始化、启动、停止。
代码：

1. /**
2. * User: ronghao
3. * Date: 2008-10-14
4. * Time: 10:36:30
5. * 管理Memcached 的CacheManager
6. */
7. public   class  MemcachedCacheManagerFactoryBean  implements  FactoryBean, InitializingBean, DisposableBean {
9.      protected   final  Log logger = LogFactory.getLog(getClass());
11.      private  ICacheManager<IMemcachedCache> cacheManager;
13.      public  Object getObject()  throws  Exception {
14.          return  cacheManager;
15.     }
17.      public  Class getObjectType() {
18.          return   this .cacheManager.getClass();
19.     }
21.      public   boolean  isSingleton() {
22.          return   true ;
23.     }
25.      public   void  afterPropertiesSet()  throws  Exception {
26.         logger.info( "Initializing Memcached CacheManager" );
27.         cacheManager = CacheUtil.getCacheManager(IMemcachedCache. class ,
28.                 MemcachedCacheManager. class .getName());
29.         cacheManager.start();
30.     }
32.      public   void  destroy()  throws  Exception {
33.         logger.info( "Shutting down Memcached CacheManager" );
34.         cacheManager.stop();
35.     }
36. }

 

配置：

1. < bean   id = "memcachedManager"
2.            class = "com.framework.extcomponent.cache.MemcachedCacheManagerFactoryBean" />

 

resourceCacheBackend负责实际执行缓存操作，put 、get、remove。
代码：

1. /**
2. * User: ronghao
3. * Date: 2008-10-14
4. * Time: 10:37:16
5. * 返回  MemcachedCache
6. */
7. public   class  MemcachedCacheFactoryBean  implements  FactoryBean, BeanNameAware, InitializingBean {
9.      protected   final  Log logger = LogFactory.getLog(getClass());
11.      private  ICacheManager<IMemcachedCache> cacheManager;
12.      private  String cacheName;
13.      private  String beanName;
14.      private  IMemcachedCache cache;
16.      public   void  setCacheManager(ICacheManager<IMemcachedCache> cacheManager) {
17.          this .cacheManager = cacheManager;
18.     }
20.      public   void  setCacheName(String cacheName) {
21.          this .cacheName = cacheName;
22.     }
24.      public  Object getObject()  throws  Exception {
25.          return  cache;
26.     }
28.      public  Class getObjectType() {
29.          return   this .cache.getClass();
30.     }
32.      public   boolean  isSingleton() {
33.          return   true ; 
34.     }
36.      public   void  setBeanName(String name) {
37.          this .beanName=name;
38.     }
40.      public   void  afterPropertiesSet()  throws  Exception {
41.          // If no cache name given, use bean name as cache name.
42.         if  ( this .cacheName ==  null ) {
43.          this .cacheName =  this .beanName;
44.     }
45.         cache = cacheManager.getCache(cacheName);
46.     }
47. }

 

配置：

1. < bean   id = "resourceCacheBackend"
2.            class = "com.framework.extcomponent.cache.MemcachedCacheFactoryBean" >
3.          < property   name = "cacheManager"   ref = "memcachedManager" />
4.          < property   name = "cacheName"   value = "memcache" />
5.      </ bean >

 

resourceCache同上，替换新的实现类MemcachedBasedResourceCache即可。

二、 Session失效的处理
采用memcached作为httpsession的存储，并不直接保存httpsession对象，自定义SessionMap，SessionMap直接继承HashMap，保存SessionMap。

会话胶粘：未失败转发的情况下没必要在memcached保存的SessionMap和httpsession之间复制来复制去，眉来眼去。

利用memcached计数器保存在线人数。

系统权限采用了acegi，在acegi的拦截器链里配置snaFilter

1. < bean   id = "filterChainProxy"
2.            class = "org.acegisecurity.util.FilterChainProxy" >
3.          < property   name = "filterInvocationDefinitionSource" >
4.              < value >
5.                 CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
6.                 PATTERN_TYPE_APACHE_ANT
7.                 /**=snaFilter,httpSessionContextIntegrationFilter,logoutFilter,authenticationProcessingFilter,basicProcessingFilter,securityContextHolderAwareRequestFilter,exceptionTranslationFilter,filterInvocationInterceptor
8.              </ value >
9.          </ property >
10. </ bean >

 

注意需要配置在第一个。
snaFilter的职责：
1、 没有HttpSession时，创建HttpSession;
2、 创建Cookie保存HttpSession id;
3、 如果Cookie保存的HttpSession id与当前HttpSession id一致，说明是正常请求；
4、 如果Cookie保存的HttpSession id与当前HttpSession id不一致，说明是失败转发；失败转发的处理：
     4.1、根据Cookie保存的HttpSession id从memcached获取SessionMap；
     4.2、SessionMap属性复制到当前HttpSession；
     4.3、memcached删除SessionMap。
5、 判断当前请求url是否是登出url，是则删除SessionMap，在线人数减1.

代码：

1. public   void  doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
2.                          FilterChain filterChain)  throws  IOException, ServletException {
3.          final  HttpServletRequest hrequest = (HttpServletRequest) servletRequest;
4.          final  HttpServletResponse hresponse = (HttpServletResponse) servletResponse;
5.         String uri = hrequest.getRequestURI();
6.         logger.debug( "开始SNA拦截-----------------"  + uri);
7.         HttpSession httpSession = hrequest.getSession();
8.         String sessionId = httpSession.getId();
9.          //如果是登出,则直接干掉sessionMap
10.          if  (uri.equals(logoutUrl)) {
11.             logger.debug( "remove sessionmap:"  + sessionId);
12.              //在线人数减1
13.             getCache().addOrDecr( "userCount" , 1 );
14.             getCache().remove(sessionId);
15.         }  else  {
16.             String cookiesessionid = getSessionIdFromCookie(hrequest, hresponse);
17.              if  (!sessionId.equals(cookiesessionid)) {
18.                 createCookie(sessionId, hresponse);
19.                 SessionMap sessionMap = getSessionMap(cookiesessionid);
20.                  if  (sessionMap !=  null ) {
21.                     logger.debug( "fail over--------sessionid:"  + sessionId +  "cookiesessionid:"  + cookiesessionid);
22.                     initialHttpSession(sessionMap, httpSession);
23.                     cache.remove(cookiesessionid);
24.                 }
25.             }
26.         }
27.         filterChain.doFilter(hrequest, hresponse);
28. }

 

利用HttpSessionAttributeListener监听httpsession的属性变化,同步到memecached中的sessionmap。

1. public   void  attributeAdded(HttpSessionBindingEvent event) {
2.         HttpSession httpSession = event.getSession();
3.         String attrName = event.getName();
4.         Object attrValue = event.getValue();
5.         String sessionId = httpSession.getId();
6.         logger.debug( "attributeAdded sessionId:"  + sessionId +  "name:"  + attrName +  ",value:"  + attrValue);
7.         SessionMap sessionMap = getSessionMap(sessionId);
8.          if  (sessionMap ==  null ){
9.              //在线人数加1
10.             getCache().addOrIncr( "userCount" , 1 );
11.             sessionMap =  new  SessionMap();
12.         }
13.         logger.debug( "name:"  + attrName +  ",value:"  + attrValue);
14.         sessionMap.put(attrName, attrValue);
15.         getCache().put(sessionId, sessionMap);
16.     }
18.      public   void  attributeRemoved(HttpSessionBindingEvent event) {
19.         HttpSession httpSession = event.getSession();
21.         String attrName = event.getName();
22.         String sessionId = httpSession.getId();
23.         logger.debug( "attributeRemoved sessionId:"  + sessionId +  "name:"  + attrName);
24.         SessionMap sessionMap = getSessionMap(sessionId);
25.          if  (sessionMap !=  null ) {
26.             logger.debug( "remove:"  + attrName);
27.             sessionMap.remove(attrName);
28.             getCache().put(sessionId, sessionMap);
29.         }
30.     }
32.      public   void  attributeReplaced(HttpSessionBindingEvent event) {
33.         attributeAdded(event);
34.     }

 

利用HttpSessionListener，sessionDestroyed事件时根据sessionid删除memcached里的sessionMap（如果存在）。不再担心httpsession的过期问题。

1. public   void  sessionDestroyed(HttpSessionEvent event) {
2.         HttpSession httpSession = event.getSession();
3.         String sessionId = httpSession.getId();
4.         logger.debug( "session Removed sessionId:"  + sessionId);
5.         SessionMap sessionMap = getSessionMap(sessionId);
6.          if  (sessionMap !=  null ) {
7.             logger.debug( "remove sessionmap:"  + sessionId);
8.              //在线人数减1
9.             getCache().addOrDecr( "userCount" , 1 );
10.             getCache().remove(sessionId);
11.         }
12.     }

 

三、 文件保存的处理
和缓存类似，采用集中式的文件服务。对于linux，采用nfs。参考文档http://linux.vbird.org/linux_server/0330nfs.php#What_NFS_perm 。关键在于对权限的分配。
应用程序本身不用修改。