关闭

静态代理和动态代理(JDK动态代理和CGLib动态代理)

149人阅读 评论(0) 收藏 举报
分类:
自己菜鸟一枚,结合自己的理解和网上的一些文章总结出了这篇关于代理的文章,不足之处欢迎指出
   代理(Proxy),意思就是你不用做,别人代替你去处理。如果你想要在不动自己的义务逻辑代码的前提下,在业务逻辑的前后添加一些功能(例如:日志记录、性能监控等),那么代理就是很好的选择。向我们常用的AOP(面向切面编程)就是针对代理的一种运用。

代理模式是常用的java设计模式,他的特征是代理类与委托类(委托类即实现类)有实现同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理类与委托类之间通常会存在关联关系,一个代理类的对象与一个委托类的对象关联,代理类的对象本身并不真正实现服务,而是通过调用委托类的对象的相关方法,来提供特定的服务。

分类:
按照代理的创建时期,代理类可以分为两种:
静态代理:由程序员创建或特定工具自动生成源代码,再对其编译。在程序运行前,代理类的.class文件就已经存在了
动态代理:在程序运行时,运用反射机制动态创建而成

特点:

 静态代理:一个代理类只能代理一个接口,在开发过程中会有多个业务接口,这就造成了大量的代理类;

动态代理:一个代理类可以实现全部接口的代理

静态代理的具体运用和实现原理

 首先看一下静态代理: 

首先看一下静态代理: 
1、Count.java (账户接口)

1.	package net.battier.dao;  
2.	  
3.	/** 
4.	 * 定义一个账户接口 
5.	 * @author Administrator 
6.	 */  
7.	public interface Count {  
8.	    // 查看账户方法  
9.	    public void queryCount();  
10.	  
11.	    // 修改账户方法  
12.	    public void updateCount();  
13.	  
14.	}  

2CountImpl.java (实现类/委托类)

1.	package net.battier.dao.impl;  
2.	  
3.	import net.battier.dao.Count;  
4.	  
5.	/** 
6.	 * 委托类(包含业务逻辑) 
7.	 *  
8.	 * @author Administrator 
9.	 *  
10.	 */  
11.	public class CountImpl implements Count {  
12.	  
13.	    @Override  
14.	    public void queryCount() {  
15.	        System.out.println("查看账户方法...");  
16.	  
17.	    }  
18.	  
19.	    @Override  
20.	    public void updateCount() {  
21.	        System.out.println("修改账户方法...");  
22.	  
23.	    }  
24.	  
25.	}  

3、CountProxy.java (账户接口代理类)

package net.battier.dao.impl;  
27.	  
28.	import net.battier.dao.Count;  
29.	  
30.	/** 
31.	 * 这是一个代理类(增强CountImpl实现类)  
32.	 * @author Administrator   
33.	 */  
34.	public class CountProxy implements Count {  
35.	    private CountImpl countImpl;  
36.	  
37.	    /** 
38.	     * 覆盖默认构造器 
39.	     *  
40.	     * @param countImpl 
41.	     */  
42.	    public CountProxy(CountImpl countImpl) {  
43.	        this.countImpl = countImpl;  
44.	    }  
45.	  
46.	    @Override  
47.	    public void queryCount() {  
48.	        System.out.println("事务处理之前");  
49.	        // 调用委托类的方法;  
50.	        countImpl.queryCount();  
51.	        System.out.println("事务处理之后");  
52.	    }  
53.	  
54.	    @Override  
55.	    public void updateCount() {  
56.	        System.out.println("事务处理之前");  
57.	        // 调用委托类的方法;  
58.	        countImpl.updateCount();  
59.	        System.out.println("事务处理之后");  
60.	  
61.	    }  
62.	  
63.	} 

4、TestCount.java 

1.	package net.battier.test;  
2.	  
3.	import net.battier.dao.impl.CountImpl;  
4.	import net.battier.dao.impl.CountProxy;  
5.	  
6.	/** 
7.	 *测试Count类 
8.	 *  
9.	 * @author Administrator 
10.	 *  
11.	 */  
12.	public class TestCount {  
13.	    public static void main(String[] args) {  
14.	        CountImpl countImpl = new CountImpl();  
15.	        CountProxy countProxy = new CountProxy(countImpl);  
16.	        countProxy.updateCount();  
17.	        countProxy.queryCount();  
18.	  
19.	    }  
20.	} 
观察代码可以发现每一个代理类只能为一个接口服务,这样一来程序开发中必然会产生过多的代理,而且,所有的代理操作除了调用的方法不一样之外,其他的操作都一样,这造成了代码的重复。解决这一问题最好的做法是可以通过一个代理类完成全部的代理功能,那么此时就必须使用动态代理完成。


