回顾---AOP

最新推荐文章于 2023-06-06 12:24:48 发布

z咖啡不苦

最新推荐文章于 2023-06-06 12:24:48 发布

阅读量149

点赞数

本文链接：https://blog.csdn.net/www_ly/article/details/109306823

版权

学习aop之前 , 我们要先了解一下代理模式！

在这里插入图片描述

为什么要学习代理模式
因为AOP的底层机制就是动态代理

代理模式：

静态代理
动态代理

静态代理

代理的三要素:

有共同的⾏为（比如结婚） - 接⼝
⽬标⻆⾊（新⼈） - 实现⾏为
代理⻆⾊（婚庆公司） - 实现⾏为增强⽬标对象⾏为

静态代理的特点：

⽬标⻆⾊固定
在应⽤程序执⾏前就得到⽬标⻆⾊
代理对象会增强⽬标对象的⾏为
有可能存在多个代理引起"类爆炸"（缺点）

静态代理的实现：

定义⾏为（共同）定义接⼝

/**
* 定义⾏为
*/
public interface Marry {
 public void toMarry();
}

⽬标对象（实现⾏为）

/**
* 静态代理 ——> ⽬标对象
*/
public class You implements Marry {
 // 实现⾏为
 @Override
 public void toMarry() {
 System.out.println("我要结婚了..."); 
 }
}

代理对象（实现⾏为、增强⽬标对象的⾏为）

/**
* 静态代理 ——> 代理对象
*/
public class MarryCompanyProxy implements Marry {
 // ⽬标对象
 private Marry marry;
 // 通过构造器将⽬标对象传⼊
 public MarryCompanyProxy(Marry marry) {
 this.marry = marry;
 }
 // 实现⾏为
 @Override
 public void toMarry() {
 // 增强⾏为
 before();
 
 // 执⾏⽬标对象中的⽅法
 marry.toMarry();
 // 增强⾏为
 after();
 }
 /**
 * 增强⾏为
 */
 private void after() {
 System.out.println("新婚快乐，早⽣贵⼦！");
 }
 /**
 * 增强⾏为
 */
 private void before() {
 System.out.println("场地正在布置中...");
 }
}

通过代理对象实现⽬标对象的功能

// ⽬标对象
You you = new You();
// 构造代理⻆⾊同时传⼊真实⻆⾊
MarryCompanyProxy marryCompanyProxy = new MarryCompanyProxy(you);
// 通过代理对象调⽤⽬标对象中的⽅法
marryCompanyProxy.toMarry();

静态代理的好处：
可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
公共的业务由代理来完成 . 实现了业务的分工 ,
公共业务发生扩展时变得更加集中和方便 .

缺点：
类多了 , 多了代理类 , 工作量变大了 . 开发效率降低
静态代理对于代理的⻆⾊是固定的，如dao层有20个dao类，如果要对⽅法的访问权限进⾏代理，此时需要创建20个静态代理⻆⾊，引起类爆炸，⽆法满⾜⽣产上的需要，于是就催⽣了动态代理的思想。

动态代理
动态代理的两种实现⽅式：

jdk动态代理----------------------基于接口的动态代理
CGLIB动态代理-----------------基于类的动态代理

动态代理的特点：

⽬标对象不固定
在应⽤程序执⾏时动态创建⽬标对象
代理对象会增强⽬标对象的⾏为

1、JDK动态代理（注：JDK动态代理的⽬标对象必须有接⼝实现）
JDK的动态代理需要了解两个类：
核心 : InvocationHandler 和 Proxy ，可以查看JDK帮助文档

InvocationHandler ：调用处理程序
Proxy ：代理

Proxy类
Proxy类是专⻔完成代理的操作类，可以通过此类为⼀个或多个接⼝动态地⽣成实现类。
我们来看看newProxyInstance方法

/*
返回⼀个指定接⼝的代理类的实例⽅法调⽤分派到指定的调⽤处理程序。 (返回代理对象)
loader：⼀个ClassLoader对象，定义了由哪个ClassLoader对象来对⽣成的代理对象进⾏加载
interfaces：⼀个Interface对象的数组，表示的是我将要给我需要代理的对象提供⼀组什么接⼝，如果 我提供了⼀组接⼝给它，那么这个代理对象就宣称实现了该接⼝(多态)，这样我就能调⽤这组接⼝中的⽅法了
h：⼀个InvocationHandler接⼝，表示代理实例的调⽤处理程序实现的接⼝。每个代理实例都具有⼀个关联的调⽤处理程序。对代理实例调⽤⽅法时，将对⽅法调⽤进⾏编码并将其指派到它的调⽤处理程序的 invoke ⽅法（传⼊InvocationHandler接⼝的⼦类）
*/
public static Object newProxyInstance(ClassLoader loader,
 Class<?>[] interfaces,InvocationHandler h)

