【Spring入门学习04】代理和AOP、AOP XML开发、AOP注解开发

最新推荐文章于 2024-05-03 11:47:20 发布

Mcq.

最新推荐文章于 2024-05-03 11:47:20 发布

阅读量151

点赞数

文章标签： spring java

本文链接：https://blog.csdn.net/weixin_43202895/article/details/108261495

版权

1 AOP和代理

1.1 什么是代理

代理（Proxy）是一种设计模式，提供了间接对目标对象（被代理对象）进行访问的方式，即通过代理对象访问目标对象。这样做的好处是可以在实现目标对象功能的基础上，增加额外的功能，即扩展目标对象的功能。
例如，明星与经纪人之间就是代理和被代理的关系，明星出演活动的时候，明星就是目标对象，他只要负责活动中的节目，而其它琐碎的事情（额外的功能）就交给他的经纪人（代理对象）处理。

1.2 什么是 AOP

AOP （Aspect Oriented Programming ，面向切面编程）是一种编程思想，通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能，是面向对象编程（OOP）的一种补充。

AOP 采取横向抽取的方式，将那些与业务无关，但却对多个类产生影响的公共行为和逻辑（如日志记录），抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect）。然后在程序编译或运行时，通过代理，在不修改源码的基础上，将“切面”模块的代码织入到现有方法的前后，以增强现有方法。

在这里插入图片描述

AOP通过代理技术，可以在程序运行期间，在不修改源码的情况下对方法进行功能增强，拥有以下优势：

减少系统的重复代码
降低模块间的耦合度
有利于未来的可操作性和可维护性

1.3 AOP相关术语

在在这里插入图片描述这里插入图片描述

Target（目标对象）：代理的目标对象，指所有被通知的对象，也称为被增强对象。如果 AOP 框架采用的是动态的 AOP 实现，那么该对象就是一个被代理对象。
Proxy （代理）：将通知应用到目标对象之后，动态创建的对象。
Joinpoint（连接点）：连接点是程序执行的某个特定位置，如类开始初始化前、类初始化后、类某个方法调用前、调用后、方法抛出异常后。一个类或一段程序代码拥有一些具有边界性质的特定点，这些点中的特定点就称为“连接点”。
Spring 仅支持方法的连接点，即仅能在方法调用前、方法调用后、方法抛出异常时以及方法调用前后这些程序执行点织入通知。
连接点由两个信息确定：第一是用方法表示的程序执行点；第二是用相对位置表示的方位。如在Test.foo()方法执行前的连接点，执行点位Test.foo()，方位为该方法执行前的位置。Spring 使用切点对执行点进行定位，而方位在通知中定义。
Pointcut（切入点）：所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义，即真正被增强的方法
Advice（通知/ 增强）：通知是织入目标类连接点上的一段代码，描述了拦截到 Joinpoint 之后所要做的事情。
Aspect（切面）：是切入点和通知的结合，即【目标方法+增强】。在实际应用中，切面通常是指封装的用于横向插入系统功能（如事务、曰志等）的类。
Weaving（织入）：是指把通知应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入（下文介绍）。

1.4 Spring AOP和AspectJ

AOP 的实现可分为两种：

动态代理(Spring AOP)：在代码执行阶段,在内存中截获对象，动态的插入 Pointcut 的内容。优点是不需要额外的编译，无需特定的编译器，但是性能比静态织入要低。
静态织入(Aspect)：在代码的编译阶段植入 Pointcut 的内容。优点是性能好，但是需要特定的编译器。

Spring 2.0以后引入了对 AspectJ 语法的支持，但是它本质上还是使用动态代理。原因在于，Spring 并没有真正引入 AspectJ 框架，只是借鉴了 AspectJ 的语法风格，本质上还是 Spring 的原生实现。因此，Spring 中的 AOP在运行时仍旧是纯的Spirng AOP，而不依赖 AspectJ 的编译器或者织入器。

1.5 常用的动态代理技术

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

Spring AOP的动态代理主要有两种方式，JDK 代理和 cglib 代理。在Spring 中，框架会根据被代理类是否实现了接口来决定采用哪种动态代理的方式。

1.5.1 基于JDK 的动态代理

是一种基于接口的动态代理。
通过java.lang.reflect.Proxy类实现，调用 Proxy 类的newProxylnstance()方法来创建代理代理对象，要求被代理类最少实现一个接口。具体使用如下：
①目标类接口

public interface TargetInterface {
    public void method();
}

②目标类

public class Target implements TargetInterface {
    @Override
    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() {
		//调用代理对象的任何方法，实质执行的都是invoke方法
    	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;
            }
        }
);

// 测试,使用代理对象
proxy.method();

1.5.2基于cglib的动态代理

是一种基于子类的动态代理，解决了JDK 动态代理必须实现接口的局限性。
原本是一个第三方工具，后期被集成到spring-core当中可以直接使用。该代理要求被代理类不能用 final 修饰。

①目标类

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

②动态代理代码

Target target = new Target(); //创建目标对象

