Codingmore学习

于 2024-09-20 18:35:53 发布
阅读量1.8k 收藏 49
点赞数 24
文章标签： 学习 springboot mybatis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45678095/article/details/142391275
版权

文章目录

Codingmore学习

项目地址

Codingmore项目结构

  • codingmore-admin，后台管理系统接口

  • codingmore-common，工具类及通用代码

  • codingmore-mbg， MyBatis-Plus 生成的数据库操作代码

  • codingmore-security：SpringSecurity封装公用模块

  • codingmore-web：前台展示系统接口

Codingmore-admin

codingmore-admin
    ├─component
    ├─config
    ├─controller
    └─service
    	└─impl
  • component
    • PublishPostJob 定时发布文章
  • config
    • CodingmoreSecurityConfig 该Java类定义了两个Bean：userDetailsService和dynamicSecurityService。
      • userDetailsService：根据用户名加载用户的详细信息，用于认证。
      • dynamicSecurityService：从数据库中获取资源列表，并将其转换为安全配置属性，用于授权访问控制。具体来说，它将每个资源的URL与对应的权限关联起来，存储在一个并发哈希映射中。
    • GlobalCorsConfig 全局跨域配置
    • MybatisConfig 用于配置MyBatis相关功能，具体功能如下：
      • 通过@Configuration和@EnableTransactionManagement注解声明此为Spring配置类，并开启事务管理。使用@MapperScan注解指定MyBatis映射接口的位置。
      • 定义了mybatisPlusInterceptor方法，创建并返回一个MybatisPlusInterceptor实例，用于添加分页拦截器PaginationInnerInterceptor，确保在MySQL数据库环境下支持分页查询。
    • OssCientConfig 定义了一个配置类，用于创建阿里云OSS客户端。功能如下：
      • 通过@Value注解从配置文件中读取OSS服务的endpoint、accessKeyId和accessKeySecret。使用@Bean注解创建并返回一个OSSClient实例，以便应用程序使用该客户端与阿里云OSS服务交互。
    • SwaggerConfig 配置了Swagger文档，主要功能如下：
      • 定义一个Docket类型的bean，指定API文档的生成规则、启用状态及安全方案。设置API的基本信息，如标题、描述、联系人和版本号。配置安全方案，定义请求头中的认证信息。指定需要认证的API路径。设置默认认证范围。
    • ThreadPoolConfig 定义了一个线程池配置。具体功能如下：
      • 从配置属性中读取线程池的核心参数：核心线程数、最大线程数、队列容量等。
      • 定义一个名为ossUploadImageExecutor的线程池执行器，并设置上述参数。
      • 配置拒绝策略为CallerRunsPolicy，即当任务队列满时，调用者会执行该任务。
      • 设置线程池关闭时等待所有任务完成。
    • WebConfigBeans 添加了自定义的日期转换器
  • controller
    • controller不和数据库中的表一一对应，而是与业务对应
    • CommentsController LinksController PostTagRelationController TermRelationshipsController 中不包含业务逻辑
    • UserController CRUD，禁用用户，返回token，刷新token，获取当前登录用户信息，登出，修改密码，获取角色，分配角色
    • MenuController CRUD，返回所有菜单树状图
    • MinIOController 只包含一个上传接口
    • OssController 一个上传接口
    • PostsController CRUD, 添加文章栏目关联，设置和取消置顶，上传
    • PostTagController CRUD, 模糊匹配，分页查询
    • ResourceCategoryController CRUD
    • ResourceController CRUD
    • RoleController CRUD，分页，获取或分配角色相关的菜单、资源
    • SiteController CRUD
    • TermTaxonomyController 栏目CRUD，查找子栏目
  • service
    • 包含数据库16个表的Service接口和Oss服务的接口
    • Impl 包含所有接口的实现类

Codingmore-common

codingmore-common
    ├─assist
    ├─component
    ├─exception
    ├─state
    ├─util
    └─webapi

