黑马程序员-java基础 银行业务调度系统

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

 

银行业务调度系统

业务需求：

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

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

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

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

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

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

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

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

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

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

项目分析

主要类   号码产生类 服务号码管理类   服务窗口类  测试类

号码产生类

负责产生号码 ，定义一个集合，把产生的号码加入集合中，当为最前面号码服务的时候，删除集合最前面的号码。

服务号码管理类：

要产生3种类型的号码，所以定义类型为号码产生类 类型的3个属性。用单例产生他们的对象

服务窗口类

分为普通窗口 ，快速窗口 ， vip窗口。窗口的类型可以通过专门建立一个枚来定义。

定义一个线程池来管理窗口的业务。普通窗口为普通号码服务，当没有普通客户的时候，休息一秒中。

快速窗口和vip窗口首先为各自对应的号码服务，当没有的对应的号码的时候，可以为普通号码服务。

因此，可以建立普通窗口业务方法，快速窗口业务方法，vip窗口业务方法，处理对应的业务，

当快速窗口和vip窗口没有对应的号码的时候调用普通窗口业务方法处理普通号码。

项目实现

//号码产生类

public class NumberManager {

 //服务号码

 private int lastNameber = 1;

 private List<Integer> queueNumber = new ArrayList<Integer>();

 //产生号码，并把号码装进集合

 public synchronized Integer genrateNewManager() {

  queueNumber.add(lastNameber);

  return lastNameber++;

 }

 // 获取马上需要服务的号码

 public synchronized Integer fetchNumber() {

  Integer number =null;

  //如果号码不为空，删除最前面的号码，并返回最前面的号码

  if(queueNumber.size()>0){

   

   return queueNumber.remove(0);

  }

  

  return number;

 }

}

//号码管理类

public class NumberMachine {

 //普通号码

 private NumberManager commonManager =new NumberManager();

 //快速服务号码

 private NumberManager expressManager =new NumberManager();

 //vip号码

 private NumberManager vipManager =new NumberManager();

 //我们用单例来产生号码

 private NumberMachine(){}

 private static NumberMachine instance = new NumberMachine();

 public static NumberMachine getInstance(){

  return instance;

 }

 

 

 public NumberManager getCommonManager() {

  return commonManager;

 }

 public void setCommonManager(NumberManager commonManager) {

  this.commonManager = commonManager;

 }

 public NumberManager getExpressManager() {

  return expressManager;

 }

 public void setExpressManager(NumberManager expressManager) {

  this.expressManager = expressManager;

 }

 public NumberManager getVipManager() {

  return vipManager;

 }

 public void setVipManager(NumberManager vipManager) {

  this.vipManager = vipManager;

 }

 

 

}

//服务窗口类

public class ServiceWindow {

 //窗口类型，用枚举表示

 private CustomerType type = CustomerType.COMMON;

 //窗口id

 private int windowId = 1;

 //

