快递E栈——网络编程

 1 package bean;
 2 
 3 import java.io.Serializable;
 4 
 5 /**
 6  * 快递类
 7  *
 8  * @author Administrator
 9  */
10 public class Express implements Serializable {
11     private String order;
12     private String company;
13     private int code, target;
14 
15     public Express() {
16 
17     }
18     @Override
19     public String toString() {
20         return "快递单号：" + order + "\t快递公司：" + company + "\t取件码：" + code + "\t";
21     }
22 
23 
24     public String getOrder() {
25         return order;
26     }
27 
28     public void setOrder(String order) {
29         this.order = order;
30     }
31 
32     public void setCompany(String company) {
33         this.company = company;
34     }
35 
36     public int getCode() {
37         return code;
38     }
39 
40     public void setCode(int code) {
41         this.code = code;
42     }
43 
44     public int getTarget() {
45         return target;
46     }
47 
48     public void setTarget(int target) {
49         this.target = target;
50     }
51 }

  1 package view;
  2 
  3 import bean.Express;
  4 
  5 import java.util.Scanner;
  6 
  7 /**
  8  * @author Administrator
  9  */
 10 public class View {
 11     private final Scanner scanner = new Scanner(System.in);
 12 
 13     public void welcome() {
 14         System.out.println("=====欢迎使用新职课快递柜=====");
 15     }
 16 
 17     public void exit() {
 18         System.out.println("=====欢迎下次使用=====");
 19     }
 20 
 21     /**
 22      * 选择身份界面
 23      */
 24     public int menuMain() {
 25         System.out.println("请输入您的身份:1-快递员,2-用户,0-退出程序");
 26         //全局使用nextLine()，不会因为输入产生冲突，且可以更好的接收各种类型的数据
 27         String input = scanner.nextLine();
 28         int num = -1;
 29         // 判断用户输入是否正确
 30         try {
 31             num = Integer.parseInt(input);
 32         } catch (NumberFormatException e) {
 33             System.out.println(e.getMessage());
 34         }
 35         if (num < 0 || num > 2) {
 36             System.out.println("输入有误，请重新输入");
 37             return menuMain();
 38         }
 39         return num;
 40     }
 41 
 42     /**
 43      * 快递员功能界面
 44      */
 45     public int menuDeliveryMan() {
 46         System.out.println("请选择操作:1-快递录入，2-快递删除，3-快递修改，4-查看所有快递，5-返回上级目录，0-退出");
 47         String input = scanner.nextLine();
 48         int num = -1;
 49         // 判断用户输入是否正确
 50         try {
 51             num = Integer.parseInt(input);
 52         } catch (NumberFormatException e) {
 53             System.out.println(e.getMessage());
 54         }
 55         if (num < 0 || num > 5) {
 56             System.out.println("输入有误，请重新输入");
 57             return menuDeliveryMan();
 58         }
 59         return num;
 60     }
 61 
 62     /**
 63      * 快递员录入快递
 64      *
 65      * @return 快递单号及快递公司
 66      */
 67     public Express insert() {
 68         System.out.println("请输入快递单号:");
 69         String order = scanner.nextLine();
 70         System.out.println("请输入快递公司:");
 71         String company = scanner.nextLine();
 72         Express express = new Express();
 73         express.setOrder(order);
 74         express.setCompany(company);
 75         return express;
 76     }
 77 
 78     /**
 79      * 用于查找快递单号
 80      *
 81      * @return 快递单号
 82      */
 83     public String findByOrder() {
 84         System.out.println("请输入要操作的快递单号：");
 85         return scanner.nextLine();
 86     }
 87 
 88     /**
 89      * 打印快递信息
 90      */
 91     public void printExpress(Express express) {
 92         System.out.println(express.toString());
 93     }
 94 
 95     /**
 96      * 修改快递信息
 97      */
 98     public Express updateExpress() {
 99         System.out.println("请输入新的快递单号:");
100         String order = scanner.nextLine();
101         System.out.println("请输入新的快递公司:");
102         String company = scanner.nextLine();
103         Express express = new Express();
104         express.setOrder(order);
105         express.setCompany(company);
106         return express;
107     }
108 
109     /**
110      * 询问是否删除
111      *
112      * @return 1确认删除，2取消并退出
113      */
114     public int deleteExpress() {
115         System.out.println("是否确认删除:1-确认删除，其他-取消操作");
116         String input = scanner.nextLine();
117         int num = -1;
118         // 判断用户输入是否正确
119         try {
120             num = Integer.parseInt(input);
121         } catch (NumberFormatException e) {
122             System.out.println(e.getMessage());
123         }
124         return num;
125     }
126 
127     /**
128      * 用户菜单界面
129      */
130     public int menuUser() {
131         System.out.println("请输入取件码:");
132         String code = scanner.nextLine();
133         int num = -1;
134         // 判断用户输入是否正确
135         try {
136             num = Integer.parseInt(code);
137         } catch (NumberFormatException e) {
138             System.out.println(e.getMessage());
139         }
140         if (num < 100000 || num > 999999) {
141             System.out.println("输入有误，请重新输入");
142             return menuUser();
143         }
144         return num;
145     }
146 
147     /**
148      * 提示快递已存在
149      */
150     public void expressExist() {
151         System.out.println("此单号在快递柜中已存在，请检查是否正确");
152     }
153 
154     /**
155      * 打印空信息，提示快递不存在
156      */
157     public void printNull() {
158         System.out.println("该快递不存在，请检查输入是否正确！");
159     }
160 
161     /**
162      * 打印操作成功信息
163      */
164     public void printSuccess() {
165         System.out.println("操作成功！");
166     }
167 
168     /**
169      * 打印空取件码，提示取件码错误
170      */
171     public void printCodeNull() {
172         System.out.println("取件码错误或快递已取出，请检查！");
173     }
174 
175     public void printFail() {
176         System.out.println("操作失败！");
177     }
178 
179     public void isNull() {
180         System.out.println("无快递信息！");
181     }
182 }

 1 package dao;
 2 
 3 import bean.Express;
 4 
 5 import java.io.IOException;
 6 import java.util.ArrayList;
 7 
 8 /**
 9  * @author Administrator
10  */
11 public interface ExpressDao {
12     /**
13      *添加快递
14      * @param express 快递
15      * @return ee
16      */
17     Express add(Express express);
18 
19     /**
20      * 删除快递
21      * @param order 顺序
22      * @return ww
23      */
24     boolean delete(String order);
25 
26     /**
27      * 修改快递
28      * @param oldExp 开始存的快递单号
29      * @param newExp 后面改的快递单号
30      * @return rr
31      */
32     Express update(Express oldExp, Express newExp);
33 
34     /**
35      * 查询所有快递信息
36      * @return ee
37      */
38     ArrayList<Express> getAll();
39 
40     /**
41      * 取快递
42      * @param code 取件码
43      * @return ee
44      */
45     boolean getExpress(int code);
46 
47     /**
48      * 数组大小
49      * @return ee
50      */
51     int size();
52 
53     /**
54      *根据快递号查询快递信息
55      * @param order 顺序
56      * @return ee
57      */
58     Express findByOrder(String order);
59 
60     /**
61      * 根据取件查询快递信息
62      * @param order 顺序
63      * @return ee
64      */
65     Express findByCode(int order);
66 
67     /**
68      * 从文件中读取快递信息(反序列化）
69      */
70     void readFromFile();
71 
72     /**
73      * 将信息写入文件中(序列化)
74      * @throws IOException io异常
75      */
76     void writeToFile() throws IOException;
77 }

  1 package dao;
  2 
  3 import bean.Express;
  4 
  5 import java.io.*;
  6 import java.util.ArrayList;
  7 import java.util.Random;
  8 
  9 /**
 10  * @author Administrator
 11  */
 12 public class ExpressDaoImpl implements ExpressDao {
 13     private final File file = new File("Express.txt");
 14     private ArrayList<Express> list;
 15     private final Random random = new Random();
 16 
 17     /**
 18      * 最多存储数量
 19      */
 20     private final int max = 100;
 21 
 22     /**
 23      * 反序列化获得快递柜中存放的对象HashMap<Integer, Express> data
 24      */
 25     @Override
 26     public void readFromFile() {
 27         try (FileInputStream fis = new FileInputStream(file)) {
 28             ObjectInputStream ois = new ObjectInputStream(fis);
 29             // 反序列化读取对象
 30             list = (ArrayList<Express>) ois.readObject();
 31             // 关闭输入流
 32             ois.close();
 33         } catch (IOException | ClassNotFoundException e) {
 34             // 打开文件异常时 将expresses初始为空
 35             list = new ArrayList<>();
 36         }
 37     }
 38 
 39     @Override
 40     public void writeToFile() throws IOException {
 41         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
 42         // 序列化对象
 43         oos.writeObject(list);
 44         oos.close();
 45     }
 46 
 47     /**
 48      * 随机生成6位数取件码
 49      *
 50      * @return 6位数取件码
 51      */
 52     public int randomCode() {
 53         while (true) {
 54             int code = random.nextInt(900000) + 100000;
 55             Express e = findByCode(code);
 56             if (e == null) {
 57                 return code;
 58             }
 59         }
 60 
 61     }
 62 
 63     /**
 64      * 初始化快递柜位置
 65      */
 66     public int randomTarget() {
 67         int target;
 68         do {
 69             target = random.nextInt(max) + 1;
 70         } while (findByTarget(target) != null);
 71         return target;
 72     }
 73 
 74     /**
 75      * 判断快递柜是否占用
 76      */
 77     private Express findByTarget(int target) {
 78         for (Express express : list) {
 79             if (express.getTarget() == target) {
 80                 return express;
 81             }
 82         }
 83         return null;
 84     }
 85 
 86     /**
 87      * 根据取件码查询快递
 88      *
 89      * @param code 取件码
 90      * @return 查询的结果，没有则返回null
 91      */
 92     @Override
 93     public Express findByCode(int code) {
 94         for (Express express : list) {
 95             if (express.getCode() == code) {
 96                 return express;
 97             }
 98         }
 99         return null;
100     }
101 
102     /**
103      * 根据单号查询
104      */
105     @Override
106     public Express findByOrder(String order) {
107         for (Express e : list) {
108             if (e.getOrder().equals(order)) {
109                 return e;
110             }
111         }
112         return null;
113     }
114 
115     @Override
116     public synchronized Express add(Express express) {
117         if (size() >= max) {
118             return null;
119         } else {
120             express.setCode(randomCode());
121             express.setTarget(randomTarget());
122             list.add(express);
123             return express;
124         }
125     }
126 
127     @Override
128     public synchronized boolean delete(String order) {
129         Express byOrder = findByOrder(order);
130         if (byOrder == null) {
131             return false;
132         }
133         list.remove(byOrder);
134         return true;
135     }
136 
137     @Override
138     public synchronized Express update(Express oldExp, Express newExp) {
139         Express byOrder = findByOrder(oldExp.getOrder());
140         if (byOrder != null) {
141             list.remove(oldExp);
142             newExp.setCode(randomCode());
143             newExp.setTarget(randomTarget());
144             list.add(newExp);
145             return newExp;
146         }
147         return oldExp;
148     }
149 
150     @Override
151     public synchronized ArrayList<Express> getAll() {
152         return list;
153     }
154 
155     @Override
156     public synchronized boolean getExpress(int code) {
157         Express express = findByCode(code);
158         if (express != null) {
159             list.remove(express);
160             return true;
161         }
162         return false;
163     }
164 
165     @Override
166     public int size() {
167         return list.size();
168     }
169 }

  1 package server;
  2 
  3 import bean.Express;
  4 import dao.ExpressDao;
  5 import dao.ExpressDaoImpl;
  6 
  7 import java.io.*;
  8 import java.net.ServerSocket;
  9 import java.net.Socket;
 10 import java.util.ArrayList;
 11 
 12 /**
 13  * @author Administrator
 14  */
 15 public class Server {
 16     private ServerSocket serverSocket;
 17     private static final ExpressDao EXPRESS_DAO = new ExpressDaoImpl();
 18     private int numOfClient = 0;
 19 
 20     public static void main(String[] args) {
 21         Server service = new Server();
 22         service.start();
 23     }
 24 
 25     public void start() {
 26         try {
 27             serverSocket = new ServerSocket(7063);
 28             System.out.println("服务器已启动");
 29             EXPRESS_DAO.readFromFile();
 30             do {
 31                 Socket socket = serverSocket.accept();
 32                 System.out.println("第" + (++numOfClient) + "个客户端连接了");
 33                 new Thread(() -> {
 34                     try {
 35                         // 准备连接 进入主功能模块
 36                         receive(socket);
 37                     } catch (IOException e) {
 38                         e.printStackTrace();
 39                     }
 40                 }).start();
 41             } while (true);
 42         } catch (IOException e) {
 43             e.printStackTrace();
 44         } finally {
 45             try {
 46                 if (serverSocket != null) {
 47                     serverSocket.close();
 48                 }
 49             } catch (IOException e) {
 50                 e.printStackTrace();
 51             }
 52         }
 53     }
 54 
 55     public void receive(Socket socket) throws IOException {
 56         InputStream is;
 57         OutputStream os;
 58         ObjectInputStream ois;
 59         ObjectOutputStream oos;
 60         try {
 61             is = socket.getInputStream();
 62             os = socket.getOutputStream();
 63             ois = new ObjectInputStream(is);
 64             oos = new ObjectOutputStream(os);
 65             o:
 66             while (true) {
 67                 System.out.println("进入主菜单");
 68                 switch (ois.readInt()) {
 69                     case 0:
 70                         System.out.println("客户端退出");
 71                         EXPRESS_DAO.writeToFile();
 72                         break o;
 73                     case 1:
 74                         deliveryManClient(ois, oos);
 75                         break;
 76                     case 2:
 77                         userClient(ois, oos);
 78                         break;
 79                     default:
 80                         break;
 81                 }
 82             }
 83 
 84         } catch (IOException | ClassNotFoundException e) {
 85             e.printStackTrace();
 86         }
 87     }
 88 
 89     /**
 90      * 管理员客户端
 91      *
 92      * @param oos 发送数据给服务区
 93      * @param ois 从服务器接收数据
 94      */
 95     private void deliveryManClient(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
 96         System.out.println("进入快递员界面");
 97         switch (ois.readInt()) {
 98             case 0:
 99                 EXPRESS_DAO.writeToFile();
100                 break;
101             case 1:
102                 System.out.println("添加快递");
103                 addExpress(ois, oos);
104                 break;
105             case 2:
106                 System.out.println("删除快递");
107                 deleteExpress(ois, oos);
108                 break;
109             case 3:
110                 System.out.println("修改快递");
111                 updateExpress(ois, oos);
112                 break;
113             case 4:
114                 System.out.println("查看快递");
115                 seleteAllExpress(oos);
116                 break;
117             default:
118         }
119     }
120 
121     /**
122      * 用户
123      *
124      * @param oos 发送数据给服务器
125      * @param ois 从服务器接收数据
126      */
127     private void userClient(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
128         System.out.println("用户取快递界面");
129         // 根据客户端传过来的取件码 查找快递对象
130         Express e = EXPRESS_DAO.findByCode(ois.readInt());
131         // 向客户端传送查找的对象
132         oos.writeObject(e);
133         oos.flush();
134         if (e != null) {
135             //取出快递
136             EXPRESS_DAO.writeToFile();
137             oos.writeBoolean(EXPRESS_DAO.getExpress(e.getCode()));
138             oos.flush();
139         }
140     }
141 
142     /**
143      * 存储快递
144      */
145     private void addExpress(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
146         //1.从客户端接收快递数据
147         Express addExpress = (Express) ois.readObject();
148         System.out.println(addExpress.toString());
149         //2.根据快递单号判断对应快递是否已存在
150         Express byOrder = EXPRESS_DAO.findByOrder(addExpress.getOrder());
151         //判断快递是否存在,不存在则添加快递,为空则代表不存在，添加快递。
152         if (byOrder == null) {
153             byOrder = EXPRESS_DAO.add(addExpress);
154             oos.writeObject(byOrder);
155         } else {
156             oos.writeObject(null);
157         }
158         oos.flush();
159     }
160 
161     /**
162      * 删除快递
163      */
164     private void deleteExpress(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
165         //获取到客户端输入的单号
166         String deleteOrder = (String) ois.readObject();
167         //判断是否存在
168         Express byOrder =EXPRESS_DAO.findByOrder(deleteOrder);
169         //发送快递信息至客户端
170         oos.writeObject(byOrder);
171         oos.flush();
172         //如果快递存在
173         if (byOrder != null) {
174             //接收用户确认是否删除
175             if (ois.readInt() == 1) {
176                 oos.writeBoolean(EXPRESS_DAO.delete(deleteOrder));
177                 oos.flush();
178             }
179         }
180 
181     }
182 
183     /**
184      * 修改快递
185      */
186     private void updateExpress(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
187         //得到需要修改的单号
188         String updateOrder = (String) ois.readObject();
189         //根据单号查找内容,将查找到的数据发送客户端
190         Express oldExpress = EXPRESS_DAO.findByOrder(updateOrder);
191         oos.writeObject(oldExpress);
192         oos.flush();
193         if (oldExpress != null) {
194             //接收客户端回传的更改内容
195             Express newExpress = (Express) ois.readObject();
196             //根据新快递内容去库中查找是否存在，存在就代表库中有相同的数据
197             Express isExit = EXPRESS_DAO.findByOrder(newExpress.getOrder());
198             if (isExit != null) {
199                 oos.writeBoolean(false);
200             } else {
201                 Express update = EXPRESS_DAO.update(oldExpress, newExpress);
202                 //修改成功
203                 oos.writeBoolean(true);
204                 //将修改的值返回客户端
205                 oos.writeObject(update);
206             }
207             oos.flush();
208         }
209     }
210 
211 
212     /**
213      * 查看所有快递
214      */
215     private void seleteAllExpress(ObjectOutputStream oos) throws IOException {
216         ArrayList<Express> list = EXPRESS_DAO.getAll();
217         Express[] expresses = new Express[list.size()];
218         list.toArray(expresses);
219         oos.writeObject(expresses);
220         oos.flush();
221     }
222 }

  1 package client;
  2 
  3 import bean.Express;
  4 import view.View;
  5 
  6 import java.io.*;
  7 import java.net.Socket;
  8 import java.util.Arrays;
  9 import java.util.List;
 10 
 11 /**
 12  * @author Administrator
 13  */
 14 public class Client {
 15     /**
 16      * 初始化视图
 17      */
 18     private static final View VIEW = new View();
 19     /**
 20      * 创建视图
 21      */
 22     private static Socket socket;
 23     /**
 24      * 状态码
 25      */
 26     private boolean status = true;
 27 
 28     public static void main(String[] args) throws IOException {
 29         Client ec = new Client();
 30         ec.init();
 31     }
 32 
 33 
 34     private void init() throws IOException {
 35         OutputStream os;
 36         InputStream is;
 37         ObjectOutputStream oos = null;
 38         ObjectInputStream ois = null;
 39         //1.欢迎
 40         VIEW.welcome();
 41         try {
 42             socket = new Socket("127.0.0.1", 7063);
 43             os = socket.getOutputStream();
 44             is = socket.getInputStream();
 45             // 由于服务器是先ois后oos 为了保证配对 这里需要顺序调换
 46             oos = new ObjectOutputStream(os);
 47             ois = new ObjectInputStream(is);
 48             m:
 49             while (status) {
 50                 int menu = VIEW.menuMain();
 51                 oos.writeInt(menu);
 52                 oos.flush();
 53                 switch (menu) {
 54                     case 0:
 55                         break m;
 56                     case 1:
 57                         deliveryManClient(oos, ois);
 58                         break;
 59                     case 2:
 60                         userClient(oos, ois);
 61                         break;
 62                     default:
 63                         break;
 64                 }
 65             }
 66             oos.writeInt(0);
 67             oos.flush();
 68             VIEW.exit();
 69         } catch (IOException | ClassNotFoundException e) {
 70             e.printStackTrace();
 71         } finally {
 72             if (ois != null) {
 73                 ois.close();
 74             }
 75             if (oos != null) {
 76                 oos.close();
 77             }
 78             if (socket != null) {
 79                 socket.close();
 80             }
 81         }
 82 
 83 
 84     }
 85 
 86     /**
 87      * 管理员客户端
 88      *
 89      * @param oos 发送数据给服务区
 90      * @param ois 从服务器接收数据
 91      */
 92     private void deliveryManClient(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
 93         int menu = VIEW.menuDeliveryMan();
 94         oos.writeInt(menu);
 95         oos.flush();
 96         switch (menu) {
 97             case 0:
 98                 status = false;
 99                 break;
100             case 1:
101                 addExpress(oos, ois);
102                 break;
103             case 2:
104                 deleteExpress(oos, ois);
105                 break;
106             case 3:
107                 updateExpress(oos, ois);
108                 break;
109             case 4:
110                 seleteAllExpress(ois);
111                 break;
112             default:
113                 break;
114         }
115     }
116 
117     /**
118      * 用户
119      *
120      * @param oos 发送数据给服务器
121      * @param ois 从服务器接收数据
122      */
123     private void userClient(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
124         //获取用户输入的取件码
125         int code = VIEW.menuUser();
126         oos.writeInt(code);
127         oos.flush();
128         //根据取件码查询快递
129         Express byCode = (Express) ois.readObject();
130         if (byCode == null) {
131             //不存在，提示用户取件码错误或快递不存在
132             VIEW.printCodeNull();
133         } else {
134             //提示用户操作成功，打印快递信息
135             VIEW.printSuccess();
136             VIEW.printExpress(byCode);
137             //从快递柜删除该快递
138             if (!ois.readBoolean()) {
139                 VIEW.printFail();
140             }
141         }
142     }
143 
144     /**
145      * 存储快递
146      */
147     private void addExpress(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
148         //1.提示输入快递信息
149         Express addExpress = VIEW.insert();
150         oos.writeObject(addExpress);
151         oos.flush();
152         //2.判断快递是否已存储
153         Express add = (Express) ois.readObject();
154         if (add != null) {
155             VIEW.printExpress(add);
156         } else {
157             //提示快递已存在
158             VIEW.expressExist();
159         }
160     }
161 
162     /**
163      * 删除快递
164      */
165     private void deleteExpress(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
166         //获取到用户输入的单号
167         String deleteOrder = VIEW.findByOrder();
168         //传给服务器
169         oos.writeObject(deleteOrder);
170         //刷新
171         oos.flush();
172         //查询单号是否存在
173         Express i = (Express) ois.readObject();
174         if (i == null) {
175             VIEW.printNull();
176         } else {
177             //向用户确认是否删除
178             int menu = VIEW.deleteExpress();
179             //传给服务器
180             oos.writeInt(menu);
181             oos.flush();
182             if (menu == 1) {
183                 if (ois.readBoolean()) {
184                     VIEW.printSuccess();
185                 } else {
186                     VIEW.printFail();
187                 }
188             }
189         }
190 
191     }
192 
193     /**
194      * 修改快递
195      */
196     private void updateExpress(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
197         //得到需要修改的单号
198         String updateOrder = VIEW.findByOrder();
199         oos.writeObject(updateOrder);
200         oos.flush();
201         //得到服务端回传的数据
202         Express oldExpress = (Express) ois.readObject();
203         //判断是否存在
204         if (oldExpress != null) {
205             Express newExpress = VIEW.updateExpress();
206             //将修改的内容发送至服务器
207             oos.writeObject(newExpress);
208             oos.flush();
209             if (!ois.readBoolean()) {
210                 VIEW.expressExist();
211                 VIEW.printExpress(oldExpress);
212             } else {
213                 //得到修改后的值，打印输出
214                 Express update = (Express) ois.readObject();
215                 VIEW.printSuccess();
216                 VIEW.printExpress(update);
217             }
218         } else {
219             VIEW.printNull();
220         }
221     }
222 
223 
224     /**
225      * 查看所有快递
226      */
227     private void seleteAllExpress(ObjectInputStream ois) throws IOException, ClassNotFoundException {
228         Express[] es = (Express[]) ois.readObject();
229         List<Express> expresses = Arrays.asList(es);
230         if (expresses.size() != 0) {
231             for (Express ex : expresses) {
232                 VIEW.printExpress(ex);
233 
234             }
235         } else {
236             VIEW.isNull();
237         }
238     }
239 }