黑马程序员-银行管理系统

最新推荐文章于 2023-12-19 15:31:29 发布

原创最新推荐文章于 2023-12-19 15:31:29 发布 · 613 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #银行管理系统

Java部分专栏收录该内容

29 篇文章

订阅专栏

------- 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方式展现程序运行结果。

思路分析：
结合实际情况，客户及其类型，由取号机取出的号码纸得知。则定义一个号码管理对象，并不断产生号码，即客户。有三类客户，则应有三个号码管理器，各自管理一类用户的排队号码。且三类型客户，统一由一个机器管理，可设计成单例模式。
各类型客户在对应窗口办理业务，准确的说，是窗口一次叫号。叫号之前，窗口先通过号码管理器获取将要服务的对象的号码。
服务窗口的类，三种类型的服务窗口，可添加枚举类型，三种客户类型。提供设置方法，以区别new的窗口类型。提供不同的方法，为不同的窗口类型调用以提供不同的服务，对于VIP类型，当vip客户不存在时，可继续调用普通类型服务方法。在窗口对外服务方法中，通过sleep实现每个窗口的服务时间的控制。

黑马程序员_JAVA银行业务调度系统 - zb83583047 - zb83583047的博客
主类：创建服务窗口，通过循环创建多个普通窗口，则需窗口提供一个SetID方法，以示区别。在创建进程时，使用Executors.newScheduledThreadPool(1).scheduleAtFixedRate()，通过设置不同类型窗口的延迟时间达到设定客户处理时间的目的。
在处理过程中，可创建常量类，是代码更加整齐，可读。

1. 号码管理器

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 fetchServiceNumber(){
  if(queueNumber.size()>0){
   return queueNumber.remove(0);
  }
  return null;
 }
}

在generateNumber方法里,首先把客户去的号码放进List集合里面,在这里要注意return lastNumber++和return ++lastNumber的区别

第一个是先返回,再把lastNumber加一后者是先把lastNumber加一再返回.

在fetchServiceNumber里面需要判断集合里面是否有号码,如果没有就会放回null,所以需要判断集合是否有号码,并且把返回值变为Integer 这也是Integer和int之间区别之一,在javaEE里面更建议使用integer.

2. 取号机器

public class NumberMachine {
 private NumberManager commonCustomer = new NumberManager();
 private NumberManager expressCustomer = new NumberManager();
 private NumberManager vipCustomer = new NumberManager();
 
 public NumberManager getCommonManager() {
  return commonCustomer;
 }
 public NumberManager getExpressManager() {
  return expressCustomer;
 }
 public NumberManager getVipManager() {
  return vipCustomer;
 }
 
 private NumberMachine(){}
 private static NumberMachine instance = new NumberMachine();
 public static NumberMachine getInstance(){
  return instance;
 }
}

NumberMachine 类是一个号码机器在整个系统中始终只能有一个,所以适合使用单例模式:

3. 服务窗口

