设计模式笔记15：代理模式（Proxy Pattern）

一、代理模式的内容

要点

二、 代理的种类

三、代理模式的结构

四、代理模式示例代码

public interface AbstractPermission
{
public void modifyUserInfo();
public void viewNote();
public void publishNote();
public void modifyNote();
public void setLevel(int level);
}

public class RealPermission implements AbstractPermission
{
public void modifyUserInfo()
{
System.out.println("修改用户信息！");
}

public void viewNote()
{   }

public void publishNote()
{
System.out.println("发布新帖！");
}

public void modifyNote()
{
System.out.println("修改发帖内容！");
}

public void setLevel(int level)
{	}
}

public class PermissionProxy implements AbstractPermission
{
private RealPermission permission=new RealPermission();
private int level=0;

public void modifyUserInfo()
{
if(0==level)
{
System.out.println("对不起，你没有该权限!");
}
else if(1==level)
{
permission.modifyUserInfo();
}
}

public void viewNote()
{
System.out.println("查看帖子！");
}

public void publishNote()
{
if(0==level)
{
System.out.println("对不起，你没有该权限!");
}
else if(1==level)
{
permission.publishNote();
}
}

public void modifyNote()
{
if(0==level)
{
System.out.println("对不起，你没有该权限!");
}
else if(1==level)
{
permission.modifyNote();
}
}

public void setLevel(int level)
{
this.level=level;
}
}

<?xml version="1.0"?>
<config>
<className>PermissionProxy</className>
</config>

import javax.xml.parsers.*;
import org.w3c.dom.*;
import org.xml.sax.SAXException;
import java.io.*;
public class XMLUtil
{
//该方法用于从XML配置文件中提取具体类类名，并返回一个实例对象
public static Object getBean()
{
try
{
//创建文档对象
DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;
doc = builder.parse(new File("config.xml"));

//获取包含类名的文本节点
NodeList nl = doc.getElementsByTagName("className");
Node classNode=nl.item(0).getFirstChild();
String cName=classNode.getNodeValue();

//通过类名生成实例对象并将其返回
Class c=Class.forName(cName);
Object obj=c.newInstance();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
return null;
}
}
}

public class Client
{
public static void main(String args[])
{
AbstractPermission permission;
permission=(AbstractPermission)XMLUtil.getBean();

permission.modifyUserInfo();
permission.viewNote();
permission.publishNote();
permission.modifyNote();
System.out.println("----------------------------");
permission.setLevel(1);
permission.modifyUserInfo();
permission.viewNote();
permission.publishNote();
permission.modifyNote();
}
}

public interface AbstractSubject
{
public void request();
}

public class RealSubjectA implements AbstractSubject
{
public void request()
{
System.out.println("真实主题类A！");
}
}

public class RealSubjectB implements AbstractSubject
{
public void request()
{
System.out.println("真实主题类B！");
}
}

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

public class DynamicProxy implements InvocationHandler
{
private Object obj;

public DynamicProxy(){}

public DynamicProxy(Object obj)
{
this.obj=obj;
}

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
{
preRequest();
method.invoke(obj, args);
postRequest();
return null;
}

public void preRequest(){
System.out.println("调用之前！");
}

public void postRequest(){
System.out.println("调用之后！");
}

}

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

public class Client
{
public static void main(String args[])
{
InvocationHandler handler =null;
AbstractSubject subject=null;

handler=new DynamicProxy(new RealSubjectA());
subject=(AbstractSubject)Proxy.newProxyInstance(AbstractSubject.class.getClassLoader(), new Class[]{AbstractSubject.class}, handler);
subject.request();

System.out.println("------------------------------");

handler=new DynamicProxy(new RealSubjectB());
subject=(AbstractSubject)Proxy.newProxyInstance(AbstractSubject.class.getClassLoader(), new Class[]{AbstractSubject.class}, handler);
subject.request();
}
}

五、几种常用的代理模式

六、代理模式优缺点

七、代理模式适用环境

八、代理模式应用

Proxy (recognizeable
by creational methods which returns an implementation of given abstract/interface type which in turn delegates/uses a different implementation
of given abstract/interface type)

java.lang.reflect.Proxy

java.rmi.*

九、参考资料