十二、网络编程

一、源码下载

• 链接 提取码：yu4g

二、快递柜管理

一、任务要求

二、源码框架

三、源码

bean:Express.java

package maintest.day12_4_6.mailbox.bean;

import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;
import java.util.Objects;
//对象在网络上传输需要进行对象序列化

@Getter@Setter
public class Express implements Serializable {
    private String number;
    private String company;
    private int code;

    public Express(String number, String company, int code) {
        this.number = number;
        this.company = company;
        this.code = code;
    }
    public Express() {
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Express express = (Express) o;
        return code == express.code ;
    }
    @Override
    public int hashCode() {
        return Objects.hash(number, company, code);
    }
    @Override
    public String toString() {
        return "Express{" +
                "number='" + number + '\'' +
                ", company='" + company + '\'' +
                ", code=" + code +
                '}';
    }
}

2、client:Client.java

package maintest.day12_4_6.mailbox.client;

import maintest.day12_4_6.mailbox.bean.Express;
import maintest.day12_4_6.mailbox.dao.ExpressDao;
import maintest.day12_4_6.mailbox.expressenum.Operation;

import java.io.*;
import java.net.Socket;
import java.util.ArrayList;

import static maintest.day12_4_6.mailbox.controller.Main.v;

public class Client {
    private static Socket socket;
    private static final String SERVER_ADDRESS="localhost";

    private static InputStream is;
    private static OutputStream os;
    private static ObjectInputStream ois;
    private static ObjectOutputStream oos;
    private static BufferedWriter bw;
    private static BufferedReader br;
    private static DataOutputStream dos;
    private static DataInputStream dis;

    //建立Socket
    public static Socket linkServer() throws IOException {
        socket = new Socket(SERVER_ADDRESS,55577);
        return socket;
    }
    //关闭Socket
    public static void closeServer() throws IOException {
        socket.close();
    }
    //关闭文件
    public static void fileClose() throws IOException {
        if(is!=null){
            is.close();
        }
        if(os!=null){
            os.close();
        }
        if(ois!=null){
            ois.close();
        }
        if(oos!=null){
            oos.close();
        }
        if(br!=null){
            br.close();
        }
        if(bw!=null){
            bw.close();
        }

    }


    //读取文件信息  READ_EXPRESS_FROM_FILE
    public static boolean readExpressFromFile() {
        boolean result=false;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            dis = new DataInputStream(is);

            //写数据
            dos.writeInt(Operation.READ_EXPRESS_FROM_FILE.ordinal());
            dos.flush();
            result=dis.readBoolean();
            ois=new ObjectInputStream(is);
            ExpressDao.delCab.setMailList((ArrayList<Express>)ois.readObject());

        }catch (Exception e){
            v.readFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.readFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.readFileFail();
            }
        }
        return result;
    }

    /**
     * @description: 据邮件number从集合中找寻对应邮件（（邮件未找到时返回null）
     * @param: String  number：邮件number编号
     * @return: Express  根据number在邮箱柜找到的邮件对象
     */
    public static Express findByNumber(String number){
        Express express=null;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.FIND_BY_NUMBER.ordinal());
            dos.flush();

            //写数据
            bw=new BufferedWriter(new OutputStreamWriter(os));
            bw.write(number);
            bw.newLine();
            bw.flush();

            //读数据
            ois=new ObjectInputStream(is);
            express=(Express)ois.readObject();
        }catch (Exception e){
            v.findFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.findFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.findFileFail();
            }
        }
        return express;
    }

    /**
     * @description: 添加邮件
     * @param: Express:要添加的邮件
     * @return: boolean  true:添加成功   false：添加失败
     */
    public static boolean add(Express express)  {
        boolean result=false;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.ADD.ordinal());
            dos.flush();

            oos=new ObjectOutputStream(os);
            //将邮件对象（邮件未找到时返回null）返回客户端
            oos.writeObject(express);
            oos.flush();

            //获取添加结果：  true:添加成功   false:添加失败
            dis = new DataInputStream(is);
            result=dis.readBoolean();
        }catch (Exception e){
            v.writeFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.writeFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.writeFileFail();
            }
        }
        return result;
    }

    /**
     * @description: 删除邮件
     * @param: Express:要删除的邮件
     * @return: boolean  true:删除成功   false：删除失败
     */
    public static boolean delete(Express express) {
        boolean result=false;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.DELETE.ordinal());
            dos.flush();

            oos=new ObjectOutputStream(os);
            //将邮件对象（邮件未找到时返回null）返回客户端
            oos.writeObject(express);
            oos.flush();

            //获取添加结果：  true:删除成功   false:删除失败
            dis = new DataInputStream(is);
            result=dis.readBoolean();
        }catch (Exception e){
            v.writeFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.writeFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.writeFileFail();
            }
        }
        return result;
    }

    /**
     * @description: 根据取件码查找对应快递
     * @param:   int   code:取件码
     * @return: Express: 查找到的邮件对象
     */
    public static Express findByCode(int code){
        Express express=null;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.FIND_BY_CODE.ordinal());
            dos.flush();

            dos=new DataOutputStream(os);
            dos.writeInt(code);
            dos.flush();

            ois = new ObjectInputStream(is);
            express=(Express)ois.readObject();
            System.out.println(express);
        }catch (Exception e){
            v.showFault();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.showFault();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.showFault();
            }
        }
        return express;
    }
}

3、controller:Main

package maintest.day12_4_6.mailbox.controller;

import maintest.day12_4_6.mailbox.bean.Express;
import maintest.day12_4_6.mailbox.client.Client;
import maintest.day12_4_6.mailbox.view.View;

import java.util.Scanner;

/**
 * @version: V1.0
 * @author: LiLi
 * @className:  Game
 * @packageName:  day08_3_6.controller
 * @description:
 * @data: 2020-10-17 7:20
 **/
public class Main {
    private static Scanner input=new Scanner(System.in);
    public static View v=new View();
    private static Client m=new Client();