jdk动态代理实现：
Marry.java 就是抽象角色

/**
* 定义⾏为
*/
public interface Marry {
 public void toMarry();
}

You.java 就是真实角色，真正结婚的是你。

public class You implements Marry {

    @Override
    public void toMarry() {

        System.out.println("我要结婚了...");
    }

JdkProxy.java 就是代理角色

public class JdkProxy {


    private Object target;

    public JdkProxy(Object target) {
        this.target = target;
    }


    public Object getProxy(){

        //得到类加载器
         ClassLoader loader = this.getClass().getClassLoader();
        //得到目标对象实现的接口数组
         Class[] interfaces =target.getClass().getInterfaces();
        //得到invocationHandler接口
        InvocationHandler invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                Object invoke = method.invoke(target, args);

                return invoke;
            }
        };
    //得到代理对象
    Object proxy = Proxy.newProxyInstance(loader,interfaces,invocationHandler);

    return proxy;
	}
}

这时你就可以是实现多种行为了
缺点：
JDK的动态代理机制只能代理实现了接⼝的类，⽽不能实现接⼝的类就不能使⽤JDK的动态代理

CGLIB 动态代理
在pom.xml⽂件中引⼊cglib的相关依赖

<!-- https://mvnrepository.com/artifact/cglib/cglib -->
<dependency>
 <groupId>cglib</groupId>
 <artifactId>cglib</artifactId>
 <version>2.2.2</version>
</dependency>

Person.java 是需要实现的行为

public class Person {

    public  void   eat(){
        System.out.println("吃");
    }
}

CglibProxy.java 通过代理去实现行为

public class CglibProxy   {
    private  Object tatget;
    public CglibProxy(Object tatget) {
        this.tatget = tatget;
    }

    public Object getProxy(){
        //通过Enhancer类中的create方法生成一个类，作为目标对象的代理类
        Enhancer enhancer = new Enhancer();
        //设置父类（将目标类作为代理类的父类）
        enhancer.setSuperclass(tatget.getClass());

        //代理过程
        MethodInterceptor methodInterceptor = new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

                Object result= method.invoke(tatget,objects);
                return result;
            }
        };
        //设置Callbacks
         enhancer.setCallback(methodInterceptor);

         //生成类
         return  enhancer.create();
    }
}

调⽤⽅法

public class Test2 {
    public static void main(String[] args) {

        //目标类
        Person  person = new Person();
        //得到cglib代理类
        CglibProxy cglibProxy = new CglibProxy(person);

        //得到代理类的对象
        Person proxy =(Person)cglibProxy.getProxy();
        proxy.eat();

    }
}

这样就可以是实现多种行为了
JDK代理与CGLIB代理的区别

JDK动态代理实现接⼝，Cglib动态代理继承思想
JDK动态代理（⽬标对象存在接⼝时）执⾏效率⾼于Ciglib
如果⽬标对象有接⼝实现，选择JDK代理，如果没有接⼝实现选择Cglib代理

动态代理的好处
静态代理有的它都有，静态代理没有的，它也有

可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情
公共的业务由代理来完成 . 实现了业务的分工
公共业务发生扩展时变得更加集中和方便
一个动态代理 , 一般代理某一类业务
一个动态代理可以代理多个类，代理的是接口

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

2、AOP能做什么？
AOP主要应⽤于⽇志记录，性能统计，安全控制，事务处理等⽅⾯，实现公共功能性的重复使⽤。

3、 AOP的特点

降低模块与模块之间的耦合度，提⾼业务代码的聚合度。（⾼内聚低耦合
）
提⾼了代码的复⽤性。
提⾼系统的扩展性。（⾼版本兼容低版本）
可以在不影响原有的功能基础上添加新的功能

4、AOP的底层实现
动态代理（JDK + CGLIB）

5、AOP基本概念

Joinpoint（连接点）

被拦截到的每个点，spring中指被拦截到的每⼀个⽅法，spring aop⼀个连接点即代表⼀个⽅法的执⾏。

Pointcut（切⼊点）

对连接点进⾏拦截的定义（匹配规则定义 规定拦截哪些⽅法，对哪些⽅法进⾏处理），spring 有专⻔的表达式语⾔定义。

Advice（通知）

拦截到每⼀个连接点即（每⼀个⽅法）后所要做的操作
1. 前置通知 （前置增强）— before() 执⾏⽅法前通知
2. 返回通知（返回增强）— afterReturn ⽅法正常结束返回后的通知
3. 异常抛出通知（异常抛出增强）— afetrThrow()
4. 最终通知 — after ⽆论⽅法是否发⽣异常，均会执⾏该通知。
5. 环绕通知 — around 包围⼀个连接点（join point）的通知，如⽅法调⽤。这是最强⼤的⼀种通知类型。 环绕通知可以在⽅法调⽤前后完成⾃定义的⾏为。它也会选择是否继续执⾏连接点或直接返回它们⾃⼰的返回值或抛出异常来结束执⾏。

