黑马程序员——银行业务调度系统

----------------------    android培训    java培训   期待与您交流！    ----------------------

一，模拟实现银行业务调度系统逻辑，具体需求如下：

 

1 银行内有6个业务窗口，1- 4号窗口为普通窗口，5号窗口为快速窗口，6号窗口为VIP窗口。

 

2 有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。

 

3 异步随机生成各种类型的客户，生成各类型用户的概率比例为：

 

        VIP客户 ：普通客户 ：快速客户 =  1 ：6 ：3。

 

4 客户办理业务所需时间有最大值和最小值，在该范围内随机设定每个VIP客户以及普通客户办理业务所需的时间，快速客户办理业务所需时间为最小值（提示：办理业务的过程可通过线程Sleep的方式模拟）。

 

5各类型客户在其对应窗口按顺序依次办理业务。

 

6当VIP（6号）窗口和快速业务（5号）窗口没有客户等待办理业务的时候，这两个窗口可以处理普通客户的业务，而一旦有对应的客户等待办理业务的时候，则优先处理对应客户的业务。

 

7随机生成客户时间间隔以及业务办理时间最大值和最小值自定，可以设置。

 

8不要求实现GUI，只考虑系统逻辑实现，可通过Log方式展现程序运行结果。

三，类的分析

(1)NumberManager类

?定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合。

?定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作了相同的数据，所以，要进行同步。

(2)NumberMachine类

?定义三个成员变量分别指向三个NumberManager对象，分别表示普通、快速和VIP客户的号码管理器，定义三个对应的方法来返回这三个NumberManager对象。

将NumberMachine类设计成单例

(3)CustomerType枚举类

?系统中有三种类型的客户，所以用定义一个枚举类，其中定义三个成员分别表示三种类型的客户。

?重写toString方法，返回类型的中文名称。这是在后面编码时重构出来的，刚开始不用考虑。

(4)ServiceWindow类

?定义一个start方法，内部启动一个线程，根据服务窗口的类别分别循环调用三个不同的方法。

?定义三个方法分别对三种客户进行服务，为了观察运行效果，应详细打印出其中的细节信息。

(5)MainClass类

?用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。

?接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。

(6)Constants类

?定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

代码:

NumberManager类：号码管理器类.

view plaincopy to clipboardprint?import java.util.ArrayList;  
import java.util.List;  
  
public class NumberManager {  
    private int lastNumber=1;  
    private List<Integer> queueNumber=new ArrayList<Integer>();  
    //产生服务号码   
    public synchronized Integer generateNewManager(){  
        queueNumber.add(lastNumber);  
        return lastNumber++;  
    }  
    //取出服务号码   
    public synchronized Integer fatchServiceNumber(){  
        Integer number=null;  
        if(queueNumber.size()>0){  
            return queueNumber.remove(0);  
        }  
        return number;  
    }  
  
}  
import java.util.ArrayList;
import java.util.List;

public class NumberManager {
private int lastNumber=1;
private List<Integer> queueNumber=new ArrayList<Integer>();
//产生服务号码
public synchronized Integer generateNewManager(){
  queueNumber.add(lastNumber);
  return lastNumber++;
}
//取出服务号码
public synchronized Integer fatchServiceNumber(){
  Integer number=null;
  if(queueNumber.size()>0){
   return queueNumber.remove(0);
  }
  return number;
}

}

NumberMachine类：号码管理机器

view plaincopy to clipboardprint?public class NumberMachine {  
    private NumberManager commonManager=new NumberManager();  
    private NumberManager expressManager=new NumberManager();  
    private NumberManager VipManager=new NumberManager();  
      
    public NumberManager getCommonManager() {  
        return commonManager;  
    }  
    public NumberManager getExpressManager() {  
        return expressManager;  
    }  
    public NumberManager getVipManager() {  
        return VipManager;  
    }  
      
    private NumberMachine(){}  
    public static NumberMachine getInstance(){  
        return instance;  
    }  
    private static NumberMachine instance=new NumberMachine();  
}  
public class NumberMachine {
private NumberManager commonManager=new NumberManager();
private NumberManager expressManager=new NumberManager();
private NumberManager VipManager=new NumberManager();

public NumberManager getCommonManager() {
  return commonManager;
}
public NumberManager getExpressManager() {
  return expressManager;
}
public NumberManager getVipManager() {
  return VipManager;
}

private NumberMachine(){}
public static NumberMachine getInstance(){
  return instance;
}
private static NumberMachine instance=new NumberMachine();
}

