Java socket 入门 示例

最新推荐文章于 2022-12-12 18:06:47 发布
最新推荐文章于 2022-12-12 18:06:47 发布
阅读量135 收藏
点赞数
分类专栏： Java基础 文章标签： Java socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gwoham/article/details/84612319
版权

面向连接传输协议（TCP）

两台电脑在传输数据前，会先建立一个专属的连接，就如打电话一般，双方通话时，会占有一条专属的通讯连接，当有一方挂机后，此连接就会消失。面向连接的协议特点：

  1. 确认回应：设甲乙两台电脑，当甲传数据到乙时，会等乙送回确认后才会再去传下一笔数据。当一段时间没有收到乙的确认回复，甲会试着再传一次，如果传送多次都没有回应，就表示连接可能断了。
  2. 分组序号：面向连接协议在传送数据的时候会把数据分割成固定大小的分组（packet），然后在每个分组上加上序号。序号用来检查哪些分组收到，哪些封包重复等。
  3. 流量控制

TCP是属于可靠性传输。

 

非面向连接传输协议（UDP）

与面向连接协议相比较，使用非连接协议传输数据的电脑间并不会建立一条专属的连接，这样的连接不可靠，分组可能丢失，可能收到重复的分组，也可能出现后面的分组比前面的分组先收到的情形。UDP协议一般用于短距离的传输，或者大量传输且容许些许错误的场合，如视频会议等，或者multicasting或则broadcasting。

 

连接端口

一台电脑可能同时运行着多个Server，那么此时还需要一个端口来明确客户端到底想连此台电脑的哪个Server。就如电话的分机号码，先拨通总机，然后总机根据提供的分机号码转到该分机。

 

Socket

Socket是程序与网络间的一种接口， 通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络，请求大部分的网络应用都是点对点的（point-to-point），所谓点就是服务端和客户端所执行的程序。Socket是用来接收或传送分组的一个端点。

 

Java中基本的 服务器——客户端 模型

服务器，使用ServerSocket监听指定的端口，端口可以随意指定（由于1024以下的端口通常属于保留端口，在一些操作系统中不可以随意使用，所以建议使用大于1024的端口），等待客户连接请求，客户连接后，会话产生；在完成会话后，关闭连接。

 

客户端，使用Socket对网络上某一个服务器的某一个端口发出连接请求，一旦连接成功，打开会话；会话完成后，关闭Socket。客户端不需要指定打开的端口，通常临时的、动态的分配一个1024以上的端口。

 

示例代码：

 

 服务器端：

 

public class TCPEchoServer {

	public static final int PORT = 7777;
	public static final String ADDR = "127.0.0.1";
	
	protected void handleReq(Socket clnt) throws IOException
	{
		System.out.println("Client connected from: " + clnt.getInetAddress());
		
		System.out.println(clnt.isConnected()+ "~~~~" + clnt.isClosed());
		
		BufferedInputStream dataIn = new BufferedInputStream(clnt.getInputStream());
		
		byte[] b = new byte[64];
		
		int len = dataIn.read(b);
		
		String sendBack = new String(b, 0, len);
		sendBack = sendBack.toUpperCase();
		
		OutputStream dataOut = clnt.getOutputStream();
		
		dataOut.write(sendBack.getBytes());
		
		dataIn.close();
		
		dataOut.close();
		System.out.println(clnt.isConnected()+ "~~~~" + clnt.isClosed());
	}
	
	public void start()
	{
		try 
		{ 
			ServerSocket srv = new ServerSocket( PORT, 0, InetAddress.getByName(ADDR) );
			System.out.println("Echo server start at port: " + PORT);
			
			while( true )
			{
				// 此方法阻塞，直至有socket的连接请求过来
				Socket clnt = srv.accept();
				
				handleReq(clnt);
			}
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) 
	{
		new TCPEchoServer().start();
	}
}
 

 

客户端： 
public class TCPEchoClient {

	JFrame mainFrame;
	
	JPanel container;
	
	JLabel reqLabel;
	
	JLabel resLabel;
	
	JTextField reqTfld;
	
	JTextField resTfld;
	
