(精华)2020年9月19日 ASP.NET Core 认证授权详解

最新推荐文章于 2024-08-06 15:29:58 发布
最新推荐文章于 2024-08-06 15:29:58 发布
阅读量10w+ 收藏 1
点赞数
分类专栏： # ASP.NET Core
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aa2528877987/article/details/108524602
版权

Session的使用

public static class Sample01
    {
        public static void Start()
        {
            Host.CreateDefaultBuilder()
                .ConfigureWebHostDefaults(builder => builder
                    .ConfigureServices(collection => collection
                        .AddDistributedMemoryCache()
                        .AddSession())
                    .Configure(app => app
                        .UseSession()
                        .Run(ProcessAsync)))
                .Build()
                .Run();

            static async Task ProcessAsync(HttpContext context)
            {
                var session = context.Session;
                await session.LoadAsync();
                string sessionStartTime;

                if (session.TryGetValue("SessionStartTime", out var value))
                {
                    sessionStartTime = Encoding.UTF8.GetString(value);
                }
                else
                {
                    sessionStartTime = DateTime.Now.ToString(CultureInfo.InvariantCulture);
                    session.SetString("SessionStartTime", sessionStartTime);
                }

                context.Response.ContentType = "text/html";
                await context.Response.WriteAsync($"<html><body><ul><li>Session ID:{session.Id}</li>");
                await context.Response.WriteAsync($"<li>Session Start Time:{sessionStartTime}</li>");
                await context.Response.WriteAsync($"<li>Current Time:{DateTime.Now}</li></ul></table></body></html>");
            }
        }
    }

public static class Sample02
    {
        public static void Start()
        {
            Host.CreateDefaultBuilder()
                .ConfigureWebHostDefaults(builder => builder
                    .ConfigureServices(collection => collection
                        .AddDistributedMemoryCache()
                        .AddSession())
                    .Configure(app => app
                        .UseSession()
                        .Run(ProcessAsync)))
                .Build()
                .Run();

            static async Task ProcessAsync(HttpContext context)
            {
                var session = context.Session;
                await session.LoadAsync();
                string sessionStartTime;

                if (session.TryGetValue("SessionStartTime", out var value))
                {
                    sessionStartTime = Encoding.UTF8.GetString(value);
                }
                else
                {
                    sessionStartTime = DateTime.Now.ToString(CultureInfo.InvariantCulture);
                    session.SetString("SessionStartTime", sessionStartTime);
                }

                // 使用反射获取Session Key
                var field = typeof(DistributedSession).GetTypeInfo().GetField("_sessionKey", BindingFlags.Instance | BindingFlags.NonPublic);
                var sessionKey = field?.GetValue(session);

                context.Response.ContentType = "text/html";
                await context.Response.WriteAsync($"<html><body><ul><li>Session ID:{session.Id}</li>");
                await context.Response.WriteAsync($"<li>Session Key:{sessionKey}</li>");
                await context.Response.WriteAsync($"<li>Session Start Time:{sessionStartTime}</li>");
                await context.Response.WriteAsync($"<li>Current Time:{DateTime.Now}</li></ul></table></body></html>");
            }
        }
    }

Cookie的使用

