SpringSecurity+JWT权限认证

news2024/11/19 5:27:16

SpringSecurity默认的是采用Session来判断请求的用户是否登录的，但是不方便分布式的扩展
虽然SpringSecurity也支持采用SpringSession来管理分布式下的用户状态，不过现在分布式的还是无状态的Jwt比较主流

一、创建SpringBoot的项目

spring-boot-starter-web
spring-boot-starter-security

二、代码

server.port=8111

# 再配置文件中设置登录系统的账户、密码
spring.security.user.name=jordan
spring.security.user.password=jordan

/**
	通过配置类设置登录系统的账户、密码
*/
@Configuration
public class SecurityConfig extends WebSecurityConfig{
	@Override 
	protected void configure(AuthenticationManagerBuilder auth){
		//密码加密
		BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
		String password = passwordEncoder.encode("123");
		
		auth.inMemoryAuthentication().withUser("kobe").password(password).roles("admin");
	}

	@Bean
	PasswordEncoder password(){
		return new BCryptPasswordEncoder();
	}
}	

/**
	自定义配置类，设置用户名、密码
	该配置类设置使用哪个service实现类
*/
@Configuration
public class SecurityConfigTest extends WebSecurityConfigurerAdapter{

	@Autowired
	private UserDetailsService userDetailsService;
	
	@Override
	protected void configure(AuthenticationManagerBuilder auth) throws Exception{
		auth.userDetailsService(userDetailsService).passwordEncoder(password());
	}

	@Bean
	PasswordEncoder password(){
		return new BCryptPasswordEncoder();
	}

	/**
		自定义登录页面
	*/
	@Override
	protected void configure(HttpSecurity http) throws Exception{
		
		//配置没有权限访问跳转自定义页面
		http.exceptionHandling().accessDeniedPage("/unauth.html");

		http.formLogin()//自定义自己编写的页面
			.loginPage("/login.html")//登录页面设置
			.loginProcessingUrl("/user/login")//登录访问路径
			.defaultSuccessUrl("/test/index").permitAll()//登录成功后跳转的路径
			.and().authorizeRequests()
			.antMatchers("/","test/hello","/user/login").permitAll()//设置哪些路径可以直接访问
			
		//	.antMatchers("test/index").hasAuthority("admins")//当前登录用户，只有具有admins角色的权限下才能访问该路径（单个角色）
			.antMatchers("/test/index").hasAnyAuthority("admins,manager")//	多个权限
			
			.antMatchers("/test/index").hasRole("sale") //单个角色
			.antMatchers("index").hasAnyRole("")//多个角色任意一个
			//.anyRequest().authenticated()
			.and().csrf().disable();//关闭csrf防护
	}
}

/**
	service实现类
*/
@Service("userDetailsService")
public class MyUserDetailsService implements UserDetailsService{

	@Override
	public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException{
		//设置权限
		List<GrantedAuthority> auths = AuthorityUtils.commaeparatedStringToAuthorityList("admins,ROLE_sale");//设置权限,和角色（角色必须又前缀ROLE_）
		return new User("james",new BCryptPasswordEncoder().encode("123"),auths);
	}
}

@RestController
@RequestMapping("/test")
public class TestController{
	@GetMapping("hello")
	public String add(){
		return "hello security";
	}
}

三、启动运行

通过浏览器访问http://localhost:8111
进入页面 user 默认密码从控制台中寻找（三种方式设置用户名和密码：配置文件方式、配置类、自定义编写实现类

===========================================================

查询数据库完成认证

一、添加依赖

mybatis-plus-boot-starter
mysql-connector-java
lombok

二、创建数据表（id,username,password）以及对应的实体类，配置文件中添加数据库连接信息
在这里插入图片描述
在这里插入图片描述

三、编写mapper，以及service

/**
	启动类上必须添加该接口所在的包扫描 @MapperScan("com.xxx.mapper")
*/
@Repository
public interface UsersMapper extends BaseMapper<User>{
	
}

@Service("userDetailsService")
public class MyUserDetailsService implements UserDetailService{
	
	@Autowired
	private UsersMapper usersMapper;

	@Override
	public UserDetails loadUserByUsername throws UsernameNotFoundException(String username){
		//调用usersMapper，查询数据库
		QueryWrapper<Users> wrapper = new QueryWrapper();
		wrapper.eq("username",username);//where username=? 
		Users users = usersMapper.selectOne(wrapper);
		
		if(users == null){ //数据库没有用户名，认证失败
			throw new UsernameNotFoundException("用户名不存在");
		}
		List<GrantAuthority> auths = AuthorityUtils.commaSeparatedStringToAuthorityList("roles");
		return new User(users.getUsername(),newBCryptPasswordEncoder().encode(users.getPassword()),auths);
	}
	
}

=====================================================

注解

一、启动类上开启注解@EnableGlobalMethodSecurity(securedEnabled=true)

