Shiro+SpringBoot+JPA

最新推荐文章于 2020-06-24 13:55:44 发布
最新推荐文章于 2020-06-24 13:55:44 发布
阅读量311 收藏
点赞数
分类专栏： 权限安全 文章标签： SpringBoot Shiro JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/renbowen9758/article/details/90299853
版权
环境准备

Spring Boot 2.0.4.RELEASE
pom.xml

<dependency>      
    <groupId>org.springframework.boot</groupId>      
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>      
    <groupId>org.springframework.boot</groupId>      
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>     
    <groupId>org.apache.shiro</groupId>      
    <artifactId>shiro-core</artifactId>      
    <version>1.2.3</version>
</dependency>
<dependency>      
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-spring</artifactId>
    <version>1.2.3</version>
</dependency>      
<dependency>          
    <groupId>com.alibaba</groupId>          
    <artifactId>druid</artifactId>          
    <version>1.0.20</version>      
</dependency>      
<dependency>          
    <groupId>org.apache.commons</groupId>         
    <artifactId>commons-lang3</artifactId>        
    <version>3.7</version>      
</dependency>     
<dependency>          
    <groupId>org.apache.commons</groupId>        
    <artifactId>commons-collections4</artifactId>         
    <version>4.1</version>      
</dependency>     
<dependency>          
    <groupId>org.springframework</groupId>   
    <artifactId>spring-context-support</artifactId> 
</dependency>   
<dependency>        
    <groupId>org.apache.tomcat.embed</groupId>  
    <artifactId>tomcat-embed-jasper</artifactId> 
</dependency>    
<dependency>          
    <groupId>javax.servlet</groupId>     
    <artifactId>javax.servlet-api</artifactId>   
</dependency>     
<dependency>          
    <groupId>javax.servlet</groupId>        
    <artifactId>jstl</artifactId>      
</dependency>     
<dependency>         
    <groupId>org.projectlombok</groupId>       
    <artifactId>lombok</artifactId>      
    <version>1.16.20</version>         
    <scope>provided</scope>   
</dependency>
<dependency>    
    <groupId>mysql</groupId>    
    <artifactId>mysql-connector-java</artifactId> 
    <scope>runtime</scope>
</dependency>
<dependency> 
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>  
    <scope>test</scope>
</dependency>

数据库MySQL

`SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
DROP TABLE IF EXISTS `permission`;CREATE TABLE `permission`  (  
`pid` int(11) NOT NULL COMMENT '权限id', 
`name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT 
NULL,  `url` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT 
NULL,  PRIMARY KEY (`pid`) USING BTREE) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci 
ROW_FORMAT = Compact;
INSERT INTO `permission` VALUES (1, 'add', NULL);INSERT INTO `permission` VALUES (2, 'delete', NULL);INSERT INTO `permission` VALUES (3, 'edit', NULL);INSERT INTO `permission` VALUES (4, 'query', NULL);
DROP TABLE IF EXISTS `permission_role`;CREATE TABLE `permission_role`  (  `id` int(11) NOT NULL AUTO_INCREMENT,  `rid` int(11) NOT NULL,  `pid` int(11) NOT NULL,  PRIMARY KEY (`id`) USING BTREE) ENGINE = InnoDB AUTO_INCREMENT = 7 CHARACTER SET = utf8 COLLATE = 
utf8_general_ci ROW_FORMAT = Compact;
INSERT INTO `permission_role` VALUES (1, 1, 1);INSERT INTO `permission_role` VALUES (2, 1, 2);INSERT INTO `permission_role` VALUES (3, 1, 3);INSERT INTO `permission_role` VALUES (4, 1, 4);INSERT INTO `permission_role` VALUES (5, 2, 1);INSERT INTO `permission_role` VALUES (6, 2, 4);
DROP TABLE IF EXISTS `role`;CREATE TABLE `role`  (  `rid` int(11) NOT NULL AUTO_INCREMENT COMMENT '角色id',  `rname` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT 
NULL,  PRIMARY KEY (`rid`) USING BTREE) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = 
utf8_general_ci ROW_FORMAT = Compact;
INSERT INTO `role` VALUES (1, 'admin');INSERT INTO `role` VALUES (2, 'customer');
DROP TABLE IF EXISTS `user`;CREATE TABLE `user`  (  `uid` int(11) NOT NULL COMMENT '用户id',  `username` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT 
NULL,  `password` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT 
NULL,  PRIMARY KEY (`uid`) USING BTREE) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci 
ROW_FORMAT = Compact;-
NSERT INTO `user` VALUES (1, 'admin', '123');INSERT INTO `user` VALUES (2, 'demo', '123');-
DROP TABLE IF EXISTS `user_role`;CREATE TABLE `user_role`  (  `id` int(11) NOT NULL AUTO_INCREMENT,  `uid` int(11) NOT NULL,  `rid` int(11) NOT NULL,  PRIMARY KEY (`id`) USING BTREE) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = 
utf8_general_ci ROW_FORMAT = Compact;
INSERT INTO `user_role` VALUES (1, 1, 1);
INSERT INTO `user_role` VALUES (2, 2, 2);
SET FOREIGN_KEY_CHECKS = 1;

