用zookeeper实现分布式session

最新推荐文章于 2022-05-02 14:09:44 发布
最新推荐文章于 2022-05-02 14:09:44 发布
阅读量563 收藏
点赞数
文章标签： ZooKeeper session 分布式

废话不说，直接贴代码

[java]  view plain copy
  1. package com.tianque.session;  
  2.   
  3. import java.util.Date;  
  4. import java.util.HashMap;  
  5. import java.util.Map;  
  6.   
  7. import javax.servlet.ServletContext;  
  8. import javax.servlet.http.HttpSession;  
  9. import javax.servlet.http.HttpSessionContext;  
  10.   
  11. import com.tianque.session.zookeeper.ZkSessionChangeListener;  
  12. import com.tianque.session.zookeeper.ZkSessionHelper;  
  13.   
  14. /** 
  15.  * @author hxpwangyi@163.com 
  16.  * @date 2013-3-1 
  17.  */  
  18. public abstract class AbstractSession implements HttpSession {  
  19.     private SessionMetaData meta;  
  20.   
  21.     public AbstractSession(){  
  22.         meta=new SessionMetaData();  
  23.         meta.setCreateTime(new Date().getTime());  
  24.         //meta.setSid(SidGenerator.generateSid());  
  25.         meta.setLastAccessedTime(meta.getCreateTime());  
  26.         meta.setIsnew(true);  
  27.         meta.setMaxInactiveInterval((int)SessionChangeListener.getTimeout());  
  28.         //ZkSessionHelper.addSession(meta);  
  29.     }  
  30.   
  31.     public void setLastAccessedTime(long lastAccessedTime) {  
  32.         meta.setLastAccessedTime(lastAccessedTime);  
  33.     }  
  34.   
  35.     public long getCreationTime() {  
  36.         return meta.getCreateTime();  
  37.     }  
  38.   
  39.     public String getId() {  
  40.         return meta.getSid();  
  41.     }  
  42.       
  43.     public void setId(String sid){  
  44.         meta.setSid(sid);  
  45.     }  
  46.   
  47.     public long getLastAccessedTime() {  
  48.         return meta.getLastAccessedTime();  
  49.     }  
  50.   
  51.     public ServletContext getServletContext() {  
  52.         return null;  
  53.     }  
  54.   
  55.     public void setMaxInactiveInterval(int interval) {  
  56.         meta.setMaxInactiveInterval(interval);  
  57.   
  58.     }  
  59.   
  60.     public int getMaxInactiveInterval() {  
  61.         return meta.getMaxInactiveInterval();  
  62.     }  
  63.   
  64.     public HttpSessionContext getSessionContext() {  
  65.         return null;  
  66.     }  
  67.       
  68.     public void invalidate() {  
  69.   
  70.     }  
  71.   
  72.     public boolean isNew() {  
  73.         return meta.isIsnew();  
  74.     }  
  75.   
  76.     public SessionMetaData getMeta() {  
  77.         return meta;  
  78.     }  
  79.   
  80.     public void setMeta(SessionMetaData meta) {  
  81.         this.meta = meta;  
  82.     }  
  83.       
  84.       
  85. }  

[java]  view plain copy
  1. package com.tianque.session;  
  2.   
  3. import java.io.IOException;  
  4. import java.util.Date;  
  5.   
  6. import javax.servlet.Filter;  
  7. import javax.servlet.FilterChain;  
  8. import javax.servlet.FilterConfig;  
  9. import javax.servlet.ServletException;  
  10. import javax.servlet.ServletRequest;  
  11. import javax.servlet.ServletResponse;  
  12. import javax.servlet.http.HttpServletRequest;  
  13. import javax.servlet.http.HttpServletResponse;  
  14.   
  15. /** 
  16.  * @author hxpwangyi@163.com 
  17.  * @date 2013-3-1 
  18.  */  
  19. public abstract class AbstractSessionFilter implements Filter{  
  20.   
  21.     @Override  
  22.     public void init(FilterConfig filterConfig) throws ServletException {  
  23.   
  24.           
  25.     }  
  26.   
  27.     @Override  
  28.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {  
  29.         doFilterInternal((HttpServletRequest)request,(HttpServletResponse)response);  
  30.         chain.doFilter(request, response);  
  31.           
  32.     }  
  33.   
  34.     protected abstract void doFilterInternal(HttpServletRequest request,HttpServletResponse response);  
  35.       
  36.     @Override  
  37.     public void destroy() {  
  38.           
  39.     }  
  40.   
  41. }  