codingmore-common

  • assist :

    • RedisConstants类为Java应用程序提供了一组常量和方法，用于处理Redis数据库中的网页浏览量、帖子点赞数以及管理员用户和资源信息。

  • component

    • BindingResultAspect 这段代码是一个使用Spring AOP（面向切面编程）的切面类，用于处理Hibernate Validator（一个Java验证框架）的错误结果。
    • DateConverter 日期转换类，将标准日期、标准日期时间、时间戳转换成Date类型
    • WebLog Controller层的日志封装类，包含了日志的属性
    • WebLogAspect 统一日志处理切面，记录请求信息，包括请求的URL、方法、参数、结果等。

  • exception

    • ApiException 继承 RuntimeException
    • Asserts 断言处理，用于抛出API异常
    • GlobalExceptionHandler 全局异常处理

  • state

    • 包含一些枚举类
    • PostStatus UserStatus 包含文章和用户状态
    • PostType TermRelationType UserType 用于区别类型

  • util

    • FileNameUtil 用于生成文件名称，主要是图片名称，用于OSS服务和MinIO

  • webapi

    • IErrorCode 接口类，封装API的错误码
    • ResultCode IErrorCode的实现类，包含可能用到的操作码
    • ResultObject 通用的返回对象类

全局异常处理

逻辑：参数校验出现异常时抛出，进行捕获

  1. 新建一个自定义异常类 ApiException
  2. 新建一个断言处理类Asserts，失败时抛出ApiException异常
  3. 新建一个全局异常处理类GlobalExceptionHandler， 当捕获到ApiException时，检查异常对象中的errorCode是否为空。如果errorCode不为空，则使用它构建失败的ResultObject返回。
    否则，使用异常消息构建失败的ResultObject返回。

Codingmore-mbg

  • dto ：数据传输对象
  • vo : 封装数据便于在视图中展示
  • service : 包含了Redis操作的接口和实现。数据库表对应的Service不在此模块中。
  • mapper ：映射接口，定义了与数据库交互的接口。
  • model : 相当于entity，其中每一个类对应一个数据库中的表。
  • config ：RedisConfig redis配置类。
  • util : 代码生成工具，日期工具。

Codingmore-security

Codingmore后台登录认证

使用SpringSecurity + JWT，将代码封装在codingmore-security中

codingmore-security
├── component
|    ├── JwtAuthenticationTokenFilter -- JWT登录授权过滤器
|    ├── RestAuthenticationEntryPoint
|    └── RestfulAccessDeniedHandler
├── config
|    ├── IgnoreUrlsConfig
|    └── SecurityConfig
└── util
     └── JwtTokenUtil -- JWT的token处理工具类

  • JwtAuthenticationTokenFilter

    • JWT登录授权过滤器，每次有请求时，从请求头中获取JWT。

    • 从JWT中解析出username，并验证JWT的时效。

    • 校验成功，将token放在ThreadLocal中

    • public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {
    private static final Logger LOGGER = LoggerFactory.getLogger(JwtAuthenticationTokenFilter.class);
    @Autowired
    private UserDetailsService userDetailsService;
    @Autowired
    private JwtTokenUtil jwtTokenUtil;
    @Value("${jwt.tokenHeader}")
    private String tokenHeader;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        // 从客户端请求中获取 JWT
        String authHeader = request.getHeader(this.tokenHeader);
        // 该 JWT 是我们规定的格式，以 tokenHead 开头
        if (authHeader != null && authHeader.startsWith(this.tokenHead)) {
            // The part after "Bearer "
            String authToken = authHeader.substring(this.tokenHead.length());
            // 从 JWT 中获取用户名
            String username = jwtTokenUtil.getUserNameFromToken(authToken);
            LOGGER.info("checking username:{}", username);

            // SecurityContextHolder 是 SpringSecurity 的一个工具类
            // 保存应用程序中当前使用人的安全上下文
            if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {
                // 根据用户名获取登录用户信息
                UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);
                // 验证 token 是否过期
                if (jwtTokenUtil.validateToken(authToken, userDetails)) {
                    // 将登录用户保存到安全上下文中
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails,
                            null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                    SecurityContextHolder.getContext().setAuthentication(authentication);

                    LOGGER.info("authenticated user:{}", username);
                }
            }
        }
        chain.doFilter(request, response);
    }
}

  • JWTtokenUtil

    • JWTtoken的工具类

    • /**
 * JwtToken生成的工具类
 * JWT token的格式：header.payload.signature
 * header的格式（算法、token的类型）：
 * {"alg": "HS512","typ": "JWT"}
 * payload的格式（用户名、创建时间、生成时间）：
 * {"sub":"wang","created":1489079981393,"exp":1489684781}
 * signature的生成算法：
 * HMACSHA512(base64UrlEncode(header) + "." +base64UrlEncode(payload),secret)
 *    on 2018/4/26.
 */