数据库表
image
image
image
image
image

配置文件
spring:  
    datasource:    
        type: com.alibaba.druid.pool.DruidDataSource    
        driver-class-name: com.mysql.jdbc.Driver    
        url: jdbc:mysql://127.0.0.1:3306/shiro?characterEncoding=UTF-8   
        username: root   
        password: root  
     mvc:   
        view:      
            prefix: /pages/      
            suffix: .jsp 
     jpa:    
        show-sql: true
创建自己的Realm 继承AuthorizingRealm

重写里面的两个方法
授权
doGetAuthorizationInfo(PrincipalCollection principalCollection)
从PrincipalCollection中取出User
创建一个List permissionList = new Arraylist<>();
获取到该用户对应的角色
获取到该角色下所有的权限
将权限名称添加到permissionList里
声明一个SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
将permissionList放入info里 info.addStringPermissions(permissionList);
最后将info返回
认证登陆方法
doGetAuthenticationInfo(AuthenticationToken token)
这个方法需要将我们传入的token转换成UsernamePasswordToken
然后从里面取出对应的username
再从数据库里取出对应的User
转换成SimpleAuthenticationInfo对象

public class AuthReaml extends AuthorizingRealm {    
    @Autowired    
    private UserRepository userRepository;    
    @Autowired    
    private UserRoleRepository userRoleRepository;    
    @Autowired    
    private RoleRepository roleRepository; 
    @Autowired    
    private PermissionRepository permissionRepository;    
    @Autowired    
    private PermissionRoleRepository permissionRoleRepository;
    
    /**     
    * 授权  
    * @param principalCollection 
    * @return    
    */    
    @Override    
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {        
        User user = (User) principalCollection.fromRealm(this.getClass().getName()).iterator().next();       
        List<String> permissionList = new ArrayList<>();       
        List<String> roleNameList = new ArrayList<>();   
        //根据用户id找到对应的角色        
        //定义角色集合        
        Set<Role> roleSet = new HashSet<>();        
        //从用户角色中间表查找到该用户下的所有角色        
        List<UserRole> userRoleList = userRoleRepository.findByUid(user.getUid());       
        //使用lambda取到该用户下所有的rid        
        List<Integer> rids = userRoleList.stream().map(UserRole::getRid).collect(Collectors.toList());       
        //获取数据库所有角色        
        List<Role> roleList = roleRepository.findAll();        
        for (Integer rid:rids){           
            for (Role role : roleList){                
                if (rid == role.getRid()){                    
                     //存入角色集合中                    
                    roleSet.add(role);               
                 }            
            }        
        }        
        //遍历角色集合        
        if(CollectionUtils.isNotEmpty(roleSet)){            
            //如果角色集合不为空，创建权限集合//           
            Set<Permission> permissionSet = new HashSet<>();        
            //通过角色id从权限角色中间表获取到所有的权限id           
            //1.先查询所有的角色权限集合            
            List<PermissionRole> permissionRoleList = permissionRoleRepository.findAll();           
            //2.通过判断角色id和权限id 获取该角色对应的所有权限id           
            //创建一个集合用来存放该角色对应的权限id            
            List<Integer> permissionIds = new ArrayList<>();           
            if (CollectionUtils.isNotEmpty(permissionRoleList)){                
            for (Role role:roleSet){                    
                roleNameList.add(role.getRname());                    
                for (PermissionRole permissionRole:permissionRoleList){                        
                    if (role.getRid()  == permissionRole.getRid()){                           
                    permissionIds.add(permissionRole.getPid());                        
                    }                   
                }                
            }    
        }       
            //通过权限id获取到所有的权限数据           
            //从数据库查找到所有的权限数据            
            List<Permission> permissions = permissionRepository.findAll();          
            if(CollectionUtils.isNotEmpty(permissionIds) && CollectionUtils.isNotEmpty(permissions)){             
                for (Integer permissionid : permissionIds){                  
                    for (Permission permission:permissions){                     
                        if (permissionid == permission.getPid()){                           
                        permissionList.add(permission.getName());                       
                        }                
                    }           
                }          
            }      
        }        
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();       
        info.addStringPermissions(permissionList);       
        info.addRoles(roleNameList);       
        return info;   
    }