	JButton sendBtn;
	
	private class SendEchoAction implements ActionListener
	{
		@Override
		public void actionPerformed(ActionEvent e) 
		{
			String reqStr = reqTfld.getText();
			
			sendEcho(reqStr);
		}
	}
	
	public void initUI() 
	{
		mainFrame = new JFrame("Echo client");
		
		setCmpt();
		
		mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		mainFrame.pack();
		
		mainFrame.setLocationRelativeTo(null);
		
		mainFrame.setVisible(true);
	}
	
	private void setCmpt() 
	{
		reqLabel = new JLabel("Input String:");
		resLabel = new JLabel("Server return String:");
		
		reqTfld = new JTextField();
		resTfld = new JTextField();
		
		sendBtn = new JButton("Send");
		
		sendBtn.addActionListener(new SendEchoAction());
		
		container = new JPanel();
		container.setLayout(new GridLayout(2, 3));
		
		container.add(reqLabel);
		container.add(reqTfld);
		container.add(sendBtn);
		
		container.add(resLabel);
		container.add(resTfld);
		
		mainFrame.setLayout(new FlowLayout(FlowLayout.CENTER));
		mainFrame.add(container);
		
	}
	
	public void sendEcho(String echo)
	{
		Socket snd = null;
		try 
		{
			snd = new Socket(TCPEchoServer.ADDR, TCPEchoServer.PORT);
			
			OutputStream out = snd.getOutputStream();
			
			out.write(echo.getBytes());
			
			InputStream in = snd.getInputStream();
			
			byte[] b = new byte[1024];
			
			int len = in.read(b);
			
			String resEcho = new String(b, 0, len); 
			resTfld.setText(resEcho);
		} 
		catch (Exception e1) 
		{
			e1.printStackTrace();
			resTfld.setText(e1.getMessage());
		}
		finally
		{
			if( snd != null )
			{
				try 
				{
					snd.close();
				} 
				catch (IOException e1)
				{
				}
			}
		}
	}
	
	
	public static void main(String[] args) {
		
		TCPEchoClient client = new TCPEchoClient();
		client.initUI();
	}
}
 运行客户端如下：

 
 
 多线程服务器端模型
 为服务器端增加多线程处理连接，因为Java基于TCP的实现具有阻塞特性，若多个Client连接进来却不能并发处理的话，这样效率很低。此处只需server做改动。
示例代码：
服务器端： 
public class TCPEchoMultiThreadServer extends TCPEchoServer{

	@Override
	public void handleReq(Socket clnt) throws IOException 
	{
                // 重写此方法，睡它一下，模拟处理延时
		try 
		{
			Thread.sleep(1500L);
		} 
		catch (InterruptedException e) 
		{
			e.printStackTrace();
		}
		super.handleReq(clnt);
	}
	
	@Override
	public void start() 
	{
		try 
		{
			ServerSocket srv = new ServerSocket(PORT, 0, InetAddress.getByName(ADDR));
			System.out.println("Echo multi-thread server start at port: " + PORT);
			
			while( true )
			{
				final Socket clnt = srv.accept();
				
				Thread thread = new Thread( new Runnable() 
					{
						@Override
						public void run() 
						{
							try 
							{
								handleReq(clnt);
							} 
							catch (IOException e) 
							{
								e.printStackTrace();
							}
						}
					}
				);
				
				thread.start();
                                // 打印出线程名字，可以看出每次请求都会新建线程来处理
				System.out.println(thread.getName());
			}
		} 
		catch (IOException e) 
		{
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) 
	{
		new TCPEchoMultiThreadServer().start();
	}
}
  
广播服务器模型：
玩Dota, LoL，当中同组的消息列就是属于广播模型
示例代码：
 Server 端： 
public class TCPEchoBroadcastServcer{

	public static final int PORT = 7777;
	
	public static final String ADDR = "127.0.0.1";
	
	public static final String LOGIN_CODE = "#login";
	
	public static final String LOGOUT_CODE = "#logout"; 

	public static final String REGISTER_NEED = "#yourID";
	
	public static final String FORMAL_MSG = "#fMsg";
	
	private Map<String, Socket> clntSocketList;
	
