Java ChannelHandlerContext.channel方法代码示例

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
/**
	 * 适配
	 */
	@Override
	protected ChannelHandler fixHandlerBeforeConnect(final ChannelHandler handler) {
		ChannelHandler result=new ShareableChannelInboundHandler() {
			@Override
			public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
				Channel ch=ctx.channel();
				ch.pipeline().addLast(new HttpClientCodec());
            	ch.pipeline().addLast(new HttpObjectAggregator(64*1024));
            	ch.pipeline().addLast(new WebSocketClientProtocolHandler(WebSocketClientHandshakerFactory.newHandshaker(uri, WebSocketVersion.V13, null, false, new DefaultHttpHeaders())));
            	ch.pipeline().addLast(new WebSocketConnectedClientHandler(handler));
				ctx.pipeline().remove(this);//移除当前handler
				ctx.pipeline().fireChannelRegistered();//重新从第一个handler抛出事件
			}
		};
//		ChannelInitializer<SocketChannel> result=new ChannelInitializer<SocketChannel>() {
//            @Override
//            protected void initChannel(SocketChannel ch) {
//            	ch.pipeline().addLast(new HttpClientCodec());
//            	ch.pipeline().addLast(new HttpObjectAggregator(64*1024));
//            	ch.pipeline().addLast(new WebSocketClientProtocolHandler(WebSocketClientHandshakerFactory.newHandshaker(uri, WebSocketVersion.V13, null, false, new DefaultHttpHeaders())));
//            	ch.pipeline().addLast(new WebSocketConnectedClientHandler(handler));
//            }
//        };
        return result;
	}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public void channelActive(final ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    //logger.info("connected from {}", NetUtils.channelToString(channel.remoteAddress(), channel.localAddress()));
    BaseServerHandler.addChannel(channel);
    if (connectListeners != null) {
        serverHandler.getBizThreadPool().execute(new Runnable() {
            @Override
            public void run() {
                for (ConnectListener connectListener : connectListeners) {
                    try {
                        connectListener.connected(ctx);
                    } catch (Exception e) {
                        logger.warn("Failed to call connect listener when channel active", e);
                    }
                }
            }
        });
    }
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    super.channelActive(ctx);
    this.channel = ctx.channel();

    UnknownPandaServer.getLogger().info("Channel active: " + this.channel.remoteAddress());
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
/**
 * Send back the result
 * @param ctx channel context
 * @param result rpc result
 */
private void send(ChannelHandlerContext ctx, Object result) {
  int seqId = 0;
  Channel ch = ctx.channel();

  try {
    seqId = ((ByteBuf) result).readInt();
    ((ByteBuf) result).resetReaderIndex();
    AtomicBoolean channelInUse = channelStates.get(ctx);
    if (channelInUse == null) {
      return;
    }
    long startTs = System.currentTimeMillis();
    while (true) {
      if (channelInUse.compareAndSet(false, true)) {
        ctx.writeAndFlush(result);
        channelInUse.set(false);
        LOG.debug(
          "send response buf=" + result + ",channel ctx=" + ctx.channel() + ", seqId=" + seqId
            + " use time=" + (System.currentTimeMillis() - startTs));
        return;
      }
      Thread.sleep(10);
    }
  } catch (Throwable ex) {
    LOG.error("send response of request failed, request seqId=" + seqId + ", channel=" + ch, ex);
  }
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public final void channelInactive(ChannelHandlerContext ctx)throws Exception 
{
	Channel channel=ctx.channel();
	JConnection connection = findConnection(channel);
	if (connection != null) 
	{
		listener.connectionClosed(connection);
	} else 
	{
		log.error(ctx.channel() + ":not found NettyConnection Created.");
	}
	super.channelInactive(ctx);
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
public void disconnected(ChannelHandlerContext ctx)
{
    JSON.ClientDisconnectMessage dmsg = new JSON.ClientDisconnectMessage( ctx.channel( ));
    try {
        outQ.put( dmsg);
    }
    catch (InterruptedException e) {
        logr.info( "StockTickerMessageHandler.disconnected: outQ.put( ) failed for "
                                                            + ctx + "\n" + e.toString( ));
    }
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public void call(ChannelHandlerContext ctx, MultiMessageToDeviceReq message) {
    //找寻到对应设备的channel 将消息全部推送给这个设备
    if (message != null) {
        pushSender.send(message.getDevice(), PushReq.builder().msgs(message.getMessages()).build());
        Channel channel = ctx.channel();
        channel.writeAndFlush(MultiMessageToDeviceResp.builder().result(NodeMessageEnum.OK.getCode()).build().encode());
    }
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception
{
	super.channelActive(ctx);

	this.channel = ctx.channel();
	this.address = this.channel.remoteAddress();

	//Try to handshake?
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    if(initMessage != null){
        ctx.writeAndFlush(initMessage);
    } else {
        logger.info("build connection success.");
        channel[0] = ctx.channel();
        ProcessData.Builder builder = ProcessData.newBuilder();
        builder.setType(MessageType.HEART_BEAT_REQ.getValue());
        ctx.fireChannelRead(builder.build());
    }
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
    Channel channel = ctx.channel();
    LOGGER.info("Disconnected telnet from {}", NetUtils.channelToString(channel.remoteAddress(), channel.localAddress()));
    BaseServerHandler.removeChannel(channel);
    charsetMap.remove(channel);
    ALLOW_INVOKE_CHANNELS.remove(channel);
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
private void processSubscribe(ChannelHandlerContext ctx, MqttSubscribeMessage mqttMsg) {
  if (!checkConnected(ctx)) {
    return;
  }
  log.trace("[{}] Processing subscription [{}]!", sessionId, mqttMsg.variableHeader().messageId());
  List<Integer> grantedQoSList = new ArrayList<>();
  for (MqttTopicSubscription subscription : mqttMsg.payload().topicSubscriptions()) {
    String topicName = subscription.topicName();
    // TODO: handle this qos level.
    MqttQoS reqQoS = subscription.qualityOfService();
    try {
      if (topicName.equals(DEVICE_ATTRIBUTES_TOPIC)) {
        // AdaptorToSessionActorMsg msg =
        // adaptor.convertToActorMsg(deviceSessionCtx,
        // SUBSCRIBE_ATTRIBUTES_REQUEST,
        // mqttMsg);
        // BasicToDeviceActorSessionMsg basicToDeviceActorSessionMsg = new
        // BasicToDeviceActorSessionMsg(
        // deviceSessionCtx.getDevice(), msg);
        // processor.process(basicToDeviceActorSessionMsg);
        grantedQoSList.add(getMinSupportedQos(reqQoS));
      } else if (topicName.equals(DEVICE_RPC_REQUESTS_SUB_TOPIC)) {
        // AdaptorToSessionActorMsg msg =
        // adaptor.convertToActorMsg(deviceSessionCtx,
        // SUBSCRIBE_RPC_COMMANDS_REQUEST,
        // mqttMsg);
        // processor.process(new
        // BasicToDeviceActorSessionMsg(deviceSessionCtx.getDevice(), msg));
        grantedQoSList.add(getMinSupportedQos(reqQoS));
      } else if (topicName.equals(DEVICE_RPC_RESPONSE_SUB_TOPIC)) {
        grantedQoSList.add(getMinSupportedQos(reqQoS));
      } else if (topicName.equals(DEVICE_ATTRIBUTES_RESPONSES_TOPIC)) {
        deviceSessionCtx.setAllowAttributeResponses();
        grantedQoSList.add(getMinSupportedQos(reqQoS));
      } else if (topicName.equals(DEVICE_TELEMETRY_TOPIC)) {
        grantedQoSList.add(getMinSupportedQos(reqQoS));
      } else {
        log.warn("[{}] Failed to subscribe to [{}][{}]", sessionId, topicName, reqQoS);
        grantedQoSList.add(FAILURE.value());
      }
      ChannelEntity channelEntity = new TcpChannelEntity(ctx.channel());
      MemoryMetaPool.registerTopic(channelEntity, topicName);
    } catch (Exception e) {
      e.printStackTrace();
      log.warn("[{}] Failed to subscribe to [{}][{}]", sessionId, topicName, reqQoS);
      grantedQoSList.add(FAILURE.value());
    }
  }

  ctx.writeAndFlush(createSubAckMessage(mqttMsg.variableHeader().messageId(), grantedQoSList));
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
public CLSession openSession(String identifier, ChannelHandlerContext ctx) {
    CLSession session = new CLSession(this, identifier, (SocketChannel) ctx.channel());
    this.players.put(identifier, session);
    return session;
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
public NettyConnection(ChannelHandlerContext ctx) {
	this.ctx=ctx;
	this.channel=ctx.channel();
	this.id=getChannelId(channel);
	channel.attr(CHANNEL_KEY).set(this);
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public void handlerAdded(final ChannelHandlerContext ctx) {
    final Channel incoming = ctx.channel();
    LOGGER.info("Handling connection");
    channels.add(incoming);
}
 

import io.netty.channel.ChannelHandlerContext; //导入方法依赖的package包/类
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
    UkcpChannel kcpCh = (UkcpChannel) ctx.channel();
    kcpCh.conv(EchoServer.CONV);
}