java心跳发送

java心跳发送：

大家都知道。如果你在互联网公司，并且开发的是产品那你一定接触不到。心跳机制。心跳包

那什么是心跳机制呢？

心跳机制就是定时发送一个自定义的结构体(心跳包)。确保连接的有效的机制。

大部分CS的应用需要心跳机制。心跳机制一般在Server和Client都要实现，两者实现原理基本一样。Client不关心性能，怎么做都行。

如果应用是基于TCP的，可以简单地通过SO_KEEPALIVE实现心跳。TCP在设置的KeepAlive定时器到达时向对端发一个检测TCP segment，如果没收到ACK或RST，尝试几次后，就认为对端已经不存在，最后通知应用程序。这里有个缺点是，Server主动发出检测包，对性能有点影响。

应用自己实现 
Client启动一个定时器，不断发心跳； 
Server收到心跳后，给个回应； 
Server启动一个定时器，判断Client是否存在，判断方法这里列两种： 
时间差和简单标志。

 

直接例子：加入现在我们发送一个对象

第一：首先定义一个实体类对象

package com.huojg.test;
import javax.swing.*;
import java.awt.event.ActionListener;
import java.io.Serializable;

/**心跳用timer定时器来完成
 * 
 * 心跳机制：就是定时发送一个结构体(心跳包)，让对方知道自己还活着。以确保连接的有效性的机制。
 * 大部分cs的应用需要用到心跳机制。心跳机制一般在server与client都要实现。如果应用是基于TCP，以简单地通过SO_KEEPALIVE实现心跳
 * 
 * 
 * 应用自己实现 
Client启动一个定时器，不断发心跳； 
Server收到心跳后，给个回应； 
Server启动一个定时器，判断Client是否存在，判断方法这里列两种： 
时间差和简单标志。

此处我们实现一个发送对象
 * */

public class Entity implements Serializable  {
    private String name;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Entity [name=" + name + ", sex=" + sex + "]";
    }
    

}

第二：我们定义服务端的server类

package com.huojg.test;

import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 完成心跳的server端
 */
public class ServerHeartTest extends Thread {
    private ServerSocket server = null;
    Object obj = new Object();
    @Override
    public void run() {
        try {
            server=new ServerSocket(9090);
            while(true){
                Socket clent=server.accept();
                synchronized (obj) {
                    new Thread(new Client(clent)).start();;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }    
    
     public static void main(String[] args) {
            System.out.println("开始检测客户端是否在线...");
            new ServerHeartTest().start();
        }
}
/**客户端线程
 * 
 * 
 * */
class Client implements Runnable{
Socket client;
public Client(Socket client) {
    this.client = client;
}

    @Override
    public void run() {
        try {
            while (true) {
                ObjectInput in = new ObjectInputStream(client.getInputStream());
                Entity entity = (Entity) in.readObject();
                System.out.println(entity);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
}    

 

第三步：定义客户端

package com.huojg.test;
/**
 * 客户端
 * */
public class ClientHeart extends Thread {

    @Override
    public void run() {
        try {
            while (true) {
                ClientSender.getInstance().send();
                synchronized (ClientHeart.class) {
                    // this.wait(5000);
                    Thread.sleep(2000);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

    }
    
/**
 * 程序的入口main方法
 * 
 * @param args
 */
public static void main(String[] args) {
    ClientHeart client = new ClientHeart();
    client.start();
}

}

最后我们来定义一个业务类：

package com.huojg.test;

import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;

public class ClientSender {

     private ClientSender() {
        }

        Socket sender = null;
        private static ClientSender instance;

        public static ClientSender getInstance() {
            if (instance == null) {
                synchronized (ClientHeart.class) {
                    instance = new ClientSender();
                }
            }
            return instance;
        }

        public void send() {
            try {
                sender = new Socket(InetAddress.getLocalHost(), 9090);
                while (true) {
                    ObjectOutputStream out = new ObjectOutputStream(sender.getOutputStream());
                    Entity obj = new Entity();
                    obj.setName("huojg");
                    obj.setSex("男");
                    out.writeObject(obj);
                    out.flush();

                    System.out.println("已发送...");
                    Thread.sleep(5000);
                }
            } catch (Exception e) {

            }
        }
    }

有这个四个类我们开启服务，打开client客户端。就可以看到，后台的，心跳程序运行了，

结论：

其实：心跳就是不停的操作，我们用定时器也可以做到。只是目前是C/S框架中实现的，主要使用socket完成。