AOP——SpringAOP（最重要）

最新推荐文章于 2024-08-21 15:38:22 发布
最新推荐文章于 2024-08-21 15:38:22 发布
阅读量3.1w 收藏 61
点赞数 6

http://www.cnblogs.com/solverpeng/p/5628100.html

一、AOP:

是对OOP编程方式的一种补充。翻译过来为“面向切面编程”。

可以理解为一个拦截器框架，但是这个拦截器会非常武断，如果它拦截一个类，那么它就会拦截这个类中的所有方法。如对一个目标列的代理，增强了目标类的所有方法。

两个解决办法：

1.不优雅的做法：

在添加增强时，根据方法名去判断，是否添加增强，但是这样就得一直去维护这个增强类。

2.面向切面：

将增强类和拦截条件组合在一起，然后将这个切面配置到 ProxyFactory 中，从而生成代理。

二、AOP 和 切面的关系

1.类比于 OOP 和 对象，AOP 和 切面就是这样的一种关系。

2.也可以将 切面 看成是 AOP 的一个工具。

三、几个概念

切面（Advisor）：是AOP中的一个术语，表示从业务逻辑中分离出来的横切逻辑，比如性能监控，日志记录，权限控制等。

这些功能都可以从核心的业务逻辑中抽离出去。可以解决代码耦合问题，职责更加单一。封装了增强和切点。

增强（Advice）：增强代码的功能的类，横切到代码中。

目标：目标方法（JDK代理）或目标类（CGLIB代理）

代理：JDK代理，CGLIB代理。或是通过 ProxyFactory 类生产。

切点：通过一个条件来匹配要拦截的类，这个条件称为切点。如拦截所有带 Controller 注解的类。增强的条件。

连接点：作为增强方法的入参，可以获取到目标方法的信息。

四、概括为一张图

五、增强

1.Weaving（织入）：对方法进行增强

（1）前置增强（BeforeAdvice）：在目标方法前调用。

（2）后置增强（AfterAdvice）：在目标方法后调用。

（3）环绕增强（AroundAdvice）：将 Before 和 After ，甚至抛出增强和返回增强合到一起。

（4）返回增强（AfterReturningAdvice）：在方法返回结果后执行，该增强可以接收到目标方法返回结果。

（5）抛出增强（AfterThrowingAdvice）：在目标方法抛出对应的类型后执行，可以接收到对应的异常信息。

2.Introduction（引入）：对类进行增强

（1）引入增强（DeclareParentsAdvice）：想让程序在运行的时候动态去实现某个接口，需要引入增强。

六、SpringAOP

1.编程式

（1）前置增强，需要实现：MethodBeforeAdvice 接口

增强类：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-27-11:07
 */
public class CarBeforeAdvice implements MethodBeforeAdvice{
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("before");
    }
}
复制代码

测试方法：

复制代码 
@Test
public void test03() {
　　ProxyFactory proxyFactory = new ProxyFactory();
　　proxyFactory.setTarget(new Car());
　　proxyFactory.addAdvice(new CarBeforeAdvice());
　　Wheel carProxy = (Wheel)proxyFactory.getProxy();
　　carProxy.run();
}
复制代码

（2）后置增强：实现 AfterReturningAdvice 接口

（3）环绕增强：实现 org.aopalliance.intercept.MethodInterceptor 接口，使用 Object result = methodInvocation.proceed(); 调用目标方法。在目标方法前后添加增强。

2.声明式：Spring + AspectJ

开发步骤：

（1）定义切面类，将该切面类放入到 IOC 容器中

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-27-13:10
 */
@Component
public class XMLLoggingAspect {

    public void beforeAdvice(JoinPoint point) {
        System.out.println("xml aspects logging before");
    }

    public void afterAdvice(JoinPoint point) {
        System.out.println("xml aspects logging after");
    }

    public void afterReturningAdvice(JoinPoint point, Object result) {
        System.out.println("xml aspects logging afterReturningAdvice");
    }

    public void afterThrowingAdvice(JoinPoint point, Exception e) {
        System.out.println("xml aspects logging afterThrowingAdvice");
    }

