ssm进行shiro认证步骤

最新推荐文章于 2021-06-20 01:03:07 发布
最新推荐文章于 2021-06-20 01:03:07 发布
阅读量173 收藏
点赞数
分类专栏： shiro 文章标签： shiro java ssm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45068048/article/details/111125670
版权

1.首先编写xml配置文件

<!--	定义用户自定义的realm-->
	<bean id="myrealm" class="com.hfxt.controller.shiro.UserRealm">  
	<!--		设置加密匹配器-->
		<property name="credentialsMatcher">
			<bean class="org.apache.shiro.authc.credential.HashedCredentialsMatcher">
            <property name="hashIterations" value="1024"></property>
				<property name="hashAlgorithmName" value="md5"></property>
			</bean>
		</property>
	</bean>
	<!--	引用了工具类-->
	<bean id="roleOrFillter" class="com.hfxt.controller.shiro.CustomRolesAuthorizationFilter"/>
<!--	配置权限管理器-->
	<bean id="securityManager" class="org.apache.shiro.web.mgt.DefaultWebSecurityManager">
		<property name="realms" >
			<list>
				<ref bean="myrealm"/>
			</list>
		</property>
	</bean>
<!--	logout过滤器-->
	<bean id="logout" class="org.apache.shiro.web.filter.authc.LogoutFilter">
		<property name="redirectUrl" value="/loginAjax.jsp" />
	</bean>
<!--	配置过滤器工厂-->
	<bean id="shiroFilter" class="org.apache.shiro.spring.web.ShiroFilterFactoryBean">
<!--		调用配置好的过滤管理器-->
		<property name="securityManager" ref="securityManager"/>
		<!--		登录页面-->
		<property name="loginUrl" value="/login/tologin.html"/>
		<!--		登陆成功页面-->
		<property name="successUrl" value="/filmInfo/index.html"/>
		<!--		权限不足页面-->
		<property name="unauthorizedUrl" value="/login/unauthorized"/>
		<!--		引用工具类实现满足一个角色权限即可["buyer,operator"]-->
		<property name="filters" >
			<map>
				<entry key="roleOrFilter" value-ref="roleOrFillter"/>
			</map>
		</property>
<!--		权限配置-->
		<property name="filterChainDefinitions">
		<!--			anno可以匿名访问，即可以不用登录就可以访问；-->
