Socket通信怎样保持长连接？

2010-07-16 11:04:20 1.3万阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

振动分析中相位的确定更是定位不平衡量角度的关键。是确定振动信号与转子旋转位置之间时间关系的核心步骤，而。以内，以确保校正配重安装角度的有效性。在实际动平衡中，相位角的误差需控制在。在振动分析和动平衡中，阅读详情

想通过如下方法来达到长连接的效果，但是总是不行，希望各位大虾指点~



//客户端

import java.io.*;

import java.net.Socket;

import java.net.UnknownHostException;



public class Client {

    static int RMIPort = 9999;



    public static void main(String[] args) throws ClassNotFoundException {

    	try {

				Socket socket = new Socket("127.0.0.1",9999);

				while(true)

				{

                                           

					ObjectInputStream serverinput = new ObjectInputStream(socket.getInputStream());



                                              if(serverinput.readobject()!=null)

                                            {                                           

					new ClientThread(serverinput);

                                             }

				}

			

		} catch (UnknownHostException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

}



//服务端

import java.io.*;

import java.net.*;

import java.util.ArrayList;



public class Server{

    

    public static void main(String[] args) {

    	System.out.println("开始侦听请求 。。。。");   

        ServerSocket serverSocket;

		try {

				serverSocket = new ServerSocket(9999);

				//服务器套接字   

				Socket clientSocket=null;   

				clientSocket=serverSocket.accept();//获得客户端的请求的Socket   

				System.out.println("已侦听到了客户端的请求。。。。。");

				ArrayList al = new ArrayList();

				al.add("nihao");

    

				while(true)

				{

					OutputStream os = clientSocket.getOutputStream();			

					ObjectOutputStream oos=new ObjectOutputStream(os);

					oos.writeObject(al);

					oos.flush();

					oos.close();

				}

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

    }

  

}

服务端在accept之后能够任意的写对象给客户端，而客户端则通过不停地检测serverinput 是否为空来判断是否开线程执行.我想要达到这样的效果，代码问题很大，希望大家帮我看看怎么实现，谢谢

...全文

IEEE Access 上岸指南，附含泪整理的 cover letter 、沟通邮件、终版文档等资料包终于上岸了！我是一个小硕，本科期间发表过两篇水文，奈何学校有更高的毕业要求，只能硬着头皮尝试一下 SCI。想投 IEEE Access 的朋友都应该知道小木虫论坛对这个期刊的讨论，褒贬不一，有的人说是大水刊，有的人说有难度。比如： @wow_: 不可否认，灌水期刊。只要之前中过一篇，再投基本没有不录用的！我们实验室其他老师说过一区除外的收费期刊都应该禁止灌水。 @pssp: 审稿人还... 阅读详情

lxw886

Java SE 62,621 成员 307,251 内容

+ 关注 + 加入社区

切换为时间正序

冰思雨 2010-07-18

打赏
举报

大致解释一下什么意思：
长连接的维持，是要客户端程序，定时向服务端程序，发送一个维持连接包的。
如果，长时间未发送维持连接包，服务端程序将断开连接。

客户端：
通过持有Client对象，可以随时（使用sendObject方法）发送Object给服务端。
如果keepAliveDelay毫秒（程序中是2秒）内未发送任何数据，则，自动发送一个KeepAlive对象给服务端，
用于维持连接。
由于，我们向服务端，可以发送很多不同的对象，服务端也可以返回不同的对象。
所以，对于返回对象的处理，要编写具体的ObjectAction实现类进行处理。
通过Client.addActionMap方法进行添加。这样，程序会回调处理。

服务端：
由于客户端会定时（keepAliveDelay毫秒）发送维持连接的信息过来，所以，服务端要有一个检测机制。
即当服务端receiveTimeDelay毫秒（程序中是3秒）内未接收任何数据，则，自动断开与客户端的连接。
ActionMapping的原理与客户端相似（相同）。
通过添加相应的ObjectAction实现类，可以实现不同对象的响应、应答过程。

祝好运~~

冰思雨 2010-07-18

打赏
举报

package houlei.csdn.keepalive;





import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.ServerSocket;

import java.net.Socket;

import java.util.concurrent.ConcurrentHashMap;



/**

 * C/S架构的服务端对象。

 * <p>

 * 创建时间：2010-7-18 上午12:17:37

 * @author HouLei

 * @since 1.0

 */

public class Server {



	/**

	 * 要处理客户端发来的对象，并返回一个对象，可实现该接口。

	 */

	public interface ObjectAction{

		Object doAction(Object rev);

	}

	

	public static final class DefaultObjectAction implements ObjectAction{

		public Object doAction(Object rev) {

			System.out.println("处理并返回："+rev);

			return rev;

		}

	}

	

	public static void main(String[] args) {

		int port = 65432;

		Server server = new Server(port);

		server.start();

	}

	

	private int port;

	private volatile boolean running=false;

	private long receiveTimeDelay=3000;

	private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();

	private Thread connWatchDog;

	

	public Server(int port) {

		this.port = port;

	}



	public void start(){

		if(running)return;

		running=true;

		connWatchDog = new Thread(new ConnWatchDog());

		connWatchDog.start();

	}

	

	@SuppressWarnings("deprecation")

	public void stop(){

		if(running)running=false;

		if(connWatchDog!=null)connWatchDog.stop();

	}

	

	public void addActionMap(Class<Object> cls,ObjectAction action){

		actionMapping.put(cls, action);

	}

	

	class ConnWatchDog implements Runnable{

		public void run(){

			try {

				ServerSocket ss = new ServerSocket(port,5);

				while(running){

					Socket s = ss.accept();

					new Thread(new SocketAction(s)).start();

				}

			} catch (IOException e) {

				e.printStackTrace();

				Server.this.stop();

			}

			

		}

	}

	

	class SocketAction implements Runnable{

		Socket s;

		boolean run=true;

		long lastReceiveTime = System.currentTimeMillis();

		public SocketAction(Socket s) {

			this.s = s;

		}

		public void run() {

			while(running && run){

				if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){

					overThis();

				}else{

					try {

						InputStream in = s.getInputStream();

						if(in.available()>0){

							ObjectInputStream ois = new ObjectInputStream(in);

							Object obj = ois.readObject();

							lastReceiveTime = System.currentTimeMillis();

							System.out.println("接收：\t"+obj);

							ObjectAction oa = actionMapping.get(obj.getClass());

							oa = oa==null?new DefaultObjectAction():oa;

							Object out = oa.doAction(obj);

							if(out!=null){

								ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());

								oos.writeObject(out);

								oos.flush();

							}

						}else{

							Thread.sleep(10);

						}

					} catch (Exception e) {

						e.printStackTrace();

						overThis();

					} 

				}

			}

		}

		

		private void overThis() {

			if(run)run=false;

			if(s!=null){

				try {

					s.close();

				} catch (IOException e) {

					e.printStackTrace();

				}

			}

			System.out.println("关闭："+s.getRemoteSocketAddress());

		}

		

	}

	

}

冰思雨 2010-07-18

打赏
举报

简单写了一个长连接的程序。楼主可以参考一下：

package houlei.csdn.keepalive;



import java.io.Serializable;

import java.text.SimpleDateFormat;

import java.util.Date;



/**

 * 维持连接的消息对象。

 * <p>

 * 创建时间：2010-7-18 上午12:22:09

 * @author HouLei

 * @since 1.0

 */

public class KeepAlive implements Serializable{