@SpringBootApplication
@EnableGlobalMethodSecurity(securedEnabled=true,prePostEnabled=true)
public class DemosecurityApplication{

}

二、控制类

@RestController
@RequestMapping("/test")
public class TestController{

	@GetMapping("update")
	@Secured("ROLE_sale","ROLE_manager")//设置角色
	public String update(){
		return "hello update";
	}
}

@RequestMapping("/preAuthorize")
@ResponseBody
@PreAuthorize("hasAnyAuthority('admin')")//进入方法前权限验证，将角色权限参数传到方法中
public String preAuthorize(){
	System.out.printn("preAuthorize");
	return "preAuthorize";
}

/**
	@PostAuthorize("hasAnyAuthority('admins')")//方法后权限验证，主要针对返回值
*/

/**
	@PostFilter 权限验证之后对数据进行过滤，留下用户名是admin1的数据
*/
@RequestMapping("getAll")
@PreAuthorize("hasRole('ROLE_管理员')")
@PostFilter("filterObject.username == 'admin'")
@ResponseBody
public List<UserInfo> getAllUser(){
	ArrayList<UserInfo> list = new ArrayList<>();
	list.add(new UserInfo(1l,"admin1","6666"));
	list.add(new UserInfo(2l,"admin2","888"));
	return list;
}

/**
	@PostFilter 权限验证之后对数据进行过滤，留下用户名是admin1的数据
*/

三、userDetailsService设置用户角色

List<GrantAuthority> auths = AuthorityUtils.commaSeparatedStringToAuthorityList("ROLE_sale");

==============================================================

微服务权限案例

一、数据表

在这里插入图片描述

二、父工程，管理依赖版本。子工程以及子工程中的模块
在这里插入图片描述

父工程——pom

<properties>
	<!--确定各组件的依赖版本-->
	<java.version>1.8</java.version>
	<mybatis-plus.version>3.0.5</mybatis-plus.version>
</properties>

<dependencyManagement>
	<dependencies>
		<!--对上面的版本进行具体化的依赖-->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>${mybatis-plus.version}</verison>
		</dependency>
	</dependencies>
</dependencyManagement>

子工程common——pom

<dependencies>
	<!--对父工程的依赖进行去版本处理-->
	<dependency>
		<groupId>io.springfox</groupId>
		<artifactId>springfox-swagger2</artifactId>
		<scope>provided</scope>
	</dependency>
</dependencies>

三、启动redis，启动Nacos注册中心
在这里插入图片描述
在这里插入图片描述

四、代码

密码处理

@Component
public class DefaultPasswordEncoder implements PasswordEncoder{

	public DefaultPasswordEncoder(){
		
	}
	public DefaultPasswordEncoder(int strength){
		
	}
	
	/**
		对密码进行MD5加密
	*/
	@Override
	public String encode(CharSequence charSequence){
		return MD5.encrypt(charSequence.toString());
	}
	
	/**
		密码对比
	*/
	@Override
	public boolean matches(CharSequence charSequence,String s){
		return encodedPassword.equals(MD5.encrypt(charSequence.toString()));
	}
}

token管理

@Component
public class TokenManager{

	//设置token有效时常
	private long takenEcpiration = 24*60*60*1000;
	//编码密钥(编码，解码)
	private String tokenSignKey = "123456";
	
	//使用jwt根据用户名生成token
	public String createToken(String username){
		String token = Jwts.builder().setSubject(username)
			.setExpiration(new Date(System.currentTimeMillis()+tokenEcpiration))//设置有效时长
			.signWith(SingatureAlgorithm.HS512,tokenSignKey).compressWith(CompressionCodecs.GZIP).compact();
		
		return token;
	}

	//根据token字符串得到用户信息
	public String getUserInfoFromToken(String token){
		String userinfo = Jwts.parser().setSigningKey(tokenSignKey).parseClaimsJws(token).getBody().getSubject();
		return userinfo;
	}

	//删除token
	public void removeToken(String token){}
}

退出登录

public class TokenLogoutHandler implements LogoutHandler{

	private TokenManager tokenManager;
	private RedisTemplate redisTemplate;

	public TokeLogoutHandler(TokenManager tokenManager,RedisTemplate redisTemplate){
		this.tokenManager = tokenManager;
		this.redisTemplate = redisTemplate;
	}
	
	@Override
	public void logout(HttpServletRequest request,HttpServletResponse response,Authentication authentication){
		//从header里面获取token
		String token = request.getHeader("token");
		if(token != null){
			tokenManager.removeToken(token);

			//从token获取用户名
			String username = tokenManager.getUserInfoFromToken(token);
			redisTemplate.delete(username);
		}
		ResponseUtil.out(response,R.ok());
	}
}

未授权统一处理类

public class UnauthEntryPoint implements AuthenticationEntryPoint{
	
	@Override
	public void commence(HttpServletRequest httpServletRequest,HttpServletResponse httpServletResponse,AuthenticationException e){
		ResponseUtil.out(httpServletResponse,R.error());
	}
}