<!--			authc必须登录之后才可以访问；-->
<!--			logout 退出 由于shiro有缓存机制 必须登出-->
			<value>
				/login/**=anon
				/filmInfo/**=authc,roles["buyer,operator"]				        /filmInfo/**=authc,roleOrFilter["buyer,operator"]
				/shop/**=authc
				/echar.jsp=authc
				/logout.jsp = logout

			</value>
		</property>
	</bean>

2.实现shiro角色 引用工具类实现满足一个角色权限即可[“buyer,operator”]的工具类

package com.hfxt.controller.shiro;

import org.apache.shiro.subject.Subject;
import org.apache.shiro.web.filter.authz.AuthorizationFilter;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class CustomRolesAuthorizationFilter extends AuthorizationFilter {


    protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
            throws Exception {
        Subject subject = getSubject(request, response);
        String[] rolesArray = (String[]) mappedValue;
        //没有角色限制，有权限访问
        if (rolesArray == null || rolesArray.length == 0) {
            return true;
        }
        for (int i = 0; i < rolesArray.length; i++) {
            //若当前用户是rolesArray中的任何一个，则有权限访问
            if (subject.hasRole(rolesArray[i])) {
                return true;
            }
        }
        return false;
    }

}

3.对UsernamePasswordToken类进行封装的工具类

package com.hfxt.controller.shiro;

import org.apache.shiro.authc.UsernamePasswordToken;

public class CustomToken extends UsernamePasswordToken {

	public CustomToken() {
		super();
	}

	/**
	 * Constructs a new UsernamePasswordToken encapsulating the username and password submitted during an authentication attempt, with a <tt>null</tt>
	 * {@link #getHost() host} and a <tt>rememberMe</tt> default of <tt>false</tt>.
	 * 
	 * @param username
	 *        the username submitted for authentication
	 * @param password
	 *        the password character array submitted for authentication
	 */
	public CustomToken(final String username, final char[] password) {
		this(username, password, false, null);
	}

	/**
	 * Constructs a new UsernamePasswordToken encapsulating the username and password submitted during an authentication attempt, with a <tt>null</tt>
	 * {@link #getHost() host} and a <tt>rememberMe</tt> default of <tt>false</tt>
	 * <p/>
	 * <p>
	 * This is a convience constructor and maintains the password internally via a character array, i.e. <tt>password.toCharArray();</tt>. Note that storing a
	 * password as a String in your code could have possible security implications as noted in the class JavaDoc.
	 * </p>
	 * 
	 * @param username
	 *        the username submitted for authentication
	 * @param password
	 *        the password string submitted for authentication
	 */
	public CustomToken(final String username, final String password) {
		this(username, password != null ? password.toCharArray() : null, false, null);
	}

	/**
	 * Constructs a new UsernamePasswordToken encapsulating the username and password submitted, the inetAddress from where the attempt is occurring, and a
	 * default <tt>rememberMe</tt> value of <tt>false</tt>
	 * 
	 * @param username
	 *        the username submitted for authentication
	 * @param password
	 *        the password string submitted for authentication
	 * @param host
	 *        the host name or IP string from where the attempt is occuring
	 * @since 0.2
	 */
	public CustomToken(final String username, final char[] password, final String host) {
		this(username, password, false, host);
	}

	/**
	 * Constructs a new UsernamePasswordToken encapsulating the username and password submitted, the inetAddress from where the attempt is occurring, and a
	 * default <tt>rememberMe</tt> value of <tt>false</tt>
	 * <p/>
	 * <p>
	 * This is a convience constructor and maintains the password internally via a character array, i.e. <tt>password.toCharArray();</tt>. Note that storing a
	 * password as a String in your code could have possible security implications as noted in the class JavaDoc.
	 * </p>
	 * 
	 * @param username
	 *        the username submitted for authentication
	 * @param password
	 *        the password string submitted for authentication
	 * @param host
	 *        the host name or IP string from where the attempt is occuring
	 * @since 1.0
	 */
	public CustomToken(final String username, final String password, final String host) {
		this(username, password != null ? password.toCharArray() : null, false, host);
	}

	/**
	 * Constructs a new UsernamePasswordToken encapsulating the username and password submitted, as well as if the user wishes their identity to be remembered
	 * across sessions.
	 * 
	 * @param username
	 *        the username submitted for authentication
	 * @param password
	 *        the password string submitted for authentication
	 * @param rememberMe
	 *        if the user wishes their identity to be remembered across sessions
	 * @since 0.9
	 */
	public CustomToken(final String username, final char[] password, final boolean rememberMe) {
		this(username, password, rememberMe, null);
	}

	/**
	 * Constructs a new UsernamePasswordToken encapsulating the username and password submitted, if the user wishes their identity to be remembered across
	 * sessions, and the inetAddress from where the attempt is ocurring.
	 * <p/>
	 * <p>
	 * This is a convience constructor and maintains the password internally via a character array, i.e. <tt>password.toCharArray();</tt>. Note that storing a
	 * password as a String in your code could have possible security implications as noted in the class JavaDoc.
	 * </p>
	 * 
	 * @param username
	 *        the username submitted for authentication
	 * @param password
	 *        the password string submitted for authentication
	 * @param rememberMe
	 *        if the user wishes their identity to be remembered across sessions
	 * @param host
	 *        the host name or IP string from where the attempt is occuring
	 * @since 1.0
	 */
	public CustomToken(final String username, final String password, final boolean rememberMe, final String host) {
		this(username, password != null ? password.toCharArray() : null, rememberMe, host);
	}

	/**
	 * Constructs a new UsernamePasswordToken encapsulating the username and password submitted, as well as if the user wishes their identity to be remembered
	 * across sessions.
	 * <p/>
	 * <p>
	 * This is a convience constructor and maintains the password internally via a character array, i.e. <tt>password.toCharArray();</tt>. Note that storing a
	 * password as a String in your code could have possible security implications as noted in the class JavaDoc.
	 * </p>
	 * 
	 * @param username
	 *        the username submitted for authentication
	 * @param password
	 *        the password string submitted for authentication
	 * @param rememberMe
	 *        if the user wishes their identity to be remembered across sessions
	 * @since 0.9
	 */
	public CustomToken(final String username, final String password, final boolean rememberMe) {
		this(username, password != null ? password.toCharArray() : null, rememberMe, null);
	}

	/**
	 * Constructs a new UsernamePasswordToken encapsulating the username and password submitted, if the user wishes their identity to be remembered across
	 * sessions, and the inetAddress from where the attempt is ocurring.
	 * 
	 * @param username
	 *        the username submitted for authentication
	 * @param password
	 *        the password character array submitted for authentication
	 * @param rememberMe
	 *        if the user wishes their identity to be remembered across sessions
	 * @param host
	 *        the host name or IP string from where the attempt is occuring
	 * @since 1.0
	 */
	public CustomToken(final String username, final char[] password, final boolean rememberMe, final String host) {
		super(username, password, rememberMe, host);

	/**
	 * 增加手机登录验证token.
	 */
	}
	private String mobile;
	private String verificatecode;
	
	public String getMobile() {
		return mobile;
	}
	
	public void setMobile(String mobile) {
		this.mobile = mobile;
	}
	
	public String getVerificatecode() {
		return verificatecode;
	}
	
	public void setVerificatecode(String verificatecode) {
		this.verificatecode = verificatecode;
	}
	public CustomToken(final String username, final String password,final String mobile ,final String verificatecode, final String host) {
		this(username, password != null ? password.toCharArray() : null, false, host);
		this.mobile = mobile;
		this.verificatecode = verificatecode;
	}

	/**
	 */
	public static final int Flag_Front_User  = 1;
	/**
	 */
	public static final int Flag_Admin_User  = 2;

	/**
	 */
	private int             flagFrontOrAdmin = 0;

	/**
	 */
	public int getFlagFrontOrAdmin() {
		return flagFrontOrAdmin;
	}

	/**
	 */
	public void setFlagFrontOrAdmin(int flagFrontOrAdmin) {
		this.flagFrontOrAdmin = flagFrontOrAdmin;
	}

}