    /** * 认证登陆
    * @param token
    * @return
    * @throws AuthenticationException 
    */
    @Overrideprotected 
    AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws AuthenticationException {   
        UsernamePasswordToken usernamePasswordToken = (UsernamePasswordToken) token;    
        String username = usernamePasswordToken.getUsername();    
        User user = userRepository.findByUsername(username);    
        return new SimpleAuthenticationInfo(user,user.getPassword(),
        this.getClass().getName());
    }
密码校验功能重写 新建类CredentialMatcher 继承SimpleCredentialsMatcher
public class CredentialMatcher extends SimpleCredentialsMatcher {    
/**    
* 密码校验规则重写   
* @param token     
* @param info     
* @return     
*/    
@Override   
    public boolean doCredentialsMatch(AuthenticationToken token, AuthenticationInfo info) {       
        UsernamePasswordToken usernamePasswordToken =  (UsernamePasswordToken) token;        
        //取出当前用户输入的密码        
        String password = new String(usernamePasswordToken.getPassword());       
        //获取数据库中该用户密码        
        String dbPassword = (String)info.getCredentials();        
        return this.equals(password,dbPassword);   
     }
}
创建Shiro配置类 ShiroConfiguration

@Qualifier 表示从spring中取出来的

@Configuration
public class ShiroConfiguration {    
    @Bean("shiroFilter")    
    public ShiroFilterFactoryBean shiroFilter(@Qualifier("securityManager") SecurityManager securityManager){        
        ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();       
        bean.setSecurityManager(securityManager);    
        //定义登陆url
        bean.setLoginUrl("/login"); 
        //登陆成功之后的url
        bean.setSuccessUrl("/index");       
        bean.setUnauthorizedUrl("/unauthorized");       
        LinkedHashMap<String,String> filterChainDefinitionMap = new LinkedHashMap<>();      
        //必须登陆才可以访问index
        filterChainDefinitionMap.put("/index","authc");   
        //不需要登陆就可以访问login
        filterChainDefinitionMap.put("/login","anon");       
        filterChainDefinitionMap.put("/loginUser","anon");
        //        filterChainDefinitionMap.put("/druid/**","anon"); //配置durid完全放行        
        filterChainDefinitionMap.put("/admin","roles[admin]"); //具有admin角色的用户才可以访问 /admin接口        
        filterChainDefinitionMap.put("/edit","perms[edit]"); //具有edit这个权限才可以访问 /edit接口        
        filterChainDefinitionMap.put("/**","user");        
        bean.setFilterChainDefinitionMap(filterChainDefinitionMap);      
        return bean;   
     }    
    @Bean("securityManager")    
    public SecurityManager securityManager(@Qualifier("authReaml") AuthReaml authReaml){        
        DefaultWebSecurityManager manager = new DefaultWebSecurityManager();       
        manager.setRealm(authReaml);        
        return manager;   
     }    
    @Bean("authReaml")    
    public AuthReaml authReaml(@Qualifier("credentialMatcher") CredentialMatcher matcher){        
        AuthReaml authReaml = new AuthReaml();        
        authReaml.setCredentialsMatcher(matcher);       
        return authReaml;   
     }    
    @Bean("credentialMatcher")    
    public CredentialMatcher credentialMatcher(){       
        return new CredentialMatcher();   
    }   
    //Shiro跟spring的关联
    @Bean    
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(@Qualifier("securityManager") SecurityManager securityManager){       
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();       
        advisor.setSecurityManager(securityManager);       
        return advisor;   
     }   
     
    @Bean    
    public DefaultAdvisorAutoProxyCreator defaultAdvisorAutoProxyCreator(){        
        DefaultAdvisorAutoProxyCreator creator = new DefaultAdvisorAutoProxyCreator();        
        creator.setProxyTargetClass(true);        
        return creator;    
    }
}
创建Controller
@Controller
public class TestController {

