为什么使用 AOP 如下场景:

现在有一个情景:

我们要把大象放进冰箱,步骤为:打开冰箱->放入大象->关闭冰箱

如果再把大象拿出来,步骤为:打开冰箱->拿出大象->关闭冰箱

代码如下:

 public void put() {
System.out.println("打开冰箱...");
System.out.println("放入大象...");
System.out.println("关闭冰箱...");
} public void get() {
System.out.println("打开冰箱...");
System.out.println("拿出大象...");
System.out.println("关闭冰箱...");
}

我们需要在每一个拿进拿出操作前后都要进行打开冰箱和关闭冰箱的操作,造成了代码重复。

而如果要拿进拿出其他动物,那么每一个动物的操作都需要加入打开冰箱关闭冰箱的操作,十分繁琐混乱。

解决方法就是AOP,将这些打开冰箱和关闭冰箱的操作单独抽取出来,做成一个切面,之后调用任何方法,都插入到方法前后即可。

先来看一些基本概念再来解决这个问题。

基本概念:

AOP   即Aspect Oriented Program,面向切面编程

使用AOP技术,可以将一些系统性相关的编程工作,独立提取出来,独立实现,然后通过切面切入进系统。

从而避免了在业务逻辑的代码中混入很多的系统相关的逻辑——比如权限管理,事物管理,日志记录等等。

这些系统性的编程工作都可以独立编码实现,然后通过AOP技术切入进系统即可。从而达到了 将不同的关注点分离出来的效果。

切面(Aspect):其实就是共有功能的实现。

          如日志切面、权限切面、事务切面等。

           在实际应用中通常是一个存放共有功能实现的普通Java类,之所以能被AOP容器识别成切面,是在配置中指定的。

通知/增强(Advice):是切面的具体实现。以目标方法为参照点,根据放置的地方不同,可分为前置通知(Before)、后置通知(AfterReturning)、异常通知(AfterThrowing)、最终通知(After)与环绕通知(Around)5种。

            在实际应用中通常是切面类中的一个方法,具体属于哪类通知,同样是在配置中指定的。

连接点(Joinpoint):就是程序在运行过程中能够插入切面的地点。

            例如,方法调用、异常抛出或字段修改等,但Spring只支持方法级的连接点。

切入点(Pointcut):用于定义通知应该切入到哪些连接点上。

          不同的通知通常需要切入到不同的连接点上,这种精准的匹配是由切入点的正则表达式来定义的。

目标对象(Target):就是那些即将切入切面的对象,也就是那些被通知的对象。

                    这些对象中已经只剩下干干净净的核心业务逻辑代码了,所有的共有功能代码等待AOP容器的切入。

代理对象(Proxy):将通知应用到目标对象之后被动态创建的对象。

          可以简单地理解为,代理对象的功能等于目标对象的核心业务逻辑功能加上共有功能。

           代理对象对于使用者而言是透明的,是程序运行过程中的产物。

织入(Weaving):将切面应用到目标对象从而创建一个新的代理对象的过程。

         这个过程可以发生在编译期、类装载期及运行期,当然不同的发生点有着不同的前提条件。

         譬如发生在编译期的话,就要求有一个支持这种AOP实现的特殊编译器;发生在类装载期,就要求有一个支持AOP实现的特殊类装载器;只有发生在运行期,则可直接通过Java语言的反射机制与动态代理机制来动态实现。

AOP 原理:

AOP 代理可分为静态代理和动态代理两大类,

静态代理:使用 AOP 框架提供的命令进行编译,从而在编译阶段就可生成 AOP 代理类,因此也称为编译时增强;

动态代理:在运行时借助于 JDK 动态代理、CGLIB(code generate libary)字节码生成技术 等在内存中“临时”生成 AOP 动态代理类,因此也被称为运行时增强

Spring AOP采用的是动态代理,在运行期间对业务方法进行增强,所以不会生成新类。

对于动态代理技术,Spring AOP提供了对JDK动态代理的支持以及CGLib的支持。

前者是基于反射技术的实现,后者是基于继承的机制实现。

如果目标对象有实现接口,使用jdk代理。

如果目标对象没有实现接口,则使用Cglib代理。

JDK:动态代理:

JDK动态代理需要获得被目标类的接口信息(应用Java的反射),生成一个实现了代理接口的动态代理类(字节码),再通过反射机制获得动态代理类的构造函数,利用构造函数生成动态代理类的实例对象,在调用具体方法前调用

invokeHandler方法来处理。

主要使用到 InvocationHandler 接口和 Proxy.newProxyInstance() 方法。

JDK动态代理要求被代理的类实现一个接口,只有接口中的方法才能够被代理 。

