spring boot + spring security +JWT令牌 +前后端分离--- 心得
1.前言
观看这篇随笔需要有spring security基础。
心得： 1.生成token 的变化数据是用户名和权限拼接的字符串 ，其他的固定 2.生成的token是将登录通过的用户的权限拼接的字符串加密后放入里面后加密，当携带token访问时被拦截后，会将token解析出的权限注册，因为不与数据库等数据共享校验权限最新信息， 如果在携带token的请求前权限有变化，但是token却没有改变，会导致token权限与用户真实权限不一致，形成脏数据啦！！！ 如果权限增加还好，使得无法访问新加权限的操作，如果是减少权限，比如vip过期，用户仍然可以有vip权限。 3.解决token脏数据的方案有两个： （1）等待该token失效时间【不靠谱】； （2）每次修改权限时，会强制使得token失效，具体怎么做，还没试过 4.当然，也有优点的，不与数据库等最新数据做权限对比操作，较少了访问数据库该用户信息的部分，能快速的过滤请求权限，理论上访问数据会变快。 5.可以设置过期时间，单位毫秒，用时间戳设置 ，到时间则不可在使用， 但是缺点很明显，在未过期之前，可以无数次访问验证通过，无法控制使用次数， 因此不能作为资源服务器对第三方应用开放的授权令牌， 6.令牌格式对不上，会直接报错异常，为了服务降级，做个异常捕获即可 7.如果生成了新的令牌，旧的令牌仍然可以使用，因此会导致多设备同时登录的情况，无法控制登录数量 8.使用jwt[java web token],做登录校验，则会导致http.sessionManagement().maximumSessions(1);设置失效，因为没有使用session做为登录控制 // 安全弊端很多 ， 但是让我深刻明白了token的内部思想
完全可以使用redis来完成用户token的管理，但是这样每次都需要向redis查询一次，就让jave web token 不伦不类了 。。。。
虽然已经尽可能的让服务器减少负担和提高反应速度，但仍然感觉好鸡肋
//
当然应用场景还是有的，可用于分享连接的使用，这样既能向有令牌的用户使用被分享的权限，而且不需要去数据库获取数据对其进行对比，降低服务器负担，
也就是说比较适合半开放性的功能使用
//
工程我放在GitHub仓库了
https://github.com/cen-xi/spring-security-JWT
2.操作
看我的源码大招，写了很多注释了，足够详细了，我懒得再写说明
（1）目录结构
（2）添加依赖包
pom.xml源码
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.0.RELEASE</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.example</groupId> <artifactId>security-jwt-5605</artifactId> <version>0.0.1-SNAPSHOT</version> <name>security-jwt-5605</name> <description>Demo project for Spring Boot</description> <properties> <java.version>1.8</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> <exclusions> <exclusion> <groupId>org.junit.vintage</groupId> <artifactId>junit-vintage-engine</artifactId> </exclusion> </exclusions> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-test</artifactId> <scope>test</scope> </dependency> <!-- jwt依赖--> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
（3）做一个实体类，继承 UserDetails
package com.example.securityjwt5605.model; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.userdetails.UserDetails; import java.util.Collection; import java.util.List; public class JwtUser implements UserDetails { //属性名 username 和 password 是固定死的，不可更改，否则报错 //但 grantedAuthorities 可随意 private String username; private String password; private List<GrantedAuthority> grantedAuthorities; @Override public Collection<? extends GrantedAuthority> getAuthorities() { return grantedAuthorities; } @Override public String getPassword() { return password; } @Override public String getUsername() { return username; } @Override public boolean isAccountNonExpired() { return true; } @Override public boolean isAccountNonLocked() { return true; } @Override public boolean isCredentialsNonExpired() { return true; } @Override public boolean isEnabled() { return true; } public void setUsername(String username) { this.username = username; } public void setPassword(String password) { this.password = password; } public void setGrantedAuthorities(List<GrantedAuthority> grantedAuthorities) { this.grantedAuthorities = grantedAuthorities; } }
（4）用户名密码登录过滤器
package com.example.securityjwt5605.filters; import com.example.securityjwt5605.model.JwtUser; import com.fasterxml.jackson.databind.ObjectMapper; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; import org.springframework.http.MediaType; import org.springframework.security.authentication.AuthenticationManager; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.Authentication; import org.springframework.security.core.AuthenticationException; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter; import org.springframework.security.web.util.matcher.AntPathRequestMatcher; import org.springframework.security.web.util.matcher.RequestMatcher; import javax.servlet.FilterChain; import javax.servlet.ServletException; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; import java.io.IOException; import java.io.PrintWriter; import java.util.Collection; import java.util.Date; import java.util.HashMap; import java.util.Map; /** * 首次登录才调用这个方法 */ public class JwtLoginFilter extends AbstractAuthenticationProcessingFilter { //构造方法 ，记得使用 public //第一个是 登录路径 。第二个是 认证管理者 //在启动的时候就已经h已经执行了 public JwtLoginFilter(String defaultFilterProcessesUrl, AuthenticationManager authenticationManager) { super(new AntPathRequestMatcher(defaultFilterProcessesUrl)); System.out.println("===============================登录拦截1=================================="); //存储到父类，可不加 super.便于方法 attemptAuthentication（）调用, setAuthenticationManager(authenticationManager); } /** *访问/login登录后首先进入这里 */ @Override public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse resp) throws AuthenticationException, IOException, ServletException { JwtUser user = new JwtUser(); System.out.println("===============================登录拦截2=================================="); try { //从请求中获取用户验证信息 //将json字符串解析 user = new ObjectMapper().readValue(req.getInputStream(), JwtUser.class); // }catch (Exception ignored){ // //Exception ignored表示忽略异常 // //这样内部可以不写内容 // } // String username = req.getParameter("username"); // String password = req.getParameter("password"); // if (username == null || password == null){ // throw new Exception(); // } // user.setUsername(username); // user.setPassword(password); }catch (Exception e){ //Exception ignored表示忽略异常 System.out.println("请求无法解析出JwtUser对象"); } //对请求做认证操作，如何校验，由默认的程序完成，不涉及对比操作，因为用户信息存在内存中，否则需要修改 securityConfig.java 的 configure(AuthenticationManagerBuilder auth) 用于设置数据库操作 //认证管理对象执行认证方法，new 一个用户密码认证令牌对象，参数为用户名和密码，然后放入认证方法中 //然后执行登录验证 return getAuthenticationManager().authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword())); } //认证成功 @Override protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, FilterChain chain, Authentication authResult) throws IOException, ServletException { System.out.println("===============================登录拦截3=================================="); //获取登录角色的权限 //这是权限 ，如果登录内存只有角色配置，无权限配置，则自动添加前缀构成权限 ROLE_角色 Collection<? extends GrantedAuthority> authorities = authResult.getAuthorities(); //线程安全 StringBuffer stringBuffer = new StringBuffer(); for (GrantedAuthority grantedAuthority : authorities) { System.out.println("当前有的权限："+grantedAuthority); //用逗号隔开好一点，不然后面需要手动切割 stringBuffer.append(grantedAuthority.getAuthority()).append(","); } //生成令牌 token String jwt = Jwts.builder() //登录角色的权限，这会导致如果权限更改，该token无法及时更新权限信息 .claim("authorities", stringBuffer) //用户名 .setSubject(authResult.getName()) //存活时间，过期则判为无效 .setExpiration(new Date(System.currentTimeMillis() + 1000 * 10)) //签名,第一个参数时算法，第二个参数时内容，内容可随意写 .signWith(SignatureAlgorithm.HS512, "java521@java") //协议完成 .compact(); System.out.println(jwt); System.out.println("======================"); System.out.println(stringBuffer); //设置json数据返回给前端 Map<String, Object> map = new HashMap<>(); map.put("token", jwt); map.put("msg", "登录成功"); //MediaType.APPLICATION_JSON_UTF8_VALUE 等用于 "application/json;charset=UTF-8" // response.setContentType(MediaType.APPLICATION_JSON_UTF8_VALUE); response.setContentType("application/json;charset=utf-8"); PrintWriter printWriter = response.getWriter(); //转成json后传送 printWriter.write(new ObjectMapper().writeValueAsString(map)); //关闭流 printWriter.flush(); printWriter.close(); } //认证失败 @Override protected void unsuccessfulAuthentication(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException, ServletException { System.out.println("===============================登录拦截4=================================="); Map<String, Object> map = new HashMap<>(); map.put("msg", "登录失败"); response.setContentType("application/json;charset=utf-8"); PrintWriter printWriter = response.getWriter(); //转成json后传送 printWriter.write(new ObjectMapper().writeValueAsString(map)); //关闭流 printWriter.flush(); printWriter.close(); } }
（5）token访问过滤器
package com.example.securityjwt5605.filters; import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jws; import io.jsonwebtoken.Jwts; import org.springframework.security.authentication.UsernamePasswordAuthenticationToken; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.AuthorityUtils; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.web.filter.GenericFilterBean; import sun.plugin.liveconnect.SecurityContextHelper; import javax.servlet.FilterChain; import javax.servlet.ServletException; import javax.servlet.ServletRequest; import javax.servlet.ServletResponse; import javax.servlet.http.HttpServletRequest; import java.io.IOException; import java.security.Security; import java.util.List; /** * 对携带token的请求做token检查，对比是否正确，正确则可以直接通过 */ public class JwtFilter extends GenericFilterBean { @Override public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException { System.out.println("===============================token登录拦截1=================================="); //强转http请求 HttpServletRequest httpServletRequest = (HttpServletRequest) servletRequest; //从请求头获取数据 //定死了名称为 authorization String tokenStr = httpServletRequest.getHeader("authorization"); System.out.println(tokenStr); /* 打印结果 【不可换行，这里为了展示才换行】 Bearer eyJhbGciOiJIUzUxMiJ9.eyJhdXRob3JpdGllcyI6IlJPTEVfYWRtaW4sIiwic3ViIjoiYWRtaW4iLCJleHAi OjE1OTE2MzAwMTF9.oHmTl-f5RetmFJ8rM5MaIruOkA83sqt-6F7f2c27QRWdJvTAOIYX_VbRCngodaROZ4jprQ1ktwz5sZAWcDJdkg */ System.out.println("=========================================="); if (tokenStr != null) { System.out.println("有认证令牌"); boolean k = true; Jws<Claims> jws = null; try { //解析,解析方式使用加密时配置的数字签名对应 //一旦令牌修改成位数对比不上，会报错。。。 jws = Jwts.parser().setSigningKey("java521@java") .parseClaimsJws(tokenStr.replace("Bearer", "")); System.out.println(tokenStr.replace("Bearer", "")); /* 打印结果 【不可换行，这里为了展示才换行】 eyJhbGciOiJIUzUxMiJ9.eyJhdXRob3JpdGllcyI6IlJPTEVfYWRtaW4sIiwic3ViIjoiYWRtaW4iLCJleHAiOjE 1OTE2MzAwMTF9.oHmTl-f5RetmFJ8rM5MaIruOkA83sqt-6F7f2c27QRWdJvTAOIYX_VbRCngodaROZ4jprQ1ktwz5sZAWcDJdkg */ } catch (Exception e) { //放令牌被修改、时间过期，都会抛出异常,由方法 parseClaimsJws（）安抛出的异常 // e.printStackTrace(); k = false; } if (k) { // 令牌解析成功 Claims claims = jws.getBody(); //获取token解析出来的用户名 String username = claims.getSubject(); System.out.println(username); /* 打印结果 [ROLE_admin,ROLE_user,等等] */ //从token获取登录角色的权限 //如果时以逗号格式配置字符串，可用以下方式解析,否则手动解析 List<GrantedAuthority> grantedAuthorities = AuthorityUtils.commaSeparatedStringToAuthorityList((String) claims.get("authorities")); System.out.println(grantedAuthorities); // //new令牌登录校验 对象，参数分别是 ： 用户名 ，盐[没有则设为null] ，角色/权限 UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, null, grantedAuthorities); //执行令牌登录校验 SecurityContextHolder.getContext().setAuthentication(token); } else { System.out.println("令牌解析失败，被修改了"); SecurityContextHolder.getContext() .setAuthentication(new UsernamePasswordAuthenticationToken(null, null, null)); } } else { System.out.println("没有认证令牌"); SecurityContextHolder.getContext() .setAuthentication(new UsernamePasswordAuthenticationToken(null, null, null)); } System.out.println("//让过滤器继续往下走，"); //让过滤器继续往下走 filterChain.doFilter(servletRequest, servletResponse); } } /* 总结： 1.生成token 的变化数据是用户名和权限拼接的字符串 ，其他的固定 2.生成的token是将登录通过的用户的权限拼接的字符串加密后放入里面后加密，当携带token访问时被拦截后，会将token解析出的权限注册，因为不与数据库等数据共享校验权限最新信息， 如果在携带token的请求前权限有变化，但是token却没有改变，会导致token权限与用户真实权限不一致，形成脏数据啦！！！ 如果权限增加还好，使得无法访问新加权限的操作，如果是减少权限，比如vip过期，用户仍然可以有vip权限。 3.解决token脏数据的方案有两个： （1）等待该token失效时间【不靠谱】； （2）每次修改权限时，会强制使得token失效，具体怎么做，还没试过 4.当然，也有优点的，不与数据库等最新数据做权限对比操作，较少了访问数据库该用户信息的部分，能快速的过滤请求权限，理论上访问数据会变快。 5.可以设置过期时间，单位毫秒，用时间戳设置 ，到时间则不可在使用， 但是缺点很明显，在未过期之前，可以无数次访问验证通过，无法控制使用次数， 因此不能作为资源服务器对第三方应用开放的授权令牌， 6.令牌格式对不上，会直接报错异常，为了服务降级，做个异常捕获即可 7.如果生成了新的令牌，旧的令牌仍然可以使用，因此会导致多设备同时登录的情况，无法控制登录数量 8.使用jwt[java web token],做登录校验，则会导致http.sessionManagement().maximumSessions(1);设置失效，因为没有使用session做为登录控制 // 安全弊端很多 ， 但是让我深刻明白了token的内部思想 */
（6）服务层根据用户名获取用户信息【为了简便，没有使用数据库，直接赋值】
package com.example.securityjwt5605.filters; import com.example.securityjwt5605.model.JwtUser; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.core.GrantedAuthority; import org.springframework.security.core.authority.SimpleGrantedAuthority; import org.springframework.security.core.userdetails.UserDetails; import org.springframework.security.core.userdetails.UserDetailsService; import org.springframework.security.core.userdetails.UsernameNotFoundException; import org.springframework.stereotype.Service; import java.util.ArrayList; import java.util.List; /** * 这个类其实就是为了获取用户的正确认证信息，不做信息比较，比较是在过滤器里面， * 名字叫做 UsernamePasswordAuthenticationFilter */ @Service public class MyUserDetailsService implements UserDetailsService { @Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException { JwtUser tUser = new JwtUser(); //权限设置 List<GrantedAuthority> simpleGrantedAuthorities = new ArrayList<>(); System.out.println("===============================数据库层对比=================================="); if (username.equals("cen")) { tUser.setUsername(username); tUser.setPassword("$2a$10$Qghi7vHdyQJHYlAO.FCo/u3gCbqwWBVaSHjIF0Vci.C5.1l71SExq"); simpleGrantedAuthorities.add(new SimpleGrantedAuthority("ROLE_user")); tUser.setGrantedAuthorities(simpleGrantedAuthorities); } else if (username.equals("admin")) { tUser.setUsername(username); tUser.setPassword("$2a$10$ywq3gn6E15tnY3URptsIz.zn/fznWGqc2VhO4zphS/sIbWZJtLCVK"); simpleGrantedAuthorities.add(new SimpleGrantedAuthority("ROLE_admin")); tUser.setGrantedAuthorities(simpleGrantedAuthorities); } else { throw new UsernameNotFoundException("没有找到用户"); } // System.out.println("============================="); // //根据用户名去数据库查询用户信息 // TUser tUser = userService.getByUsername(username); // if (tUser == null){ // throw new UsernameNotFoundException("用户不存在！"); // } // //权限设置 // List<SimpleGrantedAuthority> simpleGrantedAuthorities = new ArrayList<>(); // String role = tUser.getRole(); // //分割权限名称，如 user,admin // String[] roles = role.split(","); // System.out.println("============================="); // System.out.println("注册该账户权限"); // for (String r :roles){ // System.out.println(r); // //添加权限 // simpleGrantedAuthorities.add(new SimpleGrantedAuthority("ROLE_"+r)); //// simpleGrantedAuthorities.add(new SimpleGrantedAuthority(r)); // } // tUser.setGrantedAuthorities(simpleGrantedAuthorities); // System.out.println("============================="); /** * 创建一个用于认证的用户对象，包括：用户名，密码，权限 * */ //输入参数 // return new org.springframework.security.core.userdetails.User(tUser.getUsername(), tUser.getPassword(), simpleGrantedAuthorities); // 这个返回值的类型，继承了userdetails即可 return tUser; } }
（7）contoller接口
package com.example.securityjwt5605.controller; import org.springframework.web.bind.annotation.CrossOrigin; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import java.util.HashMap; import java.util.Map; @RestController public class HHController { //开启跨域 // [普通跨域] //@CrossOrigin //[spring security 跨域] @CrossOrigin(allowCredentials = "true", allowedHeaders = "*") @RequestMapping("/hello") public Map<String, Object> hello() { Map<String, Object> map = new HashMap<>(); map.put("data", "hello"); return map; } //开启跨域 // [普通跨域] //@CrossOrigin //[spring security 跨域] @CrossOrigin(allowCredentials = "true", allowedHeaders = "*") @RequestMapping("/admin") public Map<String, Object> admin() { Map<String, Object> map = new HashMap<>(); map.put("data", "i am admin"); return map; } }
（8）security配置类
package com.example.securityjwt5605.config; import com.example.securityjwt5605.filters.JwtFilter; import com.example.securityjwt5605.filters.JwtLoginFilter; import com.example.securityjwt5605.filters.MyUserDetailsService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.http.HttpMethod; import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder; import org.springframework.security.config.annotation.web.builders.HttpSecurity; import org.springframework.security.config.annotation.web.builders.WebSecurity; import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity; import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter; import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder; import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter; import org.springframework.web.servlet.config.annotation.CorsRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; import java.lang.reflect.Method; @Configuration @EnableWebSecurity public class SecurityConfig extends WebSecurityConfigurerAdapter { @Autowired private MyUserDetailsService myUserDetailsService; /** * 全局的跨域配置 */ @Bean public WebMvcConfigurer WebMvcConfigurer() { return new WebMvcConfigurer() { public void addCorsMappings(CorsRegistry corsRegistry) { //仅仅让/login可以跨域 corsRegistry.addMapping("/login").allowCredentials(true).allowedHeaders("*"); //仅仅让/logout可以跨域 corsRegistry.addMapping("/logout").allowCredentials(true).allowedHeaders("*"); //允许所有接口可以跨域访问 //corsRegistry.addMapping("/**").allowCredentials(true).allowedHeaders("*"); } }; } /** * 忽略过滤的静态文件路径 */ @Override public void configure(WebSecurity web) throws Exception { web.ignoring() .antMatchers( "/js/**/*.js", "/css/**/*.css", "/img/**", "/html/**/*.html" ); } //内存放入可登录的用户信息 @Override protected void configure(AuthenticationManagerBuilder auth) throws Exception { System.out.println("===============================认证管理构造器=================================="); //直接注册信息到内存，会导致jrebel热更新失效，无法更新该内容 // //如果仅仅设置了roles,则权限自动设置并自动添加前缀 为 ROLE_【角色内部的字符串，可以设置多个】， //字符串不可再添加ROLE_，会报java.lang.IllegalArgumentException: ROLE_user cannot start with ROLE_ (it is automatically added) //意思是用 ROLE_前缀会自动添加， // auth.inMemoryAuthentication().withUser("cen") // .password("$2a$10$Qghi7vHdyQJHYlAO.FCo/u3gCbqwWBVaSHjIF0Vci.C5.1l71SExq").roles("user") // //如果使用了roles 和 authorities ，那么roles将失效，将会注册authorities内部的字符串为权限，且不会添加前缀名ROLE_ // .and().withUser("admin") // .password("$2a$10$ywq3gn6E15tnY3URptsIz.zn/fznWGqc2VhO4zphS/sIbWZJtLCVK").roles("user").authorities("ROLE_admin"); // // //因此用户cen的权限为ROLE_user //用户admin的权限为 admin // // //调用数据库层，根据用户名获取用户信息回来， auth.userDetailsService(myUserDetailsService) //设置加密方式 .passwordEncoder(passwordEncoder()); } @Bean public BCryptPasswordEncoder passwordEncoder() { return new BCryptPasswordEncoder(); } //过滤规则,一旦设置了重写了这个方法，必须设置登录配置 //在启动的时候就执行了 @Override protected void configure(HttpSecurity http) throws Exception { System.out.println("===============================过滤规则=================================="); http.authorizeRequests() .antMatchers("/hello").hasRole("user") .antMatchers("/admin").hasRole("admin") // .antMatchers("/admin").hasAuthority("admin") //当访问/login的请求方式是post才允许通过 .antMatchers(HttpMethod.POST, "/login").permitAll() // .anyRequest() .anyRequest().authenticated() .and() //首次登录拦截。仅允许post访问/login .addFilterBefore(new JwtLoginFilter("/login", authenticationManager()), UsernamePasswordAuthenticationFilter.class) //token验证拦截 .addFilterBefore(new JwtFilter(), UsernamePasswordAuthenticationFilter.class) // .cors() .and() .csrf().disable(); // //使用jwt[java web token],做登录校验，则该设置失效，因为没有使用session做为登录控制 // http.sessionManagement().maximumSessions(1); } }
（9）同时做了简易的前端访问页面【前后端分离，前端端口是5601 ，后端是5605】
jwt.html
<!DOCTYPE html> <html lang="zh" xmlns="http://www.w3.org/1999/xhtml"> <head> <meta charset="UTF-8"> <title>[JWT] 测试</title> </head> <body> jave web token [JWT] 测试 <hr> <div> <label> 账户： <input id="name" type="text"> </label> <label> 密码： <input id="psw" type="text"> </label> </div> <button onclick="dosome(1)">登录</button> <hr> <hr> <button onclick="dosome(3)">登出</button> <hr> <label> token： <input id="url" type="text" value="http://localhost:5605/hello"> <span id="token"></span> </label> <button onclick="dotoken()">点我token访问</button> <hr> 返回的结果：<span id="res"></span> <!--当前路径是/html/** ,因此需要返回一级 ，所以用 ../js/ --> <script src="../js/jquery-1.11.1.min.js"></script> <script src="../js/base64.js"></script> <script> //当前最新的token let token = ""; function dotoken() { let url = ""+($("#url").val()).trim(); if (url == ""){ console.log("url不可空") return; } $.ajax({ //请求头添加token //方法一： // beforeSend: function (request) { // request.setRequestHeader("Authorization", token); // }, //方法二： headers: { //认证信息 Authorization: token }, async: true, type: 'post', dataType: "json", url: url, xhrFields: {withCredentials: true}, //前端适配：允许session跨域 crossDomain: true, success: function (data) { console.log(data); //请求成功回调函数 if (data != null) { // alert("有数据返回") $("#res").html(JSON.stringify(data)) } else { alert("系统异常") } }, error: function (xhr, type, errorThrown) { //异常处理； console.log("异常处理") console.log(JSON.stringify(xhr)); if (xhr.readyState == 4 && xhr.status == 403){ $("#res").html("403无权访问") } /* {"readyState":4,"responseText":"{\"timestamp\":\"2020-06-08T16:51:15.016+00:00\", \"status\":403,\"error\":\"Forbidden\",\"message\":\"\",\"path\":\"/admin\"}", "responseJSON":{"timestamp":"2020-06-08T16:51:15.016+00:00","status":403,"error":"Forbidden", "message":"","path":"/admin"},"status":403,"statusText":"error"} */ console.log(type); console.log(errorThrown); } }); } function dosome(type) { let name = ""; let psw = ""; let url = ""; if (type == 1) { name = ($("#name").val()).trim(); psw = ($("#psw").val()).trim(); //登录 url = "http://localhost:5605/login"; } else if (type == 3) { //登出 url = "http://localhost:5605/logout"; } //URL是URI的子集，所有的URL都是URI，但不是每个URI都是URL，还有可能是URN。 $.ajax({ async: true, type: 'post', //对应于后端 parama 方式获取数据 ,使用req.getParameter获取 // data: {"username": name, "password": psw}, //对应于后端raw方式获取数据，需要json解析，使用req.getInputStream()获取 data: JSON.stringify({"username": name, "password": psw}), //这里类型是json，那么跨域的后端需要是map类型、po实体类等 json类型 才能接收数据 dataType: "json", url: url, xhrFields: {withCredentials: true}, //前端适配：允许session跨域 crossDomain: true, // //请求头设置 // headers: { // //认证信息 // Authorization: authorization // }, success: function (data) { console.log(data); //请求成功回调函数 if (data != null) { // alert("有数据返回") $("#res").html(JSON.stringify(data)) token = data.token; $("#token").html(token); } else { alert("系统异常") } }, error: function (xhr, type, errorThrown) { //异常处理； console.log("异常处理") console.log(JSON.stringify(xhr)); console.log(type); console.log(errorThrown); } }); } </script> </body> </html>
3.测试
token时间设长一点，我这里设为1小时
（1）使用postman f访问 http://localhost:5605/login 进行登录
登录成功
获取令牌，访问 http://localhost:5605/hello
提交后
成功
因为用户 cen我设置了只有权限。
再次访问 http://localhost:5605/admin
无权限403被拒绝了
事实上，当令牌过期后再访问，也会抛出403结果
换一个账户
访问 http://localhost:5605/admin ，是可以访问的
（2）测试前端 跨域 访问
测试密码错误
测试登录成功
点击token访问
token 成功
换一个没有访问hello权限的账号
然后再次点击token访问
4.过滤器的先后操作
（1）工程启动，控制台打印
（2）用户名密码登录后，控制台打印
（3）携带token访问
有效的令牌
无效的令牌
奇怪的是 携带无效令牌时 会执行两次token访问过滤器，原因还不清楚
-------------------------
参考博文原址：
https://mp.weixin.qq.com/s/Sn59dxwtsEWoj2wdynQuRQ
本文来自博客园，作者：岑惜，转载请注明原文链接：https://www.cnblogs.com/c2g5201314/p/13070073.html
响应开源精神相互学习，内容良币驱除劣币
