zoukankan html css js c++ java

Spring-AOP小记

1.Spring 的 AOP 简介

1.1 什么是 AOP

AOP 为 Aspect Oriented Programming 的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP 是 OOP 的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

1.2 AOP 的作用及其优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强

优势：减少重复代码，提高开发效率，并且便于维护

1.3 AOP 的底层实现

实际上，AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

Spring 框架会监控切入点方法（被增强方法）的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

1.4 AOP 的动态代理技术

常用的动态代理技术

JDK 代理 : 基于接口的动态代理技术

cglib 代理：基于父类的动态代理技术

.png)

1.5 JDK 的动态代理

首先jdk代理是基于接口的动态代理，那么肯定要有个接口啊
1
2
3
4
public interface {

public void method();
}

动态代理代理的是啥？代理的是目标类的对象，那么首先就要有个目标类呀

public class Target implements  {
    
    
    public void method() {
        System.out.println("Target running....");
    }
}

动态代理代码

Target target = new Target(); //创建目标对象
//创建代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass()
.getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {
            
            public Object invoke(Object proxy, Method method, Object[] args) 
            throws Throwable {
                System.out.println("前置增强代码...");
                Object invoke = method.invoke(target, args);
                System.out.println("后置增强代码...");
                return invoke;
            }
        }
);

调用代理对象的方法测试
1
System.out.println(proxy.method());

.png)

==注意：==

如果目标类有返回值的话，return invoke就会返回响应的返回值，否则返回null；
代理对象调用任何目标方法都会触发执行public Object invoke(Object proxy, Method method, Object[] args) ，这个方法的invoke里面的invoke函数不一样，里面的invoke是Method所对应的方法，这个method封装的就是目标方法，args是目标方法的参数，target是目标对象（注意不是代理对象）

1.6 cglib 的动态代理

同样要有个目标类

public class Target {
    public void method() {
        System.out.println("Target running....");
    }
}

动态代理代码

Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer();   //创建增强器
enhancer.setSuperclass(Target.class); //设置父类，这一步也就是说要为谁增强
enhancer.setCallback(new MethodInterceptor() { //设置回调
    
    public Object intercept(Object o, Method method, Object[] objects, 
    MethodProxy methodProxy) throws Throwable {
        System.out.println("前置代码增强....");
        Object invoke = method.invoke(target, objects);
        System.out.println("后置代码增强....");
        return invoke;
    }
});
Target proxy = (Target) enhancer.create(); //创建代理对象

测试

1 2	//测试,当调用接口的任何方法时，代理对象的代码都无序修改 proxy.method();

1.7 AOP 相关概念

Spring 的 AOP 实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

AOP相关术语：

Target（目标对象）：代理的目标对象
Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点。就是类里面的方法
Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义。就是类里面要被增强的方法。一个类里面有很多方法，这些方法都可以叫Joinpoint，但是只有需要被增强的方法才被叫做Pointcut
Advice（通知/ 增强）：所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知。就是用来增强的方法
Aspect（切面）：是切入点（被增强的方法）和通知（用来增强的方法）的结合，在访问目标方法的时候Spring框架会自动去执行增强。一般是一个切面类，里面有Advice(增强方法)
Weaving（织入）：是指把增强方法应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。其实目的就是告诉Spring框架哪些方法需要进行哪些增强
1
2
3


<aop:before method="method2" pointcut="execution(public void xqp.proxy.aop.Target.save())"/>

2 XML 配置 AOP 详解

2.1 实例

导入 AOP 相关坐标

<!--导入spring的context坐标，context依赖aop-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

创建目标接口和目标类（内部有切点，即要被增强的方法）

public interface  {
    public void method();
}

public class Target implements  {
    
    public void method() {
        System.out.println("Target running....");
    }
}

创建切面类（内部有增强方法）

public class MyAspect {
    //前置增强方法
    public vo 大专栏  Spring-AOP小记id before(){
        System.out.println("前置代码增强.....");
    }
}

将目标类和切面类的对象创建权交给 spring（这个时候，无论是目标类还是切面类对于Spring容器来说都只是普通的bean）
1
2
3
4