 public void start() {

  Executors.newSingleThreadExecutor().execute(new Runnable() {

   public void run() {

    while (true) {

     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()

    .fetchNumber();

  System.out.println(windowName + "正在获取普通任务");

  //当票号不为空时，开始服务

  if (number != null) {

   System.out.println(windowName + "正在为为第" + number + "个" + "普通"

     + "客户服务");

   //设置随机服务时间

   long beginTime = System.currentTimeMillis();

   int maxRand = Constans.MAX_SERVICE_TIME - Constans.MIN_SERVICE_TIME;

   long serverTime = new Random().nextInt(maxRand) + 1

     + Constans.MIN_SERVICE_TIME;

   try {

    Thread.sleep(serverTime);

   } catch (InterruptedException e) {

    e.printStackTrace();

   }

   long costTime = System.currentTimeMillis() - beginTime;

   System.out.println(windowName + "为第" + number + "个" + "普通"

     + "客户完成服务，" + "耗时" + costTime / 1000 + "秒");

  } else {

   //当没有客户时，休息一秒在叫号

   System.out.println(windowName + "没有取到普通任务,休息一秒");

   try {

    Thread.sleep(1000);

   } catch (InterruptedException e) {

    e.printStackTrace();

   }

  }

 }

 //快速服务窗口

 private void expressService() {

  String windowName = "第" + windowId + "号" + type + "窗口";

  

  Integer number = NumberMachine.getInstance().getExpressManager()

    .fetchNumber();

  System.out.println(windowName + "正在获取任务");

  //当有快速客户时为快速客户服务

  if (number != null) {

   System.out.println(windowName + "正在为为第" + number + "个" + type

     + "客户服务");

   try {

    Thread.sleep(Constans.MIN_SERVICE_TIME);

   } catch (InterruptedExceptio
4000
n e) {

    e.printStackTrace();

   }

   long costTime = Constans.MIN_SERVICE_TIME;

   System.out.println(windowName + "为第" + number + "个" + type

     + "客户完成服务，" + "耗时" + costTime / 1000 + "秒");

  } else {

   //当没有快速客户时，可以为普通客户服务

   System.out.println(windowName + "没有取到任务");

   commonService();

  }

 }

 //vip服务窗口

 private void vipService() {

  String windowName = "第" + windowId + "号" + type + "窗口";

  Integer number = NumberMachine.getInstance().getVipManager()

    .fetchNumber();

  System.out.println(windowName + "正在获取任务");

  //当有vip客户时为vip客户服务

  if (number != null) {

   System.out.println(windowName + "正在为为第" + number + "个" + type

     + "客户服务");

   long beginTime = System.currentTimeMillis();

   int maxRand = Constans.MAX_SERVICE_TIME - Constans.MIN_SERVICE_TIME;

   long serverTime = new Random().nextInt(maxRand) + 1

     + Constans.MIN_SERVICE_TIME;

   try {

    Thread.sleep(serverTime);

   } catch (InterruptedException e) {

    e.printStackTrace();

   }

   long costTime = System.currentTimeMillis() - beginTime;

   System.out.println(windowName + "为第" + number + "个" + type

     + "客户完成服务，" + "耗时" + costTime / 1000 + "秒");

  } else {

   //当没有vip客户时，可以为普通客户服务

   System.out.println(windowName + "没有取到任务");

   commonService();

  }

 }

 public CustomerType getType() {

  return type;

 }

 public void setType(CustomerType type) {

  this.type = type;

 }

 public int getWindowId() {

  return windowId;

 }

 public void setWindowId(int windowId) {

  this.windowId = windowId;

 }

}

//创建枚举 设定 窗口类型

public enum CustomerType {

 COMMON,EXPRESS,VIP;

 

 public String toString(){

  switch(this){

  case COMMON:

   return "普通";

  case EXPRESS:

   return "快速";

  case VIP:

   return "VIP";

  }

  

  return null;

 }

}

//服务时间 类

public class Constans {

 //服务最大时间

 public static int MAX_SERVICE_TIME=10000;

 //服务最小时间

 public static int MIN_SERVICE_TIME=1000;

}

//测试类

public class BankTest {

 public static void main(String[] args) {

  //产生普通窗口

  for (int i = 1; i < 5; i++) {

   ServiceWindow commonWindow = new ServiceWindow();

   commonWindow.setWindowId(i);

   commonWindow.start();

  }

  //产生快速服务窗口

  ServiceWindow expressWindow = new ServiceWindow();

  expressWindow.setType(CustomerType.EXPRESS);

  expressWindow.start();

  //产生vip服务窗口

  ServiceWindow vipWindow = new ServiceWindow();

  vipWindow.setType(CustomerType.VIP);

  vipWindow.start();

  //用线程池管理号码的产生，每隔一段时间重新调用方法，就可以循环产生号码

  Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

   public void run() {

    //产生普通客户号码，每过1秒产生普通号码

    Integer number = NumberMachine.getInstance().getCommonManager().genrateNewManager();

    System.out.println(number+"普通客户等待服务");

   }

  }, 0, 1, TimeUnit.SECONDS);

  Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

   public void run() {

    //产生快速客户号码 每过2秒产生快速服务号码

    Integer number = NumberMachine.getInstance().getVipManager().genrateNewManager();

    System.out.println(number+"快速客户等待服务");

   }

  }, 0, 2, TimeUnit.SECONDS);

  

  Executors.newScheduledThreadPool(1).scheduleAtFixedRate(new Runnable() {

   public void run() {

    //产生vip客户号码 每过6秒产生vip号码

    Integer number = NumberMachine.getInstance().getVipManager().genrateNewManager();

    System.out.println(number+"VIP客户等待服务");

   }

  }, 0, 6, TimeUnit.SECONDS);

 }

}

 

 

 

 

 

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

详细请查看：http://edu.csdn.net/heima