副标题#e#
为了一步一步的把握网络编程,下面再研究网络编程中的两个根基问题,通过办理这两个问题将对网络编程的认识深入一层。
1、如何复用Socket毗连?
在前面的示例中,客户端中成立了一次毗连,只发送一次数据就封锁了,这就相当于拨打电话时,电话买通了只对话一次就封锁了,其实越发常用的应该是拨通一次电话今后多次对话,这就是复用客户端毗连。
那么如何实现成立一次毗连,举办多次数据互换呢?其实很简朴,成立毗连今后,将数据互换的逻辑写到一个轮回中就可以了。这样只要轮回不竣事则毗连就不会被封锁。凭据这种思路,可以改革一下上面的代码,让该措施可以在成立毗连一次今后,发送三次数据,虽然这里的次数也可以是多次,示例代码如下:
package tcp;
import java.io.*;
import java.net.*;
/**
* 复用毗连的Socket客户端
* 成果为:发送字符串“Hello”随处事器端,并打印出处事器端的反馈
*/
public class MulSocketClient {
public static void main(String[] args) {
Socket socket = null;
InputStream is = null;
OutputStream os = null;
//处事器端IP地点
String serverIP = "127.0.0.1";
//处事器端端标语
int port = 10000;
//发送内容
String data[] ={"First","Second","Third"};
try {
//成立毗连
socket = new Socket(serverIP,port);
//初始化流
os = socket.getOutputStream();
is = socket.getInputStream();
byte[] b = new byte[1024];
for(int i = 0;i < data.length;i++){
//发送数据
os.write(data[i].getBytes());
//吸收数据
int n = is.read(b);
//输出反馈数据
System.out.println("处事器反馈:" + new String(b,0,n));
}
} catch (Exception e) {
e.printStackTrace(); //打印异常信息
}finally{
try {
//封锁流和毗连
is.close();
os.close();
socket.close();
} catch (Exception e2) {}
}
}
}
该示例措施和前面的代码对比,将数据互换部门的逻辑写在一个for轮回的内容,这样就可以成立一次毗连,依次将data数组中的数据凭据顺序发送给处事器端了。
假如照旧利用前面示例代码中的处事器端措施运行该措施,则该措施的功效是:
java.net.SocketException: Software caused connection abort: recv failed
at java.net.SocketInputStream.socketRead0(Native Method)
at java.net.SocketInputStream.read(SocketInputStream.java:129)
at java.net.SocketInputStream.read(SocketInputStream.java:90)
at tcp.MulSocketClient.main(MulSocketClient.java:30)
处事器反馈:First
显然,客户端在实际运行时呈现了异常,呈现异常的原因是什么呢?假如仔细阅读前面的代码,应该还记得前面示例代码中的处事器端是对话一次数据今后就封锁了毗连,假如处事器端措施封锁了,客户端继承发送数据必定会呈现异常,这就是呈现该问题的原因。
#p#副标题#e#
凭据客户端实现的逻辑,也可以复用处事器端的毗连,实现的道理也是将处事器端的数据互换逻辑写在轮回中即可,凭据该种思路改革今后的处事器端代码为:
package tcp;
import java.io.*;
import java.net.*;
/**
* 复用毗连的echo处事器
* 成果:将客户端发送的内容反馈给客户端
*/
public class MulSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
OutputStream os = null;
InputStream is = null;
//监听端标语
int port = 10000;
try {
//成立毗连
serverSocket = new ServerSocket(port);
System.out.println("处事器已启动:");
//得到毗连
socket = serverSocket.accept();
//初始化流
is = socket.getInputStream();
os = socket.getOutputStream();
byte[] b = new byte[1024];
for(int i = 0;i < 3;i++){
int n = is.read(b);
//输出
System.out.println("客户端发送内容为:" + new String(b,0,n));
//向客户端发送反馈内容
os.write(b, 0, n);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//封锁流和毗连
os.close();
is.close();
socket.close();
serverSocket.close();
}catch(Exception e){}
}
}
}
#p#分页标题#e#
在该示例代码中,也将数据发送和吸收的逻辑写在了一个for轮回内部,只是在实现时硬性的将轮回次数划定成了3次,这样代码固然较量简朴,可是通用性较量差。
以该处事器端代码实现为基本运行前面的客户端措施时,客户端的输出为:
处事器反馈:First
处事器反馈:Second
处事器反馈:Third
处事器端措施的输出功效为:
处事器已启动:
客户端发送内容为:First
客户端发送内容为:Second
客户端发送内容为:Third
在该措施中,较量明明的浮现出了“请求-响应”模子,也就是在客户端提倡毗连今后,首先发送字符串“First”给处事器端,处事器端输出客户端发送的内容“First”,然后将客户端发送的内容再反馈给客户端,这样客户端也输出处事器反馈“First”,这样就完成了客户端和处事器端的一次对话,紧接着客户端发送“Second”给处事器端,处事端输出“Second”,然后将“Second”再反馈给客户端,客户端再输出“Second”,从而完成第二次会话,第三次会话的进程和这个一样。在这个进程中,每次都是客户端措施首先发送数据给处事器端,处事器吸收数据今后,将功效反馈给客户端,客户端吸收随处事器端的反馈,从而完成一次通讯进程。
在该示例中,固然办理了多次发送的问题,可是客户端和处事器端的次数节制还不足机动,假如客户端的次数不牢靠怎么办呢?是否可以利用某个非凡的字符串,譬喻quit,暗示客户端退出呢,这就涉及到网络协议的内容了,会在后续的网络应用示例部门具体先容。下面开始先容别的一个网络编程的突出问题。
2、如何使处事器端支持多个客户端同时事情?
前面先容的处事器端措施,只是实现了观念上的处事器端,离实际的处事器端措施布局间隔还很遥远,假如需要让处事器端可以或许实际利用,那么最需要办理的问题就是——如何支持多个客户端同时事情。
一个处事器端一般都需要同时为多个客户端提供通讯,假如需要同时支持多个客户端,则必需利用前面先容的线程的观念。简朴来说,也就是当处事器端吸收到一个毗连时,启动一个专门的线程处理惩罚和该客户端的通讯。
凭据这个思路改写的处事端示例措施将由两个部门构成,MulThreadSocketServer类实现处事器端节制,实现吸收客户端毗连,然后开启专门的逻辑线程处理惩罚该毗连,LogicThread类实现对付一个客户端毗连的逻辑处理惩罚,将处理惩罚的逻辑安排在该类的run要领中。该示例的代码实现为:
package tcp;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 支持多客户端的处事器端实现
*/
public class MulThreadSocketServer {
public static void main(String[] args) {
ServerSocket serverSocket = null;
Socket socket = null;
//监听端标语
int port = 10000;
try {
//成立毗连
serverSocket = new ServerSocket(port);
System.out.println("处事器已启动:");
while(true){
//得到毗连
socket = serverSocket.accept();
//启动线程
new LogicThread(socket);
}
} catch (Exception e) {
e.printStackTrace();
}finally{
try{
//封锁毗连
serverSocket.close();
}catch(Exception e){}
}
}
}
在该示例代码中,实现了一个while形式的死轮回,由于accept要领是阻塞要领,所以当客户端毗连未达到时,将阻塞该措施的执行,当客户端达到时吸收该毗连,并启动一个新的LogicThread线程处理惩罚该毗连,然后凭据轮回的执行流程,继承期待下一个客户端毗连。这样当任何一个客户端毗连达到时,都开启一个专门的线程处理惩罚,通过多个线程支持多个客户端同时处理惩罚。
下面再看一下LogicThread线程类的源代码实现:
#p#分页标题#e#
package tcp;
import java.io.*;
import java.net.*;
/**
* 处事器端逻辑线程
*/
public class LogicThread extends Thread {
Socket socket;
InputStream is;
OutputStream os;
public LogicThread(Socket socket){
this.socket = socket;
start(); //启动线程
}
public void run(){
byte[] b = new byte[1024];
try{
//初始化流
os = socket.getOutputStream();
is = socket.getInputStream();
for(int i = 0;i < 3;i++){
//读取数据
int n = is.read(b);
//逻辑处理惩罚
byte[] response = logic(b,0,n);
//反馈数据
os.write(response);
}
}catch(Exception e){
e.printStackTrace();
}finally{
close();
}
}
/**
* 封锁流和毗连
*/
private void close(){
try{
//封锁流和毗连
os.close();
is.close();
socket.close();
}catch(Exception e){}
}
/**
* 逻辑处理惩罚要领,实现echo逻辑
* @param b 客户端发送数据缓冲区
* @param off 起始下标
* @param len 有效数据长度
* @return
*/
private byte[] logic(byte[] b,int off,int len){
byte[] response = new byte[len];
//将有效数据拷贝到数组response中
System.arraycopy(b, 0, response, 0, len);
return response;
}
}
在该示例代码中,每次利用一个毗连工具结构该线程,该毗连工具就是该线程需要处理惩罚的毗连,在线程结构完成今后,该线程就被启动起来了,然后在run要领内部对客户端毗连举办处理惩罚,数据互换的逻辑和前面的示例代码一致,只是这里将吸收到客户端发送过来的数据并举办处理惩罚的逻辑封装成了logic要领,凭据前面先容的IO编程的内容,客户端发送过来的内容存储在数组b的起始下标为0,长度为n其中,这些数据是客户端发送过来的有效数据,将有效的数据通报给logic要领,logic要领实现的是echo处事的逻辑,也就是将客户端发送的有效数据形成今后新的response数组,并作为返回值反馈。
在线程中将logic要领的返回值反馈给客户端,这样就完成了处事器端的逻辑处理惩罚模仿,其他的实现和前面的先容雷同,这里就不在反复了。
这里的示例还只是基本的处事器端实现,在实际的处事器端实现中,由于硬件和端口数的限制,所以不能无限制的建设线程工具,并且频繁的建设线程工具效率也较量低,所以措施中都实现了线程池来提高措施的执行效率。
这里简朴先容一下线程池的观念,线程池(Thread pool)是池技能的一种,就是在措施启动时首先把需要个数的线程工具建设好,譬喻建设5000个线程工具,然后当客户端毗连达到时从池中取出一个已经建设完成的线程工具利用即可。当客户端毗连封锁今后,将该线程工具从头放入到线程池中供其它的客户端反复利用,这样可以提高措施的执行速度,优化措施对付内存的占用等。
关于基本的TCP方法的网络编程就先容这么多,下面先容UDP方法的网络编程在Java语言中的实现。