	public void start()
	{
		try 
		{
			ServerSocket ss = new ServerSocket( PORT, 0, InetAddress.getByName(ADDR) );
			System.out.println("Echo multi-thread server start at port: " + PORT);
			clntSocketList = new HashMap<String, Socket>();
			
			while( true )
			{
				final Socket clnt = ss.accept();
				
				Thread thread = new Thread( 
					new Runnable() 
					{
						@Override
						public void run() 
						{
							try 
							{
								handleReq(clnt);
							} 
							catch (IOException e) 
							{
								e.printStackTrace();
							}
						}
					}
				);
				
				thread.start();
				
			}
		} 
		catch (Exception e) 
		{
			e.printStackTrace();
		}
	}
	
	protected void handleReq(Socket clnt) throws IOException 
	{
		System.out.println("Client connected from: " + clnt.getInetAddress());
		
		InputStream dataIn = clnt.getInputStream();
		
		byte[] b = new byte[64]; 
		int len = dataIn.read(b);
		String req = new String(b, 0, len);
		
                // 这里实现比较挫，用了几个静态常量去区分消息种类，
                // FORMAL_MSG代表的是普通消息，LOGIN_CODEclient连进server端的消息
                // LOGOUT_CODE是离开server端消息
		if( req.indexOf(FORMAL_MSG) == -1 )
		{
			if( req.indexOf( "["+LOGIN_CODE+"]" ) == 0 )
			{
				String clntId = req.split(":")[1];
				
				clntSocketList.put(clntId, clnt);
				
				req = "New client login";
			}
			else if(  req.indexOf( "["+LOGOUT_CODE+"]" ) == 0 )
			{
				String clntId = req.split(":")[1];
				
				if( clntSocketList.containsKey(clntId) )
				{
					clntSocketList.get(clntId).close();
					clntSocketList.remove(clntId);
				}
				
				req = "A client left";
			}
		}
		else
		{
                        //普通消息需要进行截取字符串，比较挫，但一时想不出好办法。。。
			req = req.substring(req.indexOf(FORMAL_MSG)+FORMAL_MSG.length()+1, req.length());
		}
		
		_sendBroadcastMsg(req);
	}
	
	private synchronized void _sendBroadcastMsg( String msg ) throws IOException
	{
		for( String key: clntSocketList.keySet() )
		{
			Socket clnt = clntSocketList.get(key);
			if( !clnt.isClosed() && clnt.isConnected() )
			{
				this._sendMsg(clnt, msg);
				//out.close();
			}
		}
	}
	
	private void _sendMsg( Socket clnt, String msg ) throws IOException 
	{
		OutputStream out = clnt.getOutputStream();
		
		out.write(msg.getBytes());
	}
	
	public static void main(String[] args) 
	{
		new TCPEchoBroadcastServcer().start();
	}
}
 Client端： 
public class TCPEchoBroadcastClient {
	
	private String id;
	
	JFrame mainFrame;
	
	JPanel container;
	
	JPanel row1;
	
	JPanel row2;
	
	JLabel reqLabel;
	
	JLabel resLabel;
	
	JTextField reqTfld;
	
	JTextArea resTArea;
	
	JButton sendBtn;
	
	Socket connSocket;
	
	public TCPEchoBroadcastClient() 
	{
		this.id = UUID.randomUUID().toString();
	}
	
	private class SendEchoAction implements ActionListener
	{
		@Override
		public void actionPerformed(ActionEvent e) 
		{
			String reqStr = reqTfld.getText();
			
			sendEcho(reqStr);
		}
	}
	
	private class DisconnectAction extends WindowAdapter
	{
		@Override
		public void windowClosing(WindowEvent e) 
		{
			try 
			{
				_leftServer();
			} 
			catch (IOException e1) {}
			super.windowClosing(e);
		}
	}
	
	public void initUI() 
	{
		mainFrame = new JFrame("Echo Broadcast client");
		
		setCmpt();
		
		mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		mainFrame.addWindowListener(new DisconnectAction());
		
		//mainFrame.pack();
		mainFrame.setSize(500, 400);
		
		mainFrame.setResizable(false);
		
		mainFrame.setLocationRelativeTo(null);
		
		mainFrame.setVisible(true);
		
		_connectServer();
	}
	