	private static final long serialVersionUID = -2813120366138988480L;



	/* 覆盖该方法，仅用于测试使用。

	 * @see java.lang.Object#toString()

	 */

	@Override

	public String toString() {

		return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"\t维持连接包";

	}



}

package houlei.csdn.keepalive;



import java.io.IOException;

import java.io.InputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.net.Socket;

import java.net.UnknownHostException;

import java.util.concurrent.ConcurrentHashMap;



/**

 *	C/S架构的客户端对象，持有该对象，可以随时向服务端发送消息。

 * <p>

 * 创建时间：2010-7-18 上午12:17:25

 * @author HouLei

 * @since 1.0

 */

public class Client {



	/**

	 * 处理服务端发回的对象，可实现该接口。

	 */

	public static interface ObjectAction{

		void doAction(Object obj,Client client);

	}

	public static final class DefaultObjectAction implements ObjectAction{

		public void doAction(Object obj,Client client) {

			System.out.println("处理：\t"+obj.toString());

		}

	}

	public static void main(String[] args) throws UnknownHostException, IOException {

		String serverIp = "127.0.0.1";

		int port = 65432;

		Client client = new Client(serverIp,port);

		client.start();

	}

	

	private String serverIp;

	private int port;

	private Socket socket;

	private boolean running=false;

	private long lastSendTime;

	private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();

	

	public Client(String serverIp, int port) {

		this.serverIp=serverIp;this.port=port;

	}

	

	public void start() throws UnknownHostException, IOException {

		if(running)return;

		socket = new Socket(serverIp,port);

		System.out.println("本地端口："+socket.getLocalPort());

		lastSendTime=System.currentTimeMillis();

		running=true;

		new Thread(new KeepAliveWatchDog()).start();

		new Thread(new ReceiveWatchDog()).start();

	}

	

