求助简单的socket问题,必有重谢!有程序的送大分! 客户端建立了soket以后可以开一个线程监听服务器端的消息啊取数据的线程并不影响发送数据啊,当然可以同时发送接收了 解决方案 » 免费领取超大流量手机卡,每月29元包185G流量+100分钟通话, 中国电信官方发货 谢谢,大家up。在这里深表感谢,确实不难,只是在下学时浅薄,才来寻求兄弟们帮忙,确实要求不很高的一个编程,只是多线程部分要难些!(当然是对于我这样的初学者来说:)如果兄弟们有空,可以留段代码,没有多线程部分也可以有注释当然最好了,在下 大连 qq 22504826, 帮忙统统给分,谢谢捧场! 列表9.1列出了一个简单的客户端的程序.它向一个服务器发出一个请求,取回一个HTML文档,并把它显示在控制台上.9.1一个简单的socket客户端import java.io.*; import java.net.*; /** * 一个简单的从服务器取回一个HTML页面的程序 * 注意:merlin是本地机器的名字 */ public class SimpleWebClient { public static void main(String args[]) { try { // 打开一个客户端socket连接Socket clientSocket1 = new Socket("merlin", 80); System.out.println("Client1: " + clientSocket1); // 取得一个网页 getPage(clientSocket1); } catch (UnknownHostException uhe) { System.out.println("UnknownHostException: " + uhe); } catch (IOException ioe) { System.err.println("IOException: " + ioe); } } /** *通过建立的连接请求一个页面,显示回应然后关闭socket */ public static void getPage(Socket clientSocket) { try { // 需要输入和输出流 DataOutputStream outbound = new DataOutputStream( clientSocket.getOutputStream() ); DataInputStream inbound = new DataInputStream( clientSocket.getInputStream() ); // 向服务器发出HTTP请求 outbound.writeBytes("GET / HTTP/1.0\r\n\r\n"); // 读出回应 String responseLine; while ((responseLine = inbound.readLine()) != null) { // 把每一行显示出来 System.out.println(responseLine); if ( responseLine.indexOf("") != -1 ) break; } // 清除 outbound.close(); inbound.close(); clientSocket.close(); } catch (IOException ioe) { System.out.println("IOException: " + ioe); } } } 回忆一个,一个客户端向一个正在监听的服务器socket发出一个连接.客户端的sockets是用Socket类建立的.下面的程序建立了一个客户端的socket并且连接到了一个主机:Socket clientSocket = new Socket("merlin", 80);第一个参数是你想要连接的主机的名称,第二个参数是端口号.一个主机名称指定了目的的名称.端口号指定了由哪个应用程序来接收.在我们的情况下,必须指定80,因为它是默认的HTTP协议的端口. 列表9.2是一个服务器应用程序的一部分.列表9.2 一个简单的服务器程序 /** * 一个监听端口并提供HTML文档的程序.*/ class SimpleWebServer { public static void main(String args[]) { ServerSocket serverSocket = null; Socket clientSocket = null; int connects = 0; try { { // 建立一个服务器socket serverSocket = new ServerSocket(80, 5); while (connects < 5) { // 等待连接 clientSocket = serverSocket.accept(); //服务连接ServiceClient(clientSocket); connects++; } serverSocket.close(); } catch (IOException ioe) { System.out.println("Error in SimpleWebServer: " + ioe); } } public static void ServiceClient(Socket client) throws IOException { DataInputStream inbound = null; DataOutputStream outbound = null; try { // 得到IO流 inbound = new DataInputStream( client.getInputStream()); outbound = new DataOutputStream( client.getOutputStream()); //格式化输出(回应头和很少的HTML文档)StringBuffer buffer = PrepareOutput(); String inputLine; while ((inputLine = inbound.readLine()) != null) { //如果到了HTTP请求的尾部,就发送回应 if ( inputLine.equals("") ) { outbound.writeBytes(buffer.toString()); break; } } } finally { // 清除 System.out.println("Cleaning up connection: " + client); tln("Cleaning up connection: " + client); outbound.close(); inbound.close(); client.close(); client.close(); } } 服务器并不是主动地建立连接.相反地,他们是被动地监听一个客户端的连接请示然后给他们服务.服务器是由类ServerSocket来建立的.下面的程序建立了一个服务器端socket并把它绑定到80端口:ServerSocket serverSocket = new ServerSocket(80, 5); 第一个参数是服务器要监听的端口.第二个参数是可选的.API文档中说明了这是一个监听时间,但是在传统的socket程序中第二个参数是监听深度.一个服务器可以同时接收多个连接请求,但是每次只能处理一个.监听堆是一个无回答的连接请求队列.上面的请求建立一个连接来处理最后五个请求.如果省略了后面的一个参数,则默认值是50.ServerSocket serverSocket = new ServerSocket(80, 5); 一旦socket建立了并开始监听连接,进来的连接将会建立并放在监听堆.accetp()方法把在堆中的连接取出来.Socket clientSocket = serverSocket.accept(); 这个方法返回一个用来与来访者对话的客户端连接.服务器本身不可能建立对话,相反地,服务器socket会使用accept()方法来产生一个新的socket.服务器socket依旧打开并排列新的连接请求.与客户端socket一样,下面的一步建立输入和输出流:DataInputStream inbound = new DataInputStream( clientSocket.getInputStream() ); DataOutputStream outbound = new DataOutputStream( clientSocket.getOutputStream() ); 一般的I/O操作可以在新建的流中运用.在服务器回应前它等待客户端发送一个空白的行.当会话结束时,服务器关闭流和客户端socket.如果在队列中没有请示将会出现什么情况呢?那个方法将会等待一个的到来.这个行为叫阻塞.accept()方法将会阻塞服务器线程直到一个呼叫到来.当5个连接处理完闭之后,服务器退出.任何的在队列中的呼叫将会被取消. 所有的服务器都要有以下的基本的步骤:1.建立一个服务器socket并开始监听.2.使用accept()方法取得新的连接. 3.建立输入和输出流.4.在已有的协议上产生会话. 5.关闭客户端流和socket.6.回到第二步或者到第七步.7.关闭服务器socket. 所有的这些调用都可以掷出一个UnknownHostException违例.如果一台计算机没有连接上DNS服务器,或者主机的确没有找到,这个违例就会被掷出.如果一台计算机没有一个激活的TCP/IP配置,getLocalHost()也为失败并掷出一个违例. 一旦一个地址被确定了,数据报就可以被送出了.下面的程序传输了一个字符串给目的socket: String toSend = "This is the data to send!"); byte[] sendbuf = new byte[ toSend.length() ]; toSend.getBytes( 0, toSend.length(), sendbuf, 0 ); DatagramPacket sendPacket = new DatagramPacket( sendbuf, sendbuf.length, addr, port); clientSocket.send( sendPacket ); 首先,字符串必须被转换成一个字节数组.然后,一个新的DatagramPacket实例必须被建立.注意构建器的最后两个参数.因为要发送一个包,所以地址和端口必须被给定.一个applet可能可以知道它的服务器的地址,但是服务器如何知道它的客户机的地址呢.当任何一个包被收到后,返回的地址和端口会被解压出来,并通过getAddress()和getPort()方法得到.这就是一个服务器如何回应一个客户端的包: DatagramPacket sendPacket = new DatagramPacket( sendbuf, sendbuf.length, recvPacket.getAddress(), recvPacket.getPort() ); serverSocket.send( sendPacket ); 不像面向连接的操作,数据报服务器服务器其实比数据报客户端更简单: 数据报服务器一个数据报服务器的基本步骤: 1.在一个指定的端口上建立一个数据报socket. 2.用receive方法等待进来的包.3.用特定的协议来回应收到的包.4.回到第二步或继续第二步.5.关闭数据报socket.列表9.3演示了一人简单的数据报回应服务器.它将回应它收到的包. 列表9.3.一个简单的数据报回应服务器 import java.io.*; import java.net.*; public class SimpleDatagramServer { public static void main(String[] args) { DatagramSocket socket = null; DatagramPacket recvPacket, sendPacket; try { socket = new DatagramSocket(4545); while (socket != null) { recvPacket= new DatagramPacket(new byte[512], 512); socket.receive(recvPacket); sendPacket = new DatagramPacket( recvPacket.getData(), recvPacket.getLength(), recvPacket.getAddress(), recvPacket.getPort() ); socket.send( sendPacket ); } } catch (SocketException se) { System.out.println("Error in SimpleDatagramServer: " + se); } catch (IOException ioe) { System.out.println("Error in SimpleDatagramServer: " + ioe); 这个应用程序被当作一个重复的服务器.因为它只有在处理完一个进程以后才会接受另一个连接.更多的复杂服务器是并发的.它为每一个请求分配一个线程,而不是来一个处理一个.所以看起来它在同时处理多人请求.所有的商业的服务器都是并发的服务器. Java数据报类不像面向连接的类,数据报的客户端和服务器端的类在表面上是一样的.下面的程序建立了一个客户和服务器商的数据报sockets:DatagramSocket serverSocket = new DatagramSocket( 4545 );DatagramSocket clientSocket = new DatagramSocket(); 服务器用参数4545来指定端口号,由于客户端将要呼叫服务器,客户端可以利用可利用的端口.如果省略第二个参数,程序会让操作系统分配一个可用的端口.客户端可以请求一个指定的端口,但是如果其它的应用程序已经绑定到这个端口之上,请求将会失败.如果你的意图不是作为一个服务器,最好不要指定端口.由于流不能由交谈得到,那么我么如何与一个数据报Socket进行对话.答案在于数据报类. 接收数据报DatagramPacket类是用来通过DatagramSocket类接收和发送数据的类.packet类包括了连接信息和数据.就如前面所说的一样,数据报是自身独立的传输单元.DatagramPacket类压缩了这些单元.下面的程序表示了用一个数据报socket来接收数据:DatagramPacket packet = new DatagramPacket(new byte[512], 512); clientSocket.receive(packet);clientSocket.receive(packet); packet的构建器需要知道将得到的数据放在哪儿.一个512字节的缓存被建立并且作为构建器的第二个参数.每二个构建器参数是缓存的大小.就像ServerSocket类的accept()方法一样,receive()方法在数据可用之前将会阻塞.发送数据报发送数据报是非常地简单地,所有需要的只是一个地址.地址是由InetAddress类来建立的.这个类没有公共的构建器,但是它有几个static的方法,可以用来建立这个类的实例.下面的列表列出了建立InetAddress类的实例的方法: Public InetAddress Creation Methods InetAddress getByName(String host);InetAddress[] getAllByName(String host);InetAddress getLocalHost(); 得到本地主机的地址是非常地有用的,只有前面两个方法是用来发送数据包的.getByName()和getAllByName()需要目的主机的地址.第一个方法仅仅只是返回第一个符合条件的东西.第二个方法是必须的,因为一台计算机可能有多个地址.在这种情况下,这台计算机被称为multi-homed.所有的建立的方法都被标记为static.它们必须像下面这样得到调用: InetAddress addr1 = InetAddress.getByName("merlin"); InetAddress addr2[] = InetAddress.getAllByName("merlin"); InetAddress addr3 = InetAddress.getLocalHost(); 因为Socket类是面向连接的,它提供了一个可供读写的流接口.java.io包中的类可以用来访问一个已连接的socket:DataOutputStream outbound = new DataOutputStream( clientSocket.getOutputStream() ); DataInputStream inbound = new DataInputStream( clientSocket.getInputStream() ); 一旦流建立了,一般的流操作就可以做了:outbound.writeBytes("GET / HTTP/1.0\r\n\r\n); String responseLine; while ( (responseLine = inbound.readLine()) != null) { System.out.println(responseLine); } 以上的小程序请求了一个WEB页面并且把它显示出来.当程序完成之后,连接必须关闭. outbound.close(); inbound.close(); clientSocket.close(); 注意socket流必须首先关闭.所有的的socket流必须在socket关闭之前关闭.这个小程序非常地简单,但是所有的客户端程序都必须遵首下面的基本的步骤: 1.建立客户端socket连接.2.得到socket的读和写的流.3.利用流.4.关闭流.5.关闭socket.使用一个服务器端的socket只是有一点复杂,它将在下面讲到. _________________________________________________________________________________简单的WEB服务器一个简单的WEB服务器将由列表9.2这样构建.当然,还必须要对方法和回应事件进行改进.简单的服务器不会分析和存储请求头.新的WEB服务器将分析和存储请求,为以后的处理作准备.为了达到这个目的,你必须有一个包含HTTP请求的类.HTTPrequest类列表9.5列出了一个完整的HTTPrequest类.这个类必须包括一个请求头所需的所有信息. 列表9.5.HTTPrequest类. import java.io.*; import java.util.*; import java.net.*; import NameValue; /** * 这个类有一个HTTP请求的所有信息 */ public class HTTPrequest { public String version; public String method; public String file; public Socket clientSocket; public DataInputStream inbound; public NameValue headerpairs[]; /** * 建立一个这个类的实例 */ public HTTPrequest() { version = null; method = null; file = null; clientSocket = null; inbound = null; inbound = null; headerpairs = new NameValue[0]; } /** * 加入一个名称/值对到核心数组*/ public void addNameValue(String name, String value) { try { NameValue temp[] = new NameValue[ headerpairs.length + 1 ]; System.arraycopy(headerpairs, 0, temp, 0, headerpairs.length); temp[ headerpairs.length ] = new NameValue(name, value); headerpairs = temp; } catch (NullPointerException npe) { System.out.println("NullPointerException while adding name-value: " + npe); } } /** * 以字符串的形式归还这个类*/ public String toString() { String s = method + " " + file + " " + version + "\n"; for (int x = 0; x < headerpairs.length; x++ ) s += headerpairs[x] + "\n"; return s; } } NameValue类简单地存储了两个字符串:name 和 value.当一个新的对要被加入时,一个新的数组将被分配.新的数组接受了旧的数组和新的成员.旧的数组然后被一个新建的对象覆盖了. 非常感谢, 其实说具体点我实现的是对交流调速电机电压,电流变化的实时检测,客户界面和主机接受的交流调速电机的数据都有了,就缺java,socket实现的主机 客户交换数据,隔一段时间检测 电压 电流等 有没有变化,有变化客户端跟着改,划曲线,然后取个值 (这部分已经做好了),把取得值送回给服务器,就是这个过程,最好同时监测变化取服务器数据,和客户送数据给服务器,是不冲突,所以用多线程,如果多线程 麻烦,不用也行!!!您列出的功能大于我说的功能,对我要实现的也大有帮助,我研究一下! 我作的这个是 客户-服务端的socket程序, 要求客户端实时监测服务器上一些数据(电流,电压等)比如可做成客户发出一个请求后,服务器便把这些数据(如数组)不停的发往客户端,以至于服务器上的的数据发生变化,客户端就同时看到变化,从而实现实时监控, 我主要是socket这部分和多线呈不会,请写给我些代码好吗?我已经写了一个客户端界面,希望大哥能帮忙,小弟先谢过了,小弟马上毕业了,时间好紧,这个真的没精力作了! 来大连我请客!一定!大哥要能帮忙,我把我做的这部分给您们,您们帮我把socket连续发给客户数据这部分写给我,谢谢 快结贴了,大家快来呀! onetime,我有一个不需要自己编socket也可以解决你的问题的方法,而且有源代码噢,现在地web服务器很多,而且都是多线程的,并且都经过很多客户的测试的,干嘛自己写.用http和他们通讯就好. 杂么没有@MapsId捏??? 树形结构 struts2 跳转页面乱码 路线查询系统 菜鸟求助 关于Oracle中 sequence 的问题 高分求教:Axis客户端调用,如何加入soap header信息 再问一个hibernate的问题 hibernate高手请进,分不够再加 hibernate初始化时为什么删除原为库? tomcat环境变量的配置问题 JDBC连接和sql sever2k问题 请教各位高手,关于servlet的运行问题
确实要求不很高的一个编程,只是多线程部分要难些!(当然是对于
我这样的初学者来说:)如果兄弟们有空,可以留段代码,没有多线程部分也可以
有注释当然最好了,
在下 大连 qq 22504826, 帮忙统统给分,谢谢捧场!
import java.net.*;
/**
* 一个简单的从服务器取回一个HTML页面的程序
* 注意:merlin是本地机器的名字
*/
public class SimpleWebClient {
public static void main(String args[])
{
try
{
// 打开一个客户端socket连接
Socket clientSocket1 = new Socket("merlin", 80);
System.out.println("Client1: " + clientSocket1);
// 取得一个网页
getPage(clientSocket1);
}
catch (UnknownHostException uhe)
{
System.out.println("UnknownHostException: " + uhe);
}
catch (IOException ioe)
{
System.err.println("IOException: " + ioe);
}
}
/**
*通过建立的连接请求一个页面,显示回应然后关闭socket
*/
public static void getPage(Socket clientSocket)
{
try
{
// 需要输入和输出流
DataOutputStream outbound = new DataOutputStream(
clientSocket.getOutputStream() );
DataInputStream inbound = new DataInputStream(
clientSocket.getInputStream() );
// 向服务器发出HTTP请求
outbound.writeBytes("GET / HTTP/1.0\r\n\r\n");
// 读出回应
String responseLine;
while ((responseLine = inbound.readLine()) != null)
{
// 把每一行显示出来
System.out.println(responseLine);
if ( responseLine.indexOf("") != -1 )
break;
}
// 清除
outbound.close();
inbound.close();
clientSocket.close();
}
catch (IOException ioe)
{
System.out.println("IOException: " + ioe);
}
}
}
回忆一个,一个客户端向一个正在监听的服务器socket发出一个连接.客户端的sockets是用Socket类建立的.下面的程序建立了一个客户端的socket并且连接到了一个主机:Socket clientSocket = new Socket("merlin", 80);第一个参数是你想要连接的主机的名称,第二个参数是端口号.一个主机名称指定了目的的名称.端口号指定了由哪个应用程序来接收.在我们的情况下,必须指定80,因为它是默认的HTTP协议的端口.
* 一个监听端口并提供HTML文档的程序.
*/
class SimpleWebServer {
public static void main(String args[])
{
ServerSocket serverSocket = null;
Socket clientSocket = null;
int connects = 0;
try
{
{
// 建立一个服务器socket
serverSocket = new ServerSocket(80, 5);
while (connects < 5)
{
// 等待连接
clientSocket = serverSocket.accept();
//服务连接
ServiceClient(clientSocket);
connects++;
}
serverSocket.close();
}
catch (IOException ioe)
{
System.out.println("Error in SimpleWebServer: " + ioe);
}
}
public static void ServiceClient(Socket client)
throws IOException
{
DataInputStream inbound = null;
DataOutputStream outbound = null;
try
{
// 得到IO流
inbound = new DataInputStream( client.getInputStream());
outbound = new DataOutputStream( client.getOutputStream());
//格式化输出(回应头和很少的HTML文档)
StringBuffer buffer = PrepareOutput();
String inputLine;
while ((inputLine = inbound.readLine()) != null)
{
//如果到了HTTP请求的尾部,就发送回应
if ( inputLine.equals("") )
{
outbound.writeBytes(buffer.toString());
break;
}
}
}
finally
{
// 清除
System.out.println("Cleaning up connection: " + client);
tln("Cleaning up connection: " + client);
outbound.close();
inbound.close();
client.close();
client.close();
}
}
byte[] sendbuf = new byte[ toSend.length() ];
toSend.getBytes( 0, toSend.length(), sendbuf, 0 );
DatagramPacket sendPacket = new DatagramPacket( sendbuf, sendbuf.length,
addr, port);
clientSocket.send( sendPacket ); 首先,字符串必须被转换成一个字节数组.然后,一个新的DatagramPacket实例必须被建立.注意构建器的最后两个参数.因为要发送一个包,所以地址和端口必须被给定.一个applet可能可以知道它的服务器的地址,但是服务器如何知道它的客户机的地址呢.当任何一个包被收到后,返回的地址和端口会被解压出来,并通过getAddress()和getPort()方法得到.这就是一个服务器如何回应一个客户端的包: DatagramPacket sendPacket = new DatagramPacket( sendbuf, sendbuf.length,
recvPacket.getAddress(), recvPacket.getPort() );
serverSocket.send( sendPacket ); 不像面向连接的操作,数据报服务器服务器其实比数据报客户端更简单: 数据报服务器一个数据报服务器的基本步骤: 1.在一个指定的端口上建立一个数据报socket. 2.用receive方法等待进来的包.3.用特定的协议来回应收到的包.4.回到第二步或继续第二步.5.关闭数据报socket.列表9.3演示了一人简单的数据报回应服务器.它将回应它收到的包. 列表9.3.一个简单的数据报回应服务器 import java.io.*;
import java.net.*;
public class SimpleDatagramServer
{
public static void main(String[] args)
{
DatagramSocket socket = null;
DatagramPacket recvPacket, sendPacket;
try
{
socket = new DatagramSocket(4545);
while (socket != null)
{
recvPacket= new DatagramPacket(new byte[512], 512);
socket.receive(recvPacket);
sendPacket = new DatagramPacket(
recvPacket.getData(), recvPacket.getLength(),
recvPacket.getAddress(), recvPacket.getPort() );
socket.send( sendPacket );
}
}
catch (SocketException se)
{
System.out.println("Error in SimpleDatagramServer: " + se);
}
catch (IOException ioe)
{
System.out.println("Error in SimpleDatagramServer: " + ioe); 这个应用程序被当作一个重复的服务器.因为它只有在处理完一个进程以后才会接受另一个连接.更多的复杂服务器是并发的.它为每一个请求分配一个线程,而不是来一个处理一个.所以看起来它在同时处理多人请求.所有的商业的服务器都是并发的服务器. Java数据报类不像面向连接的类,数据报的客户端和服务器端的类在表面上是一样的.下面的程序建立了一个客户和服务器商的数据报sockets:DatagramSocket serverSocket = new DatagramSocket( 4545 );
DatagramSocket clientSocket = new DatagramSocket(); 服务器用参数4545来指定端口号,由于客户端将要呼叫服务器,客户端可以利用可利用的端口.如果省略第二个参数,程序会让操作系统分配一个可用的端口.客户端可以请求一个指定的端口,但是如果其它的应用程序已经绑定到这个端口之上,请求将会失败.如果你的意图不是作为一个服务器,最好不要指定端口.由于流不能由交谈得到,那么我么如何与一个数据报Socket进行对话.答案在于数据报类. 接收数据报DatagramPacket类是用来通过DatagramSocket类接收和发送数据的类.packet类包括了连接信息和数据.就如前面所说的一样,数据报是自身独立的传输单元.DatagramPacket类压缩了这些单元.下面的程序表示了用一个数据报socket来接收数据:DatagramPacket packet = new DatagramPacket(new byte[512], 512); clientSocket.receive(packet);
clientSocket.receive(packet); packet的构建器需要知道将得到的数据放在哪儿.一个512字节的缓存被建立并且作为构建器的第二个参数.每二个构建器参数是缓存的大小.就像ServerSocket类的accept()方法一样,receive()方法在数据可用之前将会阻塞.发送数据报发送数据报是非常地简单地,所有需要的只是一个地址.地址是由InetAddress类来建立的.这个类没有公共的构建器,但是它有几个static的方法,可以用来建立这个类的实例.下面的列表列出了建立InetAddress类的实例的方法: Public InetAddress Creation Methods InetAddress getByName(String host);
InetAddress[] getAllByName(String host);
InetAddress getLocalHost(); 得到本地主机的地址是非常地有用的,只有前面两个方法是用来发送数据包的.getByName()和getAllByName()需要目的主机的地址.第一个方法仅仅只是返回第一个符合条件的东西.第二个方法是必须的,因为一台计算机可能有多个地址.在这种情况下,这台计算机被称为multi-homed.所有的建立的方法都被标记为static.它们必须像下面这样得到调用: InetAddress addr1 = InetAddress.getByName("merlin");
InetAddress addr2[] = InetAddress.getAllByName("merlin");
InetAddress addr3 = InetAddress.getLocalHost();
clientSocket.getOutputStream() );
DataInputStream inbound = new DataInputStream( clientSocket.getInputStream()
); 一旦流建立了,一般的流操作就可以做了:outbound.writeBytes("GET / HTTP/1.0\r\n\r\n);
String responseLine;
while ( (responseLine = inbound.readLine()) != null)
{
System.out.println(responseLine);
} 以上的小程序请求了一个WEB页面并且把它显示出来.当程序完成之后,连接必须关闭. outbound.close();
inbound.close();
clientSocket.close(); 注意socket流必须首先关闭.所有的的socket流必须在socket关闭之前关闭.这个小程序非常地简单,但是所有的客户端程序都必须遵首下面的基本的步骤:
1.建立客户端socket连接.2.得到socket的读和写的流.3.利用流.4.关闭流.5.关闭socket.使用一个服务器端的socket只是有一点复杂,它将在下面讲到.
_________________________________________________________________________________
简单的WEB服务器一个简单的WEB服务器将由列表9.2这样构建.当然,还必须要对方法和回应事件进行改进.简单的服务器不会分析和存储请求头.新的WEB服务器将分析和存储请求,为以后的处理作准备.为了达到这个目的,你必须有一个包含HTTP请求的类.HTTPrequest类列表9.5列出了一个完整的HTTPrequest类.这个类必须包括一个请求头所需的所有信息. 列表9.5.HTTPrequest类. import java.io.*;
import java.util.*;
import java.net.*;
import NameValue;
/**
* 这个类有一个HTTP请求的所有信息
*/
public class HTTPrequest
{
public String version;
public String method;
public String file;
public Socket clientSocket;
public DataInputStream inbound;
public NameValue headerpairs[];
/**
* 建立一个这个类的实例
*/
public HTTPrequest()
{
version = null;
method = null;
file = null;
clientSocket = null;
inbound = null;
inbound = null;
headerpairs = new NameValue[0];
}
/**
* 加入一个名称/值对到核心数组
*/
public void addNameValue(String name, String value)
{
try
{
NameValue temp[] = new NameValue[ headerpairs.length + 1 ];
System.arraycopy(headerpairs, 0, temp, 0, headerpairs.length);
temp[ headerpairs.length ] = new NameValue(name, value);
headerpairs = temp;
}
catch (NullPointerException npe)
{
System.out.println("NullPointerException while adding name-value:
" + npe);
}
}
/**
* 以字符串的形式归还这个类
*/
public String toString()
{
String s = method + " " + file + " " + version + "\n";
for (int x = 0; x < headerpairs.length; x++ )
s += headerpairs[x] + "\n";
return s;
}
} NameValue类简单地存储了两个字符串:name 和 value.当一个新的对要被加入时,一个新的数组将被分配.新的数组接受了旧的数组和新的成员.旧的数组然后被一个新建的对象覆盖了.
其实说具体点我实现的是对交流调速电机电压,电流变化的实时检测,
客户界面和主机接受的交流调速电机的数据都有了,就缺java,socket实现的
主机 客户交换数据,隔一段时间检测 电压 电流等 有没有变化,有变化客户端跟着改,
划曲线,然后取个值 (这部分已经做好了),把取得值送回给服务器,就是这个过程,
最好同时监测变化取服务器数据,和客户送数据给服务器,是不冲突,所以用多线程,
如果多线程 麻烦,不用也行!!!
您列出的功能大于我说的功能,对我要实现的也大有帮助,我研究一下!
我作的这个是 客户-服务端的socket程序, 要求客户端实时监测服务器上一些数据(电流,电压等)
比如可做成客户发出一个请求后,服务器便把这些数据(如数组)不停的发往客户端,以至于服务器上的的数据发生变化,客户端就同时看到变化,从而实现实时监控, 我主要是socket这部分和多线呈不会,请写给我些代码好吗?我已经写了一个客户端界面,希望大哥能帮忙,
小弟先谢过了,小弟马上毕业了,时间好紧,这个真的没精力作了! 来大连我请客!一定!大哥要能帮忙,我把我做的这部分给您们,您们帮我把socket连续发给客户数据这部分写给我,谢谢 快结贴了,大家快来呀!
用http和他们通讯就好.