认证和授权自定义过滤器

public class TokenLoginFilter extends UsernamePasswordAuthentiocationFilter{

	private TokenManager tokenManager;
	private RedisTemplate redisTemplate;
	private AuthenticationManager authenticationManager;

	//有参构造和无参构造（略）
	//构造函数中同时设定
	
	//获取表单提供的用户名和密码
	@Override
	public Authentication attemptAuthentication(HttpServletRequest request,HttpServletResponse response) throws AuthenticationException{
		try{
			User user = new ObjectMapper().readValue(request.getInputStream(),User.class);
			return authenticationManager.authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(),user.getPassword(),new ArrayList<>())	);
		}catch(){}
	}

	//认证成功调用的方法
	@Override
	protected void seccessFulAuthentication(HttpServletRequest requeest,HttpervletResponse response,FilterChain chain,Authentication authResult) throws IOException,ServletException{
		//认证成功，得到用户信息
		SecurityUser user = (SecurityUser)authResult.getPrincipal();
		//根据用户生成token
		String token = tokenManager.createToken(user.getCurrentUerInfo().username());
		
	}

	//认证失败调用的方法
	@Override
	protected void unsuccessfulAuthentication(HttpServletRequest request,HttpServletResponse response,uthenticationException failed)throws IOException,ServletException{

	}
}

=============================================

工具类

public class AuthUtils{
	
	public static Authentication getPrincipal(){
		return SecurityContextHolder.getContext().getAuthentication();
	}
}

/**
	controller中进行应用
*/
@PostMapping("/app/user/coupons")
public Response<List<CouponResponse>> coupons(){
	LoginUser principal = (LoginUser) AuthUtils.getPrincipal().getPrincipal();
	return appDiscountCouponService.queryCoupons(principal.getId());
}

================================================================

SpringSecurity变成前后端分离，采用JWT做认证

什么是有状态：

有状态服务，即服务端需要记录每次会话的客户端信息，从而识别客户端身份，根据用户身份进行请求的处理，典型的设计如 Tomcat 中的 Session。例如登录：用户登录后，我们把用户的信息保存在服务端 session 中，并且给用户一个 cookie 值，记录对应的 session，然后下次请求，用户携带 cookie 值来（这一步有浏览器自动完成），我们就能识别到对应 session，从而找到用户的信息。这种方式目前来看最方便，但是也有一些缺陷，如下：

  • 服务端保存大量数据，增加服务端压力
  • 服务端保存用户状态，不支持集群化部署

什么是无状态：

微服务集群中的每个服务，对外提供的都使用 RESTful 风格的接口。而 RESTful 风格的一个最重要的规范就是：服务的无状态性，即：

  • 服务端不保存任何客户端请求者信息
  • 客户端的每次请求必须具备自描述信息，通过这些信息识别客户端身份
  • 客户端请求不依赖服务端的信息，多次请求不需要必须访问到同一台服务器
  • 服务端的集群和状态对客户端透明
  • 服务端可以任意的迁移和伸缩（可以方便的进行集群化部署）
  • 减小服务端存储压力

无状态登录的流程：

  • 首先客户端发送账户名、密码到服务端进行认证
  • 认证通过后，服务端将用户信息加密并且编码成一个 token，返回给客户端
  • 以后客户端每次发送请求，都需要携带认证的 token
  • 服务端对客户端发送来的 token 进行解密，判断是否有效，并且获取用户登录信息

JWT，全称是 Json Web Token

轻量级的授权和身份认证规范，可实现无状态、分布式的 Web 应用授权：

常用的 Java 实现是 GitHub 上的开源项目 jjwt，地址如下：https://github.com/jwtk/jjw
在这里插入图片描述

JWT包含三部分数据：

①、Header：头部，通常头部有两部分信息（对头部进行 Base64Url 编码（可解码），得到第一部分数据）

  • 声明类型，这里是JWT
  • 加密算法，自定义

②、Payload：载荷，就是有效数据，在官方文档中(RFC7519)，这里给了7个示例信息：（这部分也会采用 Base64Url 编码，得到第二部分数据）

  • iss (issuer)：表示签发人
  • exp (expiration time)：表示token过期时间
  • sub (subject)：主题
  • aud (audience)：受众
  • nbf (Not Before)：生效时间
  • iat (Issued At)：签发时间
  • jti (JWT ID)：编号

③、Signature：签名，是整个数据的认证信息。一般根据前两步的数据，再加上服务的的密钥secret（密钥保存在服务端，不能泄露给客户端），通过 Header 中配置的加密算法生成。用于验证整个数据完整和可靠性。

生成的数据格式如下图：（这里的数据通过 . 隔开成了三部分，分别对应前面提到的三部分，另外，这里数据是不换行的，图片换行只是为了展示方便而已）
在这里插入图片描述

JWT交互流程
在这里插入图片描述

  1. 应用程序或客户端向授权服务器请求授权
  2. 获取到授权后，授权服务器会向应用程序返回访问令牌
  3. 应用程序使用访问令牌来访问受保护资源（如 API）

