socket通信十篇
时间：2023-03-30 03:41:55
socket通信篇1
关键词：多线程 Scoket 通信
中图分类号：TP391 文献标识码：A 文章编号：1007-9416（2013）06-0060-01
我们把在Windows下同时执行的多个程序中的任何一个称之为进程。在操作系统的作用下，任何一个进程都认为自己是独立的，都认为自己拥有整台电脑全部的资源，比如内存、CPU等，它们并不知道其他进程正在与它分享这些资源，所以每个进程不会去访问另一个进程的资源。这样做的好处是一个进程无法破坏另一个进程，但缺点是进程之间的信息很难共享。虽然每个进程都认为自己拥有全部CPU资源，但实际并不是这样，系统把CPU资源以时间片为单位，按特定的算法进行分配。在分配时间片的时候，系统并不是按进程来分配而是按线程来进行分配，也就是说只有线程才有权得到CPU资源。我们可以认为线程就是一段可以被执行的代码序列，在每一个进程内部，至少有一个线程，所有进程的运行其实是进程内部的线程被执行而已，这就是进程能获得时间片的原因。我们创建的所有程序内部都有一个线程，在编写程序时并不需要做什么特殊处理，但我们可以通过编写代码让程序内部有多个线程，我们把包含两个或两个以上的线程称之为多线程程序。
1 Socket基本原理
在C#中，MS为我们提供了 .Sockets 命名空间，程序员可以通过socket来发送和接收网络上的数据。我们可以把它理解成是一个API，有了它就可以通过这个接口访问网络从而省去了很多复杂的操作。
要通过互联网进行通信，至少需要一对套接字，它是通信主机之间的端点，由它构成了单个主机内及整个网络间的编程界面。 我们把运行于客户机端的称之ClientSocket， 运行于服务器端的称之为ServerSocket。它的连接过程可以分为三个步骤：服务器监听，客户端请求，连接确认。
2 Socket通信过程 的实现
2.1 服务器端
申请一个Socket，定义到一个IP地址和一个端口上开启侦听。每成功接受一个客户端的链接便在服务端产生一个对应的Socket，在接收客户端连接时创建责和对应的客户端通信。
int recv；//用于表示客户端发送的信息长度
byte[] data=new byte[1024]；//用于缓存客户端所发送的信息
IPEndPoint ipep = new IPEndPoint（IPAddress.Any， 9050）；//定义一网络端点 Socket newsock = new Socket（AddressFamily.InterNetwork， SocketType.Dgram， ProtocolType.Udp）；//定义一个Socket
newsock.Bind（ipep）；//Socket与本地的一个终结点相关联
IPEndPoint sender = new IPEndPoint（IPAddress.Any， 0）；//定义要发送 的计算机的地址
recv = newsock.ReceiveFrom（data， ref Remote）；//接受数据
newsock.SendTo（data， data.Length， SocketFlags.None， Remote）；//发送信息
2.2 客户端
申请一个Socket，连接服务器（必须指明IP地址和端口号），通过创建一个Socket对象来初始化一个服务器端的TCP链接：
byte[] data = new byte[1024]；//定义一个数组用来做数据的缓冲区
string input， stringData；
IPEndPoint ipep = new IPEndPoint（IPAddress.Parse（"127.0.0.1"）， 9050）；
//本机预使用的IP和端口
server.SendTo（data， data.Length， SocketFlags.None， ipep）；//将数据发送到指定的终结点
data = new byte[1024]；
int recv = server.ReceiveFrom（data， ref Remote）；//接受来自服务器的数据
2.3 服务器
服务器接到连接请求后，产生一个新的Socket（端口大于1024）与客户端建立连接并进行通讯，原侦听Socket继续侦听。每个服务打开一个socket，并绑定到一个端口上，不同的端口对应不同的服务（应用程序）。
3 结语
许多Internet服务都可以见到Socket的踪影，如Telnet、Http、Email、Echo等，这些服务尽管通讯协议Protocol的定义不同，但是其基础的传输都是采用的Socket。针对Socket编程，.NET框架的 Socket类是Winsock32 API提供的套接字服务的托管代码版本。其中为实现网络编程提供了大量的方法，大多数情况下，Socket类方法只是将数据封送到它们的本机Win32副本中并处理，如果你熟悉Winsock API函数，那么用Socket类编写网络程序会非常容易。
参考文献
[1]郑阿奇.Visual C#网络编程[M].电子工业出版社，2011（10）.
socket通信篇2
关键词：Linux环境；Socket；网络通信技术
中图分类号：TP316 文献标识码：A
随着网络通信日益为人们的日常生活所依赖，我们对于高性能的网络通信的要求也是越来越高。网络的工作状况对于一个操作系统来说就是最需要的基础性的支持，因此网络的支持程度就显得尤为重要。在现行众多的操作系统中，Linux操作系统有着较好的优势。Linux操作系统是一种可以进行多任务的操作系统，内核小、效率高。Linux操作系统本身还具有较高的安全性，这在网络通信方面是非常引人关注的一点，Linux操作系统还具有良好的兼容性，可以兼容大多数的网络协定，保障运行的效率。因为这些优势，Linux操作系统的应用度非常广泛，对于Linux操作系统的网络通信的研究也成为当下的一股热潮。Socket则作为Linux操作系统的唯一连接接口，对于高性能的网络通信程序开发有着很大的奠基作用。Socket即套接字，是一种连接应用层和传输层之间的编程接口，具有访问下层通信协议的功能，并且可以调用相应的数据。在这种情况之下，我们就要进行Linux环境下基于Socket的网络通信技术研究，希望可以设计出性能更高的网络通信技术。
1.基于SOCKET下的网络通信原理
现在的网络通信大多数都是由客户机和服务器构成的，即C/S架构，此外还有一种是由浏览器和服务端构成的，即B/S架构。这两种网络通信方式即是现在的网络通信的主流通信方式。这都是先通过了解客户需求，由子程序进行沟通和处理，而子程序则由主程序进行统一控制，以主程序为代表控制多个子程序来和客户进行通信。在网络通信中，Socket即套接字是非常重要的。在一个个网络进程运作的时候，我们都是通过对不同的进程进行标注，才可以加以区别。Socket就是一个个的网络进程的ID，只有我们明确了这些ID，我们才可以进行网络间的进程通信，把一个一个进程连接起来完成，从而完成我们需要的网络通信。我们的计算机现在已经越来越复杂，我们的计算机在进行运作的时候，一般都开启的不只是一个进程，对于这些进程的区分，我们就可以用Socket来完成。Socket除了可以担当ID的作用，还可以再进行细分，这样就会含有别的信息，即端口号。在计算机运行时，进程与端口号呈现一一对应的关系，这样能够避免出现运行误差，极大的提高网络通信的运行效率。Socket的网络协议还具有非常多的类型，工作方式也不尽相同，地址格式也不相同，相同的网络协议地址就可以用组成协议地址族，见表1。
对于这些套接字地址族，我们都是可以将其作为统一的套接字接口，可以被专有各地址族的软件所使用。有了这些前提，Socket下的ID和端口号的相互配合之下，我们的网络通信才可以得到实现。
2. LINUX网络通信设计
了解了Socket下的网络通信原理之后，我们就可以进行对Linux的网j通信设计了。对于Linux的网络通信设计，我们主要从工作流程、数据发送模块和数据接受模块3个方面来进行入手。
2.1 工作流程
对于Linux的网络通信进行设计，我们要先熟悉Linux的网络通信的通信流程。因此，我们要先从Socket开始。我们首先要做的就是建立起套接口，int socket=socket（intdomain，int type，int protocol）；然后对建立的套接口进行绑定，给与建立的套接口一个地址，这个地址里包含有计算机的IP地址和端口号等一些基础信息，可以为套接口进行进程间的连接做好准备；客户端就可以请求连接网络，客户端会通过未被占用的端口来进行进程；在程序运行的时候，Socket会与相应的端口进行一对一的连接，并且会对连接的端口进行监听，以便在收到请求的时候及时地给予相应的处理；请求的队列过大会导致服务不会回应或是回应过慢，在队列减少则会尽快处理；处理完就可以将结果传输出去了，send和recv这两个函数可以完成对Socket进行数据传输；发送数据和接收数据，传输完毕之后，就可以关闭连接了。这样就可以完成整个客户访问的进程间的通信了。
2.2 数据发送模块
我们对于Linux操作系统中对于进程间的数据发送，是采用Socket函数来进行的。Int send和int recv这两个函数可以应用于套接字在进程间的通信。Send函数是用于发送数据的，如果出现了小于len的情况，就代表着数据有部分没有发送，只是发送了一部分，我们就需要再次发送来完成我们的数据发送。我们进程间的数据发送都是通过调用函数来进行的，通过函数来进行网络的连接，连接好了网络，我们才可以进行发送数据了。我们将数据顺利地发送出去之后，进程间才可以顺利地通信。
2.3 数据接收模块
我们有数据发送，当然也要有数据接收。当网络上的数据被计算机接收到了计算机，会产生一些控制器的中断，导致计算机运行出现故障。这个时候计算机的中断调控处理程序开始工作，对接收到的数据进行处理，相应地处理程序，寄存器开始工作，对接收的新数据进行记录及存储。我们在函数中要正确的设定寄存器的内容，不然我们的计算机将无法对新接收的数据进行处理。出现不同的函数时，代表的意义也是不一样的。我们就可以进行一些举例：当CPR二BNRY时，代表着缓冲区全部被存满，新接收的数据无法被使用；这时网卡将停止往内存写数据，新接收的数据将被抛弃，而无法存到我们的计算机里面；当CPR二BNR卜1时，表示网卡的接收缓冲区里没有数据，我们可以通过这个数据来判断是否有数据可以使用。
只有显示CPR！二BNRY十1时，才代表接收到了新的数据，并处于正常的存储状态，可以为我们所使用。
3. Socket网络通信模型
网络通信模型，最基础的是C/S的网络通信模型。对于这种网络通信模型，我们可以在这个网络通信模型中发现两个部分：客户程序和服务程序。我们的客户程序是由客户来进行提出请求，然后我们的服务程序开始工作，接收请求并建立连接，连接建立以后我们就可以让客户对于我们的网络通信中的数据建立起连接，客户就可以自行读取数据，进行使用。但是应用程序在使用Socket接口来读取数据之前，我们要先进行Socket函数的调用，有了Socket函数的支持，我们才可以完成通信间的连接，以此来完成整个客户程序的使用进程和服务进程的网络通信。网络通信的模型如图1所示。
结语
在这个网络发展迅速的时代，人们对于网络的要求也是越来越高，同时也带动了人们对高性能网络的开发和研究。Linux网络可以可以进行网络资源的共享，完成网络通信，而且具有较高的安全性。Linux网络还具有内核小，包含着很多的网络协议，还有开放的源代码，我们可以利用Linux网络进行基于Socket的网络通信技术的开发。Socket作为其中的接口起着举足轻重的作用，连接起了网络设备和应用程序与下层协定，从而完成设备和网络之间的网络通信。我们对于Linux环境下基于Socket的网络通信技g进行研究，希冀于提高网络通信效率，建立起更好的，性能更高的网络通信技术。
参考文献
[1]莫足琴，欧阳艳阶，马康.基于 Java Socket 多客户端并发通信聊天程序的设计与实现[J].电脑知识与技术，2008（20）：63-65.
[2] Douglas. Comer， David L.Stevens. TCP/IP客户-服务器编程与应用[M].北京：清华大学出版社，2004.
[3]农孙博，范正刚. Linux平台下的Web编程[M].北京：人民邮电出版社，2000.
socket通信篇3
关键词：socket 通信 交易
1.交易系统介绍
交易就是用户对商品的买与卖。交易系统是通过计算机系统来进行交易，也就是说，商品的买与卖都是通过计算机的网络及后台进程配对完成,交易核心采用基于内存的方式设计开发以达到最大的交易及查询响应速度。它的设计思路是：交易系统的所有数据存放在关系数据库中，但交易核心在启动后与硬盘数据不直接通信，而只是在启动时将交易所需数据一次性读入共享内存。这之后的所有交易撮合、生成委托单、交易结果都是在内存中实现的。当交易结束后，再将交易结果从内存装回硬盘数据库中，在数据库中实现交易结算、整理，产生各种帐目及统计报表，同时，再一次完成各种信息的录入与修改。
交易核心与外界的通信经由消息队列(message queue)，交易核心用于交易所使用的数据存放共享内存(shared memory)中，利用socket接口编程来实现.
2.socket的设计原理及进行通信连接的过程框图
socket设计在操作系统的核心中,提供一些系统调用以支持多种通信协议（如tcp，udp等等）。当要支持一种新的通信协议时，则需要把核心做一些改变。为了免除改变核心太多而造成不便，可以采用流的模块方式来添加新的功能，但这种方式并无法完全免除更动核心的操作。实际上，核心的设计把网络系统分成三个不同的层，如下图。
socket支持3种访问传输系统的接口：其中一种就是同步阻塞方式：使用同步阻塞方式时，socket库函数暂停程序的运行，等待传输系统完成请求的操作，操作一旦完成，应用程序重新获得控制权。如下右图。
3.重要的socket系统调用
（1）创建socket- sockets()系统调用
应用程序在使用sockets之前，首先必须拥有一个sockets，系统调用sockets()向应用程序提供创建sockets的手段，其调用格式如下：
sockid = socket (int af, int type, int protocol);
(2)指定本地地址-bind()系统调用
在创建了一个新的socket号后，还要用bind()将本地socket地址（包括主机地址和本地端口号）与所创建的socket号联系起来，其调用格式如下：
bind (socket sockid, const struct sockaddr far* name, int namelen);
(3)listen()系统调用
该调用用于面向连接的流socket，表明它愿意接收连接请求。当服务器可能同时收到几个连接请求时，便将连接请求放入请求队列。listen()在accept()之前调用，其格式为：
listen(socket sockid, int backlog);
（4）建立socket 连接connect()与accept()系统调用
用于完成整个关联的建立。connect()的调用格式如下：
connect (socket sockid, const struct sickaddr far*name, int namelen);
（5）发送数据send()和sendto()系统调用
建立了socket连接后，便可利用上述函数通过该socket发送数据。其中send()用于面向连接的传输，sendto()用于无连接传输，调用格式如下：
send (socket sockid, char faar* buf, intbuflen, int flags);
sendto(socket sockid, const char far* buf, int len, int flags, const struct sockaddr far* to, int tolen);
(6)接收数据—recv()和recvfrom()系统调用接收数据系统调用与发送数据系统调用是一对应的，其调用格式也是一一对应。
(7)关闭socket—closesocket()系统调用
socket通信篇4
关键词：UDP协议；Socket；网络通信
中图分类号：TP393文献标识码：A文章编号：1009-3044(2008)34-1867-02
Socket Network Programs Based on UDP Protocol
ZHOU Li-juan
(College of Science, Hunan University of Technology, Zhuzhou 412008, China)
Abstract: Windows Socket is a network programming interface,and applications can correspond to eachother in different domains without worrying about the different protocols by using it.This paper introduces the mechanism and principle of Socket network programs based on UDP protocol,and proposes a method of network with Java socket.
key words: UDP protocol;socket; network communication
Socket适用于网络环境中的进程间通信，它已成为当前许多操作系统的网络API，也是网络操作系统中必不可少的基础功能。随着Linux操作系统和Internet的不断发展，Linux网络环境下尤其是基于UDP的socket通信技术仍广为注目。文章介绍了socket的编程原理，并通过一个Java编写的客户/服务器程序，描述了网络中基于UDP的不同主机上的两个进程之间的socket通信机制。
1 Socket通信机制
Socket（套接字）机制是一种API，是网络应用程序的编程接口。Socket是通过标准文件描述符和其它程序通讯的一个方法。每一个套接字都用一个半相关描述：{协议，本地地址、本地端口}来表示；一个完整的套接字则用一个相关描述：{协议，本地地址、本地端口、远程地址、远程端口}，每一个套接字都有一个本地的由操作系统分配的唯一的套接字号。
根据传输数据类型的不同，Socket主要分为三类：1) 流式Socket（SOCK_STREAM），在这种方式下，两个通讯的应用程序之间要先建立一种虚拟的连接，提供可靠的、面向连接的通信流，它使用TCP协议，从而保证了数据传输的正确性和顺序的。2) 数据报Socket（SOCK_DGRAM），它使用数据报协议UDP，定义了一种无连接的服务，数据通过相互独立的报文进行传输，是无序的，并且不保证可靠、无差错。3) 原始Socket，原始套接字允许对底层协议如IP或ICMP直接访问，它功能强大但使用较为不便，主要用于一些协议的开发。
2 UDP协议的工作原理
UDP协议是一个面向无连接的协议，其连接的建立不必像TCP那样需要服务器端侦听，也不需要有客户机请求连接，属于一种“强制”性的网络连接。UDP提供一对一或一对多的、无连接的数据报服务。该服务对消息中传输的数据提供不可靠的、最大努力的传送，这意味着它不保证数据的到达，也不保证所传送的数据报的顺序是否正确，UDP不重新传输丢失的数据。其主要工作是：将应用程序传输过来的数据分块交给网络层，确认接受到分组信息。
尽管UDP无法像TCP一样提供可靠的数据传输，但UDP并不比TCP缺乏优越性。UDP在传输效率方面比TCP要高一些，而且许多应用程序并不需要保证严格的传输可靠性，比如视频会议系统等，需要实时的交互，但并不要求音频视频的绝对正确。
使用UDP协议传输数据时，首先设置客户计算机的Local Port(本地端口)属性，而作为服务器的计算机只需要设置Remoter Host(远程主机)属性为客户计算机的IP地址或域名即可，并将其Remote Port属性设置为客户计算机上的Local Port属性。使用UDP端口号时，端口提供了用于发送消息的位置，每个端口由一个唯一的编号来标识。当应用程序向另一台计算机发送数据时，UDP生成一个数据头，包括源端口，这些端口提供送达信息所需要的地址。UDP协议还为数据和数据头计算出求和检验的值，在目标计算机中，数据包被传递至UDP协议程序并送到目的地端口。
3 UDP套接字的通信过程
中提供了两个类DatagramSocket和DatagramPacket用来支持数据报通信。DatagramSoc ket用来在程序之间建立传送数据报的通信连接，是数据报通信中的Socket。在数据报实现C/S通信程序时，无论在客户端还是服务器端，都要首先建立一个DatagramSocket对象，用来表示数据报通信的端点，应用程序通过Socket接收或发送数据报。
DatagramPacket则用来表示一个数据报，它是传输数据的载体，封装了数据、数据长度、数据报地址等信息。
采用UDP套接字方式实现C/S的通信程序由客户端和服务器端两部分组成。服务器进程依次按以下步骤进行：1) 调用Socket()创建一个数据报套接字；2) 调用bind()把服务器地址绑定在该套接字上；3) 调用recvform()等待客户进程发来的请求，服务器此时处于无限循环状态；4) 服务进程接收到客户进程所发来的数据报后，进行处理，调用sendto()将处理结果返回给客户进程，返回状态3)，继续监听；5)服务进程调用close()撤消套接字，终止服务。
客户进程则按以下步骤进行：1) 调用Socket()创建一个数据流套接字；2) 调用sendto()向服务器进程发送数据报；3) 调用recvfrom()等待服务器进程返回该处理结果；4) 客户进程调用close()撤消套接字。
4 数据报通信实例
程序由服务器端和客户端两部分组成，服务器端主机中有一个名为“udp_socket.txt”文件，文件中保存了一段英文。服务器端接收一个客户端的请求，就从文件中读取若干个英文字符发送给客户端。当文件中所有内容发送给完毕，服务器端程序将退出。客户端首先构造一个数据报发送给服务器端，然后等待接受服务器端响应，当接收到服务器端的数据报后，显示数据并结束通信。
1) 服务器端程序
public class Server_Th
{ boolean m_q=true;
public void serverWork() throea IOException
{DatagramSocket ds=new DatagramSocket(2000)
//创建端口号为2000的数据报套接字
BufferedReader in=new BufferedReader(new FileReader (“udp_socket.txt”));
while(m_q)
{ byte buf[ ]=new byte[256];//创建缓冲区
DatagramPacket packet=new DatagramPacket (buf, buflength); //创建接收数据报对象
ds.receive(packet);//接收数据报
String dString=null;
if((dString=in.reaLine())==null)
{in.close();
m_q=false;
dString=”Good Morning!”;}
buf=dString.getBytes();//将数据存储到buf中
inetAddress address=packet.getAddress();
//得到客户端IP地址
int prot=packet.getPort();//得到客户端的端口
packet=new DatagramPacket (buf,buf.length, address. port );
//构造要发送数据报
ds.send(packet);//发送数据报
}
ds.close();//关闭
}
public void main(String args[])
{ Server_Th server=new Server_Th();
try
{server.serverWork();}
Catch(IOException e){}
}}
2) 客户端程序
public class Client_Th
{public void main(String args[ ]) throws IOException
{ DatagramSocket socket=new DatagramSocket( );
//创建套接字对象
byte buf[ ]=new byte[256];
InetAdress address=InetAddress.getByName(“20.14.30.9”);
//服务器IP地址
DatagramPacket packet=new DatagramPacket(buf,buf. Length,address,2000);//创建要发送的数据报对象
socket.send(packet);//接收数据报
packet=new DatagramPacket(buf,buf.length);
//创建要接收的数据报对象
socket.receive(packet);//接收数据报
String received=new String(packet.getData());
System.out.println(“The string form the server: ”+recerived);
//取得数据报中的数据并显示
Socket.close();//关闭socket
}}
编写程序时客户端和服务器端的DatagramSocket必须用一个端口，因为客户端向服务器端请求时，服务器需要知道从哪个端口监听请求。当数据进行传输时，服务器从接收到的数据报中得到客户端的接收数据的端口，然后将数据报发送到这个端口，客户端则监听这个端口而得到服务器端发送过来的数据报并显示其内容。运行时要先运行服务器端程序，再运行客户端程序。
5 小结
Socket在网络编程方面发挥着很大的作用。UDP是可靠性无法得到保障的协议，但对于质量要求不是很高的网络应用程序，UDP是一个很好的选择。
参考文献：
[1] 张桂珠.Java面向对象程序设计[M].北京:邮电出版社,2006.
[2] 周坤,傅德胜.基于Windows Socket的网络数据传输及其安全[J].计算机工程与设计,2007,28(22):5381-5386.
socket通信篇5
Abstract:Java is a kind of cross-platform, robust, safe, portable, adaptable to the distributed computer environment and object-oriented programming language, since Java program can convey by the network, and be operated on any client machine, network applications of Java Language development has been more and more widely used. In this paper, combined with the characteristics of Java network programming and based on TCP / IP protocol, several ways how to establish TCP Socker to complete the computer networks connection is introduced.
关键词:Java网络编程;TCP Socket ; 数据库
Key words:Java Network programming; TCP Socket; Data Base
中图分类号:TP31 文献标识码:A文章编号:1006-4311(2010)03-0154-01
1Java网络编程协议
Java网络编程的目的就是直接或间接地通过网络协议与其他计算机进行通讯,而广泛的应用之一就是连接到网络数据库上,从而获取网络资源。
网络上的计算机要互相通信,必须遵循一定的协议。Java网络编程支持现在广泛使用的网络协议:TCP/IP协议和UDP协议,但使用方法上是不同的。
1.1 使用TCP/IP协议
TCP/IP协议是一种面向连接的保证可靠传输的协议,通过TCP协议传输,得到的是一个顺序的无差错的数据流。发送方和接收方必须成对地建立两个socket连接,以便在TCP协议的基础上进行通信,当一个socket(通常都是server socket)等待建立连接时,另一个socket可以要求进行连接,一旦这两个socket连接起来,它们就可以进行双向数据传输,双方都可以进行发送或接收操作。
1.2 使用UDP协议
UDP协议是一种无连接的协议,不保证信息的可靠传输,由Java技术中的DatagramSocket和DatagramPacket类支持。DatagramSocket对应TCP/IP协议下的Socket概念,但不需要创建两个socket,不可使用输入输出流。DatagramPacket数据包,是UDP协议下进行传输数据的单位,数据存放在字节数组中,其中包括了目标地址和端口以及传送的信息(所以不用建立点对点的连接)。
由于TCP/IP协议能够提供可靠的数据传输,如何在发送方和接收方建立Socket连接是关键的步骤,下面我们介绍目前比较常用的Java程序中建立Socket的几种方法。
2基于TCP/IP协议的Socket连接方法
Java中Socket连接的建立是通过Socket类实现的,通过重载的构造函数可以直接连接服务器,也可以建立未连接的Socket对象,并通过connect方法来连接服务器。此外,还支持自动或手动方式选择本机的IP地址。
2.1 通过构造函数直接连接服务器
(1)自动选择IP。
这种方式是最常用的。使用的构造函数有如下两种:
在使用时只需要提供一个字符串类型的IP地址或域名以及一个整型的端口号即可,可能会抛出两个异常:UnknownHostException(提供的host并不存在或不合法)和IOException(其它的错误)。
这个构造函数只是将字符串形式的host改为InetAddress对象类型了,从而支持使用Socket类多次连接同一个IP或域名,效率比较高。在这个构造函数中只会发生IOException异常,UnknownHostException异常由InetAddress类抛出。
(2)手动绑定IP。
当本机有多块网卡或者在一个网卡上绑定了多个IP时,在连接服务器时也可以通过构造函数指定需要使用哪个IP。这时可以使用Socket类的另外两个构造函数来处理。
这两个构造函数的参数分为两部分,第一部分为前两个参数分别表示要连接的服务器的IP和端口号。第二部分为后两个参数,其中inetaddress1表示要使用的本地IP,而localPort则表示要绑定的本地端口号,在一般情况下将localPort设为0。
2.2 通过connect方法连接服务器
可以先建立未连接的Socket对象,再通过类的connect方法来连接服务器,还可以通过类的bind方法来绑定本地IP。
下面,通过一个实例来演示以上方法建立Socket连接。
假设有两台计算机:PC1和PC2。PC1绑定有两个IP:192.168.1.100和200. 200. 200.1。PC2绑定有一个IP:200. 200. 200.4。PC1和PC2的子网掩码都是255.255.255.0。而PC1的默认网关为:192.168.28.254。下面的代码需要在PC1上运行。
3综述
Java网络编程可以支持多种协议,而在TCP/IP协议下建立Socket连接也有多种方法,其中IP地址和网关的设置都会影响连接的建立,还需要在应用时由编程者保证代码执行后连接的建立,才能执行之后的收发双方I/O通道的建立及通信过程。
socket通信篇6
1.1 Linux下串口通信基本原理
Linux系统将设备和文件的操作都作为对文件的处理，所以对设备的操作，内核会返回一个文件描述符，需要将其作为参数传给相对应的函数。Linux中所有的设备文件都放在“/dev”目录下，通过“ttyS+编号”命名相应的串口资源，所以对应路径是“/devttyS*”。因而可以相对文件读写那样访问一个串口设备。
1.2 Linux下的串口设置
首先要对串口进行设置，在termios.h完成对波特率等的设置。
struct termios
{tcflag t c iflag；
tcflag t c oflag；
tcflag t c cflag；
tcflag t c lflag；
cc t c cc [NCCS]；
}；
open（ ）函数：int fd = open （"/dev/ttyS *"， O RDWR|O NOCTTY|O NDELA Y）；
然后调用read（ ）和write（ ）函数读写端口，返回实际读写的字节数，如果有错误发生则返回-1。
读取串口结束后，首先恢复串口原始属性，然后才可以关闭串口并退出程序。
1.3 串口控制应用程序
下面给出通过串口控制摄像头函数的一部分结构：
void sendMsg（int pan，int tilt）
{struct timeval timeout；
static char *driver = "/dev/ttyS1"；
timeout.tv_sec = 0；
timeout.tv_usec = 0；
formCmd（buf，pan，tilt）；
fd = uart_open（driver，B9600）；
write（fd，buf，16）；
close（fd）；
}
二、网络通信
2.1 Socket基本原理介绍
Socket是一种通信机制，客户/服务器系统既可以在本地单机上运行，也可以在网络中运行。
首先需要了解socket中的一些重要函数：（1）创建Socket：int socket（ intdomain， inttype， intprotocol）；（2）配置Socket：bind函数指定本地信息int bind（ intsocket， const structsockaddr* address， size_taddress_len）；（3）使用listen（ ）和accept（ ）函数获取远端信息：Int listen（int socket， int backlog）；Int accept（int socket， struct sockaddr* address， size_t* address_len）；（4）通信处理：send（ ），write（ ），recv（ ），read（ ）。（5） 通信结束：使用closesocket（ ）。
2.2 Windows和Linux下socket应用程序
客户端程序：创建一个未命名的套接字，然后把它连接到服务器套接字server_socket上，向服务器写一个字符，再读回经服务器处理后的一个字符。
服务器端程序：首先创建一个服务器套接字，绑定到一个名字，然后创建一个监听队列，接收来自客户程序的连接。下面我们分别在Windows和Linux下进行socket编程，实现二者之间的通信，具体函数实现的主要部分如下：
Windows下作为client端：
{
SocketClient=socket（AF_INET，SOCK_STREAM，0）；
addrSrv.sin_addr.S_un.S_addr=inet_addr（"192.168.1.10"）；
while（1）
send（SocketClient，sendBuffer，16，0）；
closesocket（SocketClient）；
WSACleanup（）；
}
Linux下作为server端：
{
server_sockfd = socket（AF_INET， SOCK_STREAM， 0）；
server_address.sin_addr.s_addr = inet_addr（"192.168.1.10"）；
bind（server_sockfd， （struct sockaddr *）&server_address， server_len）；
listen（server_sockfd， 5）；
client_sockfd = accept（server_sockfd， （struct sockaddr *）&client_address， &client_len）；
while（1）
read（client_sockfd， str，16）；
close（client_sockfd）；
}
socket通信篇7
本系统总体设计是客户端实现用户的注册和登陆界面设计与美化工作,利用Socket编程实现和服务器通信,服务器能处理客户端发出的请求,并能实现消息反馈。服务器实现与数据库连接,实现添加、删除和修改用户信息,实现多线程支持多个客户端用户同时在线。具体流程如下图:
2系统功能与实现
2.1功能设计
系统要求用户在登陆界面可以随时浏览企业的通知等动态信息,提供用户在日常生活中用到的日历、计算机等小工具,用户可以收藏自己感兴趣的网站并查看网页排名。用户在登陆前进行注册,为维护用户信息安全,需邮箱确认。为保证数据的安全性,采用C/S模式,通过服务器获取数据信息,减少客户端PC的运行负荷,充分发挥客户端PC的处理能力,提高响应速度 。
2.2模块分析
系统主要实现的功能模块有四个,分别是:用户桌面模块、系统管理模块、数据库模块、后台服务器模块。下面对这几个模块进行分析。用户桌面模块:用户桌面模块即客户端,用来显示主界面、注册界面、登录界面。主界面提供输入用户名、密码的登录操作;注册界面提供用户注册时需注册的姓名、性别、手机等基本信息;登录界面提供用户成功登录后显示企业的动态信息、用户日常使用的小工具及用户可以自己收藏的网站等。
系统管理模块:系统管理模块实现对系统进行维护和管理。数据库模块:数据库模块实现对整个系统的数据信息的存放和更新。后台服务器模块:后台服务器模块实现各模块之间数据的转发,实现多线程,完成数据更新,实现客户端、数据库及服务器三者的交互。
3系统实现的主要技术
3.1数据库设计
系统数据库配置是采用ODBC数据源加载SQL2008数据库,使用SQL数据库查询语言。数据库设计按照确定建立数据库目的和收集数据、建立概念模型、建立数据模型、实施与维护数据库四个步骤。
数据库模型采用关系(E-R)模型,关系模型是以二维表形式展现,对数据进行划分分析后,优化的关系数据模型的数据结构可分为3张表:表1(用户表)存放用户姓名、密码、邮箱等基本信息、表2(企业表)存放企业的通知等相关信息、表3(产品表)存放企业产品的编号、价格、库存等基本信息。
3.2客户端与服务器连接
客户端与服务器的连接是实现的难点。客户端是C#编写,客户端用C++编写。可以采用Socket编程。服务器端采用C++的Socket编程,完成对数据库SQL2008的登陆连接,保证数据库只存在于服务器端,通过对于不同权限的用户,设定不同的SQL执行权限,从而保证数据的安全性。客户端采用C#的Socket编程,利用TCP协议、与服务器端统一端口号与IP地址进行连接。具体步骤如下:服务器端:
(1)加载套接字库,创建Socket;
(2)绑定Socket到一个IP地址和端口;
(3)将Socket设置为监听模式等待连接请求;
(4)请求到来接受连接请求,返回一个新的对应于此次连接的Socket;
(5)用返回的Socket和客户端进行通信;
(6)关闭Socket,关闭加载的套接字库。
客户端:
(1)用指定的端口号和服务器IP创建一个EndPoint对象
(2)创建一个基于TCP协议的套接字;
(3)利用Socket对象的Connect()方法向服务器发送连接请求;
(4)如果连接成功,利用Socket对象的Send()方法向服务器发送消息;
(5)利用Socket对象的Receive()方法接收服务器发来的消息;
(6)通信结束,关闭Socket。控制流程:
socket通信篇8
[关键词] Socket TCP协议 服务器 客户端 线程
一、引言
随着信息技术的高速发展，网上交谈已成为人们学习和工作的重要手段，那么如何设计合理的、人性化的网上交谈工具就成为当务之急。使用Visual c#.NET中的Socket编程技术，以及多线程的知识可快速、方便地设计理想的网上交谈工具。一个Socket通信无论功能多么齐全、程序多么复杂，其基本结构均应包括以下步骤:创建Socket对象，建立连接;打开连接到Socket的输入/输出流;对Socket进行读写操作;关闭Socket套接字，关闭流。
二、TCP协议通信的流程
TCP协议是面向连接的协议，它的实现需要数据发送方和数据接收方建立数据通信连接，它的具体流程如下：
1.服务器端首先创建服务器套接字
2.服务器套接字监听一个端口，等待客户端的请求
3.客户端创建一个客户端套接字
4.客户端向服务器发送连接请求
5.服务器确认与客户端的连接
6.客户端和服务器利用建立的连接进行通信
7.通信完毕后，客户端和服务器关闭各自的连接
三、Socket编程简介
1.利用Socket建立服务器程序
要用Socket建立一个TCP服务器程序，一般需要以下几个步骤:
（1）创建一个服务器套接字，用IP地址和端口初始化服务器
（2）监听服务器端口
（3）确认与客户端的连接
（4）处理客户端的请求并回应客户端
（5）断开客户端的连接，释放客户端的连接
（6）关闭服务器，释放服务器连接
2.利用Socket建立客户端程序
要用Socket建立一个TCP客户端程序，一般需要以下几个步骤:
（1）创建客户端套接字
（2）连接服务器
（3）得到与服务器通信的流通道
（4）向服务器发送数据
（5）接收从服务器发回的数据
（6）断开连接
四、设计方案
1.服务器端的设计
服务器端管理着交谈任务，它维持着一张当前在线用户的列表，转发用户发送来的信息，主要功能如下：
监听本机IP地址中的一个指定的端口。
当有客户端向该端口发出请求时，服务器程序立即建立一个与该客户端的连接并启动一个新的线程来处理该客户端的所有请求。
根据客户端发送来的各种不同的请求，执行相应的操作，并将处理结果返回给该客户端。服务器能识别4种请求命令:CONN（建立新的连接）、CHAT(聊天）、PRIV(私聊)和EXIT(离开)，服务器接收ASCII字符信息，用“|”分隔信息的各个部分，一条信息包含一条命令，一个或多个信息参数。
2.客户端的设计
客户端应用程序包含用户登录窗口和用户交谈的主窗口，它允许用户登录到服务器，可以向服务器发送信息，同时可以接收从服务器返回的信息，设计的主要功能如下：
向远程服务器发送连接请求。
得到服务器程序的确认后，建立与服务器的连接，并获得与服务器交互的流通道（NetworkStream）。
通过网络流通道与服务器端的程序进行数据通信。向服务器发送服务器能够识别的以上4种命令请求，同时也接收服务器发回的命令。客户端能够识别的命令有JOIN（通知当前在线用户有新的用户进入聊天室）、LIST(更新当前在线用户)和QUIT(关闭客户端程序）。客户端程序接收ASCII字符信息，用“|”分隔信息的各个部分，一条信息包含一条命令，一个或多个信息参数。 转贴于
五、解决方案
1.服务器端的实现
服务器端是一个Windows窗体应用程序，命名为ChatServer。当运行服务器程序时，单击服务器窗体上的“启动”按钮后，便启动了服务器进程。为了使用Socket对象和Thread对象，在代码文件中加入名字空间System.Net、System.Net..Socket、System..Threading的引用。
在服务器端使用了多线程，每个用户通过一个单独的线程进行连接，当服务器开始运行时，它就启动一个线程等待客户连接（在方法StartListen()中实现）。当接收到一个请求时，服务器立即启动一个新的线程来处理和该客户端的信息交互（在方法ServiceClient()中实现）。自定义了一个Client类，它用于保存每个当前在线用户的用户名和与服务器连接的Socket对象。当Socket连接一旦建立，就马上将其保存在一个Client对象中，以便让每个用户有自己的Socket，以后可以对不同用户的Socket对象进行操作，实现与客户端的数据交换。
在服务器窗口中，单击“启动”按钮，进入btnStart_Click处理程序。在该处理程序中，创建了一个服务器套接字并且监听本机IP地址中的一个指定的端口，同时启动一个线程等待用户连接（在方法StartListen()中实现）。StartListen()方法是在新的进程中进行的操作，它主要用于当接收到一个客户端请求时，确认与客户端的连接，并且立即启动一个新的线程来处理和该客户端的信息交互（在方法ServiceClient()中实现）。ServiceClient()方法用于和客户端进行数据通信，包括接收客户端的请求，根据不同的请求命令，执行相应的操作，并将处理结果返回到客户端，此方法完成了服务器的主要的工作。SendToClient()方法实现了向客户端发送命令请求的功能，它利用不同用户保存的Socket对象，向对应的用户发送命令请求。GetUserList()方法实现了获取当前在线用户列表的功能，它通过对clients数组的遍历，获取当前在线用户的用户名，用字符串发回。
2.客户端的实现
客户端是一个Windows窗体应用程序，命名为ChatClient。当运行客户端程序时，首先进入登录界面，输入用户名，单击“登录”按钮后，进入交谈主窗口（命名为Login），在主窗口中可以向服务器发送信息，同时可以接收从服务器返回的信息。
(1)Login.cs文件的实现
Login.cs文件是登录窗体的代码文件，为了使用Socket对象，在代码文件中加入名字空间System.Net 、System.Net..Socket的引用，它主要实现了创建客户端套接字同时连接到服务器指定端口，把用户名和创建的客户端套接字传递给ChatClient窗体。
(2)ChatClient.cs文件的实现
ChatClient.cs文件是客户端窗体（ChatClient）的代码文件，在该文件中，首先获得与服务器通信的流通道，在用户登录后，向服务器发送CONN命令以此说明有新的用户进入交谈室，服务器将返回所有的当前在线用户的呢称，选择不同的人，就可以与他们交谈了，如果选中“悄悄话”复选框，则具有私人交谈的功能。
当加载ChatClient窗体时，便会进入ChatClientForm_Load处理程序。在该处理程序中，首先显示用户登录窗口。如果登录成功，那么获取与服务器的连接并得到与服务器数据交互的流通道，向服务器发送CONN请求命令，同时启动一个新的线程用于响应从服务器发回的信息（在方法ServerResponse()中实现）。ServerResponse()方法用于和服务器进行数据通信，主要是接收从服务器发回的信息，根据不同的命令，执行相应的操作。当需要进行“私人交谈” 时，便进入priCheckBox_CheckedChanged处理程序。在该处理程序中主要对privatemode的布尔属性进行设置。当需要发送信息时，便会进入btnSend_Click处理程序。在该处理程序中，如果privatemode的布尔属性值为false(不是私人交谈)，将CHAT命令发送给服务器；否则（为私人交谈），将PRIV命令发送给服务器。当用户需要离开时，便进入了btnExit_Click处理程序。在该处理程序中，将EXIT命令发送给服务器，停止交谈。
六、结束语
使用Socket编程的关键技术可以方便地实现网上交谈工具。利用Socket可以创建服务器程序和客户端程序。服务器监听本机IP地址中的一个指定的端口，建立与客户端的连接并启动一个新的线程来处理客户端的所有请求，执行相应的操作，并将处理结果返回给该客户端。客户端向远程服务器发送连接请求，得到服务器程序的确认后，建立与服务器的连接，并获得与服务器交互的流通道并通过网络流通道与服务器进行数据通信。我们可以进一步进行功能完善，进而编译成组件应用到自己的应用程序中，开发更完美的通信软件。
参考文献:
[1]谭桂华魏亮等:Visual C#高级编程范例.北京:清华大学出版社，2004年5月
socket通信篇9
关键词 JAVA，网络，SOCKET，APPLET
网络上的系统结构多为客户/服务器模式，服务器端负责数据和图像等的存储、维护、管理以及传递，客户端则负责人机界面的操作、送出需求及显示收回的数据。
下面介绍一下如何使用JAVA来进行网络编程：
1) 由于客户端通过IE同服务器建立联系，所以客户端使用Applet，服务器端使用Application；
2) 服务器应设置成多线程，应答多个客户的请求；
3) 两端通信使用SOCKET机制。
1 Java中输入/输出流概念：
过滤流DataInputStream 和DataOutputStream 除了分别作为FilterInputStream 和FilterOutputStream的子类外，还分别实现了接口DataInput 和DataOutput。接口DataInput 中定义的方法主要包括从流中读取基本类型的数据、读取一行数据、或者读取指定长度的字节数，如readBoolean() readInt()、readLine()、readFully()等。接口DataOutput中定义的方法主要是向流中写入基本类型的数据或者写入一定长度的字节数组，如writeChar()、writeDouble() DataInputStream可以从所连接的输入流中读取与机器无关的基本类型数据，用以实现一种独立于具体平台的输入方式；DataInputStream 可以向所连接的输出流写入基本类型的数据。
2 Socket 机制
Socket是面向客户/服务器模型设计的，网络上的两个程序通过一个双向的通讯连接实现数据的交换，这个双向链路的一端称为一个Socket。 Socket通常用来实现客户方和服务方的连接。客户程序可以向Socket写请求，服务器将处理此请求，然后通过Socket将结果返回给用户。
Socket通信机制提供了两种通讯方式：有联接和无联接方式，分别面向不同的应用需求。使用有联接方式时，通信链路提供了可靠的，全双工的字节流服务。在该方式下，通信双方必须创建一个联接过程并建立一条通讯链路，以后的网络通信操作完全在这一对进程之间进行，通信完毕关闭此联接过程。使用无联接方式时其系统开销比无联接方式小，但通信链路提供了不可靠的数据报服务，不能保证信源所传输的数据一定能够到达信宿。在该方式下，通信双方不必创建一个联接过程和建立一条通讯链路，网络通信操作在不同的主机和进程之间转发进行。
3 Java语言
Java语言的优点主要表现在：简单、面向对象、多线程、分布性、体系结构中立、安全性等方面。
(1) 简单性
Java与C++语言非常相近，但Java比C++简单，它抛弃了C++中的一些不是绝对必要的功能，如头文件、预处理文件、指针、结构、运算符重载、多重继承以及自动强迫同型。 Java实现了自动的垃圾收集，简化了内存管理的工作。这使程序设计更加简便，同时减少了出错的可能。
(2) 面向对象
Java提供了简单的类机制和动态的构架模型。对象中封装了它的状态变量和方法，很好地实现了模块化和信息隐藏；而类则提供了一类对象的原型，通过继承和重载机制，子类可以使用或重新定义父类或超类所提供的方法，从而既实现了代码的复用，又提供了一种动态的解决方案。
Java是一种完全面向对象的程序设计语言，它除了数组、布尔和字符三个基本数据类型外的其它类都是对象，它不再支持全局变量。在Java中，如果不创建新类就无法创建程序，Java程序在运行时必须先创建一个类的实例，然后才能提交运行。
Java同样支持继承特性，Java的类可以从其它类中继承行为，但Java只支持类的单重继承，即每个类只能从一个类中继承。
Java支持界面，界面允许程序员定义方法但又不立即实现，一个类可以实现多个界面，利用界面可以得到多重继承的许多优点而又没有多重继承的问题。
(3) 多线程
多线程使应用程序可以同时进行不同的操作，处理不同的事件。在多线程机制中，不同的线程处理不同的任务，他们之间互不干涉，不会由于一处等待影响其他部分，这样容易实现网络上的实时交互操作。
Java程序可以有多个执行线程，如可以让一个线程进行复杂的计算，而让另一个线程与用户进行交互，这样用户可以在不中断计算线程的前提下与系统进行交互。多线程保证了较高的执行效率。
(4) 分布性
Java是面向网络的语言。通过它提供的类库可以处理TCP/IP协议，用户可以通过URL地址在网络上很方便的访问其他对象。
(5) 体系结构中立
Java是一种网络语言，为使Java程序能在网络的任何地方运行，Java解释器生成与体系结构无关的字节码结构的文件格式。Java为了做到结构中立，除生成机器无关的字节码外，还制定了完全统一的语言文本，如Java的基本数据类型不会随目标机的变化而变化，一个整型总是32位，一个长整型总是64位。
为了使Java的应用程序能不依赖于具体的系统，Java语言环境还提供了用于访问底层操作系统功能的类组成的包，当程序使用这些包时，可以确保它能运行在各种支持Java的平台上。
java.lang: 一般的语言包。其中包括用于字符串处理、多线程、异常处理和数字函数等的类，该包是实现Java程序运行平台的基本包
java.util: 实用工具包。其中包括哈希表、堆栈、时间和日期等
java.io: 基于流模型的输入/输出包。该包用统一的流模型实现了各种格式的输入/输出，包括文件系统、网络和设备的输入/输出等
java.net: 网络包。该包支持TCP/IP协议，其中提供了socket、URL和WWW的编程接口
java.awt: 抽象窗口工具集。其中实现了可以跨平台的图形用户界面组件，包括窗口、菜单、滚动条和对话框等
java.applet: 支持applet程序设计的基本包
(6) 安全性
用于网络、分布环境下的Java必须要防止病毒的入侵，Java不支持指针，一切对内存的访问都必须通过对象的实例变量来实现，这样就防止了程序员使用欺骗手段访问对象的私有成员，同时也避免了指针操作中容易产生的错误。
4 JAVA工具
(1) JDK
1) Java编译器
Java编译器将Java源代码文件编译成可执行的Java字节码。Java源代码文件的扩展名为 .java，Java编译器把这种扩展名的文件编译成扩展名为.class的文件。源文件中的每个类在编译后都将产生一个class文件，这意味一个Java源代码文件可能编译生成多个class文件。
2) Java解释器
Java解释器对编译生成的字节码格式的可执行程序的运行提供支持，它是运行非图形Java程序的命令行工具。
3) Appletviewer
它是Java Applet的简单测试工具，可使用它来测试Java Applet程序，而不需要WWW浏览器的支持。
(2) Visual J++
Visual J++ 集成了可视化界面设计、交互式调试、代码编辑、联机帮助信息和介绍如何快速掌握该开发环境的实用向导等多项功能，同时具有能充分利用Active X和COM新技术的优势。利用Visual J++可创建交互性很强的Internet应用程序，是难得的Java 开发系统。
5 客户机/服务器通信的实现：
(1) Application 同 Applet 的通信
两端通过Socket机制进行连接：
1) 客户端的编程流程:
? 打开Socket，新建一个套接字；
? 为套接字建立一个输入和输出流；
? 根据服务器协议从套接字读入或向套接字写入；
? 清除套接字和输入/输出流；
2)服务器端的编程流程:
? 打开Server Socket，创建一个服务器型套接字和一个普通套接字，服务器型套接字在指定端口为客户端请求的Socket 服务；
? 使用ServerSocket类的accept()方法使服务器型套接字处于监听状态并把监听结果返回给普通套接字；
? 为该普通套接字创建输入和输出流；
? 从输入和输出流中读入或写入字节流，进行相应的处理，并将结果返回给客户端；
? 在客户端和服务器工作结束后关闭所有的对象，如服务器型的套接字，普通套接字，输入和输出流。
正是由于Java系统具有基于Socket的灵活通信机制，因而其应用程序能自由地打开和访问网络上的对象，就象在本地文件系统中一样。
(2) Applet之间的通信：
Applet之间的通信使用Applet Context类的getApplet()方法。
只要在程序中加入
Applet oneapplet=getAppletContext().getApplet(“first”);便可使用name为first的Applet中的方法了。
在该课题中大量使用了该种通信方法，因为专门同服务器端通信的 Applet中包含接收信息方法和发送信息方法，所有客户端的Applet都要使用负责通信的Applet中的方法，所以客户端的Applet同负责通信的Applet必须进行通信。
6 程序
//服务器端程序S.java 负责与客户端通信
import java.io.*;
import java.net.*;
import java.lang.*;
import T2;
class ThreadEchoHandler extends Thread //创建线程
{
T2 theT2=new T2();
Socket incoming;
int counter;
ThreadEchoHandler(Socket i，int c)
{ incoming=i;
counter=c; }
public void run()
{
try
{
DataInputStream in=new DataInputStream(incoming.getInputStream());
DataOutputStream out=new DataOutputStream(incoming.getOutputStream());
System.out.println ("hello");
boolean done=false;
while(!done)
{ String aa="";
String str=in.readUTF(); //从客户端得到字符串
//在此加入各自的服务程序
System.out.println (str);
theT2.pass(str); //解码
theT2.tongji(); //修改监控库中的信息
aa=theT2.guan(); //操纵数据库
System.out.println ("string z is:"+aa);
if(aa.compareTo("null")!=0 )
//若是查询数据库，返回查询后的结果
{ //若不是查询数据库，不向客户端输出信息
out.writeUTF(aa);
out.flush(); }
}//while
incoming.close(); //线程关闭
}//try
catch(IOException e)
{System.out.println(e);}
}//end run
}
//----------------------------------------
class S
{
public static void main(String[] args)
{
int i=1;
try
{
ServerSocket s=new ServerSocket(1111);
for(;;)
{
Socket incoming=s.accept();
System.out.println("connect: "+i);
new ThreadEchoHandler(incoming，i).start();
i++;
}
}
catch(Exception e)
{ System.out.println(e); }
}
}
//客户端通信小应用程序 Echo.java
import java.io.*;
import java.net.*;
import java.awt.*;
import java.applet.*;
public class Echo extends Applet
{
TextArea ta;
Socket echoSocket;
DataOutputStream os;
DataInputStream is;
String Line;
public void init()
{
setBackground(Color.white);
ta=new TextArea(5，80);
ta.setEditable(false);
add(ta);
try
{echoSocket=new Socket("10.102.4.41"，1111);} //与服务器建立连接
catch(IOException e)
{System.out.println("error");}
}
public void st(String stri) //发送字符串的方法
{
try
{ DataOutputStream os=new DataOutputStream(echoSocket.getOutputStream());
DataInputStream is=new DataInputStream(echoSocket.getInputStream());
os.writeUTF(""+ stri ); //向服务器输送string
os.flush();
}
catch(IOException e)
{System.out.println(" error:"+e); }
}
public String st1() //接收字符串的方法
{
String Line="";
try
{ DataOutputStream os=new DataOutputStream(echoSocket.getOutputStream());
DataInputStream is=new DataInputStream(echoSocket.getInputStream());
Line=is.readUTF(); //从服务器读来的信息
ta.appendText(""+Line); //在文本域中输出信息
}
catch(IOException e)
{System.out.println(" error:"+e); }
return Line;
}
}
7 程序调试心得：
1) 在建立Socket连接时，两端的端口号必须设为一致，否则建立不了连接。服务器端必须有主机IP地址或主机名参数。
2) 连接建立好之后应确定输入和输出流。起初程序中用的是DataInputStream和PrintStream，结果只能传输英文，传输中文时产生乱码，将PrintStream改为DataOutputStream，使用readUTF()和writeUTF()方法后，中文传输问题得到解决。
3) 如果一个使用某端口的程序没有关闭，另一个程序就不能使用这个端口。
4) 开始进行通信的程序均为 Application，因不符合客户机/服务器机制，应将客户端的Application改为Applet。其转化的主要步骤如下：
? 创建一个包含APPLET标签的HTML文件；
? 去掉应用程序中的main()方法；
? 类名应继承Applet类，而不是Frame类，并在程序开头加入
import java.applet.*;语句；
? 用init()方法代替Application程序中的构造方法，当浏览器创建Applet类对象的时候，它自动执行init()方法；
? 如Application中缺省使用了BorderLayout布局管理器，应在Applet的init()方法中重新设定；
? 如果Application中有setTitle()方法，必须将其去掉，如Application中使用了菜单，在Applet 中用按钮来替换。
5) 懂得了在一程序中如何引用自定义的类中的方法和变量，在程序开头加入import 类名；在程序中加入 类名 实例=new 类名(); 然后使用
实例.方法（），实例.变量即可。
参考文献
[1] 廖雷等，Java程序设计教程，中国电力出版社，2003
socket通信篇10
【 关键词 】 服务器；Java语言；实现
1 引 言
在Internet，现象广泛存在，可实现Internet和Intranet之间的数据通信，完成任务的软件，称为服务器（如Proxy Server）。服务器受理用户的服务请求，代替用户访问目标主机，并接收目标主机的响应，将响应结果传送给用户，在网内和网外之间充当桥梁的角色。
2 服务器
2.1 功能介绍
2.1.1 保护私有资源
服务器授权用户访问私有资源的同时，也保护私有资源。在某些虚拟专用网（VPN）设计中，所有客户端对私有服务器资源的访问均通过服务器实现，该服务器验证用户的合法性，访问私有服务器资源，并把结果按约定的方法加密后，在公共通道中传送给客户端。
在这样的系统中，私有服务器不接受除服务器之外的任何访问请求，这样服务器就起到了保护私有服务器，确保信息在公共通道中的私有性的作用。
2.1.2 网关
网关设备中的两个或多个网络接口可能是不同的物理介质或不同的协议体系结构，服务器的存在使得异构体之间的联通得以实现，即网关。
2.1.3 共享IP地址
局域网中的用户通过服务器访问Internet，对于Internet来说整个局域网所有用户共同使用同一个IP地址，即服务器的IP，无需租用过多的IP地址，这样将会给局域网用户节省大量申请IP的费用，降低网络的维护成本；同时也缓解了由于网络用户激增而造成IP地址资源紧张的问题。
2.1.4 客户访问防火墙保护的目标主机
防火墙将外部网络与内部网络隔离开，并对内网起保护作用。一般情况下防火墙禁止外网访问内网，对于合法用户访问内网造成困难，为此，互联网工作委员会专门制定了RFC1928，即SOCKSv5协议。SOCKS协议介于传输层与应用层之间，对用户进行验证和授权，使得合法用户可以透过防火墙访问受防火墙保护的目标主机。
2.1.5 管理大容量缓存
对WWW而言，为提高访问速率，服务器一般要管理一个大容量的缓存。缓存中若存在客户端请求的匹配项，则直接将请求内容返还给客户端；若无匹配项，则在客户请求内容中提取相应数据，然后向目标主机发出请求，再将目标主机的响应内容在缓存中备份并转发给客户说端。
2.1.6 用户管理
服务器要对所的客户进行管理，包括身份验证管理、流量控制管理、权限管理和计费管理等。当客户端发出访问请求时，服务器向客户端发验证请求，只有客户端通过验证，服务器才会代替客户端访问目标主机，否则关闭连接，这就是服务器的身份验证管理，基于这种验证机制，服务器完全控制了客户的请求和服务器的响应的所有信息，因此，流量控制管理、计费管理以及权限管理等诸多方面的用户管理是很方便的。
2.1.7 网络隔离
服务器的使用，使得所有内网客户对外网的访问，都由服务器代为执行，逻辑上实现了内网与外网的隔离，在此基础上，只要对服务器设置多网络端口、增加过滤、目标地址和源地址的控制等机制，可实现外网与内网物理上的隔离，起到防火墙的作用。
2.2 工作原理
服务器是防火墙（Firewall）的组成部分，它通过服务器软件（Proxy）管理和控制局域网内部的客户与Internet之间的信息交流。当局域网内某一客户机需要访问Internet时，首先向服务器发出访问请求，服务器对用户要求访问的IP地址进行分析过滤，若为允许访问的IP地址，则由服务器进入Internet，取回相应的信息并发送给局域网内的客户机，否则，服务器将拒绝访问。
服务器对信息的分析和过滤主要有统一资源定位URL（UniformResourceLo-cator）过滤器、多媒体邮件MIME（MultipurposeInternetMailExtensions）过滤器和超文本标识语言HTML（HyperTextMarkupLanguage）过滤器等方式，其中URL过滤器最为常用，它的实现有以下两种方式：第一种是在服务器中预先设置允许访问的IP地址或IP段，只有当用户申请访问的IP地址包含在此段中，服务器才给予访问；第二种方式是预先设置拒绝访问的IP地址或IP地址段，若用户申请访问的IP地址包含在这一段中，则服务器拒绝访问。
2.3 常见服务器
软件种类很多，WinGate、Ms Proxy Server、SyGate、Ccproxy等都应用广泛。其中WinGate是一种基于客户机/服务器方式的应用软件，支持大多数流行的Internet应用软件，如Netscape Navigator、Microsoft Internet explorer、Eudora、Netscape Mail以及常见的各种telnet和FTP工具。MS Proxy Server则是Cache型服务器软件，功能强大且全面，用于数据缓存使用量巨大的网络服务，如WWW浏览、FTP 下载等。SyGate是网关型服务器软件，常常充当网关角色。
3 基于Java的功能实现
1.1 Java语言
Java是一种允许跨平台撰写应用软件的面向对象程序设计语言，是Java程序设计语言和Java平台（即JavaSE， JavaEE， JavaME）的总称。Java技术具有卓越的安全性、高效性、通用性和平台移植性，广泛应用于个人PC、游戏控制台、互联网、科学超级计算机、数据中心和移动电话，具有面向对象、可移植、分布式、简单和安全等特点。
3.2 功能的实现
C/S模式，即客户/服务器模式，是目前应用最广泛的分布式体系结构，服务器是典型的C/S模式，功能的实现过程中，服务器充当服务器和客户端的双重角色。客户端的请求由服务器受理，此时服务器是一个服务器的角色，当服务器代替客户端向真正的目标服务器发出访问申请，此时，服务器又成为目标服务器的客户端，其连接示意图，如图1所示。
Java为我们提供了实现网络编程需要的Socket类，Socket是实现数据通讯的函数，有客户端和服务器端两种，客户端向服务器端发出Request，服务器端ServerSocket检测客户端的Request之后，先创建一个线程Socket服务器，然后开始由该Socket对象响应客户端最后返回一个Response。Socket服务器成功建立后，Java为我们提供的流操作可以很方便的读取数据。
为了构造服务器，考虑从 Thread 类派生出HttpProxy类，该类包含用来制定服务器行为的属性，见表1。
以下是HttpProxy 类的定义：
import .*；
import java.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 上创建一个线程：
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
服务器与Web服务器连接之后，利用循环在两个Socket线程之间传递数据，当数据为空时read方法调用过程中可能会导致程序挂起，为了防止这种情况，可以用setSoTimeout方法设置Socket的超时时间，来解决某个Socket不可用，另一个仍有机会进行处理，而不必创建新的线程的问题。
HttpProxy类的主要工作在run方法内完成，run方法其实是实现一个简单的状态机。run每次从Web浏览器读取一个字符，收集目标服务器相关信息，直到有足够的信息找出目标Web服务器。run根据收集到的信息打开通向目标Web服务器的Socket（如果存在多个服务器，run方法则打开下一个服务器的Socket），然后把请求写入Socket，再调用pipe方法，pipe方法此时在两个Socket间执行读写操作，以下是run方法的实现代码：
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类可以通过以下的main方法来测试：
static public void main（String args[]） {
System.out.println（"在端口 808 启动服务器＼n"）；
HttpProxy.log=System.out；
HttpProxy.logging=false；
HttpProxy.startProxy（808，HttpProxy.class）；}}
以下代码定义一个静态的startProxy方法，这个方法用到了一种特殊的技术，允许一个静态成员创建HttpProxy类（或 HttpProxy 类的子类）的实例。它把一个Class对象传递给startProxy类；然后startProxy方法利用映像API（Reflection API）和getDeclaredConstructor方法确定该Class对象的哪一个构造函数接受Socket参数；最后，startProxy方法调用newInstance方法创建该Class对象。
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 { java.lang.reflect.Constructor cons = clobj.getDeclaredConstructor（sarg）；
arg[0]=ssock.accept（）；
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。
4 结束语
通过服务器可以很方便地让局域网内的用户接入Internet，其应用非常广泛，在Java开发环境下实现服务器的功能，对于其他开发平台具有一定的参考意义。
参考文献
[1] 李洋.Linux下使用Socks v5服务[J].网管员世界，2011年13期.
[2] 周源邵，杨武杰等.Socks v5服务器运行模式的分析[J].计算机工程与应用，2003年39卷32期.
[3] 高铭达.利用delphi实现服务器的设计[J].Vol.4，No.1，October 2008，pp.86-87.
[4] 江红，余青松.Java程序设计教程[M].清华大学出版社，2012年11月.
[5] 范光远，辛阳.防火墙审计方案的分析与设计[J].信息网络安全，2012，（03）：81-84.
[6] Herbert Schildt.Java完全参考手册（第8版）[M]，清华大学出版社，2012年9月.
[7] 傅慧.动态包过滤防火墙规则优化研究[J].信息网络安全，2012，（12）：12-14.
[8] 王玉铎.Java语言在高校程序设计教学中的应用[J].计算机光盘软件与应用，2012年第22期.