4.controller 层处理的代码

package com.hfxt.controller;

import com.alibaba.fastjson.JSONArray;
import com.hfxt.controller.shiro.CustomToken;
import com.hfxt.entity.UserVo;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.AuthenticationException;
import org.apache.shiro.authc.IncorrectCredentialsException;
import org.apache.shiro.authc.UnknownAccountException;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.subject.Subject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;
import java.util.Map;

@Controller
@RequestMapping("/login")
public class LoginController {
    @RequestMapping("tologin.html")
    public String tologin()
    {
        return "loginAjax";
    }
    @RequestMapping("login.html")
    @ResponseBody
    public String login(UserVo uservo)
    {
        Map<String,Object> maps=new HashMap<String, Object>();
        //创建shiro认证对象
      try{
          Subject subject= SecurityUtils.getSubject();
//        封装认证用户 继承usernamepasswordtocken
          // UsernamePasswordToken token=new UsernamePasswordToken()
          CustomToken token=new CustomToken(uservo.getUsername(),uservo.getPassword());
          //提交认证
          subject.login(token);
          maps.put("retcode",1);
          maps.put("retmsg","登录成功");
      }
      catch(UnknownAccountException e){
          maps.put("retcode",-1);
          maps.put("retmsg","账户不正确");
      }catch (IncorrectCredentialsException e)
      {
          maps.put("retcode",-1);
          maps.put("retmsg","密码不正确");
      }
      catch (AuthenticationException e)
      {
          maps.put("retcode",-1);
          maps.put("retmsg","认证失败，请联系管理员");
      }

       return JSONArray.toJSONString(maps);
    }
    @RequestMapping("unauthorized")
    public String fail()
    {
        return "403";
    }
}