    public Object aroundAdvice(ProceedingJoinPoint point) throws Throwable {
        Object result = point.proceed();
        System.out.println("xml aspects logging aroundAdvice");
        return result;
    }

}
复制代码

（2）Spring AOP 配置都必须定义在 <aop:config>元素内部。

（3）在 <aop:config> 中，每个切面都需要创建一个 <aop:aspect> 元素

（4）为具体的切面实现引用后端的  bean 实例。

下面展示 前置增强、后置增强、环绕增强、返回增强、抛出增强 的一个例子：

复制代码 
<aop:config>
　　<aop:aspect ref="XMLLoggingAspect">
　　　　<aop:pointcut id="carPointcut" expression="execution(void run())"/>
　　　　<aop:before method="beforeAdvice" pointcut-ref="carPointcut"/>
　　　　<aop:after method="afterAdvice" pointcut-ref="carPointcut"/>
　　　　<aop:after-returning method="afterReturningAdvice" pointcut-ref="carPointcut" returning="result"/>
　　　　<aop:after-throwing method="afterThrowingAdvice" pointcut-ref="carPointcut" throwing="e"/>
　　　　<aop:around method="aroundAdvice" pointcut-ref="carPointcut"/>
　　</aop:aspect>
</aop:config>
复制代码

控制台输出：

xml aspects logging before
i am a car, i can run.
xml aspects logging aroundAdvice
xml aspects logging afterReturningAdvice
xml aspects logging after

基于声明式的 Spring AspectJ 织入增强配置说明：

支持配置两个级别的公共切点表达式，一个是针对某个切面的所有方法（定义在 <aop:aspect> 节点内），另一个是针对所有切面（定义在<aop:config>节点内）。使用 pointcut-ref 来引入切点。

下面展示 引入增强 的一个例子：

对于引入增强，只需要在配置在 <aop:aspect> 节点下就可以，不需要去切面类中添加任何属性。

复制代码 
<aop:config>
　　<aop:aspect ref="XMLLoggingAspect">
　　　　<aop:declare-parents
　　　　　　　　　　types-matching="com.nucsoft.spring.target.impl.Student"
   　　　　　　　　implement-interface="com.nucsoft.spring.target.Fly"
  　　　　　　　　 default-impl="com.nucsoft.spring.target.impl.SuperMan"/>
　　</aop:aspect>
</aop:config>
复制代码

测试：

复制代码 
@Test
public void test04() {
　　Person student = context.getBean(Student.class);
　　System.out.println(student.say("james"));
　　Fly fly = (Fly) student;
　　fly.fly();
}
复制代码

控制台输出：

hello,james
i am super man, i can fly.

基于声明式的 Spring AspectJ 引入增强配置说明：

（1）引入增强是类级别的，所以不存在切点表达式。

（1）利用 <aop:declare-parents> 节点在 <aop:aspect> 内部声明

（2）types-matching 属性，要增强的目标类，这里需要全类名。

（3）implement-interface 属性：动态的增强类接口。

（4）default-impl 属性：动态增强类接口的实现类。

3.注解：Spring + AspectJ

对切面类添加 @Aspect 注解，将切面类和目标类放入到 IOC 容器中，可以通过 <context:component-scan base-package=""/> 进行扫描。

添加增强方法（包括增强类型和切点表达式，以及连接点）。

在 Spring Config 文件中添加 <aop:aspectj-autoproxy proxy-target-class="true"/>， proxy-target-class属性，false 只能代理接口（JDK动态代理），true 代理类（CGLIB动态代理）

3.1 通过切点表达式（AspectJ execution）进行拦截

spring-config.xml

<context:component-scan base-package="com.nucsoft.spring"/>
<aop:aspectj-autoproxy proxy-target-class="true"/>

Person 接口：

/**
 * Created by solverpeng on 2016/7/26.
 */
public interface Person {
    String say(String name);
}

Person 实现类 Student：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-17:55
 */
@Component
public class Student implements Person{
    @Override
    public String say(String name) {
        return "hello," + name;
    }

}
复制代码

测试：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-18:15
 */
