AOP概念详解笔记

最新推荐文章于 2023-02-20 14:07:48 发布
最新推荐文章于 2023-02-20 14:07:48 发布
阅读量111 收藏
点赞数
文章标签： java spring aop spring boot bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013510614/article/details/109850790
版权

切面（Aspect）

一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是一个很好的横切关注点例子。切面用Spring的Advisor或拦截器实现， 然后可以通过@Aspect标注或在applictionContext.xml中进行配置： 

<aop:aspect id="fourAdviceAspect" ref="fourAdviceBean" order="2"> 

连接点（Joinpoint）

程序执行过程中的行为，如方法的调用或特定的异常被抛出，在代码上有JoinPoint类和ProceedingJoinPoint类，如下所示，可以通过JoinPoint获取很多参数，JoinPoint一般用在Advice实现方法中作为参数传入，ProceedingJoinPoint用于实现围绕Advice的参数传入。  通过下面JoinPoint的接口可以看出通过JoinPoint可以得到代理对象和Target对象。

package org.aspectj.lang;  
import org.aspectj.lang.reflect.SourceLocation;  
public interface JoinPoint {  
    String toString();         //连接点所在位置的相关信息  
    String toShortString();     //连接点所在位置的简短相关信息  
    String toLongString();     //连接点所在位置的全部相关信息  
    Object getThis();         //返回AOP代理对象  
    Object getTarget();       //返回目标对象  
    Object[] getArgs();       //返回被通知方法参数列表  
    Signature getSignature();  //返回当前连接点签名  
    SourceLocation getSourceLocation();//返回连接点方法所在类文件中的位置  
    String getKind();        //连接点类型  
    StaticPart getStaticPart(); //返回连接点静态部分  
}  
  
public interface ProceedingJoinPoint extends JoinPoint {  
    public Object proceed() throws Throwable;  
    public Object proceed(Object[] args) throws Throwable;  
}

切入点（Pointcut）

指定一个Adivce将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点，例如，使用正则表达式。

xml中配置：

<aop:pointcut id="myPointcut" expression="execution(* com.wicresoft.app.service.impl.*.*(..))" method="release" /> 

或使用

Annoation ：@pointcut("execution * transfer(..)")

并用一个返回值为void，方法体为空的方法来命名切入点如：  

private void anyOldTransfer(){}

之后就可以在Advice中引用，如： 

@AfterReturning(pointcut="anyOldTransfer()", returning="reVal")
package org.springframework.aop;  
public interface Pointcut {  
    ClassFilter getClassFilter();  
    MethodMatcher getMethodMatcher();  
    Pointcut TRUE = TruePointcut.INSTANCE;  
}  
package org.springframework.aop;  
public interface ClassFilter {  
     boolean matches(Class<?> clazz);//如果clazz与我们关注的现象相符时返回true,负责返回false  
     ClassFilter TRUE = TrueClassFilter.INSTANCE;//静态参数 如果类型对于要扑捉的Pointcut来说无所谓，可将此参数传递给Pointcut  
}  
package org.springframework.aop;  
public interface MethodMatcher {  
   boolean matches(Method method, Class<?> targetClass);  
  
 /** 
  * 是否对参数值敏感 
  * 如果为false表明匹配时不需要判断参数值(参数值不敏感)，称之为StaticMethodMatcher，这时只有 
  * matches(Method method, Class<?> targetClass); 被执行，执行结果可以缓存已提高效率。 
  * 如果为true表明匹配时需要判断参数值（参数值敏感），称之为DynamicMethodMatcher,这时先执行 
  * matches(Method method, Class<?> targetClass);如果返回true,然后再执行 
  * boolean matches(Method method, Class<?> targetClass, Object[] args);已做进一步判断 
  *  
  */  
 boolean isRuntime();  
 boolean matches(Method method, Class<?> targetClass, Object[] args);  
 MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;  
}

