Gausst松鼠会

这个屌丝很懒，什么也没留下！

热门标签

【JavaWeb 用户认证】Cookie、Session、Token、JWT、Interceptor、SpringBoot、Spring Security_java cookie登录

作者：Gausst松鼠会 | 2024-03-02 03:26:42

踩

java cookie登录

Token基本了解：【详细阐述Token的来源】
公钥私钥基本了解：【理解公钥】

文章目录

一、Cookie 经典介绍以及使用案例
二、Session 经典介绍以及拦截登录案例
三、Token + MySQL 的基本介绍及其基本使用
四、JWT 基本介绍及其基本讲解
五、SpringBoot 使用拦截器
六、SpringBoot + Token 基础实践案例
七、Spring Security Authentication 基本介绍及其使用案例

一、Cookie 经典介绍以及使用案例

Cookie的介绍
在这里插入图片描述
Cookie的使用案例

@Controller
public class GoodsController {
    @RequestMapping("/Login")
    public String Login(@RequestParam("phone")String phone, @RequestParam("pass")String pass, HttpServletRequest request, HttpServletResponse response){
        boolean flag = false;
        Cookie[] cookies = request.getCookies();
        // 如果Cookie存在，则从Cookie中调取信息
        if(cookies != null) {
            for (Cookie cookie : cookies) {
                if (cookie.getName().equals(phone)) {
                    System.out.println("cookie的时效: " + cookie.getMaxAge());
                    System.out.println("cookie的Comment: " + cookie.getComment());
                    System.out.println("cookie的Domain: " + cookie.getDomain());
                    System.out.println("cookie的Name: " + cookie.getName());
                    System.out.println("cookie的Path: " + cookie.getPath());
                    System.out.println("cookie的Value: " + cookie.getValue());
                    System.out.println("cookie的Secure: " + cookie.getSecure());
                    System.out.println("cookie的Version: " + cookie.getVersion());
                    flag = true;
                }
            }
          // 如果没有Cookie，则新建一个Cookie
        } if(flag == false){
            LocalDateTime now = LocalDateTime.now();
            DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd_HH:mm:ss");
            String format = LocalDateTime.now().format(dateTimeFormatter);
            Cookie cookie = new Cookie(phone, pass + "创建的时间是:_" + format);
            cookie.setMaxAge(10 * 60);
            // 设置路径：cookie.setPath(“/项目名/路径”),只有访问“/项目名/路径”才会携带 Cookie
            cookie.setPath("/");
            response.addCookie(cookie);
        }
            return "Success";
    }
}
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

二、Session 经典介绍以及拦截登录案例

Session的介绍
在这里插入图片描述
Session的使用案例
这个Servlet就是我们的主页面

@WebServlet("/mainPage")
public class MainServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置响应的MIME类型和编码
        response.setContentType("text/html;charset=utf-8");
        //得到session
        HttpSession session = request.getSession();
        //取出用户名
        Object username = session.getAttribute("username");
        PrintWriter writer = response.getWriter();
        //判断用户名是否存在
        if (username != null){
            //在一天内登录过，无需再次登录
            writer.write("<h1>用户："+username+" 登录成功</h1>");
        }else {
            //没有登录，或者登录间隔大于1天。重定向到登陆界面
            response.sendRedirect(request.getContextPath()+"/login.html");
        }
    }
 
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}
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

如果没有登录过，就会跳转到login.html页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>login</title>
    <base href="/cs/">
</head>
<body>
<form action="checkLogin" method="post">
    用户名：<input type="text" name="username" /><br/>
    密　码：<input type="password" name="password" /><br/>
    <input type="submit" value="登录">
</form>
</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

执行checkLogin业务逻辑

@WebServlet("/checkLogin")
public class CheckServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //得到用户名和密码
        String username = request.getParameter("username");
        String password = request.getParameter("password");
        //判断用户名和密码是否为我们设置的密码
        if (username.equals("tom") && password.equals("tom123")){
            //得到session
            /** request.getSession()：浏览器如果没有带sessionID，该方法就会直接创建一个sessionID
		 	*	并在响应结束后返回sessionID给浏览器
			*/
            HttpSession session = request.getSession();
            //设置最长访问间隔时间
            session.setMaxInactiveInterval(60*60*24);
            //将用户名存入session
            session.setAttribute("username",username);
            //重定向到主页面
            response.sendRedirect(request.getContextPath()+"/mainPage");
        }else {
            //设置MIME类型和编码
            response.setContentType("text/html;charset=utf-8");
            //写回提示信息
            PrintWriter writer = response.getWriter();
            writer.write("<h1>账号或密码错误</h1>");
            writer.write("<h3><a href='"+request.getContextPath()+"/login.html'>点击重新登录</a></h3>");
        }
    }
 
    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        this.doGet(request, response);
    }
}
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