public class ServiceWindow
　　　　{
　　　　　　 private CustomerType type = CustomerType.COMMON;
　　　　　　 private int windowId = 1;

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

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

　　　　　　 public void start()
 　　　　　　{
　　　　　　　　  // JDK1.5 新的建立线程的方法
　　　　　　　　  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+"窗口";
  　　　　　　　　System.out.println(windowName+"正在获取任务");
 　　　　　　　　 Integer number = NumMachine.getInstance().getComManager().getNumber();
 　　　　　　　　 if(number != null)
 　　　　　　　　 {
  　　　　　　　　　　 System.out.println(windowName+"为第"+number+"号普通客户服务");
   
  　　　　　　　　　　 long beginTime = System.currentTimeMillis();
   
   　　　　　　　　　　// 模拟服务的时间
  　　　　　　　　　　 int serviceRand = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
  　　　　　　　　　　 long sericeTime = new Random().nextInt(serviceRand)+1+Constants.MIN_SERVICE_TIME;
   
 　　　　　　　　　　  try {
   　　　　　　　　　　 Thread.sleep(sericeTime);
  　　　　　　　　　　 } 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 = NumMachine.getInstance().getExpManager().getNumber();
  　　　　　　System.out.println(windowName+"正在获取任务");
 　　　　　　 if(number != null)
  　　　　　　{
  　　　　　　　　 System.out.println(windowName+"为第"+number+"个客户服务");
   
  　　　　　　　　 long beginTime = System.currentTimeMillis();
      
  　　　　　　　　 try {
 　　　　　　　　   Thread.sleep(Constants.MIN_SERVICE_TIME);
　　　　　　　　   } catch (InterruptedException e) {
　　　　　　　　    e.printStackTrace();
　　　　　　  　　 }
   
 　　　　　　  long costTime = System.currentTimeMillis() - beginTime;
   
  　　　　　　 System.out.println(windowName+"为第"+number+"个客户服务，耗时"+costTime/1000+"秒");
 　　　　 }
  　　　　else
  　　　　{
   　　　　　　System.out.println(windowName+"没有取到号码，空闲一秒");
  　　　　　　 commonService();  // 当快速窗口没有取到任务时就为普通窗口客户服务
 　　　　　　  try {
   　　　　　　 Thread.sleep(1000);
   　　　　　　} catch (InterruptedException e) {
   　　　　　　 e.printStackTrace();
  　　　　　　 }
 　　　　 }
　　 }
 

　　// VIP客户服务
　　vate void vipService() {
 　　　　 String windowName = "第"+windowId+"号 "+type+"窗口";
 　　　　 Integer number = NumMachine.getInstance().getVipManager().getNumber();
 　　　　 System.out.println(windowName+"正在获取任务");
  　　　　if(number != null)
  　　　　{
 　　　　　　  System.out.println(windowName+"为第"+number+"个客户服务");
   
   　　　　　　long beginTime = System.currentTimeMillis();
   
   　　　　　　// 模拟服务的时间
  　　　　　　 int serviceRand = Constants.MAX_SERVICE_TIME - Constants.MIN_SERVICE_TIME;
  　　　　　　 long sericeTime = new Random().nextInt(serviceRand)+1+Constants.MIN_SERVICE_TIME;
   
 　　　　　　  try {
    　　　　　　Thread.sleep(sericeTime);
  　　　　　　 } catch (InterruptedException e) {
  　　　　　　  e.printStackTrace();
　　　　　　   }
   
  　　　　　　 long costTime = System.currentTimeMillis() - beginTime;
   
 　　　　　　  System.out.println(windowName+"为第"+number+"个客户服务，耗时"+costTime/1000+"秒");
 　　　　 }
  　　　　else
 　　　　 {  
   　　　　　　System.out.println(windowName+"没有取到号码，空闲一秒");
  　　　　　　 commonService(); // 当VIP窗口没有取到任务时就为普通窗口客户服务
  　　　　　　 try {
  　　　　　　  Thread.sleep(1000);
 　　　　　　  } catch (InterruptedException e) {
  　　　　　　  e.printStackTrace();
　　　　　　   }
 　　　　 }
 　　　}
　　}

4. 客户类型

public enum CustomerType 
　　{
　　　　 COMMON,EXPRESS,VIP;
 
　　　　 public String toString()
 　　　　{
　　　　　　  String name = null;
  
  　　　　　　switch(this)
  　　　　　　{
 　　　　　　　　  case COMMON: name = "普通";
    　　　　　　　　break;
    
   　　　　　　　　case EXPRESS: name = "快速";
  　　　　　　　　  break;
    
  　　　　　　　　 case VIP: name = name(); // 枚举中的自有方法，返回自己当前的名字
   　　　　　　　　 break;
 　　　　　　 }
  
 　　　　　　 return name;
 　　　　}
　　}

5. 所需时间

public class Constants 
　　{
　　　　 public static int MAX_SERVICE_TIME = 10000; // 最大耗时10秒
　　　　 public static int MIN_SERVICE_TIME = 1000; // 最小耗时1秒
 
　　　　 /*每个普通窗口服务一个客户的平均时间为5秒，一共有4个这样的窗口，也就是说银行的所有普通窗口合起来
　　　　  * 平均1.25秒内可以服务完一个普通客户，再加上快速窗口和VIP窗口也可以服务普通客户，所以，
　　　　  * 1秒钟产生一个普通客户比较合理，*/ 
　　　　 public static int COMMON_CUSTOMER_INTERVAL_TIME = 1; 
　　}

6. 主类

public class MainClass 
　　{
 　　　　public static void main(String[] args)
 　　　　{

　　　　　　   // 模拟普通窗口
　　　　　　　for(int i=1; i<5; i++)
  　　　　　　{
   　　　　　　　　ServiceWindow commWindow = new ServiceWindow();
   
 　　　　　　　　  commWindow.setWindowId(i);
   
   　　　　　　　　commWindow.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()
     　　　　　　　　　　{
    　　　　　　　　　　　　  Integer number = NumMachine.getInstance().getComManager().creteNumber();
   　　　　　　　　　　　　   System.out.println(number+"号普通客户正在等待服务");
    　　　　　　　　　　 }
    　　　　　　　　}, 
   　　　　　　　　 0,
    　　　　　　　　Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6,
  　　　　　　　　  TimeUnit.SECONDS
    　　　　　　);
  

　　　　　　　　// 模拟快速客户
　　     　 　　 Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
   　　　　　　　　 new Runnable()
    　　　　　　　　{
    　　　　　　　　　　 public void run()
   　　　　　　　　　　  {
    　　　　　　　　　　　　  Integer number = NumMachine.getInstance().getExpManager().creteNumber();
     　　　　　　　　　　　　 System.out.println(number+"号快速客户正在等待服务");
     　　　　　　　　　　}
  　　　　　　　　  }, 
   　　　　　　　　 0,
 　　　　　　　　   Constants.COMMON_CUSTOMER_INTERVAL_TIME * 3,
 　　　　　　　　   TimeUnit.SECONDS
 　　　　  　　 );
  　　　　　　

　　　　　　　　// 模拟VIP客户
　　　　　　　　Executors.newScheduledThreadPool(1).scheduleAtFixedRate(
    　　　　　　　　new Runnable()
    　　　　　　　　{
     　　　　　　　　　　public void run()
    　　　　　　　　　　 {
     　　　　　　　　　　　　 Integer number = NumMachine.getInstance().getVipManager().creteNumber();
     　　　　　　　　　　　　 System.out.println(number+"号VIP客户正在等待服务");
     　　　　　　　　　　}
   　　　　　　　　 }, 
   　　　　　　　　 0,
   　　　　　　　　 Constants.COMMON_CUSTOMER_INTERVAL_TIME,
    　　　　　　　　TimeUnit.SECONDS
   　　　　　　 );
　　　　　　 }
　　　　}