从公司买火车票到代理模式和适配器模式

Posted 2020-06-27 来晚板面

近期看到一些设计模式的文章，自己也有了些想法。

现公司是个爱出差的公司，不可避免要买许多火车票。这个买票的流程一直在变化。

最开始大家都是自己买火车票，然后回公司的时候报销。

就像这样：

 

public class AtFirst {
      public static void main(String[] args) {
            EmployeeABuy. Abuy();
             //报销
            EmployeeBBuy. Bbuy();
             //报销
 
      }
}
 
class EmployeeABuy{
      public static void Abuy(){
            System. out.println( "A买了一张");
      }
}
 
class EmployeeBBuy{
      public static void Bbuy(){
            System. out.println( "B买了一张");
      }
}

适配器模式

 

后来人越来越多，出差越来越频繁，不仅个人买票多，总体买票也很多，于是，大家商量应该改进一下：火车票由公司购买，员工向公司行政申请，但是行政部很忙，通常就让员工所在部门购买，最后就是行政部买行政部的票，研发部买研发部的票，但是我们只是向行政部要票，传入自己的名字就可以了。反映在程序中就是行政部作为一个适配器，适配来自研发部等部门的购买需求，就像这样：

//行政部-适配器
public class Adapter implements BuyTicket {
 
      RDBuy rdBuy=new RDBuy();
      @Override
      public void Buy(String name) {
            
                   rdBuy.Buy( name);
      }
}
 
 
interface BuyTicket{
      public void Buy(String name);
}
 
class RDBuy implements BuyTicket{
 
      @Override
      public void Buy(String name) {
      
            System. out.println( "研发部帮  " +name +"买了一张火车票" );
      }
}

 

我们买的时候就是这样：

public static void main(String[] args) {
            String emploeeName= "研发部-老王" ;
            BuyTicket buyer= new Adapter();
             buyer.Buy( emploeeName);
      }

 

其实，但就这个流程来说，还可以完善一些：

 

public class Adapter implements BuyTicket {
 
      public static void main(String[] args) {
            String emploeeName= "研发部-老王" ;
            BuyTicket buyer= new Adapter();
             buyer.Buy( emploeeName);
      }
 
      private AdministrationBuy administraionBuy= new AdministrationBuy(); //
      RDBuy rdBuy=new RDBuy();
      @Override
      public void Buy(String name) {
             if ( name.contains( "研发")) {
                   rdBuy.Buy( name);
            }
             if ( name.contains( "行政")) {
                   administraionBuy.Buy( name);
            }
      }
}
 
 
interface BuyTicket{
      public void Buy(String name);
}
//行政部
class AdministrationBuy implements BuyTicket{
      @Override
      public void Buy(String name) {
      
            System. out.println( "行政部帮  " +name +"买了一张火车票" );
      }
}
//研发部
class RDBuy implements BuyTicket{
 
      @Override
      public void Buy(String name) {
      
            System. out.println( "研发部帮  " +name +"买了一张火车票" );
      }
}

 

代理模式：

到后来，行政部增加了人手，可以自己为大家买票了，而且买票这块也需要一些审核登记，不能由着大家胡乱买啊，于是就不让各个部门买了，当然对于我们来说名义上还是公司买。

interface BuyTicket{
      public void Buy(String name);
}
 
class CompanyBuy implements BuyTicket{
 
      @Override
      public void Buy(String name) {
      
            System. out.println( name+ "买了一张火车票" );
            
      }
      
}
 
//行政部来审核
class AdministraionPoxy implements BuyTicket{
      
      BuyTicket buyTicket;
      
      public AdministraionPoxy(BuyTicket buyTicket){
             this. buyTicket= buyTicket;
      }
 
      @Override
      public void Buy(String name) {
            System. out.println( "审核...");
             buyTicket.Buy( name);
            System. out.println( "记录...");
      }
      
}

 

我们买的时候

public class Proxy {
          
      public static void main(String[] args) {
            BuyTicket employee= new CompanyBuy();
            BuyTicket company= new AdministraionPoxy( employee);
            
             company.Buy( "EmployeeABuy");
             company.Buy( "EmployeeABuy");
      }
 
}

 

动态代理：

再后来，我完善了OA流程，大家只知道申请就行了，不用关心怎么谁买，怎么买。

interface BuyTicket{
      public void Buy(String name);
}
 
class CompanyBuy implements BuyTicket{
 
      @Override
      public void Buy(String name) {            
            System. out.println( "经过一系列手续···" +name +"买票了" );
           
      }
      
}
 
class AdministraionHandler implements InvocationHandler {
      
      private Object object;
      
      public AdministraionHandler(Object object){
             this. object= object;
      }
 
 
      @Override
      public Object invoke(Object proxy, Method method, Object[] args)
                   throws Throwable {
            Object result= null;
            System. out.println( "内部审核...");
             result= method.invoke( object, args);
           System. out.println( "内部记录...");
             return result;
      }
}
 

 

对于好奇的同学，在调用buy方法的时候，再也看不见买的细节了。

   

   
      public static void main(String[] args) {
            BuyTicket buyer= new CompanyBuy();
            InvocationHandler handler= new AdministraionHandler( buyer);
            
            BuyTicket proxy=(BuyTicket)Proxy. newProxyInstance(buyer.getClass().getClassLoader(),
                         buyer.getClass().getInterfaces(), handler);
            
             proxy.Buy( "老王");
      }

 

动态代理内部使用反射构建，关于反射，我会在另一篇文章中说明。