spring boot 整合vue自定义权限

最新推荐文章于 2024-08-25 13:45:39 发布
最新推荐文章于 2024-08-25 13:45:39 发布
阅读量753 收藏 3
点赞数 2
分类专栏： spring boot 文章标签： vue spring boot
本文为吕小小布博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/qq_37059838/article/details/88041482
版权

介绍（原创转载请注明地址）

  • 将权限控制放到后台处理（权限为最简单的），采用spring-session和redis,cookie,如果怕sessionId劫持采用加密算法。
  • session和cookie混合使用由服务器session（将session接入到redis）添加用户信息，提供给客户端cookie一个token，通过token（session读取建议加密读取）读取session。权限采用自定义注解。
  • token

maven

 


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-data-redis</artifactId>
        </dependency>
     
        <dependency>
            <groupId>org.springframework.session</groupId>
            <artifactId>spring-session-jdbc</artifactId>
        </dependency>
        <!-- java的工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!--加密算法(spring提供的加密算法不安全只有MD5和base64)-->
        <dependency>
            <groupId>commons-codec</groupId>
            <artifactId>commons-codec</artifactId>
        </dependency>

application.yml配置文件

  redis:
    host: 0.0.0.0
    password: 0000000
    timeout: PT30M
    #spring-session
  session:
    store-type: redis
    timeout: PT30M
#tocmat 超时默认30分钟
server:
  servlet:
    context-path: /
    session:
      timeout: PT30M
  tomcat:
    uri-encoding: UTF-8
#超时时间要保持一致

一，密码加密

加密算法常用有MD5，BASE64，SHA-1,SHA-2(SHA:Secure Hash Algorithm即安全散列算法),HMAC（Message Authentication Code消息认证码和MD5,SHA一起使用)。除了BASE64可以解码，其它不可解码，MD5不安全是因为可以碰撞出来，这里不细说了，密码采用HMAC-SHA-2最好(算法有HMAC_MD5，HMAC_SHA_1，(后面为SHA-2算法)HMAC_SHA_224，HMAC_SHA_384,HMAC_SHA_256,HMAC_SHA_256,HMAC_SHA_512)。

这里只说一种算法HMAC_SHA_256算法（密码加密最好采用多算法加密）

/**
 * 加密
 */
public class MyUtils {


    private MyUtils() {
    }


