两种方法实现一个简单的web服务器

计算机网络报告

实现一个简单的web服务器

实现一个简单的web服务器用Java实现一个简单的web服务器

方法1：

package com.wow.server;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import https://www.360docs.net/doc/ea12355296.html,.InetAddress;

import https://www.360docs.net/doc/ea12355296.html,.ServerSocket;

import https://www.360docs.net/doc/ea12355296.html,.Socket;

import https://www.360docs.net/doc/ea12355296.html,.UnknownHostException;

/**

* 一个简单的web应用服务器

*/

public class HttpServer {

public static final String WEB_ROOT = System.getProperty("user.dir") + File.separator + "webroot";

private static final StringSHUTDOWN_COMMAND = "/SHUTDOWN";

private boolean shutdown = false;

public static void main(String[] args) {

HttpServer server = new HttpServer();

server.start();

}

//启动服务器，并接收用户请求进行处理

public void start() {

ServerSocket serverSocket = null;

int PORT = 8080;

try {

serverSocket=newServerSocket(PORT,1, InetAddress.getByName("127.0.0.1"));

} catch (UnknownHostException e) {

e.printStackTrace();

System.exit(-1);

} catch (IOException e) {

e.printStackTrace();

System.exit(-1);

}

//若请求的命令不为SHUTDOWN时，循环处理请求

while(!shutdown) {

Socket socket = null;

InputStream input = null;

OutputStream output = null;

try {

//创建socket进行请求处理

socket = serverSocket.accept();

input = socket.getInputStream();

output = socket.getOutputStream();

//接收请求

Request request = new Request(input);

request.parser();

//处理请求并返回结果

Response response = new Response(output);

response.setRequest(request);

response.sendStaticResource();

//关闭socket

socket.close();

//若请求命令为关闭，则关闭服务器

shutdown=

request.getUri().equals(SHUTDOWN_COMMAND);

} catch (IOException e) {

e.printStackTrace();

continue;

}

}

}

}

该类本身是一个应用程序，包含main方法，直接通过java命令即可运行。在运行时，它本身会启动一个ServerSocket类用于监听服务器的某个端口。当接收到的命令不是停止服务器的SHUTDOWN时，它会创建一个Socket套接字，用于接收请求及返回响应结果。

Request类则用于请求的接收，对于Http协议来讲，通过浏览器向服务器发送请求有一定的格式，其实Request也就是接收这些请求信息，并对其进行分析，抽取出所需的信息，包括cookie、url等。其中http发送的请求包括三部分：

请求方法统一资源标识符协议/版本

请求头

请求实体

其中请求头与请求实体间有一个空行，具体的示例代码如下所示：

GET /index.htm HTTP/1.1

Host: https://www.360docs.net/doc/ea12355296.html,

Connection: keep-alive

User-Agent: Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.97 Safari/537.11

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Encoding: gzip,deflate,sdch

Accept-Language: zh-CN,zh;q=0.8 Accept-Charset: GBK,utf-8;q=0.7,*;q=0.3

Cookie:

BAIDUID=D275C16E04D9BB2CF55FD9B9654AECAC:FG=1; BDREFER=%7Burl%3A%22http%3A//https://www.360docs.net/doc/ea12355296.html,/%22%2Cword %3A%22%22%7D;BDUSS=FJ2SzJxSmpKMW1sdVIwMWw3TTBwaH hZRkxFaUdoeG9QLW5GS2dLTUtyZzNhWUpSQVFBQUFBJCQAAA AAAAAAAAouTQytzfcOemhhb3poZW5nNzc1OAAAAAAAAAAAA AAAAAAAAAAAAACAYIArMAAAALCmJHAAAAAA6p5DAAAA AAAxMC4zNi4xNDcblV A3G5VQd;

BDUT=5b2fD275C16E04D9BB2CF55FD9B9654AECAC138a495329b 1; MCITY=-%3A; shifen[3113720932]=1357565900; H_PS_PSSID=1445_1661

Request类用于接收socket套接字发送过来的字节流，并按照http协议请求

的格式进行解析。对于简单的web服务器而言，我们只需要解析出它的uri即可，这样即可以通过通过文件匹配的方式找到对应的资源。具体的实现代码如下所示：

package com.wow.server;

import java.io.IOException;