    public static void main(String[] args) {
        v.welcome();
        while(true){
            int num=v.vmenu();
            switch (num){
                //管理员界面
                case 1:cController();break;
                //用户界面
                case 2:uController();break;
                //退出系统
                case 0:v.bye();return;
                default:return;
            }
        }
    }
    /**
     * @description: 管理员界面  1:快递录入	2:删除快递	3:修改快递	4:查看所有快递	0:返回首页	-1:退出
     * @param:
     * @return:
     */
    public static void cController(){
        int num=v.cmenu();
        switch (num){
            //快递录入
            case 1: {
                Express e1=v.insert();//快递信息录入提示
                if(!m.readExpressFromFile()){
                    break;
                }
                Express e2=m.findByNumber(e1.getNumber());//快递柜是否已有此快递
                if(e2==null){
                    if(m.add(e1)){//快递柜无此快递 添加
                        v.success(1);
                    }
                }else{
                    v.expressExist();//快递柜有此快递 提示
                }
            }break;
            //删除快递
            case 2:{
                String number=v.getNumber();//快递单号录入 提示
                if(!m.readExpressFromFile()){
                    break;
                }
                Express e1=m.findByNumber(number);//快递柜是否已有此快递
                if(e1==null){
                    v.expressNotExist();//快递柜无此快递 提示
                }else {
                    int type=v.confirmedDelete();//提示：确认删除?  1:确认删除  0：取消
                    if(type==1){
                        if(!m.delete(e1)) {//删除失败
                            break;
                        }
                        else{//删除成功
                            v.success(2);
                        }
                    }else {
                        return;
                    }
                }
            }break;
            //更新快递
            case 3: {
                String number = v.getNumber();//快递单号录入 提示
                if(!m.readExpressFromFile()){
                    break;
                }
                Express e1 = m.findByNumber(number);//快递柜是否已有此快递
                if (e1 == null) {
                    v.expressNotExist();//快递柜无此快递 提示
                } else {
                    Express e2=new Express();
                    v.update(e2);//更新快递信息录入 提示
                    if(!m.delete(e1)){//删除失败
                        break;
                    }
                    if(!m.add(e2)){//添加失败
                        break;
                    }
                    v.success(3);
                }
            }break;
            //查找所有快递
            case 4:{
                if(!m.readExpressFromFile()){//从文件中读取所有快递失败
                    break;
                }
                v.printAll();
            }break;
            //返回主界面
            case 0:return;
            //退出系统
            case -1:v.bye();System.exit(0);
        }
    }
    /**
     * @description: 管理员界面 1:取快递	0:返回主菜单	-1:退出
     * @param:
     * @return:
     */
    public static void uController(){
        int num=v.umenu();
        switch (num){
            //取件
            case 1: {
                int code = v.inputCode();//输入取件码
                if(!m.readExpressFromFile()){//从文件中读取所有快递失败
                    break;
                }
                Express e = m.findByCode(code);//找到对应快递
                if(!m.delete(e)){
                    //删除失败
                    break;
                }
                v.success(4);
                if (e == null) {
                    v.expressNotExist();//提示  没有对应快递
                } else {
                    v.printExpress(e);  //提示 显示快递信息

                }
            }break;
            //返回首页
            case 0:return;
            //退出系统
            case -1:v.bye();System.exit(0);break;
        }
    }
}

4、dao:ExpressDao

package maintest.day12_4_6.mailbox.dao;

import maintest.day12_4_6.mailbox.bean.Express;
import maintest.day12_4_6.mailbox.controller.Main;
import maintest.day12_4_6.mailbox.deliverycabinet.DeliveryCabinet;

import java.io.*;
import java.util.Iterator;
import java.util.Random;

import static maintest.day11_4_4.mailbox.controller.Main.v;

/**
 * @version: V1.0
 * @author: LiLi
 * @className:  ExpressDao
 * @packageName:  day08_3_6.dao
 * @description:  数组操作
 * @data: 2020-10-17 8:52
 **/
public class ExpressDao {
    private static final int DEL_CAPACITY=10;//快递柜初试容量
    public static DeliveryCabinet delCab=new DeliveryCabinet(DEL_CAPACITY);//新建一个快递柜
    private Random random=new Random();
    public static final String filePath="src\\maintest\\day12_4_6\\mailbox\\Express.txt";//文件相对存储路径

    /**
     * @description: 管理员操作：将文件中所有邮件信息读入集合中 用集合存储
     * @param:
     * @return: boolean  true:读取成功 false:读取失败
     */
    public boolean readExpressFromFile() {
        delCab.getMailList().clear();//清空集合
        try {
            File file = new File(filePath);
            if(!file.exists()){
                file.createNewFile();
            }
            InputStreamReader read = new InputStreamReader(new FileInputStream(file));
            BufferedReader bufferedReader = new BufferedReader(read);
            String lineTxt = null;
            while ((lineTxt = bufferedReader.readLine()) != null) {
                Express express=new Express();
                String[] s=lineTxt.split(" ");
                express.setNumber(s[0].toString());
                express.setCompany(s[1].toString());
                express.setCode(Integer.parseInt(s[2]));
                delCab.getMailList().add(express);
            }
            read.close();
            return true;
        } catch (Exception e) {
            v.readFileFail();
        }
        return false;
    }
    /**
     * @description: 管理员操作：判断快递柜中是否有对应单号的快递
     * @param: String
     * @return: Express    Express :快递柜中有对应快递 null:快递柜中无对应快递
     */
    public Express findByNumber(String number){
        for(int i=0;i<delCab.getMailList().size();i++){
            if(delCab.getMailList().get(i).getNumber().equals(number)){
                return delCab.getMailList().get(i);
            }
        }
        return null;
    }

    /**
     * @description: 管理员操作 将一件邮件信息存入文件
     * @param:Express
     * @return: void
     */
    public void addExpressToFile(Express e){
        try {
            File file = new File(filePath);
            if(!file.exists()){
                file.createNewFile();
            }
            OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(file,true));//append:true
            BufferedWriter bufferedWriter = new BufferedWriter(write);
            String lineTxt = null;
            lineTxt=e.getNumber()+" "+e.getCompany()+" "+e.getCode();
            if(file.length()>0)//文件非空
                bufferedWriter.write("\r\n"+lineTxt);//换行
            else{   //文件为空
                bufferedWriter.write(lineTxt);//无需换行
            }
            bufferedWriter.flush();//刷新缓存 ****注意！！
            write.close();
        } catch (IOException e1) {
            v.writeFileFail();
        }
    }
    /**
     * @description: 管理员操作： 删除原文将 创建新文件 并排除所需删除文件后将剩余所有文件写入
     * @param:  Express
     * @return: void
     */
    public void writeExpressToFile(Express e, File file){
        try {
            OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(file,true));
            BufferedWriter bufferedWriter = new BufferedWriter(write);
            String lineTxt = null;
            lineTxt=e.getNumber()+" "+e.getCompany()+" "+e.getCode();
            if(file.length()>0)//文件非空
                bufferedWriter.write("\r\n"+lineTxt);//换行
            else{   //文件为空
                bufferedWriter.write(lineTxt);//无需换行
            }
            bufferedWriter.flush();
            write.close();
        } catch (IOException e1) {
            v.writeFileFail();
        }
    }

    /**
     * @description: 管理员操作：像快递柜中添加快递
     * @param: Express
     * @return: void
     */
    public boolean add(Express e){
        if(!existEmpty())
            return false;
        //产生随机取件码
        int code=randomCode();
        e.setCode(code);
        delCab.getMailList().add(e);
        addExpressToFile(e);
        return true;
    }
    /**
     * @description: 产生[90000,99999]不重复的随机取件码
     * @param:
     * @return: int
     */
    public int randomCode(){
        while (true){
            int code= random.nextInt(90000)+10000;
            Express e=findByCode(code);
            if(e==null){
                return  code;
            }
        }
    }
    /**
     * @description: 判断邮件柜是否已满
     * @param:
     * @return: boolean
     */
    public boolean existEmpty(){
        return delCab.getMailList().size()<DEL_CAPACITY;
    }


    public File creatNewFile(){
        try{
            File file = new File(filePath);
            if(file.exists()){
                file.delete();
                file.createNewFile();
                return file;
            }
        }catch (Exception e){
            Main.v.createFileFail();
        }
        return null;
    }
    /**
     * @description: 管理员操作：删除快递柜中对应单号的快递
     * @param: Express
     * @return: void
     */
    public boolean delete(Express e)  {
        readExpressFromFile();
        delCab.getMailList().remove(e);
        File file=creatNewFile();
        try{
            Iterator<Express> it=delCab.getMailList().iterator();
            while(it.hasNext()){
                Express e1=(Express)it.next();
                writeExpressToFile(e1,file);
            }
            return  true;
        }catch (Exception e1){
            v.writeFileFail();
        }
        return false;
    }
    /**
     * @description: 管理员操作：在快递柜中寻找对应取件码的快递件
     * @param: int code
     * @return: Express    Express:找到对应取件码的快递  null:未找到对应的快递
     */
    public Express findByCode(int code){
        for(int i=0;i<delCab.getMailList().size();i++){
                if(delCab.getMailList().get(i)!=null&&delCab.getMailList().get(i).getCode()==code) {
                    return delCab.getMailList().get(i);
                }
        }
        return null;
    }
}

