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