关于PointCut中使用的execution的说明：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?) 

modifiers-pattern：方法的操作权限

ret-type-pattern：返回值

declaring-type-pattern：方法所在的包

name-pattern：方法名

parm-pattern：参数名

throws-pattern：异常

记忆法则就是Java定义一个方法时的样子：public boolean produceValue(int oo) throws Exception, 只要在方法名前加上包名就可以了。

其中，除ret-type-pattern和name-pattern之外，其他都是可选的。上例中，execution(* com.spring.service.*.*(..))表示com.spring.service包下，返回值为任意类型；方法名任意；参数不作限制的所有方法。

常见的PointCut结构图

通知（Advice）

在特定的连接点，AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。Advice中必须用到PointCut

     在xml中配置，配置中的method为Aspect实现类中的方法名，使用pointcut自定义或pointcut-ref进行引用已有pointcut

<aop:before pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method="authority" /> 
<aop:after pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method="release" /> 
<aop:after-returning pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method="log" />
<aop:around pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method="processTx" /> 
<aop:after-throwing pointcut-ref="myPointcut" method="doRecovertyActions" throwing="ex" />     

或使用Annoation:   

@Before("execution(* com.wicresoft.app.service.impl.*.*(..))")
@AfterReturning(returning="rvt", pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))")
@AfterThrowing(throwing="ex", pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))")
@After("execution(* com.wicresoft.app.service.impl.*.*(..))")
@Around("execution(* com.wicresoft.app.service.impl.*.*(..))")  

注意

  • AfterReturning 增强处理处理只有在目标方法成功完成后才会被织入。
  • After 增强处理不管目标方法如何结束（保存成功完成和遇到异常中止两种情况），它都会被织入。

使用方法拦截器的around通知，需实现接口MethodInterceptor：

public interface MethodInterceptor extends Interceptor {
    Object invoke(MethodInvocation invocation) throws Throwable;
}

invoke()方法的MethodInvocation 参数暴露将被调用的方法、目标连接点、AOP代理和传递给被调用方法的参数。 invoke()方法应该返回调用的结果：连接点的返回值。

一个简单的MethodInterceptor实现看起来如下:

public class DebugInterceptor implements MethodInterceptor {  
    public Object invoke(MethodInvocation invocation) throws Throwable {  
        System.out.println("Before: invocation=[" + invocation + "]");  
        Object rval = invocation.proceed();  
        System.out.println("Invocation returned");  
        return rval;  
    }  
}

注意MethodInvocation的proceed()方法的调用。这个调用会应用到目标连接点的拦截器链中的每一个拦截器。大部分拦截器会调用这个方法，并返回它的返回值。但是， 一个MethodInterceptor，和任何around通知一样，可以返回不同的值或者抛出一个异常，而不调用proceed方法。但是，没有好的原因你要这么做。

Before通知：需实现MethodBeforeAdvice接口

public interface MethodBeforeAdvice extends BeforeAdvice {
    void before(Method m, Object[] args, Object target) throws Throwable;
}

Throw通知，需实现ThrowsAdvice接口

After Returning通知须直线AfterReturningAdvice接口

public interface AfterReturningAdvice extends Advice {
   void afterReturning(Object returnValue, Method m, Object[] args, Object target) throws Throwable;
}

引入（Introduction）

添加方法或字段到被通知的类，引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现IsModified接口，来简化缓存。使用introduction要有三个步骤：

（1）声明新接口

（2）创建自己的IntrouductionInterceptor通过Implements IntroductionInterceptor或extends DelegatingIntroductionInterceptor 并同时implements(1)中声明的接口

（3）将新接口和自定义的IntroductionInterceptor配置到DefaultIntroductionAdvisor中，然后将前三者配置到ProxyFactoryBean中。

public interface IOtherBean {  
    public void doOther();  
}  
  
public class SomeBeanIntroductionInterceptor implements IOtherBean, IntroductionInterceptor {  
  
