模拟web服务器（小项目）搭建+部署

模拟web服务器：可以从浏览器中访问到自己编写的服务器中的资源，将其资源显示在浏览器中。

技术选型：

corejava
- 线程池同任务并发执行
- IO流传递数据客户端也会像服务端发送数据，服务器像客户端发送数据也是流
- 网络(Socket编程) 通过网络获取客户端的数据以及通过网络给客户端返回数据
ubuntu
- 软件都是部署Linux(ubuntu)

使用c/s架构，只编写服务器端，客户端由浏览器代替，浏览器向服务器发送一个请求Request，服务器给浏览器返回一个响应Response。

使用的是HTTP协议。

项目整体的文件结构：

应用包appliction，包含启动类

封装包pojo，包含了两个封装类，request类（请求类） response类（响应类）为了防止后序有对象信息的传输，所以提前给两个类实现Serializable接口（序列化、反序列化）。

工具包util，包含请求的文件类型FileTpye，线程池工具PoolUtil，Socket转换成Request对象，和Request转换成Response对象的工具类SocketTrans，装载着状态码信息的一个接口类 StateCodeEnum。

所需的文件资源放在了source文件下。

GET请求方式：
浏览器向服务器发请求：http://127.0.0.1:80/index.html
请求数据为：

//请求行包括:请求方式+空格+/+请求资源+空格+协议版本+会车换行符

GET /index.html HTTP/1.1

//请求方式为GET 请求资源为index.html 协议版本为HTTP/1.1 回车换行符为\r\n

//请求头：请求行下的都是请求头 包含客户端的一些基本信息

Host: 127.0.0.1：80 //客户端的ip和端口 都是以空格隔开

Connection: keep-alive //客户端的连接状态

Cache-Control: max-age=0

Upgrade-Insecure-Requests: 1

//客户端的基本信息

User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/84.0.4147.125 Safari/537.36

//客户端可以接收的数据类型

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9

Sec-Fetch-Site: none

Sec-Fetch-Mode: navigate

Sec-Fetch-User: ?1

Sec-Fetch-Dest: document

Accept-Encoding: gzip, deflate, br

Accept-Language: zh-CN,zh;q=0.9

发送一个GET请求由几部分组成：

请求行（请求方式，/请求资源名，协议名字/版本号）会车符换行符
请求头 key：value 回车符换行符

POST请求方式：由Postman软甲配合完成选择POST方式输入ip 端口访问的资源

http://127.0.0.1:9999/login

从Body中输入key value参数

输入结束后连接即可。因为POST方式是向指定的资源提交要被处理的数据，查询字符串POST方式是在POST请求的HTTP主体中发送，而GET方式查询字符串是在GET请求的URL中发送，所以使用Postman方式进行模拟。

Request：需要封装请求行中的请求方式，用来根据不同的请求方式做不同的处理（GET没有请求体，而POST有请求体）、封装请求行中的请求资源，用来根据不同的请求资源发送不同的响应体、封装请求行中的协议版本（协议版本一般固定）、封装请求头（请求头中的内容都是key value值，所以使用一个map进行封装）、封装请求体。

import java.io.Serializable;

import java.util.HashMap;

import java.util.Map;

public class Request implements Serializable{

    private static final long serialVersionUID = 1L;

    //请求方式

    private String requestMethod;

    //请求资源

    private String requestSource;

    //协议版本

    private String agreement;

    //请求头

    private Map<String, String> requestHead = new HashMap<String, String>();

    //请求体

    private String requestBody;

    public String getRequestSource() {

        return requestSource;

    }

    public void setRequestSource(String requestSource) {

        this.requestSource = requestSource;

    }

    public String getAgreement() {

        return agreement;

    }

    public void setAgreement(String agreement) {

        this.agreement = agreement;

    }

    public Map<String, String> getRequestHead() {

        return requestHead;

    }

    public void setRequestHead(Map<String, String> requestHead) {

        this.requestHead = requestHead;

    }

    public String getRequestBody() {

        return requestBody;

    }

    public void setRequestBody(String requestBody) {

        this.requestBody = requestBody;

    }

    public String getRequestMethod() {

        return requestMethod;

    }

    public void setRequestMethod(String requestMethod) {

        this.requestMethod = requestMethod;

    }

    @Override

    public String toString() {

        return "Request [requestMethod=" + requestMethod + ", requestSource=" + requestSource + ", agreement="

                + agreement + ", requestHead=" + requestHead + ", requestBody=" + requestBody + "]";

    }

}