import java.io.InputStream;

/**

*接收到的请求串的具体格式如下：

* GET /aaa.htm HTTP/1.1

* Host: 127.0.0.1:8080

* Connection: keep-alive

* User-Agent: Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.97 Safari/537.11

* Accept: text/html,application/xhtml+xml,application/xml;q=0.9,q=0.8 * Accept-Encoding: gzip,deflate,sdch

* Accept-Language: zh-CN,zh;q=0.8

* Accept-Charset: GBK,utf-8;q=0.7,*;q=0.3

*

*/

public class Request {

private InputStream input;

private String uri;

public Request(InputStream input) {

this.input = input;

}

public void parser() {

StringBuffer request = new StringBuffer();

byte[] buffer = new byte[2048];

int i = 0;

try {

i = input.read(buffer);

} catch (IOException e) {

e.printStackTrace();

i = -1;

}

for(int k = 0; k < i; k++) {

request.append((char)buffer[k]);

}

uri = parserUri(request.toString());

}

private String parserUri(String requestData) { int index1, index2;

index1 = requestData.indexOf(' ');

if(index1 != -1) {

index2 = requestData.indexOf(' ', index1 + 1);

if(index2 > index1) {

return requestData.substring(index1 + 1, index2);

}

}

return null;

}

public String getUri() {

return uri;

}

}

通过上述代码可以看出parser方法用于解析具体请求，它接收socket的字节流，对其进行处理，获取其中的uri信息。

当获取到uri信息后，即可将uri对应到服务器的某个应用或目录中。本文只是实现了一个简单的静态资源服务器，即将uri对应到某个目录下的文件，若文件存在则打开并读取文件信息; 若不存在则直接返回一段错误信息。Response 类即用于处理该逻辑，同时它会将文件流写回至socket套接字中，由socket套接字将响应结果返回给客户端。

对于http协议而言，响应也是有一定的格式要求的，不能发送任意格式的信息，否则浏览器是无法接收并处理的。Http响应结果也包括三部分：

协议状态码描述

响应头

响应实体段

其中响应头与响应实体段间也是有一个空行的，具体的实例如下所示：HTTP/1.1 200 OK

Date: Mon, 07 Jan 2013 14:31:36 GMT

Server: BWS/1.0

Content-Length: 4029

Content-Type: text/html;charset=gbk

Cache-Control: private Expires: Mon, 07 Jan 2013 14:31:36 GMT

Content-Encoding: gzip

Set-Cookie: H_PS_PSSID=1445_1661; path=/; domain=https://www.360docs.net/doc/ea12355296.html, Connection: Keep-Alive

…

Response类中当访问请求的文件不存在时，需要发送一段固定的响应文本给客户端，该段响应文档的格式必须严格按照http响应格式进行组织，否则客户端接收不到。具体的实现源码如下所示：

package com.wow.server;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.io.OutputStream;

/**

* 响应结果

*/