public class SpringTest {
    @Test
    public void test01() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        Student student = context.getBean(Student.class);
        String james = student.say("james");
        System.out.println(james);
    }
}
复制代码

 

（1）前置增强：关键字：@Before，JoinPoint，execution 切点表达式，表达式内容支持通配符

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-17:42
 */
@Aspect
@Component
public class LoggingAspect {
    @Before("execution(String say(String))")
    public void before(JoinPoint point) {
        System.out.println("before");
    }
}
复制代码

控制台输出：

before
hello,james

（2）后置增强：关键字：@After

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-17:42
 */
@Aspect
@Component
public class LoggingAspect {
    @After("execution(String say(String))")
    public void afterAdvice(JoinPoint point) {
        System.out.println("after...");
    }
}
复制代码

控制台输出：

after...
hello,james

（3）环绕增强：关键字：@Around，ProceedingJoinPoint

将 Student 类还原

切面类：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-17:42
 */
@Aspect
@Component
public class LoggingAspect {

    @Around("execution(String say(String))")
    public Object aroundAdvice(ProceedingJoinPoint point) throws Throwable {
        before();
        Object result = point.proceed();
        after();
        return result;
    }
    private void before(){
        System.out.println("before");
    }

    private void after(){
        System.out.println("after");
    }

}
复制代码

控制台输出：

before
after
hello,james

注意：

<1>.增强方法的返回值为 Object 类型的，该返回值与目标方法返回值一致。

<2>.Object result = point.proceed(); 该 result 即为目标方法执行后的返回值。

<3>.在环绕通知中需要明确调用 ProceedingJoinPoint 的 proceed() 方法来执行被代理的方法. 如果忘记这样做就会导致通知被执行了, 但目标方法没有被执行

<4>.环绕通知的方法需要返回目标方法执行之后的结果, 即调用 joinPoint.proceed(); 的返回值, 否则会出现空指针异常

（4）返回增强：关键字：@AfterReturning，returning，JoinPoint

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-17:42
 */
@Aspect
@Component
public class LoggingAspect {
    @AfterReturning(value = "execution(String say(String))", returning = "str")
    public void aferRetruningAdvice(JoinPoint point, String str) {
        System.out.println("str:" + str);
        System.out.println("aferRetruningAdvice");
    }
}
复制代码

控制台输出：

str:hello,james
aferRetruningAdvice
hello,james

（5）抛出增强：关键字：@AfterThrowing，throwing。注意：抛出的异常类型必须和切面抛出增强接收的异常类型相同或是其子类。

更改 Student 类，手动抛出一个异常：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-17:55
 */
@Component
public class Student implements Person{
    @Override
    public String say(String name) {
        throw new RuntimeException("exception");
    }
}
复制代码

切面类：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-17:42
 */
@Aspect
@Component
public class LoggingAspect {

    @AfterThrowing(value = "execution(String say(String))", throwing = "e")
    public void AfterThrowingAdvice(JoinPoint point, Exception e) {
        String message = e.getMessage();
        System.out.println(message);
        System.out.println("AfterThrowingAdvice");
    }

}
复制代码

控制台输出：

exception
AfterThrowingAdvice

3.2 通过切点注解表达式（AspectJ @annotation）进行拦截

开发步骤：

（1）定义注解类

/**
 * Created by solverpeng on 2016/7/27.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AuthorityTag {}

（2）为切面类中增强指定注解表达式

复制代码 
/**
 * Created by solverpeng on 2016/7/27.
 */
@Aspect
@Component
public class AuthorityAspect {
    @Before("@annotation(com.nucsoft.spring.annotation.AuthorityTag)")
    public void before(JoinPoint point) {
        System.out.println("authority before");
    }
}
复制代码

（3）在目标类目标方法上标注注解

复制代码 
/**
 * @author xzsw
 * @create 2016-07-27-9:59
 */
@Component
public class Car implements Wheel{
    @AuthorityTag
    @Override
    public void run() {
        System.out.println("i am a car, i can run.");
    }
}
复制代码

各种增强的使用：

（1）前置增强

上面介绍步骤的例子就是一个前置增强。

控制台输出：

authority before
i am a car, i can run.

（2）后置增强