Response：和请求对应，响应有响应行、响应头、响应体。响应行中有版本信息，状态码信息。响应头中包含的是key value类型的数据，用一个map封装，响应体用Object类型修饰，因为不知道响应的是什么类型的数据。

import java.io.Serializable;

import java.util.HashMap;

import java.util.Map;

import com.briup.server.util.StateCodeEnum;

public class Response implements Serializable{

    private static final long serialVersionUID = 1L;

    //响应行的版本信息

    private String agreement = "HTTP/1.1";

    //响应行的状态码信息

    private StateCodeEnum stateCode;

    //key值代表响应头的key value代表响应头的value

    private Map<String, String> responseHeader = new HashMap<String, String>();

    //响应体

    private Object responseBody;

    public String getAgreement() {

        return agreement;

    }

    public void setAgreement(String agreement) {

        this.agreement = agreement;

    }

    public StateCodeEnum getStateCode() {

        return stateCode;

    }

    public void setStateCode(StateCodeEnum stateCode) {

        this.stateCode = stateCode;

    }

    public Map<String, String> getResponseHeader() {

        return responseHeader;

    }

    public void setResponseHeader(Map<String, String> responseHeader) {

        this.responseHeader = responseHeader;

    }

    public Object getResponseBody() {

        return responseBody;

    }

    public void setResponseBody(Object responseBody) {

        this.responseBody = responseBody;

    }

    @Override

    public String toString() {

        return "Response [agreement=" + agreement + ", stateCode=" + stateCode + ", responseHeader=" + responseHeader

                + ", responseBody=" + responseBody + "]";

    }

}

FileType：响应头里的各种信息，根据key值得到响应的value值进行对响应头信息的封装。

import java.util.HashMap;

import java.util.Map;

public class FileType {

public static final Map<String, String> TYPE;

static {

    TYPE=new HashMap<>();

    TYPE.put("txt","text/html;charset=tf-8");

    TYPE.put("html","text/html;charset=tf-8");

    TYPE.put("jpg","image/jpeg;charset=tf-8");

    TYPE.put("jpeg","images/jpeg;charset=tf-8");

    TYPE.put("png","image/png;charset=tf-8");

    TYPE.put("mp4","video/mpeg4;charset=tf-8");

    TYPE.put("pdf","application/pdf;charset=tf-8");

}

}

PoolUtil：

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.net.Socket;

import java.util.Map.Entry;

import java.util.Set;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import javax.print.attribute.ResolutionSyntax;

import com.briup.server.pojo.Request;

import com.briup.server.pojo.Response;

public class PoolUtil {

    public static final ExecutorService pool;

    static {

        pool = Executors.newCachedThreadPool();

    }

    private static void writeToBrowser(Socket socket,Response response) throws IOException {

        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());

        StringBuilder builder = new StringBuilder();

        builder.append(response.getAgreement()).append(" ").append(response.getStateCode().getCode()).append(" ").append(response.getStateCode().getMsg()).append("\r\n");

        bos.write(builder.toString().getBytes());

        //删除builder里面的数据 从0开始到最后

        builder.delete(0, builder.length());

        Set<Entry<String,String>> set = response.getResponseHeader().entrySet();

        for (Entry<String, String> entry : set) {

            builder.append(entry.getKey()).append(" ").append(entry.getValue()).append("\r\n");

        }

        //响应头

        bos.write(builder.toString().getBytes());

        //空行

        bos.write("\r\n".getBytes());

        //响应体

        //如果是文件就写回文件，

        if(response.getResponseBody() instanceof File) {

            //将资源从本地磁盘读取

            BufferedInputStream bis = new BufferedInputStream(new FileInputStream((File)response.getResponseBody()));

            int count=-1;

            byte []bytes = new byte[1024];

            while((count=bis.read(bytes))!=-1) {

                bos.write(bytes, 0, count);

            }

            bos.flush();

            socket.shutdownOutput();

        }

    }

    private static void doGet(Request request,Response response,Socket socket) throws IOException {

        //通过request对象获取requestBody

        String string = request.getRequestBody();

        if (string!=null &&!"".equals(string)) {

            String[] infos = string.split("[&]");

            if ("username=123".equals(infos[0]) && "password=123".equals(infos[1])) {

                response.setStateCode(StateCodeEnum.OK);

                response.setResponseBody(new File("source/success.html"));

            } else {

                response.setStateCode(StateCodeEnum.LOGIN_FAIL);

                response.setResponseBody(new File("source/fail.html"));

            }

        }

        //将数据写回给浏览器

        writeToBrowser(socket,response);

    }

   private static void doPost(Request request,Response response,Socket socket) throws IOException{

       doGet(request, response, socket);

       writeToBrowser(socket,response);

    }