<bean id="target" class="xqp.aop.Target"></bean>

<bean id="myAspect" class="xqp.aop.MyAspect"></bean>

在 applicationContext.xml 中配置织入关系—导入aop命名空间

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

在 applicationContext.xml 中配置织入关系—配置切点表达式和前置增强的织入关系(告诉Spring谁是切面类（里面含有增强方法），哪些是目标方法，也即被增强方法（切点）)

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
        <aop:before method="before" pointcut="execution(public void 			xqp.aop.Target.method())"></aop:before>
    </aop:aspect>
</aop:config>

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test1(){
        target.method();
    }
}

2.2 切点表达式的写法

表达式语法：

execution([修饰符] 返回值类型包名.类名.方法名(参数))
- 访问修饰符可以省略
- 返回值类型、包名、类名、方法名可以使用星号* 代表任意
- 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
- 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表
  - 1
    2
    3
    4
    5
    execution(public void xqp.aop.Target.method())
    execution(void xqp.aop.Target.*(..))
    execution(* xqp.aop.*.*(..))
    execution(* xqp.aop..*.*(..))
    execution(* *..*.*(..))
通知的类型：

<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式”><</aop:通知类型>>

2.3 切点表达式的抽取

当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
    	<!--抽取切点表达式-->
        <aop:pointcut id="myPointcut" expression="execution(* 		  xqp.aop.*.*(..))"/>
        <!--引用抽取的切点表达式-->
        <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
    </aop:aspect>
</aop:config>

3 注解配置 AOP详解

首先要创建目标接口和目标类，同时将目标类交给Spring容器（@Component(“target”)）

public interface  {
    public void method();
}

@Component("target")//将目标类对象创建权交给Spring容器
public class Target implements TargetInterface {
    
    public void method() {
        System.out.println("Target running....");
    }
}

创建切面类（内部有增强方法)，将切面类交给Spring容器（@Component(“myAspect”)）并且配置织入关系（@Aspect 和 @Before(“execution( com.itheima.aop..*(..))”)）

@Component("myAspect")//将切面类对象创建权交给Spring容器
@Aspect//声明这个类是切面类
public class MyAspect {
    //配置织入关系（告诉Spring容器被增强的方法是谁，以及增强方法是谁）
    @Before("execution(* xqp.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

在配置文件中开启组件扫描和 AOP 的自动代理
1
2
3
4
5

<context:component-scan base-package="xqp.aop"/>


<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
==注意：自动代理必须配置，要不Spring容器无法识别通知类型和声明切面类的注解==

3.1 注解通知的类型

通知的配置语法：@通知注解(“切点表达式”)

3.2 切点表达式的抽取

同 xml配置，aop 一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut注解定义切点表达式，然后在在增强注解中进行引用。具体如下：

@@Component("myAspect")
@Aspect
public class MyAspect {
    //定义方法进行切点表达式的抽取
    @Pointcut("execution(* xqp.proxy.anno.*.*(..))")
    public void pointcut(){}
    
    //@Around("pointcut()")
    @Around("MyAspect.pointcut()")
    public Object method4(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前");
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("环绕后");
        return proceed;
    }
}=

查看全文

相关阅读:
hashCode()相同，equals()也一定为true吗？
什么是装箱？什么是拆箱？装箱和拆箱的执行过程？常见问题？
LOJ114_k 大异或和_线性基
 BZOJ_4459_[Jsoi2013]丢番图_数学+分解质因数
 BZOJ_4184_shallot_线段树按时间分治维护线性基
 BZOJ_2844_albus就是要第一个出场_线性基
 BZOJ_3105_[cqoi2013]新Nim游戏_线性基+博弈论
 BZOJ_1195_[HNOI2006]最短母串_AC自动机+BFS+分层图
 BZOJ_3881_[Coci2015]Divljak_AC自动机+dfs序+树状数组
 BZOJ_1532_[POI2005]Kos-Dicing_二分+网络流

原文地址：https://www.cnblogs.com/lijianming180/p/12409855.html