`
lzh166
  • 浏览: 298034 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

代理模式与Java 动态代理类

阅读更多
1. 代理模式
代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个客户不想或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
代理模式一般涉及到的角色有:
抽象角色:声明真实对象和代理对象的共同接口;
代理角色:代理对象角色内部含有对真实对象的引用,从而可以操作真实对象,同时代理对象提供与真实对象相同的接口以便在任何时刻都能代替真实对象。同时,代理对象可以在执行真实对象操作时,附加其他的操作,相当于对真实对象进行封装。
真实角色:代理角色所代表的真实对象,是我们最终要引用的对象。
抽象角色:
abstract public class Subject    
{       
 abstract public void request();     
}  
 
真实角色:实现了Subject的request()方法。
public class RealSubject extends Subject     
{   
 public RealSubject()      
{    
   
}     
 //重写父类的方法  
 public void request() {     
 System.out.println("From real subject.");     
 }     
}
   
代理角色:
public class ProxySubject extends Subject {    
   
private RealSubject realSubject; //以真实角色作为代理角色的属性    
   
public ProxySubject() { }    
  
public void request() //该方法封装了真实对象的request方法    
   
{    
   
 preRequest();    
   
if( realSubject == null )      
{    
   
realSubject = new RealSubject();    
   
}    
   
realSubject.request(); //此处执行真实对象的request方法    
    
postRequest();    
    
}     
private void preRequest()    
{    
//something you want to do before requesting     
}      
private void postRequest()    
{     
//something you want to do after requesting      
}      
}  
 
客户端调用:
Subject sub=new ProxySubject();    
   
Sub.request(); 

由以上代码可以看出,客户实际需要调用的是RealSubject类的request()方法,现在用ProxySubject来代理RealSubject类,同样达到目的,同时还封装了其他方法(preRequest(),postRequest()),可以处理一些其他问题。

另外,如果要按照上述的方法使用代理模式,那么真实角色必须是事先已经存在的,并将其作为代理对象的内部属性。但是实际使用时,一个真实角色必须对应一个代理角色,如果大量使用会导致类的急剧膨胀;此外,如果事先并不知道真实角色,该如何使用代理呢?这个问题可以通过Java的动态代理类来解决。
2 .动态代理类 (重点)

Java动态代理类位于Java.lang.reflect包下,一般主要涉及到以下两个类

(1). Interface InvocationHandler:该接口中仅定义了一个方法
Object:invoke(Object obj,Method method, Object[] args)

在实际使用时,第一个参数obj一般是指代理类,method是被代理的方法,如上例中的request(),args为该方法的参数数组。这个抽象方法在代理类中动态实现。

(2).Proxy:该类即为动态代理类,作用类似于上例中的ProxySubject,其中主要包含以下内容:

构造函数,估计用于给内部的h赋值
Protected Proxy(InvocationHandler h)


获得一个代理类,其中loader是类装载器,interfaces是真实类所拥有的全部接口的数组
Static Class getProxyClass (ClassLoader loader, Class[] interfaces)


返回代理类的一个实例,返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)。
Static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)


所谓 Dynamic Proxy是这样一种class:它是在运行时生成的class,在生成它时你必须提供一组interface给它,然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦,这个Dynamic Proxy其实就是一个Proxy,它不会替你作实质性的工作,在生成它的实例时你必须提供一个handler,由它接管实际的工作。
在使用动态代理类时,我们必须实现InvocationHandler接口,以第一节中的示例为例:

抽象角色(之前是抽象类,此处应改为接口):

public interface Subject    
{    
abstract public void request();    
   
} 

具体角色RealSubject:同上;
代理角色:
import java.lang.reflect.Method;    
import java.lang.reflect.InvocationHandler;    
   
public class DynamicSubject implements InvocationHandler {    
   
private Object sub;    
   
public DynamicSubject() {    
}    
   
public DynamicSubject(Object obj) {    
sub = obj;    
}    
   
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
System.out.println("before calling " + method);    
method.invoke(sub,args);    
System.out.println("after calling " + method);    
return null;    
}    
}    

该代理类的内部属性为Object类,实际使用时通过该类的构造函数DynamicSubject(Object obj)对其赋值;此外,在该类还实现了invoke方法,该方法中的
method.invoke(sub,args); 

其实就是调用被代理对象的将要被执行的方法,方法参数sub是实际的被代理对象,args为执行被代理对象相应操作所需的参数。通过动态代理类,我们可以在调用之前或之后执行一些相关操作。

客户端:

import java.lang.reflect.InvocationHandler;    
import java.lang.reflect.Proxy;    
import java.lang.reflect.Constructor;    
import java.lang.reflect.Method;    
   
public class Client    
{    
static public void main(String[] args) throws Throwable    
{    
RealSubject rs = new RealSubject(); //在这里指定被代理类    
InvocationHandler ds = new DynamicSubject(rs); //初始化代理类    
Class cls = rs.getClass();    
   
//以下是分解步骤    
/*   
Class c = Proxy.getProxyClass(cls.getClassLoader(),cls.getInterfaces()) ;   
Constructor ct=c.getConstructor(new Class[]{InvocationHandler.class});   
Subject subject =(Subject) ct.newInstance(new Object[]{ds});   
*/   
   
//以下是一次性生成    
Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(),    
cls.getInterfaces(),ds );    
subject.request();    
} 
  
通过这种方式,被代理的对象(RealSubject)可以在运行时动态改变,需要控制的接口(Subject接口)可以在运行时改变,控制的方式(DynamicSubject类)也可以动态改变,从而实现了非常灵活的动态代理关系.

下面再来补充一下
1、InvocationHandler原理分析
Collection proxy3 = (Collection)Proxy.newProxyInstance(
				Collection.class.getClassLoader(),
				new Class[]{Collection.class}, 
				new InvocationHandler(){
					ArrayList target = new ArrayList();
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						long startTime = System.currentTimeMillis();
						Object retVal = method.invoke(target, args);
						long endTime = System.currentTimeMillis();
						System.out.println(method.getName()+":runtime is "+(endTime-startTime));
						return retVal;
					}
					
				});
System.out.println(proxy3.getClass().getName()); 


我们说如果我们调用代理类的一个方法,他会交给InvocationHandler的invoke方法去执行 返回的结果也是目标对象调用方法后的返回结果,那对于代理对象:
System.out.println(proxy3.getClass().getName()); 按照我们上面的理论,调用代理对象方法的时候会返回真实对象的返回结果,那应该是java.util.ArrayList
为什么会是$proxy0呢?
原因是调用代理对象的从Object继承的hashCode()  equals()  toString()这几个方法的时候才会把调用请求转发给InvocationHandler对象,而对于其他的方法
有自己的实现,所以getClass().getName()返回的是$proxy0


2、动态代理的工作原理图
(1)、客户端调用代理,代理的构造方法接受一个handler对象,客户端调用代理的各个方法,代理各个方法会把各个方法请求交给handler对象,这个handler对象又把各个请求分发给目标的相应方法



(2)、把嵌套在代理中的一些业务逻辑方法(log()方法)抽取出来,将动态代理中的“切面”问题封装到一个类中,而不要硬编码到动态代理类中,动态代理类中的target
要改成Object,以便让他更有通用性
(1)切面问题接口定义
	public interface Advice {
		public void beforeMethod(Method method);
		public void afterMethod(Method method);
	}
	(2)切面问题的具体实现
	public class MyAdvice implements Advice {
		long beginTime;
		public void afterMethod(Method method) {
			System.out.println("方法执行之后:");
			long endTime = System.currentTimeMillis();
			System.out.println(method.getName() + "方法运行时间为" + (beginTime - endTime));
			
		}

		public void beforeMethod(Method method) {
			System.out.println("方法执行之前:");
			beginTime = System.currentTimeMillis();
		}
	}
	(3)动态代理方法的封装
	private static Object getProxy(final Object target, final Advice advice) {
		Object proxy = Proxy.newProxyInstance(
						target.getClass().getClassLoader(), 
						target.getClass().getInterfaces(),
						new InvocationHandler() {
							public Object invoke(Object proxy, Method method, Object[] args)
									throws Throwable {
								
	//在方法执行之前插入自己的业务逻辑				advice.beforeMethod(method);
								Object retVal = method.invoke(target, args);
	//在方法执行之前插入自己的业务逻辑				advice.afterMethod(method);
								return retVal;
							}
						}
		);
		return proxy;
	}
	(4)测试运行
		ArrayList target = new ArrayList();
		Collection proxy = (Collection)getProxy(target, new MyAdvice());
		proxy.add("abc");


3、实现类似Spring可配置的Aop框架:

通过读取配置文件中配置。来实例化一个Bean,根据所读取到配置信息,来确认返回的是真实的一个对象,还是一个代理对象,如果我传递的这个类是个ProxyFactory类型的一个类(instanceof)则返回该类的一个代理对象,否则直接返回所指定类的一个真实的对象。在这里我创建了两个类,BeanFactory类和ProxyFactoryBean类(在这里就写个类而不去接口了,在spring中是由一个接口和实现类完成的),好了,下面把代码贴一下:

/**
 * Bean工厂
 * @author lzh
 */
public class BeanFactory {

	Properties pros = new Properties();
	public BeanFactory(){	}
	/**
	 * 通过构造方法获取配置文件中信息
	 * @param is 输入流
	 */
	public BeanFactory(InputStream is){
		try {
			pros.load(is);//读取文件信息
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	/**
	 * 得到bean的实例化对象
	 * @param name bean的名称
	 * @return  bean实例对象
	 */
	public Object getBean(String name){
		//通过配置文件得到对应的bean名称(name)所对应key的值
		String className = pros.getProperty(name);
		Object bean = null;
		try {
			//通过反射得到对应的class字节码
			Class clazz = Class.forName(className);
			bean = clazz.newInstance();//创建该字节码的实例
		} catch (Exception e) {
			e.printStackTrace();
		}
		//如果创建的这个对象是一个ProxyFactoryBean类型的,就返回代理对象,否则返回真实的对象   
		if (bean instanceof ProxyFactoryBean) {
			
			ProxyFactoryBean proxyFactoryBean = (ProxyFactoryBean) bean;
			
			Advice advice = null;
			Object target = null;
			try {
				//通过配置文件中读取对应名称的class字节码的实例(自己增加的业务逻辑和目标实例)
				advice = (Advice)Class.forName(pros.getProperty(name+".advice")).newInstance();
				target = Class.forName(pros.getProperty(name+".target")).newInstance();
			} catch (Exception e) {
				e.printStackTrace();
			}
			//将创建的实例对象设置给ProxyFactoryBean
			proxyFactoryBean.setAdvice(advice);
			proxyFactoryBean.setTarget(target);
			//调用ProxyFactoryBean类的getProxy(),得到代理实例对象
			Object proxy = proxyFactoryBean.getProxy();
			return proxy;
		}
		
		return bean;
	}
	
}

ProxyFactoryBean 类
/**
 * 充当生成代理的工厂
 * @author lzh
 *	需要为代理工厂提供目标对象和业务逻辑对象
 */
public class ProxyFactoryBean {
	
	private Advice advice;
	private Object target;
	
	public Advice getAdvice() {
		return advice;
	}

	public void setAdvice(Advice advice) {
		this.advice = advice;
	}

	public Object getTarget() {
		return target;
	}

	public void setTarget(Object target) {
		this.target = target;
	}

	/**
	 * 得到代理对象
	 * @return
	 */
	public Object getProxy() {
		Object proxy3 = Proxy.newProxyInstance(
				target.getClass().getClassLoader(),
				target.getClass().getInterfaces(),
				new InvocationHandler(){
					
					public Object invoke(Object proxy, Method method,
							Object[] args) throws Throwable {
						advice.beforMethod(method);
						Object retVal = method.invoke(target, args);
						advice.afterMethod(method);
						return retVal;
					}
					
				});
		return proxy3;
	}
}


测试类:
	public static void main(String[] args) {
		
		InputStream is = AopFrameWorkTest.class.getResourceAsStream("config.properties");
		
		Collection c = (Collection)new BeanFactory(is).getBean("xxx");
		System.out.println(c.getClass().getName());
		//System.out.println(c.size());
		
	}

在测试之前需要说明一下,在我报下面有个配置文件需要加上,不过这里配置文件的位置是和
ProxyFactoryBean类位于同一位置的,下面贴一下配置文件的内容:
xxx=java.util.ArrayList
#xxx=cn.itcast.proxy.aopframework.ProxyFactoryBean
xxx.target=java.util.ArrayList
xxx.advice=cn.itcast.proxy.MyAdvice

以上我对java动态代理的一些小小总结,边整理,边转帖,边学习,呵呵,共同进步!


  • 大小: 49 KB
  • 大小: 15.8 KB
  • 大小: 30.3 KB
分享到:
评论

相关推荐

    对代理模式与Java动态代理类的理解

    对代理模式与Java动态代理类的理解说明

    Java代理模式Java动态代理

    ### Java代理模式与Java动态代理详解 #### 一、代理模式概述 代理模式是一种软件设计模式,它在客户端和目标对象之间提供了一种间接层。这种模式的主要目的是控制客户端对目标对象的访问,并且可以在不修改原有...

    Java设计模式——代理设计模式(静态代理和动态代理)

    动态代理则是在运行时动态生成代理类,不需要提前编写代理类的代码。Java提供了一个内置的机制来实现动态代理,即`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口。 1. **定义接口**:与...

    java中的三种代理模式

    JDK动态代理基于Java反射API,可以在运行时动态地生成代理类和实例。它需要目标对象实现至少一个接口,然后通过`java.lang.reflect.Proxy`类和`java.lang.reflect.InvocationHandler`接口来创建代理对象。...

    java动态代理类的实例

    在Java中,静态代理是通过定义一个与被代理类实现相同接口的新类来实现的,而动态代理则在运行时动态生成此类,无需预先编写代理类的代码。 `java.lang.reflect.Proxy`类是Java动态代理的核心,它提供了创建代理...

    java装饰模式及动态代理模式示例源码

    装饰模式和动态代理模式是Java编程中两种非常重要的设计模式,它们都在代码的扩展性和灵活性方面发挥着关键作用。下面将分别对这两种模式进行详细解释,并结合手写的数据库连接池和动态代理模式的使用进行深入探讨。...

    代理模式java代码 Proxy(5) 2个代理类

    在这个主题“代理模式java代码 Proxy(5) 2个代理类”中,我们可以理解为将介绍两种不同的代理类实现。 1. 静态代理 在静态代理中,我们需要创建一个接口,然后让目标对象和代理对象都实现这个接口。代理类会持有...

    Java 动态代理详解(代理模式+静态代理+JDK动态代理+CGLIB动态代理)

    Java 动态代理详解(代理模式+静态代理+JDK动态代理+CGLIB动态代理) Java 动态代理是 Java 编程语言中的一种强大工具,广泛应用于 Spring AOP、Hibernate 数据查询、测试框架的后端 mock、RPC 远程调用、Java 注解...

    java + 动态代理 + 动态代理实际应用场景

    2: 动态代理demo 举例实际应用场景(载入数据库驱动的时候,使用AIDL与系统Servic进行通信) 3: 动态代理使用到基础理论:ClassLoader 加载.class字节码文件得到 , Class对象, Class对象通过 newProxyInstance ...

    用Java实现的代理模式之动态代理

    在Java中,代理模式有静态代理和动态代理两种实现方式。本篇将重点讨论"动态代理",这是一种在运行时创建代理对象的技术,使得我们可以在程序运行过程中,根据需要动态地生成具有额外功能的代理类。 动态代理主要由...

    java静态代理、动态代理、装饰设计模式

    在Java编程中,代理模式是一种常见的设计模式,它允许我们为一个对象提供一个代理以控制对这个对象的访问。代理模式通常用于增加额外的功能或在访问原对象时进行额外的操作,比如日志记录、安全控制、性能统计等。...

    Java 静态代理模式

    静态代理模式是一种结构型设计模式,其核心思想是通过创建一个代理类,这个代理类作为原对象的替代,提供与原对象相同的方法调用,但可以在调用前后添加额外的操作。这种模式在不修改原始对象代码的情况下,可以用于...

    Java设计模式-代理模式例子

    1. 静态代理:在编译时就已经确定了代理类与目标类的关系。通常,代理类会实现和目标类相同的接口,以便于在代理类中调用目标类的方法。这种方式的缺点是如果目标类数量多或接口频繁变动,需要手动维护的代理类也会...

    JAVA设计模式之代理模式实例

    在本实例中,我们将深入探讨Java中的代理模式及其应用。 代理模式的核心思想是为一个对象创建一个代理对象,这个代理对象在客户端和目标对象之间起到中介的作用。它可以控制目标对象的访问,也可以在调用目标对象的...

    java 动态代理模式 适配器模式

    Java动态代理模式与适配器模式是两种在软件设计中常用的设计模式,它们都有各自的优点和应用场景。在Java中,动态代理模式主要依赖于Java的反射API和InvocationHandler接口,而适配器模式则用于解决不同接口之间的...

    java动态代理实例

    Java动态代理是Java语言提供的一种在运行时创建代理对象的技术,它允许我们为已存在的接口创建代理类,以便在调用真实目标对象的方法时添加额外的功能或行为。在这个实例中,我们将深入探讨Java动态代理的核心概念,...

    Java静态代理与动态代理demo

    Java提供了两种实现代理模式的方式:静态代理和动态代理。 **静态代理** 静态代理是在编译时就已经确定了代理类,通过继承或实现目标接口来创建代理类。以下是一个简单的静态代理实现示例: ```java // 目标接口 ...

    JAVA设计模式(代理模式)

    了解并熟练掌握代理模式,对于提高Java开发中的设计质量与可维护性具有重要意义。在实践中,应根据具体需求选择合适的代理实现方式,以达到最佳的设计效果。通过学习和实践,开发者可以更好地理解和运用这一模式,...

    java代理模式

    在Java中,代理模式主要有静态代理和动态代理两种实现方式。 一、静态代理 静态代理是在编译时就已经确定了代理关系。代理类和目标类需要实现相同的接口,这样代理类就可以持有目标类的引用,并在调用目标类方法...

    Java中的代理模式Demo

    1. 静态代理:静态代理是通过程序员手动创建一个代理类,这个代理类实现了与目标类相同的接口,然后在代理类的方法中调用目标类的相应方法。这种方式的优点是代码清晰,缺点是如果目标类接口增加,代理类也需要相应...

Global site tag (gtag.js) - Google Analytics