5、deliveryCabinet

package maintest.day12_4_6.mailbox.deliverycabinet;

import lombok.Getter;
import lombok.Setter;
import maintest.day12_4_6.mailbox.bean.Express;

import java.io.Serializable;
import java.util.ArrayList;

@Getter@Setter
public class DeliveryCabinet implements Serializable {

    private int delCapacity;//快递柜容量
    private String delName;//快递柜名
    private static ArrayList<Express> mailList=new ArrayList<>();//存储快递的数据结构

    public ArrayList<Express> getMailList(){
        return  mailList;
    }
    public void setMailList(ArrayList<Express> mail){
        mailList=mail;
    }
    public DeliveryCabinet(int delCapacity) {
        this.delCapacity=delCapacity;
    }

    public DeliveryCabinet(int delCapacity, String delName) {
        this.delCapacity=delCapacity;
        this.delName=delName;
    }
}

6、expressenum:Operation

package maintest.day12_4_6.mailbox.expressenum;

public enum Operation {
    READ_EXPRESS_FROM_FILE,FIND_BY_NUMBER,ADD,DELETE,FIND_BY_CODE
}

7、server :Server.java LogicThread.java

package maintest.day12_4_6.mailbox.server;

import maintest.day12_4_6.mailbox.bean.Express;
import maintest.day12_4_6.mailbox.dao.ExpressDao;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static Socket socket;
    private static ServerSocket ss;
    private static final int PORT=55577;
    private static ExpressDao m=new ExpressDao();

    private static InputStream is;
    private static OutputStream os;
    private static ObjectInputStream ois;
    private static ObjectOutputStream oos;
    private static BufferedWriter bw;
    private static BufferedReader br;
    private static DataInputStream dis;
    private static DataOutputStream dos;


    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ss = new ServerSocket(PORT);
       while(true){
           socket= ss.accept();
           System.out.println("服务器已启动");
           new LogicThread(socket);
        }
    }
    public static void fileClose() throws IOException {
        if(is!=null){
            is.close();
        }
        if(os!=null){
            os.close();
        }
        if(ois!=null){
            ois.close();
        }
        if(bw!=null){
            bw.close();
        }
    }

    //根据客户端的不同请求 执行不同操作
    public static void getClientLink() throws IOException, ClassNotFoundException {
        is=socket.getInputStream();
        dis = new DataInputStream(is);
        int result=dis.readInt();
        //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
        //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
        switch (result){
            case 0:readExpressFromFile();break;
            case 1:findByNumber();break;
            case 2:add();break;
            case 3:delete();break;
            case 4:findByCode();break;
        }
    }

    //据邮件number从集合中找寻对应邮件
    public static void findByNumber() throws IOException {
        os = socket.getOutputStream();
        br=new BufferedReader(new InputStreamReader(is));
        String number=br.readLine();

        //根据邮件number从集合中找寻对应邮件（（邮件未找到时返回null）
        Express express=m.findByNumber(number);
        oos=new ObjectOutputStream(os);
        //将邮件对象（邮件未找到时返回null）返回客户端
        oos.writeObject(express);
        oos.flush();
    }

    //读取文件信息  READ_EXPRESS_FROM_FILE
    public static void readExpressFromFile() throws IOException, ClassNotFoundException {
        os = socket.getOutputStream();
        dos=new DataOutputStream(os);
        boolean readResult=m.readExpressFromFile();
        System.out.println("read success"+readResult);
        System.out.println(ExpressDao.delCab.getMailList().size());
        dos.writeBoolean(readResult);
        dos.flush();
        oos=new ObjectOutputStream(os);
        oos.writeObject(m.delCab.getMailList());
    }


    //添加邮件
    public static void add() throws IOException, ClassNotFoundException {
        os = socket.getOutputStream();
        ois=new ObjectInputStream(is);
        Express express=(Express)ois.readObject();
        boolean result=m.add(express);

        dos=new DataOutputStream(os);
	    dos.writeBoolean(result);
	    dos.flush();
    }
    //从文件中删除指定邮件对象
    public static void delete() throws IOException, ClassNotFoundException {
        os = socket.getOutputStream();
        ois=new ObjectInputStream(is);
        Express express=(Express)ois.readObject();
        boolean result=m.delete(express);

        dos=new DataOutputStream(os);
        dos.writeBoolean(result);
        dos.flush();
    }
    //根据取件码查找指定邮件 返回客户端找到的邮件对象
    public static void findByCode() throws IOException {
        os = socket.getOutputStream();
        is=socket.getInputStream();
        dis=new DataInputStream(is);
        int code=dis.readInt();

        Express e = m.findByCode(code);//找到对应快递
        oos=new ObjectOutputStream(os);
        oos.writeObject(e);
        oos.flush();
    }
}

package maintest.day12_4_6.mailbox.server;

import lombok.SneakyThrows;

import java.net.Socket;

public class LogicThread extends Thread{
    Socket socket;
    public LogicThread(Socket socket) {
        this.socket=socket;
        start();
    }
    @SneakyThrows
    @Override
    public void run() {
        System.out.println("run");
        Server.getClientLink();
        sleep(100000);
    }
}

8、view:View.java

package maintest.day12_4_6.mailbox.view;


import maintest.day12_4_6.mailbox.bean.Express;
import maintest.day12_4_6.mailbox.dao.ExpressDao;

import java.util.Scanner;

/**
 * @author: LiLi
 * @className: View
 * @packageName: view
 * @description:  快递驿站的视图显示
 * @data: 2020-10-16 23：13
 **/
public class View {
    private static Scanner input=new Scanner(System.in);
    private int num;
    private String inputText;



    /**
     * @description: 欢迎
     * @param:
     * @return: void
     */
    public void welcome(){
        System.out.println("-----欢迎来到LiLi的快递e站-----");
    }
    /**
     * @description: 输入出错
     * @param:
     * @return: void
     */
    public void showFault(){
        System.out.println("输入有误，请重新输入！");
    }
    /**
     * @description: 结束
     * @param:
     * @return: void
     */
    public void bye(){
        System.out.println("--------感谢您的使用！希望您身体健康，生活愉快！bye~~---------");
    }
    public void success(int type){
        switch (type){
            case 1:
                System.out.println("添加成功!");break;
            case 2:
                System.out.println("删除成功！");break;
            case 3:
                System.out.println("更行快递成功！");break;
            case 4:
                System.out.println("操作成功");break;
                default:return;
        }
    }
    public void findFileFail(){
        System.out.println("找不到指定文件！");
    }
    public void readFileFail(){
        System.out.println("读取文件内容出错！");
    }
    public void writeFileFail(){
        System.out.println("文件写出失败！");
    }
    public void createFileFail(){
        System.out.println("文件创建失败！");
    }