可以为多个增强使用同一个注解，如：

复制代码 
/**
 * Created by solverpeng on 2016/7/27.
 */
@Aspect
@Component
public class AuthorityAspect {
    @Before("@annotation(com.nucsoft.spring.annotation.AuthorityTag)")
    public void before(JoinPoint point) {
        System.out.println("authority before");
    }

    @After("@annotation(com.nucsoft.spring.annotation.AuthorityTag)")
    public void afterAdvice(JoinPoint point) {
        System.out.println("authority after");
    }
}
复制代码

控制台输出：

authority before
i am a car, i can run.
authority after

也可以为每个增强使用不同的注解，如：

注解：

/**
 * Created by solverpeng on 2016/7/27.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BeforeAuthorityTag {}

 

/**
 * Created by solverpeng on 2016/7/27.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AfterAuthorityTag {}

切面：

复制代码 
/**
 * Created by solverpeng on 2016/7/27.
 */
@Aspect
@Component
public class AuthorityAspect {
    @Before("@annotation(com.nucsoft.spring.annotation.BeforeAuthorityTag)")
    public void before(JoinPoint point) {
        System.out.println("authority before");
    }

    @After("@annotation(com.nucsoft.spring.annotation.AfterAuthorityTag)")
    public void afterAdvice(JoinPoint point) {
        System.out.println("authority after");
    }
}
复制代码

使用：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-27-9:59
 */
@Component
public class Car implements Wheel{
    @BeforeAuthorityTag
    @AfterAuthorityTag
    @Override
    public void run() {
        System.out.println("i am a car, i can run.");
    }
}
复制代码

控制台输出：

authority before
i am a car, i can run.
authority after

（3）环绕增强

注解类：

/**
 * Created by solverpeng on 2016/7/27.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AroundAuthorityTag {}

切面增强：

复制代码 
@Around(value = "@annotation(com.nucsoft.spring.annotation.AroundAuthorityTag)")
public Object aroundAdvice(ProceedingJoinPoint point) throws Throwable {
　　Object result = point.proceed();
　　after();
　　System.out.println("authority aroundAdvice");
　　return result;
}

private void after() {
　　System.out.println("after");
}
复制代码

目标类：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-27-9:59
 */
@Component
public class Car implements Wheel{
    @AroundAuthorityTag
    @Override
    public void run() {
        System.out.println("i am a car, i can run.");
    }
}
复制代码

 

控制台输出：

i am a car, i can run.
after
authority aroundAdvice

（4）返回增强

注解类：

/**
 * Created by solverpeng on 2016/7/27.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AfterReturningAuthorityTag {}

切面增强：

@AfterReturning(value = "@annotation(com.nucsoft.spring.annotation.AfterReturningAuthorityTag)", returning = "result")
public void afterReturningAdvice(JoinPoint point, Object result) {
　　System.out.println("authority afterReturning");
}

目标类：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-27-9:59
 */
@Component
public class Car implements Wheel{
    @AfterReturningAuthorityTag
    @Override
    public void run() {
        System.out.println("i am a car, i can run.");
    }
}
复制代码

控制台输出：

i am a car, i can run.
authority afterReturning

（5）抛出增强

注解类：

/**
 * Created by solverpeng on 2016/7/27.
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface AfterThrowingAuthorityTag {}

切面增强：

@AfterThrowing(value = "@annotation(com.nucsoft.spring.annotation.AfterThrowingAuthorityTag)", throwing = "e")
public void afterThrowAdvice(JoinPoint point, Exception e) {
　　System.out.println(e.getMessage());
　　System.out.println("authority afterThrowing");
}

目标类：

复制代码 
@Component
public class Car implements Wheel{
    @AfterThrowingAuthorityTag
    @Override
    public void run() {
        System.out.println("i am a car, i can run.");
        throw new RuntimeException("throw a new runtimeException");
    }
}
复制代码

控制台输出：

i am a car, i can run.
throw a new runtimeException
authority afterThrowing

java.lang.RuntimeException: throw a new runtimeException

（6）引入增强：关键字：@DeclareParents

将要引入的接口：

/**
 * Created by solverpeng on 2016/7/26.
 */