public static void service( Request request,Response response,Socket socket) {

    pool.execute(()->{

        try {

            if(("GET").equals(request.getRequestMethod())) {

                PoolUtil.doGet(request, response, socket);

            }

            else if(("POST").equals(request.getRequestMethod())){

                PoolUtil.doPost(request, response, socket);

            }

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    });

}

}

SocketTrans：

import java.io.BufferedReader;

import java.io.File;

import java.io.IOException;

import java.io.InputStreamReader;

import java.net.Socket;

import com.briup.server.pojo.Request;

import com.briup.server.pojo.Response;

public class SocketTrans {

public static  Request socketToRequest(Socket socket) throws IOException  {

    if(socket ==null) {

        throw new RuntimeException("参数为空");

    }

    Request request = new Request();

    BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));

    //得到请求行

    String line = reader.readLine();

    String[] split = line.split(" ");

    request.setAgreement(split[2]);

    request.setRequestMethod(split[0]);

    String[] split2 = split[1].split("[?]");

    request.setRequestSource(split2[0]);

    //数组长度大于1 代表后面有数据

    if(split2.length>1) {

        request.setRequestBody(split2[1]);

    }

    //得到请求头

    while((line = reader.readLine())!=null&&!"".equals(line)) {

        String[] herderInfo = line.split(":");

        request.getRequestHead().put(herderInfo[0], herderInfo[1].trim());

    }

    //判断请求头里有没有Content-Length，有则代表有请求体

    if (request.getRequestHead().containsKey("Content-Length")) {

         request.setRequestBody(reader.readLine());

    }

    //封装完后 input流使用完毕了

    socket.shutdownInput();

    return request;

}

public static Response getResponse(Request request) {

    if(request==null) {

        throw new RuntimeException("参数为空");

    }

    Response response = new Response();

    //设置协议版本

    response.setAgreement(request.getAgreement());

    //判断资源是否存在

    String fileName = request.getRequestSource();

    File file = new File("source",fileName);

    //设置响应体

    //得到请求资源的后缀名

    fileName= fileName.substring(fileName.lastIndexOf(".")+1);

    //文件存在后缀名正确 不存在后缀名可能正确 也可能不正确

    if(file.exists()) {

        response.setStateCode(StateCodeEnum.OK);

        response.setResponseBody(file);

        response.getResponseHeader().put("Content-Type:", FileType.TYPE.get(fileName));

    }else {

        response.setStateCode(StateCodeEnum.NOT_FOUND);

        response.setResponseBody(new File("source/404.html"));

        response.getResponseHeader().put("Content-Type:", FileType.TYPE.get("html"));

    }

    return response;

}

}

StateCodeEnum ：

public enum StateCodeEnum {

    OK(200,"OK"),NOT_FOUND(404,"NOT_FOUND"),LOGIN_FAIL(401,"UNAUTHORIZED");

private int code;

private String msg;

private StateCodeEnum(int code,String msg) {

    this.code = code;

    this.msg = msg;

}

public int getCode() {

    return code;

}

public void setCode(int code) {

    this.code = code;

}

public String getMsg() {

    return msg;

}

public void setMsg(String msg) {

    this.msg = msg;

}

}

项目的代码基本结束，可以实现从浏览器端向服务器端。

将项目打包，右击项目，选择Export ，选择jarFile，选择要打包的地点。

将项目部署到Ubuntu的一个镜像中，方便测试，

在Ubuntu中，点击文件，点击打开，选中server.ovf(镜像文件),将其导入。

为方便远程操作服务器，使用一个远程连接工具srct814-x64软件。

在Ubuntu中查看ip 使用ifconfig ，在srct814-x64中添加此ip并连接。

在srct-x64中安装jdk，配置环境变量，使其具备Java环境。

在srct-x64中点击file，打开connect SFTP session ，将打包好的server.jar文件和资源文件夹source拖进这个窗口。

在该控制台窗口中整理文件，将source和jar包放在一个文件夹下，此时项目就算部署好了，在该窗口运行jar包

Java -jar server.jar

打开浏览器输入服务器的ip和端口号和你要访问的资源就可以访问到了。

如我的Ubuntu中ip是192.168.235.129 端口号为9999

在浏览器中输入 192.168.235.129:9999/1.png

就可以访问到服务器中的1.png文件

巴特西

模拟web服务器（小项目）搭建+部署

最新文章

热门文章

巴特西

模拟web服务器 （小项目） 搭建+部署

最新文章

热门文章

模拟web服务器（小项目）搭建+部署