    public void doOther() {  
        System.out.println("doOther!");  
    }  
  
    public Object invoke(MethodInvocation invocation) throws Throwable {  
          
        //判断调用的方法是否为指定类中的方法  
        if ( implementsInterface(invocation.getMethod().getDeclaringClass()) ) {  
            return invocation.getMethod().invoke(this, invocation.getArguments());  
        }  
          
        return invocation.proceed();  
    }  
      
    /** 
     * 判断clazz是否为给定接口IOtherBean的实现 
     */  
    public boolean implementsInterface(Class clazz) {  
          
        return clazz.isAssignableFrom(IOtherBean.class);  
    }  
}  
<!-- 目标对象 -->  
<bean id="someBeanTarget" class="aop.spring.introduction.SomeBeanImpl" />  
<!-- 通知 -->  
<bean id="someBeanAdvice" class="aop.spring.introduction.SomeBeanIntroductionInterceptor" />  
<!-- 通知者，只能以构造器方法注入-->  
<bean id="introductionAdvisor" class="org.springframework.aop.support.DefaultIntroductionAdvisor">  
    <constructor-arg ref="someBeanAdvice" />  
    <constructor-arg value="aop.spring.introduction.IOtherBean" />      
</bean>  
      
<!-- 代理 （将我们的切面织入到目标对象）-->  
<bean id="someBeanProxy" class="org.springframework.aop.framework.ProxyFactoryBean">  
    <!-- 若目标对象实现了代理接口，则可以提供代理接口的配置 -->  
    <property name="proxyInterfaces"  value="aop.spring.introduction.ISomeBean" />  
    <!-- 配置目标对象 -->  
    <property name="target" ref="someBeanTarget" />  
    <!-- 配置切面 -->  
    <property name="interceptorNames">  
        <list>  
            <value>introductionAdvisor</value>  
        </list>  
    </property>  
</bean>

拦截器（Advisor ）

常用的有PointCutAdvisor和IntroudtionAdvisor。前者Advisor有PointCut和Advice组成，满足Poincut（指定了哪些方法需要增强），则执行相应的Advice（定义了增强的功能），后者由Introduction构成。PointCutAdvisor主要是根据PointCut中制定的Target Objects的方法在调用(前，后，around,throws, after-return等)时引入新的Aspect中的methods, 而IntroductionAdvisor主要是引入新的接口到Targets对象中。

public interface PointcutAdvisor {  
    Pointcut getPointcut();  
    Advice getAdvice();  
}

1、PointcutAdvisor：

 Advice和Pointcut，默认实现为DefaultPointcutAdvisor， 还有NameMatchMethodPointcutAdvisor，RegexpMethodPointcutAdvisor等。 

 其中NameMacthMethodPointCutAdvisor、RegexpMethodPointCutAdvisor 可以对比常用的PointCut类有NameMatchedMethodPointCut和JdkRegexMethodPointCut。
 前者需要注入mappedName和advice属性，后者需要注入pattern和advice属性。其中mappedName和pattern是直接配置的值，而advice需要自己实现具体的advice，可见实现advisor的时候，不需要实现PointCut，一般PointCut只需要配置就好了，不需要具体实现类
 mappedName指明了要拦截的方法名，pattern按照正则表达式的方法指明了要拦截的方法名，advice定义了一个增强（需要自己实 现MethodBeforeAdvice、  MethodAfterAdvice、ThrowsAdvice、MethodInterceptor接口之 一）。然后在ProxyFactoryBean的拦截器（interceptorNames）中注入这个PointCutAdvisor即可，如上面这个ProxyFactoryBean是一个静态代理，只能代理一个类给加上AOP，那么这个静态代理需要注入有目标对象，目标对象的接口，和interceptorsNames

2、 IntroductionAdvisor ：

默认实现为DefaultIntroductionAdvisor，这个主要与Introduction有关，可以参考上面的例子