public interface Fly {
    void fly();
}

将要引入的接口的实现：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-20:55
 */
public class SuperMan implements Fly{
    @Override
    public void fly() {
        System.out.println("i am super man, i can fly.");
    }
}
复制代码

切面类：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-17:42
 */
@Aspect
@Component
public class LoggingAspect {　　
    @DeclareParents(value = "com.nucsoft.spring.target.impl.Student", defaultImpl = SuperMan.class)
    private Fly fly;
}
复制代码

测试类：

复制代码 
/**
 * @author solverpeng
 * @create 2016-07-26-18:15
 */
public class SpringTest {
    @Test
    public void test01() {
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        Person student = context.getBean(Student.class);
        String james = student.say("james");
        System.out.println(james);
        Fly fly = (Fly) student; fly.fly(); } }
复制代码

控制台输出：

hello,james
i am super man, i can fly.

说明：

<1>.在 Aspect 类中定义一个需要引入增强的接口，它也就是运行时需要动态实现的接口。

<2>.@DeclareParents  注解：

value 属性：目标类，可以是一个 AspectJ 类型的表达式，可以引入到多个类中。

defaultImpl 属性：引入接口的默认实现类。

<3>.虽然切面类中标注有@DeclareParents  注解 的属性可以是任意的，但是一般还是将其设置为 引入增强类型。

<4>.从 ApplicationContext 中获取到的 student 对象其实是一个代理对象，可以转型为自己静态实现的接口 Person，也可以转型为动态实现的接口 Fly，切换起来非常方便。

3.3 对比基于注解的切点表达式和注解表达式

注解表达式：更加灵活，但是相应的在开发的过程中，需要程序员手动的去为每个需要添加增强的方法添加对应注解。更加容易扩展。

切点表达式：可以写出通用的增强，也不需要程序员手动的去为每个方法添加增强，但是需要切点表达式适配。

 

七、小的知识点

1.利用方法签名编写 AspectJ 切点表达式

execution * com.nucsoft.spring.Calculator.*(..): 匹配 Calculator 中声明的所有方法,

第一个 * 代表任意修饰符及任意返回值. 第二个 * 代表任意方法. .. 匹配任意数量的参数. 若目标类与接口与该切面在同一个包中, 可以省略包名.

execution public * Calculator.*(..): 匹配 ArithmeticCalculator 接口的所有公有方法.

execution public double Calculator.*(..): 匹配 Calculator 中返回 double 类型数值的方法

execution public double Calculator.*(double, ..): 匹配第一个参数为 double 类型的方法, .. 匹配任意数量任意类型的参数

execution public double Calculator.*(double, double): 匹配参数类型为 double, double 类型的方法.

2.可以合并切点表达式 使用 &&, ||, !  来合并。如：

execution(void run()) || execution(void say())

3.切面优先级：

可以通过实现 Ordered 接口或利用 @Order 注解指定。

（1）实现 Ordered 接口，getOrder() 方法返回的值越小，优先级越高。

（2）使用 @Order 注解，需要出现在注解中，同样是值越小优先级越高。

4.重用切点定义

在 AspectJ 切面中, 可以通过 @Pointcut 注解将一个切入点声明成简单的方法. 切入点的方法体通常是空的, 因为将切入点定义与应用程序逻辑混在一起是不合理的。

切入点方法的访问控制符同时也控制着这个切入点的可见性。如果切入点要在多个切面中共用, 最好将它们集中在一个公共的类中。

在这种情况下, 它们必须被声明为 public。在引入这个切入点时, 必须将类名也包括在内。如果类没有与这个切面放在同一个包中, 还必须包含包名。

其他通知可以通过方法名称引入该切入点。

如：

复制代码 
@Pointcut("execution(void run())")
public void LoggingPointcut(){};

@Before("LoggingPointcut()")
public void before() {
　　System.out.println("before");
}
复制代码

八、总结

1.在学习 Spring AOP 之前，最好先理解了 静态代理，JDK动态代理，CGLIB动态代理。

2.明白切面和增强以及切点之间的关系

3.几个增强之间的区别

