spring security6+springboot3+jwt实现权限控制

最新推荐文章于 2024-05-20 22:57:28 发布
最新推荐文章于 2024-05-20 22:57:28 发布
阅读量933 收藏 12
点赞数 9
文章标签： spring java mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68534248/article/details/136735305
版权

maven配置

myabits-plus,redis,lombok,hutool

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.0.5</version>
        <relativePath/> <!-- lookup parent from repository -->
</parent>
 
 
<properties>
        <java.version>17</java.version>
    </properties>
 
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
 
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>


        <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>
        <!--        redis依赖start-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>
        <dependency>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.8.16</version>
        </dependency>

        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-api</artifactId>
            <version>0.11.5</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-impl</artifactId>
            <version>0.11.5</version>
        </dependency>
        <dependency>
            <groupId>io.jsonwebtoken</groupId>
            <artifactId>jjwt-jackson</artifactId>
            <version>0.11.5</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.baomidou/mybatis-plus-boot-starter -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.3</version>
        </dependency>
        <!-- Mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>
    </dependencies>

授权核心类配置

spring security的核心配置，包含了自定义的鉴权

@Configuration
@RequiredArgsConstructor
public class AuthConfig {
 

    /**
     * 自定义的权限读取类
     */
    private final MyUserDetailService myUserDetailService;
 

    /**
     * springsecurity权限校验提供类
     
     * @return
     */
    @Bean
    public AuthenticationProvider authenticationProvider() {
        DaoAuthenticationProvider authProvider = new DaoAuthenticationProvider();
        //使用自定义的用户校验
        authProvider.setUserDetailsService(myUserDetailService);
        authProvider.setPasswordEncoder(passwordEncoder());
        return authProvider;
    }
 
    
    
    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
 
    /**
     * 密码加密
     *
     * @return
     */
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

MyUserDetailService 自定义的权限读取类
AuthenticationProvider 提供权限校验方法类，把MyUserDetailService类和PasswordEncoder 类作为入参，实现自定义权限校验

AuthenticationManager 鉴权工具的管理bean，用默认提供的就行

PasswordEncoder 使用BCryptPasswordEncoder作为我们密码加密的方法

用户详细权限获取类

MyUserDetailService是我们实现自定义权限认证的核心方法之一，通过实现UserDetailsService的loadUserByUsername方法实现获取用户拥有的详细权限，然后springsecurity框架会帮助我们对需要拦截的请求进行权限校验

创建我们的一个用户类，然后实现UserDetails接口，UserDetails是springsecurity框架的授权用户实体，我们需要继承这个接口才能让框架去为我们实现权限校验，这两个类都需要去继承框架的接口，这样才能让框架帮我们管理

 
##class MyUserDetailService 
 
 
@RequiredArgsConstructor
@Service
@Slf4j
public class MyUserDetailService implements UserDetailsService, UserDetailsPasswordService {
 
 
    //获取当前用户的方法，使用框架的上下文获取当前请求的用户
    public static Authentication getCurrentUser() {
        return SecurityContextHolder.getContext().getAuthentication();
    }
 
    //刷新密码，如果用户更改密码了会重新刷新token或者退出登录，我也没用过，大家可以试一下
    @Override
    public UserDetails updatePassword(UserDetails user, String newPassword) {
        return null;
    }
 
    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        log.info("进入查找用户的方法");
        UserDO userDO = new UserDO().selectOne(new LambdaQueryWrapper<UserDO>().eq(UserDO::getUsername, username));
        if (userDO != null) {
            //从数据库中获取用户，真实环境下需要获取用户拥有的权限，现在我们就先写死
            Set<SimpleGrantedAuthority> permissions = Set.of("admin:read", "admin:create", "admin:update", "admin:delete").stream().map(permission -> new SimpleGrantedAuthority(permission)).collect(Collectors.toSet());
            //返回生成的用户
            var sysUser = new SysUser().setId(1).setPassword(userDO.getPassword()).setUsername(username).setAuthorities(permissions);
            return sysUser;
        }
        return null;
 
    }
}
 
 
##class SysUser 
 
@Data
@NoArgsConstructor
@AllArgsConstructor
@Accessors(chain = true)
public class SysUser implements UserDetails, Serializable {
 
    private Integer id;
 
    private String username;
 
