2. 程式人生 > >Netty實現客戶端和服務端的通訊

Netty實現客戶端和服務端的通訊

阿新 • • 發佈：2019-02-13

        Netty是Apache團隊的又一個優秀的Socket框架，它和mina是一個團隊開發的，所以很多思想是相同的，接下來，我們就來實現客戶端和服務端的雙向通訊。

        首先，我們定義訊息型別：

/**
 * 訊息型別
 * @author 李熠
 *
 */
public enum MsgType {

	PING,SEND,LOGIN,NO_TARGET
}
分別是心跳、傳送、登入、找不到目標

當客戶端和服務端連線後，需要向服務端傳送登入請求，也就是訊息型別：LOGIN，服務端接收到LOGIN請求後，會將客戶端加入到佇列中，

import java.io.Serializable;

public class Message implements Serializable {

	private static final long serialVersionUID = -5756901646411393269L;

	private String clientId;//傳送者客戶端ID
	
	private MsgType type;//訊息型別
	
	private String data;//資料
	
	private String targetId;//目標客戶端ID
	
	public String getTargetId() {
		return targetId;
	}
	
	public void setTargetId(String targetId) {
		this.targetId = targetId;
	}

	public String getClientId() {
		return clientId;
	}

	public void setClientId(String clientId) {
		this.clientId = clientId;
	}

	public MsgType getType() {
		return type;
	}

	public void setType(MsgType type) {
		this.type = type;
	}

	public String getData() {
		return data;
	}

	public void setData(String data) {
		this.data = data;
	}
	
	public Message(){
		
	}
	
	public Message(MsgType type){
		this.type = type;
	}
}
這類是定義的訊息Bean，想服務端傳送訊息就是傳送的這個物件的資料。

接下來，實現客戶端佇列程式碼：

import io.netty.channel.Channel;
import io.netty.channel.socket.SocketChannel;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class NettyChannelMap {

	private static Map<String , SocketChannel> map = new ConcurrentHashMap<>();
	
	public static void add(String clientId,SocketChannel channel){
		map.put(clientId, channel);
	}
	
	public static Channel get(String clientId){
		return map.get(clientId);
	}
	
	public static void remove(SocketChannel channel){
		for (Map.Entry<String,SocketChannel> entry:map.entrySet()){
            if (entry.getValue()==channel){
                map.remove(entry.getKey());
            }
        }
	}
	
}
服務端：
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.nio.charset.Charset;

public class NettyServer {

	private int port;
    public SocketChannel socketChannel;
    public NettyServer(int port) throws InterruptedException {
        this.port = port;
        bind();
    }

    private void bind() throws InterruptedException {
        EventLoopGroup boss=new NioEventLoopGroup();
        EventLoopGroup worker=new NioEventLoopGroup();
        ServerBootstrap bootstrap=new ServerBootstrap();
        bootstrap.group(boss,worker);
        bootstrap.channel(NioServerSocketChannel.class);
        bootstrap.option(ChannelOption.SO_BACKLOG, 128);
        //通過NoDelay禁用Nagle,使訊息立即發出去，不用等待到一定的資料量才發出去
        bootstrap.option(ChannelOption.TCP_NODELAY, true);
        //保持長連線狀態
        bootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
        bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel socketChannel) throws Exception {
                ChannelPipeline p = socketChannel.pipeline();
                //字串類解析
 
//這裡只能新增字串的編碼和解碼器，
//網上有很多例子是這樣寫的：
//這種寫法只能所有客戶端都用netty寫，否則其他框架實現的客戶端無法傳送訊息到服務端,因為他是轉換的netty自己的Object
//p.addLast(new ObjectEncoder());
          //p.addLast(new ObjectDecoder(ClassResolvers.cacheDisabled(this.getClass().getClassLoader())));	
                p.addLast(new StringEncoder(Charset.forName("UTF-8")));
                p.addLast(new StringDecoder(Charset.forName("UTF-8")));
                p.addLast(new NettyServerHandler());
            }
        });
        ChannelFuture f= bootstrap.bind(port).sync();
        if(f.isSuccess()){
            System.out.println("server start---------------");
        }
    }
    public static void main(String []args) throws InterruptedException {
    	if(args.length == 0){
    		new NettyServer(9999);
    	}else{
    		new NettyServer(Integer.parseInt(args[0]));
    	}
    }
}


