设计模式学习之代理模式（二）--CGLIB实现对Class动态代理

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

静态代理的不足
1、需要为真实主题写一个形式上完全一样的封装类，假如主题接口中的方法很多，为每一个接口写一个代理方法也很麻烦

2、如果接口有变动，则真实主题和代理类都要修改，不利于系统维护

 

JDK动态代理的美中不足

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

下面介绍利用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();
	}

2.  延迟加载对象

 

示例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();
	}

示例2： 

使用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在每次访问延迟加载属性时都会触发代理类回调方法