AOP实战---对用户/角色/规则操作日志记录

最新推荐文章于 2023-09-18 22:39:45 发布
最新推荐文章于 2023-09-18 22:39:45 发布
阅读量203 收藏
点赞数
文章标签： java 测试
原文链接：https://my.oschina.net/u/3278373/blog/874566
版权

1.导入jar包   JDK1.7的 aop jar包必须用1.7版本的

aspectjrt-1.7.4.jar /aspectjweaver-1.7.4.jar

<dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.7.4</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.7.4</version>

</dependency>

2.配置

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.0.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop.xsd">

<!-- 加入Aspectj配置   注解配置-->
 <aop:aspectj-autoproxy />

package com.pingan.insurance.roadassistant.service.serviceImpl;

import java.lang.reflect.Method;
import java.util.Date;
import java.util.List;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;
import com.pingan.common.Constants;
import com.pingan.common.model.BusResult;
import com.pingan.insurance.roadassistant.dao.RoleMapper;
import com.pingan.insurance.roadassistant.dao.RuleInstanceMapper;
import com.pingan.insurance.roadassistant.dao.UserMapper;
import com.pingan.insurance.roadassistant.model.OperationLog;
import com.pingan.insurance.roadassistant.model.Provider;
import com.pingan.insurance.roadassistant.model.Role;
import com.pingan.insurance.roadassistant.model.RuleAllot;
import com.pingan.insurance.roadassistant.model.RuleAllotPersents;
import com.pingan.insurance.roadassistant.model.RuleInstance;
import com.pingan.insurance.roadassistant.model.User;
import com.pingan.insurance.roadassistant.service.OperationLogService;

 
/**
 * 日志记录，添加、删除、修改方法AOP
 * @author jiangweiwei336
 *
 */
@Aspect
@Component
public class LogAspect {  
      
    @Autowired  
    private OperationLogService logService;//日志记录Service
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private RoleMapper roleMapper;
    @Autowired
    private RuleInstanceMapper ruleInstanceMapper;
    
    private static Logger logger = Logger.getLogger(LogAspect.class);
    
    /** 
     * 添加业务逻辑方法切入点 
     */  
    @Pointcut("execution(* com.pingan.insurance.roadassistant.service.serviceImpl.*.insert*(..))"
    		+ "||execution(* com.pingan.insurance.roadassistant.service.serviceImpl.*.create*(..))")  
    public void insertServiceCall() { }  
      
    /** 
     * 修改业务逻辑方法切入点 
     */  
    @Pointcut("execution(* com.pingan.insurance.roadassistant.service.serviceImpl.*.update*(..))"
    		//+ "execution(* com.pingan.insurance.roadassistant.service.serviceImpl.*.bind*(..))"
    		+ "||execution(* com.pingan.insurance.roadassistant.service.serviceImpl.*.reset*(..))")  
    public void updateServiceCall() { } 
    
    /** 
     * 用户绑定角色方法切入点 
     */  
    @Pointcut("execution(* com.pingan.insurance.roadassistant.service.serviceImpl.*.bind*(..))")  
    public void bindServiceCall() { }
    
    /** 
     * 删除业务逻辑方法切入点 
     */  
    @Pointcut("execution(* com.pingan.insurance.roadassistant.service.serviceImpl.*.delete*(..))"
    		+ "||execution(* com.pingan.insurance.roadassistant.service.serviceImpl.*.forbid*(..))")  
    public void deleteServiceCall() { }  
      
