jdk动态代理与cglib代理、spring aop代理实现原理解析

原创声明：本博客来源为本人原创作品，绝非他处摘取，转摘请联系博主

代理（proxy）的定义：为某对象提供代理服务，拥有操作代理对象的功能，在某些情况下，当客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

动态代理实现主要有2种形式，主要分为：
1.jdk动态代理：
1)原理：是根据类加载器和接口创建代理类（此代理类是接口的实现类，所以必须使用接口 面向接口生成代理，位于java.lang.reflect包下）
2)实现方式：
1. 通过实现InvocationHandler接口创建自己的调用处理器 IvocationHandler handler = new InvocationHandlerImpl(…);
2. 通过为Proxy类指定ClassLoader对象和一组interface创建动态代理类Class clazz = Proxy.getProxyClass(classLoader,new Class[]{…});
3. 通过反射机制获取动态代理类的构造函数，其参数类型是调用处理器接口类型Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});
4. 通过构造函数创建代理类实例，此时需将调用处理器对象作为参数被传入Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));
2~4步骤可合并

package proxy.jdkproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

import org.junit.Test;

public class JDKProxy{
    //写法1
    private Object targetObject;//代理目标
    public Object CustomerProxy(Object obj) {
        targetObject = obj;
        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(), targetObject.getClass().getInterfaces(),new targetHandler());
    }
    class targetHandler  implements InvocationHandler{
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
             System.out.println("开启事务...");
             Object returnValue = method.invoke(targetObject, args);//回调被代理目标的方法userDaoImpl.add();
             System.out.println("提交事务");
             return returnValue;
        }
    }
    public static void main(String[] args) {
        JDKProxy jdkProxy = new JDKProxy();
        Customer userDao = (Customer)jdkProxy.CustomerProxy(new CustomerImpl());
        userDao.shopping();
    }
    //写法2
    @Test
    public void test1(){
        Customer customer = new CustomerImpl();
        Customer cus = (Customer) Proxy.newProxyInstance(customer.getClass().getClassLoader(), customer.getClass().getInterfaces(),new InvocationHandler(){
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                // TODO Auto-generated method stub
                return method.invoke(proxy, args);
            }

        });
        cus.shopping();
    }
}

3)不足点：jdk动态代理，必须是面向接口，目标业务类必须实现接口
2.CGLIB代理
1.原理：利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。
2.实现方法：

package proxy.cglib;

import java.lang.reflect.Method;

import org.junit.Test;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import proxy.model.Customer;

public class CGLIBProxy {
    //写法1
    private Object targetObject;
    private Object createProxy(Object obj){
        targetObject = obj;
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetObject.getClass());//设置代理对象，父类，说明是继承，所有代理对象不能为final
        enhancer.setCallback(new MyHandler());
        return enhancer.create();//创建代理
    }
    class MyHandler implements MethodInterceptor{
        @Override
        public Object intercept(Object arg0, Method method, Object[] args,
                MethodProxy arg3) throws Throwable {
            System.out.println("开启事务..");
            Object returnValue = method.invoke(targetObject, args);
            System.out.println("提交事务....");
            return returnValue;
        }
    }
    @Test
    public  void test1() {
        CGLIBProxy cglibProxy = new CGLIBProxy();
        Customer customer = (Customer)cglibProxy.createProxy(new Customer());
        customer.eat();
    }
    //写法2
    @Test
    public void test2(){
        Customer customer = new Customer();
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(customer.getClass());
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] args,
                    MethodProxy arg3) throws Throwable {
                if(method.getName().equals("eat")){
                    System.out.println("customer的eat方法被拦截了。。。。");
                    Object invoke = method.invoke(proxy, args);
                    System.out.println("真实方法拦截之后。。。。");
                    return invoke;
                }
                // 不拦截
                return method.invoke(proxy, args);
            }
        });
        Customer cus = (Customer) enhancer.create();
        cus.eat();
    }
}

3.注意点：被代理目标不是是final修饰的类（final修饰类不能被继承）
spring aop代理原理
1.注意点：

  • 如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP
  • 如果目标对象实现了接口，可以强制使用CGLIB实现AOP
  • 如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

