代理模式和动态代理

最新推荐文章于 2024-10-04 21:33:42 发布

原创最新推荐文章于 2024-10-04 21:33:42 发布 · 510 阅读

0 ·

CC 4.0 BY-SA版权

java笔记专栏收录该内容

6 篇文章

订阅专栏

代理模式的作用是：为其他对象提供一种代理以控制对这个对象的访问。

在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用

代理模式一般涉及到的角色有：

1、抽象角色：声明真实对象和代理对象的共同接口

2、代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同

的接口以便在任何时刻都能代替真实对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真

实对象进行封装

3、真实角色：代理角色所代表的真实对象，是我们最终要引用的对象

例如：

Subject.java

public abstract class Subject {

	public abstract void request();
	
}

RealSubject.java

public class RealSubject extends Subject {

	public void request() {
		System.out.println("From real subject.");

	}

}

ProxySubject.java

public class ProxySubject extends Subject {
	
	private RealSubject realSubject;//代理角色内部引用了真实角色
	

	public void request() {
		
		this.preRequest();//在真实角色操作之前所附加的操作
		
		if(null == realSubject){
			realSubject = new RealSubject();
		}
		
		realSubject.request();//真实角色所完的事情
		
		this.postRequest();//在真实角色之后所附加的操作

	}
	
	private void preRequest(){
		System.out.println("pre request");
	}
	
	private void postRequest(){
		System.out.println("post request");
	}

}

Client.java

public class Client {

	public static void main(String[] args) {
		Subject subject = new ProxySubject();
		subject.request();
	}

}

运行Client.java，打印出：

pre request
From real subject.
post request

由以上代码可以看出，客户实际需要调用的是RealSubject类的request()方法，现在用ProxySubject来代理 RealSubject类，

同样达到目的，同时还封装了其他方法(preRequest(),postRequest())，可以处理一些其他问题。

RealSubject和ProxySubject都继承了Subject

可以理解为：Subject是租房子，RealSubject是房主，ProxySubject是中介，client客户无法与房主直接沟通，通过中介联系，

中介还可以完成收中介费等自己的方法。

如果要按照上述的方法使用代理模式，那么真实角色必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，

一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色，该如何使用代理呢？

这个问题可以通过Java的动态代理类来解决。

以上是抽象类实现，以下必须是接口实现。

动态代理类（Dynamic Proxy）：

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

(1)Interface InvocationHandler

该接口中仅定义了一个方法

• public object invoke(Object obj,Method method, Object[] args)

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

这个抽象方法在代理类中动态实现。
(2)Proxy

该类即为动态代理类，作用类似于上例中的 ProxySubject，其中主要包含以下内容

• protected Proxy(InvocationHandler h)：构造函数，用于给内部的h赋值。
• static Class getProxyClass (ClassLoader loader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，

interfaces是真实类所拥有的全部接口的数组。
• static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)：

返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法 )

loader 是定义代理类的类加载器，interfaces 是代理类要实现的接口列表，h 是指派方法调用的调用处理程序

所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class 就宣称

它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然，这个Dynamic Proxy其实就是一个Proxy，

它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

在使用动态代理类时，我们必须实现 InvocationHandler接口，即个个动态代理类有一个与之关联的InvocationHandler

例1：

Subject.java

public interface Subject {

	public void request();
}

RealSubject.java

public class RealSubject implements Subject {

	public void request() {
		System.out.println("From real subject!");
	}
}

DynamicSubject.java

public class DynamicSubject implements InvocationHandler {

	//该代理类内部属性是Object类型,代理任意一个真实对象,通过该类构造方法传递进一个对象
	private Object sub;
	
	public DynamicSubject(Object obj){
		this.sub = obj;
	}
	
	/**
	 * 实现invoke方法,method.invoke 是 调用被代理对象的将要执行的方法
	 * 方法参数是sub,表示该方法从属于sub,通过动态代理类
	 * 可以在执行真实对象的方法前后加入自己的一些额外的方法
	 */
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("before calling:" + method);
		method.invoke(sub, args);
		System.out.println(args == null);//没有参数则是true
		System.out.println("after calling:" + method);
		return null;
	}

}

Client.java

