《计算机网络·自顶向下方法》 第二章 套接字编程作业 JAVA

作业1

概述：

如何使用JAVA创建HTTP报文，在本回答中没有体现。
本回答的报文均由一个自定义类而实现。

代码逻辑：
1.建立连接
2.客户端发送请求的文件路径到服务端
3.服务端寻找文件。如果找到，发送文件，并且发送一个确定报文。如果没有找到，发送一个没有找到的报文。

服务端

总所周知，服务端可能需要同时为多个客户端提供服务，所以很自然的，博主使用了多线程技术。具体的，博主使用了线程池技术
同时，在服务端，对于同一类服务，线程池只需要一个就够了，所以博主使用了单例模式来设计代码。

在编写代码的过程中，我遇到了两个问题：
第一个问题，TCP是面向字节流的运输层协议，在发送一个文件后，再发送一个Object，如果之前不指定文件的长度，那么接收端根本无法确定，接收到的数据属于文件，还是属于后来发送的Object
第二个问题，发送Object的时候，一开始我使用了ObjectOutputStream 发送，但是很显然地，接收端不能使用ObjectInputStream接收，因为在接收文件时，该Object的一部分字节可能已经被读入到byte[]中了。所以客户端必须使用socket的InputStream接收数据，再通过相关方法（详见代码）将byte转化为Object。问题就出在这里，我尝试了很久，但是一直在类型转换的时候出现异常，直到我将发送的Object在服务端转化为byte[]，才发现得到的byte[]长度和客户端收到的不一样。为什么会这样，我找了很久的答案，但是一无所获，只能假设，在ObjectOutputStream基于Socket.OutputStream的时候，会做相关优化，减少字节长度。通过比对byte[]的内容大致可以猜测，基于Socket.OutputStream的ObjectOutputStream发送Object时，会忽略一部分Object的头部信息。最后的解决方法是，不使用ObjectOutputStream直接发送，而是将其转化为byte[]之后，再通过Socket.OutputStream发送。

客户端

客户端不用考虑多线程的问题
实现比服务端简单得多，只需要根据服务端代码接收相关信息即可

Datagram类

自定义类，同时存在于客户端和服务端，用于客户端和服务端接收信息，上文提到的Object实际上就是指Datagram的某个实例

Datagram类

package DatagramBean;

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

/**
 * @Author : ZGQ
 * @Date : 2020/2/16 18:10
 * @Version : 1.0
 */
public class Datagram implements Serializable {
    static final long serialVersionUID = 952752194657456L;
    int code;
    String message;

    public Datagram() {
    }

    public Datagram(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Datagram datagram = (Datagram) o;
        return code == datagram.code &&
                Objects.equals(message, datagram.message);
    }

    @Override
    public int hashCode() {
        return Objects.hash(code, message);
    }

    @Override
    public String toString() {
        return "Datagram{" +
                "code=" + code +
                ", message='" + message + '\'' +
                '}';
    }
}

服务端代码

package TCP;
import DatagramBean.Datagram;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author : ZGQ
 * @Date : 2020/2/16 18:03
 * @Version : 1.0
 */

//多线程
class ServerUtil implements Runnable{

    private static final int MAX_BUFF_SIZE = 1024;

    private Socket socket = null;
    private InputStream is = null;
    private FileInputStream fis = null;
    private OutputStream os = null;
    private ObjectOutputStream oos=null;

    public ServerUtil(Socket socket){
        this.socket=socket;
    }

    //接收客户端的请求的文件路径
    private String receURL() throws IOException {
        byte[] data = new byte[MAX_BUFF_SIZE];
        int len = is.read(data);
        String s1 = new String(data,0,len);
        return s1;
    }

    //发送文件
    private void sendFile(String s1) throws IOException {
        fis = new FileInputStream(s1);
        byte[] data = new byte[MAX_BUFF_SIZE];
        int len = 0;
        fis = new FileInputStream(s1);
        int times = 0;
        int lst = 0;
        while ((len=fis.read(data))!=-1){
            lst=len;
            os.write(data,0,len);
            times++;
        }
        os.flush();
        System.out.println("lst = " + lst);
    }

    //通过路径获取文件长度
    private long getFileLenByPath(String path) throws IOException {
        File file = new File(path);
        return file.length();
    }

    //发送获取成功的回复
    private void sendResSuccess(long len) throws IOException {
        sendRes(200,"len = "+len);
    }

    //发送获取失败的回复
    private void sendResFailed() throws IOException {
        sendRes(404,"文件不存在");
    }

    //发送回复
    private void sendRes(int code,String message) throws IOException {
        Datagram datagram = new Datagram(code,message);
        oos.writeObject(datagram);
        oos.flush();
    }

