java实现一个简答而实际的TCP的服务端和客户端连接
Java网络编程之TCP通信完整代码示例

Java⽹络编程之TCP通信完整代码⽰例⼀、概述 Socket类是Java执⾏客户端TCP操作的基础类,这个类本⾝使⽤代码通过主机操作系统的本地TCP栈进⾏通信。
Socket 类的⽅法会建⽴和销毁连接,设置各种Socket选项。
ServerSocket类是Java执⾏服务器端操作的基础类,该类运⾏于服务器,监听⼊站TCP连接,每个socket服务器监听服务器的某个端⼝,当远程主机的客户端尝试连接此端⼝时,服务器就被唤醒,并返回⼀个表⽰两台主机之间socket的正常Socket对象。
⼆、什么是TCP? TCP是⼀种⾯向连接的、可靠的、基于字节流的传输层通信协议。
TCP通信分为客户端和服务器端,对应的对象是分别是Socket和ServerSocket。
当⼀台计算机需要与另⼀台远程计算机连接时,TCP协议会让他们建⽴⼀个连接:⽤于发送和接收数据的虚拟链路。
TCP协议负责收集信息包,并将其按适当的次序放好传送,在接收端收到后再将其正确的还原。
为了保证数据包在传送中准确⽆误,TCP使⽤了重发机制:当⼀个通信实体发送⼀个消息给另⼀个通信实体后需要收到另⼀个实体的确认信息,如果没有收到确认信息,则会再次重发刚才发送的信息。
三、TCP通信 1、构造函数 Socket类实现客户端套接字,通过构造函数可以指定希望连接的主机和端⼝。
主机可以指定为InetAddress或String,端⼝始终指定为0到65535之间的int值。
Socket s=new Socket("127.0.0.1", 10001);//创建⼀个流套接字并将其连接到指定主机上的指定端⼝号ServerSocket类实现服务器套接字。
服务器套接字等待请求通过⽹络传⼊,它基于该请求执⾏某些操作,然后向请求者返回结果。
ServerSocket ss=new ServerSocket(10001);//创建绑定到特定端⼝的服务器套接字2、例⼦:TCP⽂件复制 客户端:public class ClientDemo{public static void main(String[] args) throws UnknownHostException, IOException{Socket s=new Socket("127.0.0.1", 10004);BufferedReader buf = new BufferedReader(new FileReader("C:\\Users\\Administrator\\Desktop\\1.txt"));String line=null;/*PrintWriter out=new PrintWriter(s.getOutputStream(),true);while((line=buf.readLine())!=null){out.println(line);}*/BufferedWriter out=new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));while((line=buf.readLine())!=null){out.write(line);out.newLine();out.flush();}s.shutdownOutput();BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));String str=in.readLine();System.out.println(str);s.close();buf.close();}}服务器端:public class ServerDemo{public static void main(String[] args) throws IOException{ServerSocket ss=new ServerSocket(10004);Socket s=ss.accept();BufferedReader in=new BufferedReader(new InputStreamReader(s.getInputStream()));String line=null;/*PrintWriter buf=new PrintWriter(new FileWriter("C:\\Users\\Administrator\\Desktop\\2.txt"),true);while((line=in.readLine())!=null){buf.println(line);}*/BufferedWriter buf=new BufferedWriter(new FileWriter("C:\\Users\\Administrator\\Desktop\\2.txt"));while((line=in.readLine())!=null){buf.write(line);buf.newLine();buf.flush();}PrintWriter out=new PrintWriter(s.getOutputStream(),true);out.println("传输成功!");ss.close();buf.close();}}四、Socket在浏览上的应⽤ 我们可以在Eclipse中编写服务器端,然后利⽤浏览器进⾏访问。
java实现tcp连接的接收数据方法