其方法是将被代理对象注入到一个中间对象,而中间对象实现InvocationHandler接口,在实现该接口时,可以在被代理对象调用它的方法时,在调用的前后插入一些代码。

而 Proxy.newProxyInstance() 能够利用中间对象来生产代理对象。

插入的代码就是切面代码。所以使用JDK动态代理可以实现AOP。

现在演示一下如何使用JDK动态代理实现开头的情景

JDK动态代理需要被代理类实现一个接口,先写一个接口。

public interface AnimalOperation {
public void put();
public void get();
}

再写一个类(要被代理的类),实现这个接口

public class ElephantOperation implements AnimalOperation{

    public void put() {
System.out.println("放入大象...");
} public void get() {
System.out.println("拿出大象...");
}
}

然后写一个类来实现InvocationHandler接口,在该类中对被代理类的方法做增强,并编写生成代理对象的方法

public class FridgeJDKProxy implements InvocationHandler{
//被代理的对象,之后用反射调用被代理方法的时候需要被代理对象的引用
private Object target; //InvocationHandler接口的方法,
// proxy是代理对象,method是被代理的方法,args是被代理方法的参数,返回值是原方法的返回
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
openDoor();//调用被代理方法做一些操作
Object result = method.invoke(target, args);//执行被代理对象的方法,如果方法有返回值则赋值给result
closeDoor();//调用被代理方法后做一些操作
return result;
}
private void openDoor(){
System.out.println("打开冰箱...");
}
private void closeDoor(){
System.out.println("关闭冰箱...");
}
public Object getProxy(Object target){
this.target=target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),this);
}
}

其中Proxy.newProxyInstance()方法需要的参数分别为,类加载器ClassLoader loader,接口数组Class<?>[] interfaces,与 InvocationHandler

测试代码为:

  public static void main(String args[]) {
AnimalOperation elephantOperation =(AnimalOperation) new FridgeJDKProxy().getProxy(new ElephantOperation());
elephantOperation.put();
elephantOperation.get();
}

打印结果:

CGLIB 动态代理:

字节码生成技术实现AOP,其实就是继承被代理对象,然后Override需要被代理的方法,在覆盖该方法时,自然是可以插入我们自己的代码的。

CGLib动态代理需要依赖asm包,把被代理对象类的class文件加载进来,修改其字节码生成子类。

因为需要Override被代理对象的方法,所以自然CGLIB技术实现AOP时,就 必须要求需要被代理的方法不能是final方法,因为final方法不能被子类覆盖 。

现在演示一下如何使用CGLIB动态代理实现开头的情景

CGLIB动态代理不要求被代理类实现接口,先写一个被代理类。

public class MonkeyOperation {
public void put() {
System.out.println("放入猴子...");
} public void get() {
System.out.println("拿出猴子...");
}
}

在写一个类实现MethodInterceptor接口,并在接口方法intercept()里对被代理对象的方法做增强,并编写生成代理对象的方法

public class FridgeCGLibProxy implements MethodInterceptor {

    public String name="hahaha";
public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
openDoor();//调用被代理方法做一些操作
Object result = methodProxy.invokeSuper(proxy,args);//执行被代理对象的方法,如果方法有返回值则赋值给result
closeDoor();//调用被代理方法后做一些操作
return result;
}
private void openDoor(){
System.out.println("打开冰箱...");
}
private void closeDoor(){
System.out.println("关闭冰箱...");
}
public Object getProxy(Class cls){//参数为被代理的类对象
Enhancer enhancer = new Enhancer();//创建增强器,用来创建动态代理类
enhancer.setSuperclass(cls);//设置父类,即被代理的类对象
enhancer.setCallback(this);//设置回调,指定为当前对象
return enhancer.create();//返回生成的代理类
}
}

测试代码:

  public static void main(String args[]) {
MonkeyOperation monkeyOperation =(MonkeyOperation)new FridgeCGLibProxy().getProxy(MonkeyOperation.class);
monkeyOperation.put();
monkeyOperation.get();
}

打印结果:

spring实现AOP,如果被代理对象实现了接口,那么就使用JDK的动态代理技术,反之则使用CGLIB来实现AOP,所以 Spring默认是使用JDK的动态代理技术实现AOP的 。