— 目标对象（Target Object）：包含连接点的对象，也被称作被通知或被代理对象。

— AOP代理（AOP Proxy）：AOP框架创建的对象，包含通知。在Spring中，AOP代理可以是JDK动态代理或CGLIB代理。如ProxyFactory,ProxyFactoryBean, 下面会进行详细说明    

— 编织（Weaving）：组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。将Aspect加入到程序代码的过程，对于Spring AOP，由ProxyFactory或者ProxyFactoryBean负责织入动作。 

通过ProxyFactory可以将对符合条件的类调用时添加上Aspect。

或者 可使用XML声明式 ProxyFactoryBean:需要设定 target，interceptorNames（可以是Advice或者Advisor，注意顺序, 对接口代理需设置proxyInterfaces 

注意：一个ProxyFactoryBean只能指定一个代理目标，不是很方便，这就产生了自动代理。通过自动代理，可以实现自动为多个目标Bean实现AOP代理、避免客户端直接访问目标Bean（即getBean返回的都是Bean的代理对象）。spring的自动代理是通过BeanPostProcessor实现的，容器载入xml配置后会修改bean为代理Bean，而id不变。 

ApplicationContext可以直接检测到定义在容器中的BeanPostProcessor，BeanFactory需要手动添加。 
有2种常用的BeanPostProcessor： 

1.BeanNameAutoProxyCreator :

故名思议，BeanName需要注入的两个属性有BeanNames和interceptorNames

<bean id="loginBeforeAdvisor" .../>    
<bean id="loginThrowsAdvisor" .../>    
<bean  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">    
        <!-- 注入目标Bean -->    
        <property name="beanNames" value="*Service">    
        </property>    
        <property name="interceptorNames">    
            <list>    
                <value>loginBeforeAdvisor</value>    
                <value>loginThrowsAdvisor</value>    
            </list>    
        </property>    
</bean>

2.DefaultAdvisorAutoProxyCreator：

DefaultAdvisorAutoProxyCreator和BeanNameAutoProxyCreator不同的是，前者只和Advisor 匹配， 该类实现了BeanPostProcessor接口。当应用上下文读入所有的Bean的配置信息后，该类将扫描上下文，寻找所有的Advisor，他将这些Advisor应用到所有符合切入点的Bean中。所以下面的xml中没有绑定也无需绑定DefaultAdvisorAutoProxyCreator与Advisor的关系。

<?xml version="1.0" encoding="UTF-8"?>  
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">  
<beans>  
     <bean id="kwikEMartTarget" class="demo.ApuKwikEMart"></bean>  
     <bean id="performanceThresholdInterceptor" class="demo.advice.PerformanceThresholdInterceptor">  
          <constructor-arg>  
               <value>5000</value>  
          </constructor-arg>  
     </bean>  
     <!-- 使用RegexpMethodPointcutAdvisor来匹配切入点完成个一个Advisor; -->  
     <bean id="regexpFilterPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  
          <property name="pattern">  
               <!-- 匹配的名字为方法名-->  
               <value>.*buy.*</value>  
          </property>  
          <property name="advice">  
               <ref bean="performanceThresholdInterceptor"/>  
          </property>  
     </bean>  
     <bean id="defaultAdvisorAutoProxyCreator"  
     class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator" />  
</beans>

在使用Aonnotation的时候，需要进行在ApplicationContext.xml中进行配置：

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
       xmlns:aop="http://www.springframework.org/schema/aop"        
       xsi:schemaLocation="http://www.springframework.org/schema/beans  
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
           http://www.springframework.org/schema/aop  
       http://www.springframework.org/schema/beans/spring-aop-3.0.xsd">  
        <!-- 启动对@AspectJ注解的支持 -->  
        <aop:aspectj-autoproxy/>  
</beans>