    /** 
     * 管理员添加操作日志(后置通知) 
     * @param joinPoint 
     * @param rtv 
     * @throws Throwable 
     */  
    @AfterReturning(value="insertServiceCall()", argNames="rtv", returning="rtv")  
    public void insertServiceCallCalls(JoinPoint joinPoint, Object rtv) throws Throwable{  
    	if(rtv instanceof BusResult){
    		BusResult busResult=(BusResult) rtv;
    		String rtnCode = busResult.getRtnCode();
    		if(rtnCode.equals(Constants.SUCCESS)){
        		try {
        			logAddOperation(joinPoint);
        		} catch (Exception e) {
        			logger.info("记录新增日志异常信息"+e.getMessage());
        		}
        	}
    	}else if(rtv instanceof String){
    		String data=(String) rtv;
    		if(data!=null){
    			try {
        			logAddOperation(joinPoint);
        		} catch (Exception e) {
        			logger.info("记录新增日志异常信息"+e.getMessage());
        		}
    		}
    	}
    }

	private void logAddOperation(JoinPoint joinPoint) {
		//获取参数
		Object object = joinPoint.getArgs()[0];
		if(object instanceof User){
			User user=(User) joinPoint.getArgs()[0];
			String userJson = JSONObject.toJSONString(user);
			String username=user.getCreatedUser();
			String userId = user.getUserId();
			String contentType="user";
			logAdd(userJson, username,contentType,userId);
		}else if(object instanceof Role){
			Role role=(Role) joinPoint.getArgs()[0];
			String roleJson = JSONObject.toJSONString(role);
			String username=role.getCreatedUser();
			String roleId = role.getRoleId();
			String contentType="role";
			logAdd(roleJson, username,contentType,roleId);
		}else if(object instanceof RuleInstance){
			RuleInstance ruleInstance=(RuleInstance) joinPoint.getArgs()[0];
			String ruleInstanceJson = JSONObject.toJSONString(ruleInstance);
			String username=ruleInstance.getCreator();
			String code = ruleInstance.getCode();
			String contentType="ruleInstance";
			logAdd(ruleInstanceJson, username,contentType,code);
		}else if(object instanceof RuleAllot){
			RuleAllot ruleAllot=(RuleAllot) joinPoint.getArgs()[0];
			String ruleAllotJson = JSONObject.toJSONString(ruleAllot);
			String username=ruleAllot.getCreator();
			List<RuleAllotPersents> list = ruleAllot.getRuleAllotPersents();
			RuleAllotPersents ruleAllotPersents = list.get(0);
			String code = ruleAllotPersents.getInstanceCode();
			String contentType="ruleInstance";
			logAdd(ruleAllotJson, username,contentType,code);
		}else if(object instanceof Provider){
			Provider provider=(Provider) joinPoint.getArgs()[0];
			String providerJson = JSONObject.toJSONString(provider);
			String username=provider.getCreator();
			String contentType="provider";
			String providerCode = provider.getProviderCode();
			logAdd(providerJson, username, contentType, providerCode);
		}
	}

	private void logAdd(String content,String username,String contentType,String contentId) {
		//创建日志对象  
        OperationLog operationLog=new OperationLog();
        operationLog.setUsername(username);//设置管理员id  
        operationLog.setCreatedTime(new Date());//操作时间  
        operationLog.setNewContent(content);//操作内容  
        operationLog.setOperationType("新增");//操作  
        operationLog.setContentType(contentType);//操作内容类型
        operationLog.setContentId(contentId);//操作内容ID
          
        logService.log(operationLog);//添加日志  
        
	}  
      
