socket实验报告
socket编程 实验报告
socket编程实验报告《Socket编程实验报告》在计算机网络通信中,Socket编程是一种常见的通信方式,它可以在不同的计算机之间实现数据的传输和通信。
本次实验旨在通过Socket编程实现一个简单的客户端和服务器端通信,并对其进行测试和分析。
实验环境:- 操作系统:Windows 10- 开发工具:Visual Studio Code- 编程语言:Python实验步骤:1. 设计客户端和服务器端的通信协议2. 编写客户端和服务器端的代码3. 运行客户端和服务器端,并进行通信测试4. 分析通信过程中的数据传输情况实验结果:经过实验,我们成功实现了一个简单的客户端和服务器端通信程序。
在测试过程中,我们发现数据可以正常地在客户端和服务器端之间传输,而且通信过程稳定可靠。
分析:通过本次实验,我们深入了解了Socket编程的基本原理和实现方式。
Socket编程可以灵活地实现不同计算机之间的通信,为网络通信提供了重要的技术支持。
在实际应用中,Socket编程可以用于实现各种网络通信功能,如网页浏览、文件传输、视频流等。
总结:通过本次实验,我们对Socket编程有了更深入的了解,并掌握了基本的编程技巧和调试方法。
Socket编程是网络通信中的重要技术,对于计算机网络领域的学习和应用具有重要的意义。
希望通过今后的实践和学习,我们能够进一步深化对Socket编程的理解,为网络通信技术的发展做出贡献。
通过本次实验,我们对Socket编程有了更深入的了解,并掌握了基本的编程技巧和调试方法。
Socket编程是网络通信中的重要技术,对于计算机网络领域的学习和应用具有重要的意义。
希望通过今后的实践和学习,我们能够进一步深化对Socket编程的理解,为网络通信技术的发展做出贡献。
实验三Socket通信实验报告
实验三Socket 通信实验报告1)实验目的和要求1. 掌握VB、VC++、VS 或JAVA 等集成开发环境编写网络程序的方法;2. 掌握客户/服务器(C/S)应用的工作方式;3. 学习网络中进程之间通信的原理和实现方法;4. 理解单播、组播和广播的原理并比较其不同之处;5. 要求本机既是客户端又是服务器端;2)实验内容所编写的程序应具有如下功能:1. 具有点对点通信功能,任意客户端之间能够发送消息;2. 具有群组通信功能,客户端能够向组内成员同时发送消息,其他组成员不能收到;3. 具有广播功能,客户端能够向所有其他成员广播消息;3)编程语言和环境1. 编程语言C/C++/C#/Java 等均可;2. 编程环境Windows (MS Visual 系列,VC/VB/ ;)和Linux (编辑器vi+编译器GCC )均可;4)实验主要功能实现说明以下为针对三个实验内容实现方法的简要说明,示例所用语言为C。
基于 C 的面向连接的socket 编程模型1. 点对点通信功能实现网络点对点通讯程序的关键步骤就是实现信息在网络中的发送和接收。
数据接收使用的是Socket,数据发送使用的是NetworkStream 。
1.1 利用Socket 来接收信息TcpListener tlListen1 = new TcpListener ( 8889 ) ;// 侦听端口号tlListen1.Start ( ) ;Socket skSocket = tlListen1.AcceptSocket ( ) ;// 接受远程计算机的连接请求,并获得用以接收数据的Socket 实例EndPoint tempRemoteEP = skSocket.RemoteEndPoint ;// 获得远程计算机对应的网络远程终结点while ( true ){Byte [] byStream = new Byte[80] ;// 定义从远程计算机接收到数据存放的数据缓冲区int i = skSocket.ReceiveFrom ( byStream , ref tempRemoteEP ) ;// 接收数据,并存放到定义的缓冲区中string sMessage = System.Text.Encoding.UTF8.GetString ( byStream ) ;// 以指定的编码,从缓冲区中解析出内容MessageBox.Show ( sMessage ) ;// 显示传送来的数据1.2 利用NetworkStream 来传送信息TcpClient tcpc = new TcpClient ( "10.138.198.213" , 8888 ) ;// 对IP 地址为“10.138.198.213 ”的计算机的8888 端口提出连接申请NetworkStream tcpStream = tcpc.GetStream ( ) ;// 如果连接申请建立,则获得用以传送数据的数据流string sMsg = " 您好,见到您很高兴" ;StreamWriter reqStreamW = new StreamWriter ( tcpStream ) ;// 以特定的编码往向数据流中写入数据, 默认为UTF8 编码reqStreamW.Write ( sMsg ) ;// 将字符串写入数据流中reqStreamW.Flush ( ) ;// 清理当前编写器的所有缓冲区,并使所有缓冲数据写入基础流2. 群组通信功能组播编程需要UDP ,有两个类支持组播网络编程Socket 和UdpClient. 一台计算机要加入某一个组,然后接收发往这个组的信息。
Socket通信实验
《网络通信程序设计》上机实验报告实验名称: Socket编程班级:软件112 姓名:周航学号: 1110290054 上机时间: 2013.03.03. 指导教师:王华一、实验内容或题目:(1).套接字相关类的使用1.创建一个具有服务器IP地址和端口号的Socket对象。
Socket soc=newSocket("localhost",4001);2.客户端接受输入。
3.客户端向服务器发送请求。
4.关闭PrintStream和Socket对象(2).修改本阶段的第一部分中完成的程序,是服务器将向客户端返回响应。
二、实验目的与要求:掌握套接字相关类的使用,掌握Web相关类的使用。
三、实验步骤与源程序:(1)实验步骤a) 编辑FClient.java和FServer.javab) 编译FClient.java和FServer.javac) 先运行FServer.java等待客户端请求,然后运行FClient.java(2)源代码题目1FClient.javapublic class FClient {public static void main(String[] args) throws Exception {Socket soc=new Socket("localhost",4001);BufferedReader br=new BufferedReader(newInputStreamReader(System.in));System.out.println("请输入消息至服务器");String message="";String temp;while(!(temp=br.readLine()).equals("send")){message=message+temp+"\n";}PrintStream ps=new PrintStream(soc.getOutputStream());ps.print(message);ps.close();soc.close();}}FServer.javapublic class FServer {public static void main(String []args)throws Exception{ServerSocket ss=new ServerSocket(4001);Socket soc=ss.accept();BufferedReader br=new BufferedReader(newInputStreamReader(soc.getInputStream()));String message="";String temp=null;do{temp=br.readLine();if(temp==null){break;}message=message+temp;}while(true);br.close();PrintStream ps=new PrintStream(new FileOutputStream("message.txt"));ps.println(message);ps.close();System.out.println("已存储消息");}}题目2:FClient.javapublic class FClient {public static void main(String[] args) throws Exception {Socket CTS=new Socket("localhost",9090);//将数据输入流连接到socket上DataInputStream IFS=new DataInputStream(CTS.getInputStream());//将数据输出流连接到socket上PrintStream OTS=new PrintStream(CTS.getOutputStream());//将信息放到Socket输出流中OTS.print("尝试连接服务器");System.out.println("尝试连接服务器");//清空缓冲区,立即发送OTS.flush();boolean goon=true;while(goon){String instr=IFS.readUTF();if(instr.equals("连接成功")){System.out.println("连接成功");goon=false;}}//退出循环IFS.close();OTS.close();CTS.close();}}FServer.javapublic class FServer {public static void main(String []args)throws Exception{System.out.println("等待连接");ServerSocket ss=new ServerSocket(9090);//侦听来自客户端的请求Socket CTC=ss.accept();//关联socket 输入输出流DataInputStream IFC=new DataInputStream(CTC.getInputStream());DataOutputStream OTC=new DataOutputStream(CTC.getOutputStream());OTC.writeUTF("连接成功");OTC.flush();IFC.close();OTC.close();ss.close();}}四、测试数据与实验结果题目1题目2五、总结:通过这次实验,我初步了解了Socket的使用,datagramSocket类可以实现面向连接的通信和无连接的客户端和服务器套接字,DatagramPacket可以构造udp无连接的数据报报文。
Socket通信实验
中南大学计算机网络实验报告———Socket通信实验专业:计算机科学与技术班级:姓名:学号:一、实验目的与要求1、掌握VB、VC++、VS或JAVA等集成开发环境编写网络程序的方法;2、掌握客户/服务器(C/S)应用的工作方式;3、学习网络中进程之间通信的原理和实现方法;4、理解单播、组播和广播的原理并比较其不同之处;5、要求本机既是客户端又是服务器端;二、实验内容与原理实现实验内容:1、具有点对点通信功能,任意客户端之间能够发送消息;2、具有群组通信功能,客户端能够向组内成员同时发送消息,其他组成员不能收到;3、具有广播功能,客户端能够向所有其他成员广播消息;实验原理:Socket即为网络上的两个程序通过一个双向的通信连接实现数据的交换,这个双向链路的一段成为一个socket。
Socket通常用来实现客户端和服务端的连接。
它既能接受请求,也能发送请求。
在我选择使用java语言中,有专门的SocketServer类和Socket类来处理用户的请求和响应。
网络编程是通过使用套接字来达到进程间通信目的的编程,Socket编程是网络编程的主流工具,Socket API是实现进程间通信的一种编程设施,也是一种为进程间提供底层抽象的机制,提供了访问下层通信协议的大量系统调用和相应的数据结构。
三、实验的具体设计1、建立连接1)服务程序调用socket创建一个新的套接字,并在传输层实体中分配表空间,返回一个文件描述符用于以后调用中使用该套接字;调用bind将一个地址赋予该套接字,使得远程客户程序能访问该服务程序;调用listen分配数据空间,以便存储多个用户的连接建立请求;调用accept将服务程序阻塞起来,等待接收客户程序发来的连接请求。
当传输层实体接收到建立连接的TPDU时,新创建一个和原来的套接字相同属性的套接字并返回其文件描述符。
服务程序创建一个子进程处理此次连接,然后继续等待发往原来套接字的连接请求。
计算机网络socket编程实验报告
Socket编程实验报告一、程序代码(1)服务器端#include <stdio.h>#include <Winsock2.h>#pragma comment(lib, "ws2_32.lib")void main(){ WORD wVersionRequested;WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );if ( err != 0 ) { return; }if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ){ WSACleanup( );return; }SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);SOCKADDR_IN addrSrv;addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000);bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));// 绑定端口listen(sockSrv,SOMAXCONN); //SOMAXCONN由系统确定请求数SOCKADDR_IN addrClient;// 连接上的客户端ip地址int len=sizeof(SOCKADDR);while(1){SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);// 接受客户端连接,获取客户端的ip地址char sendBuf[50];sprintf(sendBuf,"Welcome %s tohere!",inet_ntoa(addrClient.sin_addr));// 组合消息发送出去send(sockConn,sendBuf,strlen(sendBuf)+1,0);// 发送消息到客户端char recvBuf[50]; recv(sockConn,recvBuf,50,0);// 接受客户端消息printf("%s\n",recvBuf);closesocket(sockConn);WSACleanup();//断开连接}}(2)客户端代码#include <stdio.h>#include <Winsock2.h>#pragma comment(lib, "ws2_32.lib")void main(){WORD wVersionRequested;WSADATA wsaData;//WSAata用来存储系统传回的关于WinSocket的资料。
Socket通信实验报告
FD_ZERO,FD_SET,FD_ISSET,FD_CLR,select 共 5 个函数。 FD_ZERO 用于把列表初始化,即清零。 FD_SET 把一个 socket 加入到列表中 FD_ISSET 用来判断调用 FD_ISSET 时指定的 socket(由调
但如果服务器端ip是内网地址则程序实现局域网内聊天对于ip本次实验服务器端源代码使用c语言编写c语言的主要优点是效率高能够提供服务器端需要的执行能力支持较多用户同时在线完成socket的建立连接中转客户间的数据进行通信
Socket 通信实验: 使用 socket 进行通信程序设计
姓名:于广溪 学号:11300720070 系别:通信科学与工程 日期:2013 年 11 月 7 日
3) 多线程简介 线程的概念是指一个计算活动的执行过程。当程序的
代码指令装入内存后,操作系统允许多个线程(进程)执 行这段代码。每个线程都有一个自己的指令指针和本地变 量,它们共享一份全局变量(进程则所有资源都是独立 的)。多线程的操作系统把 CPU 资源划分成若干时间片, 以一定规则流转时间片。一个线程(进程)执行一小片时 间,然后另一个线程得到执行。在 1 秒内可以完成以千为 数量的轮转所以若干线程(进程)就好像一直在得到执行
用时的第一个参数指定)在不在列表中,即判断此 socket 是 否可读写。
FD_CLR 用来将指定的 socket(由调用时的第一个参数指 定)清除出列表。
Select 用来进行检测,其定义如下: int select( _In_ int nfds, Inout_ fd_set *readfds,
_Inout_ fd_set *writefds, _Inout_ fd_set *exceptfds, _In_ const struct timeval *timeout
计算机网络socket编程实验报告
计算机网络socket编程实验报告
实验报告
黑龙江大学教务处
黑龙江大学计算机科学与技术专业、软件工程专业
《计算机网络》课程实验报告
学号20111913 姓名陈声晓班级1班
实验时间 4.16-4.30第1节-第2节
实验名称Socket通信
实验内容在一台计算机上实现两个程序的通信
一、实验目的
掌握Windows通信程序的编写,通信原理,实际编写通信程序,本试验是后续实验的基础。
做到在一台计算机上实现两个程序的通信。
二、实验环境
Windows xp/7
三、主要设计思想与算法
1.服务器创建socket,并规定通信的端口号(大于1024),等待客户端的连接。
2.客户端创建socket,通过端口号连接服务端。
3.客户端向服务端发送接收数据。
4.服务端接收发送数据。
5.通信结束,客户端和服务端关闭socket。
6.Socket通信流程:
四、实验结果(测试用例、实验结果)
五、实验总结
计算机网络通信利用java语言编写时,用到的技术室socket技术。
任何一个socket程序都至少包含客户端程序和服务端程序。
通过IP地址和端口号,实现了两台计算机之间的链接,然后才可以根据具体需要实现通信。
运行时先运行服务器程序,不难理解,客户端没有开放,就无法连接。
socket通信实验报告
socket通信实验报告socket通信实验报告一、引言在计算机网络领域,Socket通信是一种常见的网络通信方式。
通过Socket,可以实现不同计算机之间的数据传输和通信。
本实验旨在通过搭建一个简单的Socket通信系统,了解Socket通信的基本原理和实现方式,并通过实验验证Socket通信的可行性和效果。
二、实验目的1. 了解Socket通信的基本原理和概念;2. 掌握Socket通信的编程实现方法;3. 验证Socket通信的可行性和效果。
三、实验环境和工具1. 实验环境:Windows操作系统;2. 编程语言:Python;3. 开发工具:PyCharm。
四、实验步骤1. 创建Socket服务器:首先,我们需要创建一个Socket服务器,用于监听客户端的连接请求。
在Python中,可以使用socket库来实现Socket服务器的创建。
通过指定IP地址和端口号,服务器可以监听指定的网络地址。
在实验中,我们选择使用本地回环地址(127.0.0.1)和一个自定义的端口号(例如8888)来创建Socket服务器。
2. 等待客户端连接:Socket服务器创建成功后,需要等待客户端的连接请求。
服务器通过调用socket的accept()方法来等待客户端的连接。
一旦有客户端连接成功,服务器将返回一个新的Socket对象,用于与客户端进行通信。
3. 客户端连接:在另一台计算机上,我们创建一个Socket客户端,用于连接到服务器。
客户端通过指定服务器的IP地址和端口号,调用socket的connect()方法来与服务器建立连接。
4. 数据传输:一旦客户端和服务器成功建立连接,它们就可以进行数据传输了。
在实验中,我们可以通过客户端向服务器发送数据,服务器接收并处理数据,然后将处理结果返回给客户端。
5. 断开连接:当数据传输完成后,客户端和服务器可以选择断开连接。
在Python中,可以通过调用socket的close()方法来关闭连接。
socket实验报告
中南大学Socket通信实验公共网络络班级信息安全0901学生王树雄学号0909090128教师王伟平【实验目的】理解Socket的基本概念工作原理,掌握Socket的建立、监听、连接、发送数据和接收数据。
【实验内容】采用Java(c++或者c语言)语言编写网络上的点对点的Socket程序。
该程序必须能在服务器端实现监听连接请求,客户端实现发送连接请求的功能,在建立连接后进行发送和接收数据的功能。
【实验要求】实验课时为4学时。
要求完成在服务器端和客户端的源程序的编写,并作出分析。
具体要求如下:1、服务器端建立一个Socket,设置好本机的IP和监听的端口与Socket进行绑定,开始监听连接请求,当接收到连接请求后,发出确认,同客户端建立连接,开始与客户端进行通信。
2、客户端建立一个Socket,设置好服务器端的IP和提供服务的端口,发出连接请求,在收到服务器的确认后,建立连接,开始与服务器端进行通信。
3、服务器端和客户端的连接及它们之间的数据传送均采用同步方式。
【基本概念】网络上的两个程序通过一个双向的通信连接实现数据的交换,这个双向连路的一端成为一个Socket。
Socket通常用来实现客户方和服务方的连接。
它既可以接受请求,也可以发送请求,利用它可以较为方便的编写网络上数据的传递。
在Java等语言中,有专门的Socket类来处理用户的请求和响应。
利用Socket类的方法,就可以实现两台计算机之间的通讯。
【演示界面】主界面注册界面【总结感悟】用到了java语言已经提供好的socket类进行调用,这在很大程度上方便了我们的操作,遇上的问题是注册在文件里面和登陆的时候从文件里面调取。
还有多道线程方面的处理问题。
以及界面等方面的内容,当然,设计到的专业知识是tcp 方面的,也就是面向连接的,也可以用udp来进行通信。
SOCKET实验报告
实验报告实验一 socket编程一、实验目的通过socket程序的编写、调试,掌握socket编程的基本方法,了解客户端与服务器端的特点,掌握并熟悉运用socket类与serversocket类。
二、实验内容①学习socket编程使用的类和接口,着重掌握基于tcp协议的socket。
②编写服务器端的应用程序③编写客户端的应用程序④实现服务器端与客户端的交互三、实验代码1.服务器端程序过程:在端口5000上创建一个等待连接的serversocket对象server:server=newserversocket(5000);接着调用server对象的accept()方法等待某客户程序发出连接请求。
该方法一直阻塞直到有客户连接到带端口。
一旦有客户发送正确请求,则连接成功,accept()方法返回一个socket对象,于是得到了一个新的用于通信的socket对象,通信链路建立成功。
然后利用socket类提供的方法创建socket对象的输入流和输出流。
此后即于客户端进行通信,直到客户端断开连接即关闭各个流结束通信。
代码如下:import .*;import java.io.*;class aa{static public void main (string args[]) throws ioexception {serversocket server=null;socket socket=null;inputstream is=null;outputstream os=null;datainputstream in=null;printstream out=null;try{ //在端口5000注册服务server=new serversocket(5000); socket =server.accept();//侦听连接请求,等待连接system.out.println(**********************服务器端界面*************************);system.out.println(与客户端连接成功!); system.out.println();system.out.println(对话内容为:); system.out.println();system.out.println(等待客户发送信息.....); //获取对应的socket的输入/输出流is=socket.getinputstream();os=socket.getoutputstream(); //建立数据流in= new datainputstream(is); out =new printstream(os);//表示向对方输出string str=in.readline();//逐行读取do{system.out.println(客户端说:+ str); str=in.readline();}while(str.trim().equals(bye)) //如果是“bye”就退出system.out.println(客户想要离开); }catch(exception e) //捕获程序异常{system.out.println(error:+e); }finally{is.close();//关闭输入流os.close();//关闭输出流in.close();//关闭数据输入流socket.close();//关闭socket }}}2.客户端程序过程:首先创建一个指向服务器的指定端口号(5000)的socket对象socket:socket=newsocket(localhost,5000);此时服务器指定为本地计算机,若要在网络中指定服务器,只需要将参数localhost改成相应的服务器名或者ip地址即可。
网络工程网络编程实验报告2-Socket编程
《网络编程》实验报告实验序号:02 实验项目名称:Socket编程学号姓名专业、班20网络工程实验地点指导教师实验时间2022一、实验目的及要求掌握Socket编程的基本原理,调试并在代码标注注释:(1) ServerSocket, ClientSocket(2) SimpleClient, SimpleServer(3) PortScanner(4) Sender, Receiver(5) SenderClient, ReceiverSever二、实验设备(环境)及要求一台Windows XP、JDK1.6、MyEclipse 8.5三、实验内容与步骤1运行ServerSocket, ClientSocket2.第二个实验,第三次连接不成功的原因是:客户端建立了三个不同的连接,而服务端只有两个。
3.第三个实验是扫描1-1024端口有没有被服务器监听。
4.判断连接结束方式5.设置睡眠时间四、实验结果与数据处理1运行ServerSocket, ClientSocket2.第二个实验,第三次连接不成功的原因是:客户端建立了三个不同的连接,而服务端只有两个。
3.第三个实验是扫描1-1024端口有没有被服务器监听。
4.判断连接结束方式5.设置睡眠时间四、实验结果与数据处理附源程序清单:1. EchoServerpackage Hello;import java.io.*;import .*;public class EchoServer {private int port=8000;//监听端口号private ServerSocket serverSocket;public EchoServer() throws IOException {serverSocket = new ServerSocket(port);//创建一个SocketSystem.out.println("服务器启动");}public String echo(String msg) {return "echo:" + msg;}private PrintWriter getWriter(Socket socket)throws IOException{////参数socket 表示每写一行,PrintWriter缓存就自动溢出,把数据写到目的地OutputStream socketOut = socket.getOutputStream();return new PrintWriter(socketOut,true);}private BufferedReader getReader(Socket socket)throws IOException{InputStream socketIn = socket.getInputStream();//获得输入流,获得用户的请求//数据流输入return new BufferedReader(new InputStreamReader(socketIn));}public void service() {while (true) {Socket socket=null;try {socket = serverSocket.accept(); //等待客户连接System.out.println("New connection accepted "+socket.getInetAddress() + ":" +socket.getPort());BufferedReader br =getReader(socket);PrintWriter pw = getWriter(socket);String msg = null;while ((msg = br.readLine()) != null) {System.out.println(msg);pw.println(echo(msg));if (msg.equals("bye")) //如果客户发送消息为“bye”,就结束通信break; }}catch (IOException e) {e.printStackTrace();}finally {try{if(socket!=null) socket.close(); //断开连接}catch (IOException e) {e.printStackTrace();}} } }// service() 方法结束public static void main(String args[])throws IOException {new EchoServer().service();}}import .*;import java.io.*;import java.util.*;public class EchoClient {//创建客户端private String host="localhost";//当参数host 的取值为“localhost”,表示EchoClient与EchoServer进程运行在同一个主机上private int port=8000;//监听端口号8000private Socket socket;public EchoClient()throws IOException{socket=new Socket(host,port); //建立连接}public static void main(String args[])throws IOException{//输入输出new EchoClient().talk();}private PrintWriter getWriter(Socket socket)throws IOException{//发送数据OutputStream socketOut = socket.getOutputStream();//获得输出流return new PrintWriter(socketOut,true);}private BufferedReader getReader(Socket socket)throws IOException{InputStream socketIn = socket.getInputStream(); //获得输入流return new BufferedReader(new InputStreamReader(socketIn));}public void talk()throws IOException {try{BufferedReader br=getReader(socket);PrintWriter pw=getWriter(socket);BufferedReader localReader=new BufferedReader(new InputStreamReader(System.in));String msg=null;while((msg=localReader.readLine())!=null){pw.println(msg);System.out.println(br.readLine());if(msg.equals("bye"))break;}}catch(IOException e){e.printStackTrace();}finally{//关闭流和连接try{socket.close();}catch(IOException e){e.printStackTrace();} }}}2. .SimpleClientimport java.io.*;import .*;public class SimpleClient {public static void main(String args[])throws Exception {Socket s1 = new Socket("localhost",8000);System.out.println("第一次连接成功");Socket s2 = new Socket("localhost",8000);System.out.println("第二次连接成功");Socket s3 = new Socket("localhost",8000);System.out.println("第三次连接成功");}package Hello;import java.io.*;import .*;public class SimpleServer {public static void main(String args[])throws Exception {ServerSocket serverSocket = new ServerSocket(8000,2); //连接请求队列的长度为2Thread.sleep(360000); //睡眠6分钟}}3. import .*;import java.io.*;public class PortScanner { public static void main(String args[]){String host="localhost";//当参数host 的取值为“localhost”,表示Client与Server进程运行在同一个主机上if(args.length>0)host=args[0];new PortScanner().scan(host);}public void scan(String host){//扫描1-1024端口Socket socket=null;for(int port=1;port<1024;port++){try {//try catch语句判断输出socket = new Socket(host, port);System.out.println("There is a server on port "+port);//如果有连接There is a server on port,} catch (IOException e) {System.out.println("Can't connect to port "+port);//如果没有连接Can't connect to port} finally {try {if(socket!=null)socket.close();//断开连接} catch (IOException e) {e.printStackTrace();}}}}4. Senderimport java.io.*;import .*;public class Receiver { private int port=8000;private ServerSocket serverSocket;private static int stopWay=1; //结束通信的方式private final int NATURAL_STOP=1; //自然结束private final int SUDDEN_STOP=2; //突然终止程序private final int SOCKET_STOP=3; //关闭Socket,再结束程序private final int INPUT_STOP=4; //关闭输入流,再结束程序private final int SERVERSOCKET_STOP=5; //关闭ServerSocket,再结束程序public Receiver() throws IOException {serverSocket = new ServerSocket(port);System.out.println("服务器已经启动");}private BufferedReader getReader(Socket socket)throws IOException{ InputStream socketIn = socket.getInputStream();return new BufferedReader(new InputStreamReader(socketIn));}public void receive() throws Exception{Socket socket=null;socket = serverSocket.accept();BufferedReader br =getReader(socket);for(int i=0;i<20;i++) {String msg=br.readLine();System.out.println("receive:"+msg);Thread.sleep(1000);if(i==2){ //终止程序,结束通信if(stopWay==SUDDEN_STOP){System.out.println("突然终止程序");System.exit(0);}else if(stopWay==SOCKET_STOP){System.out.println("关闭Socket并终止程序");socket.close();break;}else if(stopWay==INPUT_STOP){System.out.println("关闭输入流并终止程序");socket.shutdownInput();break;}else if(stopWay==SERVERSOCKET_STOP){System.out.println("关闭ServerSocket并终止程序");serverSocket.close();break;}}}if(stopWay==NA TURAL_STOP){socket.close();serverSocket.close();}}public static void main(String args[])throws Exception {if(args.length>0)stopWay=Integer.parseInt(args[0]);new Receiver().receive();}}Receiverimport .*;import java.io.*;import java.util.*;public class Sender {private String host="localhost";private int port=8000;private Socket socket;private static int stopWay=1; //结束通信的方式private final int NATURAL_STOP=1; //自然结束private final int SUDDEN_STOP=2; //突然终止程序private final int SOCKET_STOP=3; //关闭Socket,再结束程序private final int OUTPUT_STOP=4; //关闭输出流,再结束程序public Sender()throws IOException{socket=new Socket(host,port);}public static void main(String args[])throws Exception{if(args.length>0)stopWay=Integer.parseInt(args[0]);new Sender().send();}private PrintWriter getWriter(Socket socket)throws IOException{ OutputStream socketOut = socket.getOutputStream();return new PrintWriter(socketOut,true);}public void send()throws Exception {PrintWriter pw=getWriter(socket);for(int i=0;i<20;i++){String msg="hello_"+i;pw.println(msg);System.out.println("send:"+msg);Thread.sleep(500); //捕捉异常if(i==2){ //终止程序,结束通信if(stopWay==SUDDEN_STOP){System.out.println("突然终止程序");//输出System.exit(0);}else if(stopWay==SOCKET_STOP){System.out.println("关闭Socket并终止程序");//输出socket.close();break;}else if(stopWay==OUTPUT_STOP){socket.shutdownOutput();System.out.println("关闭输出流并终止程序");//输出break;}}}if(stopWay==NATURAL_STOP){socket.close();}}}5 SendClientimport java.io.*;import .*;public class SendClient {public static void main(String args[])throws Exception {Socket s = new Socket("localhost",8000);OutputStream out=s.getOutputStream();out.write("hello ".getBytes());out.write("everyone".getBytes());Thread.sleep(60000); //睡眠1分钟s.close();}}package Hello;import java.io.*;import .*;public class ReceiveServer { public static void main(String args[])throws Exception { ServerSocket serverSocket = new ServerSocket(8000);Socket s=serverSocket.accept();//s.setSoTimeout(20000);InputStream in=s.getInputStream();ByteArrayOutputStream buffer=new ByteArrayOutputStream();byte[] buff=new byte[1024];int len=-1;do{try{len=in.read(buff);if(len!=-1)buffer.write(buff,0,len);}catch(SocketTimeoutException e){System.out.println("等待读超时");len=0;}}while(len!=-1);System.out.println(new String(buffer.toByteArray())); //把字节数组转换为字符串}}。
套接字实验报告
套接字实验报告套接字实验报告引言套接字(Socket)是计算机网络中一种重要的通信机制,它允许不同计算机之间的进程进行通信。
在本次实验中,我们将学习套接字的基本概念和使用方法,并通过实际编程实现简单的网络通信。
一、套接字的基本概念1.1 套接字的定义套接字是计算机网络中用于实现进程间通信的一种机制。
它可以在不同主机之间传递数据,使得进程能够进行通信和协作。
1.2 套接字的类型套接字可以分为两种类型:流式套接字(SOCK_STREAM)和数据报套接字(SOCK_DGRAM)。
流式套接字提供面向连接的可靠通信,而数据报套接字则提供无连接的不可靠通信。
1.3 套接字的地址套接字的地址由IP地址和端口号组成。
IP地址用于标识主机,端口号用于标识进程。
二、套接字的使用方法2.1 创建套接字在使用套接字之前,首先需要创建一个套接字对象。
可以通过调用socket()函数来创建套接字,指定套接字的类型和协议。
2.2 绑定套接字在进行网络通信之前,需要将套接字绑定到一个特定的地址上。
可以通过调用bind()函数来实现套接字的绑定。
2.3 监听套接字如果希望套接字能够接受连接请求,需要将套接字设置为监听状态。
可以通过调用listen()函数来实现套接字的监听。
2.4 接受连接当套接字处于监听状态时,可以通过调用accept()函数来接受客户端的连接请求,并返回一个新的套接字对象,用于与客户端进行通信。
2.5 发送和接收数据一旦建立了连接,就可以通过调用send()函数来发送数据,调用recv()函数来接收数据。
三、实验过程和结果在本次实验中,我们使用Python编程语言来实现套接字的使用。
首先,我们创建一个服务器端程序和一个客户端程序。
3.1 服务器端程序服务器端程序首先创建一个套接字对象,并将其绑定到一个特定的地址上。
然后,将套接字设置为监听状态,等待客户端的连接请求。
一旦接受到连接请求,就创建一个新的套接字对象,并与客户端进行通信。
计算机网络socket实验
《计算机网络》实验报告socket编程学院姓名学号(后边附有源代码地址)年月日Phase 1: Establishing Client-Server Communications1.题目要求此题目要求实现一个通过TCP套接字来建立连接的通讯,服务器和客户端需要实现以下5个功能:1.客户端与服务器建立连接,需要用户名和加密密码。
2.客户端发送想分享的文件名给服务器。
3.客户端发送一个想下载的文件查询。
4.客户端显示收到的回复信息,并显示。
5.登出。
2.开发环境操作系统:Linux 2.6.32-279.el6.x86_64编程语言:C99编译器:GCC 4.4.6 20120305 (Red Hat 4.4.6-4)3.程序详解网络和I/O使用单线程利用epoll实现非阻塞异步IO。
此部分功能主要用于实现多客户端的网络I/O的轮询处理,使用Linux内核中的EPOLL特性实现。
维护一个哈希表(Client),用于将文件描述符与客户端数据(如接收缓冲区、发送缓冲区和会话状态等)进行映射。
对应主要的功能函数包括:int newclientid(int fd)用于在Client哈希表中创建新项,与提供的文件描述符(fd)对应。
int fd2clientid(int fd)用于在Client哈希表中根据提供的文件描述符(fd)查找项目。
void setnonblocking(int sock)设置SOCKET为非阻塞模式int server_startup(u_short port)在指定的端口上启动trackerd监听服务,并设置epollint push_data(struct client_data* client, char* buf, int len)向指定的客户端推送数据,会先进入客户端数据体内的发送缓冲区,再等待由epoll通知就绪时发送void close_client(int clientid)关闭指定的客户端,释放资源int server_loop()网络服务循环,调用epoll来接受连接和就绪通知,并监视连接中断,如有数据就绪则使用recv放入接收缓冲区,如通知发送就绪则将用send将发送缓冲区中的数据发送至客户端。
Socket编程利用TCP协议的实验报告
Socket 编程报告( TCP/IP 协议)一.实验目的通过C++ 来实现TCP/IP 协议下的Socket 编程,掌握TCP 协议的算法实现。
二.实验原理客户端建立Socket ,通过端口号和地址确定目标服务器,使用Connect 连接到服务器,成后调用CloseSocket 关闭Socket服务端建立Socket ,声明自身的端口号和地址并绑定到Socket ,使用Listen 打开监听,接,如果有,捕获Socket ,并通过Recv 获取消息的内容,通信完成后调用CloseSocket 如果不再需要等待任何客户端连接,那么用CloseSocket 关闭掉自身的Socket三.实验代码( C++ 实现)服务器端代码如下:#pragma once#include <>#include <>#pragma comment (lib,"")class CServerNet{public:.\n");();}elseprintf("serverNet init failed with error : %d\n",iRlt);system("pause");}客户端代码如下:#pragma once#include <>#include<>#pragma comment(lib, "")class CClientNet{public:// 连接上指定服务器int Connect(int port,const char* address);// 发送信息int SendMsg(const char* msg,int len);// 关闭send 发送消息,等待处理,通信完然后不断用Accept 去查看是否有连关闭这个对应Accept 到的Socket ,void Close(); private:};int CClientNet::Connect( int port,const char* address ){int rlt = 0;// 用于记录错误信息并输出int iErrMsg;// 启动WinSockWSAData wsaData;iErrMsg = WSAStartup(MAKEWORD(1,1),&wsaData);if (iErrMsg != NO_ERROR)// 有错误{printf("failed with wsaStartup error : %d\n",iErrMsg);rlt = 1; return rlt;}// 创建Socketm_sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);if (m_sock == INVALID_SOCKET)// 创建Socket 失败{printf("socket failed with error : %d\n",WSAGetLastError());rlt = 2; return rlt;}// 目标服务器数据sockaddr_in sockaddrServer;= AF_INET;= port;= inet_addr(address);// 连接,sock 与目标服务器连接iErrMsg = connect(m_sock,(sockaddr*)&sockaddrServer,sizeof(sockaddrServer)); if (iErrMsg < 0) {printf("connect failed with error : %d\n",iErrMsg);rlt = 3; return rlt;}return rlt;}int CClientNet::SendMsg(const char* msg,int len){int rlt = 0;// 发送消息,指定sock 发送消息iErrMsg = send(m_sock,msg,len,0);if (iErrMsg < 0)// 发送失败{printf("send msg failed with error : %d\n",iErrMsg);rlt = 1; return rlt;} return rlt;}void CClientNet::Close(){ closesocket(m_sock);}int main(){CClientNet client; printf("Connect\n");// 发送消息printf("send msg\n");("hello\0",sizeof("hello\0"));// 关闭socket printf("close\n");(); system("pause");}四.实验结果五.心得体会通过本次实验,我了解了TCP/IP 协议与UDP 协议的异同之处,理解了Socket 在通信中的地位和作用。
计网socket编程实验报告
深圳大学实验报告实验课程名称:计算机网络实验项目名称: Socket 编程学院:计算机与软件学院专业:计算机科学与技术报告人:学号:班级:同组人:指导教师:实验时间: 2015-05-10 提交时间: 2015年5月29日声明:本次实验内容由报告人和同组人独立完成,所有涉及到他人的工作均已说明。
报告人和同组人均同意教师及学校为教学活动而引用本实验的内容,且无需事先征得同意和特别说明。
教务处制一、实验目的了解FTP协议的工作原理,掌握基于socket的网络编程的基本原理。
二、实验要求用 Socket (WinSock)编程,实现简单的 FTP 客户端:客户端和 FTP 服务器建立 Socket 连接。
向服务器发送 USER、PASS 命令登录 FTP 服务器。
使用 PORT(或PASV)建立数据连接。
使用 NLST 进行文件列表。
使用 RETR / STOR 命令下载/上传文件。
在下载完毕后断开数据连接并发送 QUIT 命令退出。
服务器:Apache Friends 中的 FileZillaFTP,或是lab:lab @ 在整个交互的过程中,控制连接始终处于连接的状态。
数据连接在每传输一个文件时先打开,传输后关闭三、实验分析设计(1)服务端启动,等待用户连接(2)客户端启动,请求与服务端连接(3)服务端应答,与用户建立连接(4)用户输入目录操作、文件上传下载等指令,服务端接收到指令后进行解析,作出相应的响应(5)重复(4)的过程,直至用户输入quit指令要求离开,服务结束四、核心代码说明#pragma comment(lib,"ws2_32")#include<WinSock.h>#include<fstream>#include<iostream>#include<errno.h>#include<time.h>#include<string>#include"ftpClient.h"using namespace std;#define MENU "Welcome To The FTP Server,Please Input The Command And Enter!Such as: LIST,CWD,RETR,STOR,DELE,RMD,MKD"//定义了在ftp服务器上能进行的操作int main(){char Dir[256];memset(Dir,NULL,256);int returnNum;char ip[16];int port;char test;char userName[50];memset(userName,NULL,50);strncpy(userName,"anonymous",strlen("anonymous"));char PWD[50];char temp[512];char Command[4];//char Parameter[256];cout<<"Please input the ip of the FTP server::";cin>>ip;cout<<"Do you want to change the port,Now the port is 21 :[Y/N]";//使用命令端口21来连接到ftp服务器,在ftp协议下不用更改cin>>test;if(test=='Y'||test=='y')//连接到ftp服务器{cout<<"Please input the num of the port::";cin>>temp;port =(temp[0] - '0')*100+(temp[1] - '0')*10+(temp[2] - '0'); //将字符型转化为数值型memset(temp,NULL,2);}else if (test=='N'||test=='n')port = 21;elsecout<<"Error"<<endl;/************************************用户登录模块************************************/ftpClient* client = new ftpClient(ip,port);cout<<"Do you want to change USERNAME,Now is anonymous:[Y/N]"; //不更改时默认的是匿名登录cin>>test;if(test=='Y'||test=='y'){cout<<"UserName::";cin>>userName;//输入登录名}else if (test=='N'||test=='n')cout<<"UserName::anonymous"<<endl;elsecout<<"Error Check input!"<<endl;client->setCommand("USER",userName);//验证登录名cout<<userName<<endl;client->sendCommand(); //向ftp服务器发送用户名returnNum = client->receiveCommand(); //从ftp服务器接收到的响应码,正确时应为331if(returnNum == 331){cout<<"PassWord::";cin>>PWD;//输入密码client->setCommand("PASS",PWD);client->sendCommand();returnNum = client->receiveCommand(); //从ftp服务器接收响应码,正确时应返回230if(returnNum == 230) //用户已经正确登录到了ftp服务器{while(1){cout<<MENU<<endl;cout<<"FTP::>";cin>>Command;if(strcmp(Command,"list")==0||strcmp(Command,"LIST")==0){/************************************连接控制,传输控制,命令传输(需使用socketData连接的命令,如:LIST)************************************/client->setCommand("PASV");client->sendCommand();client->receiveCommand();client->getPort();client->setCommand("TYPE","I");client->sendCommand();client->receiveCommand();client->interlizeDataSocket();client->setCommand("LIST", ".");cout<<Dir<<endl;client->sendCommand();client->receiveCommand();client->receiveList();client->receiveCommand();}else if(strcmp(Command,"CWD")==0||strcmp(Command,"cwd")==0){memset(Dir,NULL,512);cout<<"Plase input the dir of your will(compelete dir)::"<<endl;cin>>Dir;client->setCommand("CWD ",Dir);client->sendCommand();client->receiveCommand();}else if(strcmp(Command,"retr")==0||strcmp(Command,"RETR")==0){char* filename = new char[512];memset(filename,NULL,512);/************************************下载模块************************************/client->setCommand("PASV");client->sendCommand();client->receiveCommand();client->getPort();client->setCommand("TYPE","I");client->sendCommand();client->receiveCommand();client->interlizeDataSocket();cout<<"Please input the name you want to download:";cin>>filename;client->setCommand("RETR ",filename);client->sendCommand();client->receiveCommand();client->receiveData(filename);client->receiveCommand();delete filename;}else if(strcmp(Command,"stor")==0||strcmp(Command,"STOR")==0){char* filename = new char[512];memset(filename,NULL,512);/************************************上传模块************************************/client->setCommand("PASV");client->sendCommand();client->receiveCommand();client->getPort();client->setCommand("TYPE","I");client->sendCommand();client->receiveCommand();client->interlizeDataSocket();cout<<"Please input the name you want to UPload:";cin>>filename;client->setCommand("STOR ",filename);client->sendCommand();client->receiveCommand();client->sendData(filename);client->receiveCommand();delete filename;}else if(strcmp(Command,"dele")==0||strcmp(Command,"DELE")==0) //进入删除文件的程序代码段{char* filename = new char[512];memset(filename,NULL,strlen(filename));cout<<"Please input the filename you want to Delete:";cin>>filename;client->setCommand("DELE ",filename);client->sendCommand();client->receiveCommand();delete filename;}else if(strcmp(Command,"rmd")==0||strcmp(Command,"RMD")==0) //进入删除目录的程序代码段{memset(Dir,NULL,strlen(Dir));cout<<"Please input the Direct you want to Delete:";cin>>Dir;client->setCommand("RMD ",Dir);client->sendCommand();client->receiveCommand();}else if(strcmp(Command,"mkd")==0||strcmp(Command,"MKD")==0) //进入修改文件的程序代码段{memset(Dir,NULL,strlen(Dir));cout<<"Please input the Direct you want to Make:";cin>>Dir;client->setCommand("MKD ",Dir);client->sendCommand();client->receiveCommand();}else if(strcmp(Command,"QUIT")==0||strcmp(Command,"quit")==0) //进入退出文件的程序代码段{break;}else{cout<<"No such COMMAND!!";}}}}elsecout<<"Error You can not login in."<<endl;cout<<"Cleaning system resource"<<endl;//delete [] userName;//delete [] Direct;//delete client;cout<<"Exiting Goodbye"<<endl;system("pause");}五、测试与结果六、总结与分析本次实验达到了本项实验的初始目的和要求。
计算机网络socket编程实验报告
Socket 编程实验报告一、程序代码( 1 )服务器端#include <stdio.h>#include <Winsock2.h>#pragma comment(lib, "ws2_32.lib")void main(){ WORD wVersionRequested;WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );if ( err != 0 ) { return; }if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ){ WSACleanup( );return; }SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);SOCKADDR_IN addrSrv;addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY); addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000); bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));// 绑定端口listen(sockSrv,SOMAXCONN); //SOMAXCONN 由系统确定请求数SOCKADDR_INaddrClient;// 连接上的客户端ip 地址intlen=sizeof(SOCKADDR);while(1){SOCKET sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);// 接受客户端连接, 获取客户端的ip 地址charsendBuf[50];sprintf(sendBuf,"Welcome %s to here!",inet_ntoa(addrClient.sin_addr));// 组合消息发送出去send(sockConn,sendBuf,strlen(sendBuf)+1,0);// 发送消息到客户端charrecvBuf[50]; recv(sockConn,recvBuf,50,0);// 接受客户端消息printf("%s\n",recvBuf);closesocket(sockConn);WSACleanup();// 断开连接( 2)客户端代码#include <stdio.h>#include <Winsock2.h>#pragma comment(lib, "ws2_32.lib") void main(){WORD wVersionRequested;WSADATA wsaData;//WSAata 用来存储系统传回的关于WinSocket int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );if ( err != 0 ){return;}if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ) { WSACleanup( );return;}SOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);// AF_INET ..tcp 连接,初始化连接与端口号SOCKADDR_IN addrSrv; addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");// 本机地址,服务器在本机开启addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000);// 设置端口号connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));//charrecvBuf[50];recv(sockClient,recvBuf,50,0);// 接受数据printf("%s\n",recvBuf);send(sockClient,"hello",strlen("hello")+1,0);// 发送数据closesocket(sockClient);// 关闭连接WSACleanup(); 的资料。
socket学习实验报告
Socket编程学习报告班级:学号:姓名:一、SOCKET:所谓socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄。
应用程序通常通过"套接字"向网络发出请求或者应答网络请求socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。
我的理解就是Socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/写IO、打开、关闭)二、TCPTCP协议简介TCP协议的作用主要是在计算机间可靠地交换传输数据包。
TCP协议是面向连接的协议,它比较安全、稳定,但是效率不高,占用资源较多。
因为TCP协议是面向连接的端到端的可靠协议,支持多种网络应用程序,所以在网络发展的今天,它已成为事实上的网络协议标准。
TCP协议具有以下3种主要特征:▪TCP协议是面向连接的,在任何数据实施交换之前,首先要在两台计算机之间建立连接进程。
▪由于使用了序列号和返回通知,TCP协议使用户确信传输的可靠性。
▪TCP协议使用字节流通信号,这意味着数据被当做没有信息的字节序列来对待。
TCP协议的数据段格式TCP 协议中有两个重要术语,那就是“连接端”及“标记”。
“连接端”是进行TCP连接的两端计算机,也称为“源节点”和“终节点”。
一个连接由连接两端的套接字标识,本地的套接字可能和不同的外部套接字通信,这种通信是全双工的。
IP地址和通信所使用端口的组合就称做套接字(Socket),它代表一个TCP 协议连接的一个连接端。
为了获得TCP协议服务,必须在发送端计算机的一个端口上和接收端计算机的一个端口上建立连接。
而“标记”在TCP协议包头中表示TCP协议的连接情况。
一个TCP协议数据包包括一个TCP协议头,后面是“选项”和“数据”。
socket编程实验报告
实验一Socket编程班级:电子商务08-2班学号:20085154姓名:杨阳一、目的通过socket程序的编写、调试,掌握socket编程的基本方法,促进学生对概念的理解,培养动手能力。
二、基本要求编写并调试教学中使用的socket程序示例,并加以修改,增加程序的功能。
完成实验后,需要按时提交实验报告。
三、实验内容服务器端程序代码:import java.io.*;import .*;public class Socketserver{public static void main(String args[]){Socket soc=null;InputStream is=null;OutputStream os=null;ServerSocket servSocket=null;try{servSocket=new ServerSocket(8000);// 调用ServerSocket类的构造方法,以8000端口号为参数,创建一个ServerSocket对象soc=servSocket.accept();//服务程序使用ServerSocket对象的accept( )方法接收来自客户程序的请求。
直到接收到从客户程序发来的连接请求(否则一直等待),然后该方法返回一个新建的Socket类的对象is=soc.getInputStream();//返回对socket的输入流的引用os=soc.getOutputStream();//返回对socket的输出流的引用BufferedReader in=new BufferedReader(new InputStreamReader(is));//通过InputStreamReader的对象is的读取,将值赋给in,基于字符流PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(os)),true);//通过BufferedWriter方法封装了os,将值赋给out,其方法取参数ture表示当读取数据时,即自动刷新缓存区,当该参数取flash时,只有当缓存区满时,才会刷新缓存区System.out.println("client'sIP:"+soc.getInetAddress());//getInetAddress()方法可以获得客户机的IP地址; System.out.println()表示向本地计算机反映相关信息System.out.println("client's port"+soc.getPort());//getPort()方法可以获得端口号out.println("welcome!");//该方法表示向客户端输出相关数据String s=in.readLine();//读取一行数据while(!s.equalsIgnoreCase("quit"))//当客户端的数据不为quit时{System.out.println("client said:"+s);s=in.readLine();}System.out.println("client wants to leave.");}catch(Exception e){System.err.println("socket wrong connetion");//输出错误信息e.printStackTrace();//出现异常时,打印整个方法调用名单}finally{//finally方法释放资源try{is.close();//关闭输入流os.close();//关闭输出流soc.close();//关闭SocketservSocket.close();//关闭ServerSockerSystem.out.println("over,successfully leasing resouce");}catch(Exception e){System.err.println("close socket wrong");//输出错误信息e.printStackTrace();//出现异常时,打印整个方法调用名单}}}}客户端程序代码:import java.io.*;import .*;public class Socketclient{public static void main(String args[]){Socket soc=null;InputStream is=null;OutputStream os=null;try{soc=new Socket("localhost",8000);System.out.println("connecting to the server");is=soc.getInputStream();os=soc.getOutputStream();BufferedReader in=new BufferedReader(new InputStreamReader(is));PrintWriter out=new PrintWriter(new BufferedWriter(new OutputStreamWriter(os)),true);String s=in.readLine();System.out.println("server said:"+s);System.out.println("server's IP:"+soc.getInetAddress());System.out.println("server's Port"+soc.getPort());/*byte b[]=new byte[100];System.in.read(b);String ms=new String(b);*/BufferedReader in2=new BufferedReader(new InputStreamReader(System.in));//定义变量in2获取服务器端信息String ms=in2.readLine();//定义变量ms获取信息ms=ms.trim();while(!ms.equalsIgnoreCase("quit")){out.println(ms);ms=in2.readLine();ms=ms.trim();}out.println(ms);}catch(Exception e){System.err.println("socket error");e.printStackTrace();}finally{try{is.close();os.close();soc.close();System.out.println("over,leasing resource successfully");}catch(Exception e){System.err.println("close socket wrong");e.printStackTrace();}}}}服务器端程序的编写1调用ServerSocket类的构造方法,以某端口号为参数,创建一个ServerSocket 对象。
socket实验报告
socket实验报告Socket实验报告简介Socket是计算机网络中一种常用的通信方式,它提供了一种用于网络通信的编程接口。
本实验旨在通过使用Socket编程实现简单的客户端和服务器之间的通信,探索Socket的基本原理和使用方法。
实验目的1. 理解Socket的概念和原理;2. 掌握Socket编程的基本步骤和方法;3. 实现一个简单的客户端和服务器之间的通信。
实验过程1. Socket的概念和原理Socket是一种抽象层,它将底层的网络通信细节封装起来,提供了一种简单、统一的编程接口。
通过Socket,应用程序可以通过网络进行数据传输,实现不同主机之间的通信。
2. Socket编程的基本步骤a. 创建Socket对象:在客户端和服务器端分别创建Socket对象,用于建立通信连接。
b. 建立连接:客户端通过Socket对象连接到服务器端,建立起通信通道。
c. 数据传输:通过Socket对象进行数据的发送和接收。
d. 关闭连接:通信结束后,关闭Socket连接。
3. 实现一个简单的客户端和服务器之间的通信a. 客户端代码:```pythonimport socketdef main():# 创建Socket对象client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 建立连接server_address = ('localhost', 8888)client_socket.connect(server_address)# 发送数据message = 'Hello, server!'client_socket.sendall(message.encode())# 接收数据data = client_socket.recv(1024)print('Received:', data.decode())# 关闭连接client_socket.close()if __name__ == '__main__':main()```b. 服务器端代码:```pythonimport socketdef main():# 创建Socket对象server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 绑定地址和端口server_address = ('localhost', 8888)server_socket.bind(server_address)# 监听连接server_socket.listen(1)print('Waiting for client connection...')while True:# 建立连接client_socket, client_address = server_socket.accept()print('Connected by', client_address)# 接收数据data = client_socket.recv(1024)print('Received:', data.decode())# 发送数据message = 'Hello, client!'client_socket.sendall(message.encode())# 关闭连接client_socket.close()if __name__ == '__main__':main()```实验结果通过运行客户端和服务器端的代码,可以实现客户端向服务器发送消息,并接收服务器返回的消息。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
课程名称计算机网络课程设计成绩评定
实验项目名称客户服务器通信指导教师
学生姓名学号
学院信息科学技术学院系计算机科学系专业网络工程(一)课程设计原理
实现语言:java
开发平台:MyEclipse8.5
关于java的面向连接的通信方式介绍如下:
Java提供的套接字分为客户端和服务器端两种:
1、客户端的socket
Socket(String host,int port):生成一个连接到某个主机内某个端口号码的套接字。
Socket(InetAddress host,int port):生成一个连接到某个主机地址上某个端口号码的套接字。
InputStream getInputStream():得到套接字的输入数据流。
OutputStream getOutputStream():得到套接字的输出数据流。
工作完毕,使用流对象的close()方法关闭用于网络通信的输入、输出流,用Socket对象的close()方法关闭socket。
2、服务器端的socket
ServerSocket(int port):生成一个服务器套接字,并指定所使用的端口号码,在序列里等待连接的客户机的数目最大50,若端口的值为0,则使用任何可供使用的端口。
ServerSocket(int port,int backlog):backlog表示在序列里等待连接的客户机的数目,若数目超过backlog,则客户机的连接被拒绝。
InputStream getInputStream():得到套接字的输入数据流。
OutputStream getOutputStream():得到套接字的输出数据流。
Socket accept():等待接收来自客户的连接请求,服务器会等到联机为止。
工作完毕,使用流对象的close()方法关闭用于网络通信的输入、输出流,用ServerSocket对象的close()方法关闭监听socket。
(二)源代码
因为测试机器是本机,因此目的IP选用的是自测地址(127.0.0.1)
1、服务器端源代码
import .*;
import java.util.Scanner;
import java.io.*;
public class server{
public static void main( String args[]){
try{
boolean flag = true;
Socket clientSocket = null;
int c;
String outputLine;
String inputLine;
ServerSocket serverSocket = new ServerSocket( 8000);
System.out.println("Server listen on" + serverSocket.getLocalPort());
while( flag){
clientSocket = serverSocket.accept();
DataInputStream is = new DataInputStream( new
BufferedInputStream( clientSocket.getInputStream()));
PrintStream os = new PrintStream( new
BufferedOutputStream( clientSocket.getOutputStream()));
while( (inputLine = is.readLine()) != null ){
if( inputLine.equals("stop")){
System.out.println("warning: client ended this talk!");
flag = false;
os.println("warning: you ended this talk!");
break;
}
System.out.println("the client:" + inputLine);
BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
outputLine = br.readLine();
os.println( outputLine );
os.flush();
}
os.close();
is.close();
clientSocket.close();
}
serverSocket.close();
}catch( IOException e){
System.err.println( "Exception" + e );
}
}
}
2客户端源代码
import .*;
import java.io.*;
public class client{
public static void main( String args[]){
try{
Socket echoSocket = new Socket( "127.0.0.1",8000);
OutputStream os = echoSocket.getOutputStream();
DataInputStream is = new
DataInputStream( echoSocket.getInputStream());
int c;
String responseLine;
while( ( c = System.in.read()) != -1 ){
os.write( (byte)c);
if( c == '\n'){
os.flush();
responseLine = is.readLine();
System.out.println( "reply(server): " + responseLine );
}
}
os.close();
is.close();
echoSocket.close();
}catch( Exception e){
System.err.println( "Exception:" + e);
}
}
}
(三)运行结果
1、因为采用c/s经典模型,server的程序需要先运行,监听端口8000;运行client向server端口8000提出请求,server进行响应。
(简单说明:输入回车,表示确认发送,服务端接收到信息并打印在终端,服务器端也可发送信息给客户端,同样以回车作为确认发送。
程序中,IP地址使用自测地址)
2、截图说明
若先运行client客户端。
会发现异常如下:
原因是当client发出请求时,目的主机并未有服务程序处理,因此无法连接。
运行server端,截图如下:
表示服务端已在监听端口8000,当client提出连接请求时,服务端作出相应的响应。
再运行client客户端:
发现未出现任何异常。
说明已经正常连接。
尝试在client客户端输入文字并发送。
Client端:
Server端:
如图,发送成功。
下面,server端也可输入信息,用于聊天。
Server端:
Client端:
表示成功接收server端发过来的信息。
终止聊天,在client端提出。
终止指令为:stop。
现在在client端输入stop结束此次对话。
Client端:
Server端:
至此,会话结束。
成功终止对话。
(四)实验体会与总结
Java提供socket类使得tcp连接的通信十分方便,在实现通信过程的时候,最主要的是理解java中的各种流类型起到的作用。