java类org.jboss.netty.channel.MessageEvent的实例源码

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
    Object msg = e.getMessage();
    if (!(msg instanceof RpcRequest)) {
        logger.error("not RpcRequest received!");
        return;
    }
    RpcRequest request = (RpcRequest) msg;
    ctx.setAttachment(request);

    RpcResponse response = new RpcResponse(request.getRequestID());
    try {
        Object result = handle(request);
        response.setResult(result);
    } catch (Throwable t) {
        logger.error("handle rpc request fail! request:"+request, t);
        response.setException(t);
    }
    e.getChannel().write(response);
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception
{
    if (LOG.isTraceEnabled()) {
        LOG.trace("message received called " + e.getMessage());
    }
    try {
        if (LOG.isDebugEnabled()) {
            LOG.debug("New message " + e.toString()
                    + " from " + ctx.getChannel());
        }
        NettyServerCnxn cnxn = (NettyServerCnxn)ctx.getAttachment();
        synchronized(cnxn) {
            processMessage(e, cnxn);
        }
    } catch(Exception ex) {
        LOG.error("Unexpected exception in receive", ex);
        throw ex;
    }
}

public static void messageReceived(MessageEvent e) {
    String msgName = e.getMessage().getClass().getName();
    if (msgName.equals(SLoginMsg.class.getName())) {
        sendToLogin(e);
    } else if (msgName.equals(SRecommendListMsg.class.getName())) {
        sendToRecommend(e);
    } else if (msgName.equals(SHelpMeMsg.class.getName())) {
        sendToHelpMeMsg(e);
    } else if (msgName.equals(SMeHelpMsg.class.getName())) {
        sendToMeHelpMsg(e);
    } else if (msgName.equals(SFriendList.class.getName())) {
        sendToFriend(e);
    } else if (msgName.equals(SChatMessage.class.getName())) {
        sendToChat(e);
    } else if (msgName.equals(SSelectReqMsg.class.getName())) {
        sendToQuery(e);
    } else if (msgName.equals(SRegisterMsg.class.getName())) {
        sendToRegister(e);
    } else if (msgName.equals(SPhotoRequestMsg.class.getName())) {
        sendToPhoto(e);
    } else if (msgName.equals(SUserInfoRequest.class.getName())) {
        sendToInformation(e);
    } else if(msgName.equals(SOrderMsg.class.getName())) {
        sendToInformation1(e);
    } 
}

private static void sendToInformation1(MessageEvent e) {
    SOrderMsg msg = (SOrderMsg) e.getMessage();
    if (isCurrUI(Config.TAG_InformationActivity)) {
        sOrderMsgListener.onSOrderMsgReceived(msg);
    } else {
        Intent intent = new Intent(currContext, InformationActivity.class);
        Bundle bundle = new Bundle();
        bundle.putInt("TAG", Config.TAG_SOrderMsg);
        bundle.putSerializable("SOrderMsg", msg);
        intent.putExtras(bundle);
        String content = "";
        String title  = msg.getReqDetail();
            if(msg.getOrderType() == OrderMsgType.REQUEST) {
                content = "嗨，有人帮助你啦，快来看吧！";
            } else {
                if(msg.isbOrdered()) {
                    content = "嗨，你们已经正在交易中了";
                }
            }
        myNotifi(1000,intent, title, content);
    }
}

public static void sendToHelpMeMsg(MessageEvent e) {
        SHelpMeMsg msg = (SHelpMeMsg) e.getMessage();
        synchronized (String.class) {
        if(DataHiBang.sHelpMeMsgList.size()>=10) {
            DataHiBang.sHelpMeMsgList.remove(0);
        }
        DataHiBang.sHelpMeMsgList.add(msg);
        }
        if (isCurrUI(Config.TAG_MessageActivity)) {
            sHelpMeMsgListener.onHelpMeMsgReveived(msg);
        } else {
//          Intent intent = new Intent(currContext, MessageActivity.class);
            myMainTabListener.onMsgReveived(msg);
            Intent intent = new Intent(currContext, InformationActivity.class);
            Bundle bundle = new Bundle();
            bundle.putInt("TAG", Config.TAG_HelpMeMessage);
            MySHelpMeMsg helpMeMsg = new MySHelpMeMsg(msg);
            bundle.putSerializable("helpMeMessage", helpMeMsg);

            intent.putExtras(bundle);
            myNotifi(1002,intent, msg.getHelpName(), msg.getReqItem());
        }
    }