[java]  view plain copy
  1. package com.tianque.session;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.Map;  
  5.   
  6. import javax.servlet.http.Cookie;  
  7. import javax.servlet.http.HttpServletRequest;  
  8. import javax.servlet.http.HttpSession;  
  9.   
  10. /** 
  11.  * @author hxpwangyi@163.com 
  12.  * @date 2013-3-1 
  13.  */  
  14. public abstract class AbstractSessionManager {  
  15.       
  16.     private Map sessions=new HashMap();  
  17.       
  18.     public AbstractSessionManager(){}  
  19.       
  20.     public HttpSession getSession(String sid){  
  21.         return (HttpSession)sessions.get(sid);  
  22.     }  
  23.       
  24.     public void addSession(HttpSession session,String sid){  
  25.         this.sessions.put(sid, session);  
  26.     }  
  27.       
  28.     public abstract void loadSession();  
  29.       
  30.     public Map getAllSession(){  
  31.         return sessions;  
  32.     }  
  33.       
  34.       
  35.     public String getSessionIdByCookie(HttpServletRequest request){  
  36.         Cookie[] cookies = request.getCookies();  
  37.         if (cookies == null) {  
  38.             return null;  
  39.         }  
  40.         for (int i = 0; i < cookies.length; i++) {  
  41.             Cookie cookie = cookies[i];  
  42.             if ("sid".equals(cookie.getName())) {  
  43.                 String sid = cookie.getValue();  
  44.                 return sid;  
  45.             }  
  46.         }  
  47.         return null;  
  48.     }  
  49. }  

[java]  view plain copy
  1. package com.tianque.session;  
  2.   
  3. import javax.servlet.ServletContextEvent;  
  4. import javax.servlet.ServletContextListener;  
  5.   
  6. /** 
  7.  * @author hxpwangyi@163.com 
  8.  * @date 2013-3-1 
  9.  */  
  10. public abstract class SessionChangeListener implements ServletContextListener {  
  11.     private static long timeout;  
  12.       
  13.     public static long getTimeout(){  
  14.         return timeout;  
  15.     }  
  16.       
  17.     public void contextInitialized(ServletContextEvent sce) {  
  18.         String timeoutStr=sce.getServletContext().getInitParameter("sessionTimeout");  
  19.         if(timeoutStr!=null&&!timeoutStr.equals("")){  
  20.             timeout=Long.parseLong(timeoutStr);  
  21.         }else{  
  22.             timeout=3600000;  
  23.         }  
  24.         subscribeSession();  
  25.     }  
  26.   
  27.     public void contextDestroyed(ServletContextEvent sce) {  
  28.         release();  
  29.     }  
  30.       
  31.     protected abstract void subscribeSession();  
  32.       
  33.     protected abstract void release();  
  34. }  

[java]  view plain copy
  1. package com.tianque.session;  
  2.   
  3. import java.io.Serializable;  
  4.   
  5. import javax.servlet.ServletContext;  
  6.   
  7. /** 
  8.  * @author hxpwangyi@163.com 
  9.  * @date 2013-3-1 
  10.  */  
  11. public class SessionMetaData implements Serializable{  
  12.     private long createTime;  
  13.     private String sid;  
  14.     private long lastAccessedTime;  
  15.     private int maxInactiveInterval;  
  16.     private boolean isnew;  
  17.   
  18.     public long getCreateTime() {  
  19.         return createTime;  
  20.     }  
  21.   
  22.     public void setCreateTime(long createTime) {  
  23.         this.createTime = createTime;  
  24.     }  
  25.   
  26.     public String getSid() {  
  27.         return sid;  
  28.     }  
  29.   
  30.     public void setSid(String sid) {  
  31.         this.sid = sid;  
  32.     }  
  33.   
  34.     public long getLastAccessedTime() {  
  35.         return lastAccessedTime;  
  36.     }  
  37.   
  38.     public void setLastAccessedTime(long lastAccessedTime) {  
  39.         this.lastAccessedTime = lastAccessedTime;  
  40.     }  
  41.   
  42.     public int getMaxInactiveInterval() {  
  43.         return maxInactiveInterval;  
  44.     }  
  45.   
  46.     public void setMaxInactiveInterval(int maxInactiveInterval) {  
  47.         this.maxInactiveInterval = maxInactiveInterval;  
  48.     }  
  49.   
  50.     public boolean isIsnew() {  
  51.         return isnew;  
  52.     }  
  53.   
  54.     public void setIsnew(boolean isnew) {  
  55.         this.isnew = isnew;  
  56.     }  
  57.   
  58. }  