import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.socket.SocketChannel;
import cn.sunsharp.netty.bean.Message;
import cn.sunsharp.netty.bean.MsgType;
import cn.sunsharp.netty.bean.NettyChannelMap;

import com.alibaba.fastjson.JSON;


//最好繼承
SimpleChannelInboundHandler<String>表示傳遞字串訊息，handler會把json格式的字串轉換為Message物件
public class NettyServerHandler extends SimpleChannelInboundHandler<String>{@Override public void channelInactive(ChannelHandlerContext ctx) throws Exception { //channel失效，從Map中移除 NettyChannelMap.remove((SocketChannel)ctx.channel()); }@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)throws Exception {//cause.printStackTrace();System.out.println("出現異常！");}@Overrideprotected void messageReceived(ChannelHandlerContext ctx, String msg)throws Exception {System.out.println(msg);Message message = JSON.parseObject(msg+"", Message.class);System.out.println("接收到訊息："+message);String clientId = message.getClientId();if(MsgType.LOGIN.equals(message.getType())){System.out.printf("將%s新增到佇列\n",clientId); NettyChannelMap.add(clientId,(SocketChannel)ctx.channel()); }else{ if(NettyChannelMap.get(clientId)==null){ System.out.printf("登入失敗，請重新登入!",clientId); //說明未登入，或者連線斷了，伺服器向客戶端發起登入請求，讓客戶端重新登入 message = new Message(MsgType.LOGIN); ctx.channel().writeAndFlush(JSON.toJSONString(message)); } } switch (message.getType()){ case PING:{ message = new Message(MsgType.PING); NettyChannelMap.get(clientId).writeAndFlush(JSON.toJSONString(message)); }break; case SEND:{ //收到客戶端的請求，傳送給targetId System.out.println("傳送訊息："+message); if(NettyChannelMap.get(message.getTargetId()) != null){ NettyChannelMap.get(message.getTargetId()).writeAndFlush(JSON.toJSONString(message)); }else{ message.setType(MsgType.NO_TARGET); NettyChannelMap.get(clientId).writeAndFlush(JSON.toJSONString(message)); } }break; default:break; }}}客戶端可以使用任何框架任何語言的Socket來連線併發送訊息，為了方便，這裡依然用Netty來實現客戶端：
import java.nio.charset.Charset;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;
import io.netty.util.concurrent.DefaultEventExecutorGroup;
import io.netty.util.concurrent.EventExecutorGroup;
import cn.sunsharp.regulation.bean.Message;
import cn.sunsharp.regulation.bean.MsgType;

import com.alibaba.fastjson.JSON;

public class NettyClient {