6.授权加认证

package com.hfxt.controller.shiro;

import com.hfxt.entity.RoleVo;
import com.hfxt.entity.UserVo;
import com.hfxt.service.RoleVoService;
import com.hfxt.service.UserVoService;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.authz.SimpleAuthorizationInfo;
import org.apache.shiro.crypto.hash.Md5Hash;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
import org.apache.shiro.util.ByteSource;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.annotation.Resource;
import java.util.List;

public class UserRealm extends AuthorizingRealm {
   @Resource
    protected UserVoService userVoService;
   @Resource
 protected RoleVoService roleVoService;
    //授权
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
//        声明返回授权对象
        SimpleAuthorizationInfo info=new SimpleAuthorizationInfo();
        UserVo userVo= (UserVo) SecurityUtils.getSubject().getPrincipal();
        //获取角色
        List<RoleVo> list=roleVoService.getRoleVosByUserid(userVo.getId().intValue());
      for(RoleVo roleVo :list)
      {
          info.addRole(roleVo.getRoleCode());

      }


        return info;
    }
//认证
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) throws
            AuthenticationException {
      //得到认证对象
        String username= (String) token.getPrincipal();
        String password=new String( (char []) token.getCredentials());
        UserVo userVo=null;
        try{
            userVo=userVoService.getUserVoByUserVoName(username);
        }
        catch(Exception e){
            e.printStackTrace();
        }
        if (userVo == null) {
            throw new UnknownAccountException();
        }
        //加密算法
        String newpwd=new Md5Hash(password,userVo.getSalt(),1024).toString();
        System.out.println("加密之后："+newpwd);
        System.out.println("数据库的密码："+ userVo.getPassword());
        if(!userVo.getPassword().equals(newpwd))
        {
            throw new IncorrectCredentialsException();
        }
        //进行认证
        //第一个参数 user
        //第二个参数是user.getpassword;
        //第三个参数（密码加密 salt(盐值)） 可省
        //第四个参数是当前realm的名字
        ByteSource sale=ByteSource.Util.bytes(userVo.getSalt());
        SimpleAuthenticationInfo info=new SimpleAuthenticationInfo(userVo, userVo.getPassword(),sale,getName());

        return info;
    }
}

web.xml配置监听器监听

<!--    配置shiro拦截器(权限验证)-->
    <filter>
        <filter-name>shiroFilter</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>shiroFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