public class Client {
	public static void main(String[] args) {
		RealSubject realSubject = new RealSubject();
		
		InvocationHandler handler = new DynamicSubject(realSubject);
		
		Class<?> classType = handler.getClass();
		
		//下面的代码一次性生成代理
		//运行期间动态生成一个class类(如：$Proxy0),并生成一个class类对象
                //转换成接口类型,不要转换成具体的实现类类型,并不知道具体的哪些实现类

                Subject subject = (Subject) Proxy.newProxyInstance(
				classType.getClassLoader(), realSubject.getClass().getInterfaces(), handler);
		
		subject.request();//调用方法,可以传参数,传给args
		System.out.println(subject.getClass());
	}
}

运行Client.java，打印出：

before calling:public abstract void com.dynamicproxy.Subject.request()
From real subject!
true
after calling:public abstract void com.dynamicproxy.Subject.request()
class $Proxy0

通过这种方式，被代理的对象 (RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，

控制的方式(DynamicSubject类) 也可以动态改变，从而实现了非常灵活的动态代理关系

动态代理是指客户通过代理类来调用其它对象的方法

动态代理使用场合:

调试

远程方法调用(RMI)

动态代理步骤：

1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法

2.创建被代理的类以及接口

3.通过Proxy的静态方法 newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个代理

4.通过代理调用方法

例2：

VectorProxy.java

public class VectorProxy implements InvocationHandler {

	private Object proxyObj;
	
	public VectorProxy(Object obj){
		this.proxyObj = obj;
	}
	
	//生成obj的代理对象
	public static Object factory(Object obj){
		Class<?> classType = obj.getClass();
		
		return Proxy.newProxyInstance(classType.getClassLoader(),
				classType.getInterfaces(), new VectorProxy(obj));
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("before calling:" + method);
		
		if(null!=args){
			for(Object obj:args){
				System.out.println(obj);//看看传来的参数是什么
			}
		}
		
		Object object = method.invoke(proxyObj, args);
		
		System.out.println("after calling:" + method);

		return object;
	}

        public static void main(String[] args) {
		//Vector实现了List接口,v是运行时动态生成的一个类的实例,不是ArrayList和LinkedList的实例
		List v = (List)factory(new Vector());
		
		System.out.println(v.getClass().getName());
		
		v.add("New");//add方法返回类型为boolean 
		v.add("York");
                
                System.out.println(v);//打印v,调用toString,转到invoke方法
    
                v.remove(0);
                System.out.println(v);
        }

}

运行VectorProxy.java，打印出：

$Proxy0
before calling:public abstract boolean java.util.List.add(java.lang.Object)
New
after calling:public abstract boolean java.util.List.add(java.lang.Object)
before calling:public abstract boolean java.util.List.add(java.lang.Object)
York
after calling:public abstract boolean java.util.List.add(java.lang.Object)
before calling:public java.lang.String java.lang.Object.toString()
after calling:public java.lang.String java.lang.Object.toString()
[New, York]
before calling:public abstract java.lang.Object java.util.List.remove(int)
0
after calling:public abstract java.lang.Object java.util.List.remove(int)
before calling:public java.lang.String java.lang.Object.toString()
after calling:public java.lang.String java.lang.Object.toString()
[York]

例3：

Foo.java

public interface Foo {
	public void doAction();
}

FooImpl.java

public class FooImpl implements Foo {

	public void doAction() {
		System.out.println("in FooImpl doAction!");
	}

}

FooImpl2.java

public class FooImpl2 implements Foo {

	public void doAction() {
		System.out.println("in FooImpl2 doAction!");
	}

}

CommonInvocationHandler.java

public class CommonInvocationHandler implements InvocationHandler {

	private Object target;
	
	public CommonInvocationHandler(Object target){
		this.target = target;
	}
	
	public CommonInvocationHandler(){

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

	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		
		return method.invoke(target, args);
	}

}

Demo.java

public class Demo {

	public static void main(String[] args) {
		CommonInvocationHandler handler = new CommonInvocationHandler();
	
		Foo f = null;
		
		handler.setTarget(new FooImpl());
		
		f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
				new Class[] { Foo.class }, handler);
	
		f.doAction();
		
		System.out.println("--------------------");
		
		handler.setTarget(new FooImpl2());
		
		f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
				new Class[] { Foo.class }, handler);
		
		f.doAction();
	}
	
}

运行Demo.java，打印出：

in FooImpl doAction!
--------------------
in FooImpl2 doAction!