常用的设计模式之代理模式

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

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

我们可以举个列子：

你想请某个领导干件事，可能你不能直接的联系领导，你可以通过领导的秘书，在让秘书把你完成具体的操作。

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

抽象角色：声明真实对象和代理对象的公共的接口。

代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何的时刻能代替真实的对象。同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。

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

简单的静态代理：

 

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


class RealSubject extends Subject {
    @Override
    public void request() {
        System.out.println("来自于真实的对象");
    }
}

class ProxySubject extends Subject {
    private Subject subject;
    
    public ProxySubject () {
        
    }
    
    private void doAnothing () {
        System.out.println("收取一定的手续费");
    }
    public Subject getSubject() {
        return subject;
    }

    public void setSubject(Subject subject) {
        this.doAnothing();
        this.subject = subject;
    }

    @Override
    public void request() {
        this.subject.request();
    }
}

public class Test {
    public static void main(String[] args) {
        RealSubject subject = new RealSubject ();
        ProxySubject proxy = new ProxySubject ();
        proxy.setSubject(subject);
        proxy.request();
    }
}

静态代理的缺点：
使用静态代理，那么真实对象必须事先应经存在的，并将其作为代理对象的内部属性，
当是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；
此外，如果事先并不知道真实角色，该如何代理呢？可以使用动态代理解决。
Java动态代理类位于java.lang.reflect包下，一般主要
涉及到以下两个类：
• (1)Interface InvocationHandler：该接口中仅定义了
一个方法
– public object invoke(Object obj,Method method, 
Object[] args)
• 在实际使用时，第一个参数obj一般是指代理类，
method是被代理的方法，如上例中的request()，args
为该方法的参数数组。这个抽象方法在代理类中动态实
现。
(2)Proxy：该类即为动态代理类，作用类似于上例中的
ProxySubject，其中主要包含以下内容

static Object newProxyInstance(ClassLoader 
loader, Class[] interfaces, InvocationHandler h)：
返回代理类的一个实例，返回后的代理类可以当作被代理
类使用(可使用被代理类的在Subject接口中声明过的方法
)
所谓Dynamic Proxy是这样一种class：
它是在运行时生成的class，在生成它时你
必须提供一组interface给它，然后该class
就宣称它实现了这些interface。你当然可
以把该class的实例当作这些interface中的
任何一个来用。当然，这个Dynamic 
Proxy其实就是一个Proxy，它不会替你作
实质性的工作，在生成它的实例时你必须
提供一个handler，由它接管实际的工作
在使用动态代理类时，我们必须实现
InvocationHandler接口





package com.zl.dynamicProxy;

public interface Subject {
	public void request ();
}

package com.zl.dynamicProxy;



public class RealSubject implements Subject{

	@Override
	public void request() {
		System.out.println("From The Real Subject");
	}
}
package com.zl.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyHandler implements InvocationHandler{

	private Object ob;
	
	public MyHandler(Object ob) {
		// TODO Auto-generated constructor stub
		this.ob = ob;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("doBefore");
		method.invoke(ob, new Object[]{});
		System.out.println("doAfter");
		return null;
	}
	
}


package com.zl.dynamicProxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class Test {
	public static void main(String[] args) {
		Subject realSubject = new RealSubject();
		InvocationHandler handler = new MyHandler(realSubject);
		
		Subject proxy = (Subject)Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),realSubject.getClass().getInterfaces(), handler);
		proxy.request();
		
	}
}

在struts2和spring3.x中都是使用了动态代理技术