程序博客网 > java入门教程免费下载

银行业务调度系统

来源：互联网 发布：java入门教程免费下载 编辑：程序博客网 时间：2024/06/05 15:25

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

一、银行业务调度系统的项目需求

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

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、画图非常有助于理解和分析问题


2、具体分析与设计

1）、有三种对应类型的客户：VIP客户，普通客户，快速客户 ，异步随机生成各种类型的客户，各类型客户在其对应窗口按顺序依次办理业务 。
    首先，经常在银行办理业务的人更有利于理解本系统，每一个客户其实就是由银行的一个取号机器产生号码的方式来表示的。所以，我想到要有       一个号码管理器对象，让这个对象不断地产生号码，就等于随机生成了客户。

    由于有三类客户，每类客户的号码编排都是完全独立的，所以，我想到本系统一共要产生三个号码管理器对象，各自管理一类用户的排队号码。这     三个号码管理器对象统一由一个号码机器进行管理，这个号码机器在整个系统中始终只能有一个，所以，它要被设计成单例。
2）、各类型客户在其对应窗口按顺序依次办理业务 ，准确地说，应该是窗口依次叫号。
   各个窗口问的相应的号码管理器该叫哪一个号了？即服务窗口每次找号码管理器获取当前要被服务的号码。

三、程序具体设计及代码

1、NumberManager类的编写

1）、定义一个用于存储上一个客户号码的成员变量和用于存储所有等待服务的客户号码的队列集合。
2）、定义一个产生新号码的方法和获取马上要为之服务的号码的方法，这两个方法被不同的线程操作了相同的数据，所以，要进行同步。

3）、程序源代码

[java] view plaincopy
  1. public class NumberManager {  
  2.     //定义一个变量，记录上一次生成的号码  
  3.     private int lastNumber = 0;  
  4.     //定义一个集合，用于存放产生的号码  
  5.     private List queueNumbers = new ArrayList();  
  6.       
  7.     public synchronized Integer generateNewNumber(){  
  8.         queueNumbers.add(++lastNumber);  
  9.         return lastNumber;  
  10.     }  
  11.       
  12.     public synchronized Integer fetchNumber(){  
  13.         if(queueNumbers.size()>0){  
  14.             //这里返回的是集合中删除的元素值。  
  15.             return (Integer)queueNumbers.remove(0);  
  16.         }else{  
  17.             return null;  
  18.         }  
  19.     }  
  20. }  

2、NumberMachine类的编写

1）、定义三个成员变量分别指向三个NumberManager对象，分别表示普通、快速和VIP客户的号码管理器，定义三个对应的方法来返回这三个            NumberManager对象。
2）、将NumberMachine类设计成单例。

3）、程序源代码

[java] view plaincopy
  1. public class NumberMachine {  
  2.   
  3.     private NumberMachine() {  
  4.     }  
  5.       
  6.     private static NumberMachine instance = new NumberMachine();  
  7.     //所有的号码都是由一个号码机器产生的，所以选择单例  
  8.     public static NumberMachine getInstance() {  
  9.         return instance;  
  10.     }  
  11.     //创建三个不同类型的号码管理  
  12.     private NumberManager commonManager = new NumberManager();  
  13.     private NumberManager expressManager = new NumberManager();  
  14.     private NumberManager vipManager = new NumberManager();  
  15.   
  16.     //获取普通号码管理对象  
  17.     public NumberManager getCommonManager() {  
  18.         return commonManager;  
  19.     }  
  20.     //获取快速号码管理对象  
  21.     public NumberManager getExpressManager() {  
  22.         return expressManager;  
  23.     }  
  24.     //获取VIP号码管理对象  
  25.     public NumberManager getVipManager() {  
  26.         return vipManager;  
  27.     }  
  28.   
  29. }  

3、CustomerType枚举类的编写
1）、系统中有三种类型的客户，所以用定义一个枚举类，其中定义三个成员分别表示三种类型的客户。
2）、重写toString方法，返回类型的中文名称。这是在后面编码时重构出来的，刚开始不用考虑。