    /** 
     * 修改操作日志(环绕通知 可查询出修改前内容作对比)
     * @param joinPoint 
     * @param rtv 
     * @throws Throwable 
     */  
	@Around(value="updateServiceCall()", argNames="rtv")  
    public Object updateServiceCallCalls(ProceedingJoinPoint pjp) throws Throwable{  
		Object result=null;
		
    	try {
			//获取参数
			Object object = pjp.getArgs()[0];
			if(object instanceof User){
				User user=(User) pjp.getArgs()[0];
				//先查询出原有内容
				String userName = user.getUsername();
				User oldUser = userMapper.selectByUserName(userName);
				String oldUserJson = JSONObject.toJSONString(oldUser);
				
				result=pjp.proceed(); //执行修改操作---返回result
				
				String newUserJson = JSONObject.toJSONString(user);
				String username=user.getModifyUser();
				String userId = user.getUserId();
				String contentType="user";
				logUpdate(oldUserJson,newUserJson, username,contentType,userId);
			}else if(object instanceof Role){
				Role role=(Role) pjp.getArgs()[0];
				//先查询出原有内容
				String roleName = role.getRoleName();
				Role oldRole = roleMapper.selectRolesByName(roleName);
				String oldRoleJson = JSONObject.toJSONString(oldRole);
				
				result=pjp.proceed(); //执行修改操作
				
				String newRoleJoson = JSONObject.toJSONString(role);
				String username=role.getModifyUser();
				String newRoleId = role.getRoleId();
				String contentType="role";
				logUpdate(oldRoleJson,newRoleJoson, username,contentType,newRoleId);
			}else if(object instanceof RuleInstance){
				RuleInstance ruleInstance=(RuleInstance) pjp.getArgs()[0];
				//先查询出原有内容
				String code = ruleInstance.getCode();
				RuleInstance oldRuleInstance = ruleInstanceMapper.selectByRuleCode(code);
				String oldRuleInstanceJson = JSONObject.toJSONString(oldRuleInstance);
				
				result=pjp.proceed(); //执行修改操作
				
				String newRuleInstanceJson = JSONObject.toJSONString(ruleInstance);
				String username=ruleInstance.getModifier();
				String newCode = ruleInstance.getCode();
				String contentType="ruleInstance";
				logUpdate(oldRuleInstanceJson,newRuleInstanceJson, username,contentType,newCode);
			}else if(object instanceof RuleAllot){
				RuleAllot ruleAllot=(RuleAllot) pjp.getArgs()[0];
				//先查询出原有内容
				String code = ruleAllot.getAllotCode();
				RuleInstance oldRuleInstance = ruleInstanceMapper.selectByRuleCode(code);
				String oldRuleInstanceJson = JSONObject.toJSONString(oldRuleInstance);
				
				result=pjp.proceed(); //执行修改操作
				
				String newRuleInstanceJson = JSONObject.toJSONString(ruleAllot);
				String username=ruleAllot.getModifier();
				String newCode = ruleAllot.getAllotCode();
				String contentType="ruleInstance";
				logUpdate(oldRuleInstanceJson,newRuleInstanceJson, username,contentType,newCode);
			}else if(object instanceof String){
				//说明是resetPassword 参数为string
				String userId = (String) pjp.getArgs()[0];
				String username = (String) pjp.getArgs()[1];
				User user = userMapper.selectByPrimaryKey(userId);
				String userJson = JSONObject.toJSONString(user);
				
				result=pjp.proceed(); //执行修改操作
				
				OperationLog operationLog=new OperationLog();
		        operationLog.setUsername(username);//设置管理员id  
		        operationLog.setCreatedTime(new Date());//操作时间  
		        operationLog.setOldContent(userJson);//旧内容
		        operationLog.setOperationType("用户重置密码");//操作  
		        operationLog.setContentType("user");//操作内容类型
		        operationLog.setContentId(userId);//操作内容ID
		        logService.log(operationLog);//添加日志  
			}else if(object instanceof List){
				@SuppressWarnings("unchecked")
				List<RuleInstance> list=(List<RuleInstance>)pjp.getArgs()[0];
				String listString = JSONObject.toJSONString(list);
				String username= (String) pjp.getArgs()[1];
				
				result=pjp.proceed(); //执行修改操作
				OperationLog operationLog=new OperationLog();
		        operationLog.setUsername(username);//设置管理员id  
		        operationLog.setCreatedTime(new Date());//操作时间  
		        operationLog.setOperationType("设置规则优先级");//操作  
		        operationLog.setContentType("RuleInstance");//操作内容类型
		        operationLog.setNewContent(listString);
		        logService.log(operationLog);//添加日志  
			}
		} catch (Exception e) {
			logger.info("记录更新日志异常信息"+e.getMessage());
		}
    	return result; 
    } 
	
