通过一个xml文件来确定服务器要如何响应相关请求

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app>
    3.     <servlet>
    4.         <servlet-name>login</servlet-name>
    5.         <servlet-class>com/xys/server/basic/LoginServlet</servlet-class>
    6.     </servlet>
    7.     <servlet>
    8.         <servlet-name>reg</servlet-name>
    9.         <servlet-class>com/xys/server/basic/RegisterServlet</servlet-class>
    10.     </servlet>
    11.     <servlet-mapping>
    12.         <servlet-name>login</servlet-name>
    13.         <url-pattern>/login</url-pattern>
    14.         <url-pattern>/g</url-pattern>
    15.     </servlet-mapping>
    16.     <servlet-mapping>
    17.         <servlet-name>reg</servlet-name>
    18.         <url-pattern>/reg</url-pattern>
    19.     </servlet-mapping>
    20. </web-app>

    在这个例子中如果浏览器做了/login或/g请求，则服务器就需要执行com.xys.server.basic.LoginServlet类中的操作
    下面四个类用于解析web.xml以判断何时需要执行哪个类中的操作，再创建相应的响应类做出响应

    1. package com.xys.server.basic;
    3. import java.util.HashMap;
    4. import java.util.List;
    5. import java.util.Map;
    7. //将entities容器和mappings容器转换为Map容器
    8. public class WebContext {
    9.     private final Map<String, String> EntityMap = new HashMap<>();
    10.     private final Map<String, String> MappingMap = new HashMap<>();
    11.     public WebContext(List<Entity> entities, List<Mapping> mappings){
    12.         for(Entity en :entities){
    13.             EntityMap.put(en.getName(), en.getClz());
    14.         }
    15.         for(Mapping ma :mappings){
    16.             for(String pa:ma.getPatterns() ){
    17.                 MappingMap.put(pa, ma.getName());
    18.             }
    19.         }
    20.     }
    22.     //通过url获取相应类的地址
    23.     public String getClz(String pattern){
    24.         return EntityMap.get(MappingMap.get(pattern));
    25.     }
    26. }
    1. package com.xys.server.basic;
    3. public class Entity {
    4.     private String name;
    5.     private  String clz;
    7.     //保存web.xml中一个servlet标签中的相关内容
    8.     public Entity(){
    10.     }
    12.     public void setName(String name) {
    13.         this.name = name;
    14.     }
    16.     public void setClz(String clz) {
    17.         this.clz = clz;
    18.     }
    20.     public String getName() {
    21.         return name;
    22.     }
    24.     public String getClz() {
    25.         return clz;
    26.     }
    27. }
    1. package com.xys.server.basic;
    3. import java.util.HashSet;
    4. import java.util.Set;
    6. //保存web.xml中一个servlet-mapping标签中的相关内容
    7. public class Mapping {
    8.     private String name;
    9.     private Set<String> patterns;
    11.     public Mapping(){
    12.         patterns = new HashSet<String>();
    13.     }
    15.     public void setName(String name) {
    16.         this.name = name;
    17.     }
    19.     public String getName() {
    20.         return name;
    21.     }
    23.     public void setPatterns(Set<String> patterns) {
    24.         this.patterns = patterns;
    25.     }
    27.     public Set<String> getPatterns() {
    28.         return patterns;
    29.     }
    31.     public void addPatterns(String pattern){
    32.         patterns.add(pattern);
    33.     }
    34. }
    1. package com.xys.server.basic;
    3. import org.xml.sax.Attributes;
    4. import org.xml.sax.helpers.DefaultHandler;
    5. import javax.xml.parsers.SAXParser;
    6. import javax.xml.parsers.SAXParserFactory;
    7. import java.net.Socket;
    8. import java.util.ArrayList;
    9. import java.util.List;
    11. //解析WebXML
    12. public class SaxAnalyze {
    13.     public void Analyze(String pattern, String parameter, Socket client) throws Exception {
    14.         Response response = new Response(client);
    15.         //1、获取解析工厂
    16.         SAXParserFactory factory = SAXParserFactory.newInstance();
    17.         //2、从解析工厂获取解析器
    18.         SAXParser parser = factory.newSAXParser();
    19.         //4、加载处理器
    20.         WebHandle handle = new WebHandle();
    21.         //5、解析：执行处理器中的方法，在该例子中，处理器会根据Web.xml中的内容创建servlet对象和servlet-mapping对象，并将其存入容器
    22.         parser.parse(Thread.currentThread().getContextClassLoader().getResourceAsStream("com/xys/server/basic/Web.xml"), handle);
    23.         //调用WebContext类将解析获取的servlet对象和servlet-mapping对象存入map，方便通过servlet-mapping找到对应的servlet，再通过servlet找到对应的类
    24.         WebContext wc = new WebContext(handle.getEntities(),handle.getMappings());
    25.          //通过url获取相应类的地址
    26.         String index = "<html>" +
    27.                 "<head>" +
    28.                 "<title>" +
    29.                 "index" +
    30.                 "</title>" +
    31.                 "</head>" +
    32.                 "<body>" +
    33.                 "MyServer的回复：主页" +
    34.                 "</body>" +
    35.                 "</html>";
    36.         //url请求为空则进入主页
    37.         if(pattern == null || pattern.equals("") || pattern.equals("/"))
    38.             response.PushToBrowser(200, index);
    39.         else {
    40.             //url请求不为空，则根据web.xml的内容创建相关类
    41.             String name = wc.getClz(pattern);
    42.             if (name != null) {
    43.                 name = name.replace("/", ".");
    44.                 //利用反射创建相关类
    45.                 Class<?> Clz = Class.forName(name);
    46.                 //声明一个响应接口，用该接口接收一个响应实现类对象，根据不同的请求会实例化不同的响应实现类对象
    47.                 Servlet servlet = (Servlet) Clz.getConstructor().newInstance();
    48.                 servlet.Service(parameter, client);
    49.                 //请求不存在返回404页
    50.             } else {
    51.                 String errorContent = "<html>" +
    52.                         "<head>" +
    53.                         "<title>" +
    54.                         "error" +
    55.                         "</title>" +
    56.                         "</head>" +
    57.                         "<body>" +
    58.                         "MyServer的回复：404 NOT FOUND" +
    59.                         "</body>" +
    60.                         "</html>";
    61.                 response.PushToBrowser(404, errorContent);
    62.             }
    63.         }
    64.     }
    66.     //3、编写处理器
    67.     private static class WebHandle extends DefaultHandler{
    69.         private final List<Entity> entities = new ArrayList<>();
    70.         private final List<Mapping> mappings = new ArrayList<>();
    71.         private Entity entity;
    72.         private Mapping mapping;
    73.         String tag;
    74.         boolean isMapping = false;
    76.         //建servlet对象和servlet-mapping对象
    77.         @Override
    78.         public void startElement(String uri, String localName, String qName, Attributes attributes) {
    79.             tag = qName;
    80.             if(tag.equals("servlet")){
    81.                 entity = new Entity();
    82.             }else if(tag.equals("servlet-mapping")){
    83.                 mapping = new Mapping();
    84.                 isMapping = true;
    85.             }
    86.         }
    88.         //根据XML中的内容为对象的属性赋值
    89.         @Override
    90.         public void characters(char[] ch, int start, int length) {
    91.             String str = new String(ch, start, length);
    92.             if(tag != null && !str.equals("")){
    93.                 if(isMapping){
    94.                     if(tag.equals("servlet-name")){
    95.                         mapping.setName(str);
    96.                     }else if(tag.equals("url-pattern")){
    97.                         mapping.addPatterns(str);
    98.                     }
    99.                 }else{
    100.                     if(tag.equals("servlet-name")){
    101.                         entity.setName(str);
    102.                     }else if(tag.equals("servlet-class")){
    103.                         entity.setClz(str);
    104.                     }
    105.                 }
    106.             }
    107.         }
    109.         //将对象放入容器
    110.         @Override
    111.         public void endElement(String uri, String localName, String qName) {
    112.                 if (qName.equals("servlet")) {
    113.                     entities.add(entity);
    114.                 } else if (qName.equals("servlet-mapping")) {
    115.                     mappings.add(mapping);
    116.                 }
    117.             tag = null;
    118.         }
    120.         public List<Entity> getEntities() {
    121.             return entities;
    122.         }
    124.         public List<Mapping> getMappings() {
    125.             return mappings;
    126.         }
    127.     }
    128. }

    响应接口，所有响应类均实现该接口，这样在做出响应时只需要声明一个相应接口，然后调用接口中相应的方法即可，上面的方法会自行根据请求实例化不同的响应实现类

    1. package com.xys.server.basic;
    3. import java.net.Socket;
    5. public interface Servlet {
    6.     void Service(String parameter, Socket client);
    7. }

    两个实现类：实现类可以接受请求参数，并执行将请求参数放入map中的处理操作
    登录

    1. package com.xys.server.basic;
    3. import java.net.Socket;
    4. import java.util.*;
    6. //登录
    7. public class LoginServlet implements Servlet{
    8.     @Override
    9.     public void Service(String parameter, Socket client) {
    10.         Map<String, List<String>> ServiceParameter = Convert.convertMap(parameter);
    11.         System.out.println("参数为："+parameter);
    12.         for(String key:ServiceParameter.keySet()){
    13.             System.out.print(key+": ");
    14.             List<String> values = ServiceParameter.get(key);
    15.             String[] valueArray = values.toArray(new String[0]);
    16.             for(String value:valueArray){
    17.                 System.out.print(value+" ");
    18.             }
    19.             System.out.println();
    20.         }
    21.         Response response = new Response(client);
    22.             //编写响应正文
    23.             String content = "<html>" +
    24.                     "<head>" +
    25.                     "<title>" +
    26.                     "success" +
    27.                     "</title>" +
    28.                     "</head>" +
    29.                     "<body>" +
    30.                     "LoginServlet的回复：登录成功" +
    31.                     "</body>" +
    32.                     "</html>";
    33.         response.PushToBrowser(200, content);
    34.     }
    35. }

    注册

    1. package com.xys.server.basic;
    3. import java.io.IOException;
    4. import java.net.Socket;
    5. import java.util.List;
    6. import java.util.Map;
    8. //注册
    9. public class RegisterServlet implements Servlet{
    10.     @Override
    11.     public void Service(String parameter, Socket client) {
    12.         Map<String, List<String>> RegisterParameter = Convert.convertMap(parameter);
    13.         System.out.println("参数为："+parameter);
    14.         for(String key:RegisterParameter.keySet()){
    15.             System.out.print(key+": ");
    16.             List<String> values = RegisterParameter.get(key);
    17.             String[] valueArray = values.toArray(new String[0]);
    18.             for(String value:valueArray){
    19.                 System.out.print(value+" ");
    20.             }
    21.             System.out.println();
    22.         }
    23.         try{
    24.             Response response = new Response(client.getOutputStream());
    25.             //编写响应正文
    26.             String content = "<html>" +
    27.                     "<head>" +
    28.                     "<title>" +
    29.                     "success" +
    30.                     "</title>" +
    31.                     "</head>" +
    32.                     "<body>" +
    33.                     "RegisterServlet的回复：用户注册" +
    34.                     "</body>" +
    35.                     "</html>";
    36.             response.PushToBrowser(200, content);
    37.         } catch (IOException e) {
    38.             e.printStackTrace();
    39.         }
    41.     }
    42. }
    1. package com.xys.server.basic;
    3. import java.util.*;
    5. public class Convert {
    6.     //将请求参数转为map容器
    7.     public static Map<String, List<String>> convertMap(String parameter) {
    8.         Map<String, List<String>> parameterM = new HashMap<>();
    9.         String[] KeyValues = parameter.split("&");
    10.         for (String query : KeyValues) {
    11.             String[] kv = query.split("=");
    12.             kv = Arrays.copyOf(kv, 2);//避免有些参数是空值导致kv的长度只有1
    13.             String key = kv[0];
    14.             String value = kv[1];
    15.             //如果这个key还没有被存进map，就在容器中新建一个键值对
    16.             if (!parameterM.containsKey(key))
    17.                 parameterM.put(key, new ArrayList<String>());
    18.             //获取相应的key值所对应的value容器，将value存入
    19.             parameterM.get(key).add(value);
    21.         }
    22.         return parameterM;
    23.     }
    24. }

    向浏览器发送响应的类，任何类都可以调用该类向浏览器发送响应，例如上面的两个响应实现类就有调用这个类

    1. package com.xys.server.basic;
    3. import java.io.BufferedWriter;
    4. import java.io.IOException;
    5. import java.io.OutputStream;
    6. import java.io.OutputStreamWriter;
    7. import java.net.Socket;
    8. import java.nio.charset.StandardCharsets;
    9. import java.util.Date;
    11. //服务器响应请求
    12. public class Response {
    13.     private BufferedWriter bw;
    14.     private String content;
    15.     private StringBuilder headInfo;
    16.     private int len;
    17.     private final String BLANK = " ";
    18.     private final String CRLF = "\r\n";
    19.     private Response(){
    20.         content = "";
    21.         headInfo = new StringBuilder();
    22.         len = 0;
    23.     }
    25.     public Response(Socket client){
    26.         this();
    27.         try{
    28.             bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
    29.         } catch (IOException e) {
    30.             e.printStackTrace();
    31.         }
    32.     }
    34.     public Response(OutputStream os){
    35.         this();
    36.         try{
    37.             bw = new BufferedWriter(new OutputStreamWriter(os));
    38.         } catch (Exception e) {
    39.             e.printStackTrace();
    40.         }
    41.     }
    43.     //建立响应协议并发送
    44.     public void PushToBrowser(int code, String content) {
    45.         if(headInfo == null)
    46.             code = 505;
    47.         len = content.getBytes(StandardCharsets.UTF_8).length;
    48.         buildHead(code);
    49.         try{
    50.             bw.append(headInfo);
    51.             bw.append(content);
    52.             bw.flush();
    53.         } catch (IOException e) {
    54.             e.printStackTrace();
    55.         }
    57.     }
    59.     //建立状态行和响应头
    60.     private void buildHead(int code){
    61.         headInfo.append("HTTP/1.1").append(BLANK);
    62.         headInfo.append(code).append(BLANK);
    63.         switch(code){
    64.             case 200:
    65.                 headInfo.append("OK").append(CRLF);
    66.                 break;
    67.             case 404:
    68.                 headInfo.append("NOT FOUND").append(CRLF);
    69.                 break;
    70.             case 505:
    71.                 headInfo.append("SERVER ERROR").append(CRLF);
    72.                 break;
    73.         }
    74.         headInfo.append("Date:").append(new Date()).append(CRLF);
    75.         headInfo.append("Server:MyServer/0.01;charset:UTF-8").append(CRLF);
    76.         headInfo.append("Content-type:text/html").append(CRLF);
    77.         headInfo.append("Content-length:").append(len).append(CRLF).append(CRLF);
    78.     }
    79. }

    主类，同时用于获取请求参数，并将参数传给响应实现类进行进一步操作

    1. package com.xys.server.basic;
    3. import java.io.InputStream;
    4. import java.net.ServerSocket;
    5. import java.net.Socket;
    7. //主类
    8. public class Main {
    9.     private static boolean isRunner = true;
    10.     public static void main(String[] args) throws Exception {
    11.         ServerSocket s_socket = new ServerSocket(8888);
    12.         while(isRunner){
    13.             Socket client = s_socket.accept();
    14.             System.out.println("------------------------------");
    15.             System.out.println("一个客户端建立了连接");
    16.             new Thread(new Dispatcher(client)).start();
    17.         }
    18.     }
    20.     //封装内部类：多线程获取不同的请求内容
    21.     private static class Dispatcher implements Runnable{
    22.         private final Socket client;
    23.         public Dispatcher(Socket client){
    24.             this.client = client;
    25.         }
    26.         @Override
    27.         public void run() {
    28.             try{
    29.                 SaxAnalyze sa = new SaxAnalyze();
    30.                 //获取请求协议
    31.                 InputStream is = client.getInputStream();
    32.                 byte[] flush = new byte[1024 * 10];
    33.                 int len = is.read(flush);
    34.                 String info = new String(flush, 0, len);
    35.                 //从请求协议中分离URI
    36.                 int idx1 = info.indexOf("/");
    37.                 int idx2 = info.indexOf(" ", idx1);
    38.                 String pattern = info.substring(idx1, idx2);
    39.                 //从请求协议中分离参数
    40.                 String parameter = info.substring(info.lastIndexOf("\r\n") + 1);
    41.                 System.out.println("请求协议：" + "\r\n" + info);
    42.                 System.out.println("请求的服务为：" + pattern);
    43.                 //解析xml，并根据获得的URI创建对应的对象，并将获得的参数传给创建的对象
    44.                 sa.Analyze(pattern, parameter, client);
    45.                 client.close();
    46.             } catch (Exception e) {
    47.                 e.printStackTrace();
    48.                 isRunner = false;
    49.             }
    50.         }
    51.     }
    52. }