Java 从底层socket实现http服务器

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量1k 收藏
点赞数
分类专栏： JAVA 文章标签： socket java css http服务器 http协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/llf22282776/article/details/51577130
版权

本文以JAVA socket编程，实现http服务器,
http协议基础自行学习
不多说，上代码
Httpsimple类：

package css_nobody;


import java.io.BufferedReader;  
import java.io.IOException;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.io.OutputStream;  
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.swing.JTextArea;  



public class HttpSimpleServer implements Runnable{
    private int port;//绑定端口号

    private String Web_root;//html文件根目录
    private ServerSocket serverSocket;//服务器套接字
    private ExecutorService threadpool;//线程池
    private Safty_JtextArea msgDisplayer;//展示信息
    public HttpSimpleServer(int port,String web_root,Safty_JtextArea jt) {
            this.port=port;
            this.Web_root=web_root;
            msgDisplayer=jt;

    }
    public boolean startServer() throws IOException {

            serverSocket=new ServerSocket(port);

            threadpool=Executors.newCachedThreadPool();
            while(true){
            Socket  client= serverSocket.accept();
            System.out.println("New client connection!");
            System.out.println("address:"+client.getInetAddress().getHostAddress()+" "+client.getInetAddress().getHostName());
            threadpool.execute(new ResponderServer(client,msgDisplayer,Web_root));//放入线程池中进行

            }








    }
    @Override
    public void run() {
        try {
            startServer();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


}

ResponderServer类

package css_nobody;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Reader;
import java.net.InetAddress;
import java.net.Socket;
import java.net.SocketException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Vector;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

import javax.lang.model.element.Element;
import javax.swing.JTextArea;



public class ResponderServer implements Runnable{
private Socket clientsocket;//客户套接字
private InputStream dateFromClient;//写入流
private OutputStream dateToClient;//写出流
private Safty_JtextArea msgtxt;//消息显示区域
private String[]  addressClient;//地址，端口
private Map<String, String> table;//请求/相应头部
private final int TIME_OUT =100000;//请求时间
private String web_root;//文件根目录
public ResponderServer(Socket client,Safty_JtextArea jt,String web_root) {
    // TODO Auto-generated constructor stub
    clientsocket=client;
    this.web_root=web_root;
    msgtxt=jt;
    dateFromClient=null;
    dateToClient=null;
    addressClient=new String[2];
    table=new HashMap<String,String>();
    table.put("Date", "");//服务器日期
    table.put("Server", "father of kongzhe");//服务器名称
    table.put("Accept", "text/html");//接受请求类型
    table.put("Content-Length", "");//相应正文长度
    table.put("Last-Modified", "");//最后修改日期
    table.put("Msg", "");//如果为测试客户端，这个将会返回测试客户端发送的内容+accept,表明通信协议正确
    table.put("Cookies", "111");//一些标志身份的数据

}
@SuppressWarnings("finally")
@Override
public void run() {
    //处理请求，发送结果，关闭输入输出流
    boolean isgetted= getStream();
    System.out.println("strem already get!!");
    if(isgetted==false){
        try {
            clientsocket.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();

        }
        finally{
            return;

        }
    }//打开流失败，不连接
     try {
        clientsocket.setSoTimeout(TIME_OUT);//设置超时
    } catch (SocketException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
     BufferedInputStream bin=new BufferedInputStream(dateFromClient);
    try {
        LinkedList<Byte> alldatalist=new LinkedList<Byte>();//链表

        int byteint;
        queue lqueue=new queue(4);//最大大小

        while((byteint=bin.read())!=-1){//有数据
            System.out.println("read byte:"+byteint+" "+(char)byteint);
            alldatalist.add(Byte.valueOf((byte)byteint));
            if(canbebreak(lqueue, byteint)){break;}
            //将信息全部读出来，放到队列里面

        }
            Byte[] bytearray_up=new Byte[alldatalist.size()];
            alldatalist.toArray(bytearray_up);
            byte[] bytearray=new byte[bytearray_up.length];
            for(int i=0;i<bytearray_up.length;i++)bytearray[i]=bytearray_up[i].byteValue();//析构为byte
            StringBuffer datestring=new StringBuffer(new String(bytearray));//创建一个缓冲字符串
            System.out.println("alldata:"+datestring);
            analysisAndResponde(datestring);//进行分析处理

    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }




}

public boolean getStream() {

    try {
        dateFromClient= clientsocket.getInputStream();//输入liu 
        dateToClient=clientsocket.getOutputStream();
        InetAddress intadd=clientsocket.getInetAddress();//

        addressClient[1]=intadd.getHostAddress();
        System.out.println("addressClient[1]"+addressClient[1]);

        addressClient[0]=intadd.getHostName();
        System.out.println("addressClient[0]"+addressClient[0]);
        return true;
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
        msgtxt.append(addressClient[0]+":"+addressClient[1]+"failed!");
        return false;
    }//输出流

}
private void analysisAndResponde(StringBuffer alldate){//分析Method,分布处理
    int index=0;
    if("GET".equalsIgnoreCase(alldate.substring(0, alldate.indexOf(" "))))//第一个空格之前的,为方法
    {  
        index=alldate.indexOf(" ");
        GetMethod(alldate, index);//进行get方法处理
    }
    else if("POST".equalsIgnoreCase(alldate.substring(0, alldate.indexOf(" ")))){
        index=alldate.indexOf(" ");
        PostMethod(alldate, index);//进行post 方法处理

    }
    else {

        FaileMethod();//进行失败方法处理
    }


}
private void GetMethod(StringBuffer alldate,int index){
         String url= alldate.substring(index+" ".length(), alldate.indexOf(" ", index+" ".length()));//从第1个空格之后，截取一段直到第二个空格为止的字符串
         Map<String, String> requestFromClient =new HashMap<String,String>();//表头以哈希表的形式放进去
            index=alldate.indexOf("\r\n");//找到以第一个index

            boolean isEnded=false;
            while(isEnded==false){
                String stringtemp=alldate.substring(index+"\r\n".length(),alldate.indexOf("\r\n",index+"\r\n".length()));//第一个\r\n之后开始变为一个新航
                System.out.println("stringtemp1:"+stringtemp);
                if(stringtemp==null || stringtemp.equals("") || stringtemp.length()<=0){
                    isEnded=true;//找到最后一行了
                }
                else{
                    String[] keyAndValues= stringtemp.split(":");
                    if(keyAndValues!=null && keyAndValues.length>=2){
                        System.out.println("key:"+keyAndValues[0]+" Values:"+keyAndValues[1]);
                        requestFromClient.put(keyAndValues[0], keyAndValues[1]);

                    }
                    else{
                        System.out.println("can not know");
                    }

                    index=alldate.indexOf("\r\n",index+"\r\n".length());//下一个行的开始
                }
            }//这些就放进去了
            System.out.println("urlpath:"+web_root+url);
         File f=new File(web_root+url);
         if(f.exists()==false){//文件不存在
             FaileMethod(requestFromClient);//访问失败
             return;

         }
         try {

            FileInputStream fin=new FileInputStream(f);//建立输入流
            StringBuffer dateback=new StringBuffer();//建立输出数据的缓冲
            byte[] bytedate=new byte[fin.available()];//

            fin.read(bytedate);//读出来
            fin.close();//关闭文件流
            dateback.append(new String(bytedate));//将字符流变成字符串,输出到输出数据缓冲,这个缓冲是响应正文

            String msgvalue=requestFromClient.get("Msg");
            if(msgvalue!=null ){//
                System.out.println("out!!"+msgvalue);
                table.put("Msg", "acceptted:"+msgvalue);        
            }
            table.put("Date",new SimpleDateFormat().format(new Date()));
            table.put("Last-Modified", new SimpleDateFormat().format(new Date()));
            table.put("Content-Length", ""+bytedate.length);//
            String s="HTTP/1.0 200 0K\r\n"+MapToString(table)+"\r\n"+dateback.toString();
            dateToClient.write(s.getBytes());//写出去
            dateToClient.flush();//刷新
            clientsocket.shutdownOutput();


            String allmsg=MapToString(requestFromClient);
            msgtxt.setText(msgtxt.getText()+ "来自("+addressClient[0]+":"+addressClient[1]+")的请求头:\r\n"+allmsg);
            //clientsocket.close();//结束服务




        } catch (FileNotFoundException e) {

            e.printStackTrace();
        }
         catch(IOException e1){

             e1.printStackTrace();

         }




}
private void PostMethod(StringBuffer alldate,int index){
    GetMethod(alldate, index);//暂时按get处理



}

private void FaileMethod(Map<String, String> requestFromClient){
    table.put("Date",new SimpleDateFormat().format(new Date()));
    table.put("Last-Modified", new SimpleDateFormat().format(new Date()));
    table.put("Content-Length", ""+0);//
    String s="HTTP/1.0 404 Not Found\r\n"+MapToString(table)+"\r\n";
    String allmsg=MapToString(requestFromClient);
    msgtxt.append("来自("+addressClient[0]+":"+addressClient[1]+")的请求头:\r\n"+allmsg);

    try {
        dateToClient.write(s.getBytes());//写出去
        dateToClient.flush();
        clientsocket.shutdownOutput();
        //clientsocket.close();
    } catch (IOException e) {
        // TODO: handle exception
    }



}
private void FaileMethod(){

    table.put("Date",new SimpleDateFormat().format(new Date()));
    table.put("Last-Modified", new SimpleDateFormat().format(new Date()));
    table.put("Content-Length", ""+0);//
    String s="HTTP/1.0 404 Not Found\r\n"+MapToString(table)+"\r\n";
    String allmsg="UNknow request!\r\n";
    msgtxt.append("来自("+addressClient[0]+":"+addressClient[1]+")的请求头:\r\n"+allmsg);

    try {
        dateToClient.write(s.getBytes());//写出去
        clientsocket.shutdownOutput();
        //clientsocket.close();
    } catch (IOException e) {
        // TODO: handle exception
    }


}
private String MapToString(Map<String, String> map){

    if(map==null)return "";
    String s=new String();
    for(Map.Entry<String, String> entry:map.entrySet()){
        s+=entry.getKey()+":"+entry.getValue()+"\r\n";

    }

    return s;
}
private boolean canbebreak(queue lqueue,int byteint){
    lqueue.Enqueue(byteint);
    if(lqueue.getnowsize()>=4){
        System.out.println(lqueue.getIndexOf(0)+" "+lqueue.getIndexOf(1)+" "+lqueue.getIndexOf(2)+" "+lqueue.getIndexOf(3)+" ");
            if(lqueue.getIndexOf(0)==13 && lqueue.getIndexOf(1)==10 && lqueue.getIndexOf(2)==13 && lqueue.getIndexOf(3)==10){
                return true;
            }
           else {
            lqueue.dequeue();
            return false;
        }
    }
    return false;
}


class queue {   
     public  int maxsize;
     public int nowsize;
     public node tail;
     public node top;

    public queue(int num){
        nowsize=0;
        maxsize=num;
        tail=top=null;



    }   
    public  boolean Enqueue(int dataitem){
        node newnode=new node(dataitem);
        if(top==null){
            tail=top=newnode;
            nowsize++;
            return true;
        //缓冲队列为空        
        }
        else{
            if(nowsize>=maxsize)return false; //缓冲已满，已有100个
            node oldn=tail;
            tail.setnext(newnode); //放入队未

            tail=newnode;   //重置末尾指针
            tail.setprev(oldn);

            nowsize++; //增一
            return true;
        }
    }
    public node dequeue()   {//
        if(top==null)return null;//空表
        else {
            if(top==tail){ //只有一个
                node n=top; //取出来
                nowsize--; //数量减一
                top=tail=null;
              return n;   //返回
            }
            else { //不止一个
                node n=top;
                top=top.getnext(); 
                top.setprev(null); //把第一个取出来,
                nowsize--; //数量减一
                return n;//返回取出的

            }
            }



    }

    public   boolean isFull(){return nowsize==maxsize;} 
    public   int getnowsize(){return nowsize;}
    public   int getIndexOf(int index){
        if(nowsize>=index+1){
            node n=top;
            for(int i=0;i<index;i++){
                n=n.getnext();
            }
            return n.getdata();
        }
        else {
            return -1;
        }
    }

    }

class node{
         public int dataitem;
         public node next;
         public node prev;
      public node(int data){
        dataitem=data;
        next=null;
        prev=null;

    }   
    public int getdata(){return dataitem;}
    public node getnext() {return next;}
    public void setnext(node n) { next=n;}
    public node getprev() {return prev;}
    public void setprev(node n) { prev=n;}

    }





}

前端代码和测试我就不贴了，可自行删除掉jtextArea，关键部分注释很到位，我在工程根目录下html文件夹放2个html文件，均可以正常访问
具体代码可留邮箱

llf22282776
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
计算机网络实验一 Windows环境下用java实现web服务器
03-20
在Java中，我们可以使用内置的HttpURLConnection或HttpClient类来简化HTTP通信，或者自定义更底层的Socket通信。对于初学者，理解并实现一个简单的HTTP服务器可以帮助深入理解HTTP协议和服务器的工作流程。 在"实验...
java Socket通信实现.rar
05-17
Java Socket通信实现是Java网络编程中的重要组成部分，它允许两个应用程序通过网络进行双向通信。Socket在TCP/IP协议栈中扮演着客户端与服务器端交互的角色，提供了低级别的、面向连接的、可靠的字节流通信。本代码...
Java HTTP服务器 TJWS
06-06
Java平台提供了丰富的API来实现HTTP服务器，如Java.net包中的ServerSocket和Socket类，以及Java EE中的Servlet API。TJWS利用这些API，实现了对HTTP协议的支持，能够解析和处理HTTP请求，生成HTTP响应。 3. **TJWS...
Java Robot对象实现服务器屏幕远程监视.doc
06-09
【Java Robot对象实现服务器屏幕远程监视】 在Java编程中，有时我们需要远程监控服务器的状态，包括其用户界面（GUI）的实时展示。Java SDK提供了一个名为`Robot`的类，允许开发者模拟键盘和鼠标操作，同时也提供了...
HTTP-and-Socket.rar_http socket_java socket http_socket_socket
09-19
3. **编程**：使用Java，可以调用Socket类和ServerSocket类进行Socket编程，实现客户端和服务器端的交互，包括连接建立、数据交换和连接关闭等步骤。 **HTTP与Socket的关系** 1. **层次差异**：HTTP是应用层协议，...
枚举工具类
qq_43049583的博客
08-04 222
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 286
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 617
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
Springboot+Websocket+Security+Vue 实现弹幕推送功能
Gemini1995的博客
08-01 565
【代码】Springboot+Websocket+Security+Vue 实现弹幕推送功能。
JavaSE面向对象进阶
qq_45348840的博客
07-30 531
需求：在实际开发中，经常会遇到一些数组使用的工具类;请按照如下要求编写一个数组的工具类：ArrayUtil提供一个工具类方法printArr,用于返回整数数组的内容。返回的字符串格式如：[10,20,50,34,100 ]（只考虑整数数组，且只考虑一维数组)提供这样一个工具方法getAerage,用于返回平均分。（只考虑浮点型数组，且只考虑一维数组)定义一个测试类TestDemo,调用该工具类的工具方法，并返回结果。// 私有化构造方法// 定义静态方法，方便调用。i++) {
花几千上万学习Java，真没必要！（三十五）
wehpd的博客
07-30 704
集合之Map
26.jdk源码阅读之ConcurrentLinkedQueue
前端、移动端、后端源码级底层原理分享
07-29 1016
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
javaweb_03：在ide中配置tomcat
qq_52200849的博客
08-01 190
④创建artifact。②点击加号创建，选择。
安装ElasticSearch
diffiii
07-31 649
(1).使用WinSCP工具拷贝下载好的安装文件jdk-8u121-linux-x64.gz到建的es文件夹下。(5).修改配置文件elasticsearch-5.2.0/Configs/elasticsearch.yml。plugins—这里存放一些常用的插件，如果有一切额外的插件，可以放在这里使用。(2).切换到elasticsearch根目录，启动elasticsearch。data—这里是ES得当前节点的分片的数据，可以直接拷贝到其他的节点进行使用。1.1.1.6 维护elastic。
java中static关键字的作用
weixin_41020960的博客
08-01 628
这意味着这个变量被类的所有实例共享，而不是每个实例拥有自己的副本。类变量可以通过类名直接访问，而不需要创建类的实例。关键字是 Java 中一个非常重要的特性，它允许开发者在不创建对象的情况下访问类的方法和变量，这在很多场景下非常有用。这类方法可以在没有创建类的实例的情况下被调用，它们只能访问类的静态变量和静态方法。关键字也可以用于静态初始化块，这是一段在类加载时执行的代码块，用于初始化静态变量。: 静态变量是不变的，一旦在静态初始化块或静态方法中被初始化，它们的值就不能被修改。关键字可以声明静态内部类。
面向对象程序设计之sort排序
嫌人闲事
07-31 414
敲过排序算法的都会的，Sort排序与compareTo的改写。
spring原理（第六天）
GD2604279407的博客
08-02 546
今天将会学到Aware 接口及 InitializingBean 接口我们可以先了解他们的作用：1. Aware 接口用于注入一些与容器相关信息, 例如a. BeanNameAware 注入 bean 的名字b. BeanFactoryAware 注入 BeanFactory 容器c. ApplicationContextAware 注入 ApplicationContext 容器2. InitializingBean 接口提供了一种【内置】的初始化手段。
day12 Java基础——自增自减运算符，初识Math类
Qhumaing的博客
07-30 325
int b = a++;//执行完这行代码后，先给b复制，再自增1
高级java每日一道面试题-2024年7月31日-并发篇-你对ThreadLocal了解多少?
qq_43071699的博客
07-31 934
是Java中提供的一个类，用于实现线程局部变量。它允许每个线程访问自己的独立变量副本，而不会影响到其他线程中的变量。为每个使用该变量的线程提供了独立的变量实例，因此，即使是多个线程同时访问同一个变量，它们也是访问自己线程内部的那个副本，从而实现了线程间的数据隔离,干扰和同步开销。
Java Socket实现网络通信与文件传输
"Java语言实现基于消息传递的网络通信，主要使用了Socket技术来构建一个简单的服务器和客户端聊天应用，同时也实现了文件传输功能。通过这个项目，可以深入了解Java Socket的工作机制和原理。" 在Java中，Socket是...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值