3）、程序源代码

[java] view plaincopy
  1. public enum CustomerType {  
  2.     //分别代表普通类型的客户，快速类型的客户，VIP客户  
  3.     COMMON,EXPRESS,VIP;  
  4.     public String toString(){  
  5.         String name = null;  
  6.         switch(this){  
  7.         case COMMON:  
  8.             name = "普通";  
  9.             break;  
  10.         case EXPRESS:  
  11.             name = "快速";  
  12.             break;  
  13.         case VIP:  
  14.             name = name();  
  15.             break;  
  16.         }  
  17.         return name;  
  18.     }  
  19. }  

4、ServiceWindow类的编写
1）、定义一个start方法，内部启动一个线程，根据服务窗口的类别分别循环调用三个不同的方法。 
2）、定义三个方法分别对三种客户进行服务，为了观察运行效果，应详细打印出其中的细节信息。

3）、程序源代码

[java] view plaincopy
  1. public class ServiceWindow {  
  2.     private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");  
  3.     //窗口服务的类型  
  4.     private CustomerType type = CustomerType.COMMON;  
  5.     //窗口编号  
  6.     private int number = 1;  
  7.   
  8.     public CustomerType getType() {  
  9.         return type;  
  10.     }  
  11.   
  12.     public void setType(CustomerType type) {  
  13.         this.type = type;  
  14.     }  
  15.   
  16.     public void setNumber(int number) {  
  17.         this.number = number;  
  18.     }  
  19.   
  20.     public void start() {  
  21.         Executors.newSingleThreadExecutor().execute(new Runnable() {  
  22.             public void run() {  
  23.                 // 下面这种写法的运行效率低，最好是把while放在case下面  
  24.                 while (true) {  
  25.                     switch (type) {  
  26.                     case COMMON:  
  27.                         commonService();  
  28.                         break;  
  29.                     case EXPRESS:  
  30.                         expressService();  
  31.                         break;  
  32.                     case VIP:  
  33.                         vipService();  
  34.                         break;  
  35.                     }  
  36.                 }  
  37.             }  
  38.         });  
  39.     }  
  40.     //普通服务  
  41.     private void commonService() {  
  42.         String windowName = "第" + number + "号" + type + "窗口";  
  43.         System.out.println(windowName + "开始获取普通任务!");  
  44.         //获取服务号码  
  45.         Integer serviceNumber = NumberMachine.getInstance().getCommonManager()  
  46.                 .fetchNumber();  
  47.         if (serviceNumber != null) {  
  48.             System.out.println(windowName + "开始为第" + serviceNumber + "号普通客户服务");  
  49.             int maxRandom = Constants.MAX_SERVICE_TIME  
  50.                     - Constants.MIN_SERVICE_TIME;  
  51.             int serviceTime = new Random().nextInt(maxRandom) + 1  
  52.                     + Constants.MIN_SERVICE_TIME;  
  53.   
  54.             try {  
  55.                 Thread.sleep(serviceTime);  
  56.             } catch (InterruptedException e) {  
  57.                 e.printStackTrace();  
  58.             }  
  59.             System.out.println(windowName + "完成为第" + serviceNumber  
  60.                     + "号普通客户服务，总共耗时" + serviceTime / 1000 + "秒");  
  61.         } else {  
  62.             System.out.println(windowName + "没有取到普通任务，正在空闲一秒");  
  63.             try {  
  64.                 Thread.sleep(1000);  
  65.             } catch (InterruptedException e) {  
  66.                 e.printStackTrace();  
  67.             }  
  68.         }  
  69.     }  
  70.   
  71.     //快速服务  
  72.     private void expressService() {  
  73.         Integer serviceNumber = NumberMachine.getInstance().getExpressManager()  
  74.                 .fetchNumber();  
  75.         String windowName = "第" + number + "号" + type + "窗口";  
  76.         System.out.println(windowName + "开始获取快速任务!");  
  77.         if (serviceNumber != null) {  
  78.             System.out.println(windowName + "开始为第" + serviceNumber + "号快速客户服务");  
  79.             int serviceTime = Constants.MIN_SERVICE_TIME;  
  80.             try {  
  81.                 Thread.sleep(serviceTime);  
  82.             } catch (InterruptedException e) {  
  83.                 e.printStackTrace();  
  84.             }  
  85.             System.out.println(windowName + "完成为第" + serviceNumber  
  86.                     + "号快速客户服务，总共耗时" + serviceTime / 1000 + "秒");  
  87.         } else {  
  88.             System.out.println(windowName + "没有取到快速任务！");  
  89.             commonService();  
  90.         }  
  91.     }  
  92.   
  93.     //VIP服务  
  94.     private void vipService() {  
  95.   
  96.         Integer serviceNumber = NumberMachine.getInstance().getVipManager()  
  97.                 .fetchNumber();  
  98.         String windowName = "第" + number + "号" + type + "窗口";  
  99.         System.out.println(windowName + "开始获取VIP任务!");  
  100.         if (serviceNumber != null) {  
  101.             System.out  
  102.                     .println(windowName + "开始为第" + serviceNumber + "号VIP客户服务");  
  103.             int maxRandom = Constants.MAX_SERVICE_TIME  
  104.                     - Constants.MIN_SERVICE_TIME;  
  105.             int serviceTime = new Random().nextInt(maxRandom) + 1  
  106.                     + Constants.MIN_SERVICE_TIME;  
  107.             try {  
  108.                 Thread.sleep(serviceTime);  
  109.             } catch (InterruptedException e) {  
  110.                 e.printStackTrace();  
  111.             }  
  112.             System.out.println(windowName + "完成为第" + serviceNumber  
  113.                     + "号VIP客户服务，总共耗时" + serviceTime / 1000 + "秒");  
  114.         } else {  
  115.             System.out.println(windowName + "没有取到VIP任务！");  
  116.             commonService();  
  117.         }  
  118.     }  
  119. }  

