java長連接,java長連接調用

本文目錄一覽：

• 1、java怎麼實現長連接？
• 2、如何用java實現HTTP長連接
• 3、請教JAVA如何實現web下的長連接關鍵後台如何寫
• 4、java Socket 短連接和長連接的區別
• 5、java如何實現http長連接
• 6、java 實現長連接接受信息，發送信息

java怎麼實現長連接？

應該是HTTP連接吧，HTTP連接本身的request/response模式設計就是短鏈接的，即服務器端響應之後斷開連接。

若要做長連接，在沒有具體業務的情況下，最基礎的就是建立java.net.Socket連接，自己制定協議來控制斷開。服務器端的實現老的有標準IO（java.net.*），新的有NIO（java.nio.*）。有具體業務時可以考慮一些成熟的協議來實現，如XMPP等。

如何用java實現HTTP長連接

1、通過輪詢來實現長連接（偽·長連接）

2、websocket（真·長連接）

請教JAVA如何實現web下的長連接關鍵後台如何寫

目前web上的消息通訊方式主要有以下幾種。

輪詢，長連接，websocket

輪詢：隔一段時間訪問服務器，服務器不管有沒有新消息都立刻返回。

長連接：頁面向服務器發出請求，由服務器決定什麼時候返回。（如果有新消息則立刻返回，沒有的話就保持連接，直到有新消息才返回）

websocket：類似Java Socket，由Http請求模擬實現的socket。

要實現長連接的關鍵就是： 由服務器端決定什麼時候返回數據。比如在servlet中。

doGet(…){

…

Thread.sleep(30000);

return …

}

這就是一個長連接的例子，只是沒有任何意義而已。

你要做的就是在doGet中阻塞住，

while(!hasNewMsg){

sleep(500)

}

return newMsg…

當然你的ajax超時時間要設置長一點。

如果可以的話，最好可以使用websocket。

java Socket 短連接和長連接的區別

所謂長連接，指在一個TCP連接上可以連續發送多個數據包，在TCP連接保持期間，如果沒有數據包發送，需要雙方發檢測包以維持此連接，一般需要自己做在線維持。

短連接是指通信雙方有數據交互時，就建立一個TCP連接，數據發送完成後，則斷開此TCP連接，一般銀行都使用短連接。

比如http的，只是連接、請求、關閉，過程時間較短,服務器若是一段時間內沒有收到請求即可關閉連接。

其實長連接是相對於通常的短連接而說的，也就是長時間保持客戶端與服務端的連接狀態。

長連接與短連接的操作過程:

通常的短連接操作步驟是：

連接→數據傳輸→關閉連接；

而長連接通常就是：

連接→數據傳輸→保持連接(心跳)→數據傳輸→保持連接(心跳)→……→關閉連接；

這就要求長連接在沒有數據通信時，定時發送數據包(心跳)，以維持連接狀態，短連接在沒有數據傳輸時直接關閉就行了.

java如何實現http長連接

通過輪詢來實現長連接

輪詢：隔一段時間訪問服務器，服務器不管有沒有新消息都立刻返回。

http長連接實現代碼：

客戶端：

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 ConcurrentHashMapClass, ObjectAction actionMapping = new ConcurrentHashMapClass,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(ClassObject 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()-lastSendTimekeepAliveDelay){

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();

}

}

}

}

}

服務端：

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 ConcurrentHashMapClass, ObjectAction actionMapping = new ConcurrentHashMapClass,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(ClassObject 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()-lastReceiveTimereceiveTimeDelay){

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());//關閉長連接

}

}

}

長連接的維持，是要客戶端程序，定時向服務端程序，發送一個維持連接包的。

如果，長時間未發送維持連接包，服務端程序將斷開連接。

java 實現長連接接受信息，發送信息

對於你這個需求，可以用當前比較熱門的websocket來解決。

websocket可以實現服務端和客戶端全雙工通信，實時性非常好。

你可以自己搭建websocket服務，也可以使用第三方的websocket推送框架，比如【GoEasy】。

【GoEasy】目前支持java、php、python等服務端語言，同時也支持小程序、vue、uniapp等前端技術，使用起來還是非常方便的。