动态代理的具体运用和实现原理:

Java动态代理又可以分为JDK动态代理和CGLib动态代理。JDK动态代理必须是基于接口的类,而CGLib是基于类进行代理(即cglib代理没有接口的类),针对这两个动态代理的具体运用和实现原理进行分析和总结:

JDK动态代理
  主要运用的技术:Proxy类、InvocationHandler接口
JDK动态代理中包含一个类和一个接口:

import java.lang.reflect.Method;

public interface InvocationHandler { 
	/**
	 * 
	 * @param proxy 指被代理的对象
	 * @param method 要调用的方法
	 * @param args 方法调用时所需要的参数
	 * @return
	 * @throws Throwable
	 */
	public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
}

可以将InvocationHandler接口的子类想象成一个代理的最终操作类,替换掉ProxySubject。 

Proxy类: 
Proxy类是专门完成代理的操作类,可以通过此类为一个或多个接口动态地生成实现类,此类提供了如下的操作方法:

public staticObject newProxyInstance(ClassLoader loader, Class<?>[] interfaces, 
InvocationHandler h) 
                              throws IllegalArgumentException 
参数说明: 
ClassLoader loader:类加载器 
Class<?>[] interfaces:得到全部的接口 
InvocationHandler h:得到InvocationHandler接口的子类实例 

Ps:类加载器 
在Proxy类中的newProxyInstance()方法中需要一个ClassLoader类的实例,ClassLoader实际上对应的是类加载器,在Java中主要有一下三种类加载器; 
Booststrap ClassLoader:此加载器采用C++编写,一般开发中是看不到的; 
Extendsion ClassLoader:用来进行扩展类的加载,一般对应的是jre\lib\ext目录中的类; 
AppClassLoader:(默认)加载classpath指定的类,是最常使用的是一种加载器。 

动态代理 
与静态代理类对照的是动态代理类,动态代理类的字节码在程序运行时由Java反射机制动态生成,无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作,而且提高了软件系统的可扩展性,因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 

动态代理示例: 

1、BookFacade.java 

1.	package net.battier.dao;  
2.	  
3.	public interface BookFacade {  
4.	    public void addBook();  
5.	}  

2、BookFacadeImpl.java 

1.	package net.battier.dao.impl;  
2.	  
3.	import net.battier.dao.BookFacade;  
4.	  
5.	public class BookFacadeImpl implements BookFacade {  
6.	  
7.	    @Override  
8.	    public void addBook() {  
9.	        System.out.println("增加图书方法。。。");  
10.	    }  
11.	  
12.	}  
13.	   
3、BookFacadeProxy.java

16.	package net.battier.proxy;  
17.	  
18.	import java.lang.reflect.InvocationHandler;  
19.	import java.lang.reflect.Method;  
20.	import java.lang.reflect.Proxy;  
21.	  
22.	/** 
23.	 * JDK动态代理代理类 
24.	 *  
25.	 * @author student 
26.	 *  
27.	 */  
28.	public class BookFacadeProxy implements InvocationHandler {  
29.	    private Object target;  
30.	    /** 
31.	     * 绑定委托对象并返回一个代理类 
32.	     * @param target 
33.	     * @return 
34.	     */  
35.	    public Object bind(Object target) {  
36.	        this.target = target;  
37.	        //取得代理对象  
38.	        return Proxy.newProxyInstance(target.getClass().getClassLoader(),  
39.	                target.getClass().getInterfaces(), this);   //要绑定接口(这是一个缺陷,cglib弥补了这一缺陷)  
40.	    }  
41.	  
42.	    @Override  
43.	    /** 
44.	     * 调用方法 
45.	     */  
46.	    public Object invoke(Object proxy, Method method, Object[] args)  
47.	            throws Throwable {  
48.	        Object result=null;  
49.	        System.out.println("事物开始");  
50.	        //执行方法  
51.	        result=method.invoke(target, args);  
52.	        System.out.println("事物结束");  
53.	        return result;  
54.	    }  
55.	  
56.	}  

 