class Program
    {
        private static readonly Dictionary<string, string> Accounts = new Dictionary<string, string>
        {
            {"Admin", "123"}, {"UserA", "123"}, {"UserB", "123"}
        };

        public static void Main(string[] args)
        {
            Host.CreateDefaultBuilder()
                .ConfigureWebHostDefaults(builder => builder
                    .ConfigureServices(collection => collection
                        .AddRouting()
                        .AddAuthentication(options =>
                            options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme)
                        .AddCookie())
                    .Configure(app => app
                        .UseAuthentication()
                        .UseRouting()
                        .UseEndpoints(endpoints =>
                        {
                            endpoints.Map("/", RenderHomePageAsync);
                            endpoints.Map("Account/Login", SignInAsync);
                            endpoints.Map("Account/Logout", SignOutAsync);
                        })))
                .Build()
                .Run();
        }

        public static async Task RenderHomePageAsync(HttpContext context)
        {
            if (context?.User?.Identity?.IsAuthenticated == true)
            {
                await context.Response.WriteAsync(
                    @"<html>
                    <head><title>Index</title></head>
                    <body>" +
                    $"<h3>Welcome {context.User.Identity.Name}</h3>" +
                    @"<a href='/Account/Logout'>Sign Out</a>
                    </body>
                </html>");
            }
            else
            {
                await context.ChallengeAsync();
            }
               
        }


        public static async Task SignInAsync(HttpContext context)
        {
            if (string.CompareOrdinal(context.Request.Method, "GET") == 0)
            {
                await RenderLoginPageAsync(context, null, null, null);
            }
            else
            {
                var userName = context.Request.Form["username"];
                var password = context.Request.Form["password"];
                if (Accounts.TryGetValue(userName, out var pwd) && pwd == password)
                {
                    var identity = new GenericIdentity(userName, "Passord");
                    var principal = new ClaimsPrincipal(identity);
                    await context.SignInAsync(principal);
                }
                else
                {
                    await RenderLoginPageAsync(context, userName, password, "Invalid user name or password!");
                }
            }
        }

        private static Task RenderLoginPageAsync(HttpContext context, string userName, string password,
            string errorMessage)
        {
            context.Response.ContentType = "text/html";
            return context.Response.WriteAsync(
                @"<html>
                <head><title>Login</title></head>
                <body>
                    <form method='post'>" +
                $"<input type='text' name='username' placeholder='User name' value = '{userName}' /> " +
                $"<input type='password' name='password' placeholder='Password' value = '{password}' /> " +
                @"<input type='submit' value='Sign In' />
                    </form>" +
                $"<p style='color:red'>{errorMessage}</p>" +
                @"</body>
            </html>");
        }


        public static async Task SignOutAsync(HttpContext context)
        {
            await context.SignOutAsync();
            context.Response.Redirect("/");
        }
    }

class Program
    {
        static void Main(string[] args)
        {
            Host.CreateDefaultBuilder()
                .ConfigureWebHostDefaults(builder => builder
                    .ConfigureServices(collection => collection
                        .AddDbContext<UserDbContext>(options => options
                            .UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=AuthorizationDemo;Trusted_Connection=True;MultipleActiveResultSets=true")
                        )
                        .AddRouting()
                        .AddAuthorization()
                        .AddAuthentication(options => options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme).AddCookie())
                    .Configure(app => app
                        .UseAuthentication()
                        .UseRouting()
                        .UseEndpoints(endpoints =>
                        {
                            endpoints.Map("/", RenderHomePageAsync);
                            endpoints.Map("Account/Login", SignInAsync);
                            endpoints.Map("Account/Logout", SignOutAsync);
                            endpoints.Map("Account/AccessDenied", DenyAccessAsync);
                        })))
                .Build()
                .Run();
        }

        public static async Task RenderHomePageAsync(HttpContext context)
        {
            if (context?.User?.Identity?.IsAuthenticated == true)
            {
                var requirement = new RolesAuthorizationRequirement(new [] { "ADMIN" });
                var authorizationService = context.RequestServices.GetRequiredService<IAuthorizationService>();
                var result = await authorizationService.AuthorizeAsync(context.User, null, new IAuthorizationRequirement[] { requirement });
                if (result.Succeeded)
                {
                    await context.Response.WriteAsync(
                        @"<html>
                    <head><title>Index</title></head>
                    <body>" +
                        $"<h3>{context.User.Identity.Name}, you are authorized.</h3>" +
                        @"<a href='Account/Logout'>Sign Out</a>
                    </body>
                </html>");
                }
                else
                {
                    await context.ForbidAsync();
                }
            }
            else
            {
                await context.ChallengeAsync();
            }
        }

          public static async Task SignInAsync(HttpContext context)
        {
            if (string.Compare(context.Request.Method, "GET") == 0)
            {
                await RenderLoginPageAsync(context, null, null, null);
            }
            else
            {
                string userName = context.Request.Form["username"];
                string password = context.Request.Form["password"];
                var dbContext = context.RequestServices.GetRequiredService<UserDbContext>();
                var user = await dbContext.Users.Include(it => it.Roles).SingleOrDefaultAsync(it => it.UserName == userName.ToUpper());
                if (user?.Password == password)
                {
                    var identity = new GenericIdentity(userName, CookieAuthenticationDefaults.AuthenticationScheme);
                    foreach (var role in user.Roles)
                    {
                        identity.AddClaim(new Claim(ClaimTypes.Role, role.NormalizedRoleName));
                    }
                    var principal = new ClaimsPrincipal(identity);
                    await context.SignInAsync(principal);
                }
                else
                {
                    await RenderLoginPageAsync(context, userName, password, "Invalid user name or password!");
                }
            }
        }

        private static Task RenderLoginPageAsync(HttpContext context, string userName, string password, string errorMessage)
        {
            context.Response.ContentType = "text/html";
            return context.Response.WriteAsync(
                @"<html>
                <head><title>Login</title></head>
                <body>
                    <form method='post'>" +
                            $"<input type='text' name='username' placeholder='User name' value = '{userName}' /> " +
                            $"<input type='password' name='password' placeholder='Password' value = '{password}' /> " +
                            @"<input type='submit' value='Sign In' />
                    </form>" +
                            $"<p style='color:red'>{errorMessage}</p>" +
                    @"</body>
            </html>");
        }

        public static async Task SignOutAsync(HttpContext context)
        {
            await context.SignOutAsync();
            await context.ChallengeAsync(new AuthenticationProperties { RedirectUri = "/" });
        }

        public static Task DenyAccessAsync(HttpContext context)
        {
            return context.Response.WriteAsync(
                @"<html>
                <head><title>Index</title></head>
                <body>" +
                $"<h3>{context.User.Identity.Name}, your access is denied.</h3>" +
                @"<a href='/Account/Logout'>Sign Out</a>
                </body>
            </html>");
        } 

      
    }

CookieAuthentication

class Program
    {
        static void Main(string[] args)
        {
            Host.CreateDefaultBuilder()
                .ConfigureWebHostDefaults(builder => builder
                    .ConfigureServices(collection => collection
                        .AddDbContext<UserDbContext>(options => options
                            .UseSqlServer("Server=(localdb)\\mssqllocaldb;Database=AuthorizationDemo;Trusted_Connection=True;MultipleActiveResultSets=true")
                        )
                        .AddRouting()
                        .AddAuthorization(options => {
                            var requirement = new RolesAuthorizationRequirement(new [] { "ADMIN" });
                            var policy = new AuthorizationPolicy(new IAuthorizationRequirement[] { requirement }, new string[0]);
                            options.AddPolicy("HomePage", policy);
                        })
                        .AddAuthentication(options => options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme).AddCookie())
                    .Configure(app => app
                        .UseAuthentication()
                        .UseRouting()
                        .UseEndpoints(endpoints =>
                        {
                            endpoints.Map("/", RenderHomePageAsync);
                            endpoints.Map("Account/Login", SignInAsync);
                            endpoints.Map("Account/Logout", SignOutAsync);
                            endpoints.Map("Account/AccessDenied", DenyAccessAsync);
                        })))
                .Build()
                .Run();
        }

        public static async Task RenderHomePageAsync(HttpContext context)
        {
            if (context?.User?.Identity?.IsAuthenticated == true)
            {
                var authorizationService = context.RequestServices.GetRequiredService<IAuthorizationService>();
                var result = await authorizationService.AuthorizeAsync(context.User, "HomePage");
                if (result.Succeeded)
                {
                    await context.Response.WriteAsync(
                        @"<html>
                    <head><title>Index</title></head>
                    <body>" +
                        $"<h3>{context.User.Identity.Name}, you are authorized.</h3>" +
                        @"<a href='Account/Logout'>Sign Out</a>
                    </body>
                </html>");
                }
                else
                {
                    await context.ForbidAsync();
                }
            }
            else
            {
                await context.ChallengeAsync();
            }
        }

          public static async Task SignInAsync(HttpContext context)
        {
            if (string.Compare(context.Request.Method, "GET") == 0)
            {
                await RenderLoginPageAsync(context, null, null, null);
            }
            else
            {
                string userName = context.Request.Form["username"];
                string password = context.Request.Form["password"];
                var dbContext = context.RequestServices.GetRequiredService<UserDbContext>();
                var user = await dbContext.Users.Include(it => it.Roles).SingleOrDefaultAsync(it => it.UserName == userName.ToUpper());
                if (user?.Password == password)
                {
                    var identity = new GenericIdentity(userName, CookieAuthenticationDefaults.AuthenticationScheme);
                    foreach (var role in user.Roles)
                    {
                        identity.AddClaim(new Claim(ClaimTypes.Role, role.NormalizedRoleName));
                    }
                    var principal = new ClaimsPrincipal(identity);
                    await context.SignInAsync(principal);
                }
                else
                {
                    await RenderLoginPageAsync(context, userName, password, "Invalid user name or password!");
                }
            }
        }

        private static Task RenderLoginPageAsync(HttpContext context, string userName, string password, string errorMessage)
        {
            context.Response.ContentType = "text/html";
            return context.Response.WriteAsync(
                @"<html>
                <head><title>Login</title></head>
                <body>
                    <form method='post'>" +
                            $"<input type='text' name='username' placeholder='User name' value = '{userName}' /> " +
                            $"<input type='password' name='password' placeholder='Password' value = '{password}' /> " +
                            @"<input type='submit' value='Sign In' />
                    </form>" +
                            $"<p style='color:red'>{errorMessage}</p>" +
                    @"</body>
            </html>");
        }

        public static async Task SignOutAsync(HttpContext context)
        {
            await context.SignOutAsync();
            await context.ChallengeAsync(new AuthenticationProperties { RedirectUri = "/" });
        }

        public static Task DenyAccessAsync(HttpContext context)
        {
            return context.Response.WriteAsync(
                @"<html>
                <head><title>Index</title></head>
                <body>" +
                $"<h3>{context.User.Identity.Name}, your access is denied.</h3>" +
                @"<a href='/Account/Logout'>Sign Out</a>
                </body>
            </html>");
        } 

      
    }

权限认证交互示例

public class Program
    {
        public static void Main()
        {
            Host.CreateDefaultBuilder()
                .ConfigureWebHostDefaults(builder => builder
                    .UseUrls("http://*:443")
                    
                    .Configure(app => app.Run(ProcessAsync)))
                .Build()
                .Run();

            static async Task ProcessAsync(HttpContext httpContext)
            {
                httpContext.Response.ContentType = "text/html";
                var html =
                @"<html>
                <body>
                    <ul id='contacts'></ul>
                    <script src='http://code.jquery.com/jquery-3.3.1.min.js'></script>
                    <script>
                    $(function()
                    {
                        var url = 'http://www.one.com:8080/contacts';
                        $.getJSON(url, null, function(contacts) {
                            $.each(contacts, function(index, contact)
                            {
                                var html = '<li><ul>';
                                html += '<li>Name: ' + contact.Name + '</li>';
                                html += '<li>Phone No:' + contact.PhoneNo + '</li>';
                                html += '<li>Email Address: ' + contact.EmailAddress + '</li>';
                                html += '</ul>';
                                $('#contacts').append($(html));
                            });
                        });
                    });
                    </script >
                </body>
                </html>";
                await httpContext.Response.WriteAsync(html);
            }
        }
    }

public class Program
    {
        public static void Main()
        {
            Host.CreateDefaultBuilder()
                .ConfigureWebHostDefaults(builder => builder
                    .UseUrls("http://*:8080")
                    .Configure(app => app
                        .UsePathBase("/contacts")
                        .Run(ProcessAsync)))
                .Build()
                .Run();

            static Task ProcessAsync(HttpContext httpContext)
            {
                var response = httpContext.Response;
                response.ContentType = "application/json";
                var contacts = new Contact[]
                {
                new Contact("张三", "123", "zhangsan@qq.com"),
                new Contact("李四","456", "lisi@qq.com"),
                new Contact("王五", "789", "wangwu@qq.com")
                };
                return response.WriteAsync(JsonConvert.SerializeObject(contacts));
            }
        }
    }
愚公搬代码
关注
专栏目录
快速理解ASP.NET Core的认证与授权
dotNET跨平台
01-04 1711
ASP.NET Core的认证与授权已经不是什么新鲜事了，微软官方的文档对于如何在ASP.NET Core中实现认证与授权有着非常详细深入的介绍。但有时候在开发过程中，我们也往往会感觉无从...
Asp.Net Core Swagger 页面适配 Nginx 二级目录 | 完美解决方案
寒冰屋的专栏
03-18 1270
当我们把 Asp.Net Core 程序部署在 Nginx 后面时，通常来说，不会使用顶级目录，而是使用二级目录，访问方式类似： http://{DOMAIN}/{BASEPATH}/WeatherForecast
ASP.Net Core设置接口根路径的方法
最新发布
woshihedayu的博客
08-06 449
但是，这样做了以后，swagger相关的接口路径并没有发生变化。也就是说，所有的接口都对应两个请求路径，一个是以acl开头的路径，另一个是swagger里面的请求路径。其中，UsePathBase方法添加了一个中间件，设置所有请求的根路径是acl，要注意中间件添加的位置，在MapControllers方法前面，才能生效。使用asp.net core开发微服务项目，需要给每个服务设置不同的根路径，这样既能使用网关转发请求，又方便对单个服务进行测试，保证请求路径的统一。
.NET Core中鉴权 Authentication Authorization
lwpoor123的博客
12-18 793
Authentication:鉴定身份信息，例如用户有没有登录，用户基本信息 Authorization:判定用户有没有权限 使用框架提供的Cookie鉴权方式 1.首先在服务容器注入鉴权服务和Cookie服务支持 2.注册鉴权和授权中间件,用于在管道中调用拦截校验鉴权和授权 3.在控制器引入特性 [Authorize] ，调用登录接口时使用HttpContext.SignInAsync()写入鉴权信息
关于 context.Response.Redirect 跳转问题
Kc
09-02 1万+
查看这篇帖子Response.Redirect 发现的问题 1：采用ajax方式提交给IHttpHander 因为你是使用的异步请求的方式，页面自然不会跳转(帖子已经说明),这个时候context 对象应该被挂起了吧 要想跳转 可采用 a:IHttpHander 的返
asp.net core 授权详解
10-15
ASP.NET Core 授权详解 ASP.NET Core 是一个跨平台的高性能框架，用于构建现代云应用程序。在开发过程中，确保应用程序的安全性是至关重要的，而授权是实现这一目标的关键部分。授权控制了谁能够访问特定的资源，...
详解ASP.NET Core Token认证
10-20
ASP.NET Core Token认证是一种安全机制，主要用于身份验证和授权，特别是在单页应用程序（SPA）、移动应用以及现代Web API中。它依赖于令牌（Token），尤其是JSON Web Tokens（JWTs），这些令牌包含了用户的身份信息...
ASP.NET Core学习之使用JWT认证授权详解
12-16
认证授权是很多系统的基本功能 , 在以前PC的时代 , 通常是基于cookies-session这样的方式实现认证授权 , 在那个时候通常系统的用户量都不会很大, 所以这种方式也一直很好运行, 随着现在都软件用户量越来越大, 系统...
【ASP.NET编程知识】ASP.NET Core学习之使用JWT认证授权详解.docx
05-15
ASP.NET Core 使用 JWT 认证授权详解 在 ASP.NET Core 中，使用 JWT（JSON Web Token）认证授权是一种常见的身份验证方式。本文将详细介绍 JWT 的优势和劣势，以及在 ASP.NET Core 中如何集成 JWT 认证。 认证和...
详解ASP.NET Core和ASP.NET Framework共享身份验证
01-20
ASP.NET Core 和 ASP.NET Framework 共享身份验证是.NET开发者在迁移项目时面临的重要问题。随着.NET Core的崛起，它的优势如开源、跨平台、高性能等吸引了大量开发者的关注。然而，由于.NET Core与.NET Framework在...
ASP.NET Core 运行原理解剖[3]:Middleware-请求管道的构成
weixin_33696106的博客
09-03 283
在 ASP.NET 中，我们知道，它有一个面向切面的请求管道，有19个主要的事件构成，能够让我们进行灵活的扩展。通常是在 web.config 中通过注册 HttpModule 来实现对请求管道事件监听，并通过 HttpHandler 进入到我们的应用程序中。而在 ASP.NET Core 中，对请求管道进行了重新设计，通过使用一种称为中间件的方式来进行管道的注册，同时也变得更加简洁和强大。 目录...
asp.net Web API 身份验证 不记名令牌验证 Bearer Token Authentication 简单实现
weixin_33805992的博客
09-12 1338
1. Startup.Auth.cs文件 添加属性 1 public static OAuthBearerAuthenticationOptions OAuthBearerOptions { get; private set; }  添加静态构造函数 1 2 3 4 5 6 ...
基于.NetCore3.1系列 —— 认证授权方案之授权揭秘 (下篇)
dotNET跨平台
07-11 942
一、前言回顾：基于.NetCore3.1系列 —— 认证授权方案之授权揭秘 (上篇)在上一篇中，主要讲解了授权在配置方面的源码，从添加授权配置开始，我们引入了需要的授权配置选项，而不同的...
Asp.Net Core 中IdentityServer4 实战之角色授权详解
极客神殿
05-02 1612
一、前言 前几篇文章分享了IdentityServer4密码模式的基本授权及自定义授权等方式，最近由于改造一个网关服务，也用到了IdentityServer4的授权，改造过程中发现比较适合基于Role角色的授权，通过不同的角色来限制用户访问不同的Api资源，当时编写的时候我是使用了一个中间件来实现，想想可能基于Role角色的方式来实现会更佳，不过也只是其中一小部分适合，这里我就来分享IdentityServer4基于角色的授权详解。 没有看过之前的几篇文章，我建议先回过头看看上面那几篇文章再来看本篇文章，不
关于 OpenIdConnect 认证启用 HTTPS 回调 RedirectUri 不生效问题
热门推荐
weixin_33901926的博客
06-04 1万+
在搭建 IdentityServer 服务端后，我们尝试使用了 OIDC(OpenID Connect) 的中间件来代替了原先的 Session 系统认证方式，起初采用的是 HTTP 协议，一切都没有什么问题，最近启用全站 HTTPS 后，发现登陆会跳转到 HTTP的页面， OpenID Connect 认证流程 第一步： 请求构造授权页 Request URL:https://sso...
.net core 认证与授权（一）
ting2909的博客
02-06 1553
前言 .net core web并不是一个非常新的架构，很多文章提及到认证与授权这个过程，但是一般都会提及到里面的方法怎么用的，而不是模拟一个怎样的过程，所以我打算记录自己的理解。 什么是认证？我们大学毕业有学士证书和毕业证书，来证明你是一个学士。 什么是授权，比如说你被认证是我的朋友后，你可以拿着这个身份，可以进入我的朋友圈看动态。 那么.net core 的认证与授权是一个什么样的过程，在这里...
ASP.NET Core 反向代理部署知多少
dotNET跨平台
03-02 884
引言最近在折腾统一认证中心，看到开源项目[IdentityServer4.Admin：https://github.com/skoruba/IdentityServer4.Admin]集...
Asp.Net Core-身份验证
终南山守门人
08-31 4786
在本章中，我们将简要讨论ASP.NET Core的身份验证框架。 ASP.NET Core身份框架用于实现表单身份验证。 有许多选项可供选择，以识别您的用户，包括Windows身份验证和所有第三方身份提供商，如Google，Microsoft，Facebook和GitHub等。 Identity框架是我们将在project.js文件中添加到我们的应用程序中的另一个依赖项。 此框架允
ASP.NET Core JWT授权认证详解与实战教程
本文将深入浅出地探讨ASP.NET Core中JWT（JSON Web Tokens）授权认证的流程原理。JWT是一种轻量级的身份验证机制，它利用一个包含用户信息的短令牌进行安全通信，适用于无状态的API和服务间交互。 首先，了解JWT的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

愚公搬代码

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

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

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

打赏作者

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

抵扣说明：

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

余额充值