CustomerType类：  客户类型用枚举来实现。

view plaincopy to clipboardprint?public enum CustomerType {  
    COMMON,EXPRESS,VIP;  
      
    public String toString(){  
        switch(this){  
            case COMMON:  
                return "普通";  
            //  break;   
            case EXPRESS:  
                return "快速";  
            //  break;   
            case VIP:  
                return name();  
                  
        }  
        return null;  
    }  
  
}  
public enum CustomerType {
COMMON,EXPRESS,VIP;

public String toString(){
  switch(this){
   case COMMON:
    return "普通";
   // break;
   case EXPRESS:
    return "快速";
   // break;
   case VIP:
    return name();
    
  }
  return null;
}

}

ServiceWindow类： 窗口服务

view plaincopy to clipboardprint?import java.util.Random;  
import java.util.concurrent.Executors;  
  
public class ServiceWindow {  
    private CustomerType type=CustomerType.COMMON;//定义窗口类型   
    private int windowId=1;  
        // TODO: handle exception   
      
    public void setType(CustomerType type) {  
        this.type = type;  
    }  
  
    public void setWindowId(int windowId) {  
        this.windowId = windowId;  
    }  
  
    public void start(){  
        Executors.newSingleThreadExecutor().execute(new Runnable(){  
  
            @Override  
            public void run() {  
                // TODO Auto-generated method stub   
                while(true)  
                {  
                    /*switch(int) 
                    if(type==CustomerType.COMMON) 
                    NumberMachine.getInstance().getCommonManager(); 
                    else*/  
                    //switch的数据类型只能是整数，枚举也可以   
                    switch(type){  
                        case COMMON:  
                            commonService();  
                            break;  
                        case EXPRESS:  
                            expressService();  
                            break;  
                        case VIP:  
                            vipService();  
                            break;  
                      
                    }  
                }  
            }         
        private void commonService() {  
            String windowName="第"+windowId+"号"+type+"窗口";  
              
            Integer number=NumberMachine.getInstance().getCommonManager().fatchServiceNumber();  
            System.out.println(windowName+"正在获取任务");  
            if(number!=null){  
                System.out.println(windowName+"为第"+number+"个"+"普通"+"客户服务.");  
                long beginTime=System.currentTimeMillis();  
                //long serveTime=0;   
                int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;  
                long serveTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;  
                try {  
                    Thread.sleep(serveTime);  
                } catch (InterruptedException e) {  
                    // TODO: handle exception   
                    e.printStackTrace();  
                }  
                long costTime=System.currentTimeMillis()-beginTime;  
                System.out.println(windowName+"为第"+number+"个"+"普通"+"客户完成服务，耗时"+costTime/1000+"秒");  
            }  
            else{  
                System.out.println(windowName+"没有取到服务任务！先休息1秒钟嘛！");  
                //commonService();   
                try {  
                    Thread.sleep(1000);  
                } catch (InterruptedException e) {  
                    // TODO: handle exception   
                    e.printStackTrace();  
                }  
            }  
        }  
          
          
        private void expressService() {  
            String windowName="第"+windowId+"号"+type+"窗口";  
            System.out.println(windowName+"正在获取任务");  
            Integer number=NumberMachine.getInstance().getExpressManager().fatchServiceNumber();  
            System.out.println(windowName+"正在获取任务");  
            if(number!=null){  
                System.out.println(windowName+"为第"+number+"个"+type+"客户服务.");  
                long beginTime=System.currentTimeMillis();  
                //long serveTime=0;   
                /*int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME; 
                long serveTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;*/  
                try {  
                    Thread.sleep(Constants.MIN_SERVICE_TIME);  
                } catch (InterruptedException e) {  
                    // TODO: handle exception   
                    e.printStackTrace();  
                }  
                long costTime=System.currentTimeMillis()-beginTime;  
                System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");  
            }  
            else{  
                System.out.println(windowName+"没有取到服务任务！");  
                commonService();  
                  
            }  
        }  
          
        private void vipService() {  
            String windowName="第"+windowId+"号"+type+"窗口";  
              
            Integer number=NumberMachine.getInstance().getVipManager().fatchServiceNumber();  
            System.out.println(windowName+"正在获取任务");  
            if(number!=null){  
                System.out.println(windowName+"为第"+number+"个"+type+"客户服务.");  
                long beginTime=System.currentTimeMillis();  
                //long serveTime=0;   
                int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;  
                long serveTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;  
                try {  
                    Thread.sleep(serveTime);  
                } catch (InterruptedException e) {  
                    // TODO: handle exception   
                    e.printStackTrace();  
                }  
                long costTime=System.currentTimeMillis()-beginTime;  
                System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");  
            }  
            else{  
                System.out.println(windowName+"没有取到服务任务！");  
                commonService();  
                  
            }  
        }  
    });  
    }  
  
}  
import java.util.Random;
import java.util.concurrent.Executors;