LJ君
关注
专栏目录
SSM项目整合Shiro进行身份验证
huangjhai的博客
02-25 466
简介 身份验证指的是系统一般需要提供一些标识信息来表明登录者的身份，如提供用户名和密码，或手机号和验证码来证明。在 Shiro 中，用户需要提供principals（身份）和 credentials（证明）给 Shiro来验证用户身份。 principals：身份即为主体的标识属性，它可以是任何属性，如用户名、 邮箱，手机号等，必须保证唯一。一个主体可以有多个principals，但只有一个 P...
SSM整合shiro实现登陆验证以及权限检测
baidu_41553786的博客
02-23 455
[本人原文所在：](http://www.wandererchen.xyz/archives/SSM%E6%95%B4%E5%90%88shiro%E5%AE%9E%E7%8E%B0%E7%99%BB%E9%99%86%E9%AA%8C%E8%AF%81%E4%BB%A5%E5%8F%8A%E6%9D%83%E9%99%90%E6%A3%80%E6%B5%8B) ...
SSM整合shiro验证
Autism_A的博客
06-20 186
啥也不说了 直接上代码
从实例入手学习SSM与Shiro的整合流程
BADAO_LIUMANG_QIZHI的博客
05-17 310
场景 从实例入手学习Shiro与Web的整合： https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/90140802 在此基础上，实现Shiro与SSM整合。 关于SSM的整合不做过多介绍，请参照： 第一个SSM整合的Maven入门级项目(超详细步骤) https://blog.csdn.net/BADAO_LIUMANG...
使用注解的形式对token进行验证
check_bug的博客
01-27 1300
使用注解的形式对token进行验证前言设计思路实现方案总结 前言 现在很多系统都是都用上了springboot、springcloud，系统也偏向分布式部署、管理，最早的用户令牌方案：session、cookie已经不能够满足系统的需求，使用一些特殊操作完成令牌的生成及校验会造成更多的服务器开销及客户端开销，为此许多项目都使用上了token。 token的原理即为将一串加密字符，寄存在请求头中，随着请求头往返与前后端，以校验该访问是否有权限。 如果每一个系统都去写一套token的生成和验证，是一个很繁琐的重
SSM+shiro+redis
04-13
在实际项目中，SSM+Shiro+Redis的集成过程包括以下几个步骤： 1. 配置Spring：设置Spring的Bean定义和依赖注入，同时配置Spring MVC的DispatcherServlet，处理Web请求。 2. 集成MyBatis：配置MyBatis的...
ssm+shiro实现简单的登陆认证功能
11-07
在SSM+Shiro实现登录认证的过程中，主要步骤包括： 1. **Shiro配置**：首先，在Spring的配置文件中引入Shiro的相关bean，如SecurityManager、Realm（自定义的权限验证类，通常继承AuthorizingRealm）等。 2. **...
ssm+shiro整合
11-02
整合SSM和Shiro的过程中，主要步骤包括： 1. **引入依赖**：在项目pom.xml文件中添加Spring、Spring MVC、MyBatis和Shiro的相关依赖库。 2. **配置Spring**：创建Spring的配置文件，如`applicationContext.xml`，...
ssm与shiro简单整合.zip
02-14
通过以上步骤，我们可以实现一个简单的SSM与Shiro的整合项目，提供基本的用户认证和授权功能。虽然描述中提到这个项目只有几个简单的页面，没有复杂的特效，但其背后涉及的原理和技术点仍然相当广泛，包括SSM框架的...
SSM整合Shiro-登录案例.zip
09-04
SSM整合Shiro登录案例是一个基于Spring、SpringMVC和MyBatis的Java Web项目，其中集成了Apache Shiro安全框架来实现用户的身份认证和授权功能。在这个案例中，我们将探讨如何将这三个主流的Java Web开发框架有效地...
Token注解实现前后端安全访问
HealerJean梦想博客
09-10 2416
前言 1、Tocken注解 package com.duodian.youhui.admin.config.token.annotation; import java.lang.annotation.ElementType; import java.lang.annotation.Retention; import java.lang.annotation.Retention...
关于shiro授权 This subject is anonymous - it does not have any identifying principals and authorization
m0_49359842的博客
01-17 4651
在进行shiro前后分离授权时，报错如下。 This subject is anonymous - it does not have any identifying principals and authorization operations require an identity to check against. A Subject instance will acquire these identifying principals automatically after a successful
【shiro】UsernamePasswordToken中char[]替代String的安全性
厚积薄发者，轻舟万重山
08-12 6298
UsernamePasswordToken password as a char[] instead of a String，char[]替代String的安全性
在SSM中使用shiro实现登录验证（附密码加密）
Alan_Xiang的博客
01-31 2万+
第一步：导入需要的jar：（maven方式） <properties> <!-- log4j日志文件管理包版本 --> <slf4j.version>1.7.7</slf4j.version> <log4j.version>1.2.17</log4j.version> </properties> <!-- log start
Shiro学习笔记（二）UsernamePasswordToken源码简单解析
热门推荐
zch-兴趣使然-blog
03-27 3万+
在shrio中，AuthenticationToken用于存储前端传来的登录信息，通俗来说就是用户名及密码等。而在这之中比较常用的就是UsernamePasswordToken。为了了解shrio的验证过程有必要先了解与验证相关的主要的几个类。首先看下shrio对UsernamePasswordToken的描述： /** * <p>A simple username/passwo...
ssm+shiro框架的详细配置
辰霄丶的博客
11-07 430
首先导入maven的pom文件 &amp;amp;amp;lt;!--Shiro安全框架集成,主要用来更便捷的认证，授权，加密，会话管理--&amp;amp;amp;gt; &amp;amp;amp;lt;!-- shiro配置 --&amp;amp;amp;gt; &amp;amp;amp;lt;dependency&amp;amp;amp;gt; &amp;amp;amp;lt;groupId&amp;a
SSM集成Shiro实现用户登录认证
TD_FAlmK的博客
12-02 359
Shiro的核心API： 整合步骤： 1、首先在pom.xml中引入shiro-spring的jar包 <!-- https://mvnrepository.com/artifact/org.apache.shiro/shiro-spring --> <dependency> <groupId>org.apache.shiro</groupId> <artifactId>shiro-spring</ar..
SSM+Shiro+用户登录授权
编程小白
06-30 3003
SSM与整合Shiro进行整合实现用户登录验证及权限分配 在前面的学习过程中，已经学习了 Shiro的一些基本组件以及如何利用Shiro进行权限控制。下面学习用目前比较主流的SSM框架来整合Shiro框架，将我们前面学习的一些基本知识运用到实际项目之中。由于本人初学，内容可能比较粗浅，后期进行深入理解后会细化，SSM项目的搭建过程这里不再叙述，可查阅其他人教程学习，可能有时间也会进行回顾记录。 ...
maven项目中SSM+Shiro整合配置中，在有SpringMVC+MyBatis配置下整合shiro的配置步骤
m0_37954004的博客
01-20 9166
最近在做SSM（SpringMVC+Shiro+MyBatis）整合的一个项目，对于shiro的配置不是特别熟练，于是想要写下来，加深一下印象。在有SpringMVC+MyBatis配置的基础上整合shiro：      首先进入shiro的官方网站（http://shiro.apache.org/），如下图所示（图中有提示下一步怎么操作）：点击Download进入到下面这个页面：向下拖动，可以看
ssm 整合 shiro
最新发布
09-13
SSM（Spring+Spring MVC+MyBatis）是一种常用的JavaWeb开发框架组合，而Shiro是一种强大的安全框架，可以用于认证、授权和会话管理等功能。将SSM整合Shiro可以为我们的应用程序提供更高级别的安全性。 下面是整合SSM和Shiro的步骤： 1. 引入依赖：在项目的配置文件中添加Shiro和相关框架（Spring、MyBatis）的依赖。 2. 创建Shiro配置类：创建一个继承自org.apache.shiro.spring.web.ShiroFilterFactoryBean的类，并在该类中配置Shiro的相关参数，如登录URL、登录成功URL、无权限URL等。 3. 配置Shiro过滤器链：在Shiro配置类中配置Shiro过滤器链，即定义URL与过滤器的对应关系。可以使用Shiro提供的过滤器实现不同URL的访问权限控制。 4. 自定义Realm：创建一个继承自org.apache.shiro.realm.Realm的类，并实现其中的认证和授权方法。在这里，可以使用MyBatis访问数据库获取用户信息和权限信息。 5. 配置Spring和MyBatis：在Spring配置文件中配置DataSource、SqlSessionFactoryBean和MapperScannerConfigurer等相关Bean，以及扫描自定义Realm类的包。 6. 在Web.xml中配置DispatcherServlet：配置Spring MVC的核心控制器DispatcherServlet，并指定Spring MVC相关的配置文件路径。 以上是大致的步骤，具体实现可以参考相关的文档和示例代码。整合SSM和Shiro可以为你的应用程序提供更加可靠的安全保障。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值