    //将Object转化为字节
    private byte[] ObjectToByte(Datagram datagram){
        ByteArrayOutputStream baos = null;
        ObjectOutputStream oos = null;
        byte[] data = new byte[MAX_BUFF_SIZE];
        try {
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(datagram);
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(oos!=null){ oos.close(); }
                if(baos!=null){ baos.close(); }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return new byte[0];
    }


    //以字节的方式发送回复
    private void sendResByte(int code,String message) throws IOException {
        Datagram datagram = new Datagram(code,message);
        byte[] bytes = ObjectToByte(datagram);
        os.write(bytes);
        System.out.println(bytes.length);
    }

    @Override
    public void run() {
        try {

            is = socket.getInputStream();
            os = socket.getOutputStream();
            oos = new ObjectOutputStream(os);

            String path = receURL();
            System.out.println("path = " + path);
            long len = 0;
            try{
                long fileLen = getFileLenByPath(path);
                System.out.println(fileLen);
                sendResSuccess(fileLen);
                sendFile(path);
                sendResByte(200,"东西收到了吧，哈哈");
            }catch (IOException e){
                sendResFailed();
                System.out.println("没有找到对应的资源");
            }
        } catch (IOException e) {
            System.err.println("socket输入输出流创建失败");
        } finally {
            try {

                if(oos!=null)oos.close();
                if(os!=null)os.close();
                if(fis!=null)fis.close();
                if(is!=null)is.close();
                if(socket!=null)socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        System.out.println("OVERD\n");
    }
}

public class Task1 {
    //单例模式
    static Task1 task=null;
    ExecutorService threadPool = null;
    private Task1(){
        threadPool=Executors.newFixedThreadPool(50);
    }
    public static Task1 getInstance(){
        if (task == null) {
            synchronized (Task1.class) {
                if (task == null) {
                    task = new Task1();
                }
            }
        }
        return task;
    }


    //调用此函数开始服务
    public void server()  {
        ServerSocket serverSocket = null;
        try {
            serverSocket = new ServerSocket(9527);
            while (true){
                threadPool.execute(new ServerUtil(serverSocket.accept()));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(serverSocket!=null)serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端代码

package TCP;
import DatagramBean.Datagram;
import com.sun.istack.internal.ByteArrayDataSource;
import com.sun.scenario.effect.Merge;

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

/**
 * @Author : ZGQ
 * @Date : 2020/2/16 19:01
 * @Version : 1.0
 */
public class Task1 {

    public static final int MAX_BUF_SIZE = 1024;
    Socket socket = null;
    OutputStream os = null;
    InputStream is = null;
    FileOutputStream fos = null;
    ObjectInputStream ois = null;

    //发送要访问的服务端文件地址
    private void sendURL() throws IOException {
        os.write("D:\\Java\\server_source\\setu.png".getBytes());
        os.flush();
    }

    //将byte[]转化为Object
    private Object byteToObject(byte[] bytes) throws IOException, ClassNotFoundException {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);
        ois = new ObjectInputStream(byteArrayInputStream);
        return ois.readObject();

    }

    //接收文件
    //注意TCP面向字节流，收到的数据中结尾可能存在不属于文件的部分
    //此方法的返回值即为收到的多余数据，它属于TCP传送的下一个（或多个）对象
    private byte[] receFile(String dest, int fileLen) throws IOException {
        fos = new FileOutputStream(dest);
        byte[] data = new byte[MAX_BUF_SIZE];
        int receivedLen = 0;
        while (receivedLen < fileLen) {
            int len = is.read(data);
            if (len == -1) {
                return new byte[0];
            }
            int len_of_remain = Math.min(fileLen - receivedLen, MAX_BUF_SIZE);
            fos.write(data, 0, len_of_remain);
            receivedLen += len;
            if (receivedLen == fileLen) {
                System.out.println("没有多余数据");
                return new byte[0];
            } else if (receivedLen > fileLen) {
                return subByte(data, len_of_remain, len);
            }
        }
        return new byte[0];
    }

    //接收服务端的回复，内容可能包括文件是否存在，文件长度等
    private Datagram receRes() throws IOException, ClassNotFoundException {
        return (Datagram) ois.readObject();
    }

    //通过服务端的回复，获取文件长度
    private int getLen(Datagram datagram) {
        return Integer.parseInt(datagram.getMessage().substring(6));
    }

    //获取一个byte[] 的一段
    private byte[] subByte(byte[] data, int start, int totLen) {
        byte[] newData = new byte[totLen - start];
        int cnt = 0;
        for (int i = start; i < totLen; i++) {
            newData[cnt++] = data[i];
        }
        return newData;
    }

    //合并两个byte[]
    private byte[] byteMerge(byte[] bytes1, byte[] bytes2) {
        int len = bytes1.length + bytes2.length;
        byte[] newByte = new byte[len];
        int cnt = 0;
        for (byte b : bytes1) {
            newByte[cnt++] = b;
        }
        for (byte b : bytes2) {
            newByte[cnt++] = b;
        }
        return newByte;
    }

    //receFile()中，可能已经读取了下一个对象的一部分，这里读取剩下的所有部分
    private byte[] receRemain() throws IOException {
        byte[] data = new byte[MAX_BUF_SIZE];
        byte[] ret = new byte[0];
        int len = 0;
        int totlen = 0;
        while ((len = is.read(data)) != -1) {
            ret = byteMerge(ret, subByte(data, 0, len));
            totlen += len;
        }
        if (totlen >= 0) return ret;
        else return new byte[0];
    }

    //客户端程序
    public void client() {
        try {

            socket = new Socket("127.0.0.1", 9527);
            os = socket.getOutputStream();
            is = socket.getInputStream();
            ois = new ObjectInputStream(is);
            sendURL();
            Datagram datagram = receRes();
            long fileLen = getLen(datagram);
            if(fileLen==0){
                System.out.println("文件缺失");
                return;
            }

            System.out.println("fineLen = "+fileLen);

            byte[] remain1 = receFile("D:\\Java\\client_workspace\\name.png", (int) fileLen);
            byte[] remain2 = receRemain();
            byte[] Obj = byteMerge(remain1,remain2);

            datagram = (Datagram) byteToObject(Obj);
            System.out.println(datagram);

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (ois != null) ois.close();
                if (fos != null) fos.close();
                if (is != null) is.close();
                if (os != null) os.close();
                if (socket != null) socket.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}