因为 JWT 签发的 token 中已经包含了用户的身份信息，并且每次请求都会携带，这样服务的就无需保存用户信息，甚至无需去数据库查询，这样就完全符合了 RESTful 的无状态规范

存在的问题：

  • 续签问题，这是被很多人诟病的问题之一，传统的 cookie+session 的方案天然的支持续签，但是 jwt 由于服务端不保存用户状态，因此很难完美解决续签问题，如果引入 redis，虽然可以解决问题，但是 jwt 也变得不伦不类了。
  • 注销问题，由于服务端不再保存用户信息，所以一般可以通过修改 secret 来实现注销，服务端 secret 修改后，已经颁发的未过期的 token 就会认证失败，进而实现注销，不过毕竟没有传统的注销方便。
  • 密码重置，密码重置后，原本的 token 依然可以访问系统，这时候也需要强制修改 secret。
  • 基于第 2 点和第 3 点，一般建议不同用户取不同 secret。

5个handler

  • 实现AuthenticationEntryPoint接口，当匿名请求需要登录的接口时拦截处理
  • AuthentiocationSuccessHandler接口，当登录成功后，该处理类的方法被调用
  • AuthenticationFailureHandler接口，当登录失败后，该处理类的方法被调用
  • AccessDeniedHandler接口，当登陆后，访问接口没有权限的时候该处理类的方法被调用
  • LogoutSuccessHandler接口，注销的时候调用

1个filter OncePerRequestFilter

前端发起请求的时候将token放在请求头中，在过滤器中对请求头进行解析

  • 如果有accessToken的请求头，取出token，解析成功，将解析出来的用户信息放到SpringSecurity的上下文中
  • 如果有accessToken的请求头，解析失败（无效token，或者过期失效）取不到用户信息，则放行
  • 没有accessToken的请求头，放行

AuthenticationEntryPoint

匿名未登录的时候访问，遇到需要登录认证的时候被调用

@Component
public class CustomerAuthenticationEntryPoint implements AuthentiocationEntryPoint{
	
	@Override
	 public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException, ServletException {
     //设置response状态码，返回错误信息等
     ...
        ResponseUtil.out(401, ResultUtil.failure(ErrorCodeConstants.REQUIRED_LOGIN_ERROR));
    }
}

AuthenticationSuccessHandler

输入用户名和密码认证成功后，调用的方法
获取用户信息，使用JWT生成token，然后返回token

@Slf4j
@Component
public class CustomerAuthentiocationSuccessHandler implements AuthenticationSuccessHandler{
	
	@Override
	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
		//获取当前用户，拿到用户名或者userId，创建token
		log.info("登录成功……");
		CustomerUserDetails principal = (CustomerUserDetails)authentication.getPrincipal();
		
		//颁发token
		Map<String,Object> emptyMap = new HashMap<>(4);
		emptyMap.put(UserConstants.USER_ID,principal.getId());

		String token = JwtTokenUtil.generateToken(principal.getUsername(),emptyMap);
		ResponseUtil.out(ResultUtil.success(token));
	}
}

AuthenticationFailureHandler

登录失败调用该方法

@Slf4j
@Component
public class CustomerAuthenticationFailHandler implements AuthenticationFailureHandler{
	
	@Override
	public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException e) throws IOException, ServletException {
	
		//设置response状态码，返回错误信息等
     ....
        ResponseUtil.out(401, ResultUtil.failure(ErrorCodeConstants.LOGIN_UNMATCH_ERROR));
	}
}

LogoutSuccessHandler

退出登录的时候调用
JWT无法主动控制失效，可以采用JWT+session方式，比如删除存在在Redis的token

@Component
public class CustomerLogoutSuccessHandler implements LogoutSuccessHandler {
    @Override
    public void onLogoutSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        ResponseUtil.out(ResultUtil.success("Logout Success!"));
    }
}

AccessDeniedHandler

登录之后，访问缺失权限的资源会调用

@Component
@Slf4j
public class CustomerRestAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException) {
        ResponseUtil.out(403, ResultUtil.failure(ErrorCodeConstants.PERMISSION_DENY));
    }

}

OncePerRequestFilter

过滤器,在请求过来的时候,解析请求头中的token,再解析token得到用户信息,再存到SecurityContextHolder中

@Component
@Slf4j
public class CustomerJwtAuthenticationTokenFilter extends OncePerRequestFilter{
	
	@Autowired
	CustomerUserDetailService customerUserDetailService;
	