Aspect（切⾯）

切⼊点与通知的结合，决定了切⾯的定义，切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么，切⾯则是横切关注点的抽象，与类相似，类是对物体特征的抽象，切⾯则是横切关注点抽象。

Target（⽬标对象）

被代理的⽬标对象

Weave（织⼊）

将切⾯应⽤到⽬标对象并⽣成代理对象的这个过程即为织⼊

Introduction（引⼊）

在不修改原有应⽤程序代码的情况下，在程序运⾏期为类动态添加⽅法或者字段的过程称为引⼊

6、Aop在Spring中的作用
提供声明式事务；允许用户自定义切面

Spring AOP的实现
两种实现方式：
注解和xml
前提是要有spring环境
1、坐标依赖引⼊

<!--Spring AOP-->
<dependency>
 <groupId>org.aspectj</groupId>
 <artifactId>aspectjweaver</artifactId>
 <version>1.8.9</version>
</dependency>

2、添加spring.xml的配置
添加命名空间

xmlns:aop="http://www.springframework.org/schema/aop"

http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd

第一种方式—注解实现
定义切⾯

/**
* 切⾯
* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）
* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
*/
@Component // 将对象交给IOC容器去实例化
@Aspect // 声明当前类是⼀个切⾯
public class LogCut {
 /**
 * 切⼊点：
 * 		匹配规则。规定什么⽅法被拦截、需要处理什么⽅法
 * 定义切⼊点
 * 		@Pointcut("匹配规则")
 *
 * Aop 切⼊点表达式简介
 * 1. 执⾏任意公共⽅法：
 * 		execution(public *(..))
 * 2. 执⾏任意的set⽅法
 * 		execution(* set*(..))
 * 3. 执⾏com.xxxx.service包下任意类的任意⽅法
 * 		execution(* com.xxxx.service.*.*(..))
 * 4. 执⾏com.xxxx.service 包 以及⼦包下任意类的任意⽅法
 * 		execution(* com.xxxx.service..*.*(..))
 *
 * 注：表达式中的第⼀个* 代表的是⽅法的修饰范围
 * 可选值：private、protected、public （* 表示所有范围） 
 */
 @Pointcut("execution (* com.xxxx.service..*.*(..) )")
 public void cut(){}
 /**
 * 声明前置通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法执⾏前 执⾏该通知
 *
 */
 @Before(value = "cut()")
 public void before() {
 System.out.println("前置通知.....");
 }
 /**
 * 声明返回通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法（⽆异常）执⾏后 执⾏该通知
 *
 */
 @AfterReturning(value = "cut()")
 public void afterReturn() {
 System.out.println("返回通知.....");
 }
 /**
 * 声明最终通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法（⽆异常或有异常）执⾏后 执⾏该通知
 *
 */
 @After(value = "cut()")
 public void after() {
 System.out.println("最终通知.....");
 }
 /**
 * 声明异常通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法出现异常时 执⾏该通知
 */
 @AfterThrowing(value="cut()",throwing = "e")
 public void afterThrow(Exception e) {
 System.out.println("异常通知....." + " 异常原因：" + e.getCause());
 }
 /**
 * 声明环绕通知 并将通知应⽤到切⼊点上
 * ⽅法执⾏前后 通过环绕通知定义相应处理
 * 需要通过显式调⽤对应的⽅法，否则⽆法访问指定⽅法 (pjp.proceed();)
 * * @param pjp
 * @return
 */
 @Around(value = "cut()")
 public Object around(ProceedingJoinPoint pjp) {
 System.out.println("前置通知...");
 Object object = null;
 try {
 object = pjp.proceed();
 System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
 // System.out.println("返回通知...");
 } catch (Throwable throwable) {
 throwable.printStackTrace();
 System.out.println("异常通知...");
 }
 System.out.println("最终通知...");
 return object;
 }
}

第二种方式—xml实现
首先在spring.xml 配置⽂件中配置AOP代理

<!--配置AOP代理-->
<aop:aspectj-autoproxy/>

然后再定义切⾯

