作业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
");
}
}
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();
}
}
}
}