	@Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException {
    	
    	String authHeader = request.getHeader(SecurityConstants.HEADER);

		if(authHeader != null && authHeader.startsWith(SecurityConstants.TOKEN_SPLIT)){
			 UserDetails userDetails = customerUserDetailService.loadUserByUsername(username);
                if (userDetails != null) {
                    UsernamePasswordAuthenticationToken authentication =
                            new UsernamePasswordAuthenticationToken(userDetails, userDetails.getPassword(), userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
		}
    }
    
}

配置WebSecurityConfigurerAdapter

将handler和filter注册到SpringSecurity中，同时配置一些放行的url

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(securedEnabled = true, prePostEnabled = true)// 控制@Secured权限注解
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

  /**
   * 这里需要交给spring注入,而不是直接new
   */
  @Autowired
  private PasswordEncoder passwordEncoder;
  @Autowired
  private CustomerUserDetailService customerUserDetailService;
  @Autowired
  private CustomerAuthenticationFailHandler customerAuthenticationFailHandler;
  @Autowired
  private CustomerAuthenticationSuccessHandler customerAuthenticationSuccessHandler;
  @Autowired
  private CustomerJwtAuthenticationTokenFilter customerJwtAuthenticationTokenFilter;
  @Autowired
  private CustomerRestAccessDeniedHandler customerRestAccessDeniedHandler;
  @Autowired
  private CustomerLogoutSuccessHandler customerLogoutSuccessHandler;
  @Autowired
  private CustomerAuthenticationEntryPoint customerAuthenticationEntryPoint;


 
  /**
   * 该方法定义认证用户信息获取的来源、密码校验的规则
   *
   * @param auth
   * @throws Exception
   */
  @Override
  protected void configure(AuthenticationManagerBuilder auth) throws Exception {
    //auth.authenticationProvider(myauthenticationProvider)  自定义密码校验的规则

    //如果需要改变认证的用户信息来源，我们可以实现UserDetailsService
    auth.userDetailsService(customerUserDetailService).passwordEncoder(passwordEncoder);
  }


  @Override
  protected void configure(HttpSecurity http) throws Exception {
    /**
     * antMatchers: ant的通配符规则
     * ? 匹配任何单字符
     * * 匹配0或者任意数量的字符，不包含"/"
     * ** 匹配0或者更多的目录，包含"/"
     */
    http
            .headers()
            .frameOptions().disable();

    http
            //登录后,访问没有权限处理类
            .exceptionHandling().accessDeniedHandler(customerRestAccessDeniedHandler)
            //匿名访问,没有权限的处理类
            .authenticationEntryPoint(customerAuthenticationEntryPoint)
    ;

    //使用jwt的Authentication,来解析过来的请求是否有token
    http
            .addFilterBefore(customerJwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);


    http
            .authorizeRequests()
            //这里表示"/any"和"/ignore"不需要权限校验
            .antMatchers("/ignore/**", "/login", "/**/register/**").permitAll()
            .anyRequest().authenticated()
            // 这里表示任何请求都需要校验认证(上面配置的放行)


            .and()
            //配置登录,检测到用户未登录时跳转的url地址,登录放行
            .formLogin()
            //需要跟前端表单的action地址一致
            .loginProcessingUrl("/login")
            .successHandler(customerAuthenticationSuccessHandler)
            .failureHandler(customerAuthenticationFailHandler)
            .permitAll()

            //配置取消session管理,又Jwt来获取用户状态,否则即使token无效,也会有session信息,依旧判断用户为登录状态
            .and()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)

            //配置登出,登出放行
            .and()
            .logout()
            .logoutSuccessHandler(customerLogoutSuccessHandler)
            .permitAll()
            
            .and()
            .csrf().disable()
    ;
  }


}

实战

一、创建一个项目（添加 Spring Security 依赖，添加 jjwt 依赖）

<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>io.jsonwebtoken</groupId>
    <artifactId>jjwt</artifactId>
    <version>0.9.1</version>
</dependency>

二、创建用户对象

public class User implements UserDetails {

    private String username;
    private String password;
    private List<GrantedAuthority> authorities;
    
    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;
    }
    //省略getter/setter
}

三、Controller接口

设计是 /hello 接口可以被具有 user 角色的用户访问，
而 /admin 接口则可以被具有 admin 角色的用户访问

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "hello jwt !";
    }
    @GetMapping("/admin")
    public String admin() {
        return "hello admin !";
    }
}

四、JWT过滤器

  • 一个是用户登录的过滤器，在用户的登录的过滤器中校验用户是否登录成功，如果登录成功，则生成一个token返回给客户端，登录失败则给前端一个登录失败的提示。
  • 第二个过滤器则是当其他请求发送来，校验token的过滤器，如果校验成功，就让请求继续执行。
public class JwtLoginFilter extends AbstractAuthenticationProcessingFilter{
	
	protected JwtLoginFilter(String defaultFilterProcessesUrl,AuthenticationManager authenticationManager){
		super(new AntPathRequestMatcher(defaultFilterProcessesUrl));
        setAuthenticationManager(authenticationManager);
	}