public class Response {

private OutputStream output;

private Request request;

private static final int BUFFER_SIZE = 1024;

public Response(OutputStream output) {

this.output = output;

}

public void setRequest(Request request) {

this.request = request;

}

//发送一个静态资源给客户端，若本地服务器有对应的文件则返回，否则返回404页面

public void sendStaticResource() {

byte[] buffer = new byte[BUFFER_SIZE];

int ch;

FileInputStream fis = null;

try {

File file = new File(HttpServer.WEB_ROOT, request.getUri());

if(file.exists()) {

fis = new FileInputStream(file);

ch = fis.read(buffer);

while(ch != -1) {

output.write(buffer, 0, ch);

ch = fis.read(buffer, 0, BUFFER_SIZE);

}

} else {

String errorMessage = "HTTP/1.1 404 File Not Found \r\n" +

"Content-Type: text/html\r\n" +

"Content-Length: 24\r\n" +

"\r\n" +

"

File Not Found!

";

output.write(errorMessage.getBytes());

}

} catch (Exception e) {

System.out.println(e.toString());

} finally {

if(fis != null) {

try {

fis.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

}

方法2：

import java.io.IOException;

import java.io.OutputStream;

import java.io.PrintWriter;

import https://www.360docs.net/doc/ea12355296.html,.Socket;

public class HTTPThread implements Runnable {

private Socket socket;

private int count;

public HTTPThread(){

}

public HTTPThread(Socket socket, int count){ this.socket = socket;

this.count = count;

}

@Override

public void run() {

// TODO Auto-generated method stub

try {

OutputStream os = socket.getOutputStream();

PrintWriter pw = new PrintWriter(os);

pw.println("");

pw.println("");

pw.println("");

pw.println("This my page! You are welcome!");

pw.println("");

pw.println("");

pw.println("");

pw.flush();

pw.close();

os.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

import java.io.IOException;

import https://www.360docs.net/doc/ea12355296.html,.ServerSocket;

import https://www.360docs.net/doc/ea12355296.html,.Socket;

public class TCPServer {

public static void main(String[] args){

int count = 1;

try {

ServerSocket ss = new ServerSocket(8080);

Socket s = null;

while((s=ss.accept()) != null){

System.out.println("The visitor:" + count);

HTTPThread httpThread = new HTTPThread(s, count);

Thread thread = new Thread(httpThread);

thread.start();

count++;

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

编译运行后，通过浏览器访问http://localhost:8080/就可以了，是不是很神奇呢！用C语言实现一个简单的web编程

#include

#include

#include

#include

#include

#include

#include

#include

#include

#define EOL "\r\n"

#define EOL_SIZE 2

typedef struct {

char *ext;

char *mediatype;

} extn;

//Possible media types

extn extensions[] ={

{"gif", "image/gif" },

{"txt", "text/plain" },

{"jpg", "image/jpg" },

{"jpeg","image/jpeg"},

{"png", "image/png" },

{"ico", "image/ico" },

{"zip", "image/zip" },

{"gz", "image/gz" },

{"tar", "image/tar" },

{"htm", "text/html" },

{"html","text/html" },

{"php", "text/html" },

{"pdf","application/pdf"},

{"zip","application/octet-stream"},

{"rar","application/octet-stream"},

{0,0} };

/*

A helper function

*/

void error(const char *msg) {

perror(msg);

exit(1);

}

/*

A helper function

*/

int get_file_size(int fd) {

struct stat stat_struct;

if (fstat(fd, &stat_struct) == -1)

return (1);

return (int) stat_struct.st_size;

}

/*

A helper function

*/

void send_new(int fd, char *msg) {

int len = strlen(msg);

if (send(fd, msg, len, 0) == -1) {

printf("Error in send\n");

}

}

/*

This function recieves the buffer

until an "End of line(EOL)" byte is recieved

*/

int recv_new(int fd, char *buffer) {

char *p = buffer; // Use of a pointer to the buffer rather than dealing with the buffer directly

int eol_matched = 0; // Use to check whether the recieved byte is matched with the buffer byte or not

while (recv(fd, p, 1, 0) != 0) // Start receiving 1 byte at a time

{

if (*p == EOL[eol_matched]) // if the byte matches with the first eol byte that is '\r'

{

++eol_matched;

if (eol_matched == EOL_SIZE) // if both the bytes matches with the EOL

{

*(p + 1 - EOL_SIZE) = '\0'; // End the string

return (strlen(buffer)); // Return the bytes recieved

}

} else {

eol_matched = 0;

}

p++; // Increment the pointer to receive next byte

}

return (0);

}

/*

A helper function: Returns the

web root location.

*/

char* webroot() {

// open the file "conf" for reading

FILE *in = fopen("conf", "rt");

// read the first line from the file

char buff[1000];

fgets(buff, 1000, in);

// close the stream

fclose(in);

char* nl_ptr = strrchr(buff, '\n');

if (nl_ptr != NULL)

*nl_ptr = '\0';

return strdup(buff);

}

/*

Handles php requests

*/

void php_cgi(char* script_path, int fd) {

send_new(fd, "HTTP/1.1 200 OK\n Server: Web Server in C\n Connection: close\n"); dup2(fd, STDOUT_FILENO);

char script[500];

strcpy(script, "SCRIPT_FILENAME=");

strcat(script, script_path);

putenv("GATEW AY_INTERFACE=CGI/1.1");

putenv(script);

putenv("QUERY_STRING=");

putenv("REQUEST_METHOD=GET");

putenv("REDIRECT_STA TUS=true");

putenv("SERVER_PROTOCOL=HTTP/1.1");

putenv("REMOTE_HOST=127.0.0.1");

execl("/usr/bin/php-cgi", "php-cgi", NULL); }

/*

This function parses the HTTP requests, arrange resource locations,

check for supported media types,

serves files in a web root,

sends the HTTP error codes.

*/

int connection(int fd) {

char request[500], resource[500], *ptr;

int fd1, length;

if (recv_new(fd, request) == 0) {

printf("Recieve Failed\n");

}

printf("%s\n", request);

// Check for a valid browser request

ptr = strstr(request, " HTTP/");

if (ptr == NULL) {

printf("NOT HTTP !\n");

} else {

*ptr = 0;

ptr = NULL;

if (strncmp(request, "GET ", 4) == 0) {

ptr = request + 4;

}

if (ptr == NULL) {

printf("Unknown Request ! \n");

} else {

if (ptr[strlen(ptr) - 1] == '/') {

strcat(ptr, "index.html");

}

strcpy(resource, webroot());

strcat(resource, ptr);

char* s = strchr(ptr, '.');

int i;

for (i = 0; extensions[i].ext != NULL; i++) {

if (strcmp(s + 1, extensions[i].ext) == 0) {

fd1 = open(resource, O_RDONL Y, 0);

printf("Opening \"%s\"\n", resource);

if (fd1 == -1) {

printf("404 File not found Error\n");

send_new(fd, "HTTP/1.1 404 Not Found\r\n");

send_new(fd, "Server : Web Server in C\r\n\r\n");

send_new(fd, "");

send_new(fd, "

404 Not Found: The requested resource could not be found!

");

//Handling php requests

} else if (strcmp(extensions[i].ext, "php") == 0) {

php_cgi(resource, fd);

sleep(1);

close(fd);

exit(1);

} else {

printf("200 OK, Content-Type: %s\n\n",

extensions[i].mediatype);

send_new(fd, "HTTP/1.1 200 OK\r\n");

send_new(fd, "Server : Web Server in C\r\n\r\n");

if (ptr == request + 4) // if it is a GET request

{

if ((length = get_file_size(fd1)) == -1)

printf("Error in getting size !\n");

size_t total_bytes_sent = 0;

ssize_t bytes_sent;

while (total_bytes_sent < length) {

//Zero copy optimization

if ((bytes_sent = sendfile(fd, fd1, 0,

length - total_bytes_sent)) <= 0) {

if (errno == EINTR || errno == EAGAIN) {

continue;

}

perror("sendfile");

return -1;

}

total_bytes_sent += bytes_sent;

}

}

}

break;

}

int size = sizeof(extensions) / sizeof(extensions[0]);

if (i == size - 2) {

printf("415 Unsupported Media Type\n");

send_new(fd, "HTTP/1.1 415 Unsupported Media Type\r\n");

send_new(fd, "Server : Web Server in C\r\n\r\n");

send_new(fd, "");

send_new(fd, "

415 Unsupported Media Type!

");

}

}

close(fd);

}

}

shutdown(fd, SHUT_RDWR);

}

int main(int argc, char *argv[]) {

int sockfd, newsockfd, portno, pid;

socklen_t clilen;

struct sockaddr_in serv_addr, cli_addr;

if (argc < 2) {

fprintf(stderr, "ERROR, no port provided\n");

exit(1);

}

sockfd = socket(AF_INET, SOCK_STREAM, 0);

if (sockfd < 0)

error("ERROR opening socket");

bzero((char *) &serv_addr, sizeof(serv_addr));

portno = atoi(argv[1]);

serv_addr.sin_family = AF_INET;

serv_addr.sin_addr.s_addr = INADDR_ANY;

serv_addr.sin_port = htons(portno);

if (bind(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0)

error("ERROR on binding");

listen(sockfd, 5);

clilen = sizeof(cli_addr);

/*

Server runs forever, forking off a separate

process for each connection.

*/

while (1) {

newsockfd = accept(sockfd, (struct sockaddr *) &cli_addr, &clilen);

if (newsockfd < 0)

error("ERROR on accept");

pid = fork();

if (pid < 0)

error("ERROR on fork");

if (pid == 0) {

close(sockfd);

connection(newsockfd);

exit(0);

} else

close(newsockfd);

} /* end of while */

close(sockfd);

return 0; /* we never get here */ }