目录
一，快递管理训练任务
1，题目描述
2，源代码
2.1 bean.Express
2.2 dao.ExpressDao
2.3 main
2.4 view.View
3，总结
3.1 核心数据结构改动
3.2 ExpressDao
3.3 Main与ServerMain、ClientMain
3.4 说明
3.5 遇到的问题
3.6 思考
二，图书管理训练任务（选做）
1，题目描述
还记得之前的快递管理吗？
我们将数据存储在文件中，其实数据存储在客 户端中是很不安全的，今天我们来学习网络编程，客户端后续只用来收集用户 的操作，需要存储的数据都存储在服务器中。
为了保证服务器能同时连接多个客户端，记得在服务器引入多线程技术。 接下来加油学习吧!
代码结构
package bean;
import java.io.Serializable;
import java.util.Objects;
/**
*
*/
public class Express implements Serializable {
private String number; // 快递单号
private String company; // 公司
private int code; // 取件码
public int posX, posY; // 快递所在快递柜中的位置
// 构造方法
public Express(String number, String company, int code) {
this.number = number;
this.company = company;
this.code = code;
}
public Express() {
}
// getter/setter
public String getNumber() {
return number;
}
public String getCompany() {
return company;
}
public int getCode() {
return code;
}
public void setNumber(String number) {
this.number = number;
}
public void setCompany(String company) {
this.company = company;
}
public void setCode(int code) {
this.code = code;
}
// 重写toString 方法
@Override
public String toString() {
return "Express{" +
"number='" + number + '\'' +
", company='" + company + '\'' +
", code=" + code +
'}';
}
// 重写equals方法
/**
* 只要快递单号相同就认为快递相同
* @param o
* @return
*/
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Express express = (Express) o;
return Objects.equals(number, express.number);
}
@Override
public int hashCode() {
return Objects.hash(code);
}
}
package dao;
import bean.Express;
import java.io.*;
import java.util.ArrayList;
import java.util.Random;
// 实现可序列化标记接口 使得dao对象支持序列化与反序列化
public class ExpressDao {
private File file = new File("SerializedData.txt");
private boolean[][] cabinet = new boolean[10][]; // 二维数组表示快递柜位置是否被占用 true已占用 false未占用
private ArrayList
private Random random = new Random(); // 用于生成随机数
/**
* 反序列化获得快递柜中存放的对象HashMap
*/
public void readFromFile() {
try (FileInputStream fis = new FileInputStream(file)) {
ObjectInputStream ois = new ObjectInputStream(fis);
expresses = (ArrayList
ois.close(); // 关闭输入流
} catch (IOException | ClassNotFoundException e) {
expresses = new ArrayList
}
}
/**
* 序列化存储对象HashMap
* @throws IOException
*/
public void writeToFile() throws IOException {
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(expresses); // 序列化对象
oos.close();
}
/**
* 初始化数据结构：cabinet（表示快递柜是否被占用），expresses（存储）
*/
public void init() {
for(int i = 0; i <10; i++){
cabinet[i] = new boolean[10];
}
for(Express e : expresses) {
cabinet[e.posX][e.posY] = true; // 表示此位置已被占用
}
}
/**
*
* @param e 新加入的快递对象
* @return
*/
public synchronized boolean add(Express e){
int size = expresses.size();
if(size >= 100){
return false;
}
// 1,随机生成两个0-9的下标
int x = -1, y = -1;
while (true){
x = random.nextInt(10);
y = random.nextInt(10);
if(cabinet[x][y] == false){
break; // 此位置未被占用
}
}
// 2,判断取件码是否重复(最简单的 一个个对比)
int code = randomCode(); // 获得没有重复的取件码
e.setCode(code);
e.posX = x; // 快递柜存放快递的位置
e.posY = y;
size++; // 快递数目加一
cabinet[x][y] = true; // 此位置已被占用
expresses.add(e); //
return true;
}
/**
* 遍历所有对象 生成独一无二的取件码
* @return
*/
private int randomCode(){
while (true) {
int code = random.nextInt(900000) + 100000; // 范围(000000-899999)+1000000
Express e = findByCode(code);
if(e == null) { // 说明取件码未重复
return code;
}
}
}
/**
* 快递员根据快递单号查询HashMap中存放的快递
* @param number
* @return
*/
public Express findByNumber(String number){
for(Express e : expresses) {
if(e.getNumber().equals(number)) {
return e;
}
}
return null;
}
/**
* 根据取件码查询快递
* @param code 取件码
* @return 查询到结果 查询失败返回null
*/
public Express findByCode(int code){
for(Express e : expresses) {
if(e.getCode() == code) {
return e;
}
}
return null;
}
/**
* 多余的操作 为了MVC更圆润
* @param oldExpress
* @param newExpress
*/
public synchronized Boolean update(Express oldExpress, Express newExpress){
delete(oldExpress);
return add(newExpress);
}
/**
* 删除特定的快递对象
* @param e
*/
public synchronized boolean delete(Express e){
cabinet[e.posX][e.posY] = false;
return expresses.remove(e);// 删除指定对象
}
/**
* 获取所有的快递对象
* @return
*/
public synchronized ArrayList
return expresses;
}
}
1)main.ClientMain
package main;
import bean.Express;
import view.View;
import java.io.*;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class ClientMain {
private Socket socket;
private View v = new View();
public static void main(String[] args) throws IOException {
ClientMain client = new ClientMain();
client.link();
}
/**
* 创建套接字，与服务端进行连接；
* 创建对象输入/输出流，与服务端进行数据交互；
* @throws IOException
*/
public void link() throws IOException {
OutputStream os = null;
InputStream is = null;
ObjectOutputStream oos = null;
ObjectInputStream ois = null;
try {
socket = new Socket("127.0.0.1", 8888);
v.connectSuccess();
is = socket.getInputStream();
os = socket.getOutputStream();
oos = new ObjectOutputStream(os);// 由于服务器是先ois后oos 为了保证配对 这里需要顺序调换
ois = new ObjectInputStream(is);
o:while (true) {
int num = v.menu();// 获得角色选择码
oos.writeInt(num);
oos.flush();
switch (num) {
case 0:
break o;
case 1:
gClient(oos, ois);
break;
case 2:
uClient(oos, ois);
break;
default:
v.choiceError();
break;
}
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
} finally {
if(ois != null) ois.close();
if(oos != null) oos.close();
if(socket != null) socket.close();
}
}
/**
* 客户端管理员模块
* @param oos
* @param ois
* @throws IOException
* @throws ClassNotFoundException
*/
public void gClient(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
while (true) {
int num = v.gMenu();// 获得用户输入的功能码
oos.writeInt(num);// 向服务器传送功能码 保证进入同样的功能模块
oos.flush();
switch (num) {
case 0:// 退出
return;
case 1:// 插入
insert(oos, ois);
break;
case 2:// 修改
update(oos, ois);
break;
case 3:// 删除
delete(oos, ois);
break;
case 4:// 显示所有
printAll(oos, ois);
break;
default:
v.choiceError();
break;
}
}
}
/**
* 客户端用户模块
* @param oos
* @param ois
* @throws IOException
* @throws ClassNotFoundException
*/
public void uClient(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
while (true) {
int num = v.uMenu();
oos.writeInt(num);
oos.flush();
switch (num) {
case 0:
return;
case 1:
int code = v.getExpress();
oos.writeInt(code);
oos.flush();
Express e = (Express) ois.readObject();
if(e != null) {// 查询到有快递存在
v.printExpress(e);
if(ois.readBoolean()) v.success();
else v.fail();
} else {
v.printNull();// 取件码对应快递不存在
}
break;
default:
v.choiceError();
break;
}
}
}
/**
* 插入快递对象；
* 利用view对象获取将要插入快递对象，并将其传送给服务端
* @param oos
* @param ois
* @throws IOException
* @throws ClassNotFoundException
*/
public void insert(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
Express e = v.insert();
oos.writeObject(e);
oos.flush();
Express e1 = (Express) ois.readObject();// 返回对象为空 表示当前快递单号尚未被使用
if(e1 == null) {
if(ois.readBoolean()) {// 插入成功
v.success();
} else {
v.fail();
}
} else {
v.expressExist();
}
}
/**
* 删除快递对象
* @param oos
* @param ois
* @throws IOException
* @throws ClassNotFoundException
*/
public void delete(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
String id = v.findByNumber();
oos.writeObject(id);
oos.flush();
Express e = (Express) ois.readObject();
if(e != null) {
int num = v.delete();// 再次向用户确认是否删除
oos.writeInt(num);
oos.flush();
switch (num) {
case 1:// 确认删除
if(ois.readBoolean()) v.success();
else v.fail();
break;
default:// 取消删除或退出
break;
}
} else {
v.printNull();
}
}
/**
* 更新快递对象
* @param oos
* @param ois
* @throws IOException
* @throws ClassNotFoundException
*/
public void update(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
String id = v.findByNumber();
oos.writeObject(id);
oos.flush();
Express e = (Express) ois.readObject();
if(e != null) {// 被更新的快递对象存在
Express e1 = v.update();
oos.writeObject(e1);
oos.flush();
if(ois.readBoolean()) v.success();
else v.fail();
} else {
v.printNull();
}
}
/**
* 打印快递对象
* @param oos
* @param ois
* @throws IOException
* @throws ClassNotFoundException
*/
public void printAll(ObjectOutputStream oos, ObjectInputStream ois) throws IOException, ClassNotFoundException {
// ArrayList
// v.printAll(expresses);
Express[] es = (Express[]) ois.readObject();
List
v.printAll(expresses);
}
}
2)main.ServerMain
package main;
import bean.Express;
import dao.ExpressDao;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
public class ServerMain {
private ServerSocket serverSocket;
private ExpressDao dao = new ExpressDao();
private int numOfClient = 0;
// 服务器
public static void main(String[] args) throws IOException {
ServerMain server = new ServerMain();
server.start();
}
/**
* 启动服务器，并与客户端进行连接
*/
public void start() {
try {
serverSocket = new ServerSocket(8888);
System.out.println("服务器已启动");
dao.readFromFile();// 从文件中读取数据
dao.init();// 初始化数据结构
System.out.println("数据初始化成功");
while (true) {
Socket socket = serverSocket.accept();
System.out.println("第" + (++numOfClient) + "个客户端连接了");
new Thread() {
@Override
public void run() {
try {
receive(socket);// 准备连接 进入主功能模块
} catch (IOException e) {
e.printStackTrace();
}
}
}.start();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if(serverSocket != null){
serverSocket.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 创建对象输入/输出流，与客户端进行数据交互；
* 进入主模块，选择角色；
* @param socket
* @throws IOException
*/
public void receive(Socket socket) throws IOException {
InputStream is = socket.getInputStream();
OutputStream os = socket.getOutputStream();
ObjectInputStream ois = new ObjectInputStream(is);
ObjectOutputStream oos = new ObjectOutputStream(os);
try(is; os; ois; oos) {// 这种方式可以在try/catch执行结束后 自动关闭资源
o: while (true) {
switch (ois.readInt()) {
case 0:// 退出
dao.writeToFile();// 退出服务器端 将数据对象写回文件
break o;
case 1:
gClient(ois, oos);// 进入管理员操作功能模块
break ;
case 2:
uClient(ois, oos);// 进入用户操作功能模块
break ;
default: break ;
}
}
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 服务端——管理员模块，负责与客户端——管理员模块进行数据交互
* @param ois
* @param oos
* @throws IOException
* @throws ClassNotFoundException
*/
public void gClient(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
while (true) {
switch (ois.readInt()) {
case 0:// 退出
return;
case 1:// 插入
insert(ois, oos);
break;
case 2:// 修改
update(ois, oos);
break;
case 3:// 删除
delete(ois, oos);
break;
case 4:// 显示所有
printAll(ois, oos);
break;
}
}
}
/**
* 服务端——用户模块，负责与客户端——用户模块进行数据交互
* @param ois
* @param oos
* @throws IOException
*/
public void uClient(ObjectInputStream ois, ObjectOutputStream oos) throws IOException {
while (true) {
switch (ois.readInt()) {
case 0:
return;
case 1:// 取件
Express e = dao.findByCode(ois.readInt());// 根据客户端传过来的取件码 查找快递对象
oos.writeObject(e);// 向客户端传送查找的对象
oos.flush();
if(e != null) {
oos.writeBoolean(dao.delete(e));
oos.flush();
}
break;
default: break;
}
}
}
/**
* 插入快递对象；
* 接受客户端发来的新快递对象，用dao对象对数据进行操作，并将操作结果返还给客户端
* @param ois
* @param oos
* @throws IOException
* @throws ClassNotFoundException
*/
public void insert(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
Express e = (Express) ois.readObject();
Express e1 = dao.findByNumber(e.getNumber());// 根据快递单号判断对应快递是否已存在
oos.writeObject(e1);
oos.flush();
if(e1 == null) {
oos.writeBoolean(dao.add(e));
oos.flush();
}
}
/**
* 删除快递对象
* @param ois
* @param oos
* @throws IOException
* @throws ClassNotFoundException
*/
public void delete(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
String id = (String) ois.readObject();
Express e = dao.findByNumber(id);
oos.writeObject(e);
oos.flush();
if(e != null) {// 快递对象存在
switch (ois.readInt()) {// 再次向用户确认是否删除
case 1:
oos.writeBoolean(dao.delete(e));
oos.flush();
break;
default:
break;
}
}
}
/**
* 更新快递对象
* @param ois
* @param oos
* @throws IOException
* @throws ClassNotFoundException
*/
public void update(ObjectInputStream ois, ObjectOutputStream oos) throws IOException, ClassNotFoundException {
String id = (String) ois.readObject();
Express e = dao.findByNumber(id);
oos.writeObject(e);
oos.flush();
if(e != null) {
Express e1 = (Express) ois.readObject();
oos.writeBoolean(dao.update(e, e1));
oos.flush();
}
}
/**
* 向客户端传送所有快递对象
* @param ois
* @param oos
* @throws IOException
*/
public void printAll(ObjectInputStream ois, ObjectOutputStream oos) throws IOException {
// oos.writeObject(dao.getAll());
// oos.flush();
ArrayList
Express[] expresses = new Express[list.size()];
list.toArray(expresses);
oos.writeObject(expresses);
oos.flush();
}
}
package view;
import bean.Express;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Scanner;
/**
* 视图层
* 只负责展示视图 不包含其他任何逻辑
*/
public class View {
public Scanner input = new Scanner(System.in);
/**
* 获得用户的角色选择输入，并进入相应的功能
* @return 返回功能码 1：管理员 2：普通用户 0：退出
*/
public int menu(){
System.out.println("根据提示输入功能序号：");
System.out.println("1,管理员");
System.out.println("2,普通用户");
System.out.println("0,退出");
String s = input.nextLine();
int funcNum = -1;
try{
funcNum = Integer.parseInt(s);
}catch (NumberFormatException e){ // 格式异常 递归继续获取功能码
return menu();
}
if(funcNum <0 || funcNum > 2){ // 功能码不合法
return menu();
}
return funcNum;
}
/*
-----------------------------------------------------------------
*/
/**
* 获得管理员输入的功能码
* @return 管理员输入的合法功能码 1：录入 2：修改 3：删除 4：查看所有 0：退出
*/
public int gMenu(){
System.out.println("根据提示输入功能序号：");
System.out.println("1,快递录入");
System.out.println("2,快递修改");
System.out.println("3,快递删除");
System.out.println("4,查看所有快递");
System.out.println("0,退出");
String s = input.nextLine();
int funcNum = -1;
try{
funcNum = Integer.parseInt(s);
}catch (NumberFormatException e){ // 格式异常 递归继续获取功能码
return gMenu();
}
if(funcNum <0 || funcNum > 4){ // 功能码不合法
return gMenu();
}
return funcNum;
}
/**
* 1快递员录入信息
* @return 返回包含了快递单号和快递公司的快递对象
*/
public Express insert(){
System.out.println("请根据提示输入快递信息：");
System.out.print("请输入快递单号：");
String number = input.nextLine();
System.out.print("请输入快递公司：");
String company = input.nextLine();
Express e = new Express();
e.setNumber(number);
e.setCompany(company);
return e;
}
/**
* 2修改快递信息
*/
public Express update(){
System.out.print("请输入新的快递单号：");
String number = input.nextLine();
System.out.print("请输入新的快递公司");
String company = input.nextLine();
Express e = new Express();
e.setNumber(number);
e.setCompany(company);
return e;
}
/**
* 3询问是否删除
* @return 给出快递管理员的选择 1：删除 2：取消
*/
public int delete(){
System.out.println("确认是否删除：");
System.out.println("1,确认删除");
System.out.println("2,取消删除");
System.out.println("0,退出");
String s = input.nextLine();
int num = -1;
try {
num = Integer.parseInt(s);
}catch (NumberFormatException e){
return delete();
}
if(num <0 || num > 2){
return delete();
}
return num;
}
/**
* 4遍历显示所有快递信息
* @param es
*/
public void printAll(List
int count = 0;
for(Express e : es) {
count++;
printExpress(e);
}
if(count == 0){
System.out.println("暂无快递信息");
}
}
/**
* 提示用户输入快递单号
* @return
*/
public String findByNumber(){
System.out.println("请根据提示输入快递信息：");
System.out.print("请输入需要操作的快递单号：");
String number = input.nextLine();
return number;
}
/**
* 显示快递信息
* @param e
*/
public void printExpress(Express e){
if(e == null){
System.out.println("快递信息不存在");
return;
}
System.out.println("快递信息如下：");
System.out.println("位置：第" + (e.posX + 1) + "排，" + (e.posY + 1) + "列; " +
"快递公司：" + e.getCompany() + "; " + "快递单号：" + e.getNumber() + ";" +
"取件码：" + e.getCode() + ";");
}
/*
-----------------------------------------------------------------
*/
/**
* 获得用户输入的取件码（这里简化，只要取件码相同，就算取件成功）
* @return 用户输入的合法功能码(6位)
*/
public int uMenu(){
System.out.println("根据提示输入功能序号：");
System.out.println("0,退出");
System.out.println("1,取出快递");
String s = input.nextLine();
int funcNum = -1;
try{
funcNum = Integer.parseInt(s);
}catch (NumberFormatException e){ // 格式异常 递归继续获取功能码
System.out.println("格式异常");
return uMenu();
}
if(funcNum <0 || funcNum > 1){ // 功能码不合法
System.out.println("功能码不合法");
return uMenu();
}
return funcNum;
}
/**
* 用户取件
* @return
*/
public int getExpress() {
System.out.println("根据提示进行取件：");
System.out.print("请输入取件码：");
String s = input.nextLine();
int code = -1;
try{
code = Integer.parseInt(s);
}catch (NumberFormatException e){ // 格式异常 递归继续获取功能码
System.out.println("格式异常");
return getExpress();
}
if(code <100000 || code > 999999){ // 功能码不合法
System.out.println("输入有误，请重试！");
return getExpress();
}
return code;
}
public void expressExist(){
System.out.println("此快递单号已存在，请勿重复存储");
}
public void printCode(Express e) {
System.out.println("新快递的取件码为：" + e.getCode());
}
public void success(){
System.out.println("操作成功！");
}
public void fail(){
System.out.println("操作失败！");
}
public void choiceError() {
System.out.println("输入选项有误，请重新输入！");
}
public void printNull(){
System.out.println("快递不存在，请检查输入");
}
public void connectSuccess() {
System.out.println("服务器连接成功");
}
}
与上一次的任务卡@&再见萤火虫&【任务卡_03-Java核心类库_第4节 IO】相比，有着较大的改动。
京公网安备 11010802041100号