	private void setCmpt() 
	{
		row1 = new JPanel();
		
		reqLabel = new JLabel("Input String:");
		resLabel = new JLabel("Server return String:");
		
		reqTfld = new JTextField();
		resTArea = new JTextArea();
		resTArea.setEditable(false);
		
		sendBtn = new JButton("Send");
		
		sendBtn.addActionListener(new SendEchoAction());
		
		container = new JPanel();
		
		GridBagLayout layout = new GridBagLayout();
		container.setLayout(layout);
	
		GridBagConstraints gbc = new GridBagConstraints();
		gbc.fill = GridBagConstraints.BOTH;
		gbc.insets = new Insets(2, 2, 2, 2);
		
		gbc.weightx = 1;
		gbc.gridwidth = 1;
		gbc.gridheight = 1;
		layout.setConstraints(reqLabel, gbc);
		container.add(reqLabel);
		
		gbc.weightx = 1;
		gbc.gridwidth = 1;
		gbc.gridheight = 1;
		gbc.ipadx = 220;
		layout.setConstraints(reqTfld, gbc);
		container.add(reqTfld);
		
		gbc.weightx = 1;
		gbc.gridwidth = 0;
		gbc.gridheight = 1;
		gbc.ipadx = 0;
		layout.setConstraints(sendBtn, gbc);
		container.add(sendBtn);
		
		JPanel resLbPanel = new JPanel();
		resLbPanel.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0));
		
		resLbPanel.add(resLabel);
		
		gbc.gridwidth = 1;
		gbc.gridheight = 1;
		layout.setConstraints(resLbPanel, gbc);
		container.add(resLbPanel);
		
		JScrollPane resTaPanel = new JScrollPane(resTArea);
		resTaPanel.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
		resTaPanel.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED);
		
		gbc.weighty = 1;
		gbc.gridwidth = 0;
		gbc.gridheight = 1;
		layout.setConstraints(resTaPanel, gbc);
		container.add(resTaPanel);
		
		mainFrame.add(container);
	}
	
	private void _connectServer()
	{
		try 
		{
			connSocket = new Socket(TCPEchoBroadcastServcer.ADDR, TCPEchoBroadcastServcer.PORT);
			
			this._registerToServer();
			
			Thread thread = new Thread(new Runnable() 
				{
					@Override
					public void run() 
					{
						try 
						{
							while( true )
							{
								_listenToServer();
							}
						} 
						catch (IOException e) 
						{
							e.printStackTrace();
						}
					}
				}
			);
			
			thread.start();
		} 
		catch (Exception e) 
		{
			e.printStackTrace();
			if( connSocket != null )
			{
				try 
				{
					connSocket.close();
				} 
				catch (IOException ie) {}
			}
		} 
	}
	
	private void _registerToServer() throws IOException
	{
		OutputStream out = connSocket.getOutputStream();
		
		String reqStr = "[" + TCPEchoBroadcastServcer.LOGIN_CODE + "]:" + this.id;
		out.write(reqStr.getBytes());
		
		out.flush();
	}
	
	private void _leftServer() throws IOException
	{
		Socket snd = new Socket(TCPEchoBroadcastServcer.ADDR, TCPEchoBroadcastServcer.PORT);
		
		OutputStream out = snd.getOutputStream();
		
		String reqStr = "[" + TCPEchoBroadcastServcer.LOGOUT_CODE + "]:" + this.id;
		out.write(reqStr.getBytes());
		
		out.flush();
		
		snd.close();
	}
	
	private void _listenToServer() throws IOException
	{
		if( connSocket.isClosed() )
		{
			return;
		}
		
		String resStr = null;
		
		InputStream in = connSocket.getInputStream();
		
		byte[] b = new byte[64];
		int len = in.read(b);
		if( len != -1 )
		{
			resStr = new String(b, 0, len);
			
			resTArea.append(resStr+"\n");
		}
	}
	
	public void sendEcho(String echo)
	{
		Socket snd = null;
		try 
		{
			snd = new Socket(TCPEchoBroadcastServcer.ADDR, TCPEchoBroadcastServcer.PORT);
			
			OutputStream out = snd.getOutputStream();
			
			echo = TCPEchoBroadcastServcer.FORMAL_MSG + ":" + echo;
			out.write(echo.getBytes());
			
			out.flush();
			
		} 
		catch (Exception e1) 
		{
			e1.printStackTrace();
		}
		finally
		{
			if( snd != null )
			{
				try 
				{
					snd.close();
				} 
				catch (IOException e1){}
			}
		}
	}
	
	public static void main(String[] args) 
	{
		TCPEchoBroadcastClient client = new TCPEchoBroadcastClient();
		client.initUI();
	}
}
 

 
UDP通讯方式
最后是基于UDP传输协议的一个demo，具体应用场景还不太清楚。。。
Server 端： 
public class UDPEchoServer {