	/**
		从登录参数中提取出用户名密码，然后调用 AuthenticationManager.authenticate() 方法去进行自动校验
	*/
	@Override
	public Authentication attemptAuthentication(HttpServletRequest req, HttpServletResponse resp) 
	 	throws AuthenticationException, IOException, ServletException {
		
		User user = new ObjectMapper().readValue(req.getInputStream(), User.class);
	    return getAuthenticationManager()
	       .authenticate(new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword()));
	}

	/**
		如果校验成功，就会来到 successfulAuthentication 回调中，在 successfulAuthentication 方法中，将用户角色遍历然后用一个 , 连接起来，
		然后再利用 Jwts 去生成 token，按照代码的顺序，生成过程一共配置了四个参数，分别是用户角色、主题、过期时间以及加密算法和密钥，
		然后将生成的 token 写出到客户端
	*/
	@Override
    protected void successfulAuthentication(HttpServletRequest req, 
    										HttpServletResponse resp,
    										FilterChain chain, 
    										Authentication authResult)
     	throws IOException, ServletException {
		
		Collection<? extends GrantedAuthority> authorities = authResult.getAuthorities();

		StringBuffer as = new StringBuffer();
		for(GrantedAuthority authority : authorities){
			as.append(authority.getAuthority())
                    .append(",");
		}

		//Jwts 去生成 token
		String jwt = Jwts.builder()
			.claim("authorities",as)//配置用户角色
			.setSubject(authResult.getName())
			.setExpiration(new Date(System.currentTimeMillis()+ 10 * 60 * 1000))
			.signWith(SignatureAlgorithm.HS512,"sang@123")
            .compact();

		//将生成的 token 写出到客户端
		resp.setContentType("application/json;charset=utf-8");
        PrintWriter out = resp.getWriter();
        out.write(new ObjectMapper().writeValueAsString(jwt));
        out.flush();
        out.close();
	}
	
	/**
		校验失败就会来到 unsuccessfulAuthentication 方法中，在这个方法中返回一个错误提示给客户端即可
	*/
	protected void unsuccessfulAuthentication(HttpServletRequest req, HttpServletResponse resp, AuthenticationException failed) 
					throws IOException, ServletException {
        resp.setContentType("application/json;charset=utf-8");
        PrintWriter out = resp.getWriter();
        out.write("登录失败!");
        out.flush();
        out.close();
    }
}

public class JwtFilter extends GenericFilterBean{
	
	@Override
	public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain)
		 throws IOException, ServletException {

		//首先从请求头中提取出 authorization 字段，这个字段对应的 value 就是用户的 token
		HttpServletRequest req = (HttpServletRequest) servletRequest;
        String jwtToken = req.getHeader("authorization");
        System.out.println(jwtToken);
        
        //将提取出来的 token 字符串转换为一个 Claims 对象
        Claims claims = Jwts.parser().setSigningKey("sang@123").parseClaimsJws(jwtToken.replace("Bearer",""))
                .getBody();
        String username = claims.getSubject();//获取当前登录用户名
        List<GrantedAuthority> authorities = AuthorityUtils.commaSeparatedStringToAuthorityList((String) claims.get("authorities"));//获取用户角色

		//创建一个 UsernamePasswordAuthenticationToken 放到当前的 Context 中，然后执行过滤链使请求继续执行下去
        UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(username, null, authorities);
        SecurityContextHolder.getContext().setAuthentication(token);
        filterChain.doFilter(req,servletResponse);
	}
}

五、SpringSecurity配置

@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
	
	/**
		未对密码进行加密，因此配置了 NoOpPasswordEncoder 的实例
	*/
	@Bean
	PasswordEncoder passwordEncoder(){
		return NoOpPasswordEncoder.getInstance();
	}

	/**
		未连接数据库，在内存中配置了两个用户，两个用户具备不同的角色。
	*/
	@Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication().withUser("admin")
                .password("123").roles("admin")
                .and()
                .withUser("sang")
                .password("456")
                .roles("user");
    }

	/**
		配置路径规则时， /hello 接口必须要具备 user 角色才能访问， /admin 接口必须要具备 admin 角色才能访问，
		POST 请求并且是 /login 接口则可以直接通过，其他接口必须认证后才能访问。
	*/
	 @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/hello").hasRole("user")
                .antMatchers("/admin").hasRole("admin")
                .antMatchers(HttpMethod.POST, "/login").permitAll()
                .anyRequest().authenticated()
                .and()
                .addFilterBefore(new JwtLoginFilter("/login",authenticationManager()),UsernamePasswordAuthenticationFilter.class)
                .addFilterBefore(new JwtFilter(),UsernamePasswordAuthenticationFilter.class)
                .csrf().disable();//最后配置上两个自定义的过滤器并且关闭掉 csrf 保护
    }
}

六、测试
在这里插入图片描述

登录成功后返回的字符串就是经过 base64url 转码的 token，一共有三部分，通过一个 . 隔开，我们可以对第一个 . 之前的字符串进行解码，即 Header，如下：
在这里插入图片描述
再对两个 . 之间的字符解码，即 payload：
在这里插入图片描述
设置信息，由于 base64 并不是加密方案，只是一种编码方案，因此，不建议将敏感的用户信息放到 token 中
接下来再去访问 /hello 接口，注意认证方式选择 Bearer Token，Token 值为刚刚获取到的值，如下：
在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1233354.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