	/** 
     * 用户绑定角色操作日志(环绕通知) 
     * @param joinPoint 
     * @param rtv 
     * @throws Throwable 
     */  
	@Around(value="bindServiceCall()", argNames="rtv")  
    public Object bindServiceCallCalls(ProceedingJoinPoint pjp) throws Throwable{  
		Object result=null;
    	try {
			//获取参数
			User user=(User) pjp.getArgs()[0];
			//先查询出原有内容
			String userId = user.getUserId();
			User oldUser=userMapper.selectByPrimaryKey(userId);
			String oldUserJson = JSONObject.toJSONString(oldUser);
			
			result=pjp.proceed(); //执行修改操作
			
			String newUserJson = user.toString();
			//String newUserJson = JSONObject.toJSONString(oldUser);
			String username=user.getModifyUser();
			String contentType="user";
			logUpdate(oldUserJson,newUserJson, username,contentType,userId);
		} catch (Exception e) {
			logger.info("记录更新日志异常信息"+e.getMessage());
		}
    	return result; 
    } 
    
    private void logUpdate(String oldContent,String newContent,String username,String contentType,String contentId) {
		//创建日志对象  
        OperationLog operationLog=new OperationLog();
        operationLog.setUsername(username);//设置管理员id  
        operationLog.setCreatedTime(new Date());//操作时间  
        operationLog.setOldContent(oldContent);//旧内容
        operationLog.setNewContent(newContent);//新内容  
        operationLog.setOperationType("修改");//操作  
        operationLog.setContentType(contentType);//操作内容类型
        operationLog.setContentId(contentId);//操作内容ID
          
        logService.log(operationLog);//添加日志  
	}  
      
    /** 
     * 删除操作(后置通知 只记录删除的id)
     * @param joinPoint 
     * @param rtv 
     * @throws Throwable 
     */  
    @AfterReturning(value="deleteServiceCall()", argNames="rtv",returning="rtv")  
    public void deleteCallCalls(JoinPoint joinPoint, Object rtv) throws Throwable {  
    	String contentId = (String) joinPoint.getArgs()[0];
    	String username=(String) joinPoint.getArgs()[1];
    	//创建日志对象  
        OperationLog operationLog=new OperationLog();
        operationLog.setUsername(username);//设置管理员id  
        operationLog.setCreatedTime(new Date());//操作时间  
        operationLog.setOperationType("删除");//操作  
        operationLog.setContentId(contentId);//操作内容ID
          
        logService.log(operationLog);//添加日志  
    }  
      
    /** 
     * 使用Java反射来获取被拦截方法(insert、update)的参数值， 
     * 将参数值拼接为操作内容 
     */  
    public String adminOptionContent(Object[] args, String mName) throws Exception{  
        if (args == null) {  
            return null;  
        }  
        StringBuffer rs = new StringBuffer();  
        rs.append(mName);  
        String className = null;  
        int index = 1;  
        // 遍历参数对象  
        for (Object info : args) {  
            //获取对象类型  
            className = info.getClass().getName();  
            className = className.substring(className.lastIndexOf(".") + 1);  
            rs.append("[参数" + index + "，类型：" + className + "，值：");  
            // 获取对象的所有方法  
            Method[] methods = info.getClass().getDeclaredMethods();  
              
            // 遍历方法，判断get方法  
            for (Method method : methods) {  
                String methodName = method.getName();  
                // 判断是不是get方法  
                if (methodName.indexOf("get") == -1) {// 不是get方法  
                    continue;// 不处理  
                }  
                  
                Object rsValue = null;  
                try {  
                    // 调用get方法，获取返回值  
                    rsValue = method.invoke(info);  
                    if (rsValue == null) {//没有返回值  
                        continue;  
                    }  
                } catch (Exception e) {  
                    continue;  
                }  
                //将值加入内容中  
                rs.append("(" + methodName + " : " + rsValue + ")");  
            }  
            rs.append("]");  
            index++;  
        }  
        return rs.toString();  
    }  
}

 