4、TestProxy.java 

1.	package net.battier.test;  
2.	  
3.	import net.battier.dao.BookFacade;  
4.	import net.battier.dao.impl.BookFacadeImpl;  
5.	import net.battier.proxy.BookFacadeProxy;  
6.	  
7.	public class TestProxy {  
8.	  
9.	    public static void main(String[] args) {  
10.	        BookFacadeProxy proxy = new BookFacadeProxy();  
11.	        BookFacade bookProxy = (BookFacade) proxy.bind(new BookFacadeImpl());  
12.	        bookProxy.addBook();  
13.	    }  
14.	  
15.	}  
但是,JDK的动态代理依靠接口实现,如果有些类并没有实现接口,则不能使用JDK代理,这就要使用cglib动态代理了。


Cglib动态代理 
JDK
的动态代理机制只能代理实现了接口的类,而不能实现接口的类就不能实现JDK的动态代理,cglib是针对类来实现代理的,他的原理是对指定的目标类生成一个子类,并覆盖其中方法实现增强,但因为采用的是继承,所以不能对final修饰的类进行代理。

示例 
1
BookFacadeCglib.java 

1.	package net.battier.dao;  
2.	  
3.	public interface BookFacade {  
4.	    public void addBook();  
5.	}  


2、BookCadeImpl1.java 

1.	package net.battier.dao.impl;  
2.	  
3.	/** 
4.	 * 这个是没有实现接口的实现类 
5.	 *  
6.	 * @author student 
7.	 *  
8.	 */  
9.	public class BookFacadeImpl1 {  
10.	    public void addBook() {  
11.	        System.out.println("增加图书的普通方法...");  
12.	    }  
13.	}  

3BookFacadeProxy.java 

1.	package net.battier.proxy;  
2.	  
3.	import java.lang.reflect.Method;  
4.	  
5.	import net.sf.cglib.proxy.Enhancer;  
6.	import net.sf.cglib.proxy.MethodInterceptor;  
7.	import net.sf.cglib.proxy.MethodProxy;  
8.	  
9.	/** 
10.	 * 使用cglib动态代理 
11.	 *  
12.	 * @author student 
13.	 *  
14.	 */  
15.	public class BookFacadeCglib implements MethodInterceptor {  
16.	    private Object target;  
17.	  
18.	    /** 
19.	     * 创建代理对象 
20.	     *  
21.	     * @param target 
22.	     * @return 
23.	     */  
24.	    public Object getInstance(Object target) {  
25.	        this.target = target;  
26.	        Enhancer enhancer = new Enhancer();  
27.	        enhancer.setSuperclass(this.target.getClass());  
28.	        // 回调方法  
29.	        enhancer.setCallback(this);  
30.	        // 创建代理对象  
31.	        return enhancer.create();  
32.	    }  
33.	  
34.	    @Override  
35.	    // 回调方法  
36.	    public Object intercept(Object obj, Method method, Object[] args,  
37.	            MethodProxy proxy) throws Throwable {  
38.	        System.out.println("事物开始");  
39.	        proxy.invokeSuper(obj, args);  
40.	        System.out.println("事物结束");  
41.	        return null;  
42.	  
43.	  
44.	    }  
45.	  
46.	}  

4TestCglib.java

1.	package net.battier.test;  
2.	  
3.	import net.battier.dao.impl.BookFacadeImpl1;  
4.	import net.battier.proxy.BookFacadeCglib;  
5.	  
6.	public class TestCglib {  
7.	      
8.	    public static void main(String[] args) {  
9.	        BookFacadeCglib cglib=new BookFacadeCglib();  
10.	        BookFacadeImpl1 bookCglib=(BookFacadeImpl1)cglib.getInstance(new BookFacadeImpl1());  
11.	        bookCglib.addBook();  
12.	    }  
13.	}







0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:38094次
    • 积分:520
    • 等级:
    • 排名:千里之外
    • 原创:15篇
    • 转载:16篇
    • 译文:0篇
    • 评论:1条
    最新评论