2.强制把jdk代理转换成cglib代理

  • 添加CGLIB库，SPRING_HOME/cglib/*.jar
  • 在spring配置文件中加入
    传统AOP可以实现自动代理，不需要专门指定代理，可以在类生成的时候自动代理，有两种方式实现自动代理，基于Bean名称的自动代理BeanNameAutoProxyCreator和基于切面信息的自动代理DefaultAdvisorAutoProxyCreator

spring mvc 使用DefaultAdvisorAutoProxyCreator实现自动代理 配置

<!--定义一个表示声明使用自动代理的类  -->
    <bean id="autoProxyCreator" class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/>
    <!-- 定义代理类 -->
    <bean id="exceptionHandler" class="com.kaizhi.platform.util.ExceptionHandler"/>
    <!-- 定义支持正则表达式的通知 -->
    <bean id="exceptionHandlerAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice">
            <ref bean="exceptionHandler"/>
        </property>
        <property name="patterns">
            <value>.save*.*</value>//正则匹配需要拦截的方法
        </property>
     </bean>

spring mvc 使用BeanNameAutoProxyCreator自动代理配

<!-- 基于BeanNameAutoProxyCreator，Bean名称的自动代理 -->
    <!-- 定义代理类 -->
    <bean id="exceptionHandler" class="com.kaizhi.platform.util.ExceptionHandler"/>
    <bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
        <!-- 拦截的业务bean -->
        <property name="beanNames" value="*adminFinanceService"/>
        <!-- 拦截的通知 -->
        <property name="interceptorNames" value="exceptionHandler"/>
    </bean>

参考：http://blog.csdn.net/zx13525079024/article/details/51913141

时间： 2024-08-07 08:09:25

jdk动态代理与cglib代理、spring aop代理实现原理解析的相关文章

Spring AOP 的实现 原理

反射实现 AOP 动态代理模式实例说明(Spring AOP 的实现 原理) 比如说,我们现在要开发的一个应用里面有很多的业务方法,但是,我们现在要对这个方法的执行做全面监控,或部分监控.也许我们就会在要一些方法前去加上一条日志记录, 我们写个例子看看我们最简单的解决方案 我们先写一个接口IHello.java代码如下: [java] view plaincopyprint? package sinosoft.dj.aop.staticaop; public interface IHello {

【Spring】AOP之JDK动态代理和CGLib动态代理

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 一.JAVA动态代理  1.1 代理模式         代理模式是常用的java设计模式,他的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息.过滤消息.把消息转发给委托类,以及事后处理消息等.代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务. 按照代理的创

spring aop原理 JDK动态代理和CGLIB动态代理

Spring的两大特性是IOC和AOPIOC负责将对象动态的注入到容器,从而达到一种需要谁就注入谁,什么时候需要就什么时候注入的效果.理解spring的ioc也很重要.但是今天主要来和大家讲讲aop.AOP 广泛应用于处理一些具有横切性质的系统级服务,AOP 的出现是对 OOP 的良好补充,用于处理系统中分布于各个模块的横切关注点,比如事务管理.日志.缓存等等. AOP实现的关键在于AOP框架自动创建的AOP代理.AOP代理主要分为静态代理和动态代理, 静态代理的代表为AspectJ:动态代理则

深入探索spring技术内幕(六): JDK动态代理和cglib生成代理

[ JDK生成代理 ] JDK中给我们提供了一个Proxy类可以动态的给我们生成代理. 假定我们要做一个权限管理系统, 需要控制用户对某一个方法的访问. 如果user为null, 那么不让用户访问save方法. ① 接口类: PersonService public interface PersonService { public void save(); } ② 实现类: PersonServiceImpl public class PersonServiceImpl implements P

JDK动态代理和CGLIB动态代理

转载自http://www.itzhai.com/java-dong-tai-dai-li-zhi-jdk-dong-tai-dai-li-he-cglib-dong-tai-dai-li-mian-xiang-qie-mian-bian-cheng-aop-yuan-li.html 静态代理 静态代理相对来说比较简单,无非就是聚合+多态: 参考:设计模式笔记 – Proxy 代理模式 (Design Pattern) 动态代理 我们知道,通过使用代理,可以在被代理的类的方法的前后添加一些处理方

JDK动态代理和CGLIB动态代理+源码下载

在上一篇文章-java代理详解讲解实现机制,一种是继承另外一种是组合,而且通过做实现也证明使用组合的方式更加的灵活.之后提到了代理的两种种类,一种是静态代理,另外一种是动态代理.上一篇文件中着重介绍的是静态代理(相对于动态代理很容易理解).这一片文章就接着介绍动态代理. 动态代理实现的最终效果:通过以一个统一的方式实现对任意的接口/类的代理.相比较静态代理而言,我们可以不用再无限制的增加代理类,不用再写许多重复的代码.很符合面向对象设计原则中的"开闭原则":对修改关闭,对扩展开放. 动

JDK动态代理和CGLIB代理的区别

一.原理区别: java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理. 而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理. 1.如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP 2.如果目标对象实现了接口,可以强制使用CGLIB实现AOP 3.如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换 如何强制使用

设计模式---JDK动态代理和CGLIB代理

Cglig代理设计模式 /*测试类*/ package cglibProxy; import org.junit.Test; public class TestCglib { @Test public void test1(){ CglibProxy cglibProxy=new CglibProxy(); UserServiceImpl userServiceImpl = (UserServiceImpl)cglibProxy.createProxyInstance(new UserServi

关于JDK动态代理和CGLIB动态代理

1. 代理模式 一句话总结:为其他对象提供一种代理以控制对这个对象的访问.千篇一律的介绍:代理模式是常用的java设计模式,他的特征是代理类与委托类(或目标类)有同样的接口,代理类主要负责为委托类预处理消息.过滤消息.把消息转发给委托类,以及事后处理消息等.代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务. 按照代理的创建时期,代理类可以分为两种. 静态代理:由程序员创建或特定工具