java实现tcp连接的接收数据方法Java是一种广泛应用于网络编程的编程语言,它提供了丰富的库和工具来实现TCP连接的数据接收。
在本文中,我将介绍如何使用Java实现TCP连接的接收数据方法。
我们需要了解TCP连接的基本概念。
TCP(Transmission Control Protocol)是一种可靠的、面向连接的协议,它在网络上提供了可靠的数据传输服务。
在TCP连接中,客户端和服务器之间建立一个可靠的双向通信通道,通过这个通道可以进行数据的传输和交换。
在Java中,我们可以使用Socket类来实现TCP连接的接收数据。
Socket类提供了一组方法来创建、连接和关闭套接字,以及发送和接收数据。
下面是一个简单的示例代码,展示了如何使用Java实现TCP连接的接收数据方法:```javaimport java.io.InputStream;import .Socket;public class TCPServer {public static void main(String[] args) {try {// 创建一个Socket对象,指定服务器的IP地址和端口号 Socket socket = new Socket("127.0.0.1", 8888);// 获取Socket的输入流InputStream inputStream = socket.getInputStream();// 创建一个缓冲区,用于读取数据byte[] buffer = new byte[1024];// 读取数据,并将其存储到缓冲区中int length = inputStream.read(buffer);// 将字节数组转换为字符串,并输出到控制台String data = new String(buffer, 0, length);System.out.println("接收到的数据:" + data);// 关闭输入流和SocketinputStream.close();socket.close();} catch (Exception e) {e.printStackTrace();}}}```在上面的示例代码中,我们首先创建了一个Socket对象,并指定了服务器的IP地址和端口号。
Java网络编程,实现客户端与服务端的交互

