`
shihuan830619
  • 浏览: 582965 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

Java Socket长连接示例代码

    博客分类：
  • J2SE
javasocket长连接 
阅读更多
SocketListenerPusher.java代码如下: 
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.commons.configuration.ConfigurationException;
import org.directwebremoting.impl.DaemonThreadFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.shihuan.dragonkeeper.common.utils.PropertiesUtil;
import com.shihuan.dragonkeeper.global.ConfigFile;

public class SocketListenerPusher implements Runnable {

	protected static Logger logger = LoggerFactory.getLogger(SocketListenerPusher.class);
	
	public static String socketlistenerserver_CONFIG = ConfigFile.SOCKETLISTENERSERVER__CONFIG + ConfigFile.SUFFIX_NAME;
	
	private ServerSocket serverSocket;
    private ExecutorService pool;
    
	
	public SocketListenerPusher() {
		int port = 0;
		int poolsize = 0;
		
		try {
			port = Integer.parseInt(PropertiesUtil.getPropertiesValue(socketlistenerserver_CONFIG, "serverport"));
			poolsize = Integer.parseInt(PropertiesUtil.getPropertiesValue(socketlistenerserver_CONFIG, "poolsize"));
			
			serverSocket = new ServerSocket();
			serverSocket.setReuseAddress(true);
			serverSocket.bind(new InetSocketAddress(port));
		    pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * poolsize);
		    
		    //下面两句循环执行run()方法, 相当于while(true){...}
		    ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1, new DaemonThreadFactory());
			executor.scheduleAtFixedRate(this, 1L, 1L, TimeUnit.MILLISECONDS);
			
		} catch (NumberFormatException e) {
			logger.error(e.getMessage(), e);
			e.printStackTrace();
		} catch (ConfigurationException e) {
			logger.error(e.getMessage(), e);
			e.printStackTrace();
		} catch (IOException e) {
			logger.error(e.getMessage(), e);
			e.printStackTrace();
		}

	}
	
	public void run() {
		Socket socket = null;
		try {
			socket = serverSocket.accept();
			pool.execute(new SocketListenerHandler(socket));
		} catch (IOException e) {
			System.out.println("线程池被关闭!!!!!!!!!!!");
			pool.shutdown();
			logger.error(e.getMessage(), e);
			e.printStackTrace();
		}
		
	}

SocketListenerHandler.java代码如下: 
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.net.Socket;
import java.sql.Connection;
import java.sql.SQLException;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.dbutils.DbUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.io.IOUtils;
import org.directwebremoting.Browser;
import org.directwebremoting.ScriptSessions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.fastjson.JSON;
import com.shihuan.dragonkeeper.common.dto.DataSourceInfo;
import com.shihuan.dragonkeeper.common.utils.ByteArrayUtil;
import com.shihuan.dragonkeeper.common.utils.DataSourceMapUtil;
import com.shihuan.dragonkeeper.common.utils.DateFormatterUtil;
import com.shihuan.dragonkeeper.common.utils.PropertiesUtil;
import com.shihuan.dragonkeeper.global.ConfigFile;
import com.shihuan.dragonkeeper.server.bean.ActivityServiceBean;

public class SocketListenerHandler implements Runnable {

	protected static Logger logger = LoggerFactory.getLogger(SocketListenerHandler.class);
	
	private static String jdbc_CONFIG = ConfigFile.JDBC_CONFIG + ConfigFile.SUFFIX_NAME;
    
    public static final int timeOut = 0*1000 ;  //设置读取操作异常为1秒
    private final String dataRealTimeAction_id = "Agentdata_" + Math.random();
    
    private static final String noData = "{'nodata':'心跳信息'}";
	private static final String errorData = "{'error':'无法解析的请求'}";
    
	
	private Socket connectedsocket = null;
	
	public SocketListenerHandler(Socket socket){
		this.connectedsocket = socket;
	}

@Override
	public void run() {
		BufferedReader in = null;
String resultData = "";
		
		try {
			connectedsocket.setSoTimeout(timeOut);  //表示接收数据时的等待超时数据, 此方法必须在接收数据之前执行才有效. 此外, 当输入流的 read()方法抛出 SocketTimeoutException后, Socket仍然是连接的, 可以尝试再次读数据, 单位为毫秒, 它的默认值为 0(表示会无限等待, 永远不会超时)
			connectedsocket.setKeepAlive(false);   //表示对于长时间处于空闲状态的Socket, 是否要自动把它关闭.
			
			in = new BufferedReader(new InputStreamReader(connectedsocket.getInputStream()));
if (in.ready()) {  //判断流中是否有数据
				
				resultData = getNoHeadData(in.readLine());   //从Agent端接收到的数据
				logger.info("#### 结果DATA = "+resultData);
				
				if (resultData==null || "".equals(resultData)) {
					logger.info(dataRealTimeAction_id + " -->>> " + "内容为空!");
				} else if (resultData.charAt(0) != '{') {  //要在客户端定时维持心跳信息
					logger.info(dataRealTimeAction_id + " -->>> " + noData);
				} else {
					ActivityServiceBean asb = JSON.parseObject(resultData, ActivityServiceBean.class);
					System.out.println("打印预处理信息Start......");
					System.out.println(asb.getProxyname() + " -- " + asb.getIp() + " -- " + asb.getCalltime() + " -- " + asb.getAnswertime() + " -- " + asb.getCpu() + " -- " + asb.getThread() + " -- " + asb.getStatus() + " -- " + asb.getAccessaddress() + " -- " + asb.getAccessfilename() + " -- " + asb.getSql() + " -- " + asb.getContent());
					System.out.println("打印预处理信息End......");
//					parseData(ois);
					
					logger.info(dataRealTimeAction_id + ": 成功处理了接收到的数据!");
				}
				
			}
} catch (IOException e) {
			logger.error(e.getMessage() + " " + errorData, e);
			e.printStackTrace();
		} catch (NumberFormatException e) {
			logger.error(e.getMessage(), e);
			e.printStackTrace();
		} finally {
			
			if (in != null) {
				try {
					in.close();
				} catch (IOException e) {
					logger.error(e.getMessage(), e);
					e.printStackTrace();
				}
			}
}
		
	}


TestSocketListenerPusher.java请求端代码如下: 
import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Date;

import org.apache.commons.configuration.ConfigurationException;

import com.alibaba.fastjson.JSON;
import com.shihuan.dragonkeeper.common.utils.ByteArrayUtil;
import com.shihuan.dragonkeeper.common.utils.PropertiesUtil;
import com.shihuan.dragonkeeper.global.ConfigFile;
import com.shihuan.dragonkeeper.server.bean.ActivityServiceBean;

public class TestSocketListenerPusher implements Runnable {

	private static String socketlistenerserver_CONFIG = ConfigFile.SOCKETLISTENERSERVER__CONFIG + ConfigFile.SUFFIX_NAME;
	
	private Socket socketclient = null;
	
	@Override
	public void run() {
		
		String serverip = "";
		int port = 0;
		
		OutputStream os = null;
		
		try {
			serverip = PropertiesUtil.getPropertiesValue(socketlistenerserver_CONFIG, "serverip");
			port = Integer.parseInt(PropertiesUtil.getPropertiesValue(socketlistenerserver_CONFIG, "serverport"));
			
			
			ActivityServiceBean asb = null;
			
			for (int i=0; i<2; i++) {
				asb = new ActivityServiceBean();
				asb.setProxyname("testProxyname"+i);
				asb.setIp("testIp"+i);
				Date curdate = new Date();
				asb.setCalltime(curdate);
				asb.setAnswertime(curdate);
				asb.setCpu("testCpu"+i);
				asb.setThread("testThread"+i);
				asb.setStatus("testStatus"+i);
				asb.setAccessaddress("testAccessaddress"+i);
				asb.setAccessfilename("testAccessfilename"+i);
				asb.setSql("testSql"+i);
				asb.setContent("testContent"+i);
				
				String jsonStr = JSON.toJSONString(asb).trim();
				byte[] information = (new String(ByteArrayUtil.getIntToByte(jsonStr.length()))+jsonStr).getBytes();
				
				System.out.println(information.length);
				
				socketclient = new Socket(serverip, port);
				socketclient.setSoTimeout(0);
				socketclient.setKeepAlive(false);
				
				os = new BufferedOutputStream(socketclient.getOutputStream());
				os.write(information);
				os.flush();
				
				System.out.println("Client" + i + " -->>> " + new String(ByteArrayUtil.getIntToByte(jsonStr.length()))+jsonStr);
				
				os.close();
				Thread.sleep(3000);
			}
			
			
		} catch (ConfigurationException e) {
			e.printStackTrace();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			/*
			try {
				if (os != null) {
					os.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
			*/
		}
		
		
	}
	
	public static void main(String[] args) {
		Thread t = new Thread(new TestSocketListenerPusher());
		t.start();
	}

}



源代码在笔者shihuan8@163.com邮箱网盘中J2EE代码文件夹里。

----------------------------------------------------------------------------------
如果是按byte[]传输数据的情况,请参考如下代码:

SimpleSocketServer.java代码如下: 
package com.shihuan.socket;

import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class SimpleSocketServer {

	public static void main(String[] args) {
		try {
			ServerSocket ss = new ServerSocket();
			ss.setReuseAddress(true);  //两个进程共用同一个端口的时候,一个进程关闭后,另一个进程还能够立刻重用相同端口
            ss.setReceiveBufferSize(128*1024);  //缓冲区中允许接收的最大字节数,默认是8192
            ss.bind(new InetSocketAddress(19990)); 
			
			Socket client = ss.accept();
			InputStream in = new BufferedInputStream(client.getInputStream());
			
			byte tmpb = (byte)in.read();
			System.out.println("第一个字节的byte值 --->> " + tmpb);
			System.out.println("接收字节 --->> " + in.available());
			byte[] bc = new byte[in.available()+1];
			bc[0] = tmpb;
			in.read(bc, 1, in.available());
			
			System.out.println(bc.length);
			System.out.println(new String(bc));
			in.close();
		} catch (IOException e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}

	}

}


SimpleSocketClient.java代码如下: 
package com.shihuan.socket;

import java.io.BufferedOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

public class SimpleSocketClient {

	public static void main(String[] args) throws UnknownHostException {
		try {
			Socket s = new Socket("192.168.1.10", 19990);
			OutputStream os = new BufferedOutputStream(s.getOutputStream());
			String info = "abc!";
			info = "大家好!";
			byte[] bi = info.getBytes();
			os.write(bi);
			os.flush();
			os.close();
		} catch (IOException e) {
			System.out.println(e.getMessage());
			e.printStackTrace();
		}
	}

}


稍微复杂一点儿代码示例，处理了粘包问题：
StartListenerTcpThread.java代码: 
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.util.Vector;
import java.util.concurrent.ExcutorService;
import java.util.concurrent.Excutors;

import org.apache.commons.io.IUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.shihuan.dragonkeeper.common.utils.ByteArrayUtil;
import com.shihuan.dragonkeeper.global.ConfigFile;

public class StartListenerTcpThread implements Runnable {
   public static Logger logger = LoggerFactory.getLogger(StartListenerTcpThread.class);

   private static ExcutorService Threadpool = Excutors.newCachedThreadPool();
   private static boolean businessflag = true;
   private static final int receiveBufferSize = 128;
   private static Vector<byte[]> tmpbytes = new Vector<byte[]>();
   private ServerSocket serverSocket = null;

   public StartListenerTcpThread(String ip, int port){
      try{
         serverSocket = new ServerSocket();
         serverSocket.setReuseAddress(true);
         serverSocket.setReceiveBufferSize(receiveBufferSize*1024);
         serverSocket.setSoTimeout(0);
         SocketAddress sa = new InetSocketAddress(port);
         serverSocket.bind(sa, 20);
      }catch(IOException e){
         logger.error(e.getMessage(), e);
      }
   }

   public void run(){
      Socket socket = null;
      while(true){
         if(businessflag){
            try{
               socket = serverSocket.accept();
               System.out.println("New connection accepted " + socket.getInetAddress() + ":" + socket.getPort());
               InputStream socketIn = new BufferedInputStream(socket.getInputStream());
               byte tmpb = (byte)socketIn.read();
               byte[] currentbytes = null;
               if(tmpbytes.size() > 0){  //上一次IO流中有未处理的剩余包
                  int oldBytesLen = tmpbytes.get(0).length;
                  int socketBytesLen = socketIn.available()+1;
                  int currentLength = oldByteLen + socketBytesLen;
                  currentbytes = new byte[currentLength];
                  System.arraycopy(tmpbytes.get(0), 0, currentbytes, oldBytesLen);
                  currentbytes[oldBytesLen] = tmpb;
                  socketIn.read(currentbytes, oldBytesLen+1, socketBytesLen-1);
                  socketIn.close();
                  splitInputStreamByte(currentbytes);
               }else{  //正常未粘包情况
                  int socketBytesLen = socketIn.available()+1;
                  currentbytes = new byte[socketBytesLen];
                  currentbytes[0] = tmpb;
                  socketIn.read(currentbytes, 1, socketBytesLen-1);
                  socketIn.close();
                  splitInputStreamByte(currentbytes);
               }
            }catch(IOException e){
               logger.error(e.getMessage(), e);
            }
         }
      }
   }

   /**
    * 拆分byte数组并分多线程处理
    * @param parambytes 原byte数组
    * @return 处理后剩余部分的byte数组
   */
   private static void splitInputStreamByte(byte[] parambytes) {
      if(parambytes != null){
         if(parambytes.length > 4){
            byte[] head = new byte[4];  //单包长度
            System.arraycopy(parambytes, 0, head, 0, 4);
            int bodyLength = ByteArrayUtil.getint(head);
            if(bodyLength <= parambytes.length-4){
               final byte[] body = new byte[bodyLength];
               System.arraycopy(parambytes, 4, body, 0, bodyLength);
               ThreadPool.execute(new Runnable(){
                  public void run(){
                     byte[] processDatas = body;
                     try{
                        System.out.println(IOUtils.toString(processDatas, "UTF-8").trim());
                     }catch(IOException e){
                        logger.error(e.getMessage(), e);
                     }
                  }
               });

               int resultLen = parambytes.length-4-bodyLength;
               if(resultLen == 0){
                  splitInputStreamByte(null);
               }else{
                  byte[] resultbytes = new byte[resultLen];
                  System.arraycopy(parambytes, 4+bodyLength, resultbytes, 0, resultLen);
                  splitInputStreamByte(resultbytes);
               }
            }else{
               tmpbytes.clear();
               tmpbytes.add(parambytes);
            }
         }else{
            tmpbytes.clear();
            tmpbytes.add(parambytes);
         }
      }
   }

   public static void openflag(){
      businessflag = true;
   }

   public static void closeflag(){
      businessflag = false;
   }

}


TestTcpSocket.java代码： 
import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

import com.shihuan.dragonkeeper.common.utils.ByteArrayUtil;
import com.shihuan.dragonkeeper.global.ConfigFile;

public class TestTcpSocket implements Runnable{
   private Socket socketClient = null;

   public void run(){
      String serverip = "192.168.1.10";
      int port = 19990;
      try{
         while(true){
           System.out.println("SocketClient start......");
           String mystr = "hello everyone!";
           socketClient = new Socket(serverip, port);
           OutputStream os = socketClient.getOutputStream();
           byte[] head = ByteArrayUtil.int2byte(mystr.length());
           byte[] body = mystr.getBytes();
           byte[] total = ByteArrayUtil.byteMerge(head, body);

           os.write(total);
           os.flush();
           os.close();

           Thread.sleep(1000);

           System.out.println("SocketClient end......");
         }
      }catch(Exception e){
         logger.error(e.getMessage(), e);
      }
   }

   public static void main(String[] args){
      Thread t = new Thread(new TestTcpSocket());
      t.start();
   }
}


下面写ByteArrayUtil.java代码： 
package com.shihuan.dragonkeeper.common.utils;

public class ByteArrayUtil {

   /**
    * 将int型的数据类型转换成byte[]类型
   */
   public static final byte[] int2byte(int paramInt){
      byte[] resultByte = new byte[4];
      resultByte[3] = ((byte)(paramInt & 0xFF));
      resultByte[2] = ((byte)(paramInt >>> 8 & 0xFF));
      resultByte[1] = ((byte)(paramInt >>> 16 & 0xFF));
      resultByte[0] = ((byte)(paramInt >>> 24 & 0xFF));

      return resultByte;
   }

   /**
    * 将byte型的数据类型转换成int类型
   */
   public static final int getint(byte[] paramArrayOfByte){
      int result = (paramArrayOfByte[0] & 0xFF) << 24 | (paramArrayOfByte[1] & 0xFF) << 16 | (paramArrayOfByte[2] & 0xFF) << 8 | paramArrayOfByte[3] & 0xFF;
      return result;
   }

   /**
    * 合并两个byte数组到一个byte数组中
   */
   public static byte[] byteMerge(byte[] byte1, byte[] byte2){
      byte[] result = new byte[byte1.length+byte2.length];
      System.arraycopy(byte1, 0, result, 0, byte1.length);
      System.arraycopy(byte2, 0, result, byte1.length, byte2.length);
      return result;
   }
}


http://blog.csdn.net/defonds/article/details/8782785
分享到：
| cpdetector_1.0.10_binary下载
评论
5 楼 wdloyeu 2016-11-12  
shihuan8@163.com邮箱网盘在哪，没找到。
能给份源码吗：发我的邮箱：2017-93-2088@qq.com
谢谢！
4 楼 开奔驰遛宝马 2016-08-31  
能分享一份源码吗？ feng2400650@163.com
3 楼 romi0913 2016-07-13  
求源码，yannan_mail@163.com,拜托大神
2 楼 liu129jun 2016-06-05  
能给份源码吗？274474385@qq.com
1 楼 jethai 2015-08-17  
大神能不能给个源码，我的邮箱jethai@126.com
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java程序socket编程示例代码

    Java程序socket编程示例代码 Java程序socket编程是Java语言中的一种网络编程方式，主要用于实现客户机/服务器（C/S）架构的通信。下面是Java程序socket编程的示例代码，包括Server端和Client端的实现。 Socket编程...

    java socket 长连接实例

    "Java Socket 长连接实例"是关于如何实现一个持久连接的服务器和客户端程序的示例，这种连接能够保持开放，直到一方明确地关闭它。这在需要频繁通信或者需要长时间保持连接状态的应用场景中非常有用，比如聊天应用、...

    java socket长连接客户端服务端（标准实例）

    本文将详细解读“Java Socket长连接客户端服务端（标准实例）”的相关知识点，包括其实现原理、代码解析及应用示例。 #### 一、Socket通信概述 Socket是应用程序与网络之间的桥梁，它提供了网络上两个程序之间双向...

    Java Socket 聊天通信演示代码

    在本示例中，我们将深入探讨Java Socket如何用于构建一个简单的聊天应用。 首先，Java Socket通信基于TCP（传输控制协议），它确保了数据的可靠传输，包括数据的顺序和无丢失。在聊天应用中，服务器端创建一个...

    java socket 客户端代码

    下面是一个简单的Java Socket客户端示例，用于连接到一个聊天服务器： ```java import java.io.*; import java.net.*; public class ChatClient { public static void main(String[] args) { try (Socket socket...

    java socket异步长连接demo

    "异步长连接"是Java Socket编程中一种高效且广泛使用的通信模式，它允许客户端和服务器保持连接状态，以便在需要时快速交换数据，而无需反复建立和关闭连接。 在Java中，通常使用`java.net.Socket`和`java.net....

    Java Socket传输图片源代码

    3. **Socket连接过程**： - 服务器端首先创建一个`ServerSocket`实例，并调用`bind()`方法绑定到特定的IP地址和端口号，然后调用`accept()`方法监听客户端连接。 - 客户端创建`Socket`实例，通过`connect()`方法...

    Socket长连接+心跳包+发送读取

    Socket长连接是网络编程中的重要概念，主要...在提供的压缩包文件中，可能包含了实现这些功能的示例代码，可以作为学习和开发Socket长连接应用的参考。通过对这些代码的阅读和理解，可以深入掌握Socket编程的核心技术。

    Socket连接示例代码

    在这个"Socket连接示例代码"中，我们将深入探讨Socket的基本概念、工作原理以及如何通过客户端和服务器进行本地或局域网通信。 首先，Socket在计算机网络中扮演着桥梁的角色，它允许两个程序（通常是一个服务器和一...

    Java_socket 通信示例（Java源码）

    在压缩包中的"java_socket共享示例"可能包含了服务端和客户端的源代码，包括Java类、主函数以及必要的数据传输逻辑。分析这些源代码，可以帮助我们更深入地理解Java Socket通信的工作原理。 总之，这个Java_socket...

    JAVA Socket通信示例

    Java Socket默认支持这种通信模式，因为Socket连接一旦建立，双方都可以读写数据，但一次只能读或写，不能同时进行。例如，服务器先发送数据，然后客户端响应，接着客户端再发送数据，服务器回应，以此类推。 **3. ...

    Java 长链接示例

    本示例将探讨如何在Java中实现长连接，并结合心跳检测来保持连接的活性。 首先，让我们了解TCP长连接的概念。TCP是一种面向连接的、可靠的传输协议，它会在数据传输前先建立连接，传输完成后断开连接。然而，对于...

    java与plc通讯示例代码

    本示例代码利用了Modbus协议，这是一种广泛应用于工业设备间通信的开放标准协议。Modbus4J是一个Java库，它允许Java应用程序通过Modbus与各种设备进行交互，包括PLC。 Modbus是一种串行通信协议，最早由Schneider ...

    Android-Socket长连接通信心跳包消息回调Java服务端

    这个压缩包可能包含了一个完整的Socket通信示例项目，包括Android客户端和Java服务端代码。通过分析和学习这个项目，你可以更直观地了解上述知识点的实现方式，包括如何创建Socket连接、实现心跳包、处理消息回调...

    Java Socket示例

    - **客户端代码**：客户端创建Socket连接到服务器，然后打开输入输出流进行读写操作。用户输入的消息通过输出流发送到服务器，服务器接收到消息后广播给所有已连接的客户端。 - **消息传输**：在聊天工具中，消息...

    java socket 长连接

    - `MoreClient.java`: 这可能是实现多客户端连接的类，可能会使用线程池来管理多个Socket连接。 - `MoreServer.java`: 处理多个客户端连接的服务器端代码，可能包含线程池和心跳机制。 - `Client.java`: 单个...

    java socket 文件传输 示例

    本示例将详细介绍如何在Android平台上使用Java Socket进行文件传输。 首先，我们需要创建一个服务器端（Server）来监听和接收连接请求。在提供的文件`Server.java`中，通常会包含以下步骤： 1. 导入必要的库，如`...

    JAVA socket收发数据，并支持断网自动连接

    8. **示例代码片段** - 客户端： ```java Socket socket = new Socket("localhost", 1234); DataOutputStream out = new DataOutputStream(socket.getOutputStream()); out.writeUTF("Hello, Server!"); ...

    Java基于Socket文件传输示例

    这个"Java基于Socket文件传输示例：服务器端和客户端"的文档很可能会详细讲解以上步骤，并提供实际的代码示例，帮助读者理解如何在Java中实现Socket文件传输。通过实践这样的示例，开发者可以深入理解网络编程的基本...

    socket示例代码

    本示例代码包括客户端和服务端两部分，旨在展示如何通过Java的Socket API进行基本的通信。 在Java中，`java.net.Socket`类代表一个客户端Socket，用来连接到服务器的特定端口。`java.net.ServerSocket`类则用于...

Magicbox
Global site tag (gtag.js) - Google Analytics