    private String password;
 
 
    //该用户所拥有的权限，如果细分为角色和权限，可以把两个都放到这个集合里面，比如ROLE_ADMIN,admin:user:create可以同时存入
    private Collection<? extends GrantedAuthority> authorities;
 
 
 
    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return this.authorities;
    }
 
    @Override
    public String getPassword() {
        return this.password;
    }
 
    @Override
    public String getUsername() {
        return this.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;
    }
}

JWT加解密方法

JWT (全称：Json Web Token)是一个开放标准(RFC 7519)，它定义了一种紧凑的、自包含的方式，用于作为 JSON 对象在各方之间安全地传输信息。该信息可以被验证和信任，因为它是数字签名的。开发者可以将在每个服务间传递的信息（比如用户的id，name，权限集合等）通过加密生成一个token，然后在服务端解析出这个token就可以获取到这个请求携带的用户的信息。

可以通过JwtService类来对token进行加解密


##application.yml
 
application:
  security:
    jwt:
      secret-key: 404E635266556A586E3272357538782F413F4428472B4B6250645367566B5970
      expiration: 86400000 # a day
      refresh-token:
        expiration: 604800000 # 7 days
 
 
 
 
 
 
 
 
## class JwtService
 
 
@Service
public class JwtService {
 
  @Value("${application.security.jwt.secret-key}")
  private String secretKey;
  @Value("${application.security.jwt.expiration}")
  private long jwtExpiration;
  @Value("${application.security.jwt.refresh-token.expiration}")
  private long refreshExpiration;
 
  public String extractUsername(String token) {
    return extractClaim(token, Claims::getSubject);
  }
 
  public <T> T extractClaim(String token, Function<Claims, T> claimsResolver) {
    final Claims claims = extractAllClaims(token);
    return claimsResolver.apply(claims);
  }
 
  public String generateToken(UserDetails userDetails) {
    return generateToken(new HashMap<>(), userDetails);
  }
 
  public String generateToken(
      Map<String, Object> extraClaims,
      UserDetails userDetails
  ) {
    return buildToken(extraClaims, userDetails, jwtExpiration);
  }
 
  public String generateRefreshToken(
      UserDetails userDetails
  ) {
    return buildToken(new HashMap<>(), userDetails, refreshExpiration);
  }
 
  private String buildToken(
          Map<String, Object> extraClaims,
          UserDetails userDetails,
          long expiration
  ) {
    return Jwts
            .builder()
            .setClaims(extraClaims)
            .setSubject(userDetails.getUsername())
            .setIssuedAt(new Date(System.currentTimeMillis()))
            .setExpiration(new Date(System.currentTimeMillis() + expiration))
            .signWith(getSignInKey(), SignatureAlgorithm.HS256)
            .compact();
  }
 
  public boolean isTokenValid(String token, SysUser sysUser) {
    final String username = extractUsername(token);
    return (username.equals(sysUser.getUsername())) && !isTokenExpired(token);
  }
 
  private boolean isTokenExpired(String token) {
    return extractExpiration(token).before(new Date());
  }
 
  private Date extractExpiration(String token) {
    return extractClaim(token, Claims::getExpiration);
  }
 
  private Claims extractAllClaims(String token) {
    return Jwts
        .parserBuilder()
        .setSigningKey(getSignInKey())
        .build()
        .parseClaimsJws(token)
        .getBody();
  }
 
  private Key getSignInKey() {
    byte[] keyBytes = Decoders.BASE64.decode(secretKey);
    return Keys.hmacShaKeyFor(keyBytes);
  }
}

SecurityConfig

 
##class SecurityConfig 
 
@Configuration
@EnableWebSecurity
@RequiredArgsConstructor
@EnableMethodSecurity
public class SecurityConfig {
 
 
    /**
     * AuthConfig中自定义的bean
     */
    private final AuthenticationProvider authenticationProvider;
 
    private final JwtFilter jwtFilter;
 
    private final LogoutService logoutService;
 
    private final MyAccessDeniedHandler myAccessDeniedHandler;
 
 
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                .csrf()//关闭session
                .disable()
                .authorizeHttpRequests()
                .requestMatchers("/api/v1/auth/**")//  放行/api/v1/auth/下的所有请求，主要是登录登出
                .permitAll()
 