buildAdmin 后端控制器的代码分析

buildAdmin 后端控制器的代码分析

buildAdmin的代码生成&#xff0c;很像是 fastadmin 的生成模式&#xff0c;当我们利用数据库生成了一个控制器的时候&#xff0c;我们可以看到&#xff0c; 它的生成代码很简洁 <?phpnamespace app\admin\controller\askanswer;use app\common\controller\Backend;/*** 回…
阅读更多...
在Spring Boot中使用Thymeleaf开发Web页面

在Spring Boot中使用Thymeleaf开发Web页面

引言&#xff1a; 为啥写这篇文章呢&#xff1f;我明明就没怎么用过这个Thymeleaf进行web开发&#xff0c;用JSP也行&#xff0c;三剑客也行&#xff0c;或者Vue&#xff0c;React&#xff0c;PHP等等&#xff0c;不好吗&#xff1f; 那我为啥写这篇博客呢&#xff1f;这个写了…
阅读更多...
1445 雉兔同笼

1445 雉兔同笼

Tint(input()) for i in range(T):s input().split()head int(s[0])foot int(s[1])rabbitfoot/2-headchicken2*head-foot/2if rabbit>0 and chicken>0 and rabbit.is_integer():print(int(chicken),int(rabbit))else:print(-1)
阅读更多...
Playcanvas后处理-辉光bloom

Playcanvas后处理-辉光bloom

&#xff08;一&#xff09;Bloom介绍 Bloom&#xff08;辉光、光晕、泛光&#xff09;是一种常见的摄像机后处理&#xff08;PostProcessing&#xff09;效果&#xff0c;用于再现真实世界相机的成像伪影。这种效果会产生从图像中明亮区域边界延伸的光条纹&#xff08;或羽毛…
阅读更多...
亚马逊车灯外贸出口CE认证标准办理解析

亚马逊车灯外贸出口CE认证标准办理解析

车灯是车辆夜间行驶在道路照明的工具&#xff0c;也是发出各种车辆行驶信号的提示工具。车灯一般分为前照灯、尾灯、转向灯等。车灯出口欧盟需要办理CE认证。 CE认证是欧盟对进入欧洲市场的产品强制性的认证标志&#xff0c;是指符合欧盟安全、健康、环境保护等标准和要求的产…
阅读更多...
美容仪器经营小程序商城的作用如何

美容仪器经营小程序商城的作用如何

美容仪器可以包含剃须刀、微针仪、微晶笔等&#xff0c;除了美容美业机构需要外&#xff0c;在家庭中也有不小的需求&#xff0c;对产品经营商家来说除了满足客户线下订购的需求外&#xff0c;还需要线上拓展更广的客群及多场景客户在线消费。 入驻第三方平台是商家们首先考虑…
阅读更多...
mricorn 手动勾画ROI并保存为模版的方法步骤

mricorn 手动勾画ROI并保存为模版的方法步骤

mricorn软件手动勾画ROI&#xff1a; 这里拿一个做了切除手术的癫痫病人举例子&#xff0c;我们需要把切除区域勾画出来并保存成切除的模版。 1、将图像导入到mricorn中 2、逐层勾画ROI并填充 比较方便的是从切除区域的起始层进行勾画&#xff0c;这里为了方便展示只勾画中间…
阅读更多...
【操作系统】文件系统之文件共享与文件保护

【操作系统】文件系统之文件共享与文件保护

文章目录 文件共享硬链接软链接 文件保护口令保护加密保护访问控制 文件共享 为了实现文件的共享&#xff0c;引入了“计数器”字段&#xff0c;当一个文件每被一个用户所共享&#xff0c;那么计数器就加一。如果一个用户删除文件&#xff0c;计数器相应的减一。如果计数器为0…
阅读更多...
ITIL® 4 Foundation​，即将开课~想了解点击查看

ITIL® 4 Foundation​，即将开课~想了解点击查看

ITIL 4 Foundation 即将开课~ 想报名的必须提前预约啦 &#x1f447;&#x1f447;&#x1f447; 2 0 23 年 培训地点&#xff1a; 远程直播&#xff1a;线上平台学习 开课时间&#xff1a; 周末班&#xff1a;11月25日、26日&#xff1b; 什么是ITIL&#xff1f; 信息技…
阅读更多...
数据仓库架构之详解Kappa和Lambda

数据仓库架构之详解Kappa和Lambda

目录 一、前言 二、架构详解 1 Lambda 架构 1.1 Lambda 架构组成 1.2 Lambda 特点 1.3 Lambda 架构的优点 1.4 Lambda 架构的不足 2 Kappa 架构 2.1 Kappa 架构的核心组件 2.2 Kappa 架构优点 2.3 Kappa 架构的注意事项 三、区别对比 四、选择时考虑因素 一、前言 …
阅读更多...
鸿蒙原生应用/元服务开发-AGC分发如何配置版本信息（上）

