java-webserver基础

手写webserver基础

文章目录

• ​​反射​​
• ​​xml解析​​
• ​​获取请求协议​​
• ​​返回响应​​
• ​​封装响应信息​​
• ​​封装request​​
• ​​获取参数-处理中文​​
• ​​引入Servlet​​
• ​​整合webxml​​
• ​​封装分发器​​
• ​​404/505/首页处理​​

反射

/**
 * 反射:把Java类中的各种构造(方法、属性、构造器、类名)映射成一个个的Java对象
 * 1. 获取Class对象
 *  Class.forName("完整路径")
 * 2. 可以动态创建对象
 *  clz.getConstructor().newInstance()
 * @author sweetheart
 *
 */

public class ReflectTest {

  public static void main(String[] args) throws Exception {
    
    // 三种方式
    
    // 1、对象.getClass()
    Iphone iphone = new Iphone();
    Class clz = iphone.getClass();
    // 2、类.class
    clz  = Iphone.class;
    // 3、Class.forName("包名.类名")
    clz = Class.forName("cn.xxx.server.basic.Iphone");
    
    // 创建对象
    Iphone iphone2 = (Iphone)clz.getConstructor().newInstance();
    System.out.println(iphone2);
  }

}
class Iphone{
  
  public Iphone() {
    
  }
}

xml解析

​​p.xml​​

<?xml version="1.0" encoding="UTF-8"?>
<persons>
  <person>
    <name>小黑</name>
    <age>19</age>
  </person>
  <person>
    <name>大白</name>
    <age>20</age>
  </person>
</persons>

​​Person.java​​

public class Person {
  
  private String name;
  private int age;
  
  public Person() {
    
  }

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  } 
}

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;


/**
 * 熟悉SAX解析流程
 * @author sweetheart
 *
 */
public class XmlTest02 {

  public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
    
    // SAX解析
    // 1. 获取解析工厂
    SAXParserFactory factory = SAXParserFactory.newInstance();
    
    // 2. 从解析工厂获取解析器
    SAXParser parse = factory.newSAXParser();
    
    // 3. 编写处理器
    
    // 4. 加载文档Document注册处理器
    PersonPHandler handler = new PersonPHandler();
    
    // 5.解析
    parse.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("cn/whb/server/basic/p.xml"),handler);
    
    List<Person> persons;
    persons = handler.getPersons();
    
    System.out.println(persons.size());
    for(Person ps:persons) {
      System.out.println(ps.getName()+":"+ps.getAge());
    }
  }
}

class PersonPHandler extends DefaultHandler{
  
  private List<Person> persons;
  private Person person;
  
  public List<Person> getPersons() {
    return persons;
  }

  public void setPersons(List<Person> persons) {
    this.persons = persons;
  }

  private String tag; // 存储操作标签
  
  @Override
  public void startDocument() throws SAXException {
    persons = new ArrayList<>();
  }
  
  @Override
  public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
    
    System.out.println(qName+"-->解析开始");
    
    if(null!=qName) {
      tag = qName; // 存储标签名
      if(tag.equals("person")) {
        person = new Person();
      }
    }
  }
  
  @Override
  public void characters(char[] ch, int start, int length) throws SAXException {
    
    String contents = new String(ch,start,length).trim();
    if(tag.equals("name")) {
      person.setName(contents);
    }else if(tag.equals("age")) {
      person.setAge(Integer.valueOf(contents));
    }
  }
  
  @Override
  public void endElement(String uri, String localName, String qName) throws SAXException {
    
    System.out.println(qName+"-->解析结束");
    
    if(qName.equals("person")) {
      persons.add(person);
    }
    tag = "";   // 防止tag对应的属性被空字符串所覆盖
  }
  
  @Override
  public void endDocument() throws SAXException {
    
    System.out.println("----解析文档结束-----");
  }
}

获取请求协议

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 使用ServerSocket建立与浏览器的连接,获取请求协议
 */
public class Server01 {
    private ServerSocket serverSocket;

    public static void main(String[] args) {

        Server01 server = new Server01();
        server.start();
        server.receive();
    }