	public void stop(){

		if(running)running=false;

	}

	

	/**

	 * 添加接收对象的处理对象。

	 * @param cls 待处理的对象，其所属的类。

	 * @param action 处理过程对象。

	 */

	public void addActionMap(Class<Object> cls,ObjectAction action){

		actionMapping.put(cls, action);

	}



	public void sendObject(Object obj) throws IOException {

		ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());

		oos.writeObject(obj);

		System.out.println("发送：\t"+obj);

		oos.flush();

	}

	

	class KeepAliveWatchDog implements Runnable{

		long checkDelay = 10;

		long keepAliveDelay = 2000;

		public void run() {

			while(running){

				if(System.currentTimeMillis()-lastSendTime>keepAliveDelay){

					try {

						Client.this.sendObject(new KeepAlive());

					} catch (IOException e) {

						e.printStackTrace();

						Client.this.stop();

					}

					lastSendTime = System.currentTimeMillis();

				}else{

					try {

						Thread.sleep(checkDelay);

					} catch (InterruptedException e) {

						e.printStackTrace();

						Client.this.stop();

					}

				}

			}

		}

	}

	

	class ReceiveWatchDog implements Runnable{

		public void run() {

			while(running){

				try {

					InputStream in = socket.getInputStream();

					if(in.available()>0){

						ObjectInputStream ois = new ObjectInputStream(in);

						Object obj = ois.readObject();

						System.out.println("接收：\t"+obj);

						ObjectAction oa = actionMapping.get(obj.getClass());

						oa = oa==null?new DefaultObjectAction():oa;

						oa.doAction(obj, Client.this);

					}else{

						Thread.sleep(10);

					}

				} catch (Exception e) {

					e.printStackTrace();

					Client.this.stop();

				} 

			}

		}

	}

	

}

码域空间 2010-07-17

打赏
举报

我认为长连接还是用有缓冲区的输入输出流比较好，另外不要在服务端的循环体中将输出流关闭，这样会有异常，还有在客户端，一旦readObject()之后，再在ClientThread里处理输入流，读取到的数据就不是你想要的了，因为已经读过一次了。下面是我的代码，不知道是不是你想要的。



//服务端

import java.io.*;

import java.net.*;



public class Server{

    

    public static void main(String[] args) {

        System.out.println("开始侦听请求 。。。。");   

        ServerSocket serverSocket;

        try {

                serverSocket = new ServerSocket(9999);

                //服务器套接字   

                Socket clientSocket=null;   

                clientSocket=serverSocket.accept();//获得客户端的请求的Socket   

                System.out.println("已侦听到了客户端的请求。。。。。");

    

                OutputStreamWriter os = new OutputStreamWriter(clientSocket.getOutputStream());            

                BufferedWriter oos = new BufferedWriter(os);

                while(true)

                {

                    oos.write("hello client");

                    oos.newLine();

                    oos.flush();

                }

        } catch (IOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

  

}



//客户端

import java.io.*;

import java.net.Socket;

import java.net.UnknownHostException;



public class Client {

	static int RMIPort = 9999;



	public static void main(String[] args) throws ClassNotFoundException {

		try {

			Socket socket = new Socket("127.0.0.1", 9999);

			while (true) {

				BufferedReader serverinput = new BufferedReader(new InputStreamReader(socket.getInputStream()));



				String line = serverinput.readLine();

				if (line != null) {

					new ClientThread(line);

				}

			}



		} catch (UnknownHostException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

}

dr_lou 2010-07-17

打赏
举报

http://huangxx.javaeye.com/blog/167774

prince_java 2010-07-17

打赏
举报

oos.close();
你这一句话直接把连接关闭了，怎么可能实现长连接，把这句删了就行了

lxw886 2010-07-17

打赏
举报

[Quote=引用 2 楼 bhdgx 的回复:]
我认为长连接还是用有缓冲区的输入输出流比较好，另外不要在服务端的循环体中将输出流关闭，这样会有异常，还有在客户端，一旦readObject()之后，再在ClientThread里处理输入流，读取到的数据就不是你想要的了，因为已经读过一次了。下面是我的代码，不知道是不是你想要的。

Java code

//服务端
import java.io.*;
import java.net.*;……
[/Quote]
能不能在长链接的基础上传对象，而不是String？

DAVE_LUO 2010-07-17

打赏
举报

[Quote=引用 3 楼 prince_java 的回复:]
oos.close();
你这一句话直接把连接关闭了，怎么可能实现长连接，把这句删了就行了
[/Quote]
正解，另外，楼主的代码需要完善。

lxw886 2010-07-16

打赏
举报

自己顶起来

Socket通信怎样保持长连接？

相关推荐