用ServerSocket接收Http请求

Question

我想用ServerSocket监听一个端口，然后通过在浏览器中输入http://localhost:port/的方式访问这个server。有没有谁遇到过这样的问题？

Answer 1

怎么可能，你开着web服务，端口已经占用了，socket还怎么监听

Answer 2

用浏览器访问肯定是可以,但你的ServerSocket会处理HTTP协议吗?

Answer 3

用浏览器根本就访问不到ServerSocket，如果是再web服务器中，可以开另外的端口嘛，比如8081，8082。

Answer 4

注意，这个serversocket不在web容器中……，请问大家有什么实现思路没有？

Answer 5

理解错了，我以为你是要通过socket监听http请求。要是只做服务的话，没有问题，像tomcat就是用socket实现的，简单的，就是监听一个端口，当浏览器访问的时候，就向这个端口发送一个http协议，服务器解析后，返回给浏览器。这有个最简单的小例子，分server，request，response  3个类，
server就是起socket监听，
request解析接收的inputstream
response响应。
推荐一本好书 how tomcat works
楼下代码：

Answer 6

import java.net.Socket;
import java.net.ServerSocket;
import java.net.InetAddress;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.IOException;
import java.io.File;public class HttpServer
{
/**
 * WEB_ROOT is the directory where our HTML and other files reside. For
 * this package, WEB_ROOT is the "webroot" directory under the working
 * directory. The working directory is the location in the file system
 * from where the java command was invoked.
 */
public static final String WEB_ROOT = System.getProperty("user.dir")+File.separator+"webroot";
// shutdown command
private static final String SHUTDOWN_COMMAND = "/SHUTDOWN";
// the shutdown command received
private boolean shutdown = false; public static void main(String[] args)
{
HttpServer server = new HttpServer();
server.await();
} public void await()
{
ServerSocket serverSocket = null;
int port = 8080;
try
{
serverSocket = new ServerSocket(port, 1, InetAddress.getByName("127.0.0.1"));
}
catch (IOException e)
{
e.printStackTrace();
System.exit(1);
}
// Loop waiting for a request
while (!shutdown)
{
Socket socket = null;
InputStream input = null;
OutputStream output = null;
try
{
socket = serverSocket.accept();
input = socket.getInputStream();
output = socket.getOutputStream();
// create Request object and parse
Request request = new Request(input);
request.parse();
// create Response object
Response response = new Response(output);
response.setRequest(request);
response.sendStaticResource();
// Close the socket
socket.close();
// check if the previous URI is a shutdown
// command
shutdown = request.getUri().equals(SHUTDOWN_COMMAND);
}
catch (Exception e)
{
e.printStackTrace();
continue;
}
}
}
}import java.io.InputStream;
import java.io.IOException;public class Request {  private InputStream input;
  private String uri;  public Request(InputStream input) {
    this.input = input;
  }  public void parse() {
    // Read a set of characters from the socket
    StringBuffer request = new StringBuffer(2048);
    int i;
    byte[] buffer = new byte[2048];
    try {
      i = input.read(buffer);
    }
    catch (IOException e) {
      e.printStackTrace();
      i = -1;
    }
    for (int j=0; j<i; j++) {
      request.append((char) buffer[j]);
    }
    System.out.print(request.toString());
    uri = parseUri(request.toString());
  }  private String parseUri(String requestString) {
    int index1, index2;
    index1 = requestString.indexOf(' ');
    if (index1 != -1) {
      index2 = requestString.indexOf(' ', index1 + 1);
      if (index2 > index1)
        return requestString.substring(index1 + 1, index2);
    }
    return null;
  }  public String getUri() {
    return uri;
  }}
import java.io.OutputStream;
import java.io.IOException;
import java.io.FileInputStream;
import java.io.File;/*
  HTTP Response = Status-Line
    *(( general-header | response-header | entity-header ) CRLF)
    CRLF
    [ message-body ]
    Status-Line = HTTP-Version SP Status-Code SP Reason-Phrase CRLF
*/public class Response {  private static final int BUFFER_SIZE = 1024;
  Request request;
  OutputStream output;  public Response(OutputStream output) {
    this.output = output;
  }  public void setRequest(Request request) {
    this.request = request;
  }  public void sendStaticResource() throws IOException {
    byte[] bytes = new byte[BUFFER_SIZE];
    FileInputStream fis = null;
    try {
      File file = new File(HttpServer.WEB_ROOT, request.getUri());
      if (file.exists()) {
        fis = new FileInputStream(file);
        int ch = fis.read(bytes, 0, BUFFER_SIZE);
        while (ch!=-1) {
          output.write(bytes, 0, ch);
          ch = fis.read(bytes, 0, BUFFER_SIZE);
        }
      }
      else {
        // file not found
        String errorMessage = "HTTP/1.1 404 File Not Found\r\n" +
          "Content-Type: text/html\r\n" +
          "Content-Length: 23\r\n" +
          "\r\n" +
          "<h1>File Not Found</h1>";
        output.write(errorMessage.getBytes());
      }
    }
    catch (Exception e) {
      // thrown if cannot instantiate a File object
      System.out.println(e.toString() );
    }
    finally {
      if (fis!=null)
        fis.close();
    }
  }
}

Answer 7

相当于一个迷你的服务器。
工程下建一个webroot的文件夹，里面放几html页就可以直接访问
如:
http://127.0.0.1:8080/index.html

Answer 8

忽悠人用的。
package org.sl.test;import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;/**
 * 忽悠人的http 服务器
 * @author shanl
 *
 */
public class HttpServer {
static public void start(){
StringBuilder echo = new StringBuilder();
echo.append("<html>");
echo.append("<head>");
echo.append("<title>hello</title>");
echo.append("</head>");
echo.append("<body>");
echo.append("<center>");
echo.append("<b1>Welcome to my home page.</b1>");
echo.append("</center>");
echo.append("</body>");
echo.append("</html>");

ServerSocket ss = null;
int port = 8010;
SocketAddress address = null;
Socket connect = null;
byte[] buffer = new byte[512];
int readLen = 0;

try{
System.out.println("开始监听:" + port);
address = new InetSocketAddress("192.168.2.23", port);
ss = new ServerSocket();
ss.bind(address);

while(true){
connect = ss.accept();

do{
readLen = connect.getInputStream().read(buffer);
System.out.println(new String(buffer));
}while(readLen == 512);

connect.getOutputStream().write(echo.toString().getBytes());
connect.close();
}
}catch(Exception ex){
ex.printStackTrace();
}
}

public static void main(String[] args){
start();
}
}