public class JwtTokenUtil {
    private static final Logger LOGGER = LoggerFactory.getLogger(JwtTokenUtil.class);

    private static final String CLAIM_KEY_USERNAME = "sub";
    private static final String CLAIM_KEY_CREATED = "created";

    @Value("${jwt.secret}")
    private String secret;
    @Value("${jwt.expiration}")
    private Long expiration;
    @Value("${jwt.tokenHead}")
    private String tokenHead;

    /**
     * 根据用户名、创建时间生成JWT的token
     */
    private String generateToken(Map<String, Object> claims) {
        return Jwts.builder()
                .setClaims(claims)
                .setExpiration(generateExpirationDate())
                .signWith(SignatureAlgorithm.HS512, secret)
                .compact();
    }

    /**
     * 从token中获取JWT中的负载
     */
    private Claims getClaimsFromToken(String token) {
        Claims claims = null;
        try {
            claims = Jwts.parser()
                    .setSigningKey(secret)
                    .parseClaimsJws(token)
                    .getBody();
        } catch (Exception e) {
            LOGGER.info("JWT格式验证失败:{}", token);
        }
        return claims;
    }

    /**
     * 生成token的过期时间
     */
    private Date generateExpirationDate() {
        return new Date(System.currentTimeMillis() + expiration * 1000);
    }

    /**
     * 从token中获取登录用户名
     */
    public String getUserNameFromToken(String token) {
        String username = null;
        Claims claims = getClaimsFromToken(token);
        if (claims != null) {
            username = claims.getSubject();
        }

        return username;
    }

    /**
     * 验证token是否还有效
     *
     * @param token       客户端传入的token
     * @param userDetails 从数据库中查询出来的用户信息
     */
    public boolean validateToken(String token, UserDetails userDetails) {
        String username = getUserNameFromToken(token);
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }

    /**
     * 判断token是否已经失效
     */
    private boolean isTokenExpired(String token) {
        Date expiredDate = getExpiredDateFromToken(token);
        return expiredDate.before(new Date());
    }

    /**
     * 从token中获取过期时间
     */
    private Date getExpiredDateFromToken(String token) {
        Claims claims = getClaimsFromToken(token);
        return claims.getExpiration();
    }

    /**
     * 根据用户信息生成token
     */
    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put(CLAIM_KEY_USERNAME, userDetails.getUsername());
        claims.put(CLAIM_KEY_CREATED, new Date());
        return generateToken(claims);
    }

    /**
     * 当原来的token没过期时是可以刷新的
     *
     * @param oldToken 带tokenHead的token
     */
    public String refreshHeadToken(String oldToken) {
        if(StrUtil.isEmpty(oldToken)){
            return null;
        }
        String token = oldToken.substring(tokenHead.length());
        if(StrUtil.isEmpty(token)){
            return null;
        }
        //token校验不通过
        Claims claims = getClaimsFromToken(token);
        if(claims==null){
            return null;
        }
        //如果token已经过期，不支持刷新
        if(isTokenExpired(token)){
            return null;
        }
        //如果token在30分钟之内刚刷新过，返回原token
        if(tokenRefreshJustBefore(token,30*60)){
            return token;
        }else{
            claims.put(CLAIM_KEY_CREATED, new Date());
            return generateToken(claims);
        }
    }

    /**
     * 判断token在指定时间内是否刚刚刷新过
     * @param token 原token
     * @param time 指定时间（秒）
     */
    private boolean tokenRefreshJustBefore(String token, int time) {
        Claims claims = getClaimsFromToken(token);
        Date created = claims.get(CLAIM_KEY_CREATED, Date.class);
        Date refreshDate = new Date();
        //刷新时间在创建时间的指定时间内
        if(refreshDate.after(created)&&refreshDate.before(DateUtil.offsetSecond(created,time))){
            return true;
        }
        return false;
    }
}

  • RestAuthenticationEntryPoint

    • 自定义返回结果，未登录或者过期

    • public class RestAuthenticationEntryPoint implements AuthenticationEntryPoint {
    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response, AuthenticationException authException) throws IOException, ServletException {
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Cache-Control","no-cache");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        response.getWriter().println(JSONUtil.parse(ResultObject.unauthorized(authException.getMessage())));
        response.getWriter().flush();
    }
}

  • RestfulAccessDeniedHandler

    • 自定义返回结果，没有权限访问时

    • public class RestfulAccessDeniedHandler implements AccessDeniedHandler{
    @Override
    public void handle(HttpServletRequest request,
                       HttpServletResponse response,
                       AccessDeniedException e) throws IOException, ServletException {
        response.setHeader("Access-Control-Allow-Origin", "*");
        response.setHeader("Cache-Control","no-cache");
        response.setCharacterEncoding("UTF-8");
        response.setContentType("application/json");
        response.getWriter().println(JSONUtil.parse(ResultObject.forbidden(e.getMessage())));
        response.getWriter().flush();
    }
}

  • IgnoreUrlsConfig

    • 配置不需要安全保护的资源

    • @Getter