    // 启动服务
    public void start(){
        try {
            serverSocket = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败");
        }
    }

    // 接受连接处理
    public void receive(){
        try {
            Socket client = serverSocket.accept();
            System.out.println("一个客户端建立了连接");
            // 获取请求协议
            InputStream is = client.getInputStream();
            byte[] datas = new byte[1024*1024];
            int len = is.read(datas);
            String requestInfo = new String(datas, 0, len);
            System.out.println(requestInfo);

        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("客户端错误");
        }
    }

    // 停止服务
    public void stop(){

    }

}

http协议基于tcp/ip协议,此处采用tcp-socket编程模拟服务器

返回响应

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

/**
 * 返回响应
 */
public class Server02 {
    private ServerSocket serverSocket;

    public static void main(String[] args) {

        Server02 server = new Server02();
        server.start();
        server.receive();
    }

    // 启动服务
    public void start(){
        try {
            serverSocket = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败");
        }
    }

    // 接受连接处理
    public void receive(){
        try {
            Socket client = serverSocket.accept();
            System.out.println("一个客户端建立了连接");
            // 获取请求协议
            InputStream is = client.getInputStream();
            byte[] datas = new byte[1024*1024];
            int len = is.read(datas);
            String requestInfo = new String(datas, 0, len);
            System.out.println(requestInfo);

            StringBuilder content = new StringBuilder();
            content.append("<html>");
            content.append("<head>");
            content.append("<title>");
            content.append("标题....");
            content.append("</title>");
            content.append("</head>") ;
            content.append("<body>");
            content.append("server....start");
            content.append("</body>");
            content.append("</html>");

            // 字节长度
            int size = content.toString().getBytes().length;

            StringBuilder responseInfo = new StringBuilder();
            String blank = " ";
            String CRLF = "\r\n";

            // 返回
            // 1. 响应行: HTTP/1.1 200 OK
            responseInfo.append("HTTP/1.1").append(blank);
            responseInfo.append(200).append(blank);
            responseInfo.append("OK").append(CRLF);
            // 2. 响应头:
            /*
                Date: Mon, 15 Feb 2021 02:44:34 GMT
                Server: my-server
                Content-Type: text/html;charset=utf-8
                Content-length: 字节长度
            */
            responseInfo.append("Date: ").append(new Date()).append(CRLF);
            responseInfo.append("Server: ").append("my-server").append(CRLF);
            responseInfo.append("Content-Type: ").append("text/html;charset=utf-8").append(CRLF);
            responseInfo.append("Content-length: ").append(size).append(CRLF);
            responseInfo.append(CRLF);
            // 3. 正文
            responseInfo.append(content);

            // 写出到客户端
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
            bw.write(responseInfo.toString());
            bw.flush();

        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("客户端错误");
        }
    }

    // 停止服务
    public void stop(){

    }

}

封装响应信息

import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Date;

public class Response {
    private BufferedWriter bw;
    // 正文
    private StringBuilder content;
    // 协议头(状态行与请求头 回车)信息
    private StringBuilder headInfo;
    private int len;  // 正文的字节数
    private static final String BLANK = " ";
    private static final String CRLF = "\r\n";

    private Response(){
        content = new StringBuilder();
        headInfo = new StringBuilder();
        len = 0;
    }