除环绕增强外，所有的连接点使用的都是 JoinPoint 类型的入参，而环绕增强使用的是 ProceedingJoinPoint。

返回增强能接受到返回值

抛出增强能接收到抛出的异常

环绕增强的返回值类型为目标方法返回值类型

4.Spring AOP 支持声明式和基于注解的方式，注解优先。

5.步骤：

1.定义切面，以及增强，编写切点表达式

2.如果切点表达式是基于注解的，还需要对目标方法添加对应的注解。

乔志勇笔记
关注
专栏目录
【Spring】（5）AOP面向切面编程：谈谈AOP的概念和必要性
aaa_hao的博客
10-14 1313
两个月前跟着b站动力节点王鹤老师的Spring框架教程视频学习完了Spring框架，在学习过程中我将视频中涉及的代码都一行一行手敲了一遍，并且把Spring入门相关的资料整理了一下，在这里记录一下我在Spring框架学习过程中的笔记和一些心得，希望能帮助到想要通过文字教程入门Spring这一框架的小伙伴哦！ 视频地址：2020最新Spring框架教程【IDEA版】-Spring框架从入门到精通 文章目录AOP 面向切面编程1. 不使用 AOP 的开发方式2. 回顾动态代理3. AOP 简介4. AOP .
AOP重要吗
zmelody的专栏
08-24 1076
AOP（Aspect-Oriented Programming）这个领域还很新，不过我乐观地预计，将来很多大项目会采纳AOP方法。在我看来，AOP是非常重要的方向，可能会是软件开发方法发展道路上的“下一个大家伙”。当然，AOP并不是一种取代性的技术，就像现在电视没有取代收音机，电脑也没有取代电视。不过采用AOP方法后，现在许多模式就不再需要了（当然也会出现一批新的模式），软件开发过程也将会改观。
利用切面（Aspect）实现出入参加解密及数据脱敏
最新发布
xiaoxiaoxiao_Ming的博客
08-21 877
创建一个注解，用于标记需要进行加解密处理的方法。在你的Controller中应用这个注解。@Secure// 这里接收到的数据已经被解密// 返回的数据会被加密通过以上步骤，我们使用Spring Boot中的AOP功能和自定义注解，实现了对请求参数的解密和对响应结果的加密，这些功能都由一个注解来完成。这种方法具有良好的扩展性和可维护性，适用于需要保护数据传输安全的场景。：指定该注解可以应用于字段。：指定该注解在运行时可用，通过反射可以获取到。
Spring AOP 关键词的理解
weixin_30852367的博客
05-26 285
1.如下图所示： 　　 　　AOP的执行就是在什么时候，什么地方，做什么。 2.关键词理解： 　　连接点(JoinPoint)： 就是能够作为切点的一个个动作（方法），当然实际上不是所有连接点都当做切点的。 　　切点(Poincut)：链接点中的一个或多个，切面会在这些点上来做文章（切点就是什么地方）。 　　通知(Advice)：通知是在切点上什么时候，做什么。 　　　　　　通知有下...
Spring 之Aop增强
m0_73889578的博客
02-22 212
遍历后置处理器，并应用postProcessBeforeInstantiation()，其中与Aop相关的核心处理器是AnnotationAwareAspectJAutoProxyCreator 这个类实现了SmartInstantiationAwareBeanPostProcessor，他会找到所有Bean中那些事切面类，原理就是判断Bean上面是否带有@Aspect注解，而Aspect本身并不能由Spring容器管理，所以还需要给切面类接上@Component注解。2.创建Aop增强类。
Spring AOP--引入增强
布袋
05-30 2767
上篇博客写到了Spring AOP，不管是前置增强，后置增强，引入增强都是对方法的增强，但是是否考虑过对类进行增强呢？！伟大的spring做到了，只是换了一种说法：Introduction（引入）        首先我们来说一下引入增强的目的：动态的让被增强的类实现一个接口；下面就写一下代码吧： 定义了一个新接口 Apology： /** * 道歉接口 * @author 陈丽娜 *
Spring AOP——Spring 中面向切面编程
slw213106的博客
12-12 308
一、AOP——另一种编程思想 1.1 什么是 AOP AOP （Aspect Orient Programming）,直译过来就是 面向切面编程。AOP 是一种编程思想，是面向对象编程（OOP）的一种补充。面向对象编程将程序抽象成各个层次的对象，而面向切面编程是将程序抽象成各个切面。 从《Spring实战（第4版）》图书中扒了一张图： 从该图可以很形象地看出，所谓切面，相当于应用对象间的横切点，我们可以将其单独抽象为单独的模块。 1.2 为什么需要 AOP 想象下面的场景，开发中在多个模块间有
征服Spring AOP—— Schema
04-04
本文将深入探讨“Spring AOP——Schema”，这是Spring AOP的一种配置方式，通过XML schema定义切面和通知。 首先，我们需要理解AOP的基本概念。面向切面编程是一种编程范式，旨在提高软件的模块化程度，将关注点...
Spring AOP——基于注解的AOP实现
05-18
Spring AOP是Spring框架中的一个重要模块，它提供了面向切面编程（AOP）的支持。AOP是一种编程思想，它可以在不改变原有代码的情况下，通过在程序运行时动态地将代码“织入”到现有代码中，从而实现对原有代码的增强...
详细总结什么是SpringAOP——面试一点通
P_FastrackJava的博客
03-06 408
愿大家前程似锦~
Spring源码——AOP
等一杯咖啡的博客
10-21 2282
前言 内容主要参考自《Spring源码深度解析》一书，算是读书笔记或是原书的补充。进入正文后可能会引来各种不适，毕竟阅读源码是件极其痛苦的事情。 本文主要涉及书中第七章的部分，依照书中内容以及个人理解对Spring源码进行了注释，详见Github仓库：https://github.com/MrSorrow/spring-framework 正式进入正文前，强烈推荐先阅读文末参考阅读第一篇：关于 S...
Spring AOP之5种增强方法应用范例
05-19
Spring AOP之5种增强方法应用范例 ，具体效果和过程看博文 http://blog.csdn.net/evankaka/article/details/45241863
spring中的增强类型
weixin_30485799的博客
10-12 76
　　在spring中有两种增强方式：XML配置文件和注解配置。下面一次为大家讲解。 　　使用的是Aspectj第三方框架纯POJO （在XML中配置节点） 　　　 　　使用@AspectJ，首先要保证所用的JDK是5.0或以上版本 　　1）首先，创建一个切入点MyAspect，代码如下： 1 public class MyAspect { 2 // ...
spring---aop（9）---Spring AOP中引入增强
weixin_30685047的博客
08-15 139
写在前面 　　Spring将introduction通知看作一种特殊类型的拦截通知。用Spring的行话来讲，对方法的增强叫做Wearing（织入），而对类的增强叫introduction（引入）。Introduction Advice（引入增强）就是对类的功能增强，它也是Spring AOP 提供的一种特殊增强。 一个简单的例子（以CGLIB的代理实现） 　　定义一个接口（这个例子演...
Spring-AOP 代理，增强
weixin_68107783的博客
12-04 269
Spring-AOP 代理，增强
Spring AOP的五种增强方式
m0_73889578的博客
02-20 166
增强方法也称为通知方法，指标注有@Before、@AfterRunning、@AfterThrowing、@After或@Around注解的Java方法。其中，有前置增强、后置增强、返回增强、异常增强和环绕增强五种增强方式。前置增强（@Before，又称前置通知）：在目标方法执行之前执行。于 2020-02-06 15:07:08 发布。Spring AOP的五种增强方式。
Spring学习日记：Aop五种增强+注解开发Ioc/Aop
m0_74777020的博客
08-22 2815
自述：此篇文章主要记录了本人学习Spring的日常，在CSDN上发表，一是为了方便今后回顾，二也是想分享给有需要的人。
Spring-aop的四种增强方式
weixin_66187554的博客
02-22 194
java
Spring Aop中五种增强方法
S_Tian的博客
02-04 849
@Aspect @Component public class CalculatorAspect { @Pointcut("execution(public int live.sunhao.calculator.service.CalculatorService.*(..))") public void pointcut() { } //前置增强（又称前置通知）：在目标方法执...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值