第一次来访问主界面@WebServlet("/mainPage")，发现服务器发现我们没有登录，直接重定向到登录界面。
在这里插入图片描述
下面我们来登录一下，输入我们设置的用户名和密码，分别是tom和tom123。

我们登录成功了，那么现在我们关闭游览器，然后重新打开，并且直接访问主界面，看能否直接访问。我们发现登录成功了，并没有重定向，因为我们已经登录过了嘛，一天之内都不需要重新登陆。我们的功能就实现了。
在这里插入图片描述

三、Token + MySQL 的基本介绍及其基本使用

传统的token是某个用户登陆之后，服务器返回一个token给用户保存，这个token可能是随机几个字母的组合，并且服务器保留同一份token(比如用MySQL、Redis存储token)

当用户对其他的接口访问时，必须携带这个token，接着服务器判断这个token是否存在于MySQL中，来判断用户是否已经登陆或者是否有相应的权限

Token在MySQL数据库中存储
浏览器携带Token发起请求，服务器将用户Token与Token数据库对比，从而判断用户是否登录了。

package com.cm.entity; 

@Data
public class JsUser implements Serializable {
	private static final long serialVersionUID = 5332542385182145442L;
	private String uuid;
	private String userName;
	private String password;
	private Integer age;
	private String sex;
	private String city;
}
1
2
3
4
5
6
7
8
9
10
11
12

package com.cm.entity;

@Data
public class Token implements Serializable {
	private static final long serialVersionUID = 2919875280591926465L;
	private String uuid;
	private String token;
	@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
	private Date createTime;
}
1
2
3
4
5
6
7
8
9
10

四、JWT 基本介绍及其基本讲解

JWT是由三段信息构成：
在这里插入图片描述
服务器生成JWT

1. token的第一段字符串：由Header部分数据通过base64加密算法得到（可逆）
2. token的第二段字符串：由Payload部分数据通过base64加密算法得到（可逆）
3. token的第三段字符串：将header密文、Payload密文、密钥scret拼接起来，通过HS256加密（不可逆），得到的密文再进行一次base64加密
1
2
3

