设计模式学习五、代理模式

一、什么是代理模式？

                  为另一个对象提供一个替身或一个占位符以控制对这个对象的访问。

二、 代理模式各种变体。

         远程代理：使得客户端可以访问在远程主机的角色（两个程序不在同一个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内置的代理支持，可以根据需要创建动态代理。并将所有调用分配到所选的处理器。

 

转载于:https://www.cnblogs.com/GregZQ/p/8365280.html