	public static final int PORT = 7777;
	public static final String ADDR = "127.0.0.1";
	
	public static void main(String[] args) {
		
		DatagramSocket srv = null;
		try 
		{
			byte[] buffer = new byte[1024];
			
			srv = new DatagramSocket(PORT);
			
			DatagramPacket packet = new DatagramPacket(buffer, 1024);
			System.out.println("Server is ready, Waiting requset come...");
			
			while( true )
			{
				srv.receive(packet);
				
				InetAddress clntAddr = packet.getAddress();
				
				int clntPort = packet.getPort();
				
				System.out.println("A request package from: " + clntAddr + " # " + clntPort);
				
				String str = new String(packet.getData());
				
				String echo = str.toUpperCase();
				
				DatagramPacket resPacket = new DatagramPacket(echo.getBytes(), echo.length(), clntAddr, clntPort);
				
				srv.send(resPacket);
			}
		} 
		catch (Exception e) 
		{
			if( srv != null )
			{
				srv.close();
			}
		}
	}
}
 
客户端： 
public class UDPEchoClient {

JFrame mainFrame;
	
	JPanel container;
	
	JLabel reqLabel;
	
	JLabel resLabel;
	
	JTextField reqTfld;
	
	JTextField resTfld;
	
	JButton sendBtn;
	
	private class SendEchoAction implements ActionListener
	{
		@Override
		public void actionPerformed(ActionEvent e) 
		{
			String reqStr = reqTfld.getText();
			
			sendEcho(reqStr);
		}
	}
	
	public void initUI() 
	{
		mainFrame = new JFrame("Echo client");
		
		setCmpt();
		
		mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		mainFrame.pack();
		
		mainFrame.setLocationRelativeTo(null);
		
		mainFrame.setVisible(true);
	}
	
	private void setCmpt() 
	{
		reqLabel = new JLabel("Input String:");
		resLabel = new JLabel("Server return String:");
		
		reqTfld = new JTextField();
		resTfld = new JTextField();
		
		sendBtn = new JButton("Send");
		
		sendBtn.addActionListener(new SendEchoAction());
		
		container = new JPanel();
		container.setLayout(new GridLayout(2, 3));
		
		container.add(reqLabel);
		container.add(reqTfld);
		container.add(sendBtn);
		
		container.add(resLabel);
		container.add(resTfld);
		
		mainFrame.setLayout(new FlowLayout(FlowLayout.CENTER));
		mainFrame.add(container);
		
	}
	
	public void sendEcho(String echo)
	{
		DatagramSocket clnt = null;
		
		try 
		{
			clnt = new DatagramSocket();
			
			byte[] sndEcho =  echo.getBytes();
			
			InetAddress addr = InetAddress.getByName(UDPEchoServer.ADDR);
			
			DatagramPacket packet = new DatagramPacket(sndEcho, sndEcho.length, addr, UDPEchoServer.PORT);
			
			clnt.send(packet);
			
			clnt.receive(packet);
			
			byte[] resData =  packet.getData();
			
			resTfld.setText(new String(resData));
		} 
		catch (Exception e) 
		{
			clnt.close();
		}
	}
	
