CGLIB子类代理和JDK动态代理示例和比较

为什么80%的码农都做不了架构师？>>>   

Cglib代理，也叫做子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。

比较：

      JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。

      CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。

       CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

Cglib子类代理：

         1)需要引入cglib – jar文件，但是spring的核心包中已经包括了cglib功能，所以直接添加spring-core的依赖即可

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.3.10.RELEASE</version>
        </dependency>

         2）引入功能包后，就可以在内存中动态构建子类

         3）代理的类不能为final， 否则报错。

         4） 目标对象的方法如果为final/static,那么就不会被拦截，即不会执行目标对象额外的业务方法。

在Spring的AOP编程中，

         如果加入容器的目标对象有实现接口，用JDK代理；

         如果目标对象没有实现接口，用Cglib代理；

下面开始CGLIB代理的示例

先写一个UserDao

package xin.sun.proxy.cglib;

/**
 * @author Ginkgo
 */
public class UserDao {

    public void save() {
        System.out.println("UserDao . save");
    }
}

再写一个代理工厂ProxyFactory，实现CGLIB中的MethodInterceptor接口

package xin.sun.proxy.cglib;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author Ginkgo
 */
public class ProxyFactory implements MethodInterceptor {

    /**
     * 被代理对象
     */
    private Object target;

    /**
     * 构造器
     *
     * @param target
     */
    public ProxyFactory(Object target) {
        this.target = target;
    }

    /**
     * 获取代理对象实例
     *
     * @return Object 代理对象实例
     */
    public Object getProxyInstance() {

        /**
         * 工具类
         */
        Enhancer enhancer = new Enhancer();
        /**
         * 设置父类
         */
        enhancer.setSuperclass(target.getClass());
        /**
         * 设置回调对象
         */
        enhancer.setCallback(this);
        /**
         * 创建子类代理对象，并返回
         */
        return enhancer.create();
    }

    /**
     * 重写拦截方法
     *
     * @param o           代理对象
     * @param method      委托类方法
     * @param objects     方法参数
     * @param methodProxy 代理方法的MethodProxy对象
     * @return Object 目标方法执行结果
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("开始事务...");

        /**
         * 方法执行结果
         */
        Object result = method.invoke(target,objects);

        System.out.println("结束事务...");

        return result;
    }
}

再写一个入口类Portal来测试

package xin.sun.proxy.cglib;

/**
 * @author Ginkgo
 */
public class Portal {

    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory(new UserDao());
        UserDao proxyInstance = (UserDao) proxyFactory.getProxyInstance();
        proxyInstance.save();
    }
}

运行结果：

开始事务...
UserDao . save
结束事务...

然后再看看JDK动态代理

先写一个接口IOrderDao和实现类OrderDaoImpl

package xin.sun.proxy.dynamic;

/**
 * @author Ginkgo
 */
public interface IOrderDao {

    /**
     * 保存对象
     *
     * @param obj
     */
    void save(Object obj);
}

-----------------------------------------------------------------------------------------------------

package xin.sun.proxy.dynamic;

/**
 * @author Ginkgo
 */
public class OrderDaoImpl implements IOrderDao {
    @Override
    public void save(Object obj) {
        System.out.println("OrderDaoImpl -> save " + obj);
    }
}

再写一个代理工厂ProxyFactory，实现InvocationHandler接口

package xin.sun.proxy.dynamic;

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

/**
 * @author Ginkgo
 */
public class ProxyFactory implements InvocationHandler {

    /**
     * 被代理对象
     */
    private Object target;

    /**
     * 构造器
     *
     * @param target
     */
    public ProxyFactory(Object target) {
        this.target = target;
    }

    /**
     * desc:获取代理对象
     *
     * @return java.lang.Object
     * @author Ginkgo
     */
    public Object getProxyInstance() {

        Object proxyInstance = Proxy
                .newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
        return proxyInstance;
    }

    /**
     * 重写调用方法
     *
     * @param proxy
     * @param method
     * @param args
     * @return Object 方法执行结果
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("开始事务 ...");

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

        System.out.println("结束事务 ...");

        return result;
    }
}

在写一个Portal入口类测试一下

package xin.sun.proxy.dynamic;

/**
 * @author Ginkgo
 */
public class Portal {

    public static void main(String[] args) {

        ProxyFactory proxyFactory = new ProxyFactory(new OrderDaoImpl());
        IOrderDao proxyInstance = (IOrderDao) proxyFactory.getProxyInstance();
        proxyInstance.save("test");
    }
}

运行结果

开始事务 ...
OrderDaoImpl -> save test
结束事务 ...

 

转载于:https://my.oschina.net/GinkGo/blog/1563128