对应Java代码如下

 public static String generateToken(Map<String,Object> dataMap){
        Date date = new Date();
        Date expireTime = new Date(date.getTime() + expire * 1000);
        String token = Jwts.builder()
                .setHeaderParam("typ", "JWT")	// header数据部分
                .setClaims(dataMap)				// Payload数据部分
                .setIssuedAt(date)				// 当前时间
                .setExpiration(expireTime)		// 过期时间
                .signWith(SignatureAlgorithm.HS256, secret) //秘钥数据部分
                .compact();
        return token;
1
2
3
4
5
6
7
8
9
10
11

服务器生成Token并添加到浏览器的Cookie中

public class UserServiceImpl implements UserService{
	@Autowired
	private UserMapper userMapper;
	
	@Autowired
	TokenUtil tokenUtil;

	public R loginCheck(User user, HttpServletResponse response){
		User user2 = userMapper.selectByName(user.getUsername());
		if(user2 == null){
			return R.error().message("该用户不存在！");
		}
		if(!user2.getPassword().equals(user.getPassword())){
			return R.error().message("密码错误！");
		}

		// 获取token
		String token = tokenUtil.generateToken(user2);
		// 将token放在Cookie中
		Cookie cookie = new Cookie("token", token);
		// 将token的Cookie保存到浏览器中
		response.addCookie(cookie);
	}	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

服务器解析浏览器发来的Token

1. 服务器获取Token，并将Token切割成三部分
2. 对第二段字符串1进行base64解密，检测token是否超时
3. 对第一、二段字符串拼接，再次进行HS256加密，得到密文字符串signature
4. 对比服务器生成的signature和浏览器发来signature，如果相同，那么就是已经登录。
1
2
3
4

对应的Java代码

	/**
     * 验证token
     * @return  token正确返回对象，token不正确返回null
     */
    public static Claims getClaimByToken(String token){
        try {
          return Jwts.parser()
                    .setSigningKey(secret)  //获取秘钥
                    .parseClaimsJws(token)	//解析验证token
                    .getBody();
        }catch (Exception e){
            log.info("token验证失败",e);
            return  null;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

JWT生成Token常用工具类

package com.hhk.server.config;

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * JwtToken工具类
 */
//别忘记要@Component注解
@Component
public class JwtTokenUtil {
    //准备两常量
    private static final String CLAIM_KEY_USERNAME="sub";
    private static final String CLAIM_KEY_CREATED="created";
    //@Value可以从配置目录里面拿静态值
    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;

    /**
     * 第一个工具类功能
     * 根据用户信息生成token
     * 用户信息根据Spring security框架中的UserDetail中拿
     */
    public String generateToken(UserDetails userDetails){
        //准备一个空荷载claims，用于存储生成的key和value键值对（下面是存储生成token的时间和用户名）
        Map<String,Object> claims=new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME,userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED,new Date());
        return generateToken(claims);
    }

    /**
     * 根据荷载生成token
     * 主要是通过Jwts把荷载、失效时间、以及密钥加密生成token
     * @param claims
     * @return
     */
    private String generateToken(Map<String,Object> claims){
        //有了荷载claims就可以通过Jwts生成token,方式如下：
        return Jwts.builder()
                .setClaims(claims)//把荷载存储到里面
                .setExpiration(generateExpirationDate())//设置失效时间
                .signWith(SignatureAlgorithm.ES512,secret) //签名
                .compact();
    }


    /**
     * 生成token失效时间
     * @return
     */
    private Date generateExpirationDate() {
        //失效时间是当前系统的时间+我们在配置文件里定义的时间
        return new Date(System.currentTimeMillis()+expiration);
    }

    /**
     * 根据token获取用户名
     * @param token
     * @return
     */
    public String getUserNameFormToken(String token){
        String username;//用户名是通过在token中获取到荷载claims，然后再从荷载中取用户名
        try{
            Claims claims=getClaimsFormToken(token);
            username=claims.getSubject();
        }catch (Exception e){
            username=null;
        }
        return username;
    }

    /**
     * 从token中获取荷载
     * 获取荷载是通过jwts，然后船两参数，分别是secret、和token
     * @param token
     * @return
     */
    private Claims getClaimsFormToken(String token) {
        Claims claims=null;
        try{
            claims=Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        }catch (Exception e){
            e.printStackTrace();
        }
        return claims;
    }

    /**
     * 验证token是否有效
     * 主要通过token中的用户名和userDetail中的用户名是否一致，并且，token是否已经失效
     * @param token
     * @param userDetails
     * @return
     */
    public boolean validateToken(String token,UserDetails userDetails){
        String username=getUserNameFormToken(token);
        return username.equals(userDetails.getUsername())&&!isTokenExpired(token);
    }

    /**
     * 判断token是否已经失效
     * @param token
     * @return
     */
    private boolean isTokenExpired(String token) {
        //先获取之前设置的token的失效时间
        Date expireDate=getExpiredDateFormToken(token);
        return expireDate.before(new Date()); //判断下，当前时间是都已经在expireDate之后
    }

    /**
     * 根据token获取失效时间
     * 也是先从token中获取荷载
     * 然后从荷载中拿到到设置的失效时间
     * @param token
     * @return
     */
    private Date getExpiredDateFormToken(String token) {
        Claims claims=getClaimsFormToken(token);
        return claims.getExpiration();
    }

    /**
     * 判断toke是否可以被刷新
     * 如果过期则可以刷新
     * @param token
     * @return
     */
    public boolean canRefresh(String token){
        return !isTokenExpired(token);
    }

    /**
     * 刷新我们的token
     * @param token
     * @return
     */
    public String refreshToken(String token){
        Claims claims=getClaimsFormToken(token);
        claims.put(CLAIM_KEY_CREATED,new Date());
        return generateToken(claims);
    }
}
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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

五、SpringBoot 使用拦截器

定义拦截器只需要实现HandlerIntercepter

/**
* 自定义拦截器
*/
public class MyInterceptor implements HandlerInterceptor {
    private static final Logger logger =
    LoggerFactory.getLogger(MyInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse
    response, Object handler) throws Exception {
        HandlerMethod handlerMethod = (HandlerMethod) handler;
        Method method = handlerMethod.getMethod();
        String methodName = method.getName();
        logger.info("====拦截到了方法：{}，在该方法执行之前执行====", methodName);
        // 返回true才会继续执行，返回false则取消当前请求
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse
    response, Object handler, ModelAndView modelAndView) throws Exception {
        logger.info("执行完方法之后进执行(Controller方法调用之后)，但是此时还没进行视图渲
        染");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse
    response, Object handler, Exception ex) throws Exception {
        logger.info("整个请求都处理完咯，DispatcherServlet也渲染了对应的视图咯，此时我可
        以做一些清理的工作了");
    }
}
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

配置拦截器

@Configuration
public class MyInterceptorConfig extends WebMvcConfigurationSupport {
    
    // 将上面自定义好的拦截器添加进去。
    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor()).addPathPatterns("/**");
        super.addInterceptors(registry);
    }

	// 用来指定静态资源不被拦截
	@Override
	protected void addResourceHandlers(ResourceHandlerRegistry registry) {
    	registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");
    	super.addResourceHandlers(registry);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

六、SpringBoot + Token 基础实践案例

首先引入JWTUtils 工具类

@Slf4j
public class JwtUtil {

    public static void main(String[] args) {
        System.out.println(generate(1, DateUtil.date().offset(DateField.DAY_OF_MONTH, 1)));
        System.out.println(getId("eyJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJKZXJzZXktU2VjdXJpdHktQmFzaWMiLCJzdWIiOiIxIiwiZXhwIjoxNjI2MDA4NzcyLCJpYXQiOjE2MjU5MjIzNzJ9.arWl-hagLZ8xlfacXwUs-iSTjH3UVGIK68lEYMOYNPI"));
    }

    private static final String KEY = "1234qwer";

    public static String generate(Integer id, Date expiration) {
        if (id == null) {
            throw new NullPointerException("null id is illegal");
        }
        if (expiration == null) {
            throw new NullPointerException("null expiration is illegal");
        }
        return Jwts.builder()
                .setIssuer("Jersey-Security-Basic")
                .setSubject(id.toString())
                .setExpiration(expiration)
                .setIssuedAt(new Date())
                .signWith(SignatureAlgorithm.HS256, KEY)
                .compact();
    }

    public static boolean verify(String token) {
        try {
            Jwts.parser().setSigningKey(KEY).parseClaimsJws(token.trim());
            return true;
        } catch (Exception e) {
            log.error("无效的token:{}", token);
            return false;
        }
    }

    public static Integer getId(String token) {
        if (verify(token)) {
            Jws<Claims> claimsJws = Jwts.parser().setSigningKey(KEY).parseClaimsJws(token);
            return Convert.toInt(claimsJws.getBody().getSubject(), null);
        }
        return null;
    }
}
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

新建登录拦截器

public class LoginInterceptor implements HandlerInterceptor {

    @Autowired
    UserMapper userMapper;

    private static final Logger log = LoggerFactory.getLogger(LoginInterceptor.class);

    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse response, Object o) throws Exception {
        String token = httpServletRequest.getHeader("Authorization");
        if (token == null) {
            throw new RuntimeException("未携带token");
        }
        Integer id = JwtUtil.getId(token);
        User user = userMapper.selectOne(new QueryWrapper<User>().eq("id", id));
        if (user == null) {
            throw new RuntimeException("用户不存在，请重新登录");
        }
        // 验证token
        boolean verify = JwtUtil.verify(token);
        System.out.println(verify);
        if (verify) {
            return true;
        }
        return false;
    }
    //访问controller之后 访问视图之前被调用
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        log.info("--------------处理请求完成后视图渲染之前的处理操作---------------");
    }
    //访问视图之后被调用
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        log.info("---------------视图渲染之后的操作-------------------------0");
    }

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

配置拦截器

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    @Value("${savePath:/data/springboot-demo/file/}")
    private String savePath;

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/media/**")
                .addResourceLocations("file:" + savePath)
                .setCacheControl(CacheControl.maxAge(864000, TimeUnit.SECONDS).cachePublic());
    }

    /**
     * 拦截器
     * @param registry
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor())//添加拦截器
                .excludePathPatterns("/user/loginByCode", "/user/loginByOpenId")//对应的不拦截的请求
                .addPathPatterns("/**"); //拦截所有请求
    }

    /**
     * 自己写的拦截器
     * @return
     */
    @Bean
    public LoginInterceptor loginInterceptor() {
         return new LoginInterceptor();
     }
}

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

七、Spring Security Authentication 基本介绍及其使用案例

Authentication获取当前用户信息
Spring Security使用一个Authentication对象来描述当前用户的相关信息。SecurityContextHolder中持有的是当前用户的SecurityContext，而SecurityContext持有的是代表当前用户相关信息的Authentication的引用。

这个Authentication对象不需要我们自己去创建，在与系统交互的过程中，Spring Security会自动为我们创建相应的Authentication对象，然后赋值给当前的SecurityContext。

但是往往我们需要在程序中获取当前用户的相关信息，比如最常见的是获取当前登录用户的用户名。在程序的任何地方，通过如下方式我们可以获取到当前用户的用户名。

public String getCurrentUsername() {

	Object principal=SecurityContextHolder.getContext().getAuthentication().getPrincipal();

   	if (principal instanceof UserDetails) 
         return ((UserDetails) principal).getUsername();

    if (principal instanceof Principal) 
 	     return ((Principal) principal).getName();
    
    return String.valueOf(principal);
}
1
2
3
4
5
6
7
8
9
10
11
12

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/178768