jdk代理和cglib代理

代理:代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。
jdk代理跟cglib代理都是动态代理,再学习这两个代理之前,先来学习一下静态代理。

一:代理模式(静态代理)

代理模式是常用设计模式的一种,我们在软件设计时常用的代理一般是指静态代理,也就是在代码中显式指定的代理。
静态代理 由业务实现类、业务代理类 两部分组成。业务实现类 负责实现主要的业务方法,业务代理类负责对调用的业务方法作拦截、过滤、预处理,主要是在方法中首先进行预处理动作,然后调用业务实现类的方法,还可以规定调用后的操作。我们在需要调用业务时,不是直接通过业务实现类来调用的,而是通过业务代理类的同名方法来调用被代理类处理过的业务方法。
静态代理的实现:
1:首先定义一个接口,说明业务逻辑。

package com.nieshenkuan.Proxy.staticproxy;

//1:首先定义一个接口,说明业务逻辑。
/**
 * 定义一个账户接口
 * 
 * @author NSK
 *
 */
public interface Count {
    // 查询账户
    public void queryCount();

    // 修改账户
    public void updateCount();
}

2:然后,定义业务实现类,实现业务逻辑接口

package com.nieshenkuan.Proxy.staticproxy;

//2:然后,定义业务实现类,实现业务逻辑接口
/**
 * 委托类(包含业务逻辑)
 * 
 * @author NSK
 *
 */
public class CountImpl implements Count {

    @Override
    public void queryCount() {
        System.out.println("查看账户...");

    }

    @Override
    public void updateCount() {
        System.out.println("修改账户...");

    }
}

3:定义业务代理类:通过组合,在代理类中创建一个业务实现类对象来调用具体的业务方法;通过实现业务逻辑接口,来统一业务方法;在代理类中实现业务逻辑接口中的方法时,进行预处理操作、通过业务实现类对象调用真正的业务方法、进行调用后操作的定义。

package com.nieshenkuan.Proxy.staticproxy;

/**
 * 3:定义业务代理类:通过组合,在代理类中创建一个业务实现类对象来调用具体的业务方法;
 * 通过实现业务逻辑接口,来统一业务方法;在代理类中实现业务逻辑接口中的方法时,
 * 进行预处理操作、通过业务实现类对象调用真正的业务方法、进行调用后操作的定义。
 * @author NSK
 *
 */
public class CountProxy implements Count {
    private CountImpl countImpl; // 组合一个业务实现类对象来进行真正的业务方法的调用

    /**
     * 覆盖默认构造器
     * 
     * @param countImpl
     */
    public CountProxy(CountImpl countImpl) {
        this.countImpl = countImpl;
    }

    @Override
    public void queryCount() {
        System.out.println("查询账户的预处理——————");
        // 调用真正的查询账户方法
        countImpl.queryCount();
        System.out.println("查询账户之后————————");
    }

    @Override
    public void updateCount() {
        System.out.println("修改账户之前的预处理——————");
        // 调用真正的修改账户操作
        countImpl.updateCount();
        System.out.println("修改账户之后——————————");

    }

}

4:在使用时,首先创建业务实现类对象,然后把业务实现类对象作构造参数创建一个代理类对象,最后通过代理类对象进行业务方法的调用。

package com.nieshenkuan.Proxy.staticproxy;


/*
 * 4:在使用时,
 * 首先创建业务实现类对象,然后把业务实现类对象作构造参数创建一个代理类对象,
 * 最后通过代理类对象进行业务方法的调用。
 */
public class Test {

    @org.junit.Test
    public void test() {

        CountImpl countImpl = new CountImpl();
        CountProxy countProxy = new CountProxy(countImpl);
        countProxy.updateCount();
        countProxy.queryCount();
    }
    /*
     * 静态代理的缺点很明显:一个代理类只能对一个业务接口的实现类进行包装,
     * 如果有多个业务接口的话就要定义很多实现类和代理类才行。
     * 而且,如果代理类对业务方法的预处理、调用后操作都是一样的(比如:调用前输出提示、调用后自动关闭连接),
     * 则多个代理类就会有很多重复代码。这时我们可以定义这样一个代理类,
     * 它能代理所有实现类的方法调用:根据传进来的业务实现类和方法名进行具体调用。——那就是动态代理。
     */
}