    /**
     * 编码base64
     *
     * @param data 需要编码的数据
     * @return 编码之后的内容
     */
    public static String encodeBase64(Object data) {
        try {
            if (Objects.nonNull(data)) {
                String json =getJson(data);
                if (StringUtils.isNotEmpty(json)) {
                    return Base64.encodeBase64String(json.getBytes(StandardCharsets.UTF_8));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 解码base64
     *
     * @param data 解码的内容
     * @return 解码之后的数据
     */
    public static String decodeBase64(Object data) {
        try {
            String json =getJson(data);
            if (StringUtils.isNotEmpty(json)) {
                return new String(Base64.decodeBase64(json));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 单加密
     *
     * @param pwd 需要加密的内容
     * @return string
     */
    public static String encryptToken(String pwd) {
        //防止碰撞加了内容:1sdfjjthu235
        return new HmacUtils(HmacAlgorithms.HMAC_SHA_256, "123456").hmacHex(pwd)+"1sdfjjthu235";
       //hmac和hamcHex区别是加密的内容一个是8进制一个是16进制
       //123456为密匙不要泄密(一般是数据库提供的密匙)
    }

    /**
     * 单校验
     *
     * @param pwd 需要加密的内容
     * @return string
     */
    public static boolean verifyToken(String pwd, String data) {
        boolean flag = false;
        if (StringUtils.isNoneEmpty(pwd, data)) {
            if (Objects.equals(pwd, encryptToken(data))) {
                flag = true;
            }
        }
        return flag;
    }
     public static String getJson(Object data) {
        try {
           if (Objects.nonNull(data)){
               ObjectMapper mapper = new ObjectMapper();
               return mapper.writeValueAsString(data);
           }
        } catch (JsonProcessingException e) {
            logger.error("JSON转换异常",e.getMessage());
        }
        return null;
    }
}

工具类

public class HttpUtils {
    private HttpUtils() {

    }

    private final static Logger logger = LoggerFactory.getLogger(HttpUtils.class);

    private static RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();


    public static HttpServletRequest getHttpServletRequest() {
        try {
            ServletRequestAttributes attributes = (ServletRequestAttributes) requestAttributes;
            if (Objects.nonNull(attributes)) {
                return attributes.getRequest();
            }
        } catch (Exception e) {
            logger.error("获取httpRequest异常:" + e.getMessage());
        }
        return null;
    }

    public static HttpServletResponse getHttpServletResponse() {
        try {
            ServletRequestAttributes attributes = (ServletRequestAttributes) requestAttributes;
            if (Objects.nonNull(attributes)) {
                return attributes.getResponse();
            }
        } catch (Exception e) {
            logger.error("获取httpResponse异常:" + e.getMessage());
        }
        return null;
    }
}
public class SessionUtils {
    private SessionUtils() {
    }

    /**
     * 修改、删除Cookie时，新建的Cookie除value、maxAge之外的所有属性，
     * 例如name、path、domain等，都要与原Cookie完全一样。
     * 否则，浏览器将视为两个不同的Cookie不予覆盖，导致修改、删除失败。
     */

    private final static Logger logger = LoggerFactory.getLogger(SessionUtils.class);


    private static HttpServletRequest httpServletRequest = HttpUtils.getHttpServletRequest();


    public static Object getSession(String key) {
        try {
            if (StringUtils.isNotEmpty(key)) {
                if (Objects.nonNull(httpServletRequest)) {
                    HttpSession session = httpServletRequest.getSession();
                    return session.getAttribute(key);
                }
            }
        } catch (Exception e) {
            logger.error("session添加异常!", e.getMessage());
        }
        return "session获取的key为空!";
    }

    public static void save(String key, Object data) {
        try {
            if (Objects.nonNull(httpServletRequest)) {
                HttpSession session = httpServletRequest.getSession();
                session.setAttribute(key, data);
            }
        } catch (Exception e) {
            logger.error("session添加失败!", e.getMessage());
        }
    }

    public static void delete(String key) {
        try {
            if (Objects.nonNull(httpServletRequest)) {
                HttpSession session = httpServletRequest.getSession();
                session.removeAttribute(key);
            }
        } catch (Exception e) {
            logger.error("session删除失败!", e.getMessage());
        }
    }
}
public class CookiesUtils {

    public static final String TOKEN = "token";

    private CookiesUtils() {

    }

    /**
     * 修改、删除Cookie时，新建的Cookie除value、maxAge之外的所有属性，
     * 例如name、path、domain等，都要与原Cookie完全一样。
     * 否则，浏览器将视为两个不同的Cookie不予覆盖，导致修改、删除失败。
     */

    private final static Logger logger = LoggerFactory.getLogger(CookiesUtils.class);

    private static HttpServletResponse httpServletResponse = HttpUtils.getHttpServletResponse();

    private static HttpServletRequest httpServletRequest = HttpUtils.getHttpServletRequest();


    public static String getCookie(String key) {
        try {
            if (StringUtils.isNotEmpty(key)) {
                if (Objects.nonNull(httpServletRequest)) {
                    for (Cookie cookie : httpServletRequest.getCookies()) {
                        if (Objects.equals(cookie.getName(), key)) {
                            return cookie.getValue();
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error("cookie获取异常!", e.getMessage());
        }
        return "cookie获取的token为空!";
    }

    public static void save(String key, Object data) {
        try {
            if (Objects.nonNull(httpServletResponse)) {
                Cookie cookie = new Cookie(key, String.valueOf(data));
                //设置cookie有效时间为30分钟
                cookie.setMaxAge(30 * 60);
                //禁止js脚本读取cookie必须通过接口读取防止XSS攻击
                cookie.setHttpOnly(true);
                httpServletResponse.addCookie(cookie);
            }
        } catch (Exception e) {
            logger.error("cookie添加失败!", e.getMessage());
        }
    }

    public static void delete(String key) {
        try {
            if (Objects.nonNull(httpServletRequest)) {
                Cookie[] cookies = httpServletRequest.getCookies();
                for (Cookie cookie : cookies) {
                    if (Objects.equals(cookie.getName(), key)) {
                        cookie.setValue(null);
                        cookie.setMaxAge(0);
                    }
                }
            }
        } catch (Exception e) {
            logger.error("cookie删除失败!", e.getMessage());
        }
    }

    public static boolean exists(String key) {
        boolean flag = false;
        try {
            if (Objects.nonNull(httpServletRequest)) {
                Cookie[] cookies = httpServletRequest.getCookies();
                for (Cookie cookie : cookies) {
                    if (Objects.equals(cookie.getName(), key)) {
                        flag = true;
                    }
                }
            }
        } catch (Exception e) {
            logger.error("exists-cookie异常!", e.getMessage());
        }
        return flag;
    }
}

 

登录的service实现类 

public boolean login(User user) {
        try {
            if (StringUtils.isNoneEmpty(user.getUserName(), user.getPwd())) {
                //根据用户名查询 pwd负责接收前台敏文密码password是数据库加密后的密码
                User users = UserRepository.getByUserName(user.getUserName());
                if (Objects.nonNull(user)) {
                    //这里是根据角色查询权限user.setPermissions(permissionService.getPermissions(user.getRoles()));
                    if (StringUtils.isNoneEmpty(users.getPassword())) {
                        //算法校验
                        boolean flag = CryptUtils.verify(users.getPassword()，user.getPwd());
                        if (flag) {
                            //session和cookie操作
                            //建议token加密(思路为cookie的值不加密，session的key是由cookie提供的值进行加密得到key)
                            String token = 保证唯一,可以使用数据库唯一列,例如用户名;
                            if (CookiesUtils.exists(token)) {
                                CookiesUtils.delete(token);
                                SessionUtils.delete(token);
                            } else {
                                CookiesUtils.save(CookiesUtils.TOKEN, token);
                                SessionUtils.save(token, user);
                            }
                            return true;
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error("登录异常！", e.getMessage());
        }
        return false;
    }

权限

public class UserUtils {
    private UserUtils() {
    }

    public static User get() {
        try {
            String token = CookiesUtils.getCookie(CookiesUtils.TOKEN);
            if (StringUtils.isNotEmpty(token)) {
                //建议token加密参考登录
                return (User) SessionUtils.getSession(token);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

/**
 * 授权注解
 */
@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface PreAuthorize {
    String value() default "";
}

 

/**
 * 权限拦截器
 */
public class SecurityInterceptor extends HandlerInterceptorAdapter {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        boolean flag = false;
        try {
            HttpStatus httpStatus = hasPermission(handler);
            String methodClass = ((HandlerMethod) handler).getMethod().getDeclaringClass().getName();
            String methodName = ((HandlerMethod) handler).getMethod().getName();
            switch (httpStatus) {
                case OK:
                    //认证成功放行。
                    flag = true;
                    break;
                case UNAUTHORIZED:
                    //如果没有权限响应401未授权
                    response.sendError(HttpStatus.UNAUTHORIZED.value(), "Message:unauthorized");
                    logger.warn("401未授权!未授权的接口:" + methodClass + "." + methodName);
                    break;
                case FORBIDDEN:
                    //如果未登录请求则响应403被禁用
                    response.sendError(HttpStatus.FORBIDDEN.value(), "Message:forbidden");
                    logger.warn("403禁止访问!");
                    break;
            }
        } catch (Exception e) {
            logger.error("权限认证异常!", e.getMessage());
        }
        return flag;
    }

   /**
     * 是否有权限
     *
     * @param handler handler
     * @return boolean
     */
    private HttpStatus hasPermission(Object handler) {
        //默认状态码为403(被禁止)
        HttpStatus httpStatus = HttpStatus.FORBIDDEN;
        if (handler instanceof HandlerMethod) {
            HandlerMethod handlerMethod = (HandlerMethod) handler;
            // 获取方法上的注解
            PreAuthorize preAuthorize = handlerMethod.getMethod().getAnnotation(PreAuthorize.class);
            // 如果方法上的注解为空 则获取类的注解
            if (Objects.isNull(preAuthorize)) {
                preAuthorize = handlerMethod.getMethod().getDeclaringClass().getAnnotation(PreAuthorize.class);
            }
            // 如果标记了注解，则判断权限
            if (Objects.nonNull(preAuthorize) && StringUtils.isNotBlank(preAuthorize.value())) {
                // redis或数据库 中获取该用户的权限信息 并判断是否有权限
                SysUser user = UserUtils.get();
                if (Objects.nonNull(user)) {
                    for (SysRole role : user.getSysRoles()) {
                        if (Objects.nonNull(role.getSysPermissions())) {
                            for (SysPermission permission : role.getSysPermissions()) {
                                if (StringUtils.isNotBlank(permission.getPerCode())) {
                                    while (Objects.equals(permission.getPerCode(), preAuthorize.value())){
                                        //返回状态码为200(成功)
                                        httpStatus = HttpStatus.OK;
                                    }
                                } else {
                                    //返回状态码为401(未授权)
                                    httpStatus = HttpStatus.UNAUTHORIZED;
                                }
                            }
                        }
                    }
                }
            }
        }
        return httpStatus;
    }
}

@Configuration
public class MVCConfig extends WebMvcConfigurationSupport {
    @Bean
    public SecurityInterceptor getSecurityInterceptor() {
        return new SecurityInterceptor();
    }


    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //添加拦截器
        InterceptorRegistration registration = registry.addInterceptor(getSecurityInterceptor());
        //排除路径
        registration.excludePathPatterns("/login");
        registration.excludePathPatterns("/logout");
        //注意必须放行spring boot 提供的默认错误controller
        registration.excludePathPatterns("/error");
        //拦截全部路径
        registration.addPathPatterns("/**");
    }
}

注解用法

    @PreAuthorize("user@create")要和数据库字段permission的renZhen保证一样
    @GetMapping("create")
    public String create(){
        return "我是授权过的！";
    }

Vue通过Axios处理401,403,404,500即可。cookie和session和前台无关，由后台自行处理

 

吕小小布
关注
专栏目录
[0]Spring Boot+Vue全栈开发实战.学习笔记
qq_57210034的博客
05-23 380
目录 Spring Boot 入门 .. .... .. ... .. .. …. ....... .. ....………......….. ... .. …..... ... .……… .... .. 1 1.1 Spring Boot 简介............... ...... .. .. …. ... .........………… .. .. ….. .... ......... ..… ...... .….. 1 1.2 开发第一个 Spring Boot 程序….. ... .. ... .
spring boot + spring security 之 自定义用户登录
weixin_38552343的博客
07-09 3420
搞了两天，学了一个大概，创建security的项目demo已经三四个了，终于初步搞定了登录认证，至于授权，登录都有了，授权不小意思吗？ 哈哈，不扯了，我开始说步骤，直接干货，记到你的小本儿上（这可是我翻了三本书，看数不过来的博客上总结的细节） 我搭建的环境是jdk1.8、spring boot 2.4.8、spring security 5.4.7 以下说明，适合spring security5.0以上版本 我这里先不说原理，直接给你们我能登录的代码（因为标题是自定义，下面的内容都是自定义，详细的看
springboot-vue-shiro-权限整合
01-06
springboot+vue+shiro 前后盾分离，权限整合，vue路由配置解析，有sql语句，shiro 权限验证。
Spring Boot + Vue 前后端分离开发，权限管理的一点思路
weixin_33758863的博客
05-23 470
在传统的前后端不分的开发中，权限管理主要通过过滤器或者拦截器来进行（权限管理框架本身也是通过过滤器来实现功能），如果用户不具备某一个角色或者某一个权限，则无法访问某一个页面。 但是在前后端分离中，页面的跳转统统交给前端去做，后端只提供数据，这种时候，权限管理不能再按照之前的思路来。 首先要明确一点，前端是展示给用户看的，所有的菜单显示或者隐藏目的不是为了实现权限管理，而是为了给用户一个良好的体验，...
(附论文)基于Springboot和Vue的考研互助交流平台系统(403)
最新发布
code_kang_kang的博客
08-25 300
该平台包括管理员和用户两部分。同时还能为用户提供一个方便实用的考研互助交流系统，使得用户能够及时地找到合适自己的考研信息。管理员在使用本系统时，可以通过后台管理员界面管理用户的信息，也可以发布系统公告，让用户及时了解考研信息。(附论文)基于Springboot和Vue的考研互助交流平台系统(403)开发工具：Idea或Eclipse。后端框架：Springboot。Jar包仓库：Maven。
Springboot+Vue后台管理系统-简单的权限管理
justleavel的博客
02-07 2392
首先说一次下最简单的实现权限管理的方法，那就是在数据库中新增一个字段也就是role，然后设置0就是超级管理员1就是普通用户，然后前端我们在左侧导航栏这里这样写： 我们这里data里面传一个·user，然后在create方法里面做一个调取用户数据的方法然后后端相应写一个根据用户id查询的接口： 这里对应前端： request.get("/user/"+this.user.id) 就可以做到对于不同的用户实现不同的界面效果 总之就是在create方法里面增加： let userStr = sessio
二十一、SpringBoot + Jwt + Vue 权限管理系统（1）
Daniel的博客
10-29 1737
文章使用：前后端工具ideaIU-2018.2.5下载拓展使用：前端工具HBuilder下载前端使用工具VSCode下载对比参考 👉🏾👉🏾二、项目环境搭建安装成功测试 👇🏾👇🏾 安装参考 一、Node 的安装这就表示你已经安装成功啦，牛逼开始的第一步！2、接下来，我们安装vue的环境 出现的问题解决 👉🏾👉🏾七、使用vue ui命令没有反应3、从而跳转至vue可视化工具界面，创建vue-admin前端项目 注: 前提是idea中安装vue.js插件命令很简单： 然后我们打开
二十二、SpringBoot + Jwt + Vue 权限管理系统 （2）
Daniel的博客
10-29 931
Element-ui布局选择Index.vue index.js 目前布局显示 ① 头像②下拉菜单③链接Index.vue 当前完整代码： 最终显示 最终显示： 2. 因为考虑到后面需要做动态菜单，所以单独 Home.vue 页面出来，因此我新建了个：SideMenu.vue SideMenu.vue作为一个组件添加到Home.vue中，我们首选需要导入，然后声明compoents，然后才能使用标签，所以在Home.vue中代码如下： Home.vue index.js 注意Si
Spring Boot和Vue.js的web商城系统源码.zip
01-06
三、Spring Boot与Vue.js的整合 1. RESTful API设计：Spring Boot后端提供符合RESTful原则的接口，如GET、POST、PUT、DELETE等，以JSON格式交互数据。 2. Axios调用：Vue.js前端使用Axios库发起HTTP请求，与后端...
spring boot+shiro+mybatis实现不同用户登录显示不同的权限菜单
06-28
在本项目中，MyBatis与Spring Boot整合，用于处理数据库操作，如用户信息的存取、角色与权限的关联等。通过Mapper接口，开发者可以方便地定义SQL语句，提高代码的可读性和维护性。 **实现步骤** 1. **配置Shiro**：...
SpringBoot+Vue前后端分离，使用SpringSecurity完美处理权限问题
10-12
转载他人 https://blog.csdn.net/u012702547/article/details/79010010 https://blog.csdn.net/u012702547/article/details/79019510
vue+element+springboot+shiro权限控制
12-07
vue+element+springboot+shiro权限控制,mysql数据库 登录帐号/密码 admin:111111
java vue 脚手架,我的springboot+vue前后端分离权限脚手架
weixin_42302763的博客
03-12 363
我的springboot+vue前后端分离权限脚手架其实两周前就写好了，就是拖着一直没补个README文档。喜欢的同学帮我上个星星：biu。有bug请issue我。码云地址：码云biuBiu，boot和vue的连读而想到的名字。一个基于Spring Boot和Vue的Web开发脚手架，整合和最基础的RBAC权限控制，包括：菜单权限、按钮权限、接口权限。前端使用vue-cli，后端使用Spring ...
vue+springboot后台实现页面按钮权限
weixin_30672295的博客
09-12 1215
思路 　　1.用户跟角色关联 　　2.角色跟菜单关联 　　3.菜单跟菜单下的按钮关联 　　4.后端返回每个菜单下的按钮，前端通过自定义事件，在每个按钮上加上相应的事件 打字麻烦，还是看图吧！ 建立btn.js 然后在main.js中引入btn.js 页面按钮中加入v-has=" " 后端返回数据格式 页面之前效果 ...
基于 SpringBoot 和 Vue.js 的权限管理系统部署教程
jonssonyan
02-06 1580
在上一篇文章我介绍了我的新项目——基于 SpringBoot 和 Vue.js 的权限管理系统，本文主要介绍该系统的部署。
SpringBoot和Vue实现权限菜单功能——基于SpringBoot和Vue的后台管理系统项目系列博客（十七）
IronmanJay
11-09 2807
今天的主要内容包括：新建角色数据表、使用代码生成器生成角色代码、测试生成的角色代码、新建菜单数据表、使用代码生成器生成菜单代码、测试生成的菜单代码、分配权限菜单基础功能实现、分配权限菜单图表显示与编辑功能、分配权限菜单的授权保存功能、赋予用户以角色、实现用户角色的动态菜单、实现用户菜单的动态路由、完成404提示界面、配置管理员修改用户权限后重新登录、父级菜单不显示的Bug解决、选择部分子菜单后子菜单全部选中的Bug解决、随机访问某一界面却进入404界面Bug的解决、访问修改密码界面却进入404界面Bug的解
yii beforeaction 如何赋值全局变量_前端如何进行用户权限管理
weixin_39564527的博客
12-04 112
1：问题：假如在做一个管理系统，面向老师学生的，学生提交申请，老师负责审核（或者还需要添加其他角色，功能权限都不同）。现在的问题是，每种角色登录看到的界面应该都是不一样的，那这个页面的区分如何实现呢？2：要不要给老师和学生各自设计一套页面？这样工作量是不是太大了，并且如果还要加入其它角色的话，难道每个角色对应一套代码？所以我们需要用一套页面适应各种用户角色，并根据身份赋予他们不同权限3：权限设计与...
二十三、SpringBoot + Jwt + Vue 权限管理系统 （3）
Daniel的博客
11-03 1140
一步一步来，不要急躁哦！！ 当时显示： 这个路由问题我提供两个解决方案：这里我们使用第二种解决方案，这类简单点，后续我们再开发页面的时候就不需要去改动路由，可以动态绑定。综上，我们把加载菜单数据这个动作放在router.js中。Router有个前缀拦截，就是在路由到页面之前我们可以做一些判断或者加载数据。src/router/index.js 这样我们才能绑定添加到路由。所以我会修改mock中的nav的数据成这样： 注意这两个的引入哦！ 最后效果如下： 上面做完之后，总还觉得少
Spring Boot + Shiro + Vue实现的RBAC权限管理系统
资源摘要信息: "基于Spring Boot、Shiro和Vue的权限管理系统是一个综合性的后台管理系统开发项目，该项目结合了Spring Boot作为后端开发框架，Shiro作为安全框架以及Vue作为前端用户界面框架，共同实现了一个完整的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值