@Setter
@ConfigurationProperties(prefix = "secure.ignored")
public class IgnoreUrlsConfig {

    private List<String> urls = new ArrayList<>();

}

  • SecurityConfig

    • SpringSecurity通用配置

    • public class CustomSecurityConfig extends WebSecurityConfigurerAdapter {

    @Autowired(required = false)
    private DynamicSecurityService dynamicSecurityService;

    @Override
    protected void configure(HttpSecurity httpSecurity) throws Exception {
        ExpressionUrlAuthorizationConfigurer<HttpSecurity>.ExpressionInterceptUrlRegistry registry = httpSecurity
                .authorizeRequests();
        //允许跨域请求的OPTIONS请求
        registry.antMatchers(HttpMethod.OPTIONS)
                .permitAll();

        //不需要保护的资源路径允许访问
        for (String url : ignoreUrlsConfig().getUrls()) {
            registry.antMatchers(url).permitAll();
        }

        // 任何请求需要身份认证
        registry.and()
                .authorizeRequests()
                .anyRequest()
                .authenticated()
                // 关闭跨站请求防护及不使用session
                .and()
                .csrf()
                .disable()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                // 自定义权限拒绝处理类
                .and()
                .exceptionHandling()
                .accessDeniedHandler(restfulAccessDeniedHandler())
                .authenticationEntryPoint(restAuthenticationEntryPoint())
                // 自定义权限拦截器JWT过滤器
                .and()
                .addFilterBefore(jwtAuthenticationTokenFilter(), UsernamePasswordAuthenticationFilter.class);
        //有动态权限配置时添加动态权限校验过滤器
        if(dynamicSecurityService!=null){
            registry.and().addFilterBefore(dynamicSecurityFilter(), FilterSecurityInterceptor.class);
        }
    }

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

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter() {
        return new JwtAuthenticationTokenFilter();
    }

    @Bean
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }

    @Bean
    public RestfulAccessDeniedHandler restfulAccessDeniedHandler() {
        return new RestfulAccessDeniedHandler();
    }

    @Bean
    public RestAuthenticationEntryPoint restAuthenticationEntryPoint() {
        return new RestAuthenticationEntryPoint();
    }

    @Bean
    public IgnoreUrlsConfig ignoreUrlsConfig() {
        return new IgnoreUrlsConfig();
    }

    @Bean
    public JwtTokenUtil jwtTokenUtil() {
        return new JwtTokenUtil();
    }

    @ConditionalOnBean(name = "dynamicSecurityService")
    @Bean
    public DynamicAccessDecisionManager dynamicAccessDecisionManager() {
        return new DynamicAccessDecisionManager();
    }


    @ConditionalOnBean(name = "dynamicSecurityService")
    @Bean
    public DynamicSecurityFilter dynamicSecurityFilter() {
        return new DynamicSecurityFilter();
    }

    @ConditionalOnBean(name = "dynamicSecurityService")
    @Bean
    public DynamicSecurityMetadataSource dynamicSecurityMetadataSource() {
        return new DynamicSecurityMetadataSource();
    }

}