静态代理的缺点很明显:一个代理类只能对一个业务接口的实现类进行包装,如果有多个业务接口的话就要定义很多实现类和代理类才行。而且,如果代理类对业务方法的预处理、调用后操作都是一样的(比如:调用前输出提示、调用后自动关闭连接),则多个代理类就会有很多重复代码。这时我们可以定义这样一个代理类,它能代理所有实现类的方法调用:根据传进来的业务实现类和方法名进行具体调用。——那就是动态代理。

二:动态代理的第一种实现——JDK动态代理

JDK动态代理所用到的代理类在程序调用到代理类对象时才由JVM真正创建,JVM根据传进来的 业务实现类对象 以及 方法名 ,动态地创建了一个代理类的class文件并被字节码引擎执行,然后通过该代理类对象进行方法调用。我们需要做的,只需指定代理类的预处理、调用后操作即可。
1:首先,定义业务逻辑接口

package com.nieshenkuan.Proxy.jdkproxy;

public interface BookFacade {
    public void addBook();
}

2:然后,实现业务逻辑接口创建业务实现类

package com.nieshenkuan.Proxy.jdkproxy;

public class BookFacadeImpl implements BookFacade {   
    @Override  
    public void addBook() {  
        System.out.println("增加图书方法。。。");  
    }  
  
} 

3:最后,实现 调用管理接口InvocationHandler 创建动态代理类

package com.nieshenkuan.Proxy.jdkproxy;

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

public class BookFacadeProxy implements InvocationHandler {
    private Object target;// 这其实业务实现类对象,用来调用具体的业务方法

    /**
     * 绑定业务对象并返回一个代理类
     */
    public Object bind(Object target) {
        this.target = target; // 接收业务实现类对象参数

        // 通过反射机制,创建一个代理类对象实例并返回。用户进行方法调用时使用
        // 创建代理对象时,需要传递该业务类的类加载器(用来获取业务实现类的元数据,在包装方法是调用真正的业务方法)、接口、handler实现类
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }

    /**
     * 包装调用方法:进行预处理、调用后处理
     */
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = null;

        System.out.println("预处理操作——————");
        // 调用真正的业务方法
        result = method.invoke(target, args);

        System.out.println("调用后处理——————");
        return result;
    }

}

4:在使用时,首先创建一个业务实现类对象和一个代理类对象,然后定义接口引用(这里使用向上转型)并用代理对象.bind(业务实现类对象)的返回值进行赋值。最后通过接口引用调用业务方法即可。(接口引用真正指向的是一个绑定了业务类的代理类对象,所以通过接口方法名调用的是被代理的方法们)

package com.nieshenkuan.Proxy.jdkproxy;

public class Test {
    @org.junit.Test
    public void test() {
        BookFacadeImpl bookFacadeImpl = new BookFacadeImpl();
        BookFacadeProxy proxy = new BookFacadeProxy();
        BookFacade bookfacade = (BookFacade) proxy.bind(bookFacadeImpl);
        bookfacade.addBook();
    }
}

JDK动态代理的代理对象在创建时,需要使用业务实现类所实现的接口作为参数(因为在后面代理方法时需要根据接口内的方法名进行调用)。如果业务实现类是没有实现接口而是直接定义业务方法的话,就无法使用JDK动态代理了。并且,如果业务实现类中新增了接口中没有的方法,这些方法是无法被代理的(因为无法被调用)。

三:动态代理的第二种实现——CGlib

jdk中的动态代理通过反射类Proxy和InvocationHandler回调接口实现,要求委托类必须实现一个接口,只能对该类接口中定义的方法实现代理,这在实际编程中有一定的局限性。


cglib是针对类来实现代理的,原理是对指定的业务类生成一个子类,并覆盖其中业务方法实现代理。因为采用的是继承,所以不能对final修饰的类进行代理。


cglib实现动态代理,并不要求委托类必须实现接口,底层采用asm字节码生成框架生成代理类的字节码,下面通过一个例子看看使用CGLib如何实现动态代理。
1:首先定义业务类,无需实现接口(当然,实现接口也可以,不影响的)

package com.nieshenkuan.Proxy.cglibproxy;