//1.创建增强器
Enhancer enhancer = new Enhancer();   
//2.设置父类
enhancer.setSuperclass(Target.class); 
//3.设置回调
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;
    }
});

//4。创建代理对象
Target proxy = (Target) enhancer.create(); 


//测试,使用代理对象
proxy.method();

2 AOP 开发明确的事项

Spring 2.0以后，Spring AOP引入了对 AspectJ 语法的支持，并允许直接使用 AspectJ 语法进行编程，新版本的Spring 框架，也建议使用 AspectJ 语法来开发 AOP。

2.1 需要编写的内容

编写核心业务代码（目标类的目标方法）
编写切面类，切面类中有通知(增强功能方法)
在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

2.2 AOP 技术实现的内容（执行过程）

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

2.3 AOP 底层使用哪种代理方式

在 spring 中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

3 基于 XML 的 AspectJ 开发

3.1 开发步骤

①导入相关依赖

<!--导入spring的context坐标，context依赖aop-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>
<!-- aspectj 是一个轻量级的
     spring主张使用aspectj完成织入配置
-->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

②创建目标接口和目标类（内部有切点）

public interface TargetInterface {
    public void method();
}

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

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

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

④将目标类和切面类的对象创建权交给 spring

<!--配置目标类-->
<bean id="target" class="com.itheima.aop.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="com.itheima.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">

配置切点表达式和前置增强的织入关系

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
        <aop:before method="before" pointcut="execution(public void com.itheima.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();
    }
}

3.2 标签配置详解

aop织入的基本配置

<!--配置织入关系：哪些方法需要哪些增强-->
<aop:config>
    <!--声明切面-->
    <aop:aspect ref="切面类">
        <!--抽取切点表达式-->
        <aop:pointcut id="myPointcut" expression="execution(* aop.*.*(..))" />
        <!--切面：切点+通知-->
        <aop:before method="通知方法名称" pointcut="切点表达式" />
        <aop:通知类型 method="通知方法名称" pointcut-ref="抽取的切点id"/>
    </aop:aspect>
</aop:config>

3.2.1 通知的类型

在这里插入图片描述
通知的配置语法：

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

3.2.2 切点表达式的写法

execution([修饰符] 返回值类型 包名.类名.方法名(参数))

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用星号* 代表任意
包名与类名之间一个点 . 代表当前包下的类，两个点 … 表示当前包及其子包下的类
参数列表可以使用两个点 … 表示任意个数，任意类型的参数列表

例如：

execution(public void com.itheima.aop.Target.method())	指定特定方法
execution(void com.itheima.aop.Target.*(..))  指定特定包下特定类的void方法
execution(* com.itheima.aop.*.*(..))  指定特定包下的任意类的任意方法（最常用）
execution(* com.itheima.aop..*.*(..)) 指定特定包及其子包下的任意类的任意方法
execution(* *..*.*(..))

3.2.3 抽取切点表达式

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

<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"/>
        <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
    </aop:aspect>
</aop:config>

4 基于注解的 AspectJ 开发

4.1 开发步骤

①创建目标接口和目标类（内部有切点）

public interface TargetInterface {
    public void method();
}

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

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

public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

③标识@Component，将目标类和切面类的对象创建权交给 spring

@Component("target")
public class Target implements TargetInterface {
    public void method() {
        System.out.println("Target running....");
    }
}
@Component("myAspect")
public class MyAspect {
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

④
@Aspect，标注当前类是一个切面类
@通知类型，标注通知方法

@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* com.itheima.aop.*.*(..))")
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

⑤在配置文件中开启组件扫描和 AOP 的自动代理

<!--组件扫描-->
<context:component-scan base-package="com.itheima.aop"/>

<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

⑥测试代码

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

4.2 注解配置 AOP 详解

@Component，标注spring配置
@Aspect，标注当前类是一个切面类
@通知，标注通知方法
配置组件扫描，配置aop自动代理<aop:aspectj-autoproxy/>

4.2.1 注解通知的类

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

在这里插入图片描述

4.2.2 抽取切点表达式

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

@@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("MyAspect.myPoint()")
    public void before(){
        System.out.println("前置代码增强.....");
    }
    @Pointcut("execution(* com.itheima.aop.*.*(..))")
    public void myPoint(){}
}

Mcq.

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Spring入门学习04】代理和AOP、AOP XML开发、AOP注解开发

1 AOP和代理1.1 什么是代理代理（Proxy）是一种设计模式，提供了间接对目标对象（被代理对象）进行访问的方式，即通过代理对象访问目标对象。这样做的好处是可以在实现目标对象功能的基础上，增加额外的功能，即扩展目标对象的功能。例如，明星与经纪人之间就是代理和被代理的关系，明星出演活动的时候，明星就是目标对象，他只要负责活动中的节目，而其它琐碎的事情（额外的功能）就交给他的经纪人（代理对象）处理。1.2 什么是 AOPAOP （Aspect Oriented Programming ，面向切面编
复制链接

扫一扫