Codingmore动态权限配置

不同的角色拥有不同的权限，需要对他们被允许进行的操作进行区分。

数据库划分：

user role admin_role_relation

role resource role_resource_relation

用户与角色关联，角色对应一组允许操作的资源。

首先，配置路径与资源的对应关系。通过实现DynamicSecurityService中的loadDataSource()方法，将需要资源的路径与资源一一对应。该接口的实现类位于condingmore-admin的CodingmoreSecurityConfig中配置。

配置完成后，第一步需要一个动态权限过滤器，用于实现基于路径的动态权限过滤。

其中，OPTIONS请求放行，白名单请求放行，需要鉴权的请求调用AccessDecisionManager中的decide()方法进行鉴权操作。

@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
    HttpServletRequest request = (HttpServletRequest) servletRequest;
    FilterInvocation fi = new FilterInvocation(servletRequest, servletResponse, filterChain);
    //OPTIONS请求直接放行
    if(request.getMethod().equals(HttpMethod.OPTIONS.toString())){
        fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
        return;
    }
    //白名单请求直接放行
    PathMatcher pathMatcher = new AntPathMatcher();
    for (String path : ignoreUrlsConfig.getUrls()) {
        if(pathMatcher.match(path,request.getRequestURI())){
            fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
            return;
        }
    }
    //此处会调用AccessDecisionManager中的decide方法进行鉴权操作
    InterceptorStatusToken token = super.beforeInvocation(fi);
    try {
        fi.getChain().doFilter(fi.getRequest(), fi.getResponse());
    } finally {
        super.afterInvocation(token, null);
    }
}

实现动态权限决策管理器，判断用户是否有访问权限。decide()方法中将接口需要的资源与用户拥有的资源进行对比，用户拥有权限直接返回，没有权限抛出AccessDeniedException异常。

decide()方法如下

@Override
public void decide(Authentication authentication, Object object,
                   Collection<ConfigAttribute> configAttributes) throws AccessDeniedException, InsufficientAuthenticationException {
    // 当接口未被配置资源时直接放行
    if (CollUtil.isEmpty(configAttributes)) {
        return;
    }
    Iterator<ConfigAttribute> iterator = configAttributes.iterator();
    while (iterator.hasNext()) {
        ConfigAttribute configAttribute = iterator.next();
        //将访问所需资源或用户拥有资源进行比对
        String needAuthority = configAttribute.getAttribute();
        for (GrantedAuthority grantedAuthority : authentication.getAuthorities()) {
            if (needAuthority.trim().equals(grantedAuthority.getAuthority())) {
                return;
            }
        }
    }
    throw new AccessDeniedException("抱歉，您没有访问权限");
}

在DynamicSecurityFilter中调用super.beforeInvocation(fi)方法时会调用AccessDecisionManager中的decide方法用于鉴权操作,而decide方法中的configAttributes参数会通过SecurityMetadataSource中的getAttributes方法来获取，configAttributes其实就是配置好的访问当前接口所需要的权限。

getAttributes()方法如下：