	public static void main(String[] args) 
	{
		UDPEchoClient client = new UDPEchoClient();
		
		client.initUI();
	}
}
 
gwoham
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java|Socket编程指南
Autovy blog
05-04 2511
概述 Socket编程是指编写在多台计算机上执行的程序，其中的设备都使用网络相互连接 Socket常用的通信协议有UDP和TCP，本文主要介绍通过TCP/IP网络协议进行Socket编程 Socket通信流程 服务端和客户端初始化 socket，得到文件描述符； 服务端调用 bind，将绑定在 IP 地址和端口; 服务端调用 listen，进行监听； 服务端调用 accept，等待客户端连接； 客户端调用 connect，向服务器端的地址和端口发起连接请求； 服务端 accept 返回用于传输的 soc
Java基础——Socket：随想笔记
Zain_horse的博客
02-14 101
Java基础——Socekt的使用
JavaSocket编程简单入门
AAS48的博客
09-21 942
【网络知识基础】： 书本官方上说Socket就是{ip:port}的组合。 之后我也看了很多解释Socket的博文，各有各的好，接下来谈谈我个人的看法。 我个人的理解是，在传输层中，socket就能唯一确定一个应用进程。因为，我们可以通过ip地址确定该用户的主机地址，然后可以通过port端口号确定是哪个进程在发出请求或相应。 Socket英文是插座、接口这种意思。其实Socket的工作过程和电话机...
Java Socket几个简单的入门示例
杂七杂八
10-18 4761
Socket是面向网络传输层的编程接口，需要程序员直面网络连接，字节流的读写，数据包的解析等。其难点在于服务端的迸发性能处理、数据格式的定义与拆解，在程序底层的算法上会有一定要求，更加考验程序员的编程技巧。
JAVA Socket入门 附带网络基础知识
qq_42429369的博客
07-26 140
引入 1. 网络架构模型 网络架构模型主要有OSI参考模型和TCP/IP五层模型。   1.1 OSI参考模型 OSI（Open System Interconnect），即开放式系统互联。 OSI定义了网络互连的七层框架（物理层、数据链路层、网络层、传输层、会话层、表示层、应用层）。 ps:简单记忆：物数网传会表应   1.2 TCP/IP五层模型 TCP/IP五层协议（物理层、数据链路层、网络层、传输层、应用层）。 ps：会话层、表示层、应用层 同一称为应用层。 2. TCP协议和U
java通信socket入门实例
03-16
在这个"java通信socket入门实例"中，我们将探讨如何使用Java的Socket API来建立连接、交换数据以及关闭连接。这个入门示例可能包括了客户端（Client）和服务器端（Server）两部分代码，帮助初学者理解Socket通信的...
java socket入门经典代码
05-15
这些入门示例可以帮助你理解Socket通信的基本流程，为进一步深入学习Java网络编程打下坚实基础。记得实践是检验真理的唯一标准，动手编写和运行代码是学习的最佳方式。在实践中遇到问题，不要忘记查阅相关文档或寻求...
Java的Socket网络编程基础知识入门教程
09-02
在本文中，我们将深入理解Java Socket的基本概念，包括TCP/IP协议的基础知识，以及如何使用Java实现TCP和UDP协议的简单示例程序。 首先，TCP/IP协议族是互联网的核心，它包含了多个协议，如IP、TCP和UDP。IP协议...
java小白入门.rar
08-06
Java小白入门是一个针对初学者的综合教程，涵盖了Java编程的基础概念和重要知识点。这个压缩包文件"java小白入门.rar"显然是为了帮助新手快速理解和掌握Java编程语言。让我们深入探讨一下其中可能涵盖的内容。 首先...
一个简单的java socket程序
10-29
一个简单的socket程序，一个服务端对应一个客户端的... 最简单的 入门级..
Java网络编程——Socket 编程
热门推荐
涛涛的个人博客
07-17 1万+
Java网络编程——Socket 编程
socket入门
qq_21277357的博客
12-12 197
tcp就是和对方建立连接后，我才能发送消息，连接需要三次握手，断开连接需要4次挥手。udp就是不需要等待对方连接，就可以直接发送消息，如果对方没有连接上，也不会报错。最后就在f盘生成了一个aa的文件。先启动服务端，在启动客户端。
Java的Socket简单入门
吹大的草的博客
05-21 169
聊天室的简单实现 服务端代码 /** * @author gjw * @createTime 2019/5/21 19:06 */ public class FirstSocket { public static void main(String[] args) throws IOException { int linkCount = 0; //建...
java socket 简书_Java之Socket编程入门篇
weixin_39956612的博客
02-26 104
1、什么是SocketSocket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，他把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。2、几个专用名词IP：每个计算机都有对应的唯一标识即IP地址，IP地址格式为：255.255.255.255。目前是第...
入门Java socket的一个完整实例
Jack_xiaochen的博客
09-11 4201
文件1：SocketServer.java        ----&gt;        Socket服务器端 package com.socket;      import java.net.ServerSocket;      /**   * 服务器端Socket   *    * @author Administrator   *    */   public class SocketSe...
Java小白入门 —— 网络编程之Socket
qq_43190579的博客
10-28 328
Java小白入门 —— 网络编程之Socket 一. 什么是网络模型？ 网络模型是一个设备发送数据给另一个设备，然后接收另一个设备的反馈，目前最主要的网络编程都是基于请求/响应方式的。 在网络编程中，发起请求的一方称作为客户端（Client），等待其他程序连接的一方成为服务端（Server）。客户端程序可以在需要时启动，而服务端程序需要一直保持响应状态。 在有些程序中，既可以作为客户端，也可以作为服务端。 二. IP及域名： IP地址： IP地址是用来唯一标识互联网上计算机的逻辑地址,让电脑之间可以相互通信
Java socket
IT小白的博客
08-26 148
返回本地IP地址，用getLocalAddress()方法。（获取套接字绑定的本地地址。） 返回连接的 ip 地址，用 getInetAddress() 方法。 测试是否启用 SO_REUSEADDR，用 getReuseAddress()方法。 返回此套接字绑定到的本地端口，用 getLocalPort() 方法。 ...
Java Socket 简单编程实例
糖小喵
06-27 4139
之前照着书写了一个实例，最后一次java实验也就结束了，后来还有一个是写计算机网络课程设计好像写到了套接字Socket 现在又把重新拿出来，感觉是有不少东西要学习的。 所谓socket通常也称作"套接字"。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。 事实上网络编程简单的理解就是两台计算机相互通讯数据而已，对于Java而言，这些Api存在与java.net 这个包里面.因此只要
java socket plc 通信_Java入门 - 高级教程 - 05.网络编程
最新发布
06-09
好的，你的问题是关于Java socket和PLC通信的。在Java中，可以使用Socket API来实现网络编程，包括与PLC通信。下面是一个简单的Java代码示例，用于向PLC发送数据： ```java import java.io.*; import java.net.*; public class PLCClient { public static void main(String[] args) throws IOException { String hostName = "localhost"; // PLC的IP地址 int portNumber = 12345; // PLC监听的端口号 try (Socket socket = new Socket(hostName, portNumber); PrintWriter out = new PrintWriter(socket.getOutputStream(), true); BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))) { String userInput; while ((userInput = stdIn.readLine()) != null) { out.println(userInput); // 向PLC发送数据 System.out.println("PLC返回的数据：" + in.readLine()); // 读取PLC返回的数据 } } catch (UnknownHostException e) { System.err.println("无法连接到主机：" + hostName); System.exit(1); } catch (IOException e) { System.err.println("无法在端口 " + portNumber + " 上进行连接。"); System.exit(1); } } } ``` 在这个例子中，我们使用了Socket类来建立与PLC的连接，并使用PrintWriter和BufferedReader类来读写数据。当我们向PLC发送数据时，我们可以使用out.println()方法，当我们接收到PLC返回的数据时，我们可以使用in.readLine()方法。 请注意，这只是一个简单的例子，实际上，与PLC通信可能需要使用特定的协议和数据格式。同时需要考虑到网络延迟和数据丢失等问题。因此，如果需要进行生产环境的PLC通信，请务必仔细研究PLC的通信协议和数据格式，以确保数据的正确传输和处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值