转载于:https://my.oschina.net/u/3278373/blog/874566

chuli0504
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Mall4j商城实战 - 功能分析
yueerba126的博客
11-21 291
spring-aop。
读书笔记-SpringCloudAlibaba微服务原理与实战-谭锋-【未完待续】
u011225581的专栏
03-19 1499
SpringCloudAlibaba微服务原理与实战 谭锋 电子工业出版社 ISBN-9787121388248 仅供参考, 自建索引, 以备后查 一、应用架构演进、微服务发展史 二、SpringCloud简介 三、SpringBoot、自动装配、自定义Starter 四、ZooKeeper、Dubbo （Dubbo、Apache Dubbo、Dubbo S...
AOP的实战（统一功能处理模块）
lucky_1314520的博客
08-03 289
我们要对一部分方法进行拦截，而另一部分方法不拦截，如注册方法和登录方法是不拦截的，这样的话排除方法的规则很难定义，甚至没办法定义。用户登录权限的发展从之前每个方法中自己验证用户登录权限，到现在统一的用户登录验证处理，它是一个逐渐完善和逐渐优化的过程。每个方法中都要单独写用户登录验证的方法，即使封装成公共方法，也一样要传参调用和在方法中进行判断。这些用户登录验证的方法和接下来要实现的业务几何没有任何关联，但每个方法中都要写一遍。此时用户登录权限的验证方法就会执行，这就是拦截器的实现原理。
彻底征服 Spring AOP 之 实战篇
weixin_34388207的博客
11-13 120
接上一小节彻底征服 Spring AOP 之 理论篇 Spring AOP 实战 看了上面这么多的理论知识, 不知道大家有没有觉得枯燥哈. 不过不要急, 俗话说理论是实践的基础, 对 Spring AOP 有了基本的理论认识后, 我们来看一下下面几个具体的例子吧.下面的几个例子是我在工作中所遇见的比较常用的 Spring AOP 的使用场...
Aop实战
最新发布
tmax52HZ的博客
09-18 173
Java动态代理AOP实战
AOP实战
li_tiantian的博客
05-19 264
AOP实战 一、定义AOP切面 package com.aop.service; ​ import com.alibaba.fastjson.JSONObject; import com.tf56.core.BizReturn; import com.tf56.core.exception.BizError; import com.tf56.hermesContract.exception.BusinessException; import lombok.extern.slf4j.Slf4j; imp
【大白话系列】-- AOP实战
Gilgame的博客
08-06 612
本文主要介绍如何优雅的在Spring Boot中使用自定义注解，AOP切面统一打印出入参日志 一. 首先看看切面日志输出效果： 从上图中可以看到，每个对于每个请求，开始与结束一目了然，并且打印了以下参数： URL: 请求接口地址； Description: 接口的中文说明信息； HTTP Method: 请求的方法，是 POST, GET, 还是 DELETE 等； Class Method: 被请求的方法路径 : 包名 + 方法名; IP: 请求.
记录用户操作日志（aop）
云海的博客
03-03 2078
一、面向切面编程： aop通过预编译的方式和运行期动态代理实现程序功能的一种技术。 有着代码侵入性小，不影响代码逻辑的优点。在springAOP中业务逻辑仅仅只关注业务本身，将日志记录，性能统计，安全控制，事务处理， 异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立到非指导业务逻辑的方法中， 进而改变这些行为的时候不影响业务逻辑的代码。 具体：记录用户的操作日志。 使用aop处理 ，先自定义切点cutPoint，然后写切面 a...
AOP实现操作日志记录
森林里的一天
06-22 6440
一、设计：    操作日志记录 根据业务场景 一般是需要记录下数据修改更新的日志，查询类可以忽略。 所以需要对指定的某些方法进行记录。这块希望可以结合注解灵活操作，对于注解的方法进行日志记录操作日志表设计如下：CREATE TABLE `op_log` (  `id` bigint(20) NOT NULL COMMENT '主键',  `operator` varchar(32) NOT NUL...
Java EE（J2EE）快速开发框架， SSM 架构 mybatis-plus kisso 实战项目.zip
06-16
7. **日志管理** ，如使用Log4j或SLF4J进行日志记录，调试和监控应用运行状态。 8. **数据库设计** ，理解ER模型，如何设计合理的数据库表结构和关系。 9. **RESTful API设计** ，遵循REST原则，创建清晰、可预测的...
网上书城 spring-mvc
08-15
9. **拦截器（Interceptor）**：可以定义在请求处理之前和之后执行的逻辑，例如登录检查、日志记录等。 10. **异常处理**：Spring-MVC支持自定义异常处理器，可以捕获并处理特定的业务异常。 11. **AJAX支持**：...
05_用户模块及角色模块的单表和多表操作
04-26
NULL 博文链接：https://javawjy.iteye.com/blog/2358176
Spring Boot中的AOP实战应用
![Spring Boot中的AOP...在Spring Boot中，AOP主要用于实现日志记录、安全、事务管理和性能监控等横切关注点。 # 2. Spring Boot中的AOP配置 ### 2.1 AOP代理模式 AOP（面向方面编程）是一种编程技术，它允许开发
AOP-项目实战
gpx2001的博客
06-26 202
项目需求：由于系统由多方公司联合开发，其他公司的相关接口可能偶尔网络不通，或者处于调试阶段，导致我方开发人员由于外部接口错误从而无法相关模块的开发，这里就可以使用Aop+自定义主键去实现接口拦截，从而返回正确响应参数。开启，有需要的话也可以关闭，pointCut()指定该切面的作用域，这里是用于注解，around()为处理接口拦截的具体业务。首先，我们可以自定义一个注解，这里的jsonFilePath用来指定文件（该文件包含正确的返回信息）的存放位置。
spring-AOP实战（最新，实用，简单，爆炸！！！！！）
狗蛋儿_312的博客
05-23 1149
废话不多说直接开始干（注：本文前提是你已经倒入了其他启动项目所有需要的spring包，且配置好）没有的话请去我的github下载（包含aopdemo）：下载项目第一步：倒入AOP相关jar包，本文实用POM                &lt;spring.version&gt;4.1.1.RELEASE&lt;/spring.version&gt;                 &lt;as...
Spring AOP项目实战
技术分享
07-12 1116
本文主要介绍了Spring AOP的基础知识以及在项目中实际使用场景以及代码实现
Android面向切面（AOP）编程实战
qq_36523667的博客
12-24 3184
转载自https://www.jianshu.com/p/b96a68ba50db AOP:面向切面编程(Aspect-Oriented Programming)。如果说，OOP如果是把问题划分到单个模块的话，那么AOP就是把涉及到众多模块的某一类问题进行统一管理。 Aspect介绍篇：Android中的AOP编程 这里通过几个小例子，讲解在Android开发中，如何运用AOP的方式，进
SpringAop实战
zhengxc博客
11-03 542
SpringAop实战1、什么是AOP1.1 spring Aop的应用1.2 开启spring支持1.3 声明一个切面1.4 声明一个切入点1.5 声明一个通知1.6 JoinPoint Api2、@EnableAspectJAutoProxy配置注意事项2.1 AopProxy2.2 proxyTargetClass 作用2.3 exposeProxy 作用 1、什么是AOP 与OOP对比,面...
Aop实操
qq_42938698的博客
02-17 180
准备面试
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值