综上，Spring下AOP的配置与实现，BeanNameAutoProxyCreator,DefaultAdvisorAutoProxyCreator已经部分简化了AOP配置，然而还是很繁琐： 首先要编写xxxAdvice类（需要自己实现MethodBeforeAdvice、MethodAfterAdvice、 ThrowsAdvice、MethodInterceptor接口之一），然后还要在xml中配置Advisor，还要在Advisor中注入 Advice，最后还要将Advisor加入ProxyFactoryBean、BeanNameAutoProxyCreator或者 DefaultAdvisorAutoProxyCreator中。

实际上AOP不止Spring进行了实现，还有AspectJ，后者对AOP中的概念实现比较彻底，可以看上面，而Spring中对AOP的方方面面进行简化，拿上面定义的regexpFilterPointcutAdvisor是一种Advisor包含了PointCut和Advice，而此处的PointCut就是pattern属性的值了，没有特定的PointCut Bean定义，而advice定义了Bean。而其他概念Aspect, JoinPoint都融汇于Advice的实现中即Advisor（MethodBeforeAdvice等和MethodIntector接口的实现类）或IntroductionInterceptor了。

较详细的介绍AOP http://blog.chinaunix.net/uid-21547257-id-97998.html

利用Spring Interceptor 来缓存指定方法结果： 

http://www.blogjava.net/kapok/archive/2005/04/17/3388.html

Advice的类型及实现细节：

http://blog.csdn.net/saintlu/article/details/3340190

http://www.cnblogs.com/tazi/articles/2306160.html  

http://blog.csdn.net/a906998248/article/details/7514969

http://sishuok.com/forum/blogPost/list/2466.html;jsessionid=AC7C2BDCBF5B19BE4327AD26D40C3CFF

