代理模式_利用CGLIB实现对Class动态代理

在前一篇文章中提到静态代理和JDK的动态代理,但是这两种代理都只能对接口实现代理

静态代理的不足

1、需要为真实主题写一个形式上完全一样的封装类,假如主题接口中的方法很多,为每一个接口写一个代理方法也很麻烦
2、如果接口有变动,则真实主题和代理类都要修改,不利于系统维护

JDK动态代理的美中不足

由于java不支持多继承,而JDK动态代理的动态生成的代理类必定继承一个共同的父类Proxy,这也就注定了JDK动态代理无法实现对class的动态代理。

动态代理实际上是程序在运行中,根据被代理的接口来动态生成代理类的class文件,并加载class文件运行的过程,通过反编译被生成的$Proxy0.class文件发现:


代理模式_利用CGLIB实现对Class动态代理_第1张图片
Proxy0

利用CGLIB实现对Class动态代理

CGLIB动态代理介绍

CGLIB是一个强大的高性能的代码生成包。

可以通过使用CGLIB来为那些没有接口的类创建模仿(mock)对象。

关于CGLIB

CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM(Java字节码操控框架),来转换字节码并生成新的类。除了CGLIB包,脚本语言例如 Groovy和BeanShell,也是使用ASM来生成java的字节码。当不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。所以cglib包要依赖于asm包,需要一起导入。

利用CGLIB实现动态代理

下面的例子主要演示通过代理实现简单的 写日志和权限控制

1.定义被代理类

public class BookServiceBean {
    public BookServiceBean() {
        //Thread.sleep(3000);
        System.out.println("实例化BookServiceBean对象");
    }

    public BookServiceBean(Object o){
        System.out.println("模拟初始化资源,等耗时连接");
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public void create(){  
        System.out.println("create() is running !");     
    }     
    public void query(){     
        System.out.println("query() is running !");     
    }     
    public void update(){     
        System.out.println("update() is running !");     
    }     
    public void delete(){     
        System.out.println("delete() is running !");     
    }     
}

2.配置拦截器

public class MyCglibInterceptor implements MethodInterceptor {

    private String name;  
    public MyCglibInterceptor(String name) {  
           this.name = name ;  
     }  

    public Object intercept(Object arg0, Method arg1, Object[] arg2,
            MethodProxy arg3) throws Throwable {
        System.out.println("这里可以分别打印日志或者其他操作调用的方法是:" + arg1.getName());
        // 用户进行判断
        if (!"shli".equals(name)) {
            System.out.println("你没有权限!");
            return null;
        }
        Object result = arg3.invokeSuper(arg0, arg2);
        return result;
    }
}

3.动态生成代理类

      //简单的使用cglib  
    private static void withoutFilter(){
        Enhancer en = new Enhancer();
        //进行代理     
        en.setSuperclass(BookServiceBean.class);
        //只有用户是 shli的时候才有权限
        MyCglibInterceptor interceptor = new MyCglibInterceptor("aclu");
        en.setCallback(interceptor);

        BookServiceBean service = (BookServiceBean) en.create();

        //使用代理   需要执行耗时连接
        service.query();
    }

CGLIB实现动态代理时的其他常用功能

  1. CallbackFilter(回调过滤器)
/**
 * 方法过滤器(CallbackFilter),CallbackFilte可以明确表明,被代理的类中不同的方法,被哪个拦截器所拦截
 */
public class MyProxyFilter  implements CallbackFilter {
    public int accept(Method method) {
        if(!"query".equalsIgnoreCase(method.getName()))     
            return 0;     
        return 1; 
    }  
}
//使用cglib的filter功能
    private static void withFilter(){
        Enhancer en = new Enhancer();
        //进行代理     
        en.setSuperclass(BookServiceBean.class);
        MyCglibInterceptor interceptor = new MyCglibInterceptor("aclu");
        //setCallbacks中定义了所使用的拦截器,其中NoOp.INSTANCE是CGlib所提供的实际是一个没有任何操作的拦截器
        //他们是有序的,一定要和CallbackFilter里面的顺序一致。上面return返回(0/1)的就是返回的顺序。
        //也就是说如果调用query方法就使用NoOp.INSTANCE进行拦截
        en.setCallbacks(new Callback[]{interceptor,NoOp.INSTANCE});
        en.setCallbackFilter(new MyProxyFilter());
        BookServiceBean service = (BookServiceBean) en.create();
        //使用代理
        service.query();
    }
  1. 延迟加载对象

示例1:

经测试,被懒加载的对象必须保留无参的构造方法,而无参的构造方法会在被懒加载对象生成的时候调用。

所以建议把需要懒加载的逻辑(耗时的操作),放入有参数的构造方法中,并且在loadObject()方法中使用有参数的构造方法初始化对象。

public class ServiceLazyLoader implements LazyLoader{