    /**
     * @description: 提示 快递柜中已有对应快递
     * @param:
     * @return: void
     */
    public void expressExist(){
        System.out.println("快递柜中已有此快递哦！");
    }
    /**
     * @description: 提示 快递柜中没有对应快递
     * @param:
     * @return: void
     */
    public void expressNotExist(){
        System.out.println("抱歉！快递柜中无此快递~");
    }
    /**
     * @description: 输入需要删除的快递信息
     * @param:
     * @return: String 返回需要删除的快递单号
     */
    public String getNumber(){
        System.out.println("请输入要操作的快递单号:");
        String number=input.nextLine();
        return number;
    }
    /**
     * @description: 显示快递信息
     * @param:
     * @return: void
     */
    public void printExpress(Express e){
        System.out.println("快递单号："+e.getNumber()+"\t快递公司："+e.getCompany()+"\t取件码"+e.getCode());
    }


    /**
     * @description: 主菜单
     * @param:
     * @return: int 1:管理员 2：普通用户 0：退出登录
     */
    public int vmenu(){
        System.out.println("请选择身份:");
        System.out.println("1:管理员\t2:普通用户\t0:退出登录");

        //next nextLine区别：next不能读取空格；遇到空白符（空格 回车 tab等)结束；nextLine:读取回车键结束
        inputText=input.nextLine();
        try{
            //将字符串转换成数据
            num=Integer.parseInt(inputText);
            if(num<0||num>2){
                showFault();
                return vmenu();
            }
        }catch (NumberFormatException e){
            showFault();
            return vmenu();
        }
        return num;
    }
    /**
     * @description: 管理员界面
     * @param:
     * @return: int 1:快递录入	2:删除快递	3:修改快递	4:查看所有快递	0:返回首页	-1:退出
     */
    public int cmenu(){
        System.out.println("----欢迎来到管理员界面----");
        System.out.println("请选择操作");
        System.out.println("1:快递录入\t2:删除快递\t3:修改快递\t4:查看所有快递\t0:返回首页\t-1:退出");
        inputText=input.nextLine();
        try{
            num=Integer.parseInt(inputText);
            if(num<-1||num>4){
                showFault();
                return cmenu();
            }
        }catch (NumberFormatException e){
            showFault();
            return cmenu();
        }
        return num;
    }
    /**
     * @description: 用户界面
     * @param:
     * @return: int 1:取快递	0:返回主菜单	-1:退出
     */
    public int umenu(){
        System.out.println("----欢迎来到用户界面----");
        System.out.println("请选择操作");
        System.out.println("1:取快递\t0:返回主菜单\t-1:退出");
        inputText=input.nextLine();
        try{
            num=Integer.parseInt(inputText);
            if(num<-1||num>1){
                showFault();
                return umenu();
            }
        }catch (NumberFormatException e){
            showFault();
            return umenu();
        }
        return num;
    }

    /**
     * @description: 管理员操作：插入
     * @param:
     * @return: Express
     */
    public Express insert(){
        System.out.println("请输入快递单号：");
        String number=input.nextLine();
        System.out.println("请输入快递公司");
        String company=input.nextLine();
        Express e=new Express();
        e.setNumber(number);
        e.setCompany(company);
        return e;
    }

    /**
     * @description: 确认删除提示
     * @param:
     * @return: int 1:确认删除	0:取消删除
     */
    public int confirmedDelete(){
        System.out.println("确认删除？");
        System.out.println("1:确认删除\t0:取消删除");
        inputText=input.nextLine();
        try{
            num=Integer.parseInt(inputText);
            if(num<0||num>1){
                showFault();
                return confirmedDelete();
            }
        }catch (NumberFormatException e){
            showFault();
            return confirmedDelete();
        }
        return num;
    }
    /**
     * @description: 更新操作
     * @param:
     * @return: void
     */
    public void update(Express e){
        System.out.println("请输入新的快递单号");
        String number=input.nextLine();
        System.out.println("请输入新的快递公司");
        String company=input.nextLine();
        e.setNumber(number);
        e.setCompany(company);
    }

    public int inputCode(){
        System.out.println("请输入快递取货码");
        int code;
        try{
            code=input.nextInt();
            if(code<10000||code>99999){
                showFault();
                return inputCode();
            }
            input.nextLine();
        }catch (Exception e){
            showFault();
            return inputCode();
        }
        return code;
    }

    /**
     * @description: 显示邮柜中所有快递
     * @param:  Express[][]
     * @return: void
     */
    public void printAll(){
        for(int i = 0; i< ExpressDao.delCab.getMailList().size(); i++){
                    printExpress(ExpressDao.delCab.getMailList().get(i));
        }
    }
}

二、图书管理

一、任务要求

• 管理员登陆
• 图书管理
  2.1 图书新增
  2.2 图书修改
  2.3 图书删除
  2.4 根据图书名称模糊查找图书
  2.5 查看所有图书 （三种排序）
  - 价格从高到低排序
  - 价格从低到高排序
  - 新旧排序(出版日期排序)

二、源码框架

三、源码

1、bean Administrator.java Book.java

package maintest.day12_4_6.librarysystem.bean;

import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;

@Getter@Setter
public class Administrator implements Serializable {
    private String userName;
    private String password;

    public Administrator() {
    }

    public Administrator(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }
}

package maintest.day12_4_6.librarysystem.bean;

import lombok.Getter;
import lombok.Setter;

import java.io.Serializable;
import java.util.Comparator;
import java.util.Date;
import java.util.Objects;

@Getter@Setter
public class Book implements Serializable {
    private String book_name;//书名
    private double price;//价格
    private Date publication_date;//出版日期

    public Book() {
    }

    public Book(String book_name, double price, Date publication_date) {
        this.book_name = book_name;
        this.price = price;
        this.publication_date = publication_date;
    }

    @Override
    public String toString() {
        return "Book{" +
                "book_name='" + book_name + '\'' +
                ", price=" + price +
                ", publication_date=" + publication_date +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Book book = (Book) o;
        return Double.compare(book.price, price) == 0 &&
                Objects.equals(book_name, book.book_name) &&
                Objects.equals(publication_date, book.publication_date);
    }

    @Override
    public int hashCode() {
        return Objects.hash(book_name, price, publication_date);
    }