public static void sendToChat(MessageEvent e) {
    SChatMessage msg = (SChatMessage) e.getMessage();
    if (msg.getSenderID() == chattingUserId) {
        DBManage.addSChatMsg(msg, false);
        myChattingListener.onMsgReceived(msg);
    } else {
        DBManage.addSChatMsg(msg, true);
        Intent intent = new Intent(currContext, ChatActivity.class);
        Bundle bundle = new Bundle();
        bundle.putInt("friendId", msg.getSenderID());
        bundle.putString("friendName", msg.getReceiverName());
        intent.putExtras(bundle);
        String title = "嗨帮-聊天消息 (共1条未读)";
        myNotifi(1003,intent,title,msg.getChatContent());

        // sChatMessageListener.onMsgReveived(msg);
    }
}

public static void sendToRecommend(MessageEvent e) {
        SRecommendListMsg msg = (SRecommendListMsg) e.getMessage();
//      DBManage.addRequirement(msg.getRecommendList(), true);
        synchronized (String.class) {
            if(DataHiBang.sRecommMsgList.size()>25) {
                int n = DataHiBang.sRecommMsgList.size() - 25;
                for(int i=0;i<n;i++) {
                    DataHiBang.sRecommMsgList.remove(i);
                }
            }
            DataHiBang.sRecommMsgList.addAll(msg.getRecommendList());
        }

        if (isCurrUI(Config.TAG_RecommendActivity)) {
            sRlMsgListener.onMsgReveived(msg);
        } else {
            Intent intent = new Intent(currContext, MainTabActivity.class);
            myNotifi(1004,intent, "快来帮助别人吧······", msg.getRecommendList().get(0).getReqDetail());
        }
    }

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception
{
    if (LOG.isTraceEnabled()) {
        LOG.trace("message received called " + e.getMessage());
    }
    try {
        if (LOG.isDebugEnabled()) {
            LOG.debug("New message " + e.toString()
                    + " from " + ctx.getChannel());
        }
        NettyServerCnxn cnxn = (NettyServerCnxn)ctx.getAttachment();
        synchronized(cnxn) {
            processMessage(e, cnxn);
        }
    } catch(Exception ex) {
        LOG.error("Unexpected exception in receive", ex);
        throw ex;
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
  if (e.getMessage() instanceof ChannelBuffer) {
    ChannelBuffer buffer = (ChannelBuffer) e.getMessage();

    int bytesToRead = Math.min(currentChunkSize - bytesRead, buffer.readableBytes());
    buffer.readBytes(getMailEnvelope().getMessageOutputStream(), bytesToRead);
    bytesRead += bytesToRead;

    if (bytesRead == currentChunkSize) {
      stopCapturingData();
    }

    return;
  }

  super.messageReceived(ctx, e);
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception {
  RpcInfo info = (RpcInfo) e.getMessage();
  RpcCall call = (RpcCall) info.header();

  SocketAddress remoteAddress = info.remoteAddress();
  if (LOG.isTraceEnabled()) {
    LOG.trace(program + " procedure #" + call.getProcedure());
  }

  if (this.progNumber != call.getProgram()) {
    LOG.warn("Invalid RPC call program " + call.getProgram());
    sendAcceptedReply(call, remoteAddress, AcceptState.PROG_UNAVAIL, ctx);
    return;
  }

  int ver = call.getVersion();
  if (ver < lowProgVersion || ver > highProgVersion) {
    LOG.warn("Invalid RPC call version " + ver);
    sendAcceptedReply(call, remoteAddress, AcceptState.PROG_MISMATCH, ctx);
    return;
  }

  handleInternal(ctx, info);
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception {
  ChannelBuffer buf = (ChannelBuffer) e.getMessage();
  ByteBuffer b = buf.toByteBuffer().asReadOnlyBuffer();
  XDR in = new XDR(b, XDR.State.READING);

  RpcInfo info = null;
  try {
    RpcCall callHeader = RpcCall.read(in);
    ChannelBuffer dataBuffer = ChannelBuffers.wrappedBuffer(in.buffer()
        .slice());
    info = new RpcInfo(callHeader, dataBuffer, ctx, e.getChannel(),
        e.getRemoteAddress());
  } catch (Exception exc) {
    LOG.info("Malformed RPC request from " + e.getRemoteAddress());
  }

  if (info != null) {
    Channels.fireMessageReceived(ctx, info);
  }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
        throws Exception {
    if (e.getMessage() instanceof List) {
        @SuppressWarnings("unchecked")
        List<OFMessage> msglist = (List<OFMessage>) e.getMessage();


        for (OFMessage ofm : msglist) {
            // Do the actual packet processing
            state.processOFMessage(this, ofm);
        }
    } else {
        state.processOFMessage(this, (OFMessage) e.getMessage());
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception
{
    if (LOG.isTraceEnabled()) {
        LOG.trace("message received called " + e.getMessage());
    }
    try {
        if (LOG.isDebugEnabled()) {
            LOG.debug("New message " + e.toString()
                    + " from " + ctx.getChannel());
        }
        NettyServerCnxn cnxn = (NettyServerCnxn)ctx.getAttachment();
        synchronized(cnxn) {
            processMessage(e, cnxn);
        }
    } catch(Exception ex) {
        LOG.error("Unexpected exception in receive", ex);
        throw ex;
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx,
                            MessageEvent e) throws Exception {
    Object message = e.getMessage();
    if (message instanceof SyncMessage) {
        handleSyncMessage((SyncMessage)message, ctx.getChannel());
    } else if (message instanceof List) {
        for (Object i : (List<?>)message) {
            if (i instanceof SyncMessage) {
                try {
                    handleSyncMessage((SyncMessage)i,
                                         ctx.getChannel());
                } catch (Exception ex) {
                    Channels.fireExceptionCaught(ctx, ex);
                }
            }
        }
    } else {
        handleUnknownMessage(ctx, message);
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
        throws Exception {
    if (e.getMessage() instanceof List) {
        @SuppressWarnings("unchecked")
        List<OFMessage> msglist = (List<OFMessage>)e.getMessage();
        for (OFMessage ofm : msglist) {
            try {
                // Do the actual packet processing
                state.processOFMessage(ofm);
            }
            catch (Exception ex) {
                // We are the last handler in the stream, so run the
                // exception through the channel again by passing in
                // ctx.getChannel().
                Channels.fireExceptionCaught(ctx.getChannel(), ex);
            }
        }
    }
    else {
        Channels.fireExceptionCaught(ctx.getChannel(),
                new AssertionError("Message received from channel is not a list"));
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
    lock.lock();
    try {
        // construct response
        if( e.getMessage() instanceof Request) {
            Request req = (Request) e.getMessage();
            resp =req;
            logger.info("receive "+ req.toString() +" from "+e.getRemoteAddress().toString() );
        }
        else {
            logger.info( e.getMessage().getClass().getName()+" len " + e.getMessage().toString().length()
                    +" "+ e.getChannel().getRemoteAddress().toString() );
            resp = null;
        }
        //throw new RuntimeException( e.getMessage().getClass().getName()+" is not supported");
    } finally {
        cleanUp();
        lock.unlock();
    }
    // Server is supposed to send nothing.  Therefore, do nothing.
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
    Request req =  (Request) e.getMessage();
    logger.info("receive " + req.toString()+" from "+e.getRemoteAddress().toString());
    // it might need to create a different copy
    Header header = new Header( req.getHeader().getName(), req.getHeader().getVersion(), req.getHeader().getRelease(),
          req.getHeader().getNodeId());
    Response response = null;
    try {
      Invoker invoker = (Invoker) serializer.toObject( req.getPayload() );
      response = invoke( invoker );
    } catch (Exception ex) {
      logger.error(ex.getMessage(), ex);
      response = new Response( ex.getMessage(), true);
    } finally {
       byte[] payload = serializer.toBytes( response);
       Request request = new Request(header, payload ,  Request.RequestType.Response  );
       ctx.getChannel().write(request);
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception {
  RpcInfo info = (RpcInfo) e.getMessage();
  RpcCall call = (RpcCall) info.header();

  SocketAddress remoteAddress = info.remoteAddress();
  if (LOG.isTraceEnabled()) {
    LOG.trace(program + " procedure #" + call.getProcedure());
  }

  if (this.progNumber != call.getProgram()) {
    LOG.warn("Invalid RPC call program " + call.getProgram());
    sendAcceptedReply(call, remoteAddress, AcceptState.PROG_UNAVAIL, ctx);
    return;
  }

  int ver = call.getVersion();
  if (ver < lowProgVersion || ver > highProgVersion) {
    LOG.warn("Invalid RPC call version " + ver);
    sendAcceptedReply(call, remoteAddress, AcceptState.PROG_MISMATCH, ctx);
    return;
  }

  handleInternal(ctx, info);
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception {
  ChannelBuffer buf = (ChannelBuffer) e.getMessage();
  ByteBuffer b = buf.toByteBuffer().asReadOnlyBuffer();
  XDR in = new XDR(b, XDR.State.READING);

  RpcInfo info = null;
  try {
    RpcCall callHeader = RpcCall.read(in);
    ChannelBuffer dataBuffer = ChannelBuffers.wrappedBuffer(in.buffer()
        .slice());
    info = new RpcInfo(callHeader, dataBuffer, ctx, e.getChannel(),
        e.getRemoteAddress());
  } catch (Exception exc) {
    LOG.info("Malformed RPC request from " + e.getRemoteAddress());
  }

  if (info != null) {
    Channels.fireMessageReceived(ctx, info);
  }
}

protected void updateMessageHeader(Message in, ChannelHandlerContext ctx, MessageEvent messageEvent) {
    in.setHeader(NettyConstants.NETTY_CHANNEL_HANDLER_CONTEXT, ctx);
    in.setHeader(NettyConstants.NETTY_MESSAGE_EVENT, messageEvent);
    in.setHeader(NettyConstants.NETTY_REMOTE_ADDRESS, messageEvent.getRemoteAddress());
    in.setHeader(NettyConstants.NETTY_LOCAL_ADDRESS, messageEvent.getChannel().getLocalAddress());

    if (configuration.isSsl()) {
        // setup the SslSession header
        SSLSession sslSession = getSSLSession(ctx);
        in.setHeader(NettyConstants.NETTY_SSL_SESSION, sslSession);

        // enrich headers with details from the client certificate if option is enabled
        if (configuration.isSslClientCertHeaders()) {
            enrichWithClientCertInformation(sslSession, in);
        }
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception
{
    if (LOG.isTraceEnabled()) {
        LOG.trace("message received called " + e.getMessage());
    }
    try {
        if (LOG.isDebugEnabled()) {
            LOG.debug("New message " + e.toString()
                    + " from " + ctx.getChannel());
        }
        NettyServerCnxn cnxn = (NettyServerCnxn)ctx.getAttachment();
        synchronized(cnxn) {
            processMessage(e, cnxn);
        }
    } catch(Exception ex) {
        LOG.error("Unexpected exception in receive", ex);
        throw ex;
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
        throws Exception {
    super.messageReceived(ctx, e);

    System.out.println("-------- Server  Channel messageRecieved "
            + System.currentTimeMillis());

    if (induceError.get()) {
        System.out
                .println("Inducing Error in Server messageReceived method");
        throw new IOException("Induced error ");
    }

    MessageEventBag bag = new MessageEventBag();
    bag.setBytes(e);
    bagList.add(bag);

    ChannelBuffer buffer = ChannelBuffers.dynamicBuffer();
    buffer.writeInt(200);

    ChannelFuture future = e.getChannel().write(buffer);

    future.addListener(ChannelFutureListener.CLOSE);

}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent messageEvent) throws Exception {
    // store request, as this channel handler is created per pipeline
    HttpRequest request = (HttpRequest) messageEvent.getMessage();

    LOG.debug("Message received: {}", request);

    HttpServerChannelHandler handler = getHandler(request);
    if (handler != null) {
        // store handler as attachment
        ctx.setAttachment(handler);
        handler.messageReceived(ctx, messageEvent);
    } else {
        // this resource is not found, so send empty response back
        HttpResponse response = new DefaultHttpResponse(HTTP_1_1, NOT_FOUND);
        response.headers().set(Exchange.CONTENT_TYPE, "text/plain");
        response.headers().set(Exchange.CONTENT_LENGTH, 0);
        response.setContent(ChannelBuffers.copiedBuffer(new byte[]{}));
        messageEvent.getChannel().write(response).syncUninterruptibly();
        // close the channel after send error message
        messageEvent.getChannel().close();
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception
{
    if (LOG.isTraceEnabled()) {
        LOG.trace("message received called " + e.getMessage());
    }
    try {
        if (LOG.isDebugEnabled()) {
            LOG.debug("New message " + e.toString()
                    + " from " + ctx.getChannel());
        }
        NettyServerCnxn cnxn = (NettyServerCnxn)ctx.getAttachment();
        synchronized(cnxn) {
            processMessage(e, cnxn);
        }
    } catch(Exception ex) {
        LOG.error("Unexpected exception in receive", ex);
        throw ex;
    }
}

@Override
public void messageReceived(ChannelHandlerContext ctx,
                            MessageEvent e) throws Exception {
    Object message = e.getMessage();
    if (message instanceof SyncMessage) {
        handleSyncMessage((SyncMessage)message, ctx.getChannel());
    } else if (message instanceof List) {
        for (Object i : (List<?>)message) {
            if (i instanceof SyncMessage) {
                try {
                    handleSyncMessage((SyncMessage)i,
                                         ctx.getChannel());
                } catch (Exception ex) {
                    Channels.fireExceptionCaught(ctx, ex);
                }
            }
        }
    } else {
        handleUnknownMessage(ctx, message);
    }
}

public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
  Object m = e.getMessage();
  if (!(m instanceof ChannelBuffer)) {
    ctx.sendUpstream(e);
    return;
  }

  ChannelBuffer input = (ChannelBuffer) m;
  if (!input.readable()) {
    return;
  }

  ChannelBuffer cumulation = cumulation(ctx);
  if (cumulation.readable()) {
    cumulation.discardReadBytes();
    cumulation.writeBytes(input);
    callDecode(ctx, e.getChannel(), cumulation, e.getRemoteAddress());
  } else {
    callDecode(ctx, e.getChannel(), input, e.getRemoteAddress());
    if (input.readable()) {
      cumulation.writeBytes(input);
    }
  }
}

public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
  if (e.getMessage() instanceof List) {
    @SuppressWarnings("unchecked")
    List<ResponseWrapper> responses = (List<ResponseWrapper>) e.getMessage();
    if (isDebugEnabled) {
      // for performance trace
      LOGGER.debug("receive response list from server: " + ctx.getChannel().getRemoteAddress() + ",list size is:" + responses.size());
    }
    client.putResponses(responses);
  } else if (e.getMessage() instanceof ResponseWrapper) {
    ResponseWrapper response = (ResponseWrapper) e.getMessage();
    if (isDebugEnabled) {
      // for performance trace
      LOGGER
          .debug("receive response list from server: " + ctx.getChannel().getRemoteAddress() + ",request is:" + response.getRequestId());
    }
    client.putResponse(response);
  } else {
    LOGGER.error("receive message error,only support List || ResponseWrapper");
    throw new Exception("receive message error,only support List || ResponseWrapper");
  }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
    throws Exception {
  ChannelBuffer buf = (ChannelBuffer) e.getMessage();
  ByteBuffer b = buf.toByteBuffer().asReadOnlyBuffer();
  XDR in = new XDR(b, XDR.State.READING);

  RpcInfo info = null;
  try {
    RpcCall callHeader = RpcCall.read(in);
    ChannelBuffer dataBuffer = ChannelBuffers.wrappedBuffer(in.buffer()
        .slice());
    info = new RpcInfo(callHeader, dataBuffer, ctx, e.getChannel(),
        e.getRemoteAddress());
  } catch (Exception exc) {
    LOG.info("Malformed RPC request from " + e.getRemoteAddress());
  }

  if (info != null) {
    Channels.fireMessageReceived(ctx, info);
  }
}

@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
    LOG.info("Message received", e);
    if (e.getMessage() instanceof Response) {
        Response resp = (Response) e.getMessage();
        try {
            SettableFuture<Response> future = responseQueue.take();
            future.set(resp);
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
            LOG.warn("Interrupted in handler", ie);
        }
    } else {
        LOG.warn("Received unknown message", e.getMessage());
    }
}

/**
 * Gets the Camel {@link Message} to use as the message to be set on the current {@link Exchange} when
 * we have received a reply message.
 * <p/>
 *
 * @param exchange      the current exchange
 * @param messageEvent  the incoming event which has the response message from Netty.
 * @return the Camel {@link Message} to set on the current {@link Exchange} as the response message.
 * @throws Exception is thrown if error getting the response message
 */
protected Message getResponseMessage(Exchange exchange, MessageEvent messageEvent) throws Exception {
    Object body = messageEvent.getMessage();
    if (LOG.isDebugEnabled()) {
        LOG.debug("Channel: {} received body: {}", new Object[]{messageEvent.getChannel(), body});
    }

    // if textline enabled then covert to a String which must be used for textline
    if (producer.getConfiguration().isTextline()) {
        body = producer.getContext().getTypeConverter().mandatoryConvertTo(String.class, exchange, body);
    }

    // set the result on either IN or OUT on the original exchange depending on its pattern
    if (ExchangeHelper.isOutCapable(exchange)) {
        NettyPayloadHelper.setOut(exchange, body);
        return exchange.getOut();
    } else {
        NettyPayloadHelper.setIn(exchange, body);
        return exchange.getIn();
    }
}