    public Object loadObject() throws Exception {
        System.out.println("开始加载服务信息 ..."); 
        BookServiceBean service = new BookServiceBean(new Object());
        System.out.println("加载完成....");
        return service;
    }
}
//简单的使用cglib  包括懒加载
    private static void withoutFilter(){
        Enhancer en = new Enhancer();
        //进行代理     
        en.setSuperclass(BookServiceBean.class);
        //只有用户是 shli的时候才有权限
        MyCglibInterceptor interceptor = new MyCglibInterceptor("aclu");
        en.setCallback(interceptor);
        //延时加载
        en.setCallback(new ServiceLazyLoader());
        BookServiceBean service = (BookServiceBean) en.create();

        //使用代理   需要执行耗时连接
        service.query();
    }

示例3:

使用Dispatcher和LazyLoader接口,模拟实体信息的懒加载功能

LazyLoader只在第一次访问延迟加载属性时触发代理类回调方法,

而Dispatcher在每次访问延迟加载属性时都会触发代理类回调方法

/**
  *其中包含的Info信息 需要懒加载
  *infoFromLazyLoader 通过实现LazyLoader接口实现功能
  *infoFromDispatcher 通过实现Dispatcher接口实现功能
 */
public class Person {
    private String name;
    private int id;

    private Info infoFromLazyLoader;
    private Info infoFromDispatcher;
    public Person(){
        this.name = "陶醉";
        this.id = 1;
        this.infoFromLazyLoader = createLazyLoaderInfoBean();
        this.infoFromDispatcher = createDispatcherInfoBean();
    }

    private Info createDispatcherInfoBean() {
        Info info = (Info)Enhancer.create(Info.class,new ConcreteClassDispatcher());  
        return info;
    }

    protected Info createLazyLoaderInfoBean(){  
        Info info = (Info)Enhancer.create(Info.class,new ConcreteClassLazyLoader());  
        return info;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public Info getInfoFromLazyLoader() {
        return infoFromLazyLoader;
    }

    public void setInfoFromLazyLoader(Info infoFromLazyLoader) {
        this.infoFromLazyLoader = infoFromLazyLoader;
    }

    public Info getInfoFromDispatcher() {
        return infoFromDispatcher;
    }

    public void setInfoFromDispatcher(Info infoFromDispatcher) {
        this.infoFromDispatcher = infoFromDispatcher;
    }
}

public class Info {

    public Info() {
    }

    public Info(String ss){
        System.out.println("info 构造方法");
    }
    private String address;
    private boolean married;
    private int age;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public boolean isMarried() {
        return married;
    }

    public void setMarried(boolean married) {
        this.married = married;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

}
public class ConcreteClassDispatcher implements Dispatcher{

    public Object loadObject() throws Exception {
        System.out.println("使用“Dispatcher”开始加载人员的附加信息 ..."); 
        Info info = new Info("ss");
        info.setAddress("胡建省");
        info.setAge(12);
        System.out.println("使用“Dispatcher”加载完成....");
        return info;
    }
}
public class ConcreteClassLazyLoader implements LazyLoader{

    public Object loadObject() throws Exception {
        System.out.println("开始加载人员的附加信息 ..."); 
        Info info = new Info("ss");
        info.setAddress("胡建省");
        info.setAge(12);
        System.out.println("加载完成....");
        return info;
    }
}
    //模拟cglib懒加载 的两种情况  分别为:实现LazyLoader 和  实现Dispatcher
    //LazyLoader只在第一次访问延迟加载属性时触发代理类回调方法,
    //而Dispatcher在每次访问延迟加载属性时都会触发代理类回调方法
    private static void testLazy() {
        Person person = new Person();
        System.out.println(person.getId()+"------"+person.getName());

        //获取info属性   LazyLoader
        Info info = person.getInfoFromLazyLoader();

        //调用info属性
        System.out.println("调用info的方法");
        System.out.println(info.getAge());
        Info info1 = person.getInfoFromLazyLoader();
        info1.getAge();

        //获取info   Dispatcher
        Info info2 = person.getInfoFromDispatcher();
        info2.getAddress();
        Info info3 = person.getInfoFromDispatcher();
        info3.getAddress();
    }

控制台信息


1------陶醉

调用info的方法

开始加载人员的附加信息 ...

info 构造方法

加载完成....

12

使用“Dispatcher”开始加载人员的附加信息 ...

info 构造方法

使用“Dispatcher”加载完成....

使用“Dispatcher”开始加载人员的附加信息 ...

info 构造方法

使用“Dispatcher”加载完成....

通过控制台可以看出

  1. 在调用info的方法时,info才真正的被加载。

  2. LazyLoader只在第一次访问延迟加载属性时触发代理类回调方法,而Dispatcher在每次访问延迟加载属性时都会触发代理类回调方法

你可能感兴趣的:(代理模式_利用CGLIB实现对Class动态代理)