设计模式学习五、代理模式
一、什么是代理模式？
为另一个对象提供一个替身或一个占位符以控制对这个对象的访问。
二、 代理模式各种变体。
远程代理：使得客户端可以访问在远程主机的角色（两个程序不在同一个jvm虚拟机）。
虚拟代理：当创建开销大的对象的时候，真正需要这个对象才创建它，当对象在创建前与创建中时候，由虚拟代理扮演对象替身的角色
保护代理：主要用于当前对象有不同访问权限时。（通过java的动态代理实现）
三、代理模式组成
抽象角色：代理类与真实类实现的共同的接口
真实角色：实现接口的功能。是真正做事的对象
代理角色：持有真实角色的引用，控制对真实角色的访问。
客户与真实角色的访问必须通过代理角色。任何出现真实角色的地方都可以被代理角色所替代。
四、具体实现
先说一下远程代理：
远程代理实现方式（rmi）：
问题：有一家糖果机公司，CEO希望能写一个程序在远程查询糖果机中糖果的数量（ps：也就是查看数量的客户端与糖果机系统运行的服务端不在同一个JVM下）
首先，制作远程接口：注意：每一个方法都必须要抛出RemoteException异常。
//糖果机监视器，继承Remote接口。里面包含了需要的查询糖果数量的方法。
public interface SugerMachineMoniter extends Remote{
public Integer getCount() throws RemoteException;
}
然后，编写服务端，服务端继承UnicastRemoteObject类，并实现SugerMachineMoniter接口
public class SugerMachine extends UnicastRemoteObject implements SugerMachineMoniter{
private Integer count;
protected SugerMachine(int count) throws RemoteException {
super();
this.count=count;
}
@Override
public Integer getCount() throws RemoteException{
return count;
}
}
将编写的服务端注册到rmi服务器，供远程客户端调用。
public class Server {
public static void main(String args[]){
try {
LocateRegistry.createRegistry(8888);//注册远程用户访问的端口
SugerMachine sugerMachine=new SugerMachine(50);
Naming.rebind("myServer", sugerMachine);//注册到rmi服务器上，访问的话就通过 rmi://服务器地址/注册名（这里是myServer）
} catch (RemoteException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
远程客户端调用：
public class Client {
public static void main(String args[]) throws MalformedURLException, RemoteException, NotBoundException{
SugerMachineMoniter sugerMachineMoniter=(SugerMachineMoniter) Naming.lookup("rmi://127.0.0.1:8888/myServer");
System.out.println(sugerMachineMoniter.getCount());
}
}
分析：这里面如何用到代理的？（详细的搜一下rmi的详解）
这需要查看一下rmi的运行过程，客户端调用的对象（也就是SugerMachineMoniter），其实是调用的服务器端生成的远程对象的本地代理（Stub）。我们在客户端调用的时候，每调用一个方法，客户端的代理对象（stub）把信息打包发送给服务端，服务端解包并调用真正的服务端的代码。服务端代码再把反悔信息打包返回给客户端的代理（Stub）,所以看起来就像是调用真正的对象。
再说一下保护代理（通过Java动态代理实现）：
具体问题：有一个交友网站上传个人信息资料，包括三部分（姓名，年龄，热门程度）。本人无法修改热门程度可以修改其他，其他人可以修改这个人的热门程度不可以修改其他（，，，，假装这样做是对的，，，）。
分析:这时候你需要创建两个动态代理，一个用于保护本人修改信息的时候不能修改热门程度，其他人修改这个人信息时候只能修改热门程度。
具体代码：
首先：创建需要修改的Person对象：
public interface PersonBean {//这是一个接口
public void setName(String name);
public void setAge(int age);
public void setRate(int value);
public String getName();
public int getAge();
public int getRate();
}
public class PersonBeanImpl implements PersonBean {//具体实现类
private String name;//其他人不能修改name
private int age;//其他人不能修改age
private int rate;//本人不能修改rate
@Override
public void setName(String name) {
this.name=name;
}
@Override
public void setAge(int age) {
this.age=age;
}
@Override
public void setRate(int value) {
this.rate=value;
}
@Override
public String getName() {
return name;
}
@Override
public int getAge() {
return age;
}
@Override
public int getRate() {
return rate;
}
}
创建两个InvocationHandler：
public class OwnerInvocationHandler implements InvocationHandler {//所调用的处理器都必须实现这个接口
private PersonBean personBean;
public OwnerInvocationHandler(PersonBean personBean){//将personBean引入保持对它的引用
this.personBean=personBean;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//每次调用personBean方法的时候，都是调用的它
if (method.getName().contains("get")){
return method.invoke(personBean,args);
}else if (method.getName().equals("setRate")){//对于自己，不能修改rate
throw new UnsupportedOperationException("不支持此项操作");
}else {
return method.invoke(personBean,args);
}
}
}
public class NoInvocationHandler implements InvocationHandler {
private PersonBean personBean;
public NoInvocationHandler(PersonBean personBean){
this.personBean=personBean;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Exception {
if (method.getName().contains("get")) {
return method.invoke(personBean,args);
}else if (method.getName().equals("setRate")){
return method.invoke(personBean,args);
}else { //对于别人，不能修改name与age
throw new Exception("不支持此项操作");
}
}
}
创建Proxy并实例化Proxy对象：我用两个方法实现的
public static PersonBean getOwnerInvocation(PersonBean personBean){
return (PersonBean) Proxy.newProxyInstance(personBean.getClass().getClassLoader(),//利用Proxy的静态方法创建代理，需要的参数：需要动态代理
personBean.getClass().getInterfaces(), //的对象的classLoader，所实现的接口，需要调用的invocationhandler
new OwnerInvocationHandler(personBean));
}
public static PersonBean getNoInvocation(PersonBean personBean){
return (PersonBean) Proxy.newProxyInstance(personBean.getClass().getClassLoader(),
personBean.getClass().getInterfaces(),
new NoInvocationHandler(personBean));
}
使用：
PersonBean personBean=new PersonBeanImpl();
personBean.setName("luck");
personBean.setAge(12);
personBean.setRate(6);
PersonBean ownerPerson = getOwnerInvocation(personBean);
try {
ownerPerson.setRate(8);
}catch (Exception e){
System.out.println("这项操作不支持");
}
System.out.println(ownerPerson.getName()+","+ownerPerson.getRate()+","+
ownerPerson.getAge());
PersonBean otherPerson=getNoInvocation(personBean);
try{
otherPerson.setAge(10);
}catch (Exception e){
System.out.println("不支持此方法");
}
otherPerson.setRate(10);
System.out.println(otherPerson.getName()+"."+otherPerson.getAge()+","+otherPerson.getRate());
}
输出：
这项操作不支持 luck,6,12 不支持 luck.12,10
ps:动态代理之所以称为动态代理，在系统运行时候它才创建出来。
五、总结：
一、代理模式作为一个代表，以便控制客户对真实对象的访问，控制方式有很多种。
二、远程代理管理客户和远程对象的交互，虚拟代理控制访问实例化开销大的对象，保护代理基于调用者控制对象方法的访问
三、代理在结构上类似装饰者，但是目的不同，装饰者模式为对象加上行为，而代理是控制访问 。
四、Java内置的代理支持，可以根据需要创建动态代理。并将所有调用分配到所选的处理器。