刘元涛
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
SpringAOP学习笔记
01-27
,文章属于基础级文章，适合入门级的小伙伴，它的概念，应用场景，实现原理及Spring的AOP的开发。全称:面向切面编程(AspectOrientedProgramming),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。...
AOP的基本概念
beeworkshop的博客
03-06 3844
1、概述 AOP（Aspect Oriented Programming），即面向切面编程，可以处理很多事情，常见的功能比如日志记录，性能统计，安全控制，事务处理，异常处理等。 AOP可以认为是一种更高级的“复用”技术，它是OOP（Object Oriented Programming，面向对象编程）的补充和完善。AOP的理念，就是将分散在各个业务逻辑代码中相同的代码通过横向切割的方式抽取到一个...
AOP概念详解
qq_44645822的博客
12-31 570
AOP理解AOP什么是AOPAOP体系与概念 理解AOP 什么是AOP AOP（Aspect Oriented Programming），面向切面思想，是Spring的三大核心思想之一（两外两个：IOC-控制反转、DI-依赖注入）。 程序中一般都存在一些系统性的去求，权限校验、日志记录、统计等。 有多少业务操作，就要写多少重复的校验和日志记录代码，运用面向对象的思想，我们可以把这些重复的代码抽离出来，写成公共的方法。 这样能解决代码冗余和可维护性的问题，但是每个业务方法中依然要依次调用这些公共方法，繁琐
AOP概念
guoweiting的博客
01-14 215
Spring学习
AOP基本概念
Peter的游击战
12-26 483
原文地址：AOP基本概念作者：迎风飞扬    一、关注点(Concern)     关注点就是要考察或解决的问题。如订单处理，用户验证、日志记录等都属于关注点。     核心关注点(Core Concerns)，是指系统中的核心功能，即真正的商业逻辑。一个电子商务系统核心关注点：订单处理、客户管理、库存及物流管理。     横切关注点 (Crosscutting Concerns)，他们分散在每
一文弄懂AOP各种概念
wh柒八九的博客
08-28 4540
本文来说下Redis常见使用场景 文章目录概述 概述
SpringBoot AOP使用笔记
08-26
今天小编就为大家分享一篇关于SpringBoot AOP使用笔记，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Spring AOP面向方面编程原理：AOP概念
11-21
Spring AOP面向方面编程原理：AOP概念，主要介绍面向对象的概念及原理，及作者的一些理解。
AOP的相关概念
11-12
Aop的概念和配置步骤 常用标签 常用注解
Spring AOP IOC源码笔记.pdf
05-08
1.Spring入门和IOC介绍 2.对象依赖 3.AOP入门 4.JDBCTemplate和Spring事务 5.Spring事务原理 6.Spring事务的一个线程安全问题 7.IOC再回顾和面试题 8.AOP再回顾
AOP的概念
m0_70336653的博客
02-20 159
AOP的概念
AOP基础概念
ChineseSoftware的博客
01-20 1408
一、AOP基础概念 二、Join point(连接点) 程序执行期间的某一个点，例如执行方法或处理异常时候的点。在 Spring AOP 中，连接点总是表示方法的执行。org.aspectj.lang.JoinPoint 接口表示目标类连接点对象，它定义这些主要方法。 org.aspectj.lang.ProceedingJoinPoint 继承了 JoinPoint 接口，它新增了两个方法(它们用于执行连接点方法)。 三、Advice(通知) 通知是指一个切面在特定的连接点要做的事情。通知分为方法执行前
AOP概念及作用详细解释
热门推荐
weixin_50249953的博客
03-20 1万+
今天学习spring的时候接触到一个新的知识以及概念AOP,老师当时讲这个知识点的时候，并没有讲太多关于这方面的知识，我们所学习到的知识侧重于应用，所以对这一块的理论知识是有一点缺少，以至于小编在学习完AOP之后，也不太清楚这是一个什么东西，到底有什么作用？因此小编自己在课余时间对这方面知识进行了一个补充学习，并且将自己的课后积累进行一个分享，希望能够帮助到和我一样迷惑到学习者！小编的每一遍文章自己都有很用心的在编写，希望自己的这份用心能够在帮助大家的同时得到大家的支持和鼓励，如果各位客官觉得小编的文章对各
Spring系列第31篇：aop概念详解
路人甲Java
06-14 6821
本文主要内容什么是Aop？Spring AOP中重要的一些概念详解Spring AOP 硬编码实现什么是AOP？先看一下传统程序的流程，比如银行系统会有一个取款流程我们可以把方框里的流程...
AOP 的概念、名词解释、实现原理、常用场景
codeF4的博客
05-09 4550
AOP概念 1.aop:面向切面编程。是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充。 2.在应用 AOP 编程时, 仍然需要定义公共功能, 但可以明确的定义这个功能在哪里, 以什么方式应用, 并且不必修改受影响的类. 这样一来横切关注点就被模块化到特殊的对象(切面)里 Aop的好处 1.每个事物逻辑位于一个位置, 代码不分散...
Aop概念详解
蝉之洞
03-23 2739
AOP详解
AOP是什么？
weixin_54877075的博客
07-30 7067
3、连接点【Joinpotint】
aop概念简介
weixin_57763462的博客
10-04 493
一、AOP即面向切向编程 AOP 是 Aspect Oriented Programming 的缩写，译为面向切向编程。用我们最常用的 OOP 来对比理解：纵向关系 OOP，横向角度 AOP举个小例子：设计一个日志打印模块。按 OOP 思想，我们会设计一个打印日志 LogUtils 类，然后在需要打印的地方引用即可。public class ClassA { private void initView() { LogUtils.d(TAG, “onInitView”); }}pub
spring aop xml详解
最新发布
06-01
下面是Spring AOP的XML配置详解： 1. 配置命名空间和约束 在使用Spring AOP之前，需要在XML配置文件中声明Spring AOP的命名空间和约束，如下所示： ```xml xmlns:xsi=...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

刘元涛

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

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

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

打赏作者

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

抵扣说明：

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

余额充值