public class ServiceWindow {
private CustomerType type=CustomerType.COMMON;//定义窗口类型
private int windowId=1;
  // TODO: handle exception

public void setType(CustomerType type) {
  this.type = type;
}

public void setWindowId(int windowId) {
  this.windowId = windowId;
}

public void start(){
  Executors.newSingleThreadExecutor().execute(new Runnable(){

   @Override
   public void run() {
    // TODO Auto-generated method stub
    while(true)
    {
     /*switch(int)
     if(type==CustomerType.COMMON)
     NumberMachine.getInstance().getCommonManager();
     else*/
                 //switch的数据类型只能是整数，枚举也可以
     switch(type){
      case COMMON:
          commonService();
       break;
      case EXPRESS:
       expressService();
          break;
      case VIP:
       vipService();
       break;
     
     }
    }
   }  
  private void commonService() {
   String windowName="第"+windowId+"号"+type+"窗口";
   
   Integer number=NumberMachine.getInstance().getCommonManager().fatchServiceNumber();
   System.out.println(windowName+"正在获取任务");
   if(number!=null){
    System.out.println(windowName+"为第"+number+"个"+"普通"+"客户服务.");
    long beginTime=System.currentTimeMillis();
    //long serveTime=0;
    int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
    long serveTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;
    try {
     Thread.sleep(serveTime);
    } catch (InterruptedException e) {
     // TODO: handle exception
     e.printStackTrace();
    }
    long costTime=System.currentTimeMillis()-beginTime;
    System.out.println(windowName+"为第"+number+"个"+"普通"+"客户完成服务，耗时"+costTime/1000+"秒");
   }
   else{
    System.out.println(windowName+"没有取到服务任务！先休息1秒钟嘛！");
    //commonService();
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     // TODO: handle exception
     e.printStackTrace();
    }
   }
  }
  
  
  private void expressService() {
   String windowName="第"+windowId+"号"+type+"窗口";
   System.out.println(windowName+"正在获取任务");
   Integer number=NumberMachine.getInstance().getExpressManager().fatchServiceNumber();
   System.out.println(windowName+"正在获取任务");
   if(number!=null){
    System.out.println(windowName+"为第"+number+"个"+type+"客户服务.");
    long beginTime=System.currentTimeMillis();
    //long serveTime=0;
    /*int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
    long serveTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;*/
    try {
     Thread.sleep(Constants.MIN_SERVICE_TIME);
    } catch (InterruptedException e) {
     // TODO: handle exception
     e.printStackTrace();
    }
    long costTime=System.currentTimeMillis()-beginTime;
    System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");
   }
   else{
    System.out.println(windowName+"没有取到服务任务！");
    commonService();
    
   }
  }
  
  private void vipService() {
   String windowName="第"+windowId+"号"+type+"窗口";
   
   Integer number=NumberMachine.getInstance().getVipManager().fatchServiceNumber();
   System.out.println(windowName+"正在获取任务");
   if(number!=null){
    System.out.println(windowName+"为第"+number+"个"+type+"客户服务.");
    long beginTime=System.currentTimeMillis();
    //long serveTime=0;
    int maxRand=Constants.MAX_SERVICE_TIME-Constants.MIN_SERVICE_TIME;
    long serveTime=new Random().nextInt(maxRand)+1+Constants.MIN_SERVICE_TIME;
    try {
     Thread.sleep(serveTime);
    } catch (InterruptedException e) {
     // TODO: handle exception
     e.printStackTrace();
    }
    long costTime=System.currentTimeMillis()-beginTime;
    System.out.println(windowName+"为第"+number+"个"+type+"客户完成服务，耗时"+costTime/1000+"秒");
   }
   else{
    System.out.println(windowName+"没有取到服务任务！");
    commonService();
    
   }
  }
});
}

}

