java Socket + 自定义线程池实现web服务器仿Servlet

时间 2019-11-08

标签 java socket 自定义线程实现 web 服务器 servlet 栏目 Java 繁體版

原文原文链接

前言

基于java Scoket的TCP协议简单实现http web服务器，使用自定义线程池去处理每个请求,用浏览器看成客户端，达到javaWeb中相似于访问Servlet的效果。（对http协议和Servlet要有必定了解）html

执行效果：

http服务器端：

客户端 (login.html): java

登录后： 测试帐号：zjl 123456

思路

浏览器端：是一个html的表单，输入姓名密码后点击登录便可，访问服务器地址为localhost:8080/login，而后会自动链接服务器并发送http协议的请求消息。
服务器：服务器每次接收到一个请求后,交给自定义线程池去处理,会把接收到的请求进行解析，在请求消息中解析出客户端欲请求的资源(这里是/login)，请求方式(get或者post),和请求参数，而后封装到Request实体中。而后就要根据请求资源来得到对应的Servlet了，请求资源和Servlet的全路径类名的映射关系放在web.xml这个文件，因此利用dom4j解析web.xml文件便可获得Servlet的全路径类名，再利用反射便可建立出此servlet的实例。有了Servlet的实例后调用Servlet实例的service方法并把封装后的Request对象和Reponse对象做为参数传入便可，这样就执行了Servlet的service方法，再用reponse调用print方法便可向客户端发送响应消息。

思路图形化

代码目录结构

主要代码为下面几个

web.xml配置

自定义xml文件,主要配置请求url和负责处理这个请求的Servlet实体类的映射关系,每新增一个Servlet都须要在这里配置

<?xml version="1.0" encoding="UTF-8" ?>
<web-app>
    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>demo.ServletImpl.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>
</web-app>

复制代码

入口startServer代码为

至关于服务器负责接收每个来自客户端的请求,而后放到线程池去处理此次请求

public class startServer {

    private static RequestThreadPool<ServerThread> requestThreadPool = new RequestThreadPool<>();

    public static void main(String[] args) throws Exception {
        ServerSocket server   = new ServerSocket(8080);
        System.out.println("http服务器启动成功....");

        //多线程处理每一个请求
        while(true){
            Socket client = server.accept();  //阻塞式等待接收一个请求
           // new ServerThread(client).start(); 旧版
            requestThreadPool.execute(new ServerThread(client));
        }
    }

    /** * 服务器处理浏览器请求线程 */
    static class ServerThread extends Thread{

        private Request request;  //请求
        private Response reponse;   //响应
        private Socket client;

