您现在的位置是：首页 >技术教程 >【JavaWeb 用户认证】Cookie、Session、Token、JWT、Interceptor、SpringBoot、Spring Security网站首页技术教程

【JavaWeb 用户认证】Cookie、Session、Token、JWT、Interceptor、SpringBoot、Spring Security

后端漫漫 2023-07-19 12:00:02
简介【JavaWeb 用户认证】Cookie、Session、Token、JWT、Interceptor、SpringBoot、Spring Security
  1. Token基本了解：【详细阐述Token的来源】
  2. 公钥私钥基本了解：【理解公钥】

文章目录

一、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";
    }
}

二、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);
    }
}

如果没有登录过，就会跳转到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>

执行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);
    }
}

第一次来访问主界面@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;
}

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;
}

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

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

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

对应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;

服务器生成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);
	}	
}

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

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

对应的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;
        }
    }

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);
    }
}

五、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也渲染了对应的视图咯，此时我可
        以做一些清理的工作了");
    }
}

配置拦截器

@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);
	}
}

六、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;
    }
}

新建登录拦截器

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");
    }

配置拦截器

@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();
     }
}

七、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);
}
风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

站长推荐