鸿蒙原生应用/元服务开发-AGC分发如何配置版本信息（上）

1.配置HarmonyOS应用的“发布国家或地区”。 2.设置是否为开放式测试版本。 注意&#xff1a;HarmonyOS应用开放式测试当前仅支持手机、平板、智能手表。如开发者想发布为开放式测试版本&#xff0c;选择“是”。正式发布的版本请选择“否”。 3.在“软件版本”下点击“软件包…
阅读更多...
商品购物管理与推荐系统Python+Django网页界面+协同过滤推荐算法

商品购物管理与推荐系统Python+Django网页界面+协同过滤推荐算法

一、介绍 商品管理与推荐系统。本系统使用Python作为主要开发语言&#xff0c;前端采用HTML、CSS、BootStrap等技术搭建显示界面&#xff0c;后端采用Django框架处理用户的请求响应。 创新点&#xff1a;使用协同过滤算法&#xff0c;以用户对商品的评分作为依据&#xff0c;在…
阅读更多...
5款免费BI数据可视化工具，2023年最新精选推荐！

5款免费BI数据可视化工具，2023年最新精选推荐！

BI可视化工具顾名思义是进行数据分析和可视化的软件&#xff0c;旨在将数据以表格、图表、仪表盘等形式展示出来&#xff0c;让用户能够更加直观了解其业务状况、发现问题&#xff0c;并在必要时进行决策。   市面上BI数据可视化工具很多&#xff0c;目前比较火的像国外的Tabl…
阅读更多...
【原创】为MybatisPlus增加一个逻辑删除插件，让XML中的SQL也能自动增加逻辑删除功能

【原创】为MybatisPlus增加一个逻辑删除插件，让XML中的SQL也能自动增加逻辑删除功能

前言 看到这个标题有人就要说了&#xff0c;D哥啊&#xff0c;MybatisPlus不是本来就有逻辑删除的配置吗&#xff0c;比如TableLogic注解&#xff0c;配置文件里也能添加如下配置设置逻辑删除。 mybatis-plus:mapper-locations: classpath*:mapper/*.xmlconfiguration:mapUnd…
阅读更多...
《活着》思维导图

《活着》思维导图

今天给大家分享的这部作品的题目叫“活着”&#xff0c;作为一个词语&#xff0c;“活着”在我们中国的语言里充满了力量&#xff0c;它的力量不是来自于喊叫&#xff0c;也不是来自于进攻&#xff0c;而是忍受&#xff0c;去忍受生命赋予我们的责任&#xff0c;去忍受现实给予…
阅读更多...
模型性能评估（第三周）

模型性能评估（第三周）

一、模型评估 把数据集划分成训练集和测试集&#xff0c;用训练集训练模型和参数&#xff0c;然后在测试集上测试他的表现。如下图所示&#xff0c;第一行是线性回归通常的代价函数形式&#xff0c;我们需要将其最小化来获取参数、b。训练好模型&#xff0c;获得参数后&#x…
阅读更多...
用iPad记笔记？这10款笔记软件让你事半功倍！

用iPad记笔记？这10款笔记软件让你事半功倍！

最好的笔记软件可以让你在任何地方轻松记下笔记&#xff0c;无论是关于想法、业务见解&#xff0c;还是提醒事项。 笔记软件越来越受欢迎&#xff0c;尤其是随着移动设备的广泛普及&#xff0c;尤其是商务智能手机和平板设备iPad的普及。这意味着现在用于记笔记的移动应用程序…
阅读更多...
每天分享五款工具，让大家工作生活更顺心

每天分享五款工具，让大家工作生活更顺心

​ 快乐不是在于拥有什么,而在于我们和别人分享什么。每天分享五款工具&#xff0c;让大家工作办公更顺心就是我最大的快乐。 1.沙盒软件——Sandboxie ​ Sandboxie是一款可以在沙盒中运行程序的软件&#xff0c;它可以保护用户的系统和数据免受恶意软件、病毒和其他威胁的影…
阅读更多...
Keithley2420吉时利2420数字源表

Keithley2420吉时利2420数字源表

Keithley2420吉时利2420数字源表系列&#xff0c;专用于要求紧密结合源和测量的测试应用。全部数字源表型号都提供精密电压源和电 流源以及测量功能。每款数字源表既是高度稳定的直流 电源也是真仪器级的6位半万用表。此电源的特性包括 低噪声、精密和回读。此万用表的功能包括…
阅读更多...
PGFNet

PGFNet

方法 MFRM means ‘multi-modal feature refinement mechanism’&#xff0c;MMAFM means ‘multi-modal and multi-scale attention fusion model’&#xff0c;RPM means ‘residual prediction module’ scale attention weights U R S _R^S RS​,U D S _D^S DS​ enhan…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023