        //初始化request，reponse
        public ServerThread(Socket client) {
            try {
                this.client = client;
                request = new Request(client.getInputStream());
                reponse = new Response(client.getOutputStream());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        @Override public void run() {
            try {
                System.out.println(client.getRemoteSocketAddress()+" 发出请求");

                //浏览器会默认请求网站图标资源，咱们这里忽略掉这个请求
                if (request.getUrl().equals("/favicon.ico"))
                    return;

                //1-根据请求的url得到Servlet
                Servlet servlet  = ServletFactory.getServlet(request.getUrl());

                //请求资源不存在404
                if (servlet == null){
                    reponse.setCode(404);
                    reponse.print("");
                }

                //2-执行Servlet
                if (servlet != null){
                    servlet.service(request,reponse);
                }


            } catch (Exception e) {
                e.printStackTrace();
            }finally {
                try {
                    client.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}
复制代码

自定义线程池RequestThreadPool代码

所谓的自定义线程池,不过就是里面有一个放着待处理请求(这里的任务具体指一次请求)的集合队列, 而后事先建立好n个线程去消费集合任务队列,外部每次调用execute方法都会把待处理任务添加到任务队列,而后随机唤醒一个消费线程去处理任务

package demo3.util;

import java.util.*;
import java.util.concurrent.atomic.AtomicLong;

/** * 自定义处理请求的线程池 * * * */
public class RequestThreadPool<Job extends Runnable> {
    //任务列表 (线程池)
    private final LinkedList<Job> jobsList = new LinkedList<>();

    //工做线程队列
    private final List<MyWorker> workerList = Collections.synchronizedList(new ArrayList<MyWorker>());

    //默认工做者线程数量
    private static final int DEFAULT_WORKER_NUMBERS = 5;

    //工做者编号生成序号
    private AtomicLong threadNum = new AtomicLong();


    // 构造方法
    public RequestThreadPool(){
        initWorkerThreadByNum(DEFAULT_WORKER_NUMBERS);

    }
    public RequestThreadPool(int workerNum){
        initWorkerThreadByNum(workerNum);
    }

    public void initWorkerThreadByNum(int workerNum){
        for (int i = 0; i < workerNum; i++) {
            MyWorker worker =  new MyWorker();
            workerList.add(worker);

            //工做线程开始消费任务
            new Thread (worker, "ThreadPool-Worker-"+ threadNum.incrementAndGet()).start();
        }
    }


    //把任务交给线程池，以后工做线程回去消费它
    public void execute(Job job) {
            if (job != null){
                synchronized (jobsList){
                    jobsList.addLast(job);
                    System.out.println("剩余待处理请求个数："+RequestThreadPool.this.getJobsize());
                    jobsList.notify();  //随机唤醒在此jobsList锁上等待的工做者线程
                }
            }
    }

    //关闭全部的工做者线程
    public void shutdown() {
        for (MyWorker e : workerList) {
            e.shutdown();
        }
    }
    
    //获取剩余任务个数
    public int getJobsize() {
        return jobsList.size();
    }

    
    /** * 工做线程，消费任务 */
    private class MyWorker implements Runnable{
        //是否工做
        private volatile boolean isRunning = true;

        @Override public void run() {
            while(isRunning){
                Job job = null;

                //同步获取任务
                synchronized(jobsList){
                    //若是任务列表为空就等待
                    while(jobsList.isEmpty()){
                        try {
                            jobsList.wait();
                        } catch (InterruptedException e) {
                            //感知到被中断就退出
                            return;
                        }
                    }
                    //获取任务
                    job = jobsList.removeFirst();
                }

                //执行任务
                if (job != null){
                    System.out.println("正在处理请求");
                    job.run();
                    System.out.println("处理完成，剩余待处理请求个数："+RequestThreadPool.this.getJobsize());

                }

            }
        }

        //关闭线程
        public void shutdown(){
            isRunning = false;
        }
    }
}

复制代码

ServletFactory

下面web.xml文件的路径xmlpath需根据本身电脑环境设置不然会找不到该文件
用于根据请求url获取对应Servlet实体类

/** * Servlet工厂 * * 根据url和xml文件建立Servlet * * */
public class ServletFactory {

    //Servlet上下文环境
    private static ServletContext context = new ServletContext();

    //web.xml文件路径
    private static String xmlpath = "http服务器/src/demo/web.xml";

    private ServletFactory(){}

    /** * 读取web.xml文件把servlet和url的关系进行配置存储 */
    static {
        try {
            //1-得到doucument
            SAXReader saxReader = new SAXReader();
            Document document = saxReader.read(new File(xmlpath));

            //2-得到根元素 <web-app>
            Element rootElement = document.getRootElement();

            //3-得到全部子元素
            List<Element> elements = rootElement.elements();

            //4-遍历处理全部子元素
            for (Element e : elements) {
                if ("servlet-mapping".equals(e.getName())) {
                    Element servlet_name = e.element("servlet-name");
                    Element url_pattern = e.element("url-pattern");
                    context.getUrl_map().put(url_pattern.getText(),servlet_name.getText());
                }
                else if ("servlet".equals(e.getName())) {
                    Element servlet_name = e.element("servlet-name");
                    Element servlet_class = e.element("servlet-class");
                    context.getServlet_map().put(servlet_name.getText(),servlet_class.getText());
                }
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }


    /** * 得到Servlet */
    public static synchronized Servlet getServlet(String url) throws Exception {
        String servletClass = context.getServlet_map().get(context.getUrl_map().get(url));

        if (servletClass != null)
            return (Servlet)Class.forName(servletClass).newInstance();
        else
            return null;
    }
}
复制代码

ServletContext上下文环境

存储全部的请求和Servlet映射关系

/** * Servlet的上下文环境 */
public class ServletContext {

    //Servlet别名和Servlet全路径类名的映射关系
    private  Map<String,String>  servlet_map;

    //url和 Servlet别名的映射关系
    private  Map<String,String> url_map;

    public ServletContext() {
        servlet_map = new HashMap<>();
        url_map = new HashMap<>();
    }

    public Map<String, String> getServlet_map() {
        return servlet_map;
    }


    public Map<String, String> getUrl_map() {
        return url_map;
    }
}
复制代码

Servlet抽象类代码

Servlet顶层接口,用户需自定义继承它实现本身的Servlet

/** * Servlet抽象类 */
public abstract class Servlet {

    public void service(Request request,Response reponse) throws Exception {
        this.doGet(request,reponse);
        this.doPost(request,reponse);
    }


    public abstract void doGet(Request request,Response reponse) throws Exception;
    public abstract void doPost(Request request,Response reponse) throws Exception;

}

复制代码

LoginServlet代码

自定义Servlet,负责处理登录请求

import demo.domain.Request;
import demo.domain.Response;
import demo.domain.Servlet;
public class LoginServlet extends Servlet {
    @Override public void doGet(Request request, Response reponse) throws Exception {

        String name = request.getParameter("name");
        String password = request.getParameter("password");

        if (name!= null && password !=null && name.equals("zjl") && password.equals("123456"))
            reponse.print("登录成功！");
        else
            reponse.print("登录失败!");
    }

    @Override public void doPost(Request request, Response reponse) throws Exception {
        doGet(request,reponse);
    }
}

复制代码

完成上述以后,如今你能够实现本身自定义的Servlet去处理每个请求,只要去继承Servlet抽象类便可,而后再在web.xml中配置一下Setvlet的属性便可.

完整代码地址

连接:pan.baidu.com/s/1zaJy3wK-… 密码:ovgqweb

赞扬

若是以为文章有用,你可鼓励下做者若是浪费你时间了,在这里先跟你抱歉

java Socket + 自定义线程池 实现web服务器 仿Servlet

前言