	private int port;
    private String host;
    public SocketChannel socketChannel;
    private static final EventExecutorGroup group = new DefaultEventExecutorGroup(20);
    public NettyClient(int port, String host) {
        this.port = port;
        this.host = host;
        start();
    }
    private void start(){
    	ChannelFuture future = null;
    	try {
    		EventLoopGroup eventLoopGroup=new NioEventLoopGroup();
    		Bootstrap bootstrap=new Bootstrap();
    		bootstrap.channel(NioSocketChannel.class);
    		bootstrap.option(ChannelOption.SO_KEEPALIVE,true);
    		bootstrap.group(eventLoopGroup);
    		bootstrap.remoteAddress(host,port);
    		bootstrap.handler(new ChannelInitializer<SocketChannel>() {
    			@Override
    			protected void initChannel(SocketChannel socketChannel) throws Exception {
    				socketChannel.pipeline().addLast(new IdleStateHandler(20,10,0));
    				socketChannel.pipeline().addLast(new StringEncoder(Charset.forName("UTF-8")));
    				socketChannel.pipeline().addLast(new StringDecoder(Charset.forName("UTF-8")));
    				socketChannel.pipeline().addLast(new NettyClientHandler());
    			}
    		});
    		future =bootstrap.connect(host,port).sync();
    		if (future.isSuccess()) {
    			socketChannel = (SocketChannel)future.channel();
    			System.out.println("connect server  成功---------");
    		}else{
    			System.out.println("連線失敗！");
    			System.out.println("準備重連！");
    			start();
    		}
    	} catch (Exception e) {

    	}finally{
//    		if(null != future){
//    			if(null != future.channel() && future.channel().isOpen()){
//    				future.channel().close();
//    			}
//    		}
//    		System.out.println("準備重連！");
//    		start();
    	}
    }
    public static void main(String[]args) throws InterruptedException {
        NettyClient bootstrap=new NettyClient(9999,"192.168.1.38");
        System.out.println(11111);
        Message loginMsg=new Message(MsgType.LOGIN);
        loginMsg.setClientId("001");
		loginMsg.setTargetId("192.168.1.38");
		loginMsg.setType(MsgType.LOGIN);
        bootstrap.socketChannel.writeAndFlush(JSON.toJSON(loginMsg));
    } 
}


import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.timeout.IdleStateEvent;
import cn.sunsharp.regulation.bean.Message;
import cn.sunsharp.regulation.bean.MsgType;

import com.alibaba.fastjson.JSON;

public class NettyClientHandler extends SimpleChannelInboundHandler<String> {

	public static ChannelHandlerContext context = null;
	
	//利用寫空閒傳送心跳檢測訊息
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        if (evt instanceof IdleStateEvent) {
            IdleStateEvent e = (IdleStateEvent) evt;
            switch (e.state()) {
                case WRITER_IDLE:
                    Message pingMsg=new Message(MsgType.PING);
                    ctx.writeAndFlush(JSON.toJSON(pingMsg));
                    System.out.println("send ping to server----------");
                    break;
                default:
                    break;
            }
        }
    }

	@Override
	protected void messageReceived(ChannelHandlerContext ctx, String msg)
			throws Exception {
		Message message = JSON.parseObject(msg+"", Message.class);
        MsgType msgType=message.getType();
        switch (msgType){
            case LOGIN:{
                //向伺服器發起登入
                message = new Message(MsgType.LOGIN);
                ctx.writeAndFlush(JSON.toJSONString(message));
            }break;
            case PING:{
                System.out.println("receive ping from server----------");
            }break;
            case SEND:{
            	//收到服務端訊息
                System.out.println("收到服務端訊息："+message.getData());
            }break;
            case NO_TARGET:{
            	//收到服務端訊息
                System.out.println("找不到targetId:"+message.getTargetId());
            }break;
            default:break;
        }
	}
}


相關推薦

Netty實現客戶端和服務端的通訊

