自定义单点登录（2）

惯例：

我是温浩然：

单点登录，分为客户端和服务器端，客户端，主要与用户的浏览器进行交互，操作浏览器，比如，cookie，session等。

服务器端，主要是储存用户的信息，和后台数据库进行交互，获取当前登录的用户信息，对用户的登录进行验证。

关于单点登录，我感觉，验证方式有很多种，

我这里，是对cookie进行操作，当用户登录成功后，会在浏览器新建cookie，储存一定信息，当用户访问受保护的请求时，获取cookie并进行验证，如果验证通过，则该用户已经登录，可以访问受保护的信息。

下面贴在Filter中，进行验证的代码。

1、服务器中，对用户进行验证的代码。

[java] view plain copy

1. package com.tujia.core.security;  
2.   
3. import java.util.Date;  
4. import java.util.HashMap;  
5. import java.util.Map;  
6. import java.util.UUID;  
7.   
8. import javax.annotation.Resource;  
9. import javax.servlet.http.Cookie;  
10. import javax.servlet.http.HttpServletRequest;  
11. import javax.servlet.http.HttpServletResponse;  
12.   
13. import org.springframework.beans.factory.annotation.Autowired;  
14. import org.springframework.beans.factory.annotation.Value;  
15. import org.springframework.stereotype.Component;  
16. import org.springframework.web.util.WebUtils;  
17.   
18. import com.tujia.common.exception.UnAuthedException;  
19. import com.tujia.tuuser.dao.UserDao;  
20. import com.tujia.tuuser.entity.User;  
21. import com.tujia.tuuser.service.UserService;  
22.   
23. @Component  
24. public class SecurityUtil {  
25.   
26.     @Resource  
27.     private UserDao userDao;  
28.       
29.     private String TOURL = "TOURL";  
30.   
31.     private static ThreadLocal<User> threadTuser = new ThreadLocal<User>();  
32.   
33.     private Map<String,AuthTuUser> map = new HashMap<String,AuthTuUser>();  
34.       
35.     private Map<String,User> mapUser = new HashMap<String,User>();  
36.       
37.         //下面这个是对数据进行操作，与数据库进行交互的Java类  
38.     @Autowired  
39.     private UserService userService;  
40.   
41.         /*@Autowired 
42.     TokenAuthentication tokenAuthentication;*/  
43.     //tujia.requrl  下面这些都是配置文件  
44.     @Value("${tujia.requrl}")  
45.     private String requrl;  
46.     @Value("${tujia.token}")  
47.     private String tokenKey;  
48.     @Value("${loginURL:\"\"}")  
49.     private String loginURL;  
50.   
51.     private int MS_IN_A_DAY = 24 * 3600 * 1000;  
52.     private int SECS_IN_A_MONTH = 24 * 3600 * 30;  
53.   
54.     /** 
55.      * 得到当前登录的用户，用户再业务逻辑的地方 
56.      *  
57.      * @return 
58.      */  
59.     public static User getCurrentTuser() {  
60.         return threadTuser.get();  
61.     }  
62.   
63.     /** 
64.      * 用在filter的地方， 
65.      *  
66.      * @param request 
67.      * @throws UnAuthedException  
68.      * @return：true：已经登录了。false:没有登录 
69.      */  
70.     public boolean authenticate(HttpServletRequest request,  
71.             HttpServletResponse response) throws UnAuthedException {  
72.         boolean result;  
73.         // 处理cookie情况  
74.         Cookie cookie = WebUtils.getCookie(request, tokenKey);  
75.         String url = request.getRequestURI();  
76.           
77.         //if登录cookie is null ,则添加cookie url.  
78.         if (cookie == null){  
79.             //这是被拦截后添加的cookie  
80.             Cookie cookieurl = new Cookie(requrl, url);  
81.             cookieurl.setPath("/");  
82.             cookieurl.setMaxAge(-1);  
83.             response.addCookie(cookieurl);  
84.             return false;  
85.             }  
86.           
87.         String value = cookie.getValue();  
88.         AuthTuUser au = (AuthTuUser) map.get(value);  
89.         if (au == null ){  
90.             Cookie cookieurl = new Cookie(requrl, url);  
91.             cookieurl.setPath("/");  
92.             cookieurl.setMaxAge(-1);  
93.             response.addCookie(cookieurl);  
94.             return false;  
95.             }  
96.         request.getSession().setAttribute("userLogin", mapUser.get(value));  
97.         result = verifyTuserId(au.getId());   
98.         if (!result) {  
99.             logout(request, response);  
100.         }  
101.           
102.         return result;  
103.     }  
104.   
105.   
106.     public User getLoinTuser(HttpServletRequest request) throws UnAuthedException {  
107.         // 处理cookie情况  
108.         Cookie cookie = WebUtils.getCookie(request, tokenKey);  
109.         if (cookie == null)  
110.             return null;  
111.         String value = cookie.getValue();  
112.         AuthTuUser au = (AuthTuUser) map.get(value);  
113.         if (au == null)// || au.isExpire()  
114.             return null;  
115.   
116.          User user = userService.get(au.getId());  
117.         return user;  
118.     }  
119.   
120.     private String generateValue() {  
121.         return UUID.randomUUID().toString();  
122.     }  
123.   
124.     public void inputSuccess(HttpServletRequest request,HttpServletResponse response, long userId,  
125.             boolean saved) throws UnAuthedException {  
126.         if (verifyTuserId(userId)) {  
127.             addCookieAndCache(request,response, userId, saved);  
128.         }else{  
129.             throw new UnAuthedException("该用户不存在，请重新输入！");  
130.         }  
131.     }  
132.   
133.     private void addCookieAndCache(HttpServletRequest request,HttpServletResponse response, long userId,  
134.             boolean saved) {  
135.           
136.         AuthTuUser au = new AuthTuUser(userId);  
137.           
138.         User user = userDao.get(userId);  
139.           
140.         String tokenValue = generateValue();  
141.         Cookie cookie = new Cookie(tokenKey, tokenValue);  
142.         cookie.setPath("/");  
143.         if (saved) {  
144.             cookie.setMaxAge(SECS_IN_A_MONTH);  
145.             au.setSaved(true);  
146.         } else {  
147.             cookie.setMaxAge(-1);  
148.             au.setExpireDate(new Date(System.currentTimeMillis() + MS_IN_A_DAY));  
149.         }  
150.         request.setAttribute("token", tokenValue);  
151.         response.addCookie(cookie);  
152.           
153.         map.put(tokenValue, au);  
154.         mapUser.put(tokenValue, user);  
155.         request.getSession().setAttribute("userLogin", user);  
156.     }  
157.   
158.     public boolean verifyTuserId(long userId) throws UnAuthedException {  
159.         boolean result;  
160.          User user = userService.get(userId);  
161.         if (user.isDeleted()) {// 员工被停用了  
162.             result = false;  
163.         } else {  
164.             threadTuser.set(user);  
165.             result = true;  
166.         }  
167.         return result;  
168.     }  
169.   
170.     /** 
171.      *  
172.      * @param req 
173.      * @return 
174.      */  
175.     public void logout(HttpServletRequest request, HttpServletResponse response) {  
176.   
177.         Cookie cookie = WebUtils.getCookie(request, tokenKey);  
178.         if (cookie == null)  
179.             return;  
180.   
181.         String value = cookie.getValue();  
182.         AuthTuUser au = (AuthTuUser) map.get(value);  
183.         if (au == null) {  
184.             delteCookie(response, tokenKey);  
185.             delteCookie(response, requrl);  
186.             return;  
187.         }  
188.   
189.         delteCookie(response, tokenKey);  
190.         map.remove(value);  
191.         return;  
192.   
193.     }  
194.   
195.     private void delteCookie(HttpServletResponse response, String cookieName) {  
196.         Cookie cookie = new Cookie(cookieName, "");  
197.         cookie.setPath("/");  
198.         cookie.setMaxAge(0);  
199.         response.addCookie(cookie);  
200.     }  
201.   
202.     // 线程结束的时候调用。  
203.     public static void clearOnThreadOver() {  
204.         threadTuser.remove();  
205.     }  
206.   
207.     public void setTOURL(HttpServletResponse response,  
208.             HttpServletRequest request) {  
209.         StringBuffer u = request.getRequestURL();  
210.         if (request.getQueryString() != null) {  
211.             u.append('?');  
212.             u.append(request.getQueryString());  
213.         }  
214.         Cookie cookie = new Cookie(TOURL, u.toString());  
215.         cookie.setPath("/");  
216.         cookie.setMaxAge(-1);  
217.         response.addCookie(cookie);  
218.     }  
219.   
220.     public String getTOURL(HttpServletRequest request,  
221.             HttpServletResponse response) {  
222.         Cookie cookie = WebUtils.getCookie(request, TOURL);  
223.         if (cookie == null)  
224.             return "";  
225.         delteCookie(response, TOURL);  
226.         return cookie.getValue();  
227.     }  
228.   
229.     public String getLoginURL() {  
230.         return loginURL;  
231.     }  
232.   
233.     public String getReqURL(HttpServletRequest request,HttpServletResponse response){  
234.           
235.         Cookie cookie = WebUtils.getCookie(request, requrl);  
236.           
237.         String value = cookie.getValue();     
238.         return value;  
239.     }  
240.   
241.     public void setLoginURL(String loginURL) {  
242.         this.loginURL = loginURL;  
243.     }  
244.       
245.     public void requrl(HttpServletRequest request,HttpServletResponse response) {  
246.         Cookie cookie = WebUtils.getCookie(request, requrl);  
247.         if(cookie == null){  
248.             Cookie cookieurl = new Cookie(requrl, "/tu-login/user/index");  
249.             cookieurl.setPath("/");  
250.             cookieurl.setMaxAge(-1);  
251.             response.addCookie(cookieurl);  
252.         }  
253.     }  
254.       
255.     public boolean getAuthTuUser(String token){  
256.           
257.         AuthTuUser au = (AuthTuUser) map.get(token);  
258.           
259.         if (au == null ){  
260.             return false;  
261.         }else{  
262.             User user = mapUser.get(token);  
263.               
264.             return true;  
265.         }  
266.           
267.     }  
268. }  

贴的很多，但是如果看得仔细，会发现其中我增加了两个cookie，一个是token，就是保存在浏览器中的登录信息。

另一个cookie是requrl，这个是，当用户访问受保护的请求，然后登录后，能自动调整显示的页面。

[java] view plain copy

1. AuthTuUser这个是储存用户登录信息的javaBean，当用户判断是否登录时，就用map来判断。