    public Response(Socket client){
        this();

        try {
            bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    public Response(OutputStream os){
        this();
        bw = new BufferedWriter(new OutputStreamWriter(os));
    }

    // 动态添加内容
    public Response print(String info){
        content.append(info);
        len += info.getBytes().length;
        return this;
    }

    public Response println(String info){
        content.append(info).append(CRLF);
        len += (info+CRLF).getBytes().length;
        return this;
    }


    // 构建头信息
    private void createHead(int code){
        // 1. 响应行: HTTP/1.1 200 OK
        headInfo.append("HTTP/1.1").append(BLANK);
        headInfo.append(code).append(BLANK);
        switch (code){
            case 200:
                headInfo.append("OK").append(CRLF);
                break;
            case 404:
                headInfo.append("NOT FOUND").append(CRLF);
                break;
            case 505:
                headInfo.append("SERVER ERROR").append(CRLF);
                break;
        }
        // 2. 响应头:
        headInfo.append("Date: ").append(new Date()).append(CRLF);
        headInfo.append("Server: ").append("my-server").append(CRLF);
        headInfo.append("Content-Type: ").append("text/html;charset=utf-8").append(CRLF);
        headInfo.append("Content-length: ").append(len).append(CRLF);
        headInfo.append(CRLF);
    }

    // 推送响应信息
    public void pushToBrowser(int code) throws IOException{
        if (headInfo == null){
            code = 505;
        }

        createHead(code);
        bw.append(headInfo);
        bw.append(content);
        bw.flush();

    }
}

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 封装响应信息
 * 1. 内容动态添加
 * 2. 关注状态码, 拼接好响应的协议信息
 */
public class Server03 {
    private ServerSocket serverSocket;

    public static void main(String[] args) {

        Server03 server = new Server03();
        server.start();
        server.receive();
    }

    // 启动服务
    public void start(){
        try {
            serverSocket = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败");
        }
    }

    // 接受连接处理
    public void receive(){
        try {
            Socket client = serverSocket.accept();
            System.out.println("一个客户端建立了连接");
            // 获取请求协议
            InputStream is = client.getInputStream();
            byte[] datas = new byte[1024*1024];
            int len = is.read(datas);
            String requestInfo = new String(datas, 0, len);
            System.out.println(requestInfo);

            Response response = new Response(client);
            response.print("<html>");
            response.print("<head>");
            response.print("<title>");
            response.print("标题....");
            response.print("</title>");
            response.print("</head>") ;
            response.print("<body>");
            response.print("server....start");
            response.print("</body>");
            response.print("</html>");
            
            response.pushToBrowser(200);
            
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("客户端错误");
        }
    }

    // 停止服务
    public void stop(){
        
    }
}

封装request

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

/**
 * 封装请求协议: 获取method uri以及请求参数
 */
public class Request {

    // 协议信息
    private String requestInfo;
    // 请求方式
    private String method;
    // 请求url
    private String url;
    // 请求参数
    private String queryStr = "";
    private static final String CRLF = "\r\n";

    public Request(Socket client) throws IOException{

        this(client.getInputStream());

    }

    public Request(InputStream is){

        byte[] datas = new byte[1024*1024];
        int len = 0;
        try {
            len = is.read(datas);
            this.requestInfo = new String(datas, 0, len);
            System.out.println(requestInfo);

        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        // 分解字符串
        parseRequestInfo();
    }

    private void parseRequestInfo(){
        System.out.println("------分解-------");
        // 1. 获取请求方式
        this.method = requestInfo.substring(0, requestInfo.indexOf("/")).strip().toLowerCase();  // 左闭右开
        System.out.println(method);

        // 2. 获取请求的url
        int startidx = requestInfo.indexOf("/") + 1;
        int endidx = requestInfo.indexOf("HTTP/");
        this.url = requestInfo.substring(startidx, endidx).trim();
        // 获取?的位置
        int queryidx = this.url.indexOf("?");
        if (queryidx >= 0){  // 存在请求参数
            String[] urlArray = this.url.split("\\?");
            this.url = urlArray[0];
            queryStr = urlArray[1];
        }

        System.out.println(this.url);
        // 3. 获取请求参数
        if (method.equals("post")){
            String qStr = requestInfo.substring(requestInfo.lastIndexOf(CRLF)).trim();
            if (queryStr.equals("")){  // url中不存在参数信息
                queryStr = qStr;
            }else {
                queryStr += ("&"+qStr);
            }
        }

        System.out.println(method+"-->" + url+"-->" + queryStr);
    }
}

获取参数-处理中文

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.util.*;

/**
 * 封装请求协议: 封装请求参数为Map
 */
public class Request02 {

    // 协议信息
    private String requestInfo;
    // 请求方式
    private String method;
    // 请求url
    private String url;
    // 请求参数
    private String queryStr = "";
    // 存储参数
    private Map<String, List<String>> paramterMap;
    private static final String CRLF = "\r\n";

    public Request02(Socket client) throws IOException{

        this(client.getInputStream());

    }

    public Request02(InputStream is){
        paramterMap = new HashMap<>();
        byte[] datas = new byte[1024*1024];
        int len = 0;
        try {
            len = is.read(datas);
            this.requestInfo = new String(datas, 0, len);
            System.out.println(requestInfo);

        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        // 分解字符串
        parseRequestInfo();
    }

    private void parseRequestInfo(){
        System.out.println("------分解-------");
        // 1. 获取请求方式
        this.method = requestInfo.substring(0, requestInfo.indexOf("/")).strip().toLowerCase();  // 左闭右开
        System.out.println(method);

        // 2. 获取请求的url
        int startidx = requestInfo.indexOf("/") + 1;
        int endidx = requestInfo.indexOf("HTTP/");
        this.url = requestInfo.substring(startidx, endidx).trim();
        // 获取?的位置
        int queryidx = this.url.indexOf("?");
        if (queryidx >= 0){  // 存在请求参数
            String[] urlArray = this.url.split("\\?");
            this.url = urlArray[0];
            queryStr = urlArray[1];
        }

        System.out.println(this.url);
        // 3. 获取请求参数
        if (method.equals("post")){
            String qStr = requestInfo.substring(requestInfo.lastIndexOf(CRLF)).trim();
            if (queryStr.equals("")){  // url中不存在参数信息
                queryStr = qStr;
            }else {
                queryStr += ("&"+qStr);
            }
        }

        System.out.println(method+"-->" + url+"-->" + queryStr);
        // 转成Map
        convertMap();
    }

    private void convertMap(){
        // 分割字符串 &
        String[] keyValues = this.queryStr.split("&");

        for (String query:keyValues) {
            // 再次分割 =
            String[] kv = query.split("=");
            kv = Arrays.copyOf(kv, 2);  // 防止 "others=" 这种情况存在
            // 获取key和value
            String key = kv[0];
            String value = (kv[1] == null? kv[1]: decode(kv[1], "utf-8"));
            // 存储到Map中
            if (!paramterMap.containsKey(key)){  // key不存在于map中
                paramterMap.put(key, new ArrayList<>());
            }
            paramterMap.get(key).add(value);
        }
    }

    // 处理中文
    private String decode(String value, String enc){
        try {
            return java.net.URLDecoder.decode(value, enc);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 通过name获取对应的多个值
     * @param key
     * @return
     */
    public String[] getParamtersValues(String key){
        List<String> values = this.paramterMap.get(key);
        if (values==null || values.size()<1){
            return null;
        }
        return values.toArray(new String[0]);
    }

    public String getParamter(String key){
        String[] values = getParamtersValues(key);
        return values==null? null:values[0];
    }

    public String getMethod() {
        return method;
    }

    public String getUrl() {
        return url;
    }

    public String getQueryStr() {
        return queryStr;
    }

}

引入Servlet

/**
 * 服务器小脚本接口
 */
public interface Servlet {
  
  void service(Request request, Response response);
}

public class RegisterServlet implements Servlet{

  @Override
  public void service(Request request, Response response){
    response.print("注册成功");
  }
}

import java.util.Arrays;

public class LoginServlet implements Servlet{

  @Override
  public void service(Request request, Response response) {

    response.print("<html>");
    response.print("<head>");
    response.print("<title>");
    response.print("标题....");
    response.print("</title>");
    response.print("</head>") ;
    response.print("<body>");
    response.print("server....start" + Arrays.toString(request.getParamtersValues("uname")));
    response.print("</body>");
    response.print("</html>");
  }
}

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

/**
 * 加入了Servlet,解耦了业务代码
 */
public class Server {
    private ServerSocket serverSocket;

    public static void main(String[] args) {

        Server server = new Server();
        server.start();
        server.receive();
    }

    // 启动服务
    public void start(){
        try {
            serverSocket = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败");
        }
    }

    // 接受连接处理
    public void receive(){
        try {
            Socket client = serverSocket.accept();
            System.out.println("一个客户端建立了连接");
            // 获取请求协议
            Request request = new Request(client);

            // 获取响应
            Response response = new Response(client);
            Servlet servlet = null;
            if (request.getUrl().equals("login")){
                servlet = new LoginServlet();
            }else if (request.getUrl().equals("reg")){
                servlet = new RegisterServlet();
            }else {

            }
            
            servlet.service(request, response);

            response.pushToBrowser(200);

        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("客户端错误");
        }
    }

    // 停止服务
    public void stop(){
    }
}

整合webxml

​​web.xml​​

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
  <servlet>
    <servlet-name>login</servlet-name>
    <servlet-class>server03.LoginServlet</servlet-class>
  </servlet>
  
  <servlet>
    <servlet-name>reg</servlet-name>
    <servlet-class>server03.RegisterServlet</servlet-class>
  </servlet>

  <servlet>
    <servlet-name>other</servlet-name>
    <servlet-class>server03.OtherServlet</servlet-class>
  </servlet>
  
  <servlet-mapping>
    <servlet-name>login</servlet-name>
    <url-pattern>/login</url-pattern>
    <url-pattern>/g</url-pattern>
  </servlet-mapping>
  
  <servlet-mapping>
    <servlet-name>reg</servlet-name>
    <url-pattern>/reg</url-pattern>
  </servlet-mapping>

  <servlet-mapping>
    <servlet-name>other</servlet-name>
    <url-pattern>/o</url-pattern>
  </servlet-mapping>
</web-app>

​​WebApp​​

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

public class WebAPP {
    private static WebContext webContext;

    static {
        try {

            // SAX解析
            // 1. 获取解析工厂
            SAXParserFactory factory = SAXParserFactory.newInstance();

            // 2. 从解析工厂获取解析器
            SAXParser parse = factory.newSAXParser();

            // 3. 编写处理器

            // 4. 加载文档Document注册处理器
            WebHandler handler = new WebHandler();

            // 5.解析
            parse.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("web.xml"),handler);

            webContext = new WebContext(handler.getEntitys(), handler.getMappings());

        }catch (Exception e){
            System.out.println("解析配置文件错误");
        }
    }

    /**
     * 通过url获取配置文件对应的servlet
     * @param url
     * @return
     */
    public static Servlet getSevletFromUrl(String url){

        String className = webContext.getClz("/" + url);
//        System.out.println(className);
        Class clz = null;
        try {

            clz = Class.forName(className);
            Servlet servlet = (Servlet)clz.getConstructor().newInstance();
            return servlet;

        } catch (Exception e) {
            // e.printStackTrace();
        }

        return null;
    }
}

​​WebContext​​

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class WebContext {
  
  private List<Entity> entitys = null;
  private List<Mapping> mappings = null;
  
  // key --> url-pattern  value --> servlet-name
  private Map<String,String> mappingMap = new HashMap<>();
  // key servlet-name  value --> servlet-class
  private Map<String,String> entityMap = new HashMap<>();
  
  
  public WebContext(List<Entity> entitys, List<Mapping> mappings) {
    super();
    this.entitys = entitys;
    this.mappings = mappings;
    
    // 将entity的List转成了map
    for(Entity entity:entitys) {
      entityMap.put(entity.getName(), entity.getClz());
//      System.out.println(entity.getName()+"--"+entity.getClz());
    }
    
  
    // 将mapping的List转成了map
    for(Mapping mapping:mappings) {
      for(String pattern:mapping.getPatterns()) {
        mappingMap.put(pattern, mapping.getName());
      }
      
    }
    
  }
  /**
   * 通过URL的路径找到了对应的class
   * @param pattern
   * @return
   */
  
  public String getClz(String pattern) {
    
    return entityMap.get(mappingMap.get(pattern));
  }
}

​​WebHandler​​

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import java.util.ArrayList;
import java.util.List;

  public class WebHandler extends DefaultHandler {
  
  private List<Entity> entitys = new ArrayList<>();
  private List<Mapping> mappings = new ArrayList<>();
  private Entity entity;
  private Mapping mapping;
  private boolean isMapping = false;
  private String tag; // 存储操作标签
  
  @Override
  public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
    
    System.out.println(qName+"-->解析开始");
    
    if(null!=qName) {
      tag = qName; // 存储标签名
      if(tag.equals("servlet")) {
        entity = new Entity();
        isMapping = false;
      }else if(tag.equals("servlet-mapping")) {
        mapping = new Mapping();
        isMapping = true;
      }
    }
  }
  
  @Override
  public void characters(char[] ch, int start, int length) throws SAXException {
    
    String contents = new String(ch,start,length).trim();
    if(isMapping) { // 操作servlet-mapping
      
      if(tag.equals("servlet-name")) {
        mapping.setName(contents);
      }else if(tag.equals("url-pattern")) {
        mapping.addPattern(contents);
      }
      
    }else { // 操作servlet
      if(tag.equals("servlet-name")) {
        entity.setName(contents);
      }else if(tag.equals("servlet-class")) {
        entity.setClz(contents);
      }
    }
  }
  
  @Override
  public void endElement(String uri, String localName, String qName) throws SAXException {
    
    System.out.println(qName+"-->解析结束");
    
    if(qName.equals("servlet")) {
      entitys.add(entity);
    }else if(qName.equals("servlet-mapping")) {
      mappings.add(mapping);
    }
    tag = "";
  }

  public List<Entity> getEntitys() {
    return entitys;
  }

  public List<Mapping> getMappings() {
    return mappings;
  } 
}

​​Entity​​

/**
 * <servlet>
 *  <servlet-name>login</servlet-name>
 *  <servlet-class>com.whb.server.basic.servlet</servlet-class>
 * </servlet>
 * @author sweetheart
 *
 */
public class Entity {
  private String name;
  private String clz;
  
  public Entity() {
    
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public String getClz() {
    return clz;
  }

  public void setClz(String clz) {
    this.clz = clz;
  }
  
}

​​Mapping​​

import java.util.HashSet;
import java.util.Set;

/**
 * <servlet-mapping>
 *    <servlet-name>login</servlet-name>
 *    <url-pattern>/login</url-pattern>
 *    <url-pattern>/g</url-pattern>
 * </servlet-mapping>
 * @author sweetheart
 *
 */
public class Mapping {
  
  private String name;
  private Set<String> patterns;
  
  public Mapping() {
    patterns = new HashSet<>();
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Set<String> getPatterns() {
    return patterns;
  }

  public void setPatterns(Set<String> patterns) {
    this.patterns = patterns;
  }
  
  public void addPattern(String pattern) {
    this.patterns.add(pattern);
  }
}

​​Servlet​​

/**
 * 服务器小脚本接口
 */
public interface Servlet {
  
  void service(Request request, Response response);
}

​​Server​​

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

/**
 * 整合配置文件
 */
public class Server {
    private ServerSocket serverSocket;

    public static void main(String[] args) {

        Server server = new Server();
        server.start();
        server.receive();
    }

    // 启动服务
    public void start(){
        try {
            serverSocket = new ServerSocket(8888);
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败");
        }
    }

    // 接受连接处理
    public void receive(){
        try {
            Socket client = serverSocket.accept();
            System.out.println("一个客户端建立了连接");
            // 获取请求协议
            Request request = new Request(client);

            // 获取响应
            Response response = new Response(client);
            Servlet servlet = WebAPP.getSevletFromUrl(request.getUrl());

            if (servlet!=null){

                servlet.service(request, response);
                response.pushToBrowser(200);
            }else {
                // 错误...
                response.pushToBrowser(404);
            }


        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("客户端错误");
        }
    }

    // 停止服务
    public void stop(){

    }
}

封装分发器

​​Dispatcher​​

import java.io.IOException;
import java.net.Socket;

// 分发器
public class Dispatcher implements Runnable{

    private Socket client;
    private Request request;
    private Response response;

    public Dispatcher(Socket client){
        this.client = client;
        try {
            // 获取请求协议
            request = new Request(client);
            // 获取响应
            response = new Response(client);
        } catch (IOException e) {
            e.printStackTrace();
            this.release();
        }
    }

    @Override
    public void run() {

        try {
            Servlet servlet = WebAPP.getSevletFromUrl(request.getUrl());

            if (servlet!=null){

                servlet.service(request, response);
                response.pushToBrowser(200);
            }else {
                // 错误...
                response.pushToBrowser(404);
            }
        }catch (Exception e){
            try {
                response.pushToBrowser(500);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        release();  // 防止阻塞
    }

    // 释放资源
    private void release(){
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

​​Server​​

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

/**
 * 多线程处理
 */
public class Server08 {
    private ServerSocket serverSocket;
    private boolean isRunning;

    public static void main(String[] args) {

        Server08 server = new Server08();
        server.start();
        server.receive();
    }

    // 启动服务
    public void start(){
        try {
            serverSocket = new ServerSocket(8888);
            isRunning = true;
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败");
            stop();
        }
    }

    // 接受连接处理
    public void receive(){
        while (isRunning){
            try {
                Socket client = serverSocket.accept();
                System.out.println("一个客户端建立了连接");
                // 多线程
                new Thread(new Dispatcher(client)).start();

            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("客户端错误");
            }
        }
    }

    // 停止服务
    public void stop(){
        isRunning = false;
        try {
            this.serverSocket.close();
            System.out.println("服务器已经停止");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

404/505/首页处理

​​Dispatcher​​

import java.io.IOException;
import java.io.InputStream;
import java.net.Socket;

// 分发器: 加入状态内容处理 404 505 及首页
public class Dispatcher implements Runnable{

    private Socket client;
    private Request request;
    private Response response;

    public Dispatcher(Socket client){
        this.client = client;
        try {
            // 获取请求协议
            request = new Request(client);
            // 获取响应
            response = new Response(client);
        } catch (IOException e) {
            e.printStackTrace();
            this.release();
        }
    }

    @Override
    public void run() {
        String url = request.getUrl();

        try {

            if (url == null || url.equals("")){
                InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("index.html");
                response.print(new String(is.readAllBytes()));
                response.pushToBrowser(200);
                is.close();
                return;
            }

            Servlet servlet = WebAPP.getSevletFromUrl(url);

            if (servlet!=null){

                servlet.service(request, response);
                response.pushToBrowser(200);
            }else {
                // 错误...
                InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("error.html");
                response.print(new String(is.readAllBytes()));
                response.pushToBrowser(404);
                is.close();
            }
        }catch (Exception e){
            try {
                response.println("服务器问题......");
                response.pushToBrowser(500);
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        release();  // 防止阻塞
    }

    // 释放资源
    private void release(){
        try {
            client.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

​​Server​​

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

/**
 * 处理404 505和首页
 */
public class Server09 {
    private ServerSocket serverSocket;
    private boolean isRunning;

    public static void main(String[] args) {

        Server09 server = new Server09();
        server.start();
        server.receive();
    }

    // 启动服务
    public void start(){
        try {
            serverSocket = new ServerSocket(8888);
            isRunning = true;
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("服务器启动失败");
            stop();
        }
    }

    // 接受连接处理
    public void receive(){
        while (isRunning){
            try {
                Socket client = serverSocket.accept();
                System.out.println("一个客户端建立了连接");
                // 多线程
                new Thread(new Dispatcher(client)).start();

            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("客户端错误");
            }
        }
    }

    // 停止服务
    public void stop(){
        isRunning = false;
        try {
            this.serverSocket.close();
            System.out.println("服务器已经停止");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

​​error.html​​

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>404页面</title>
</head>
<body>
    <h1>404错误页面</h1>
    <img src="./CrystalLiu2.jpg" />
</body>
</html>

​​index.html​​

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>首页</title>
</head>
<body>
    <h1>欢迎使用web-server</h1>
</body>
</html>