在Socket的程序开发中,服务器端使用ServerSocket等待客户端的链接,对于Java的网路程序来讲,每一个客户端使用一个Socket对象表示。
ServerSocketServerSocket类主要用在服务器端程序的开发上,用于接收客户端的链接请求。
Socket在服务器端每次运行时都要使用accept()方法等待客户端连接,此方法执行之后服务器端讲进入阻塞状态,直到客户端连接之后程序才可以向下继续执行,此方法的返回值是Socket,每一个Socket都表示一个客户端对象。
多线程:Java的多线程实现:有两种方式:1.继承Thread类2.实现Runnable接口继承Thread类一个类只要继承了Thread类,此类就称为多线程操作类,在Thread 子类中,必须覆写run()方法,此方法为线程的主体。
BufferedReader是从缓冲区之中读取内容,所有的输入的字节数据都将放在缓冲区之中。
BufferedReader实例化BufferedReader buf=new BufferedReader(new InputStreamReader(System.in)); InputStreamReader是R eader的子类,将输入的字节流转化为字符流。
对象输出流:ObjectOutputStream对象输入流:ObjectInputStream以下代码实现了服务端与客户端的交互:里面包含了网络编程、线程、流等知识点源代码:Server.java中的代码import java.io.*;import .*;public class Server {ServerSocket server; // 声明ServerSocketpublic Server() {try {server = new ServerSocket(5566); // 构建服务,绑定端口} catch (IOException e) {// TODO自动生成 catch 块e.printStackTrace();}}public void startServer() { //定义startServer方法,由此启动服务ServerThread st = new ServerThread(); //new出一个新线程st.start(); //启动线程}public static void main(String[] args) {Server s1 = new Server(); //用Server类创建一个S1对象,此为对象实例化s1.startServer(); //调用startServer()方法}class ServerThread extends Thread { //继承Thread类public void run() {while (true) {try {System.out.println("开始监听:");Socket formClient = server.accept();ObjectOutputStream oos = new ObjectOutputStream(formClient.getOutputStream());BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));System.out.println("请输入:");String s = buf.readLine();oos.writeObject(s);ObjectInputStream ois = new ObjectInputStream(formClient.getInputStream());String sc = (String) ois.readObject();System.out.println("客户端说:" + sc);Thread.sleep(100);} catch (IOException e) {// TODO自动生成 catch 块e.printStackTrace();} catch (ClassNotFoundException e) {// TODO自动生成 catch 块e.printStackTrace();} catch (InterruptedException e) {// TODO自动生成 catch 块e.printStackTrace();}}}}}Client.java中的代码:import java.io.*;import .*;public class Client {public static void main(String[] args) {while (true) {try {Socket toServer = new Socket(InetAddress.getLocalHost(), 5566);BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));ObjectInputStream ois = new ObjectInputStream(toServer.getInputStream());String s = (String) ois.readObject();System.out.println("服务器端说:" + s);ObjectOutputStream oos = new ObjectOutputStream(toServer.getOutputStream());System.out.println("请输入:");String sc = buf.readLine();oos.writeObject(sc);} catch (UnknownHostException e) {// TODO自动生成 catch 块e.printStackTrace();} catch (IOException e) {// TODO自动生成 catch 块e.printStackTrace();} catch (ClassNotFoundException e) {// TODO自动生成 catch 块e.printStackTrace();}}}}运行说明把Server.java和Client.java两个文件放到同一个文件夹,比如放在F:\网络编程文件夹下。
Java如何通过Socket实现TCP服务端

Java如何通过Socket实现TCP效劳端所谓socket 通常也称作”套接字“,用于描述IP地址和端口,是一个通信链的句柄。
应用程序通常通过”套接字”向网络发出请求或者应答网络请求。
Socket和ServerSocket类库位于包中。
ServerSocket用于效劳器端,Socket是建立网络连接时使用的。
在连接成功时,应用程序两端都会产生一个Socket 实例,操作这个实例,完成所需的会话。
对于一个网络连接来说,套接字是平等的,并没有差异,不因为在效劳器端或在客户端而产生不同级别。
import .io.IOException;import java.io.InputStream;import java.io.OutputStream;import java..ServerSocket;import java..Socket;import java.util.Date;import java.util.HashMap;import java.util.Map;import org.slf4j.Logger;import org.slf4j.LoggerFactory;/*** TCP效劳器端,单例模式* @author xiang**/public class TCPServer implements Runnable {private static final Logger logger =LoggerFactory.getLogger(TCPServer.class);//成员变量/private static TCPServer serverInstance;private static Map socketMaps = new HashMap();//每个客户端连接时都会新建一个SocketThread与之对应 private static ServerSocket serverSocket; //效劳器套接字private static int serPort = 9999; //效劳器端口号private static boolean flag; //效劳器状态标志private static final int BUFFERSIZE = 512; //数据接收字符数组大小//构造函数/private TCPServer() {}/*** 获取实例* @return TCPServer实例serverInstance*/public static TCPServer getServerInstance(){if(serverInstance==null)serverInstance = new TCPServer();return serverInstance;}/*** 开启效劳器* @throws IOException*/public void openTCPServer() throwsIOException{ if(serverSocket==null ||serverSocket.isClosed()){serverSocket = new ServerSocket(serPort);flag = true;}}/*** 关闭效劳器* @throws IOException*/public void closeTCPServer() throws IOException{flag = false; if(serverSocket!=null)serverSocket.close();/*for (Map.Entry entry : socketMaps.entrySet()) {System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());} */for (SocketThread value : socketMaps.values())value.closeConnect();socketMaps.clear();}/*** 效劳器向客户端发送数据* @param bytes[]:待发送的字符数组* @param key 客户端的key,为空或""时表示数据群发* @throws IOException*/public void sendMessage(String key,byte[] msgBytes){ if(key==null||key.equals("")){for (SocketThread value : socketMaps.values())value.sendMassage(msgBytes);}else{SocketThread thread = socketMaps.get(key);if(thread!=null)thread.sendMassage(msgBytes);}}/*** 效劳器向客户端发送数据* @param key 客户端的key,为空或""时表示数据群发* @param msgStr:待发送的字符串* @throws IOException*/public void sendMessage(String key,StringmsgStr){ byte[] sendByte = msgStr.getBytes();if(key==null||key.equals("")){for (SocketThread value : socketMaps.values())value.sendMassage(sendByte);}else{SocketThread thread = socketMaps.get(key);if(thread!=null)thread.sendMassage(sendByte);}}@Overridepublic void run() {("效劳器线程已经启动"); while(true){try {while(flag){("效劳器线程在监听状态中");Socket socket = serverSocket.aept();String key = socket.getRemoteSocketAddress().toString(); SocketThread thread = new SocketThread(socket,key); thread.start();socketMaps.put(key, thread);("有客户端连接:"+key);}} catch (Exception e) {e.printStackTrace();}}}/*** 处理连接后的数据接收请求内部类* @author xiang**/private class SocketThread extends Thread{ private Socket socket;private String key;private OutputStream out;private InputStream in;//构造函数public SocketThread(Socket socket,String key) { this.socket = socket;this.key = key;}/*** 发送数据* @param bytes* @throws IOException*/public void sendMassage(byte[] bytes){try {if(out==null)out = socket.getOutputStream();out.write(bytes);} catch (Exception e) {e.printStackTrace();try {closeConnect();} catch (IOException e1) {e1.printStackTrace();}socketMaps.remove(key);}}/*** 关闭连接,释放资源* @throws IOException*/public void closeConnect() throws IOException{if(out!=null) out.close();if(in!=null) in.close();if(socket!=null && socket.isConnected()) socket.close(); }@Overridepublic void run() {byte[] receivBuf = new byte[BUFFERSIZE];int recvMsgSize;try {in = socket.getInputStream();out = socket.getOutputStream();while ((recvMsgSize = in.read(receivBuf)) != -1) {String receivedData = new String(receivBuf, 0, recvMsgSize);System.out.println("Reverve form[port" +socket.getPort() + "]:" + receivedData);System.out.println("Now the size of socketMaps is" + socketMaps.size());/********************************************************** ****** 接收数据后的处理过程************************************************************ ***/}// response to clientbyte[] sendByte = "The Server has received".getBytes();// out.write(sendByte, 0, sendByte.length);out.write(sendByte);System.out.println("To Cliect[port:" + socket.getPort() + "] 回复客户端的消息发送成功");closeConnect();socketMaps.remove(key);} catch (Exception e) { e.printStackTrace();try {closeConnect();} catch (IOException e1) { e1.printStackTrace();}}}//////////////public int getport(){ return socket.getPort(); }}//. end SocketThread}。
socket建立tcp连接的java代码

socket建立tcp连接的java代码Socket是Java中常用的网络编程类,可以用于建立TCP连接,完成客户端和服务器间的通信。
下面是Socket建立TCP连接的Java代码:1. 建立Socket对象TCP协议在建立连接时,需要同时指定服务器的IP地址和端口号。
因此,在客户端程序中,需要先创建一个Socket对象来指定需要连接的服务器IP地址和端口号。
Socket socket=new Socke t(“192.168.1.1”, 8888);2. 获取输入输出流建立连接之后,客户端可以向服务器发送数据,还可以接收服务器返回的数据。
为了完成这些操作,需要获取输入输出流对象。
InputStream input=socket.getInputStream();OutputStream output=socket.getOutputStream();3. 发送数据客户端想要向服务器发送数据,可以通过输出流对象write()方法实现。
byte[] data=”Hello Server”.getBytes();output.write(data);4. 接收数据客户端从服务器接收数据,可以通过输入流对象read()方法实现。
byte[] buffer=new byte[1024];int len=input.read(buffer);5. 断开连接客户端和服务器通信结束之后,需要关闭连接。
input.close();output.close();socket.close();综上所述,以上代码实现了Socket建立TCP连接的过程,使得客户端和服务器能够互相通信,完成所需的业务操作。
Java程序设计中的TCP通信与聊天室实现案例

Java程序设计中的TCP通信与聊天室实现案例在Java程序设计中,TCP通信是一种常见的网络通信协议,它可以实现可靠的、面向连接的数据传输。
而聊天室是一种常见的网络应用,通过TCP通信可以实现多用户之间的实时交流。
本文将介绍Java程序设计中的TCP通信的基本原理以及如何使用Java语言实现一个简单的聊天室。
一、TCP通信的基本原理TCP(Transmission Control Protocol)是一种面向连接的传输层协议,它提供了可靠的数据传输和错误恢复机制。
在TCP通信中,数据传输是通过建立连接、传输数据以及断开连接这些步骤进行的。
具体的流程如下:1. 建立连接:在TCP通信中,需要先建立连接,这一步骤称为“三次握手”。
首先,客户端发送一个请求连接的报文给服务器端;服务器端接收到请求后,返回一个确认连接的报文给客户端;最后,客户端再次发送一个确认连接的报文给服务器端,建立连接成功。
2. 数据传输:连接建立成功后,客户端和服务器端可以互相发送数据。
TCP通过将数据划分成一个一个的数据段进行传输,每个数据段都会附带一些控制信息,例如序号、确认号、校验和等,以确保数据的可靠性。
3. 断开连接:当数据传输完毕后,需要断开连接。
断开连接的步骤称为“四次挥手”。
首先,客户端发送一个断开连接的请求给服务器端;服务器端返回一个确认报文给客户端,表示已经收到了断开连接的请求;然后服务器端发送一个断开连接的请求给客户端;最后,客户端返回一个确认报文给服务器端,完成断开连接。
以上就是TCP通信的基本原理,下面将介绍如何使用Java语言实现一个简单的聊天室。
二、Java程序设计中的聊天室实现案例在Java程序设计中,可以使用Socket类和ServerSocket类来实现TCP通信。
下面的代码演示了一个简单的聊天室的实现:```java// 服务端import java.io.IOException;import .ServerSocket;import .Socket;import java.util.ArrayList;import java.util.List;public class Server {private static final int PORT = 8888;private List<ClientHandler> clientHandlers = new ArrayList<>();public static void main(String[] args) {new Server().start();}public void start() {try {ServerSocket serverSocket = new ServerSocket(PORT);System.out.println("服务器已启动,等待客户端连接...");while (true) {Socket clientSocket = serverSocket.accept();ClientHandler clientHandler = new ClientHandler(clientSocket, this);clientHandlers.add(clientHandler);new Thread(clientHandler).start();}} catch (IOException e) {e.printStackTrace();}}public void broadcast(String message) {for (ClientHandler clientHandler : clientHandlers) {clientHandler.sendMessage(message);}}public void removeClientHandler(ClientHandler clientHandler) { clientHandlers.remove(clientHandler);}}// 客户端import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.PrintWriter;import .Socket;public class ClientHandler implements Runnable {private Socket socket;private Server server;private BufferedReader reader;private PrintWriter writer;public ClientHandler(Socket socket, Server server) {this.socket = socket;this.server = server;try {reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));writer = new PrintWriter(socket.getOutputStream(), true);} catch (IOException e) {e.printStackTrace();}}@Overridepublic void run() {try {String message;while ((message = reader.readLine()) != null) {server.broadcast(message);}} catch (IOException e) {e.printStackTrace();} finally {try {reader.close();writer.close();socket.close();server.removeClientHandler(this); // 断开连接后从客户端处理列表中移除} catch (IOException e) {e.printStackTrace();}}}public void sendMessage(String message) {writer.println(message);}}// 测试类public class ChatRoomTest {public static void main(String[] args) {// 启动服务器new Server().start();// 启动客户端new Thread(() -> {try {Socket socket = new Socket("localhost", 8888);BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));PrintWriter writer = newPrintWriter(socket.getOutputStream(), true);writer.println("Hello, server!");String message;while ((message = reader.readLine()) != null) {System.out.println("收到服务器的消息:" + message);}} catch (IOException e) {e.printStackTrace();}}).start();}}```以上代码实现了一个简单的聊天室,服务器端使用ServerSocket监听客户端的连接请求,并创建一个新的线程来处理每个客户端的连接;客户端通过Socket连接到服务器,并发送消息给服务器,服务器收到消息后广播给所有的客户端。
java实现两台电脑间TCP协议文件传输

java实现两台电脑间TCP协议⽂件传输记录下之前所做的客户端向服务端发送⽂件的⼩项⽬,总结下学习到的⼀些⽅法与思路。
注:本⽂参考⾃《⿊马程序员》视频。
⾸先明确需求,在同⼀局域⽹下的机器⼈A想给喜欢了很久的机器⼈B发送情书,但是机器⼈B事先并不知道⼩A的⼼思,那么作为⽉⽼(红娘)该如何帮助他们呢?然后建⽴模型并拆分需求。
这⾥两台主机使⽤⽹线直连,在物理层上确保建⽴了连接,接下来便是利⽤相应的协议将信息从电脑A传给电脑B。
在这⼀步上,可以将此过程抽象为⽹络+I/O(Input、Output)的过程。
如果能在⼀台电脑上实现⽂件之间的传输,再加上相互的⽹络协议,羞涩的A不就可以将情书发送给B了吗?因此要先解决在⼀台电脑上传输信息的问题。
为了在⽹络上传输,使⽤必要的协议是必要的,TCP/IP协议簇就是为了解决计算机间通信⽽⽣,⽽这⾥主要⽤到UDP和TCP两种协议。
当⼩A可以向⼩B发送情书后,⼜出现了众多的追求者,那么⼩B如何去处理这么多的并发任务呢?这时便要⽤到多线程的技术。
因此接下来将分别介绍此过程中所⽤到了I/O流(最基础)、⽹络编程(最重要)、多线程知识(较重要)和其中⼀些⼩技巧。
⼀、I/O流I/O流⽤来处理设备之间的数据传输,Java对数据的传输通过流的⽅式。
流按操作数据分为两种:字节流与字符流。
如果数据是⽂本类型,那么需要使⽤字符流;如果是其他类型,那么使⽤字节流。
简单来说,字符流=字节流+编码表。
流按流向分为:输⼊流(将硬盘中的数据读⼊内存),输出流(将内存中的数据写⼊硬盘)。
简单来说,想要将某⽂件传到⽬的地,需要将此⽂件关联输⼊流,然后将输⼊流中的信息写⼊到输出流中。
将⽬的关联输出流,就可以将信息传输到⽬的地了。
Java提供了⼤量的流对象可供使⽤,其中有两⼤基类,字节流的两个顶层⽗InputStream与OutputStream;字符流的两个顶层⽗类Reader 与Writer。
这些体系的⼦类都以⽗类名作为后缀,⽽⼦类名的前缀就是该对象的功能。
Java简单实现UDP和TCP的示例

Java简单实现UDP和TCP的⽰例TCP实现TCP协议需要在双⽅之间建⽴连接,通过输⼊输出流来进⾏数据的交换,建⽴需要通过三次握⼿,断开需要四次挥⼿,保证了数据的完整性,但传输效率也会相应的降低。
简单的TCP实现//服务端public class TcpServer {public static void main(String[] args) throws IOException {ServerSocket serverSocket = new ServerSocket(8886); // 建⽴服务端,ip为本机ip,端⼝为8886Socket accept = serverSocket.accept(); // 监听客户端的连接,⼀旦有客户端连接,则会返回客户端对应的acceptInputStream in = accept.getInputStream(); //获取到客户端的输出流byte b[] = new byte[1024];int len = in.read(b);System.out.println("接受到客户端数据,返回数据"+new String(b,0,len));OutputStream out = accept.getOutputStream(); // 给客户端发送消息out.write("服务端已经接受".getBytes());serverSocket.close();}}// 客户端public class TcpClient {public static void main(String[] args) throws IOException {Socket socket = new Socket("127.0.0.1", 8886); // 通过Socket来建⽴和服务端的连接OutputStream out = socket.getOutputStream(); // 获取输出流(客户端输出流即向服务端输出信息)out.write("hello tcp Server".getBytes()); // 输出信息InputStream in = socket.getInputStream(); // 接受服务端的消息byte b[] = new byte[1024];int len = in.read(b);System.out.println("接受到服务器消息: "+new String(b,0,len)); // 输出out.write("返回的的数据已经收到 ".getBytes()); // 向服务器返回消息socket.close();}}改进服务端,启⽤多线程来接受客户端的数据// serverpublic static void main(String[] args) throws IOException {ServerSocket serverSocket = new ServerSocket(8886); // 建⽴服务端,ip为本机ip,端⼝为8886int i=4;while(i>2){Socket accept = serverSocket.accept(); // 监听客户端的连接,⼀旦有客户端连接,则会返回客户端对应的acceptServerThread st = new ServerThread(accept); // 启动线程Thread th = new Thread(st);th.start();}serverSocket.close();}// threadpublic class ServerThread implements Runnable {private Socket accept;public ServerThread(Socket s) {this.accept = s;}public void run(){InputStream in;try {in = accept.getInputStream();byte b[] = new byte[1024];int len = in.read(b);System.out.println("接受到客户端数据,返回数据" + new String(b, 0, len));OutputStream out = accept.getOutputStream(); // 给客户端发送消息out.write("服务端已经接受".getBytes());} catch (IOException e) {e.printStackTrace();}}}传递图⽚// 服务端public class Server {public static void main(String[] args) throws IOException {ServerSocket serverSocket = new ServerSocket(5555);Socket ss = serverSocket.accept();BufferedInputStream br = new BufferedInputStream(ss.getInputStream());BufferedOutputStream bw = new BufferedOutputStream(new FileOutputStream("copy.jpg")); // 写出⽂件流 byte b[] = new byte[1024];int len = 0;while ((len = br.read(b)) != -1) { // 写出⽂件bw.write(b, 0, len);bw.flush(); // 别忘了刷新,要不然最后⼀块缓冲区字符串会缺失}BufferedWriter bw2 = new BufferedWriter(new OutputStreamWriter(ss.getOutputStream())); // 输出bw2.write("图⽚传输成功");bw2.flush();bw.close();ss.close();}}// 客户端public class Client {public static void main(String[] args) throws UnknownHostException, IOException {Socket socket = new Socket("127.0.0.1", 5555);BufferedInputStream in = new BufferedInputStream(new FileInputStream("c.jpg"));BufferedOutputStream out = new BufferedOutputStream(socket.getOutputStream());byte b[] = new byte[1024];int len = 0;while ((len = in.read(b)) != -1) {out.write(b, 0, len);out.flush(); // 刷新缓冲区要不然最后⼀块缓冲区字符串会缺失}socket.shutdownOutput(); // 关闭流以后Server段才会接收道结束字符结束接受BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));String line;while ((line = br.readLine()) != null) {System.out.println(line);}in.close();socket.close();}}UDP实现UDP是将数据打成数据包向对⽅发送,只关系是否发送成功,⽽不关⼼是否接收成功,传输速度快,但是可靠性低。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
java实现一个简答而实际的TCP的服务端和客户端连接
服务端:
package com.server;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import .ServerSocket;
import .Socket;
import .SocketTimeoutException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TcpIpServer {
public static void main(String[] args) {
// info Auto-generated method stub
ServerSocket serverSocket = null;
try {
serverSocket = new ServerSocket(7777);
System.out.println(getTime()+"服务端准备好啦.");
} catch (IOException e) {
// info Auto-generated catch block
e.printStackTrace();
}
while(true){
try {
System.out.println(getTime()+"等待连接请求.");
// serverSocket.setSoTimeout(5*1000);
Socket socket = serverSocket.accept();
System.out.println(getTime()+socket.getInetAddress()+"连接请求从这开始.");
OutputStream out = socket.getOutputStream();
DataOutputStream dos = new DataOutputStream(out);
dos.writeUTF("[Notice]Test Message1 from Server.");
System.out.println(getTime()+"数据传送啦.");
dos.close();
socket.close();
}
//catch(SocketTimeoutException e){
// System.out.println("end!");
// System.exit(0);
// }
catch (IOException e) {
// info Auto-generated catch block
e.printStackTrace();
}
}
}
static String getTime() {
// info Auto-generated method stub
SimpleDateFormat f = new SimpleDateFormat("[hh:mm:s]");
return f.format(new Date());
}
}
客户端:
package com.client;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import .Socket;
import .UnknownHostException;
public class TcpIpClient {
public static void main(String[] args) {
// info Auto-generated method stub
String serverIp = "127.0.0.1";
System.out.println("服务端连接中.服务端IP : " + serverIp);
try {
Socket socket = new Socket(serverIp, 7777);
InputStream in = socket.getInputStream();
DataInputStream dis = new DataInputStream(in);
System.out.println("从服务端获得消息: " + dis.readUTF());
System.out.println("连接终止.");
dis.close();
socket.close();
System.out.println("关闭连接.");
} catch (UnknownHostException e) {
// info Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// info Auto-generated catch block
e.printStackTrace();
}
}
}。