码迷,mamicode.com
首页 > 编程语言 > 详细

Spring AOP原理

时间:2019-03-15 18:47:51      阅读:185      评论:0      收藏:0      [点我收藏+]

标签:intval   通过   mvc   OLE   简历   维护成本   intellij   除了   getc   

一、AOP介绍

AOP 全称Aspect Orient Programming,即面向切面编程,是对OOP(Object Orient Programming)的一种补充。广泛应用于处理一些具有横切性质的系统服务,如日志输出,安全控制,事务管理,缓存,对象池等。AOP实现的关键在于AOP框架自动创建的AOP代理,AOP代理分为静态代理和动态代理。

1、静态代理:指使用AOP框架提供的命令进行编译,从而在编译阶段就生成AOP代理。也称编译时增强。

    静态代理说白了,就是程序运行前就已经存在代理类的字节码文件、代理类和原始类的关系在运行前就已经确定了。

1) 静态代理Demo

IPerson接口

public interface IPerson {
    //找工作
    void findJob();

}

 

ZhangSan要去找工作
/**
 * 目标对象
 */
public class ZhangSan implements  IPerson {
    @Override
    public void findJob() {
        System.out.println("我是张三,我在找工作...");
    }
}

  

代理类:人才市场

public class PersonMarketProxy implements  IPerson{

    private  IPerson target = new ZhangSan();

    @Override
    public void findJob() {
        System.out.println("找工作前,请把简历给我");
        target.findJob();
        System.out.println("找到工作后,要好好工作");
    }
}

  

测试

public class Main {
    public static void main(String[] args) {
        //代理对象
        IPerson proxy = new PersonMarketProxy();
        //代理对象执行代理方法
        proxy.findJob();
    }
}

  静态代理虽然保证了业务。如果代理方法增多,势必每一个方法多要进行代理。除了实现类要实现这个方法,代理类也要实现这个方法。维护成本增加。

      而动态代理很好的解决了这个问题。

  

2、动态代理:在运行时借助于JDK动态代理、CGLIG等内存中“临时”生成的AOP动态代理类。也称运行时增强。

动态代理Demo

2.1 IPerson接口

public interface IPerson {
    //找工作
    void findJob();

}

 2.2 目标对象Zhangsan类

/**
 * 目标对象
 */
public class ZhangSan implements IPerson {
    @Override
    public void findJob() {
        System.out.println("我是张三,我在找工作...");
    }
}

  

2.3 ProxyFactory 类
**
 * 动态代理
 * 给多个目标对象生成代理对象
 */
public class ProxyFactory {

    //目标对象
    private Object target;

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

    //返回代理对象
    public Object getProxyObject(){
        Object proxy = Proxy.newProxyInstance(
                target.getClass().getClassLoader(), //目标对象类加载器
                target.getClass().getInterfaces(), //目标对象实现的所有接口
                new InvocationHandler() {           //执行代理对象方法时候触发
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        String methodName = method.getName();
                        Object result = null;
                        if("findJob".equals(methodName)){
                            System.out.println("找工作前,请把简历给我");
                            result = method.invoke(target, args);
                            System.out.println("找到工作后,要好好工作");
                        }else{
                            result = method.invoke(target, args);
                        }
                        return result;
                    }
                });
        return  proxy;
    }
}

  

2.4  测试

public class Main {
    public static void main(String[] args) {
        //目标对象
        IPerson target = new ZhangSan();
        System.out.println("目标对象:" + target.getClass());
        //代理对象
        IPerson proxy = (IPerson)new ProxyFactory(target).getProxyObject();
        System.out.println("代理对象:" +  proxy.getClass());
        //代理对象执行代理方法
        proxy.findJob();

        createProxyClassFile(IPerson.class);
    }

    private static void createProxyClassFile(Class c){
        byte[] data = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{c});
        try{
            FileOutputStream fileOutputStream = new FileOutputStream("$Proxy0.class");
            fileOutputStream.write(data);
            fileOutputStream.close();
        }catch (FileNotFoundException e){
            e.printStackTrace();
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

  


  

2.5 打印结果:

技术图片

 

IPerson proxy = (IPerson)new ProxyFactory(target).getProxyObject();
这行代码其实是JDK动态生成了一个类去实现接口
public final class $Proxy0 extends Proxy implements IPerson
完整的代码如2.6.

2.6 然后使用使用createProxyClassFile,将代理类使用写入文件,文件的内容为

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;
import spring_springmvc.proxyDongTai.IPerson;

public final class $Proxy0 extends Proxy implements IPerson {
    private static Method m1;
    private static Method m2;
    private static Method m3;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void findJob() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m3 = Class.forName("spring_springmvc.proxyDongTai.IPerson").getMethod("findJob", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

  

 2.7 使用JDK生成动态代理的前提示目标类必须有实现的接口。 CGLIB是以动态生成的子类继承目标方式实现。在运行期动态的内存中构建一个子类 

 

AOP是基于动态代理的

AOP是方法级别的

AOP可以分离业务和重复代码

二、实现AOP的技术

主要实现AOP思想的技术有AspectJ和Spring AOP

1、AspectJ的底层技术

    AspectJ的底层技术是静态代理,即用一种AspectJ支持的特定语言编写切面,通过一个命令来编译,生成一个新的代理类。写着是编译时增强,相对于运行时增强性能更好。

2、Spring AOP

    Spring AOP采用动态代理,在运行期间对业务方法进行增强,不会生成新类。Spring AOP提供了对JDK动态代理支持和CGLib的支持。

    JDK动态代理只能为接口创建动态代理实例,而不能对类创建动态代理。需要获得被目标类的接口信息(使用反射技术),生成一个实现了代理接口的动态代理类(字节码),再通过反射机制获得动态代理的构造函数,利用构造函数生成代理类的实例对象,在调用具体方法前调用invokeHandler方法处理。

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

     但是Spring AOP基于注解配置的情况下,需要依赖于AspectJ包的标准注解,但是不需要额外的编译及AspectJ的织入器,而基于XML配置不需要。

 

技术图片

Spring Aop过程

1、创建容器对象的时,根据切入点表达式拦截的类,生成代理对象

2、如果有接口,使用JDK代理。反之,使用CGLIB代理。然后从容器中获取代理对象,在运行期间植入“切面” 类的方法。

    如果目标类没有实现接口,且class为final, 则不能进行Spring AOP编程。

 

Spring AOP原理

标签:intval   通过   mvc   OLE   简历   维护成本   intellij   除了   getc   

原文地址:https://www.cnblogs.com/linlf03/p/10469961.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!