        Netty是Apache團隊的又一個優秀的Socket框架，它和mina是一個團隊開發的，所以很多思想是相同的，接下來，我們就來實現客戶端和服務端的雙向通訊。        首先，我們定義訊息型別：/** * 訊息型別 * @author 李熠 * *

netty實現一個簡單的服務端和客戶端通訊

netty java Nio網路通訊框架，能接收TCP，http，webSocket，UDPelk包括：logStash，Elasticsearch，KibanaLogStash：tcp監聽netty伺服器傳送的資訊，並把訊息處理好後轉發給ESElasticsearch：接受

Netty實現客戶端和服務端通信簡單例子

啟動服務 ali tty 過程 等等 服務器初始化 讀寫操作 extends ask Netty是建立在NIO基礎之上，Netty在NIO之上又提供了更高層次的抽象。 在Netty裏面，Accept連接可以使用單獨的線程池去處理，讀寫操作又是另外的線程池來處理。 Accep

linux網路程式設計之用socket實現簡單客戶端和服務端的通訊（基於TCP）

一、介紹基於TCP協議通過socket實現網路程式設計常用API 1、讀者如果不是很熟悉，可以先看我之前寫的幾篇部落格，有socket，地址結構的理解，更加方便讀者理解 地址分別是： 2、socket（TCP）程式設計API簡介 1）、socket int s

linux網路程式設計之用socket實現簡單客戶端和服務端的通訊（基於UDP）

1、sendto和recvfrom函式介紹 sendto（經socket傳送資料） 相關函式 send , sendmsg,recv , recvfrom , socket 表頭檔案 #include < sys/types.h >#includ

基於thrift的java和python分別作為客戶端和服務端的調用實現

Coding except arr pes com ssa utf-8 encoding 中文亂碼 前面已經實現了純java的thrift的實現。 現在實現實現一下python作為客戶端和服務端的thrift的調用 1.python作為客戶端，java作為服務端 java服

Python學習筆記1：簡單實現ssh客戶端和服務端

bsp dev bre 客戶端 break 基於 bin listen 客戶 實現基於python 3.6。 server端： 1 __author__ = "PyDev2018" 2 3 import socket,os 4 server = socket.s

linux網絡編程之用socket實現簡單客戶端和服務端的通信（基於UDP）

服務端 msg ets lin fgets err n) stderr tcp 單客戶端和服務端的通信（基於UDP） 代碼 服務端代碼socket3.c #include<sys/types.h> #include<sys/socket.h>

Netty學習（3）: 客戶端和服務端的例子

服務端： package com.server; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.Channel; import io.netty.channel.ChannelFuture; import

python實現一個簡單的thirft客戶端和服務端

建立thrift檔案 service Hello { string get() } 使用thrift 建立服務需要的元件 thrift --gen py hello.thrif

MQTTnet 實現MQTT 客戶端和服務端

服務端： class Program { private static MqttServer mqttServer = null; static void Main(string[] args) { Mqtt

利用Netty進行客戶端和服務端互動的入門示例

Netty是基於事件驅動的、非同步的網路應用程式框架和工具，用以快速開發高效能、高可靠性的網路伺服器和客戶端程式。是一種NIO框架，下面從最簡單的Hello World示例開始，演示服務端和客戶端互動進行Netty互動。 1.首先,建立服務端 public class Dis

客戶端和服務端在同一臺機器上，wireshark如何實現抓包

在實際專案中，可能會遇到客戶端和服務端在同一臺機器，要抓包對兩邊的通訊等進行分析，預設wireshark是不能抓到客戶端和服務端在同一臺機器的資料包的。 注：10.16.38.103是本地I

網路程式設計二(套接字Socket、客戶端和服務端通訊問題)

在客戶機/伺服器工作模式中，在Server端，要準備接受多個Client端計算機的通訊。為此，除用IP地址標識Internet上的計算機之外，另還引入埠號，用埠號標識正在Server端後臺服務的執行緒。埠號與IP地址的組合稱為網路套接字（socket）。 Java語言在

boost的asio實現簡單的客戶端和服務端

客戶端： //客戶端 #include "stdafx.h" #include<boost/asio/io_service.hpp> #include<boost/asio/ip/tcp.hpp> #include<

JAVA實現XML-RPC客戶端和服務端

客戶端程式碼： package test_xmlrpc.test; import java.net.URL; import java.util.ArrayList; import java.uti

socket網絡編程登錄實現及多客戶端和服務端的數據交互

取數據 sin 一個用戶 run set inf exceptio 反序列化 ram 一.TCP/IP 客戶端 package com.demo.entity; import java.io.Serializable; public class User

客戶端和服務端如何使用Token和Session

cnblogs blank style ssi exception font 統一 判斷 用戶 一、我們先解釋一下他的含義： 1、Token的引入：Token是在客戶端頻繁向服務端請求數據，服務端頻繁的去數據庫查詢用戶名和密碼並進行對比，判斷用戶名和密碼正確與否，並作

netty4----netty5的客戶端和服務端

服務端 處理 sock 一個 servers 線程不安全 inbound nio owa 服務端： package com.server; import io.netty.bootstrap.ServerBootstrap; import io.netty.channe

客戶端和服務端根路徑“/”的區別

name 根路徑 ber AC jsp 後端 ffffff http 最簡 文章來源 ： https://blog.csdn.net/zwt520123/article/details/76794446 JSP 變為 HTML 的問題 由上面可以看到，整個 Web