JAVA设计模式之代理模式

【代理模式应用场景举例】

比如在玩“极品飞车”这款游戏，如果游戏者手中的金钱达到了一定的数量就可以到车店买一部性能更高的赛车，那么这个卖车的“车店”就是一个典型的“汽车厂家”的“代理”，他为汽车厂家“提供卖车的服务”给有需求的人士。从面向对象的方面考虑，“销售汽车的代理”也是一个对象，那么这个对象也具有一定的状态，在软件项目中这个对象也具有管理财务进销存的基本功能，那么在设计时就要以面向OOP编程的思想来考虑软件的类结构，这个销售汽车的代理也是一个类了。

【代理模式解释】

类型：结构模式

对一些对象提供代理，以限制那些对象去访问其它对象。

【代理模式-Java代码实现】

新建一个买车的接口：

[java] view plain copy

print ?

1. public interface buy_car {  
2.   public void buy_mycar();  
3. }  

public interface buy_car {
  public void buy_mycar();
}

 

新建一个people人类，具有买车的行为，所以实现接口buy_car

[java] view plain copy

print ?

1. class people implements buy_car {  
2.    
3.    private int cash;  
4.    private String vip;  
5.    private String username;  
6.     
7.  @Override  
8.  public void buy_mycar() {  
9.   // TODO Auto-generated method stub  
10.   System.out.print(username+"是vip 客户，可以直接购买新车！");  
11.  }  
12.   
13. public int getCash(){  
14.       return cash;  
15.    }  
16.    public void setCash(int cash){  
17.        this.cash = cash;  
18.     }  
19.    public String getUsername(){  
20.        return username;  
21.     }  
22.    public void setUsername(String username){  
23.        this.username = username;  
24.     }  
25.    public String getVip(){  
26.        return vip;  
27.     }  
28.    public void setVip(String vip){  
29.         this.vip = vip;  
30.    }  
31. }  

class people implements buy_car {
 
   private int cash;
   private String vip;
   private String username;
  
 @Override
 public void buy_mycar() {
  // TODO Auto-generated method stub
  System.out.print(username+"是vip 客户，可以直接购买新车！");
 }

public int getCash(){
      return cash;
   }
   public void setCash(int cash){
       this.cash = cash;
    }
   public String getUsername(){
       return username;
    }
   public void setUsername(String username){
       this.username = username;
    }
   public String getVip(){
       return vip;
    }
   public void setVip(String vip){
        this.vip = vip;
   }
}

people类不能拥有车，必须经过proxy代理类的认证，符合条件之后才可以拥有车辆，新建一个代理，这个代理类来考察当前的people是否有资格进行买车：

[java] view plain copy

print ?

1. class proxyclass implements buy_car {  
2.      
3.     private people people;  
4.     public people getPeople(){  
5.      return people;  
6.     }  
7.     public void setPeople(people people){  
8.      this.people = people;  
9.     }  
10.       
11.  @Override  
12.  public void buy_mycar() {  
13.   // TODO Auto-generated method stub  
14.     
15.   if (people.getVip() == "vip"){  
16.       people.buy_mycar();  
17.       return ;  
18.      }   
19.     if(people.getCash()>=50000){  
20.      System.out.println(people.getUsername()+"买了新车，交易结束！");  
21.     }  
22.     else  
23.     {  
24.      System.out.println(people.getUsername()+"钱不够，不能买车，继续比赛！");  
25.     }  
26.  }  
27. }  

class proxyclass implements buy_car {
   
    private people people;
    public people getPeople(){
     return people;
    }
    public void setPeople(people people){
     this.people = people;
    }
    
 @Override
 public void buy_mycar() {
  // TODO Auto-generated method stub
  
  if (people.getVip() == "vip"){
      people.buy_mycar();
      return ;
     } 
    if(people.getCash()>=50000){
     System.out.println(people.getUsername()+"买了新车，交易结束！");
    }
    else
    {
     System.out.println(people.getUsername()+"钱不够，不能买车，继续比赛！");
    }
 }
}

最后创建一个客户端，用来模拟买车的行为：

[java] view plain copy

print ?

1. public class run_main {  
2.   
3.   
4.  public static void main(String[] args) {  
5.   // TODO Auto-generated method stub  
6.       people people_1 =new people();  
7.       people_1.setCash(60000);  
8.       people_1.setUsername("jeck");  
9.   
10.   
11.       people people_2 =new people();  
12.       people_2.setCash(40000);  
13.       people_2.setUsername("rose");  
14.        
15.       people people_3 =new people();  
16.   
17.       people_3.setCash(0);  
18.       people_3.setUsername("tom");  
19.       people_3.setVip("vip");  
20.        
21.       proxyclass proxy_buy = new proxyclass();  
22.       proxy_buy.setPeople(people_1);  
23.       proxy_buy.buy_mycar();  
24.        
25.       proxy_buy.setPeople(people_2);  
26.       proxy_buy.buy_mycar();  
27.        
28.       proxy_buy.setPeople(people_3);  
29.       proxy_buy.buy_mycar();  
30.              
31.  }  
32.   
33. }  

public class run_main {


 public static void main(String[] args) {
  // TODO Auto-generated method stub
      people people_1 =new people();
      people_1.setCash(60000);
      people_1.setUsername("jeck");


      people people_2 =new people();
      people_2.setCash(40000);
      people_2.setUsername("rose");
     
      people people_3 =new people();

      people_3.setCash(0);
      people_3.setUsername("tom");
      people_3.setVip("vip");
     
      proxyclass proxy_buy = new proxyclass();
      proxy_buy.setPeople(people_1);
      proxy_buy.buy_mycar();
     
      proxy_buy.setPeople(people_2);
      proxy_buy.buy_mycar();
     
      proxy_buy.setPeople(people_3);
      proxy_buy.buy_mycar();
           
 }

}

程序运行结果如下：

[java] view plain copy

print ?

1. jeck买了新车，交易结束！  
2. rose钱不够，不能买车，继续比赛！  
3. tom是vip 客户，可以直接购买新车！  

 jeck买了新车，交易结束！
 rose钱不够，不能买车，继续比赛！
 tom是vip 客户，可以直接购买新车！

 

代理模式主要使用了java的多态，干活的是被代理类，代理类主要是接活，你让我干活，好，我交给幕后的类去干，你满意就成，那怎么知道被代理类能不能干呢？同根就成，大家知根知底，你能做啥，我能做啥都清楚得很，同样一个接口。

作者：jason0539

微博：http://weibo.com/2553717707

博客：http://blog.csdn.net/jason0539（转载请说明出处）