    //按照书籍价格进行升序排序 价格相同依照姓名排序
    public static class BookCompareByPriceAsc implements Comparator,Serializable {// 书籍自带的一个比较器
        public int compare(Object o1, Object o2) {
            Book s1 = (Book) o1;// 转型
            Book s2 = (Book) o2;// 转型
            int result = s1.getPrice()> s2.getPrice() ? 1 : (s1.getPrice() == s2.getPrice() ? 0 : -1);
            if (result == 0) {
                result = s1.getBook_name().compareTo(s2.getBook_name());
            }
            return result;
        }
    }
    //按照书籍价格进行降序排序 价格相同依照姓名排序
    public static class BookCompareByPriceDesc implements Comparator {// 老师自带的一个比较器
        public int compare(Object o1, Object o2) {
            Book s1 = (Book) o1;// 转型
            Book s2 = (Book) o2;// 转型
            int result = s1.getPrice()> s2.getPrice() ? -1 : (s1.getPrice() == s2.getPrice() ? 0 : 1);
            if (result == 0) {
                result = s1.getBook_name().compareTo(s2.getBook_name());
            }
            return result;
        }
    }
    //按照书籍出版日期进行排序
    public static class BookCompareByDate implements Comparator {// 老师自带的一个比较器
        public int compare(Object o1, Object o2) {
            Book s1 = (Book) o1;// 转型
            Book s2 = (Book) o2;// 转型
            int result = s1.getPublication_date().compareTo(s2.getPublication_date()) ;
            if (result == 0) {
                result = s1.getBook_name().compareTo(s2.getBook_name());
            }
            return result;
        }
    }

}

2、client:Client

package maintest.day12_4_6.librarysystem.client;

import maintest.day12_4_6.librarysystem.bean.Administrator;
import maintest.day12_4_6.librarysystem.bean.Book;
import maintest.day12_4_6.librarysystem.dao.BookDao;
import maintest.day12_4_6.librarysystem.libraryenum.Operation;

import java.io.*;
import java.net.Socket;
import java.util.List;
import java.util.TreeSet;

import static maintest.day12_4_6.librarysystem.controller.Main.v;

public class Client {
    private static Socket socket;
    private static final String SERVER_ADDRESS="localhost";

    private static InputStream is;
    private static OutputStream os;
    private static ObjectInputStream ois;
    private static ObjectOutputStream oos;
    private static BufferedWriter bw;
    private static BufferedReader br;
    private static DataOutputStream dos;
    private static DataInputStream dis;


   /* public static void main(String[] args) throws IOException, ClassNotFoundException {
        //readExpressFromFile();
       // Express express=findByNumber("1001");
       *//* Express express=new Express();
        express.setCompany("xt");
        express.setNumber("1004");
        add(express);*//*
       *//* Express express=new Express();
        express.setCompany("yt");//1001 yt 33588
        express.setNumber("1001");
        express.setCode(33588);
        delete(express);*//*
       findByCode(93425);
    }*/

    //建立Socket
    public static Socket linkServer() throws IOException {
        socket = new Socket(SERVER_ADDRESS,55577);
        return socket;
    }
    //关闭Socket
    public static void closeServer() throws IOException {
        socket.close();
    }
    //关闭文件
    public static void fileClose() throws IOException {
        if(is!=null){
            is.close();
        }
        if(os!=null){
            os.close();
        }
        if(ois!=null){
            ois.close();
        }
        if(oos!=null){
            oos.close();
        }
        if(br!=null){
            br.close();
        }
        if(bw!=null){
            bw.close();
        }

    }


    //读取文件信息  READ_EXPRESS_FROM_FILE
    public static boolean readBookFromFile() {
        boolean result=false;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            dis = new DataInputStream(is);

            //写数据
            dos.writeInt(Operation.READ_BOOK_FROM_FILE.ordinal());
            dos.flush();
            result=dis.readBoolean();
            ois=new ObjectInputStream(is);
            BookDao.bookList=(TreeSet<Book>)ois.readObject();
            System.out.println(BookDao.bookList.size());
        }catch (Exception e){
            v.readFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.readFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.readFileFail();
            }
        }
        return result;
    }
    public static boolean login(Administrator admin){
        boolean result=false;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.LOGIN.ordinal());
            dos.flush();

            oos=new ObjectOutputStream(os);
            oos.writeObject(admin);
            oos.flush();

            //登录结果：  true:登录成功   false:登录失败
            dis = new DataInputStream(is);
            result=dis.readBoolean();
        }catch (Exception e){
            v.writeFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.writeFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.writeFileFail();
            }
        }
        return result;
    }
    /**
     * @description: 据邮件number从集合中找寻对应邮件（（邮件未找到时返回null）
     * @param: String  number：邮件number编号
     * @return: Express  根据number在邮箱柜找到的邮件对象
     */
    public static Book findByBookName(String name){
        Book book=null;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.FIND_BY_BOOK_NAME.ordinal());
            dos.flush();

            //写数据
            bw=new BufferedWriter(new OutputStreamWriter(os));
            bw.write(name);
            bw.newLine();
            bw.flush();

            //读数据
            ois=new ObjectInputStream(is);
            book=(Book)ois.readObject();
        }catch (Exception e){
            v.findFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.findFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.findFileFail();
            }
        }
        return book;
    }

    /**
     * @description: 添加邮件
     * @param: Express:要添加的邮件
     * @return: boolean  true:添加成功   false：添加失败
     */
    public static boolean add(Book book)  {
        boolean result=false;
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.ADD.ordinal());
            dos.flush();

            oos=new ObjectOutputStream(os);
            //将邮件对象（邮件未找到时返回null）返回客户端
            oos.writeObject(book);
            oos.flush();

            //获取添加结果：  true:添加成功   false:添加失败
            dis = new DataInputStream(is);
            result=dis.readBoolean();
        }catch (Exception e){
            v.writeFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.writeFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.writeFileFail();
            }
        }
        return result;
    }

    /**
     * @description: 删除邮件
     * @param: Express:要删除的邮件
     * @return: boolean  true:删除成功   false：删除失败
     */
    public static void delete(Book book) {
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.DELETE.ordinal());
            dos.flush();

            oos=new ObjectOutputStream(os);
            //将邮件对象（邮件未找到时返回null）返回客户端
            oos.writeObject(book);
            oos.flush();
        }catch (Exception e){
            v.writeFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.writeFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.writeFileFail();
            }
        }
    }
    //模糊查询
    public static void matchFindBooks(String name) {
        try{
            //打开一个套接字，准备发送请求
            Socket socket= linkServer();
            //建立传输流
            os=socket.getOutputStream();
            is = socket.getInputStream();
            dos=new DataOutputStream(os);
            //写数据
            //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
            //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
            dos.writeInt(Operation.MATCH_FIND_BOOKS.ordinal());
            dos.flush();

            //写数据
            bw=new BufferedWriter(new OutputStreamWriter(os));
            bw.write(name);
            bw.newLine();
            bw.flush();
            ois=new ObjectInputStream(is);
            BookDao.arrList=(List<Book>) ois.readObject();
        }catch (Exception e){
            v.findFileFail();
        }finally {
            try {
                fileClose();
            } catch (IOException e) {
                v.findFileFail();
            }
            try {
                closeServer();
            } catch (IOException e) {
                v.findFileFail();
            }
        }
    }
}

3、controller:Main.java

package maintest.day12_4_6.librarysystem.controller;

import maintest.day12_4_6.librarysystem.bean.Administrator;
import maintest.day12_4_6.librarysystem.bean.Book;
import maintest.day12_4_6.librarysystem.client.Client;
import maintest.day12_4_6.librarysystem.view.View;

/**
 * @version: V1.0
 * @author: LiLi
 * @className:  Library
 * @packageName:  day11_4_4.librarysystem.controller
 * @description:
 * @data: 2020-10-22 10:55
 **/
public class Main {
    public  static View v=new View();
    private static Client m=new Client();