Constants类：一些固定的数据可以用常量来表示

view plaincopy to clipboardprint?public class Constants {  
    public static int MAX_SERVICE_TIME=10000;  
    public static int MIN_SERVICE_TIME=1000;  
    public static int COMMON_CUSTOMER_INTERVAL_TIME=1;  
  
}  
public class Constants {
public static int MAX_SERVICE_TIME=10000;
public static int MIN_SERVICE_TIME=1000;
public static int COMMON_CUSTOMER_INTERVAL_TIME=1;

}

MainClass类： 银行运行过程

view plaincopy to clipboardprint?import java.util.concurrent.Executors;  
import java.util.concurrent.TimeUnit;  
  
public class MainClass {  
  
    /** 
     * @param args 
     */  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub   
           
        for(int i=1;i<5;i++)  
        {  
            ServiceWindow commonWindow=new ServiceWindow();  
            commonWindow.setWindowId(i);  
            commonWindow.start();  
        }  
        ServiceWindow vipWindow=new ServiceWindow();  
        vipWindow.setType(CustomerType.VIP);  
        //vipWindow.setWindowId(6);   
        vipWindow.start();  
          
        ServiceWindow expressWindow=new ServiceWindow();  
        expressWindow.setType(CustomerType.EXPRESS);  
        expressWindow.start();  
          
          
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                new Runnable(){  
  
                    @Override  
                    public void run() {  
                        // TODO Auto-generated method stub   
                        Integer number=NumberMachine.getInstance().getCommonManager().generateNewManager(); 
                        System.out.println(number+"号普通客户等待服务！");  
                    }  
                      
                },   
                0,   
                Constants.COMMON_CUSTOMER_INTERVAL_TIME,   
                TimeUnit.SECONDS);  
          
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                new Runnable(){  
  
                    @Override  
                    public void run() {  
                        // TODO Auto-generated method stub   
                        Integer number=NumberMachine.getInstance().getVipManager().generateNewManager();  
                        System.out.println(number+"号vip客户等待服务！");  
                          
                    }  
                      
                },   
                0,   
                Constants.COMMON_CUSTOMER_INTERVAL_TIME*6,   
                TimeUnit.SECONDS);  
          
        Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
                new Runnable(){  
  
                    @Override  
                    public void run() {  
                        // TODO Auto-generated method stub   
                        Integer number=NumberMachine.getInstance().getExpressManager().generateNewManager(); 
                        System.out.println(number+"号快速客户等待服务！");  
                          
                    }  
                      
                },   
                0,   
                Constants.COMMON_CUSTOMER_INTERVAL_TIME*2,   
                TimeUnit.SECONDS);  
  
    }  
  
} 

根据需求，有三种对应类型的客户：VIP客户，普通客户，快速客户（办理如交水电费、电话费之类业务的客户）。

定义一个NumberMachine类这个类描述了产生客户和通过方法怎么得到这三个客户

package cn.itcast.test;

public class NumberMachine {

private NumberMachine(){}//构造函数私有化是因为要固定产生三个客户！
private static NumberMachine instance = new NumberMachine();
public static NumberMachine getInstance(){
  return instance;
}

private NumberManager commonManager = new NumberManager();
private NumberManager expressManager = new NumberManager();
private NumberManager vipManager = new NumberManager();
public NumberManager getCommonManager() {
  return commonManager;
}
public NumberManager getExpressManager() {
  return expressManager;
}
public NumberManager getVipManager() {
  return vipManager;
} 
}

NumberManager 类是机器产生号码的类，

package cn.itcast.test;

import java.util.ArrayList;
import java.util.List;

public class NumberManager {
private int lastNumber = 0;
private List queueNumbers = new ArrayList();
//多线程的同步
public synchronized Integer generateNewNumber(){
  queueNumbers.add(++lastNumber);
  return lastNumber;
}

public synchronized Integer fetchNumber(){
  if(queueNumbers.size()>0){
   return (Integer)queueNumbers.remove(0);
  }else{
   return null;
  }
}
}