**
* 切⾯
* 切⼊点和通知的抽象 （与⾯向对象中的 类 相似）
* 定义 切⼊点和通知 （切⼊点定义了要拦截哪些类的哪些⽅法，通知则定义了拦截过⽅法后要做什么）
*/
@Component // 将对象交给IOC容器去实例化
public class LogCut02 {
 public void cut(){}
 /**
 * 声明前置通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法执⾏前 执⾏该通知
 *
 */
 public void before() {
 System.out.println("前置通知.....");
 }
 /**
 * 声明返回通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法（⽆异常）执⾏后 执⾏该通知
 *
 */
 public void afterReturn() {
 System.out.println("返回通知.....");
 }
 /**
 * 声明最终通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法（⽆异常或有异常）执⾏后 执⾏该通知
 *
 */
 public void after() {
 System.out.println("最终通知.....");
 }
 /**
 * 声明异常通知 并将通知应⽤到定义的切⼊点上
 * ⽬标类⽅法出现异常时 执⾏该通知
 */
 public void afterThrow(Exception e) {
 System.out.println("异常通知....." + " 异常原因：" + e.getCause());
 }
 /**
 * 声明环绕通知 并将通知应⽤到切⼊点上
 * ⽅法执⾏前后 通过环绕通知定义相应处理
 * 需要通过显式调⽤对应的⽅法，否则⽆法访问指定⽅法 (pjp.proceed();)
 * @param pjp
 * @return
 */
 public Object around(ProceedingJoinPoint pjp) {
 System.out.println("前置通知...");
 Object object = null;
 try {
 object = pjp.proceed();
 System.out.println(pjp.getTarget() + "======" + pjp.getSignature());
 // System.out.println("返回通知...");
 } catch (Throwable throwable) {
  throwable.printStackTrace();
 System.out.println("异常通知...");
 }
 System.out.println("最终通知...");
 return object;
 }
}

配置⽂件相关配置（spring.xml）

<!--aop相关配置-->
<aop:config>
 <!--aop切⾯-->
 <aop:aspect ref="logCut02">
 <!-- 定义aop 切⼊点 -->
 <aop:pointcut id="cut" expression="execution(* com.xxxx.service..*.*(..))"/>
 <!-- 配置前置通知 指定前置通知⽅法名 并引⽤切⼊点定义 -->
 <aop:before method="before" pointcut-ref="cut"/>
 <!-- 配置返回通知 指定返回通知⽅法名 并引⽤切⼊点定义 -->
 <aop:after-returning method="afterReturn" pointcut-ref="cut"/>
 <!-- 配置异常通知 指定异常通知⽅法名 并引⽤切⼊点定义 -->
 <aop:after-throwing method="afterThrow" throwing="e" pointcut-ref="cut"/>
 <!-- 配置最终通知 指定最终通知⽅法名 并引⽤切⼊点定义 -->
 <aop:after method="after" pointcut-ref="cut"/>
 <!-- 配置环绕通知 指定环绕通知⽅法名 并引⽤切⼊点定义 -->
 <aop:around method="around" pointcut-ref="cut"/>
 </aop:aspect>
</aop:config>

=====================================================================================

Spring AOP总结
代理模式实现三要素：

接⼝定义
⽬标对象与代理对象必须实现统⼀接⼝
代理对象持有⽬标对象的引⽤增强⽬标对象⾏为

代理模式实现分类以及对应区别：

静态代理：⼿动为⽬标对象制作代理对象，即在程序编译阶段完成代理对象的创建
动态代理：在程序运⾏期动态创建⽬标对象对应代理对象。
jdk动态代理：被代理⽬标对象必须实现某⼀或某⼀组接⼝实现⽅式通过回调创建代理对象。
cglib 动态代理：被代理⽬标对象可以不必实现接⼝，继承的⽅式实现。

动态代理相⽐较静态代理，提⾼开发效率，可以批量化创建代理，提⾼代码复⽤率。

Aop 理解：

⾯向切⾯，相⽐oop 关注的是代码中的层或⾯
解耦，提⾼系统扩展性
提⾼代码复⽤

Aop 关键词：

连接点：每⼀个⽅法
切⼊点：匹配的⽅法集合
切⾯：连接点与切⼊点的集合决定了切⾯，横切关注点的抽象
通知：⼏种通知
⽬标对象：被代理对象
织⼊：程序运⾏期将切⾯应⽤到⽬标对象并⽣成代理对象的过程
引⼊：在不修改原始代码情况下，在程序运⾏期为程序动态引⼊⽅法或字段的过程

z咖啡不苦

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
回顾---AOP

学习aop之前 , 我们要先了解一下代理模式！为什么要学习代理模式因为AOP的底层机制就是动态代理代理模式：静态代理动态代理静态代理代理的三要素:有共同的⾏为（比如结婚） - 接⼝⽬标⻆⾊（新⼈） - 实现⾏为代理⻆⾊（婚庆公司） - 实现⾏为增强⽬标对象⾏为静态代理的特点：⽬标⻆⾊固定在应⽤程序执⾏前就得到⽬标⻆⾊代理对象会增强⽬标对象的⾏为有可能存在多个代理引起"类爆炸"（缺点）静态代理的实现：定义⾏为（共同）定义接⼝/*** 定义⾏为*/
复制链接

扫一扫