[java]  view plain copy
  1. package com.tianque.session;  
  2.   
  3. import java.util.UUID;  
  4.   
  5. /** 
  6.  * @author hxpwangyi@163.com 
  7.  * @date 2013-3-1 
  8.  */  
  9. public class SidGenerator {  
  10.     public static String generateSid(){  
  11.         return UUID.randomUUID().toString();  
  12.     }  
  13. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import org.I0Itec.zkclient.ZkClient;  
  4.   
  5. /** 
  6.  * @author hxpwangyi@163.com 
  7.  * @date 2013-3-1 
  8.  */  
  9. public class ZkConnectionSingleton {  
  10.     private static String zkServer = "127.0.0.1:2181";  
  11.     private static ZkClient zkClient=new ZkClient(zkServer);  
  12.       
  13.     public static ZkClient getInstance(){  
  14.         return zkClient;  
  15.     }  
  16. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import java.util.Enumeration;  
  4. import java.util.HashMap;  
  5. import java.util.Map;  
  6.   
  7. import javax.servlet.http.HttpServletRequest;  
  8.   
  9. import com.tianque.session.AbstractSession;  
  10. import com.tianque.session.AbstractSessionManager;  
  11.   
  12. /** 
  13.  * @author hxpwangyi@163.com 
  14.  * @date 2013-3-1 
  15.  */  
  16. public class ZkSession extends AbstractSession {  
  17.     private Map attributes=new HashMap();  
  18.       
  19.     public Object getAttribute(String name) {  
  20.         return this.attributes.get(name);  
  21.     }  
  22.   
  23.     public Object getValue(String name) {  
  24.         return null;  
  25.     }  
  26.   
  27.     public Enumeration getAttributeNames() {  
  28.         return null;  
  29.     }  
  30.   
  31.     public String[] getValueNames() {  
  32.         return null;  
  33.     }  
  34.   
  35.     public void setAttribute(String name, Object value) {  
  36.         this.attributes.put(name, value);  
  37.         ZkSessionHelper.setAttribute(this.getId(), name, value);  
  38.     }  
  39.   
  40.     public void putValue(String name, Object value) {  
  41.   
  42.     }  
  43.   
  44.     public void removeAttribute(String name) {  
  45.         this.attributes.remove(name);  
  46.         ZkSessionHelper.removeAttribute(this.getId(), name);  
  47.     }  
  48.   
  49.     public void removeValue(String name) {  
  50.   
  51.     }  
  52.   
  53.     public void localSetAttribute(String name, Object value){  
  54.         this.attributes.put(name, value);  
  55.     }  
  56.   
  57.       
  58.   
  59. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import org.I0Itec.zkclient.IZkDataListener;  
  4.   
  5. /** 
  6.  * @author hxpwangyi@163.com 
  7.  * @date 2013-3-2 
  8.  */  
  9. public class ZkSessionAttributeDataListener implements IZkDataListener {  
  10.   
  11.     @Override  
  12.     public void handleDataChange(String arg0, Object arg1) throws Exception {  
  13.         String name=arg0.substring(arg0.lastIndexOf("/")+1);  
  14.         Object value=arg1;  
  15.         String prefix=arg0.substring(0,arg0.lastIndexOf("/"));  
  16.         String sid=prefix.substring(prefix.lastIndexOf("/")+1);  
  17.         ((ZkSession)ZkSessionManager.getInstance().getSession(sid)).localSetAttribute(name, value);  
  18.           
  19.     }  
  20.   
  21.     @Override  
  22.     public void handleDataDeleted(String arg0) throws Exception {  
  23.   
  24.     }  
  25.   
  26. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import java.util.HashMap;  
  4. import java.util.HashSet;  
  5. import java.util.Iterator;  
  6. import java.util.List;  
  7. import java.util.Map;  
  8. import java.util.Set;  
  9.   
  10. import org.I0Itec.zkclient.IZkChildListener;  
  11. import org.I0Itec.zkclient.IZkDataListener;  
  12. import org.I0Itec.zkclient.ZkClient;  
  13.   
  14. import com.tianque.session.SessionChangeListener;  
  15. import com.tianque.session.SessionMetaData;  
  16.   
  17. /** 
  18.  * @author hxpwangyi@163.com 
  19.  * @date 2013-3-1 
  20.  */  
  21. public class ZkSessionChangeListener extends SessionChangeListener {  
  22.     private static final Map<String, Set<IZkDataListener>> sissionDataListeners=new HashMap<String, Set<IZkDataListener>>();  
  23.     private static final Map<String,Map<String, Set<IZkDataListener>>> attributeDataListeners= new HashMap<String,Map<String, Set<IZkDataListener>>>();  
  24.       
  25.     private void subscribeSessionAttributeChange(List<String> zkSessions){  
  26.         final ZkClient zkClient=ZkConnectionSingleton.getInstance();  
  27.         for(int i=0,len=zkSessions.size();i<len;i++){  
  28.             String sid=(String)zkSessions.get(i);  
  29.             List<String> zkSessionAttributes=zkClient.getChildren(ZkSessionHelper.root+"/"+sid);  
  30.             Map<String, Set<IZkDataListener>> attributesDataListener=attributeDataListeners.get(sid);  
  31.               
  32.             for(int j=0,size=zkSessionAttributes.size();j<size;j++){  
  33.                 String name=zkSessionAttributes.get(j);  
  34.                 IZkDataListener newDataListener=new ZkSessionAttributeDataListener();  
  35.                 if(attributesDataListener==null){  
  36.                     attributesDataListener=new HashMap<String, Set<IZkDataListener>>();  
  37.                     Set<IZkDataListener> attributeDataListener=new HashSet<IZkDataListener>();  
  38.                     attributeDataListener.add(newDataListener);  
  39.                     attributesDataListener.put(name, attributeDataListener);  
  40.                     attributeDataListeners.put(sid, attributesDataListener);  
  41.                 }else{  
  42.                     Set<IZkDataListener> attributeDataListener=attributesDataListener.get(name);  
  43.                     if(attributeDataListener!=null){  
  44.                          Iterator<IZkDataListener> it=attributeDataListener.iterator();  
  45.                          while(it.hasNext()){  
  46.                              zkClient.unsubscribeDataChanges(ZkSessionHelper.root+"/"+sid+"/"+name, it.next());  
  47.                          }  
  48.                     }else{  
  49.                         attributeDataListener=new HashSet<IZkDataListener>();  
  50.                         attributeDataListener.add(newDataListener);  
  51.                     }  
  52.                 }  
  53.                 zkClient.subscribeDataChanges(ZkSessionHelper.root+"/"+sid+"/"+name,newDataListener );  
  54.             }  
  55.               
  56.         }  
  57.     }  
  58.       
  59.     private void subscribeSessionDataChange(List<String> zkSessions){  
  60.         final ZkClient zkClient=ZkConnectionSingleton.getInstance();  
  61.         for(int i=0,len=zkSessions.size();i<len;i++){  
  62.             String sid=(String)zkSessions.get(i);  
  63.             Set<IZkDataListener> listenerSet=sissionDataListeners.get(sid);  
  64.             if(listenerSet!=null){  
  65.                 Iterator<IZkDataListener> it=listenerSet.iterator();  
  66.                 while(it.hasNext()){  
  67.                     zkClient.unsubscribeDataChanges(ZkSessionHelper.root+"/"+sid, it.next());  
  68.                 }  
  69.             }  
  70.             IZkDataListener newDataListener=new ZkSessionDataListener();  
  71.             if(listenerSet==null){  
  72.                 listenerSet=new HashSet<IZkDataListener>();  
  73.                 listenerSet.add(newDataListener);  
  74.                 sissionDataListeners.put(sid, listenerSet);  
  75.             }else{  
  76.                 listenerSet.add(newDataListener);  
  77.             }  
  78.             zkClient.subscribeDataChanges(ZkSessionHelper.root+"/"+sid,newDataListener );  
  79.         }  
  80.         subscribeSessionAttributeChange(zkSessions);  
  81.     }  
  82.     protected void subscribeSession() {  
  83.         final ZkClient zkClient=ZkConnectionSingleton.getInstance();  
  84.         if(!zkClient.exists(ZkSessionHelper.root)){  
  85.             zkClient.createPersistent(ZkSessionHelper.root);  
  86.         }  
  87.         ZkSessionManager.getInstance().loadSession();  
  88.         new ZkSessionCleaner().start();  
  89.         List<String> zkSessions=zkClient.getChildren(ZkSessionHelper.root);  
  90.         subscribeSessionDataChange(zkSessions);  
  91.         zkClient.subscribeChildChanges(ZkSessionHelper.root, new IZkChildListener() {  
  92.             @Override  
  93.             public void handleChildChange(String parentPath, List currentChilds) throws Exception {  
  94.                   subscribeSessionDataChange(currentChilds);  
  95.                   //subscribeSessionAttributeChange(currentChilds);  
  96.                    Map sessions=ZkSessionManager.getInstance().getAllSession();  
  97.                    for(Object sid: sessions.keySet()){  
  98.                        boolean has=false;  
  99.                        for(int j=0, len=currentChilds.size();j<len;j++){  
  100.                            if(((String)sid).equals(currentChilds.get(j))){  
  101.                                has=true;  
  102.                                break;  
  103.                            }  
  104.                        }  
  105.                        if(!has){  
  106.                            sessions.remove(sid);  
  107.                        }  
  108.                    }  
  109.                    for(int j=0, len=currentChilds.size();j<len;j++){  
  110.                        boolean has=false;  
  111.                        String zkSid=(String)currentChilds.get(j);  
  112.                        for(Object sid: sessions.keySet()){  
  113.                            if(((String)sid).equals(zkSid)){  
  114.                                has=true;  
  115.                                break;  
  116.                            }  
  117.                        }  
  118.                        if(!has){  
  119.                            SessionMetaData meta=zkClient.readData(ZkSessionHelper.root+"/"+zkSid);  
  120.                            ZkSession session=new ZkSession();  
  121.                            session.setMeta(meta);  
  122.                            ZkSessionManager.getInstance().addSession(session, session.getId());  
  123.                            List<String> keys=zkClient.getChildren(ZkSessionHelper.root+"/"+zkSid);  
  124.                            for(int i=0,size=keys.size();i<size;i++){  
  125.                                Object val=zkClient.readData(keys.get(i));  
  126.                                session.localSetAttribute(keys.get(i), val);  
  127.                            }  
  128.                        }  
  129.                    }  
  130.             }  
  131.         });  
  132.     }  
  133.       
  134.       
  135.   
  136.     protected void release() {  
  137.           
  138.   
  139.     }  
  140.   
  141. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import java.util.Date;  
  4. import java.util.List;  
  5.   
  6. import org.I0Itec.zkclient.ZkClient;  
  7.   
  8. import com.tianque.session.SessionMetaData;  
  9.   
  10. /** 
  11.  * @author hxpwangyi@163.com 
  12.  * @date 2013-3-2 
  13.  */  
  14. public class ZkSessionCleaner extends Thread {  
  15.   
  16.     @Override  
  17.     public void run() {  
  18.         ZkClient client=ZkConnectionSingleton.getInstance();  
  19.         while(true){  
  20.             List<String> sessionList=client.getChildren(ZkSessionHelper.root);  
  21.             for(int i=0,len=sessionList.size();i<len;i++){  
  22.                 String sid=sessionList.get(i);  
  23.                 SessionMetaData meta=client.readData(ZkSessionHelper.root+"/"+sid);  
  24.                 ZkSession session=new ZkSession();  
  25.                 if((new Date().getTime()- meta.getLastAccessedTime())>meta.getMaxInactiveInterval()){  
  26.       
  27.                     client.deleteRecursive(ZkSessionHelper.root+"/"+sid);  
  28.                 }  
  29.             }  
  30.             try {  
  31.                 Thread.sleep(30000);  
  32.             } catch (InterruptedException e) {  
  33.             }  
  34.         }  
  35.     }  
  36.   
  37. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import org.I0Itec.zkclient.IZkDataListener;  
  4. import org.I0Itec.zkclient.ZkClient;  
  5.   
  6. import com.tianque.session.SessionMetaData;  
  7.   
  8. /** 
  9.  * @author hxpwangyi@163.com 
  10.  * @date 2013-3-2 
  11.  */  
  12. public class ZkSessionDataListener implements IZkDataListener {  
  13.   
  14.     @Override  
  15.     public void handleDataChange(String arg0, Object arg1) throws Exception {  
  16.         ZkClient client=ZkConnectionSingleton.getInstance();  
  17.         String sid=arg0.substring(arg0.lastIndexOf("/")+1);  
  18.         ZkSession session=(ZkSession)ZkSessionManager.getInstance().getSession(sid);  
  19.         SessionMetaData meta=client.readData(arg0);  
  20.         session.setMeta(meta);  
  21.   
  22.     }  
  23.   
  24.     @Override  
  25.     public void handleDataDeleted(String arg0) throws Exception {  
  26.           
  27.   
  28.     }  
  29.   
  30. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import javax.servlet.http.Cookie;  
  6. import javax.servlet.http.HttpServletRequest;  
  7. import javax.servlet.http.HttpServletResponse;  
  8. import javax.servlet.http.HttpSession;  
  9.   
  10. import org.I0Itec.zkclient.ZkClient;  
  11.   
  12. import com.tianque.session.AbstractSession;  
  13. import com.tianque.session.AbstractSessionFilter;  
  14. import com.tianque.session.AbstractSessionManager;  
  15. import com.tianque.session.SessionChangeListener;  
  16. import com.tianque.session.SidGenerator;  
  17.   
  18. /** 
  19.  * @author hxpwangyi@163.com 
  20.  * @date 2013-3-1 
  21.  */  
  22. public class ZkSessionFilter extends AbstractSessionFilter {  
  23.   
  24.       
  25.     private void newSession(HttpServletRequest request, HttpServletResponse response) {  
  26.         HttpSession session=new ZkSession();  
  27.         String sid=SidGenerator.generateSid();  
  28.         ((AbstractSession)session).setId(sid);  
  29.         ZkSessionManager.getInstance().addSession(session, sid);  
  30.         ZkSessionHelper.addSession(((AbstractSession)session).getMeta());  
  31.         Cookie cookie=new Cookie("sid",sid);  
  32.         cookie.setMaxAge((int)SessionChangeListener.getTimeout());  
  33.         response.addCookie(cookie);  
  34.         request.setAttribute("sid", sid);  
  35.           
  36.   
  37.     }  
  38.   
  39.     @Override  
  40.     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response) {  
  41.         AbstractSessionManager sessionManager=ZkSessionManager.getInstance();  
  42.         String sid=sessionManager.getSessionIdByCookie((HttpServletRequest)request);  
  43.         if(sid==null || sid.equals("")){  
  44.             newSession((HttpServletRequest)request,(HttpServletResponse)response);  
  45.         }else{  
  46.             AbstractSession session=(AbstractSession)sessionManager.getSession(sid);  
  47.             if(session!=null){  
  48.                 session.setLastAccessedTime(new Date().getTime());  
  49.                 ZkClient client=ZkConnectionSingleton.getInstance();  
  50.                 client.writeData(ZkSessionHelper.root+"/"+sid, session.getMeta());  
  51.             }else{  
  52.                 newSession((HttpServletRequest)request,(HttpServletResponse)response);  
  53.             }  
  54.         }  
  55.           
  56.     }  
  57.   
  58. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import org.I0Itec.zkclient.ZkClient;  
  4.   
  5. import com.tianque.session.SessionMetaData;  
  6.   
  7. /** 
  8.  * @author hxpwangyi@163.com 
  9.  * @date 2013-3-1 
  10.  */  
  11. public class ZkSessionHelper {  
  12.     public static final String root="/tianque-session-root-test";  
  13.       
  14.     public static void setAttribute(String sid,String name,Object value){  
  15.         ZkClient client=ZkConnectionSingleton.getInstance();  
  16.         if(!client.exists(root+"/"+sid+"/"+name)){  
  17.             client.createPersistent(root+"/"+sid+"/"+name);  
  18.         }  
  19.         client.writeData(root+"/"+sid+"/"+name, value);  
  20.     }  
  21.       
  22.     public static void removeAttribute(String sid,String name){  
  23.         ZkClient client=ZkConnectionSingleton.getInstance();  
  24.         if(client.exists(root+"/"+sid+"/"+name)){  
  25.             client.delete(root+"/"+sid+"/"+name);  
  26.         }  
  27.     }  
  28.       
  29.     public static void addSession(SessionMetaData meta){  
  30.         ZkClient client=ZkConnectionSingleton.getInstance();  
  31.         client.createPersistent(root+"/"+meta.getSid());  
  32.         client.writeData(root+"/"+meta.getSid(), meta);  
  33.     }  
  34.       
  35. }  

[java]  view plain copy
  1. package com.tianque.session.zookeeper;  
  2.   
  3. import java.util.List;  
  4.   
  5. import org.I0Itec.zkclient.ZkClient;  
  6.   
  7. import com.tianque.session.AbstractSessionManager;  
  8. import com.tianque.session.SessionMetaData;  
  9.   
  10. /** 
  11.  * @author hxpwangyi@163.com 
  12.  * @date 2013-3-2 
  13.  */  
  14. public class ZkSessionManager extends AbstractSessionManager {  
  15.     private static AbstractSessionManager instance=new ZkSessionManager();  
  16.       
  17.     @Override  
  18.     public void loadSession() {  
  19.         ZkClient client=ZkConnectionSingleton.getInstance();  
  20.         List<String> sessionList=client.getChildren(ZkSessionHelper.root);  
  21.         for(int i=0,len=sessionList.size();i<len;i++){  
  22.             String sid=sessionList.get(i);  
  23.             SessionMetaData meta=client.readData(ZkSessionHelper.root+"/"+sid);  
  24.             ZkSession session=new ZkSession();  
  25.             session.setId(sid);  
  26.             session.setMeta(meta);  
  27.             List<String> attributeList=client.getChildren(ZkSessionHelper.root+"/"+sid);  
  28.             for(int j=0,size=attributeList.size();j<size;j++){  
  29.                 String name=attributeList.get(j);  
  30.                 Object value=client.readData(ZkSessionHelper.root+"/"+sid+"/"+name);  
  31.                 session.localSetAttribute(name, value);  
  32.             }  
  33.             AbstractSessionManager sessionManager=ZkSessionManager.getInstance();  
  34.             sessionManager.addSession(session, sid);  
  35.         }  
  36.   
  37.     }  
  38.       
  39.     public static AbstractSessionManager getInstance(){  
  40.         return instance;  
  41.     }  
  42.   
  43. }  
AI之心2023
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于ZooKeeper的分布式Session实现
03-02
ZooKeeper——“动物园管理员”。动物园里当然有好多的动物，游客可以根据动物园提供的向导图到不同的场馆观赏各种类型的动物，而不是像走在原始丛林里，心惊胆颤的被动物所观赏。为了让各种不同的动物呆在它们应该...
zookeeper分布式锁实现
weixin_43326384的博客
11-23 82
package com.my.api; import com.my.RunImp; import org.I0Itec.zkclient.IZkDataListener; import org.I0Itec.zkclient.ZkClient; import redis.clients.jedis.Jedis; import java.util.UUID; import java.util.co...
利用zookeeper实现分布式锁
孤竹彧的根据地
02-23 143
实现分布式锁的几种方式： 基于数据库实现分布式锁； 基于缓存（Redis等）实现分布式锁； 基于Zookeeper实现分布式锁 今天要写的是使用Zookeeper的方式 使用Zookeeper实现分布式锁的思想是：我在加锁的时候，插入一个节点，当把锁释放的时候，就把节点删除。为了提高效率，使用的是临时顺序节点，每次只监听比自己临近小的节点是否删除 准备：安装zookeepr，pom加依赖 ...
java zookeeper监控_用Java代码实现监控zookeeper节点信息的变化以及遍历节点
weixin_29660181的博客
02-16 508
代码比较简单,附上待深剖import org.I0Itec.zkclient.IZkDataListener;import org.I0Itec.zkclient.ZkClient;import org.I0Itec.zkclient.serialize.SerializableSerializer;import org.apache.commons.lang3.StringUtils;impor...
zookeeper 实现分布式锁
小猴子的博客
04-24 157
https://github.com/hd19940104/java/tree/master/project/micro/spring-cloud/spring-cloud-zookeeper 1、首先搭载zookeeper集群 -------------------------------------- 直接在这压缩包解压， 修改环境变量 vi /etc/profile 需要安装j...
ZooKeeper基本原理分析
踩踩踩从踩的博客
05-02 1397
前言 ZooKeeper是一个分布式的，开放源码的分布式应用程序协调服务，是Google的Chubby一个开源的实现，是Hadoop和Hbase的重要组件。它是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。 我们在项目实际的应用中，也会考虑 zk这个中间件，他提供了提供了分布式独享锁、选举、队列的接口的代码版本。 随着版本的迭代 ，对于zk来说 ...
zookeeper实现分布式session sample
11-03
zookeeper实现分布式session sample
zookeeper系列（二）实战master选举
weixin_34176694的博客
11-27 180
zookeeper系列（一）zookeeper必知zookeeper系列（二）实战master选举zookeeper系列（三）实战数据发布订阅zookeeper系列（四）实战负载均衡zookeeper系列（五）实战分布式锁zookeeper系列（六）实战分布式队列zookeeper系列（七）实战分布式命名服务zookeeper系列（八）z...
Zookeeper 典型应用场景介绍
Java知音
08-01 315
点击关注公众号，实用技术文章及时了解来源：blog.csdn.net/u013468915/article/details/809551101.前言之前自己写了一些关于Zookeeper的...
Zookeeper相关知识点梳理
chenzihao36的博客
08-10 296
目录一、Zookeeper入门1.ZK的数据模型2.ZK的watch机制3.ZK的特性二、Zookeeper应用场景1.ZK实现配置中心2.ZK实现命令服务3.ZK实现Master选举4.ZK实现分布式队列5.ZK实现分布式锁三、Zookeeper集群1.ZK集群基本概念2.ZK集群ZAB协议3.ZK集群Leader选举四、分布式一致性协议 一、Zookeeper入门 1.ZK的数据模型 2.ZK的watch机制 3.ZK的特性 二、Zookeeper应用场景 1.ZK实现配置中心 2.ZK实现命令服务 3
数据库实现分布式锁总结笔记
⛄沉淀分享成长--长久的沉淀势必会收获到你想要的，那些旅途上的果实
04-04 5049
✅作者简介：大家好我是poizxc2014 📖个人主页：poizxc2014的博客_CSDN博客-数据库,mysql,java领域博主 🔥💖如果觉得博主的文章还不错的话，请👍三连支持一下博主哦🤞
基于ZooKeeper的分布式锁
Addisoni
11-12 104
一、简介 　　锁的概念，在Java日常开发和面试中，都是个很重要的知识点。锁能很好的控制生产数据的安全性，比如商品的数量超卖问题等。传统的做法中，可以直接利用数据库锁（行锁或者表锁）来进行数据访问控制。随着请求量逐步变多的情况下，将压力怼到数据库上会对其性能产生极大影响。这时候，单体应用中可以利用JVM锁，在程序层面进行访问的控制，将压力前移，对数据库友好。当请求量再进一步变多，这时候一般会考虑...
zookeeper 分布式锁之比较基础的原理
1.01^365
10-24 622
为什么需要分布式锁？ 如下图所示 ，当nignx 并发量到达10w ，tomcat1,tomcat2,tomcat3 都是订单服务，在如此高的并发量下面， 如果不做分布式锁，那么后台生成的订单编号必定重复。如果不是分布式的话，那么只要加锁就行， 可是分布式的话，不是同一个jvm那么 加sync 锁也是不行的. 那么我们如何去解决呢？看下图 一、通过临时文件建立分布式锁 当这三个tomc...
ZKClient zookeeper 丢失事件 分析
刘本龙的专栏
12-17 1万+
由于ZK的watch一次性注册原因，以及client断开连接到重新连接上这一段时间差，可能导致zookeeper客户端不能够接收到完所有的ZK事件 不要强依赖于ZK的事件，要知道ZK事件可能丢失，也可能多个事件收到的数据是相同的（注意等幂性）。ZK能做到的是分布式数据一致性服务，可以保证最终一致性。在开发的时候要谨慎处理。 下面是测试以及原因分析
Zookeeper客户端ZkClient
鸡蛋达芬奇
09-06 1495
ZkClient简介 ZkClient是github上开源的一个zookeeper客户端。它对原生的zookeeper客户端API进行了封装，内部实现了session重连，Watcher反复注册，极大降低了开发人员使用zookeeper的难度。 创建会话 zkClient提供了7个构造方法来创建zookeeper会话。原生的zookeeper客户端API创建会话是异步过程，而zkClient将创建会
Zookeeper学习(八)：Zookeeper的数据发布与订阅模式
热门推荐
xiajie的专栏
03-20 1万+
1.发布订阅的基本概念      1.发布订阅模式可以看成一对多的关系：多个订阅者对象同时监听一个主题对象，这个主题对象在自身状态发生变化时，会通知所有的订阅者对象，使他们能够自动的更新自己的状态。        2.发布订阅模式，可以让发布方和订阅方，独立封装，独立改变，当一个对象的改变，需要同时改变其他的对象，而且它不知道有多少个对象需要改变时，可以使用发布订阅模式
ZooKeeper 笔记(2) 监听数据变化
zhanjianshinian的专栏
03-06 5130
原文出自：http://www.cnblogs.com/yjmyzz/p/4604864.html ZK中的每个节点都可以存储一些轻量级的数据，这些数据的变化会同步到集群中的其它机器。在应用中程序员可以添加watcher来监听这些数据的变化，watcher只会触发一次，所以触发过后想要继续监听，必须再手动设置监听，这比较麻烦，好在ZkClient已经做了一些增强，在watcher的基础上
Zookeeper实例原生API--复用sessionId和sessionPasswd
Andy's Blog
06-11 1257
import java.util.concurrent.CountDownLatch; import org.apache.zookeeper.WatchedEvent; import org.apache.zookeeper.Watcher; import org.apache.zookeeper.Watcher.Event.KeeperState; import org.apache.zoo
如何用Java代码实现zookeeper分布式锁
最新发布
09-27
### 回答1： 可以使用Apache Curator库来实现在Java中使用...以上是一个简单的使用Java代码实现Zookeeper分布式锁的例子。在lock方法中，当获取到锁后，会打印"Lock acquired"，当释放锁后，可以继续执行后续逻辑。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值