SpringSecurity - WebFlux环境下整合JWT使用 Token 认证授权

已于 2022-11-20 17:59:48 修改
阅读量7.1k 收藏 33
点赞数 4
分类专栏： 微服务 文章标签： java 开发语言 后端
于 2022-01-15 18:41:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43692950/article/details/122513687
版权

一、SpringSecurity - WebFlux

上篇文章我们讲解了SpringSecurity 在WebFlux环境下的动态角色权限的控制，本篇文章我们一起讲解下SpringSecurity 在WebFlux环境下整合JWT使用 Token 认证授权。

上篇文章地址：https://blog.csdn.net/qq_43692950/article/details/122511037

二、整合JWT使用 Token 认证授权

在关于SpringSecurity 在WebFlux环境下的使用，在前面的几篇文章中已经讲解了。在看本篇文章之前，最好已经看过本专栏的前面几篇关于SpringSecurity 的文章了，一些重复性的代码就不再写出来了。下面直接进入主题。

在开始之前我们先清楚一个问题，对于登录认证SpringSecurity 已经帮我们实现了，我们可以指定登录的路径，默认是x-www-form-urlencoded方式。所以我们不用编写登录的逻辑，但是有些情况下可能SpringSecurity所提供的不能满足我们的需求,比如我们是自定义的加密数据传输的情况，此时我们可以自己写一个登录接口，在该接口中颁发Token令牌出来，并设置ServerHttpSecurity对象的formLogin().disable()，下面的演示中是采用SpringSecurity 所提供的认证来进行演示。

编写JWT工具类

这里我将权限也放在了JWT中，如果需要动态变更用户权限的可以考虑放在Redis或其他NoSql数据库中，本文主要演示Jwt的使用：

@Data
@Component
public class JwtTool {
    private String key = "com.bxc";
    private long overtime = 1000 * 60 * 60;

    public String CreateToken(String userid, String username, List<String> roles) {
        long nowMillis = System.currentTimeMillis();
        Date now = new Date(nowMillis);
        JwtBuilder builder = Jwts.builder()
                .setId(userid)
                .setSubject(username)
                .setIssuedAt(now)
                .signWith(SignatureAlgorithm.HS256, key)
                .claim("roles", roles);
        if (overtime > 0) {
            builder.setExpiration(new Date(nowMillis + overtime));
        }
        return builder.compact();
    }

    public boolean VerityToken(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return true;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }

    public String getUserid(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return claims.getId();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getUserName(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return claims.getSubject();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public List<String> getUserRoles(String token) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return (List<String>) claims.get("roles");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public String getClaims(String token, String param) {
        try {
            Claims claims = Jwts.parser()
                    .setSigningKey(key)
                    .parseClaimsJws(token)
                    .getBody();
            if (claims != null) {
                return claims.get(param).toString();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
编写登录成功的Handler

我们可以在这里做办法Token令牌的逻辑：

@Component
public class LoginSuccessHandler implements ServerAuthenticationSuccessHandler {

    @Autowired
    JwtTool jwtTool;

    @Override
    public Mono<Void> onAuthenticationSuccess(WebFilterExchange webFilterExchange, Authentication authentication) {
        UserEntity user = (UserEntity) authentication.getPrincipal();
        String username = user.getUsername();
        List<GrantedAuthority> authorities = (List<GrantedAuthority>) user.getAuthorities();
        List<String> roles = authorities.stream().map(GrantedAuthority::getAuthority).collect(Collectors.toList());
        String token = jwtTool.CreateToken(String.valueOf(user.getId()), username, roles);
        JSONObject params = new JSONObject();
        params.put("code", 200);
        params.put("msg", "登陆成功！");
        params.put("username", username);
        params.put("role", roles);
        params.put("token", token);

        ServerWebExchange exchange = webFilterExchange.getExchange();
        ServerHttpResponse response = exchange.getResponse();
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        Mono<Void> ret = null;
        try {
            ret = response.writeAndFlushWith(Flux.just(ByteBufFlux.just(response.bufferFactory().wrap(params.toJSONString().getBytes("UTF-8")))));
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return ret;
    }
}
编写登录失败的Handler

返回客户端一个友好的提示，这里我直接返回了登录失败，大家可以根据AuthenticationException这个类进行具体判断，返回具体的错误信息：

@Component
public class LoginFailedHandler implements ServerAuthenticationFailureHandler {
    @Override
    public Mono<Void> onAuthenticationFailure(WebFilterExchange webFilterExchange, AuthenticationException e) {
        JSONObject params = new JSONObject();
        params.put("code", 400);
        params.put("msg", "登录失败！");

        ServerHttpResponse response = webFilterExchange.getExchange().getResponse();
        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        Mono<Void> ret = null;
        try {
            ret = response.writeAndFlushWith(Flux.just(ByteBufFlux.just(response.bufferFactory().wrap(params.toJSONString().getBytes("UTF-8")))));
        } catch (UnsupportedEncodingException e0) {
            e0.printStackTrace();
        }
        return ret;
    }
}
编写登录失效的Hander
@Component
public class LoginLoseHandler extends HttpBasicServerAuthenticationEntryPoint {

    @Override
    public Mono<Void> commence(ServerWebExchange exchange, AuthenticationException e) {
        JSONObject params = new JSONObject();
        params.put("code", 401);
        params.put("msg", "登录失效！");

        ServerHttpResponse response = exchange.getResponse();

        response.getHeaders().setContentType(MediaType.APPLICATION_JSON_UTF8);
        Mono<Void> ret = null;
        try {
            ret = response.writeAndFlushWith(Flux.just(ByteBufFlux.just(response.bufferFactory().wrap(params.toJSONString().getBytes("UTF-8")))));
        } catch (UnsupportedEncodingException e0) {
            e0.printStackTrace();
        }
        return ret;
    }
}
编写JWT的过滤器

既然上面已经颁发了JWT的Token，那么请求来的第一步就要进行JWT的过滤和校验，如果OK在交给SpringSecurity将JWT的内容解析出来，所以这个过滤器只是一个教研JWT是否有效的作用，并没有对当前请求授权：

@Slf4j
@Component
public class JwtWebFilter implements WebFilter {

    @Autowired
    JwtTool jwtTool;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        ServerHttpResponse response = exchange.getResponse();
        HttpHeaders header = response.getHeaders();
        header.add("Content-Type", "application/json; charset=UTF-8");
        String path = request.getPath().value();
        if (path.contains("/auth/login")){
            return chain.filter(exchange);
        }
        String token = exchange.getRequest().getHeaders().getFirst("token");
        if (StringUtils.isBlank(token)) {
            JSONObject jsonObject = setResultErrorMsg(401,"登录失效");
            DataBuffer buffer = response.bufferFactory().wrap(jsonObject.toJSONString().getBytes());
            return response.writeWith(Mono.just(buffer));
        }
        boolean isold = jwtTool.VerityToken(token);
        if (!isold) {
            JSONObject jsonObject = setResultErrorMsg(401,"登录失效");
            DataBuffer buffer = response.bufferFactory().wrap(jsonObject.toJSONString().getBytes());
            return response.writeWith(Mono.just(buffer));
        }
        String username = jwtTool.getUserName(token);
        if (com.alibaba.druid.util.StringUtils.isEmpty(username)) {
            JSONObject jsonObject = setResultErrorMsg(401,"登录失效");
            DataBuffer buffer = response.bufferFactory().wrap(jsonObject.toJSONString().getBytes());
            return response.writeWith(Mono.just(buffer));
        }
        return chain.filter(exchange);
    }

    private JSONObject setResultErrorMsg(Integer code,String msg) {
        JSONObject jsonObject = new JSONObject();
        jsonObject.put("code", code);
        jsonObject.put("message", msg);
        return jsonObject;
    }
}
解析JWT中用户信息，并授予角色权限信息

上面只是做了JWT的一个初步过滤，到这就要解析JWT中的信息，组建一个UsernamePasswordAuthenticationToken进行用户的授权，这里我又做了一遍JWT的校验，其实这里可以不做JWT的校验了，前面的过滤器已经校验过了，直接取内容即可，

@Slf4j
@Component
public class JwtSecurityContextRepository implements ServerSecurityContextRepository {

    @Autowired
    JwtTool jwtTool;

    @Override
    public Mono<Void> save(ServerWebExchange exchange, SecurityContext context) {
        return Mono.empty();
    }

    @Override
    public Mono<SecurityContext> load(ServerWebExchange exchange) {
        String path = exchange.getRequest().getPath().toString();
        // 过滤路径
        if ("/auth/login".equals(path)) {
            return Mono.empty();
        }
        String token = exchange.getRequest().getHeaders().getFirst("token");
        if (StringUtils.isBlank(token)) {
            throw new DisabledException("登录失效！");
        }
        boolean isold = jwtTool.VerityToken(token);
        if (!isold) {
            throw new AccessDeniedException("登录失效！");
        }
        String username = jwtTool.getUserName(token);
        if (com.alibaba.druid.util.StringUtils.isEmpty(username)) {
            throw new AccessDeniedException("登录失效！");
        }
        Authentication newAuthentication = new UsernamePasswordAuthenticationToken(username, username);
        return new ReactiveAuthenticationManager() {
            @Override
            public Mono<Authentication> authenticate(Authentication authentication) {
                return Mono.fromCallable(() -> {
                    List<String> roles = jwtTool.getUserRoles(token);
                    List<GrantedAuthority> authorities = roles.stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList());
                    UserEntity principal = new UserEntity();
                    principal.setUsername(username);
                    return new UsernamePasswordAuthenticationToken(principal, null, authorities);
                });
            }
        }.authenticate(newAuthentication).map(SecurityContextImpl::new);
    }
}
判断用户是否有权访问该接口

上面只是获取到了用户所以拥有的角色权限信息，下面还要判断访问的该接口所需的角色用户是否拥有，这个地方的逻辑在上篇文章中进行了讲解，可以参考下上篇文章：

@Component
public class AuthManagerHandler implements ReactiveAuthorizationManager<AuthorizationContext> {

    @Autowired
    MeunMapper meunMapper;

    @Autowired
    RoleMapper roleMapper;
    private AntPathMatcher antPathMatcher = new AntPathMatcher();

    @Override
    public Mono<AuthorizationDecision> check(Mono<Authentication> authentication, AuthorizationContext object) {
        ServerHttpRequest request = object.getExchange().getRequest();
        String requestUrl = request.getPath().pathWithinApplication().value();
        List<MeunEntity> list = meunMapper.selectList(null);
        List<String> roles = new ArrayList<>();
        list.forEach(m -> {
            if (antPathMatcher.match(m.getPattern(), requestUrl)) {
                List<String> allRoleByMenuId = roleMapper.getAllRoleByMenuId(m.getId())
                        .stream()
                        .map(r -> r.getRole())
                        .collect(Collectors.toList());
                roles.addAll(allRoleByMenuId);
            }
        });
        if (roles.isEmpty()) {
            return Mono.just(new AuthorizationDecision(false));
        }
        return authentication
                .filter(a -> a.isAuthenticated())
                .flatMapIterable(a -> a.getAuthorities())
                .map(g -> g.getAuthority())
                .any(c -> {
                    if (roles.contains(String.valueOf(c))) {
                        return true;
                    }
                    return false;
                })
                .map(hasAuthority -> new AuthorizationDecision(hasAuthority))
                .defaultIfEmpty(new AuthorizationDecision(false));
    }

    @Override
    public Mono<Void> verify(Mono<Authentication> authentication, AuthorizationContext object) {
        return null;
    }
}
编写无权访问的提示Handler
@Component
public class AccessDeniedHandler implements ServerAccessDeniedHandler {
    @Override
    public Mono<Void> handle(ServerWebExchange serverWebExchange, AccessDeniedException e) {
        JSONObject params = new JSONObject();
        params.put("code", 403);
        params.put("msg", "权限不足！");

        ServerHttpResponse response = serverWebExchange.getResponse();

        response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
        Mono<Void> ret = null;
        try {
            ret = response.writeAndFlushWith(Flux.just(ByteBufFlux.just(response.bufferFactory().wrap(params.toJSONString().getBytes("UTF-8")))));
        } catch (UnsupportedEncodingException e0) {
            e0.printStackTrace();
        }
        return ret;
    }
}
修改SecurityConfig配制

将上面所写的配制到SpringSecurity 中:

@Configuration
@EnableWebFluxSecurity
@EnableReactiveMethodSecurity
public class SecurityConfig {

    @Autowired
    UserDetailService userDetailService;

    @Autowired
    AuthManagerHandler authManagerHandler;

    @Autowired
    AccessDeniedHandler accessDeniedHandler;

    @Autowired
    LoginSuccessHandler loginSuccessHandler;

    @Autowired
    LoginFailedHandler loginFailedHandler;

    @Autowired
    LoginLoseHandler loginLoseHandler;

    @Autowired
    JwtSecurityContextRepository jwtSecurityContextRepository;

    @Autowired
    JwtWebFilter jwtWebFilter;

    //security的鉴权排除列表
    private static final String[] excludedAuthPages = {
            "/auth/login",
            "/auth/logout"
    };

    @Bean
    public ReactiveAuthenticationManager authenticationManager() {
        UserDetailsRepositoryReactiveAuthenticationManager authenticationManager = new UserDetailsRepositoryReactiveAuthenticationManager(userDetailService);
        authenticationManager.setPasswordEncoder(passwordEncoder());
        return authenticationManager;
    }

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

    @Bean
    SecurityWebFilterChain webFluxSecurityFilterChain(ServerHttpSecurity http) throws Exception {
        http.authorizeExchange()
                .pathMatchers(excludedAuthPages).permitAll()  //无需进行权限过滤的请求路径
                .pathMatchers(HttpMethod.OPTIONS).permitAll() //o
                .pathMatchers("/**").access(authManagerHandler)
                .anyExchange().authenticated()
                .and()
                .addFilterAfter(jwtWebFilter, SecurityWebFiltersOrder.FIRST)
                .securityContextRepository(jwtSecurityContextRepository)
                .formLogin()
                .loginPage("/auth/login")
                .authenticationSuccessHandler(loginSuccessHandler)
                .authenticationFailureHandler(loginFailedHandler)
                .and().exceptionHandling().authenticationEntryPoint(loginLoseHandler)
                .and().exceptionHandling().accessDeniedHandler(accessDeniedHandler)
                .and().cors().disable().csrf().disable();
        return http.build();
    }
}

三、效果演示

不登录，直接访问http://localhost:8080/admin/test，会提示登录失效。
在这里插入图片描述
登录http://localhost:8080/auth/login，获取返回的Token：
在这里插入图片描述
下面使用返回的Token，再次测试上面的接口：
在这里插入图片描述
如果访问一个无权限的接口：http://localhost:8080/common/test
在这里插入图片描述

小毕超
关注
专栏目录
spring-webflux-security-jwt：使用Spring Reactive Webflux，Spring Boot 2和Spring Security 5的JWT授权和认证实现
01-30
使用JWT与Spring WebFlux和Spring Security Reactive进行身份验证和授权 首先阅读的好文档 在开始之前，我建议您先阅读下一份参考 启用S​​pring WebFlux安全性 在你的应用程序首先使Webflux安全@EnableWebFluxSecurity @SpringBootApplication @EnableWebFluxSecurity public class SecuredRestApplication { .... } 创建一个InMemory UserDetailsS​​ervice 定义一个自定义UserDetailsService bean，在其中添加具有密码和初始角色的User： @Bean public MapReactiveUserDetailsService userDetailsRepository() { UserDetails user = User . withDefaultPasswordEncoder() .username( " user " )
SpringSecurity - WebFlux环境下实现用户动态认证
小毕超博客
01-15 6407
一、SpringSecurity - WebFlux 上篇文章我们讲解了SpringSecurity 整合JWT使用 Token 的方式认证授权，但是从前面的学习中应该可以发现，我们是在SpringMVC环境下实现的，所写的过滤器都是基于Servlet的。我们也知道Spring很早就退出了WebFlux异步非阻塞的web框架，是基于Netty实现的一款高性能的web框架，性能要比SpringMVC高的多，还有现在我们常用的SpringGateWay网关也是基于WebFlux框架实现的，而在WebFlux环境
SpringBoot+Cloud+Webflux+Security+Gateway+Redis+Eureka+Rabbitmq+实现网关的安全JWT鉴权验证及（令牌桶）限速 简单案例
最新发布
流水悠然，任山川引路。
08-21 950
实现Gateway基于Webflux的JWT安全验证。
Spring WebFlux (7): Springboot Security+jwt登录鉴权
泛泛之素
08-17 8827
在Spring WebFlux (3): mysql+Springboot Security实现登录鉴权的基础上实现 token登录的逻辑刚上手确实很复杂，挺难啃的，而且实现方法也不唯一，看过很多博客实现的方法基本都不一样，简单说一下我的方法： 首先设置一个WebFilter，主要两个功能： 登录和注册时是没有token的，这两个功能的路由放行 其他请求检查token，是否有token，token是否合法，讲处理的token放入上下文中 然后就是实现ServerSecurityContextRe
SpringBoot WebFlux整合Spring Security进行权限认证
asoklove的专栏
01-14 2276
环境：Springboot2.5.8 请先阅读： Reactor响应式编程（Flux、Mono）基本用法 Spring WebFlux入门实例并整合数据库实现基本的增删改查 Spring Boot Security防重登录及在线总数 简介 Spring Security的WebFlux支持依赖于WebFilter，对Spring WebFlux和Spring WebFlux.Fn的作用相同。WebMVC依赖于Filter。 依赖管理 <dependency> <gro
Spring WebFlux (3): mysql+Springboot Security实现登录鉴权
泛泛之素
08-12 3464
Security主要有两个功能： 登录 鉴权 Security通过一个user相关类存储用户信息，实现UserDetails接口功能： 看一下Security自带的User类， 主要变量： password：密码 username: 账户名 authorities： 访问权限 accountNonExpired：账户没有过期 isAccountNonLocked：账户没被锁定 （是否冻结） isCredentialsNonExpired：密码没有过期 isEnabled：账户是否可用（是否被删除）
springboot2 webflux集成spring security做权限登陆校验
chiying5380的博客
06-13 1万+
一、主要pom依赖包 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifac...
SpringCloud Gateway整合Spring Security Webflux的关键点（痛点解析），及示例项目
热门推荐
tiancao222的博客
02-18 1万+
最近公司项目需要用到后端的认证、授权，且公司项目目前是基于SpringCloud Gateway的，所以想到都是一家的产品就决定使用Spring Security了。 但是在整合过程中，经历了种种磨难，所以把最终的整合关键点列出来，让需要的读者不用再碰的头破血流了。。。 网上也有基于SpringCloud和Spring Security整合的方案，关键在于我们公司的项目使用的是Gateway，...
【项目实战】WebFlux整合r2dbc-mysql实战
本本本添哥
03-02 1504
R2DBC全称Reactive Relational Database Connectivity，也就是反应式关系型数据库连接。R2DBC是基于Reactive Streams标准来设计的。通过使用R2DBC，你可以使用reactive API来操作数据。
SpringSecurity之JWT实现token认证和授权.zip
08-09
在这个主题中，我们将深入探讨如何使用Spring Security结合JSON Web Token (JWT) 实现token认证和授权。 JWT 是一种轻量级的、安全的、无状态的身份验证机制，常用于API的鉴权。它通过在客户端和服务器之间传递令牌...
SpringBoot-JWT-Token:JWT令牌，Spring-Security
03-22
本篇文章将深入探讨如何在Spring Boot应用中结合Spring Security实现JWT令牌的认证和授权。 首先，JWT令牌是一种轻量级的身份验证标准，它允许信息在多个服务之间安全地传输，而无需在服务器上存储会话信息。JWT...
springSecurity-jwt:JWT access_token和refresh_token
04-10
SpringSecurity-JWT-VERSION2（AccessToken和RefreshToken） version1太复杂，无法优化。accessToken refreshToken流安全登录处理流程详细说明转到博客文章JWT异常处理安全异常处理（AuthenticationEntryPoint，...
spring-boot-webflux-jjwt：示例Spring Boot和带有Spring Security和JWT的WebFlux（响应式Web），用于令牌认证和授权
01-30
该项目是关于如何在Spring Boot应用中集成Spring Security和JWT（JSON Web Tokens）来实现响应式Web（WebFlux）的认证和授权。Spring Boot简化了Java应用的开发，而Spring Security则提供了强大的安全框架，JWT则是...
spring cloud gateway整合security实现统一权鉴
本作者：想花
11-06 4272
方法，返回对象包含数据库查询出的用户账号和密码，然后和用户录入的账号密码比较验证。当登录成功后会把token返回给前端，后续的调用业务接口都会把token携带上进行。因为gateway框架使用的是netty的webflux技术，不是springmvc的servlet。上图的是否 2、3是我自定义的角色，在查询数据库用户账户密码时候，也查询了角色，并且一起封装到。security有两个版本，一个是sevlet，一个是webflux。当验证完成账户密码成功后，进行权限验证，判断请求的路径。
在 webflux 环境中使用 Spring Security
2301_76607156的博客
04-11 2209
复制日志中出现的名称：，在 idea 中按两下 shift在类中可以看到如下代码：可以看到密码的来源于 User 对象，而 User 对象，由方法传入，但值最终都是取自对象。而就是一个读取配置文件的类，定义如下：spring:security:user:复制代码再次启动项目，就可以使用cxyxj在 mvc 中还自定义过登录成功响应、登录失败响应、登录无权限访问响应、未登录访问认证资源响应、登出成功响应。那在 webflux 中如何自定义呢？
SpringBoot WebFlux集成WebFluxSecurity做登录权限验证
不会飞的小龙人的博客
08-31 1万+
前言 本文，演示Spring Boot Weflux集成SpringSecurity安全验证框架做项目的身份验证与权限管理；通过@EnableWebFluxSecurity注解加载与配置Security权限与用户登录信息，通过@EnableReactiveMethodSecurity注解在标准方法上用表达式模型做安全控制设置，如：使用@PreAuthorize注解在方法上控制用户访问RestAPI做权限验证；采用jwt做登录会话数字签名，通过jwt验证后，从jwt中获取用户唯一标识，在做相应业务验权和调用
在webflux框架中如何校验token，验证用户是否登录
weixin_38390086的博客
07-15 785
在webflux框架中如何校验token，验证用户是否登录
如何在 webflux 环境中使用 Spring Security
xxxzzzqqq_的博客
04-12 1041
复制日志中出现的名称：，在 idea 中按两下 shift在类中可以看到如下代码：可以看到密码的来源于 User 对象，而 User 对象，由方法传入，但值最终都是取自对象。而就是一个读取配置文件的类，定义如下：spring:security:user:复制代码再次启动项目，就可以使用cxyxj在 mvc 中还自定义过登录成功响应、登录失败响应、登录无权限访问响应、未登录访问认证资源响应、登出成功响应。那在 webflux 中如何自定义呢？
WebFlux 和 Spring Security 会碰出哪些火花？
2401_83412087的博客
03-29 1013
核心竞争力，怎么才能提高呢？成年人想要改变生活，逆转状态？那就开始学习吧~万事开头难，但是程序员这一条路坚持几年后发展空间还是非常大的，一切重在坚持。为了帮助大家更好更高效的准备面试，特别整理了《前端工程师面试手册》电子稿文件。
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小毕超

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

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

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

打赏作者

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

抵扣说明：

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

余额充值