5、Constants类的编写
1）、定义三个常量：MAX_SERVICE_TIME、MIN_SERVICE_TIME、COMMON_CUSTOMER_INTERVAL_TIME

2）、程序源代码

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

6、MainClass类的编写
1）、用for循环创建出4个普通窗口，再创建出1个快速窗口和一个VIP窗口。
2）、接着再创建三个定时器，分别定时去创建新的普通客户号码、新的快速客户号码、新的VIP客户号码。

3）、程序源代码

[java] view plaincopy
  1. public class MainClass {  
  2.       
  3.     private static Logger logger = Logger.getLogger("cn.itcast.bankqueue");  
  4.       
  5.   
  6.     public static void main(String[] args) {  
  7.         //产生4个普通窗口  
  8.         for(int i=1;i<5;i++){  
  9.             ServiceWindow window =  new ServiceWindow();  
  10.             window.setNumber(i);  
  11.             window.start();  
  12.         }  
  13.       
  14.         //产生1个快速窗口  
  15.         ServiceWindow expressWindow =  new ServiceWindow();  
  16.         expressWindow.setType(CustomerType.EXPRESS);  
  17.         expressWindow.start();  
  18.           
  19.         //产生1个VIP窗口       
  20.         ServiceWindow vipWindow =  new ServiceWindow();  
  21.         vipWindow.setType(CustomerType.VIP);  
  22.         vipWindow.start();        
  23.           
  24.         //普通客户拿号  
  25.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
  26.                 new Runnable(){  
  27.                     public void run(){  
  28.                         Integer serviceNumber = NumberMachine.getInstance().getCommonManager().generateNewNumber();  
  29.                         /** 
  30.                          * 采用logger方式，无法看到直观的运行效果，因为logger.log方法内部并不是直接把内容打印出出来， 
  31.                          * 而是交给内部的一个线程去处理，所以，打印出来的结果在时间顺序上看起来很混乱。 
  32.                          */  
  33.                         //logger.info("第" + serviceNumber + "号普通客户正在等待服务！");  
  34.                         System.out.println("第" + serviceNumber + "号普通客户！");                         
  35.                     }  
  36.                 },  
  37.                 0,  
  38.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME,   
  39.                 TimeUnit.SECONDS);  
  40.           
  41.         //快速客户拿号  
  42.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
  43.                 new Runnable(){  
  44.                     public void run(){  
  45.                         Integer serviceNumber = NumberMachine.getInstance().getExpressManager().generateNewNumber();  
  46.                         System.out.println("第" + serviceNumber + "号快速客户正在等待服务！");  
  47.                     }  
  48.                 },  
  49.                 0,  
  50.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME * 2,   
  51.                 TimeUnit.SECONDS);  
  52.           
  53.         //VIP客户拿号  
  54.         Executors.newScheduledThreadPool(1).scheduleAtFixedRate(  
  55.                 new Runnable(){  
  56.                     public void run(){  
  57.                         Integer serviceNumber = NumberMachine.getInstance().getVipManager().generateNewNumber();  
  58.                         System.out.println("第" + serviceNumber + "号VIP客户正在等待服务！");  
  59.                     }  
  60.                 },  
  61.                 0,  
  62.                 Constants.COMMON_CUSTOMER_INTERVAL_TIME * 6,   
  63.                 TimeUnit.SECONDS);  
  64.     }  
  65.   
  66. }  