                .anyRequest()
                .authenticated()//  剩下的请求都需要拦截
                .and()
                .exceptionHandling()
                .accessDeniedHandler(myAccessDeniedHandler) //  配置无权访问的处理
                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authenticationProvider(authenticationProvider)//  使用我们自定义的权限查询校验方法
                .addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class) //  配置请求拦截
                .logout()
                .logoutUrl("/api/v1/auth/logout") //   配置登出路径
                .addLogoutHandler(logoutService)
                .logoutSuccessHandler((request, response, authentication) -> SecurityContextHolder.clearContext()) // 登出后清楚请求的上下文，也就是用户信息
        ;
 
        return http.build();
    }
}
 
 
##class LogoutService
 
/**
 * 登出具体实现类
 */
@Component
public class LogoutService implements LogoutHandler {
 
 
    /**
     * 登出实现
     * @param request
     * @param response
     * @param authentication
     */
    @Override
    public void logout(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
        //先获取token
        final String authHeader = request.getHeader("Authorization");
        final String jwt;
        if (authHeader == null ||!authHeader.startsWith("Bearer ")) {
            return;
        }
        jwt = authHeader.substring(7);
        //从db或者redis中获取token并且对比
        TokenDO tokenDO = new TokenDO().selectOne(new LambdaQueryWrapper<TokenDO>().eq(TokenDO::getToken, jwt));
        if (tokenDO != null) {
            tokenDO.setExpired(true);
            tokenDO.setRevoked(true);
            tokenDO.insertOrUpdate();
            SecurityContextHolder.clearContext();
        }
 
    }
}
 
 
##class MyAccessDeniedHandler
 
 
/**
 * 自定义无权访问处理类
 */
@Component
public class MyAccessDeniedHandler implements AccessDeniedHandler {
 
 
    @Override
    @SneakyThrows(UnAuthorizationException.class)
    public void handle(HttpServletRequest request, HttpServletResponse response, AccessDeniedException accessDeniedException)  {
        //这里是想直接抛出一个无权访问的异常然后全局捕捉，但是不知道为什么没有捕捉到
        throw new UnAuthorizationException();
    }
}

springsecurity相关的一些配置都已经完成

用户相关类

用户实体类,同时需要写一个mapper来对应实体类 

##  class   UserDO
@Data
@TableName("sys_user")
@EqualsAndHashCode(callSuper = true)
public class UserDO extends Model<UserDO> {
 
 
    @TableId(type = IdType.AUTO)
    private Integer id;
 
    private String username;
 
    private String password;
 
    private String name;
}
##  class UserMapper
@Repository
public interface UserMapper extends BaseMapper<UserDO> {
}

用户业务处理 

##  class UserService
 
public interface UserService {
 
    AjaxResult login(String username,String password);
}
 
 
 
 
##  class UserServiceImpl
 
 
@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
 
 
    private final PasswordEncoder passwordEncoder;
 
    private final JwtService jwtService;
 
    private final StringRedisTemplate stringRedisTemplate;
 
    private final int tokenTimeOut=60*1000;
 
 
    /**
     * 用户登录
     *
     * @param username
     * @param password
     * @return
     */
    @Override
    public AjaxResult login(String username, String password) {
        //简单测试security内容暂时不考虑校验用户名密码复杂度等
        UserDO userDO = new UserDO().selectOne(new LambdaQueryWrapper<UserDO>().eq(UserDO::getUsername, username));
        //校验密码是否正确
        if (passwordEncoder.matches(password, userDO.getPassword())) {
            //用户校验成功，从数据库中查询出用户的权限，现在为了方便测试直接写死
            Set<SimpleGrantedAuthority> permissions = Set.of("admin:read", "admin:create", "admin:update", "admin:delete").stream().map(permission -> new SimpleGrantedAuthority(permission)).collect(Collectors.toSet());
            //生成用户的token
            var sysUser = new SysUser().setId(1).setPassword(userDO.getPassword()).setUsername(username).setAuthorities(permissions);
            var accssToken = jwtService.generateToken(sysUser);
            var refreshToken = jwtService.generateRefreshToken(sysUser);
            //此处有两个选择，可以把token存到db或者redis中，这里方便演示两个都保存
            new TokenDO().setToken(accssToken).setUserId(userDO.getId()).setRevoked(false).setExpired(false).insert();
            //可以配合jwt设置一个超时时间双重判断是否过期，也可以作为手动使token失效的功能
            stringRedisTemplate.opsForValue().set(StrUtil.format(OauthTestApplication.REDIS_TOKEN_KEY,accssToken), JSONUtil.toJsonStr(sysUser));
 
            //返回生成的两个token
            return AjaxResult.success(TokenResponse.builder().accessToken(accssToken).refreshToken(refreshToken).build());
        }
        return AjaxResult.error();
    }
}

