在spring中实现分布式 session管理
本文主要是在spring中实现分布式session，采用redis对session进行持久化管理，这样当应用部署的时候，不需要在resin、tomcat等容器里面进行分布式配置，方便加入新的节点服务器进行集群扩容，session不依赖各节点的服务器，可直接从redis获取。下面是功能的核心代码：
一、首先在web.xml里面配置
加入拦截器：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
<!-- 分布式session start --> <filter> <filter-name>distributedsessionfilter</filter-name> <filter-class>distributedsessionfilter</filter-class> <init-param> <!-- 必填，密钥.2种方式,1对应为bean，格式为bean:key。2字符串,格式如:afffrfgv--> <param-name>key</param-name> <param-value>xxxxxxxx</param-value> </init-param> <init-param> <!-- 必填，redis对应的bean,格式为bean:xx--> <param-name>cachebean</param-name> <param-value>bean:redispersistent</param-value>//distributedbaseinterface，对应于此接口，进行session的持久化操作 </init-param> <init-param> <!-- 必填， --> <param-name>cookiename</param-name> <param-value>testsessionid</param-value> </init-param> </filter> <filter-mapping> <filter-name>distributedsessionfilter</filter-name> <url-pattern>*.do</url-pattern> </filter-mapping> <!-- 分布式session end --> |
二、拦截器的实现，核心代码如下
主要有以下的几个类：
- distributedsessionfilter，
- distributedsessionmanager，
- distributedhttpsessionwrapper，
- distributedhttpservletrequestwrapper
1、distributedsessionfilter实现filter：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import java.io.ioexception;import java.util.hashmap;import java.util.map;import javax.servlet.filter;import javax.servlet.filterchain;import javax.servlet.filterconfig;import javax.servlet.servletexception;import javax.servlet.servletrequest;import javax.servlet.servletresponse;import javax.servlet.http.httpservletrequest;import javax.servlet.http.httpservletresponse;import org.springframework.web.context.webapplicationcontext;import org.springframework.web.context.support.webapplicationcontextutils;public class distributedsessionfilter implements filter { private static final logger log = loggerfactory.getlogger(distributedsessionfilter.class); private string cookiename; //主要是对session进行管理的操作 private distributedsessionmanager distributedsessionmanager; private string key;} |
容器启动时候的初始化方法：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@override public void init(filterconfig config) throws servletexception { webapplicationcontext wac = webapplicationcontextutils.getrequiredwebapplicationcontext(config .getservletcontext()); string key = config.getinitparameter("key"); string cookiename = config.getinitparameter("cookiename"); string cachebean = config.getinitparameter("cachebean"); // 获取bean的名称，配置是"bean:" string redisbeanstr = cachebean.substring(5); distributedbaseinterface distributedcache = (distributedbaseinterface) wac.getbean(redisbeanstr); // 获取key，有2种配置方式,1对应为bean，格式为bean:key。2字符串 if (key.startswith("bean:")) { this.key = (string) wac.getbean(key.substring(5)); } else { this.key = key; } this.cookiename = cookiename; this.distributedsessionmanager = distributedsessionmanager.getinstance(distributedcache); //异常处理省略。。。 } |
进行实际的请求拦截：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
@overridepublic void dofilter(servletrequest servletrequest, servletresponse servletresponse, filterchain filterchain) throws servletexception, ioexception { distributedhttpservletrequestwrapper distreq = null; try { //请求处理 distreq = createdistributedrequest(servletrequest, servletresponse); filterchain.dofilter(distreq, servletresponse); } catch (throwable e) { //省略。。。 } finally { if (distreq != null) { try { //处理完成request后，处理session（主要是保存session会话） dealsessionafterrequest(distreq.getsession()); } catch (throwable e2) { //省略。。。 } } }}//分布式请求private distributedhttpservletrequestwrapper createdistributedrequest(servletrequest servletrequest, servletresponse servletresponse) throws ioexception, servletexception { httpservletrequest request = (httpservletrequest) servletrequest; httpservletresponse response = (httpservletresponse) servletresponse; string usersid = cookieutil.getcookie(cookiename, request); string actualsid = distributedsessionmanager.getactualsid(usersid, request, key); if (stringutil.isblank(actualsid)) { if (stringutil.isnotblank(usersid)) { log.info("usersid[{}]验证不通过", usersid); } // 写cookie string[] usersidarr = distributedsessionmanager.createusersid(request, key); usersid = usersidarr[0]; cookieutil.setcookie(cookiename, usersid, request, response); actualsid = usersidarr[1]; } actualsid = "sid:" + actualsid; distributedhttpsessionwrapper distsession = null; try { map<string, object> allattribute = distributedsessionmanager.getsession(actualsid, request.getsession() .getmaxinactiveinterval()); distsession = new distributedhttpsessionwrapper(actualsid, request.getsession(), allattribute); } catch (throwable e) { // 出错，删掉缓存数据 log.error(e.getmessage(), e); map<string, object> allattribute = new hashmap<string, object>(); distsession = new distributedhttpsessionwrapper(actualsid, request.getsession(), allattribute); distributedsessionmanager.removesession(distsession); } distributedhttpservletrequestwrapper requestwrapper = new distributedhttpservletrequestwrapper(request, distsession); return requestwrapper;}// request处理完时操作sessionprivate void dealsessionafterrequest(distributedhttpsessionwrapper session) { if (session == null) { return; } if (session.changed) { distributedsessionmanager.savesession(session); } else if (session.invalidated) { distributedsessionmanager.removesession(session); } else { distributedsessionmanager.expire(session); }} |
2、distributedsessionmanager，主要处理分布式session，核心代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
class distributedsessionmanager { protected static final logger log = loggerfactory.getlogger(distributedsessionmanager.class); private static distributedsessionmanager instance = null; //redis处理session的接口，自己根据情况实现 private distributedbaseinterface distributedbaseinterface; private static byte[] lock = new byte[1]; private distributedsessionmanager(distributedbaseinterface distributedbaseinterface) { this.distributedbaseinterface = distributedbaseinterface; } public static distributedsessionmanager getinstance(distributedbaseinterface redis) { if (instance == null) { synchronized (lock) { if (instance == null) { instance = new distributedsessionmanager(redis); } } } return instance; } //获取session public map<string, object> getsession(string sid,int second) { string json = this.distributedbaseinterface.get(sid,second); if (stringutil.isnotblank(json)) { return jsonutil.unserializemap(json); } return new hashmap<string, object>(1); } //保存session public void savesession(distributedhttpsessionwrapper session) { map<string, object> map=session.allattribute; if(maputil.isempty(map)){ return; } string json = jsonutil.serializemap(map); this.distributedbaseinterface.set(session.getid(), json, session.getmaxinactiveinterval()); } //删除session public void removesession(distributedhttpsessionwrapper session) { distributedbaseinterface.del(session.getid()); } public void expire(distributedhttpsessionwrapper session) { distributedbaseinterface.expire(session.getid(), session.getmaxinactiveinterval()); } /** * 创建cookie的sid */ public string[] createusersid(httpservletrequest request, string key) { //... } public string getactualsid(string usersid, httpservletrequest request, string key) { //... }} |
3、distributedhttpsessionwrapper 实现了 httpsession，进行分布式session包装，核心代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
public class distributedhttpsessionwrapper implements httpsession { private httpsession orgisession; private string sid; boolean changed = false; boolean invalidated = false; map<string, object> allattribute; public distributedhttpsessionwrapper(string sid, httpsession session, map<string, object> allattribute) { this.orgisession = session; this.sid = sid; this.allattribute = allattribute; } @override public string getid() { return this.sid; } @override public void setattribute(string name, object value) { changed = true; allattribute.put(name, value); } @override public object getattribute(string name) { return allattribute.get(name); } @override public enumeration<string> getattributenames() { set<string> set = allattribute.keyset(); iterator<string> iterator = set.iterator(); return new myenumeration<string>(iterator); } private class myenumeration<t> implements enumeration<t> { iterator<t> iterator; public myenumeration(iterator<t> iterator) { super(); this.iterator = iterator; } @override public boolean hasmoreelements() { return iterator.hasnext(); } @override public t nextelement() { return iterator.next(); } } @override public void invalidate() { this.invalidated = true; } @override public void removeattribute(string name) { changed = true; allattribute.remove(name); } @override public long getcreationtime() { return orgisession.getcreationtime(); } @override public long getlastaccessedtime() { return orgisession.getlastaccessedtime(); } @override public int getmaxinactiveinterval() { return orgisession.getmaxinactiveinterval(); } @override public servletcontext getservletcontext() { return orgisession.getservletcontext(); } @override public object getvalue(string arg0) { return orgisession.getvalue(arg0); } @override public string[] getvaluenames() { return orgisession.getvaluenames(); } @override public boolean isnew() { return orgisession.isnew(); } @override public void putvalue(string arg0, object arg1) { orgisession.putvalue(arg0, arg1); } @override public void removevalue(string arg0) { orgisession.removevalue(arg0); } @override public void setmaxinactiveinterval(int arg0) { orgisession.setmaxinactiveinterval(arg0); } @override public httpsessioncontext getsessioncontext() { return orgisession.getsessioncontext(); } |
4、distributedhttpservletrequestwrapper 实现了 httpservletrequestwrapper，包装处理过的session和原始request，核心代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
public class distributedhttpservletrequestwrapper extends javax.servlet.http.httpservletrequestwrapper { private httpservletrequest orgirequest; private distributedhttpsessionwrapper session; public distributedhttpservletrequestwrapper(httpservletrequest request, distributedhttpsessionwrapper session) { super(request); if (session == null){ //异常处理。。 } if (request == null){ //异常处理。。 } this.orgirequest = request; this.session = session; } public distributedhttpsessionwrapper getsession(boolean create) { orgirequest.getsession(create); return session; } public distributedhttpsessionwrapper getsession() { return session; }} |
5、另外，定义distributedbaseinterface接口，用来处理session入redis进行持久化操作：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
public interface distributedbaseinterface { /** * 根据key获取缓存数据 * @param key * @param seconds */ public string get(string key,int seconds); /** * 更新缓存数据 * @param key * @param json * @param seconds */ public void set(string key, string json,int seconds); /** * 删除缓存 * @param key */ public void del(string key); /** * 设置过期数据 * @param key * @param seconds */ public void expire(string key,int seconds); |
注：本文只是在spring中采用redis的方式对session进行管理，还有其他诸多的实现方式，比如在容器里面配置等，设计路由算法让session依赖于集群中的各个节点服务器，，，，，，但redis这种方式在实际应用中还是比较广泛的，lz公司主要就是采用此方式。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：https://blog.csdn.net/u014263388/article/details/56020889