四、总结与收获

     每次看老师编代码都给人一种享受，当眼前的代码如行云流水般的飘洒而出时，总有一种畅快淋漓的清爽。然而在自己敲打代码时，总是有不断的问题出现，这可能就是积累的差距。此次老师编写程序，使用了一些平时没有讲到的新知识，例如线程池等。学习Java也是有一段时间了，对此也有了一定的认识，前期学习了大量的基础知识，而后面的学习，则是不断的学习新的设计思路和其扩展功能等。Java的学习就是一个积累的过程，Java把所有的事物都封装成了对象，使得我们在使用时不需明白其内部结构，只需学会使用其方法即可。

    

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ -----------

0 0
java入门教程免费下载 java入门教程免费下载
原创粉丝点击
热门IT博客
为啥淘宝无法付款为啥淘宝无法付款
爬虫软件是什么爬虫软件是什么
linux swap free 0
壁纸下载软件
php程序员来晒工资
淘宝口红正品店铺
网络上有重名
java 根据ip获取地区
黑马java简历
淘宝rouwang家的模特
游泳衣女装连体淘宝网
成都 人工智能
免费好用数据恢复软件
360人工智能研究院待遇
商城数据库表结构
程序员学历重要吗
lte无线网络优化实践
手机数字统计软件
linux查看jar包内容
anywhere虚拟定位软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 男士戒指戴法 白金戒指图片 男生中指戴戒指什么意思 男生单身戒指戴法 黄金戒指图片 戒指的戴法和意义女生 左手戒指的戴法和意义 戒指的带法和意思 男生戒指戴法的意义 女生戒指戴法 戴戒指的含义 戒指戴法男士 女生戒指的戴法和意义 戒指的戴法和意义男 戒指戴法含义 女戒指的戴法和意义 女士戒指的戴法和意义 情侣戒指图片 男士戒指图片 女性戒指的戴法和意义 周大福情侣戒指 女生戴戒指的含义 周大福银戒指 单身男戒指戴哪个手指 戒指的戴法和意义女 周大福结婚戒指 周大福金戒指 周大福铂金戒指 黄金戒指女款 周大福黄金戒指 周大福男士戒指 男女戒指戴法 南红戒指款式 轻奢戒指品牌 戒指戴在不同手指的意义 戒指品牌排名 求婚戒指图片 女士戒指图片 男士黄金戒指 定制戒指品牌排行榜 买戒指怎么量手指尺寸

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里