    public static void main(String[] args) {
        v.welcome();
        Administrator admin=v.vlogin();//管理员登录
        if(!m.login(admin)){
            v.showFault(4);
        }

        while(true){
            int num=v.cmenu();//主菜单
            switch (num){
                //新增图书
                case 1:{
                    Book book=v.addBook();//图书信息录入提示
                    System.out.println(book.getPublication_date());
                    if(!m.readBookFromFile()){
                        break;
                    }
                    if(m.add(book)){
                        v.success();
                    }else{
                        v.expressExist();//图书馆有此图书 提示
                    }
                }break;
                //修改图书
                case 2:{
                    String name=v.findByBookName();//找到要修改的旧书书名
                    if(!m.readBookFromFile()){
                        break;
                    }
                    Book book1=m.findByBookName(name);//找到该书
                    Book book2=v.update();//获取新书对象
                    m.delete(book1);//删除旧书对象
                    System.out.println(book2);
                    m.add(book2);//加入新书

                }break;
                //删除图书
                case 3:{
                    String name=v.findDeleteBookName();//输入要删除的书名
                    if(!m.readBookFromFile()){
                        break;
                    }
                    Book book=m.findByBookName(name);//找到要删除的图书
                    int chose=v.confirmedDelete();//确认删除
                    if(chose==1){
                        m.delete(book);//删除指定图书
                    }else {
                        break;
                    }

                }break;
                //模糊查询
                case 4:{
                    String book_name=v.findBook();//输入查询信息
                    if(!m.readBookFromFile()){
                        break;
                    }
                    m.matchFindBooks(book_name);//根据查询信息进行模糊查询
                    v.printMatchBooks();//打印查询结果
                }break;
                //查看图书
                case 5:{
                    if(!m.readBookFromFile()){
                        break;
                    }
                    num=v.showAllBooks();//输入以哪种方式进行打印
                    if(num==1){
                        v. showBookByPriceAsc();//价格从低到高排序
                    }else if(num==2){
                        v.showBookByPriceDesc();//价格从高到低排序
                    }else {
                        v.showBookByDate();//新旧排序(出版日期排序)
                    }
                }break;
                case -1:System.exit(0);//退出系统
                case 0:break; //返回主页面
                    default:break;
            }

        }
    }
}

4、dao:BookDao.java

package maintest.day12_4_6.librarysystem.dao;

import maintest.day12_4_6.librarysystem.bean.Administrator;
import maintest.day12_4_6.librarysystem.bean.Book;
import maintest.day12_4_6.librarysystem.controller.Main;

import java.io.*;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.TreeSet;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * @version: V1.0
 * @author: LiLi
 * @className:  BookDao
 * @packageName:  day10_4_3.dao
 * @description:  集合操作
 * @data: 2020-10-20 0:49
 **/
public class BookDao {
    public static TreeSet<Book> bookList=new TreeSet<Book>(new Book.BookCompareByPriceAsc());
    public static List<Book> arrList=new ArrayList<Book>();
    private static final int  CAPACITY=100;//图书馆初始图书容量
    private static final ArrayList<Administrator> adminList=new ArrayList<>();
    public static final String filePath="src\\maintest\\day12_4_6\\librarysystem\\Library.txt";//文件相对存储路径

    static {
        adminList.add(new Administrator("admin","admin"));
    }
    public boolean login(Administrator admin){
        Iterator it=adminList.iterator();
        while(it.hasNext()){
            Administrator user=(Administrator)it.next();
            if(user.getUserName().equals(admin.getUserName())&&user.getPassword().equals(admin.getPassword()))
                return true;
        }
        return false;
    }
    /**
     * @description: 模糊查询
     * @param: String
     * @return: void
     */
    public void matchFindBooks(String name){
        Pattern pattern = Pattern.compile(name);
        Iterator<Book> it=bookList.iterator();
        while (it.hasNext()){
            Book book=(Book)it.next();
            Matcher matcher = pattern.matcher(book.getBook_name());
            if(matcher.find()){
                arrList.add(book);
            }
        }
    }


    /**
     * @description: 管理员操作：将文件中所有邮件信息读入集合中 用集合存储
     * @param:
     * @return: boolean  true:读取成功 false:读取失败
     */
    public boolean readBookFromFile() {
        bookList.clear();//清空集合
        try {
            File file = new File(filePath);
            if(!file.exists()){
                file.createNewFile();
            }
            InputStreamReader read = new InputStreamReader(new FileInputStream(file));
            BufferedReader bufferedReader = new BufferedReader(read);
            String lineTxt = null;
            while ((lineTxt = bufferedReader.readLine()) != null) {
                Book book=new Book();
                String[] s=lineTxt.split(" ");
                book.setBook_name(s[0].toString());
                book.setPrice(Double.parseDouble(s[1]));
                SimpleDateFormat sdf =   new SimpleDateFormat( "yyyy-MM-dd" );
                book.setPublication_date(sdf.parse(s[2]));
                bookList.add(book);
            }
            read.close();
            System.out.println(bookList.size());
            return true;
        } catch (Exception e) {
            Main.v.readFileFail();
        }
        return false;
    }

    /**
     * @description: 管理员操作 将一件邮件信息存入文件
     * @param:Express
     * @return: void
     */
    public void addExpressToFile(Book b){
        try {
            File file = new File(filePath);
            if(!file.exists()){
                file.createNewFile();
            }
            OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(file,true));//append:true
            BufferedWriter bufferedWriter = new BufferedWriter(write);
            String lineTxt = null;
            SimpleDateFormat sdf =   new SimpleDateFormat( "yyyy-MM-dd" );
            lineTxt=b.getBook_name()+" "+b.getPrice()+" "+sdf.format(b.getPublication_date());
            if(file.length()>0)//文件非空
                bufferedWriter.write("\r\n"+lineTxt);//换行
            else{   //文件为空
                bufferedWriter.write(lineTxt);//无需换行
            }
            bufferedWriter.flush();//刷新缓存 ****注意！！
            write.close();
        } catch (IOException e1) {
            Main.v.writeFileFail();
        }
    }
    public File creatNewFile(){
        try{
            File file = new File(filePath);
            if(file.exists()){
                file.delete();
                file.createNewFile();
                return file;
            }
        }catch (Exception e){
            Main.v.createFileFail();
        }
        return null;
    }
    /**
     * @description: 管理员操作： 删除原文将 创建新文件 并排除所需删除文件后将剩余所有文件写入
     * @param:  Express
     * @return: void
     */
    public void writeExpressToFile(Book b, File file){
        try {
            OutputStreamWriter write = new OutputStreamWriter(new FileOutputStream(file,true));
            BufferedWriter bufferedWriter = new BufferedWriter(write);
            String lineTxt = null;
            SimpleDateFormat sdf =   new SimpleDateFormat( "yyyy-MM-dd" );
            lineTxt=b.getBook_name()+" "+b.getPrice()+" "+sdf.format(b.getPublication_date());
            if(file.length()>0)//文件非空
                bufferedWriter.write("\r\n"+lineTxt);//换行
            else{   //文件为空
                bufferedWriter.write(lineTxt);//无需换行
            }
            bufferedWriter.flush();
            write.close();
        } catch (IOException e1) {
            Main.v.writeFileFail();
        }
    }



    /**
     * @description: 图书馆容量是否已满
     * @param:
     * @return:boolean  true:已满 false:未满
     */
    public boolean existEmpty(){
        return bookList.size()<CAPACITY;
    }

    /**
     * @description: 添加图书
     * @param:
     * @return:boolean  true:添加成功 false:添加失败
     */
    public boolean add(Book book){
        if(!existEmpty())
            return false;
        bookList.add(book);
        addExpressToFile(book);
        System.out.println(bookList.size());
        return true;
    }

    /**
     * @description: 根据书名找图书
     * @param:String
     * @return:Book  成功：返回相应对象 失败：返回null
     */
    public Book findByBookName(String name){
        Iterator<Book> it=bookList.iterator();
        while (it.hasNext()){
            Book book=(Book)it.next();
            if(book.getBook_name().equals(name)){
                return book;
            }
        }
        return null;
    }

    /**
     * @description: 删除图书
     * @param:
     * @return:boolean
     */
    public void delete(Book book){
        bookList.remove(book);
        Iterator<Book> it=bookList.iterator();
        File file=creatNewFile();
        while(it.hasNext()){
            Book b=(Book)it.next();
            writeExpressToFile(b,file);
        }
        System.out.println("delete:"+bookList.size());
    }
}

