栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java如何实现长连接

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java如何实现长连接

实现原理:

长连接的维持,是要客户端程序,定时向服务端程序,发送一个维持连接包的。
如果,长时间未发送维持连接包,服务端程序将断开连接。

客户端:

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

服务端:

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

心跳反映的代码:

package com.java.excel.keepalive;

import java.io.Serializable;
import java.text.SimpleDateFormat;
import java.util.Date;

public class KeepAlive implements Serializable {

  private static final long serialVersionUID = -2813120366138988480L;

  
  @Override
  public String toString() {
    return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"t维持连接包";
  }

}

服务端

package com.java.excel.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;

public class Server {

  
  public interface ObjectAction{
    Object doAction(Object rev, Server server);
  }
  
  public static final class DefaultObjectAction implements ObjectAction{
    public Object doAction(Object rev,Server server) {
      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 actionMapping = new ConcurrentHashMap();
  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 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,Server.this);
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());
    }
    
  }
  
}

客户端

package com.java.excel.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;

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 actionMapping = new ConcurrentHashMap();
  
  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(); //保持长连接的线程,每隔2秒项服务器发一个一个保持连接的心跳消息
    new Thread(new ReceiveWatchDog()).start();  //接受消息的线程,处理消息
  }
  
  public void stop(){
    if(running)running=false;
  }
  
  
  public void addActionMap(Class 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 = 1000;
    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();
 } 
      }
    }
  }
  
}

以上就是Java如何实现长连接的详细内容,更多关于java实现长连接的资料请关注考高分网其它相关文章!

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号