public class BookFacadeImpl1 {
     public void addBook() {  
            System.out.println("新增图书...");  
        }  
}

2:实现 MethodInterceptor方法代理接口,创建代理类

package com.nieshenkuan.Proxy.cglibproxy;

import java.lang.reflect.Method;

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

public class BookFacadeCglib implements MethodInterceptor {

    private Object target;// 业务类对象,供代理方法中进行真正的业务方法调用

    // 相当于JDK动态代理中的绑定
    public Object getInstance(Object target) {
        this.target = target; // 给业务对象赋值
        Enhancer enhancer = new Enhancer(); // 创建加强器,用来创建动态代理类
        enhancer.setSuperclass(this.target.getClass()); // 为加强器指定要代理的业务类(即:为下面生成的代理类指定父类)
        // 设置回调:对于代理类上所有方法的调用,都会调用CallBack,而Callback则需要实现intercept()方法进行拦
        enhancer.setCallback(this);
        // 创建动态代理类对象并返回
        return enhancer.create();
    }

    // 实现回调方法
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("预处理——————");
        proxy.invokeSuper(obj, args); // 调用业务类(父类中)的方法
        System.out.println("调用后操作——————");
        return null;
    }

}

3:创建业务类和代理类对象,然后通过 代理类对象.getInstance(业务类对象) 返回一个动态代理类对象(它是业务类的子类,可以用业务类引用指向它)。最后通过动态代理类对象进行方法调用。

package com.nieshenkuan.Proxy.cglibproxy;

public class Test {

    @org.junit.Test
    public void test() {
        BookFacadeImpl1 bookFacade = new BookFacadeImpl1();
        BookFacadeCglib cglib = new BookFacadeCglib();
        BookFacadeImpl1 bookCglib = (BookFacadeImpl1) cglib.getInstance(bookFacade);
        bookCglib.addBook();
    }
}

代理对象的生成过程由Enhancer类实现,大概步骤如下:
1、生成代理类Class的二进制字节码;
2、通过Class.forName加载二进制字节码,生成Class对象;
3、通过反射机制获取实例构造,并初始化代理类对象。

cglib字节码生成

Enhancer是CGLib的字节码增强器,可以方便的对类进行扩展,内部调用GeneratorStrategy.generate方法生成代理类的字节码,通过以下方式可以生成class文件。
具体可以看下这篇文章:https://www.cnblogs.com/chinajava/p/5880887.html

jdk和cglib动态代理实现的区别

1、jdk动态代理使用时,要求委托类必须要有接口;
2、cglib动态代理在代理对象,是直接生成委托类子类对象的字节码,因此代理类不能处理被final修饰的class和方法;
3、jdk采用反射机制调用委托类的方法,是实时的,没有生成新文件;而cglib生成子类字节码,就是委托类的子类,然后直接调用其方法

一、原理区别:

java动态代理是利用反射机制生成一个实现代理接口的匿名类,在调用具体方法前调用InvokeHandler来处理。

而cglib动态代理是利用asm开源包,对代理对象类的class文件加载进来,通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP
2、如果目标对象实现了接口,可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换

如何强制使用CGLIB实现AOP?
(1)添加CGLIB库,SPRING_HOME/cglib/*.jar
(2)在spring配置文件中加入

JDK动态代理和CGLIB字节码生成的区别?
(1)JDK动态代理只能对实现了接口的类生成代理,而不能针对类
(2)CGLIB是针对类实现代理,主要是对指定的类生成一个子类,覆盖其中的方法
因为是继承,所以该类或方法最好不要声明成final

JDK代理是不需要以来第三方的库,只要要JDK环境就可以进行代理,它有几个要求

  • 实现InvocationHandler
  • 使用Proxy.newProxyInstance产生代理对象
  • 被代理的对象必须要实现接口
    CGLib 必须依赖于CGLib的类库,但是它需要类来实现任何接口代理的是指定的类生成一个子类,覆盖其中的方法,是一种继承但是针对接口编程的环境下推荐使用JDK的代理
    在Hibernate中的拦截器其实现考虑到不需要其他接口的条件Hibernate中的相关代理采用的是CGLib来执行。

你可能感兴趣的:(jdk代理和cglib代理)