    @RequestMapping("/login")
    public String login(){
        return "login";
    }
    @RequestMapping("/logOut")
    public String logOut(){
        Subject subject = SecurityUtils.getSubject();
        if (subject!=null){
            subject.logout();
        }
        return "login";
    }
    @RequestMapping("/index")
    public String index(){
        return "index";
    }
    @RequestMapping("/admin")
    @ResponseBody
    public String admin(){
        return "admin success";
    }
    @RequestMapping("/unauthorized")
    public String unauthorized(){
        return "unauthorized";
    }
    @RequestMapping("/edit")
    @ResponseBody
    public String edit(){
        return "edit success";
    }
    @RequestMapping("/loginUser")
    public String loginUser(@RequestParam("username") String username, @RequestParam("password") String password, HttpSession session){
        UsernamePasswordToken  token = new UsernamePasswordToken(username,password);
        Subject subject = SecurityUtils.getSubject();
        try {
            subject.login(token);
            User user = (User) subject.getPrincipal();
            session.setAttribute("user",user);
            return "index";
        }catch (Exception e){
            return "login";
        }
    }
}
编写jsp页面
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>    
<title>Login</title>
</head><body>
<h1>欢迎登陆</h1>
<form action="/loginUser" method="post">    
<input type="text" name="username"><br>   
<input type="password" name="password"><br>    
<input type="submit" value="提交"></form>
</body>
</html>


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head> 
<title>Home</title>
</head>
<body><h1>欢迎登陆，${user.username}</h1>
</body>
</html>


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>    
<title>unauthorized</title>
</head>
<body>
Unauthorized!
</body>
</html>

省略repository接口与实体类

总结：
优点：
提供了一套框架，而且这个框架可用，且易于使用
更灵活，应对需求能力强，Web能力强
可以与很多框架和应用进行集成
缺点：
除了自己实现RBAC外，操作的界面也需要自己实现

Rick Jen
关注
专栏目录
一看就懂！SpringBoot+Shiro+JPA 搭建管理员、角色、权限通用权限管理系
大誌的博客
04-07 4605
Shiro Shiro是一个强大易用的Java安全框架,提供了认证、授权、加密和会话管理等功能。详细介绍可以看我的另一篇Shiro的学习笔记 Shiro 安全框架入门笔记 这次我们利用shiro快速搭建一个通用的权限管理系统，如果是需要前后端分离可以看我另一篇文章 Springboot +Shiro 前后端分离式权限管理系统 github代码:https://github.com/F...
springboot+shiro整合
weixin_45255645的博客
10-01 316
什么是shiro? Apache shiro是java的一个安全框架，shiro在开发中简单易用，其中shiro可以帮我们做：认证，授权，拦截，加密，会话处理，缓存等一些功能。 什么是认证？ 登陆某一个网站的时候，需要判断用户使用已经登陆，判断用户是否登录就是认证 什么是授权？ 登陆之后，需要判断用户的权限，然后按照不同的权限跳转到不同的页面。 shiro的三大核心组件： Subject Subject：即“当前操作用发户”。但是，在Shiro中，Subject这一概念并不仅仅指人，也可以是
springboot+jpa+shiro基础权限管理系统Demo
03-16
springboot+jap+shiro 实现了用户、 角色、模块三个表的权限管理。增加对druid的数据监控，swagger ui的嵌入， 第一次优先把resources下的test数据库导入， 不然不能登录看到效果。 直接运行Application类即可启动。
spring-boot+shiro+jpa集成
^@Hu@^的博客
06-24 275
###spring-boot+shiro+spring-data-jpa API开发使用基础框架 一、 集成spring-boot 1、 添加spring-boot依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version&g
springboot+jpa+shiro+layui实现权限管理
chuanyuan8669的博客
04-20 876
在上一篇文章中主要简单说明了如何使用springboot与shiro进行整合，同时简单的说明了下shiro相关核心模块，当然关于shiro的说明其实网上已经有了很多技术文章，同时springboot的作用其实就是spring，帮助我们提供java bean的运行环境与管理机制，将我们常说的对象...
springboot+jpa+shiro的简单项目
01-30
个人自主学习及参考网上的资料搭建的一个基于springboot+jpa+shiro的简单的项目。mysql用的是8.0.13版本的，如果是旧版本的mysql可能需要更换mysql的驱动名称及jar包。 该工程是在idea上开发的，可直接导入到idea中 数据库及表会自动创建。目前只用到了user表，其他的是用作权限控制所需要的 启动成功后直接访问localhost:8080即可访问，账号及密码自行注册。
maven+springboot+jpa+shiro权限管理内有数据库sql
03-03
本项目采用"Maven+SpringBoot+JPA+Shiro"的组合，旨在提供一个强大的权限管理解决方案，并附带了数据库SQL脚本，使得开发者能够快速搭建并扩展功能。下面将详细阐述这些技术组件以及它们在项目中的作用。 首先，...
springboot+shiro+jpa+email
11-15
本项目“springboot+shiro+jpa+email”结合了这些技术，旨在提供一个简洁的测试示例，同时也展示了如何将它们整合到一起，以实现数据持久化、权限管理以及邮件发送等功能。 首先，SpringBoot是基于Spring框架的轻量...
tmall_springboot:淘宝天猫电商商城 SpringBoot 基于前后端分离+SpringBoot+BootStrap+Vue.js+JQuery+JPA+Redis+shiro+Elasticsearch
05-14
SpringBoot天猫商城整站 基于前后端分离+SpringBoot+BootStrap、Vue.js、JQuery+JPA+Redis 天猫整站 基于前后端分离+SpringBoot+BootStrap、Vue.js、JQuery+JPA+Redis 一、项目介绍和演示 SPRINGBOOT天猫整站，基于 ...
SpringBoot+Shiro+Jpa+Redis.zip
05-15
《SpringBoot+Shiro+Jpa+Redis：构建高效安全的权限管理系统》 在现代Web应用开发中，权限管理是一个至关重要的环节。本项目通过整合SpringBoot、Shiro、Jpa以及Redis，构建了一个功能完善的权限管理系统。接下来，...
springboot集成jpa以及shiro
04-15
Springboot集成shiro以及数据库jpa实现用户权限、认证的登录，本案例为小型demo，可下载后直接使用
Spring boot + shiro + jpa小案例
09-02
Spring boot + shiro + jpa小案例
SpringBoot+Shiro+JPA+LayUI的后台管理系统
12-27
本系统是一个用SpringBoot做后台开发框架，Shiro做权限管理框架，Spring Data Jpa 做持久层框架，Layui、Layui mini做为前端框架的前后端分离的项目。 即拿即用，上手即会，可以方便你快速的开发一套属于自己的系统。
shiro-auth:使用SpringBoot+SpringJPA+Swagger+Shiro快速搭建前后端分离的权限管理系统
05-10
shiro-auth 快速搭建前后端分离的权限管理系统 提供一套基于SpringBoo+shiro的权限管理思路. 前后端都加以控制,做到按钮/接口级别的权限。 并没有加加密等过多限制，避免增加大家学习的负担。 #####本文只是提供一套基于shiro前后端分离的思路。 根据这个思路我们可以最终使用Spring的拦截器，或者servlet的Filter实现同样的权限管理 演示地址 默认用户 用户 角色 权限 Jack SVIP select;save;delete;update Rose VIP select;save;update Paul P select 后台基于 Springboot JPA Swagger Shiro 前端基于 VUE ElementUI 前端代码： 详细介绍请戳博客 里面有详细的使用介绍以及实现思路。 sql文件在/resources/doc下
SpringBoot+Spring data JPA+FreeMarker+shiro+log4jdbc
12-06
一个用SpringBoot+Spring data JPA+FreeMarker+shiro+log4jdbc完成的demo。
springboot+jpa+Shiro+layui基本手脚架.zip
03-02
"springboot+jpa+Shiro+layui基本手脚架.zip" 提供了一个集成SpringBoot、JPA、Shiro和Layui的权限管理系统的基础架构，旨在帮助开发者快速构建自己的业务系统。下面我们将详细解析这些技术栈的核心概念及其在框架中...
Spring Boot中引入Jpa和Shiro
weixin_44153121的博客
01-16 503
Apache Shiro是一个强大且易用的Java安全框架，具有身份验证、授权、密码加密和会话管理功能。 三个核心组件：Subject, SecurityManager 和 Realms 使用JPA框架的表关联查询，自定义模式可能更好。
Spring Boot + Shiro + JPA 项目整理
codeLife1993的博客
09-10 1155
配置文件 application.properties（页面等资源放在templates中） #mysql configure spring.datasource.url = jdbc:mysql://localhost:3306/popularfeelings?serverTimezone=GMT&amp;characterEncoding=utf-8 spring.datasource.u...
spring boot 2 + jpa + shiro 实现权限管理
andwey的博客
04-17 515
开发版本： IntelliJ IDEA 2019.2.2 jdk1.8 Spring Boot 2.1.11 MySQL8.0 一、创建SpringBoot项目，添加依赖包和配置application.yml 在IDEA中创建一个新的SpringBoot项目 1、pom.xml引用的依赖包如下： <dependency> <groupId>...
Vue+SpringBoot实现的电影院在线订票系统
系统利用前后端分离技术，前端采用Vue.js框架配合ElementUI设计用户界面和处理前端逻辑，后端利用SpringBoot、SpringMVC、Mybatis和Shiro进行功能开发和权限管理。” 本系统的设计与实现主要基于以下几个关键知识点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值