其实j*a实现服务器的问题并不复杂，但是又很多的朋友都不太了解如何用J*a实现Web服务器，因此呢，今天小编就来为大家分享j*a实现服务器的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！
一、如何用j*a实现HTTP长连接
可以通过轮询来实现长连接
轮询：隔一段时间访问服务器，服务器不管有没有新消息都立刻返回。
长连接实现代码：
客户端：
package houlei.csdn.keepalive;
import j*a.io.IOException;
import j*a.io.InputStream;
import j*a.io.ObjectInputStream;
import j*a.io.ObjectOutputStream;
import j*a..Socket;
import j*a..UnknownHostException;
import j*a.util.concurrent.ConcurrentHashMap;
/**
* C/S架构的客户端对象，持有该对象，可以随时向服务端发送消息。
*<p>
*创建时间：2010-7-18上午12:17:25
*@author HouLei
*@since 1.0
*/
public class Client{
/**
*处理服务端发回的对象，可实现该接口。
*/
public static interface ObjectAction{
void doAction(Object obj,Client client);
}
public static final class DefaultObjectAction implements ObjectAction{
public void doAction(Object obj,Client client){
System.out.println("处理：\t"+obj.toString());//诊断程序是否正常
}
}
public static void main(String[] args) throws UnknownHostException, IOException{
String serverIp="127.0.0.1";
int port= 65432;
Client client= new Client(serverIp,port);
client.start();
}
private String serverIp;
private int port;
private Socket socket;
private boolean running=false;
private long lastSendTime;
private ConcurrentHashMap<Class, ObjectAction> actionMing= new ConcurrentHashMap<Class,ObjectAction>();
public Client(String serverIp, int port){
this.serverIp=serverIp;this.port=port;
}
public void start() throws UnknownHostException, IOException{
if(running)return;
socket= new Socket(serverIp,port);
System.out.println("本地端口："+socket.getLocalPort());
lastSendTime=System.currentTimeMillis();
running=true;
new Thread(new KeepAliveWatchDog()).start();
new Thread(new ReceiveWatchDog()).start();
}
public void stop(){
if(running)running=false;
}
/**
*添加接收对象的处理对象。
*@param cls待处理的对象，其所属的类。
*@param action处理过程对象。
*/
public void addActionMap(Class<Object> cls,ObjectAction action){
actionMing.put(cls, action);
}
public void sendObject(Object obj) throws IOException{
ObjectOutputStream oos= new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(obj);
System.out.println("发送：\t"+obj);
oos.flush();
}
class KeepAliveWatchDog implements Runnable{
long checkDelay= 10;
long keepAliveDelay= 2000;
public void run(){
while(running){
if(System.currentTimeMillis()-lastSendTime>keepAliveDelay){
try{
Client.this.sendObject(new KeepAlive());
} catch(IOException e){
e.printStackTrace();
Client.this.stop();
}
lastSendTime= System.currentTimeMillis();
}else{
try{
Thread.sleep(checkDelay);
} catch(InterruptedException e){
e.printStackTrace();
Client.this.stop();
}
}
}
}
}
class ReceiveWatchDog implements Runnable{
public void run(){
while(running){
try{
InputStream in= socket.getInputStream();
if(in.*ailable()>0){
ObjectInputStream ois= new ObjectInputStream(in);
Object obj= ois.readObject();
System.out.println("接收：\t"+obj);//接受数据
ObjectAction oa= actionMing.get(obj.getClass());
oa= oa==null?new DefaultObjectAction():oa;
oa.doAction(obj, Client.this);
}else{
Thread.sleep(10);
}
} catch(Exception e){
e.printStackTrace();
Client.this.stop();
}
}
}
}
}
服务端：
package houlei.csdn.keepalive;
import j*a.io.IOException;
import j*a.io.InputStream;
import j*a.io.ObjectInputStream;
import j*a.io.ObjectOutputStream;
import j*a..ServerSocket;
import j*a..Socket;
import j*a.util.concurrent.ConcurrentHashMap;
/**
* C/S架构的服务端对象。
*<p>
*创建时间：2010-7-18上午12:17:37
*@author HouLei
*@since 1.0
*/
public class Server{
/**
*要处理客户端发来的对象，并返回一个对象，可实现该接口。
*/
public interface ObjectAction{
Object doAction(Object rev);
}
public static final class DefaultObjectAction implements ObjectAction{
public Object doAction(Object rev){
System.out.println("处理并返回："+rev);//确认长连接状况
return rev;
}
}
public static void main(String[] args){
int port= 65432;
Server server= new Server(port);
server.start();
}
private int port;
private volatile boolean running=false;
private long receiveTimeDelay=3000;
private ConcurrentHashMap<Class, ObjectAction> actionMing= new ConcurrentHashMap<Class,ObjectAction>();
private Thread connWatchDog;
public Server(int port){
this.port= port;
}
public void start(){
if(running)return;
running=true;
connWatchDog= new Thread(new ConnWatchDog());
connWatchDog.start();
}
@SuppressWarnings("deprecation")
public void stop(){
if(running)running=false;
if(connWatchDog!=null)connWatchDog.stop();
}
public void addActionMap(Class<Object> cls,ObjectAction action){
actionMing.put(cls, action);
}
class ConnWatchDog implements Runnable{
public void run(){
try{
ServerSocket ss= new ServerSocket(port,5);
while(running){
Socket s= ss.aept();
new Thread(new SocketAction(s)).start();
}
} catch(IOException e){
e.printStackTrace();
Server.this.stop();
}
}
}
class SocketAction implements Runnable{
Socket s;
boolean run=true;
long lastReceiveTime= System.currentTimeMillis();
public SocketAction(Socket s){
this.s= s;
}
public void run(){
while(running&& run){
if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){
overThis();
}else{
try{
InputStream in= s.getInputStream();
if(in.*ailable()>0){
ObjectInputStream ois= new ObjectInputStream(in);
Object obj= ois.readObject();
lastReceiveTime= System.currentTimeMillis();
System.out.println("接收：\t"+obj);
ObjectAction oa= actionMing.get(obj.getClass());
oa= oa==null?new DefaultObjectAction():oa;
Object out= oa.doAction(obj);
if(out!=null){
ObjectOutputStream oos= new ObjectOutputStream(s.getOutputStream());
oos.writeObject(out);
oos.flush();
}
}else{
Thread.sleep(10);
}
} catch(Exception e){
e.printStackTrace();
overThis();
}
}
}
}
private void overThis(){
if(run)run=false;
if(s!=null){
try{
s.close();
} catch(IOException e){
e.printStackTrace();
}
}
System.out.println("关闭："+s.getRemoteSocketAddress());//关闭长连接
}
}
}
长连接的维持，是要客户端程序，定时向服务端程序，发送一个维持连接包的。
如果，长时间未发送维持连接包，服务端程序将断开连接。
二、如何用J*A实现一个代理服务器
代理服务器的应用非常广泛。比如，在企业网内部，它可以用来控制员工在工作时浏览的Inter内容，阻止员工访问某些类型的内容或某些指定的网站。代理服务器实际上扮演着浏览器和Web服务器之间的中间人的角色，能够对浏览器请求进行各种各样的处理，能够过滤广告和Cookie，能够预先提取Web页面，使得浏览器访问页面的速度更快，等等。
一、基础知识
不管以哪种方式应用代理服务器，其监控HTTP传输的过程总是如下：
步骤一：内部的浏览器发送请求给代理服务器。请求的第一行包含了目标URL。
步骤二：代理服务器读取该URL，并把请求转发给合适的目标服务器。
步骤三：代理服务器接收来自Inter目标机器的应答，把应答转发给合适的内部浏览器。
例如，假设有一个企业的雇员试图访问网站。如果没有代理服务器，雇员的浏览器打开的Socket通向运行这个网站的Web服务器，从Web服务器返回的数据也传递给雇员的浏览器。如果浏览器被配置成使用代理服务器，则请求首先到达代理服务器；随后，代理服务器从请求的第一行提取目标URL，打开一个通向的Socket。当返回应答时，代理服务器把应答转发给雇员的浏览器。
当然，代理服务器并非只适用于企业环境。作为一个开发者，拥有一个自己的代理服务器是一件很不错的事情。例如，我们可以用代理服务器来分析浏览器和Web服务器的交互过程。测试和解决Web应用中存在的问题时，这种功能是很有用的。我们甚至还可以同时使用多个代理服务器（大多数代理服务器允许多个服务器在一起使用）。例如，我们可以有一个企业的代理服务器，再加上一个用j*a编写的代理服务器，用来调试应用程序。但应该注意的是，代理服务器链上的每一个服务器都会对*能产生一定的影响。
二、设计规划
正如其名字所示，代理服务器只不过是一种特殊的服务器。和大多数服务器一样，如果要处理多个请求，代理服务器应该使用线程。下面是一个代理服务器的基本规划：
等待来自客户（Web浏览器）的请求。
启动一个新的线程，以处理客户连接请求。
读取浏览器请求的第一行（该行内容包含了请求的目标URL）。
分析请求的第一行内容，得到目标服务器的名字和端口。
打开一个通向目标服务器（或下一个代理服务器，如合适的话）的Socket。
把请求的第一行发送到输出Socket。
把请求的剩余部分发送到输出Socket。
把目标Web服务器返回的数据发送给发出请求的浏览器。
当然，如果考虑细节的话，情况会更复杂一些。实际上，这里主要有两个问题要考虑：第一，从Socket按行读取数据最适合进一步处理，但这会产生*能瓶颈；第二，两个Socket之间的连接必需高效。有几种方法可以实现这两个目标，但每一种方法都有各自的代价。例如，如果要在数据进入的时候进行过滤，这些数据最好按行读取；然而，大多数时候，当数据到达代理服务器时，立即把它转发出去更适合高效这一要求。另外，数据的发送和接收也可以使用多个独立的线程，但大量地创建和拆除线程也会带来*能问题。因此，对于每一个请求，我们将用一个线程处理数据的接收和发送，同时在数据到达代理服务器时，尽可能快速地把它转发出去。
三、实例
在用j*a编写这个代理服务器的过程中，注意可重用*是很重要的。因为这样的话，当我们想要在另一个工程中以不同的方式处理浏览器请求时，可以方便地重用该代理服务器。当然，我们必须注意灵活*和效率之间的平衡。
图一显示了本文代理服务器实例（HttpProxy.j*a）的输出界面，当浏览器访问时，代理服务器向默认日志设备（即标准输出设备屏幕）输出浏览器请求的URL。图二显示了SubHttpProxy的输出。SubHttpProxy是HttpProxy的一个简单扩展。
图一
图二
为了构造代理服务器，我从Thread基类派生出了HttpProxy类（文章正文中出现的代码是该类的一些片断，完整的代码请从本文最后）。HttpProxy类包含了一些用来定制代理服务器行为的属*，参见Listing 1和表一。
【Listing 1】
/*************************************
*一个基础的代理服务器类
*************************************
*/
import j*a..*;
import j*a.io.*;
public class HttpProxy extends Thread{
static public int CONNECT_RETRIES=5;
static public int CONNECT_PAUSE=5;
static public int TIME-OUT=50;
static public int BUFSIZ=1024;
static public boolean logging= false;
static public OutputStream log=null;
//传入数据用的Socket
protected Socket socket;
//上级代理服务器，可选
static private String parent=null;
static private int parentPort=-1;
static public void setParentProxy(String name, int pport){
parent=name;
parentPort=pport;
}
//在给定Socket上创建一个代理线程。
public HttpProxy(Socket s){ socket=s; start();}
public void writeLog(int c, boolean browser) throws IOException{
log.write(c);
}
public void writeLog(byte[] bytes,int offset,
int len, boolean browser) throws IOException{
for(int i=0;i<len;i++) writeLog((int)bytes[offset+i],browser);
}
//默认情况下，日志信息输出到
//标准输出设备，
//派生类可以覆盖它
public String processHostName(String url, String host, int port, Socket sock){
j*a.text.DateFormat cal=j*a.text.DateFormat.getDateTimeInstance();
System.out.println(cal.format(new j*a.util.Date())+"-"+
url+""+ sock.getIAddress()+"<BR>");
return host;
}
表一
变量/方法说明
CONNECT_RETRIES在放弃之前尝试连接远程主机的次数。
CONNECT_PAUSE在两次连接尝试之间的暂停时间。
TIME-OUT等待Socket输入的等待时间。
BUFSIZ Socket输入的缓冲大小。
logging是否要求代理服务器在日志中记录所有已传输的数据（true表示“是”）。
log一个OutputStream对象，默认日志例程将向该OutputStream对象输出日志信息。
setParentProxy用来把一个代理服务器到另一个代理服务器（需要指定另一个服务器的名称和端口）。
当代理服务器连接到Web服务器之后，我用一个简单的循环在两个Socket之间传递数据。这里可能出现一个问题，即如果没有可操作的数据，调用read方法可能导致程序阻塞，从而挂起程序。为防止出现这个问题，我用setSoTimeout方法设置了Socket的超时时间（参见Listing 2）。这样，如果某个Socket不可用，另一个仍旧有机会进行处理，我不必创建一个新的线程。
【Listing 2】
//执行操作的线程
public void run(){
String line;
String host;
int port=80;
Socket outbound=null;
try{
socket.setSoTimeout(TIMEOUT);
InputStream is=socket.getInputStream();
OutputStream os=null;
try{
//获取请求行的内容
line="";
host="";
int state=0;
boolean space;
while(true){
int c=is.read();
if(c==-1) break;
if(logging) writeLog(c,true);
space=Character.isWhitespace((char)c);
switch(state){
case 0:
if(space) continue;
state=1;
case 1:
if(space){
state=2;
continue;
}
line=line+(char)c;
break;
case 2:
if(space) continue;//跳过多个空白字符
state=3;
case 3:
if(space){
state=4;
//只分析主机名称部分
String host0=host;
int n;
n=host.indexOf("//");
if(n!=-1) host=host.substring(n+2);
n=host.indexOf('/');
if(n!=-1) host=host.substring(0,n);
//分析可能存在的端口号
n=host.indexOf(":");
if(n!=-1){
port=Integer.parseInt(host.substring(n+1));
host=host.substring(0,n);
}
host=processHostName(host0,host,port,socket);
if(parent!=null){
host=parent;
port=parentPort;
}
int retry=CONNECT_RETRIES;
while(retry--!=0){
try{
outbound=new Socket(host,port);
break;
} catch(Exception e){}
//等待
Thread.sleep(CONNECT_PAUSE);
}
if(outbound==null) break;
outbound.setSoTimeout(TIMEOUT);
os=outbound.getOutputStream();
os.write(line.getBytes());
os.write('');
os.write(host0.getBytes());
os.write('');
pipe(is,outbound.getInputStream(),os,socket.getOutputStream());
break;
}
host=host+(char)c;
break;
}
}
}
catch(IOException e){}
} catch(Exception e){}
finally{
try{ socket.close();} catch(Exception e1){}
try{ outbound.close();} catch(Exception e2){}
}
}
和所有线程对象一样，HttpProxy类的主要工作在run方法内完成（见Listing 2）。run方法实现了一个简单的状态机，从Web浏览器每次一个读取字符，持续这个过程直至有足够的信息找出目标Web服务器。然后，run打开一个通向该Web服务器的Socket（如果有多个代理服务器被在一起，则run方法打开一个通向链里面下一个代理服务器的Socket）。打开Socket之后，run先把部分的请求写入Socket，然后调用pipe方法。pipe方法在两个Socket之间以最快的速度执行读写操作。
如果数据规模很大，另外创建一个线程可能具有更高的效率；然而，当数据规模较小时，创建新线程所需要的开销会抵消它带来的好处。
Listing 3显示了一个很简单的main方法，可以用来测试HttpProxy类。大部分的工作由一个静态的startProxy方法完成（见Listing 4）。这个方法用到了一种特殊的技术，允许一个静态成员创建HttpProxy类（或HttpProxy类的子类）的实例。它的基本思想是：把一个Class对象传递给startProxy类；然后，startProxy方法利用映像API（Reflection API）和getDeclaredConstructor方法确定该Class对象的哪一个构造函数接受一个Socket参数；最后，startProxy方法调用newInstance方法创建该Class对象。
【Listing 3】
//测试用的简单main方法
static public void main(String args[]){
System.out.println("在端口808启动代理服务器\n");
HttpProxy.log=System.out;
HttpProxy.logging=false;
HttpProxy.startProxy(808,HttpProxy.class);
}
}
【Listing 4】
static public void startProxy(int port,Class clobj){
ServerSocket ssock;
Socket sock;
try{
ssock=new ServerSocket(port);
while(true){
Class [] sarg= new Class[1];
Object [] arg= new Object[1];
sarg[0]=Socket.class;
try{
j*a.lang.reflect.Constructor cons= clobj.getDeclaredConstructor(sarg);
arg[0]=ssock.aept();
cons.newInstance(arg);//创建HttpProxy或其派生类的实例
} catch(Exception e){
Socket esock=(Socket)arg[0];
try{ esock.close();} catch(Exception ec){}
}
}
} catch(IOException e){
}
}
利用这种技术，我们可以在不创建startProxy方法定制版本的情况下，扩展HttpProxy类。要得到给定类的Class对象，只需在正常的名字后面加上.class（如果有某个对象的一个实例，则代之以调用getClass方法）。由于我们把Class对象传递给了startProxy方法，所以创建HttpProxy的派生类时，就不必再特意去修改startProxy。（代码中包含了一个派生得到的简单代理服务器）。
结束语
利用派生类定制或调整代理服务器的行为有两种途径：修改主机的名字，或者捕获所有通过代理服务器的数据。processHostName方法允许代理服务器分析和修改主机名字。如果启用了日志记录，代理服务器为每一个通过服务器的字符调用writeLog方法。如何处理这些信息完全由我们自己决定——可以把它写入日志文件，可以把它输出到控制台，或进行任何其他满足我们要求的处理。writeLog输出中的一个Boolean标记指示出数据是来自浏览器还是Web主机。
和许多工具一样，代理服务器本身并不存在好或者坏的问题，关键在于如何使用它们。代理服务器可能被用于侵犯隐私，但也可以阻隔*者和保护网络。即使代理服务器和浏览器不在同一台机器上，我也乐意把代理服务器看成是一种扩展浏览器功能的途径。例如，在把数据发送给浏览器之前，可以用代理服务器压缩数据；未来的代理服务器甚至还可能把页面从一种语言翻译成另一种语言……可能*永无止境。
三、如何用J*a实现Web服务器
如何用J*a实现Web服务器一、HTTP协议的作用原理
WWW是以Inter作为传输媒介的一个应用系统，WWW网上最基本的传输单位是Web网页。WWW的工作基于客户机/服务器计算模型，由Web浏览器（客户机）和Web服务器（服务器）构成，两者之间采用超文本传送协议（HTTP）进行通信。HTTP协议是基于TCP/IP协议之上的协议，是Web浏览器和Web服务器之间的应用层协议，是通用的、无状态的、面向对象的协议。HTTP协议的作用原理包括四个步骤：
（1）连接：Web浏览器与Web服务器建立连接，打开一个称为socket（套接字）的虚拟文件，此文件的建立标志着连接建立成功。
（2）请求：Web浏览器通过socket向Web服务器提交请求。HTTP的请求一般是GET或POST命令（POST用于FORM参数的传递）。GET命令的格式为：
GET路径/文件名 HTTP/1.0
文件名指出所访问的文件，HTTP/1.0指出Web浏览器使用的HTTP版本。
（3）应答：Web浏览器提交请求后，通过HTTP协议传送给Web服务器。Web服务器接到后，进行事务处理，处理结果又通过HTTP传回给Web浏览器，从而在Web浏览器上显示出所请求的页面。
例：假设客户机与建立了连接，就会发送GET命令：GET/mydir/index.html HTTP/1.0.主机名为的Web服务器从它的文档空间中搜索子目录mydir的文件index.html.如果找到该文件，Web服务器把该文件内容传送给相应的Web浏览器。
为了告知 Web浏览器传送内容的类型，Web服务器首先传送一些HTTP头信息，然后传送具体内容（即HTTP体信息），HTTP头信息和HTTP体信息之间用一个空行分开。
常用的HTTP头信息有：
① HTTP 1.0 200 OK
这是Web服务器应答的第一行，列出服务器正在运行的HTTP版本号和应答代码。代码“200 OK”表示请求完成。
② MIME_Version：1.0
它指示MIME类型的版本。
③ content_type：类型
这个头信息非常重要，它指示HTTP体信息的MIME类型。如：content_type：text/html指示传送的数据是HTML文档。
④ content_length：长度值
它指示HTTP体信息的长度（字节）。
（4）关闭连接：当应答结束后，Web浏览器与Web服务器必须断开，以保证其它Web浏览器能够与Web服务器建立连接。
二、J*a实现Web服务器功能的程序设计
根据上述HTTP协议的作用原理，实现GET请求的Web服务器程序的方法如下：
（1）创建ServerSocket类对象，监听端口8080.这是为了区别于HTTP的标准TCP/IP端口80而取的；
（2）等待、接受客户机连接到端口8080，得到与客户机连接的socket；
（3）创建与socket字相关联的输入流instream和输出流outstream；
（4）从与socket关联的输入流instream中读取一行客户机提交的请求信息，请求信息的格式为：GET路径/文件名 HTTP/1.0
（5）从请求信息中获取请求类型。如果请求类型是GET，则从请求信息中获取所访问的HTML文件名。没有HTML文件名时，则以index.html作为文件名；
（6）如果HTML文件存在，则打开HTML文件，把HTTP头信息和HTML文件内容通过socket传回给Web浏览器，然后关闭文件。否则发送错误信息给Web浏览器；
（7）关闭与相应Web浏览器连接的socket字。
下面的程序是根据上述方法编写的、可实现多线程的Web服务器，以保证多个客户机能同时与该Web服务器连接。
程序1：WebServer.j*a文件
//WebServer.j*a用J*A编写Web服务器
import j*a.io.*；
import j*a..*；
public class WebServer{
public static void main（String args[]）{
int i=1， PORT=8080；
ServerSocket server=null；
Socket client=null；
try{
server=new ServerSocket（PORT）；
System.out.println（"Web Server is listening on port"+server.getLocalPort（））；
for（；；）{client=server.aept（）；//接受客户机的连接请求
new ConnectionThread（client，i）。start（）；
i++；
}
} catch（Exception e）{System.out.println（e）；}
}
}
/* ConnnectionThread类完成与一个Web浏览器的通信*/
class ConnectionThread extends Thread{
Socket client；//连接Web浏览器的socket字
int counter；//计数器
public ConnectionThread（Socket cl，int c）{
client=cl；
counter=c；
}
public void run（）//线程体
{try{
String destIP=client.getIAddress（）。toString（）；//客户机IP
int destport=client.getPort（）；//客户机端口号
System.out.println（"Connection"+counter+"：connected to"+destIP+" on port"+destport+"."）；
PrintStream outstream=new PrintStream（client.getOutputStream（））；
DataInputStream instream=new DataInputStream（client.getInputStream（））；
String inline=instream.readLine（）；//读取Web浏览器提交的请求信息
System.out.println（"Received："+inline）；
if（getrequest（inline））{//如果是GET请求
String filename=getfilename（inline）；
File file=new File（filename）；
if（file.exists（））{//若文件存在，则将文件送给Web浏览器
System.out.println（filename+" requested."）；
outstream.println（"HTTP/1.0 200 OK"）；
outstream.println（"MIME_version：1.0"）；
outstream.println（"Content_Type：text/html"）；
int len=（int）file.length（）；
outstream.println（"Content_Length："+len）；
outstream.println（""）；
sendfile（outstream，file）；//发送文件
outstream.flush（）；
} else{//文件不存在时
String notfound="
Error 404-file not found
"；
outstream.println（"HTTP/1.0 404 no found"）；
outstream.println（"Content_Type：text/html"）；
outstream.println（"Content_Length："+notfound.length（）+2）；
outstream.println（""）；
outstream.println（notfound）；
outstream.flush（）；
}