5、libraryenum:Operation.java

package maintest.day12_4_6.librarysystem.libraryenum;

public enum Operation {
    LOGIN,READ_BOOK_FROM_FILE,ADD,FIND_BY_BOOK_NAME,DELETE,MATCH_FIND_BOOKS,
}

6、server:Server.java LogicThread.java

package maintest.day12_4_6.librarysystem.server;

import lombok.SneakyThrows;

import java.net.Socket;

public class LogicThread extends Thread{
    Socket socket;
    public LogicThread(Socket socket) {
        this.socket=socket;
        start();
    }
    @SneakyThrows
    @Override
    public void run() {
        System.out.println("run");
        Server.getClientLink();
        sleep(100000);
    }
}

package maintest.day12_4_6.librarysystem.server;

import maintest.day12_4_6.librarysystem.bean.Administrator;
import maintest.day12_4_6.librarysystem.bean.Book;
import maintest.day12_4_6.librarysystem.dao.BookDao;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static Socket socket;
    private static ServerSocket ss;
    private static final int PORT=55577;
    private static BookDao m=new BookDao();

    private static InputStream is;
    private static OutputStream os;
    private static ObjectInputStream ois;
    private static ObjectOutputStream oos;
    private static BufferedWriter bw;
    private static BufferedReader br;
    private static DataInputStream dis;
    private static DataOutputStream dos;


    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ss = new ServerSocket(PORT);
       while(true){
           socket= ss.accept();
           System.out.println("服务器已启动");
           new LogicThread(socket);
        }
    }
    public static void fileClose() throws IOException {
        if(is!=null){
            is.close();
        }
        if(os!=null){
            os.close();
        }
        if(ois!=null){
            ois.close();
        }
        if(bw!=null){
            bw.close();
        }
    }

    //根据客户端的不同请求 执行不同操作
    public static void getClientLink() throws IOException, ClassNotFoundException {
        is=socket.getInputStream();
        dis = new DataInputStream(is);
        int result=dis.readInt();
        //READ_EXPRESS_FROM_FILE,：将文件中的所有邮件信息读入集合中 用集合存储  FIND_BY_NUMBER：从文件中找寻相应邮件编号的邮件对象
        //ADD：向文件中添加邮件   DELETE：从文件中删除邮件   UPPDATE：更新邮件信息  FIND_BY_CODE根据取件码找寻相关邮件
        switch (result){
            case 0:login();break;
            case 1:readBookFromFile();break;
            case 2:add();break;
            case 3:findByBookName();break;
            case 4:delete();break;
            case 5:matchFindBooks();break;
        }
    }
    public static void login() throws IOException, ClassNotFoundException {
        os = socket.getOutputStream();
        ois=new ObjectInputStream(is);
        Administrator admin=(Administrator) ois.readObject();
        boolean result=m.login(admin);

        dos=new DataOutputStream(os);
        dos.writeBoolean(result);
        dos.flush();
    }
    //模糊查询
    public static void matchFindBooks() throws IOException {
        os = socket.getOutputStream();
        br=new BufferedReader(new InputStreamReader(is));
        String name=br.readLine();
        m.matchFindBooks(name);
        oos=new ObjectOutputStream(os);
        oos.writeObject(m.arrList);
        oos.flush();
    }
    //据书名从集合中找寻对应书籍
    public static void findByBookName() throws IOException {
        os = socket.getOutputStream();
        br=new BufferedReader(new InputStreamReader(is));
        String name=br.readLine();

        //据书名从集合中找寻对应书籍（书籍未找到时返回null）
        Book book=m.findByBookName(name);
        oos=new ObjectOutputStream(os);
        //将邮件对象（邮件未找到时返回null）返回客户端
        oos.writeObject(book);
        oos.flush();
    }

    //读取文件信息  READ_BOOK_FROM_FILE
    public static void readBookFromFile() throws IOException, ClassNotFoundException {
        os = socket.getOutputStream();
        dos=new DataOutputStream(os);
        boolean readResult=m.readBookFromFile();
        System.out.println("first"+m.bookList.size());
        dos.writeBoolean(readResult);
        dos.flush();
        oos=new ObjectOutputStream(os);
        System.out.println("second"+m.bookList.size());
        oos.writeObject(m.bookList);
        oos.flush();
    }

    //添加书籍
    public static void add() throws IOException, ClassNotFoundException {
        os = socket.getOutputStream();
        ois=new ObjectInputStream(is);
        Book book=(Book)ois.readObject();
        boolean result=m.add(book);

        dos=new DataOutputStream(os);
	    dos.writeBoolean(result);
	    dos.flush();
    }
    //从文件中删除指定邮件对象
    public static void delete() throws IOException, ClassNotFoundException {
        os = socket.getOutputStream();
        ois=new ObjectInputStream(is);
        Book book=(Book)ois.readObject();
        m.delete(book);
    }

}

7、view View.java

package maintest.day12_4_6.librarysystem.view;

import maintest.day12_4_6.librarysystem.bean.Administrator;
import maintest.day12_4_6.librarysystem.bean.Book;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.Scanner;
import java.util.TreeSet;

import static maintest.day12_4_6.librarysystem.dao.BookDao.arrList;
import static maintest.day12_4_6.librarysystem.dao.BookDao.bookList;

public class View {
    private Scanner input=new Scanner(System.in);
    private String inputText;
    private int num;

    //提示：欢迎使用
    public void welcome(){
        System.out.println("--------欢迎来到LiLi的图书管理系统-------");
    }
    //提示：书籍录入成功
    public void success(){
        System.out.println("书籍录入成功！");
    }
    //提示：录入失败
    public void expressExist(){
        System.out.println("录入失败，本书图书馆已有！");
    }
    public void findFileFail(){
        System.out.println("找不到指定文件！");
    }
    public void readFileFail(){
        System.out.println("读取文件内容出错！");
    }
    public void writeFileFail(){
        System.out.println("文件写出失败！");
    }
    public void createFileFail(){
        System.out.println("文件创建失败！");
    }