@Override
public Collection<ConfigAttribute> getAttributes(Object o) throws IllegalArgumentException {
    if (configAttributeMap == null) this.loadDataSource();
    List<ConfigAttribute>  configAttributes = new ArrayList<>();
    //获取当前访问的路径
    String url = ((FilterInvocation) o).getRequestUrl();
    String path = URLUtil.getPath(url);
    PathMatcher pathMatcher = new AntPathMatcher();
    Iterator<String> iterator = configAttributeMap.keySet().iterator();
    //获取访问该路径所需资源
    while (iterator.hasNext()) {
        String pattern = iterator.next();
        if (pathMatcher.match(pattern, path)) {
            configAttributes.add(configAttributeMap.get(pattern));
        }
    }
    // 未设置操作请求权限，返回空集合
    return configAttributes;
}
Spring Boot AOP 扫盲，实现接口访问的统一日志记录
V539413949的博客
04-07 455
AOP 是 Spring 体系中非常重要的两个概念之一（另外一个是 IoC），今天这篇文章就来带大家通过实战的方式，在编程猫 SpringBoot 项目中使用 AOP 技术为 controller 层添加一个切面来实现接口访问的统一日志记录。 一、关于 AOP AOP，也就是 Aspect-oriented Programming，译为面向切面编程，是计算机科学中的一个设计思想，旨在通过切面技术为业务主体增加额外的通知（Advice），从而对声明为“切点”（Pointcut）的代码块进行统一管理和装饰。 这
厉害了，仅用四步就整合好SpringSecurity+JWT实现登录认证
V539413949的博客
04-07 957
一、关于 SpringSecurity 在 Spring Boot 出现之前，SpringSecurity 的使用场景是被另外一个安全管理框架 Shiro 牢牢霸占的，因为相对于 SpringSecurity 来说，SSM 中整合 Shiro 更加轻量级。Spring Boot 出现后，使这一情况情况大有改观。正应了那句古话：一人得道鸡犬升天，虽然有点不大合适，就将就着用吧。 这是因为 Spring Boot 为 SpringSecurity 提供了自动化配置，大大降低了 SpringSecurity 的学
SpringBoot常用注解
糖丸桃桃包的博客
04-18 551
spring常用注解
全新版本Spring Security，如何才能优雅的使用？
2301_76607156的博客
05-03 293
Spring Security的升级用法确实够优雅，够简单，而且对之前用法的兼容性也比较好！个人感觉一个成熟的框架不太会在升级过程中大改用法，即使改了也会对之前的用法做兼容，所以对于绝大多数框架来说旧版本会用，新版本照样会用！
mall大型企业项目：5，权限验证加redis缓存（中）。security+jwt+redis
ljs13168734665的博客
10-11 293
security+jwt+redis1，service1,1，DynamicSecurityService1.2，RedisService1.3，UmsAdminCacheService1.4，UmsAdminService1.5，UmsResourceService2，serviceImpl2.1,RedisServiceImpl2.2,UmsAdminCacheServiceImpl2.3,UmsAdminServiceImpl2.4,UmsResourceServiceImpl 1，service 1
别再用过时的方式了！全新版本Spring Security，这样用才够优雅！
BASK2312的博客
12-21 839
Spring Security的升级用法确实够优雅，够简单，而且对之前用法的兼容性也比较好！个人感觉一个成熟的框架不太会在升级过程中大改用法，即使改了也会对之前的用法做兼容，所以对于绝大多数框架来说旧版本会用，新版本照样会用！
codingmore-admin-web是一个知识库学习网站管理系统的前端项目，基于vue+element实现。.zip
最新发布
10-21
【codingmore-admin-web】是一个专为知识库学习网站设计的管理系统前端项目，它采用现代Web开发框架Vue.js和UI组件库Element UI构建。Vue.js是一个轻量级、高性能的前端JavaScript框架，以其易学易用、灵活性高和可...
Spring Boot + Vue.js 学习教程网站开发指南
资源摘要信息:"基于Spring Boot和Vue框架的学习教程网站" 本项目是一个使用Spring Boot和Vue框架构建的前后端分离的学习教程网站。它包含前台展示系统和后台管理系统两个主要部分。前台系统为访客提供了一个内容...
Vue+Element实现的知识库学习网站管理系统
资源摘要信息:"codingmore-admin-web是一个基于Vue.js框架和Element UI组件库实现的知识库学习网站管理系统的前端项目。Vue.js是一个构建用户界面的渐进式JavaScript框架，它使得开发者能够以数据驱动的方式构建交互...
JWT和Security 登录权限判断和token访问和让token失效
yujunlong3919的专栏
12-10 9958
文章目录Spring SecurityJWT无状态的单点登录()流程用到的方法configure(HttpSecurity http)登录 authenticationSuccessHandler loadUserByUsername通过token访问 doFilterInternal方法设置权限 Spring Security Spring Security是一个功能强大且高度可定制的身份验...
厉害，我带的实习生仅用四步就整合好SpringSecurity+JWT实现登录认证
热门推荐
沉默王二
04-07 2万+
小二是新来的实习生，作为技术 leader，我还是很负责任的，有什么锅都想甩给他，啊，不，一不小心怎么把心里话全说出来了呢？重来！ 小二是新来的实习生，作为技术 leader，我还是很负责任的，有什么好事都想着他，这不，我就安排了一个整合SpringSecurity+JWT实现登录认证的小任务交，没想到，他仅用四步就搞定了，这让我感觉倍有面。 一、关于 SpringSecurity 在 Spring Boot 出现之前，SpringSecurity 的使用场景是被另外一个安全管理框架 Shiro 牢牢霸占
四、Spring Security认证和授权-动态授权解决方案
STIll_ly的博客
10-06 1759
上面两期已经学习了认证和授权的相关知识并且对源码进行了解析，相信这些知识点应付简单系统权限控制已经足够，但是如果想要实现复杂的权限控制，就需要自己进自定义开发了。今天我们来学习一下如何基于Spring Security，实时从数据库里查询用户权限进行权限校验，实现动态权限控制。 一、RBAC简介 动态权限开发以前，我们必须要有一套明确的权限系统。下面我们基于RBAC来讲解具体实现流程。 RBAC(role-based access control)，基于角色的权限控制系统，是指对于不同角色的用户，拥有不同的
SpringBoot + SpringSecurity + redis 整合优化版(2)
qq826303461的博客
07-28 965
整合SpringBoot、SpringSecurity完成，实现了前后端分离，用户状态保存到Redis（支持分布式认证、系统重启也不会导致用户离线、可以手动让用户离线等优势）。
Java 程序员进阶之路五月专题训练打卡：编程喵项目安装手册
buzai_chenmo的博客
05-02 686
🔗《Java程序员进阶之路》知识星球第一周《五月 Java 专题训练》打卡。 学习内容： 第一周 什么是对象 第一个 Spring Boot 项目 运行编程喵开源实战项目 阅读完星球专栏《Java面试指南》 第二周 对象无处不在 编程喵整合 MySQL 数据库 阅读完星球专栏《Java面试指南》 第三周 操作符 编程喵整合 JPA 阅读完星球专栏《Java面试指南》 第四周 流程控制 使用 thymeleaf 模板引擎 阅读完星球专栏《Java面试指南》 学习时间： 2022年05月0.
SpringSecurity实现动态管理权限(三)
zhoubangbang1的博客
01-07 844
SpringBoot整合SpringSecurity实现接口动态管理权限 接上一篇权限管理是后台管理不可缺少的部分，今天结合SpringSecurity实现接口的动态管理。 动态权限管理 SpringSecurity实现权限动态管理，第一步需要创建一个过滤器,doFilter方法需要注意,对于OPTIONS直接放行,否则会出现跨域问题。并且对在上篇文章提到的IgnoreUrlsConfig中的白名单也是直接放行，所有的权限操作都会在super.beforeInvocation(fi)中实现。
分析Spring Security实现方式
魏亚恒的博客
04-07 744
Spring Security的两个核心功能是：验证和鉴权。 1、用户登录检验用户名和密码即为验证。 2、用户访问网址时，根据URI判断相应的角色才可以访问即为鉴权。 验证过程： 1、后端从前端的表单得到用户密码，包装成一个Authentication类的对象； 2、将Authentication对象传给“验证管理器”ProviderManager进行验证； 3、ProviderManag...
还在从零开始搭建项目？这款升级版快速开发脚手架值得一试~
macrozheng的专栏
06-09 606
关注我Github的小伙伴应该了解，之前我开源了一款快速开发脚手架mall-tiny，该脚手架继承了mall项目的技术栈，拥有完整的权限管理功能。最近抽空把该项目支持了Spring Boot 2.7.0，今天再和大家聊聊这个脚手架，同时聊聊升级项目到Spring Boot 2.7.0的一些注意点，希望对大家有所帮助！...
手把手教你搞定权限管理，结合Spring Security实现接口的动态权限控制！
macrozheng的专栏
02-25 1万+
权限控管理作为后台管理系统中必要的功能，mall项目中结合Spring Security实现了基于路径的动态权限控制，可以对后台接口访问进行细粒度的控制，今天我们来讲下它的后端实现原理。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Liwan95

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值
>