coding++:Spring 中的 AOP 原理的更多相关文章

  1. 深入理解spring中的AOP原理 —— 实现MethodInterceptor接口,自已动手写一个AOP

      1.前言 AOP是面向切面编程,即“Aspect Oriented Programming”的缩写.面对切面,就是面向我们的关注面,不能让非关注面影响到我们的关注面.而现实中非关切面又必不可少,例 ...

  2. Spring中的AOP 专题

    Caused by: java.lang.IllegalArgumentException: ProceedingJoinPoint is only supported for around advi ...

  3. 0000 - Spring 中常用注解原理剖析

    1.概述 Spring 框架核心组件之一是 IOC,IOC 则管理 Bean 的创建和 Bean 之间的依赖注入,对于 Bean 的创建可以通过在 XML 里面使用 <bean/> 标签来 ...

  4. Spring 中常用注解原理剖析

    前言 Spring 框架核心组件之一是 IOC,IOC 则管理 Bean 的创建和 Bean 之间的依赖注入,对于 Bean 的创建可以通过在 XML 里面使用 <bean/> 标签来配置 ...

  5. spring中的AOP 以及各种通知 配置

    理解了前面动态代理对象的原理之后,其实还是有很多不足之处,因为如果在项目中有20多个类,每个类有100多个方法都需要判断是不是要开事务,那么方法调用那里会相当麻烦. spring中的AOP很好地解决了 ...

  6. Spring学习笔记(四)—— Spring中的AOP

    一.AOP概述 AOP(Aspect Oriented Programming),即面向切面编程,可以说是OOP(Object Oriented Programming,面向对象编程)的补充和完善.O ...

  7. (五)Spring 中的 aop

    目录 文章目录 AOP概念 AOP原理 AOP术语 **`Spring`** 中的 **`aop`** 的操作 使用 `AspectJ` 实现 `aop` 的两种方式 AOP概念 浅理解 aop :面 ...

  8. 复习Spring第二课--AOP原理及其实现方式

    AOP原理: AOP,面向方面的编程,使用AOP,你可以将处理方面(Aspect)的代码注入主程序,通常主程序的主要目的并不在于处理这些aspect.AOP可以防止代码混乱.AOP的应用范围包括:持久 ...

  9. Spring中的AOP

    什么是AOP? (以下内容来自百度百科) 面向切面编程(也叫面向方面编程):Aspect Oriented Programming(AOP),通过预编译方式和运行期动态代理实现程序功能的统一维护的一种 ...

随机推荐

  1. StringBuilder内存碎片对性能的影响

    StringBuilder内存碎片对性能的影响 TL;DR: StringBuilder内部是由多段char[]组成的半自动链表,因此频繁从中间修改StringBuilder,会将原本连续的内存分隔为 ...

  2. 「每天五分钟,玩转 JVM」:对象访问定位

    前言 在「对象内存布局」一节中,我们了解到对象头中包含了一个叫做类型指针的东西,即对象指向它的类元数据的指针,虚拟机通过这个指针来确定这个对象是哪个类的实例.但是,并不是所有的虚拟机都是这么去做的.不 ...

  3. angular http 节流

    有时候点列表但是由于查询问题,后端返回数据的速度很慢,导致回来的顺序错乱,后端解决不了,前端来 在jq年代 像标志位 防抖 节流等 在angular里使用了rxjs //错误示范 getIntelli ...

  4. Git&Github入门

    Github: 仓库repository: 存放项目代码,每个项目对应一个项目 收藏star: 收藏 复制克隆项目(Fork): 发起请求Pull Reques: 别人改进你的代码,如果觉得不错可以合 ...

  5. css3笔记系列-3.css中的各种选择器详解,不看后悔系列

    点击上方蓝色字体,关注我 最详细的css3选择器解析 ​ 选择器是什么? 比较官方的解释:在 CSS 中,选择器是一种模式,用于选择需要添加样式的元素. 最常见的 CSS 选择器是元素选择器.换句话说 ...

  6. CMDB资产采集方式

    一:Agent方式 原理:在每台服务器装上agent客户端程序,定时向数据库发送指定的资产信息. 优点:速度快. 缺点:服务器上需要多装一个软件 import subprocess import re ...

  7. django自动生成接口文档

    我们在实际项目中,会需要将我们的一些接口的信息返回给前端,便于前后端的交互,在实际使用中,这种自动生成接口文档的模块很多,我主要是用REST framework自动生成接口文档,这个需要用到的是cor ...

  8. SparkSQL---UDAF

    package sqlspark.Day04 import java.lang import org.apache.spark.sql.{DataFrame, Dataset, SparkSessio ...

  9. Nginx 轻松学 图文并茂 一学就会 附案例源码

    导读 篇幅较长,干货满满,需花费较长时间,转载请注明出处!背景音乐若影响到您,网页选项卡右上角即可关闭~~! Nginx概述 简介 Nginx (engine x) 是一个高性能的HTTP和反向代理w ...

  10. 使用scrapy-selenium, chrome-headless抓取动态网页

        在使用scrapy抓取网页时, 如果遇到使用js动态渲染的页面, 将无法提取到在浏览器中看到的内容. 针对这个问题scrapy官方给出的方案是scrapy-selenium, 这是一个把sel ...