最后是我们的接口控制层

在springsecurity中我们是用@PreAuthorize注解来控制该接口的权限@PreAuthorize("hasAuthority('admin:create')")标识拥有admin:create权限的用户才可以访问

 @RestController
@RequiredArgsConstructor
public class TestController {
 
 
    private final UserService userService;
 
    private final PasswordEncoder passwordEncoder;
 
 
    @PostMapping("/api/v1/auth/login")
    public AjaxResult login(String username, String password) {
        String encode = passwordEncoder.encode("123456");
        return userService.login(username, password);
    }
 
 
    @GetMapping("/api/v1/testAuth")
    @PreAuthorize("hasAuthority('admin:create')")
    public AjaxResult testAuth() {
        System.out.println("当前用户为:" + MyUserDetailService.getCurrentUser().getPrincipal());
        return AjaxResult.success("本接口你有权限");
    }
 
 
    @GetMapping("/api/v1/testUnAuth")
    @PreAuthorize("hasAuthority('admin:noauth')")
    public AjaxResult testUnAuth() {
        System.out.println("当前用户为:" + MyUserDetailService.getCurrentUser().getPrincipal());
        return AjaxResult.success("本接口你没有权限");
    }
 
    @GetMapping("/api/v1/testNoAuth")
    public AjaxResult testNoAuth() {
        System.out.println("当前用户为:" + MyUserDetailService.getCurrentUser().getPrincipal());
        return AjaxResult.success("本接口不需要权限");
    }
 
 
    @RequestMapping("/pass")
    public void pass(String password) {
        System.out.println("生成密码:"+passwordEncoder.encode(password));
    }
}

首先不登录测试我们的三个接口

localhost:8080/api/v1/testAuth

localhost:8080/api/v1/testUnAuth

localhost:8080/api/v1/testNoAuth

可以看到3个接口都没有返回，状态码都是403。403 Forbidden是HTTP协议中的一个状态码(Status Code)。可以理解为没有权限访问此站。该状态表示服务器理解了本次请求但是拒绝执行该任务，该请求不该重发给服务器。

然后我们进行登录操作

localhost:8080/api/v1/auth/login?username=admin&password=123456

 成功获取到token了，在redis中也能看到我们的token信息

 

 

 


                

        

        

    




    

      

        

            

              
                
                  O0o88
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    9
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    12
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  1
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证

				
			

			

				

					08-26
				

			

		

		

			
				
SpringBoot+SpringSecurity+JWT+MybatisPlus实现基于注解的权限验证，可根据注解的格式不同，做到角色权限控制，角色加资源权限控制等，粒度比较细化。 @PreAuthorize("hasAnyRole('ADMIN','USER')")：具有admin或...

			
		

	



                

              
                



	

		

			

				
					
基于Spring Boot 3 + Spring Security6 + JWT + Redis实现登录、token身份认证

				
			

			

				

					程序员雅痞的博客
				

				

					03-28
					
					4380
					
				

			

		

		

			
				
基于Spring Boot3实现Spring Security6 + JWT + Redis实现登录、token身份认证。

			
		

	



                


  
              

                


	

		

			

				
					
SpringSecurity6.x

				
			

			

				

					qq_45726327的博客
				

				

					03-23
					
					1164
					
				

			

		

		

			
				
Spring Security 是一个功能强大且高度可定制的身份验证和访问控制框架。它是保护基于 Spring 的应用程序的事实上的标准。Spring Security 是一个专注于为 Java 应用程序提供身份验证和授权的框架。与所有 Spring 项目一样，Spring Security 的真正强大之处在于它可以轻松扩展以满足自定义需求。实际开发的过程中，我们需要应用程序更加灵活，可以在SpringSecurity中创建自定义配置文件。Java自定义配置用来管理用户信息，

			
		

	





	

		

			

				
					
SpringBoot+SpringSecurity+JWT实现认证和授权

				
			

			

				

					oyc的博客
				

				

					01-17
					
					5万+
					
				

			

		

		

			
				