    /**
     * @description: 提示：输入要删除的书名
     * @param:
     * @return:String  返回书名
     */
    public String findDeleteBookName(){
        System.out.println("请输入要删除的图书书名：");
        String book_name;
        try{
            book_name=input.nextLine();
        }catch (Exception e){
            showFault(3);
            return findDeleteBookName();
        }
        return book_name;
    }

    /**
     * @description: 提示：输入查询所有图书的排列方式
     * @param:
     * @return:int  1:价格从低到高排序	2:价格从高到低排序	3:出版日期排序
     */
    public int showAllBooks(){
        System.out.println("请选择查询方式");
        System.out.println("1:价格从低到高排序\t2:价格从高到低排序\t3:出版日期排序");
        int num;
        try{
            num=input.nextInt();
            input.nextLine();
        }catch (Exception e){
            showFault(3);
            return showAllBooks();
        }
        return num;
    }

    /**
     * @description: 按价格从低到高打印所有图书
     */
    public void showBookByPriceAsc(){
        TreeSet<Book> ts = new TreeSet<Book>(new Book.BookCompareByPriceAsc());
        ts.addAll(bookList);
        Iterator<Book> it=ts.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    /**
     * @description: 按价格从高到低打印所有图书
     */
    public void showBookByPriceDesc(){
        TreeSet<Book> ts = new TreeSet<Book>(new Book.BookCompareByPriceDesc());
        ts.addAll(bookList);
        Iterator<Book> it=ts.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    /**
     * @description: 按日期打印所有图书
     */
    public void showBookByDate(){
        TreeSet<Book> ts = new TreeSet<Book>(new Book.BookCompareByDate());
        ts.addAll(bookList);
        Iterator<Book> it=ts.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }

    /**
     * @description: 管理员主界面
     * @return: int  1:添加图书	2:修改图书	3:删除图书	4:模糊查询	5:查看所有图书	0:返回首页	-1:退出
     */
    public int cmenu(){
        System.out.println("----欢迎来到管理员界面----");
        System.out.println("请选择操作");
        System.out.println("1:添加图书\t2:修改图书\t3:删除图书\t4:模糊查询\t5:查看所有图书\t0:返回首页\t-1:退出");
        inputText=input.nextLine();
        try{
            num=Integer.parseInt(inputText);
            if(num<-1||num>5){
                showFault(3);
                return cmenu();
            }
        }catch (NumberFormatException e){
            showFault(3);
            return cmenu();
        }
        return num;
    }

    //提示：管理员登录失败
    public void showFault(int type){
        switch (type){
            case 1:System.out.println("用户名或者密码输入错误，请重新登录！");break;
            case 2:
                System.out.println("日期格式有误，请重新输入！");break;
            case 3:
                System.out.println("输入有误，请重新输入！");break;
            case 4:
                System.out.println("用户名或者密码错误，登录失败");
                System.exit(0);
                default:break;
        }

    }

    //提示输入 ：管理员登录
    public Administrator vlogin(){
        System.out.println("---管理员登录----");
        Administrator administrator=new Administrator();
        System.out.println("请输入用户名：");
        try{
            administrator.setUserName(input.nextLine());
            System.out.println("请输入密码：");
            administrator.setPassword(input.nextLine());
        }catch (Exception e){
            showFault(1);
            return vlogin();
        }
        return administrator;
    }


    //输入提示：输入需要添加的图书信息
    public Book addBook(){
        Book book=new Book();
        try{
            System.out.println("请输入书名：");
            book.setBook_name(input.nextLine());
            System.out.println("请输入图书价格：");
            book.setPrice(input.nextDouble());
            input.nextLine();
            System.out.println("请输入出版日期(2020-10-19)：");
            String date=input.nextLine();
            SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
            book.setPublication_date(format.parse(date));

        } catch (ParseException e) {
            showFault(2);
            return addBook();
        }
        return book;
    }

    /**
     * @description: 输入要修改的旧书的书名
     */
    public String findByBookName(){
        System.out.println("请输入需要更新的旧书书名：");
        String book_name=null;
        try{
            book_name=input.nextLine();
        }catch (Exception e){
            showFault(3);
            return findByBookName();
        }
        return book_name;
    }
    //输入提示： 输入要更新的图书信息
    public Book update(){
        Book newBook=new Book();
        try{
            System.out.println("请输入新的书名：");
            newBook.setBook_name(input.nextLine());
            System.out.println("请输入新的图书价格：");
            newBook.setPrice(input.nextDouble());
            input.nextLine();
            System.out.println("请输入新的出版日期(2020-10-19)：");
            String date=input.nextLine();
            SimpleDateFormat format=new SimpleDateFormat("yyyy-MM-dd");
            newBook.setPublication_date(format.parse(date));
        } catch (ParseException e) {
            showFault(2);
            return addBook();
        }
        return newBook;
    }

    /**
     * @description: 提示：是否确认删除
     * @return :int 1:确认 0：取消
     */
    public int confirmedDelete(){
        System.out.println("确认删除？");
        System.out.println("1:确认删除\t0:取消删除");
        String inputText=input.nextLine();
        int num=-1;
        try{
            num=Integer.parseInt(inputText);
            if(num<0||num>1){
                showFault(3);
                return confirmedDelete();
            }
        }catch (NumberFormatException e){
            showFault(3);
            return confirmedDelete();
        }
        return num;
    }
    /**
     * @description: 提示：输入书记查询时的书名
     */
    public String findBook(){
        System.out.println("----图书查询-----");
        System.out.println("请输入书名信息：");
        String bookName;
        try {
            bookName = input.nextLine();
        }catch (Exception e){
            showFault(3);
            return findBook();
        }
        return bookName;
    }

    /**
     * @description: 打印模糊查询结果
     */
    public void printMatchBooks(){
        for(int i=0;i<arrList.size();i++){
            System.out.println(arrList.get(i));
        }
    }
}

四、文件上传

1、客户端

public class UploadClient {
    public static void main(String[] args) throws IOException {
        Socket socket=new Socket("127.0.0.1",8081);
        FileInputStream fis=new FileInputStream("pic.jpg");
        OutputStream os=socket.getOutputStream();
        int len=0;
        byte[] bytes=new byte[1024];
        while((len=fis.read(bytes))!=-1){
            os.write(bytes,0,len);
        }
        socket.shutdownOutput();

        InputStream is=socket.getInputStream();
        while((len=is.read(bytes))!=-1){
            System.out.println(new String(bytes,0,len));
        }
        socket.close();
    }
}

2、服务端

public class UploadServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket=new ServerSocket(8081);
        Socket socket=serverSocket.accept();

        File file=new File("upload");
        if(!file.exists()){
            file.mkdirs();
        }
        InputStream is=socket.getInputStream();
        FileOutputStream fos=new FileOutputStream(file+"/"+".jpg");
        int len=0;
        byte[] bytes=new byte[1024];
        while((len=is.read(bytes))!=-1){
            fos.write(bytes,0,len);
        }
        fos.close();
        socket.close();
        serverSocket.close();
    }
}

五、多线程

public class ThreadServer {
    public static void main(String[] args) throws Exception {
        ServerSocket serverSocket=new ServerSocket(8081);
        while(true){
            Socket socket=serverSocket.accept();
            Thread thread=new Thread(new Runnable() {
                @Override
                public void run() {

                }
            });
        }

    }
}