一、背景：

在 B/S 系统中，登录功基本都是依靠 Cookie 来实现的，用户登录成功之后主要需要客户端和服务端完成以下两项工作：

（1）服务端将登录状态记录到 Session 中，或者签发Token；

（2）客户端利用Cookie保存于服务端对应的 Session ID 或 Token。之后每次请求都会带上Cookie信息(包含Session ID或者Token），当服务端收到请求后，通过验证 Cookie 中的信息来判断用户是否登录 。

单点登录：单点登录（Single Sign On, S.

			
		

	



		

			
		



	

		

			

				
					
Springboot+Spring-Security+JWT 实现用户登录和权限认证

					
热门推荐

				
			

			

				

					congge
				

				

					06-08
					
					26万+
					
				

			

		

		

			
				
如今，互联网项目对于安全的要求越来越严格，这就是对后端开发提出了更多的要求，目前比较成熟的几种大家比较熟悉的模式，像RBAC 基于角色权限的验证，shiro框架专门用于处理权限方面的，另一个比较流行的后端框架是Spring-Security，该框架提供了一整套比较成熟，也很完整的机制用于处理各类场景下的可以基于权限，资源路径，以及授权方面的解决方案，部分模块支持定制化，而且在和oauth2.0进...

			
		

	





	

		

			

				
					
SpringBoot+SpringSecurity+Mybatisplus+JWT实现权限控制

				
			

			

				

					dhklsl的专栏
				

				

					05-11
					
					231
					
				

			

		

		

			
				
看了一篇关于springSecurity的不错的实战blog，代码比较全。

			
		

	





	

		

			

				
					
通用权限管理系统+springboot+mybatis plus+spring security+jwt+redis+mysql

				
			

			

				

					05-30
				

			

		

		

			
				
后端使用SpringBoot框架进行业务逻辑开发，利用Spring Security实现权限控制。数据库采用MySQL进行数据存储，使用MyBatis进行数据访问。 权限控制模块设计包括用户、角色和权限三个主要模块。用户模块用于管理用户...

			
		

	





	

		

			

				
					
springboot+security+jwt+mybaits-plus+mysql实现权限管理

				
			

			

				

					03-13
				

			

		

		

			
				
1.传统spring boot框架 2.security框架 3.jwt取代session 4.mybatis-plus+mysql【sql文件项目中有】 5.不想下载，可以看博客，博客中有写

			
		

	





	

		

			

				
					
Springboot+SpringSecurity+JWT实现用户登录和权限认证示例

				
			

			

				

					08-19
				

			

		

		

			
				
主要介绍了Springboot+SpringSecurity+JWT实现用户登录和权限认证示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧

			
		

	





	

		

			

				
					
springboot+security+mybatis+redis+jwt，鉴权框架搭建

				
			

			

				

					06-22
				

			

		

		

			
				
本项目集成了springboot+security+mybatis+redis+jwt用于学习security鉴权功能，其中有集成了redis，mybatis，jasypt，jwt，thymeleaf，knife4j，mybatis-plus 项目搭建已经比较成熟，能够直接进行使用，通过代码...

			
		

	





	

		

			

				
					
(三)Spring教程——依赖注入与控制反转

				
			

			

				

					
				

				

					05-14
					
					557
					
				

			

		

		

			
				
Spring有两个重要的接口：BeanFactory和ApplicationContext，所谓的容器就是实现了BeanFactory接口或者是ApplicationContext接口的类的实例，BeanFactory是最顶层、最基本的接口，它描述了容器需要实现的最基本的功能，比如对象的注册、获取等。在编写传统的Java应用代码时，我们一般是直接在对象内部通过new来创建对象，让程序主动去创建依赖对象，这就是一个“谁使用，谁创建”的过程，创建依赖对象的主动权和创建时机都是由自己来把控。

			
		

	





	

		

			

				
					
SpringCloud系列（22）--Ribbon默认负载轮询算法原理及源码解析

					
最新发布

				
			

			

				

					m0_64284147的博客
				

				

					05-20
					
					267
					
				

			

		

		

			
				
在上一篇文章中我们介绍了如何去切换Ribbon的负载均衡模式，而本章节内容则是介绍Ribbon默认负载轮询算法的原理。

			
		

	





	

		

			

				
					
【Spring Security】授权

				
			

			

				

					weixin_43676950的博客
				

				

					05-20
					
					398
					
				

			

		

		

			
				
RBAC（Role-Based Access Control，基于角色的访问控制）是一种常用的数据设计方案，它将用户的权限分配和管理与角色相关联。通过对用户角色关联和角色权限关联表进行操作，可以实现灵活的权限管理和访问控制。1、用户表（User table）：包含用户的基本信息，例如用户名、密码和其他身份验证信息。5、角色权限关联表（Role-Permission table）：将角色与权限关联起来。4、用户角色关联表（User-Role table）：将用户与角色关联起来。

			
		

	





	

		

			

				
					
spring 循环依赖

				
			

			

				

					weixin_45849726的博客
				

				

					05-14
					
					439
					
				

			

		

		

			
				
先创建ABean1.0. 记录正在创建ABean singletonCurrentlyInCreation<1.1.实例化ABean–>得到一个对象–>存入singletonFactories1.2. 填充BBean属性–>去单例池找BBean–>没有就创建1.3. 进行其他依赖注入1.4. 初始化前，初始化1.5. 初始化后1.6. 放入单例池创建BBean2.1. 实例化BBean–>得到一个对象。

			
		

	





	

		

			

				
					
java云his系统源码 一站式诊所SaaS系统Java+Spring+Angular+Nginx 云HIS系统八大特点

				
			

			

				

					zmm201453的博客
				

				

					05-15
					
					1213
					
				

			

		

		

			
				
HIS系统采用面向技术架构的分析与设计方法，应用多层次应用体系架构设计，运用基于构件技术的系统搭建模式与基于组件模式的系统内核结构。通过建立统一接口标准，实现数据交换和集成共享，通过统一身份认证和授权控制，实现业务集成、界面集成。

			
		

	





	

		

			

				
					
黑马guli商城项目初始化-SpringCloud微服务项目初始化使用SpringCloudAlibaba快速搭建分布式系统

				
			

			

				

					这个人很懒什么都没有留下
				

				

					05-16
					
					543
					
				

			

		

		

			
				
*** 1、如何使用Nacos作为配置中心统一管理配置* 1）、引入依赖，* 2）、创建一个bootstrap.properties。* 3）、需要给配置中心默认添加一个叫 数据集（Data Id）gulimall-coupon.properties。默认规则，应用名.properties* 4）、给 应用名.properties 添加任何配置* 5）、动态获取配置。* @RefreshScope：动态获取并刷新配置* @Value("${配置项的名}")：获取到配置。

			
		

	





	

		

			

				
					
SpringBoot事件发布与监听，观察者模式使用

				
			

			

				

					小哇
				

				

					05-16
					
					213
					
				

			

		

		

			
				
可以发现，用户注册与信息推送强耦合，用户注册其实到存库成功，就已经算是完成了，后面的信息推送都是额外的操作，甚至信息推送失败报错，还会影响API接口的结果，如果在同一事务，报错信息不捕获，还会导致事务回滚，存库失败。本文记录springboot使用@EventListener监听事件、ApplicationEventPublisher.publishEvent发布事件实现业务解耦。

			
		

	





	

		

			

				
					
SpringBoot设置默认文件大小

				
			

			

				

					如果相遇，那么你好哦~
				

				

					05-14
					
					221
					
				

			

		

		

			
				
修改SpringBoot项目的默认上传文件大小

			
		

	





	

		

			

				
					
使用Spring-security+jwt+springboot+mysql+jpa或mybatisplus完成RBAC权限管理 

				
			

			

				

					04-25
				

			

		

		

			
				
很好的问题！使用Spring-security jwt、Spring Boot、MySQL以及JPA或MyBatis Plus来完成RBAC权限管理是可行的。RBAC（Role-Based Access Control）权限管理是一种广泛使用的准则，用于控制基于角色的权限访问。它允许为用户的角色分配精细的权限，而不是管理每个用户的权限。在Spring Boot应用程序中，可以使用Spring Security和JWT（JSON Web Tokens）来实现RBAC。其中，Spring Security提供了许多基本组件，如用户认证和授权。JWT则提供了一种安全地传递用户信息的方式。数据库可以通过JPA或MyBatis Plus来访问和管理。这些技术的使用可以使你更好地实现RBAC权限管理系统。

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值