开始学Netty,第一天，按照文档启动一个服务

package com.netty;

import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;

/**
 * 英文不好，所以带上英文一起，谢谢
 *
 *
 * */

/**
 * DiscardServerHandler extends SimpleChannelHandler, which is an implementation
 * of ChannelHandler. SimpleChannelHandler provides various event handler
 * methods that you can override. For now, it is just enough to
 *
 * DiscardServerHandler 继承与SimpleChannelHandler,
 * SimpleChannelHandler实现了ChannelHandler SimpleChannelHandler提供了一个你能够重载的事件处理方法，
 * 现在你最好继承SimpleChannelHandler而不是实现自己的处理接口
 *
 * */
public class DiscardServerHandler extends SimpleChannelHandler {

 /**
  * We override the messageReceived event handler method here. This method is
  * called with a MessageEvent, which contains the received data, whenever
  * new data is received from a client. In this example, we ignore the
  * received data by doing nothing to implement the DISCARD protocol.
  *
  * 我们重载了messageReceived事件处理方法，这个方法有MessageEvent，包含了所有从客户端发送了的数据，在这个例子中，
  * 我们忽略接受到的数据的处理
  * */
 @Override
 public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
 }

 /**
  *
  * exceptionCaught event handler method is called with an ExceptionEvent
  * when an exception was raised by Netty due to I/O error or by a handler
  * implementation due to the exception thrown while processing events. In
  * most cases, the caught exception should be logged and its associated
  * channel should be closed here, although the implementation of this method
  * can be different depending on what you want to do to deal with an
  * exceptional situation. For example, you might want to send a response
  * message with an error code before closing the connection.
  *
  * exceptionCaught事件处理方法将被ExceptionEvent调用，当netty产生IO异常，或者一个处理方法抛出异常信息，
  * 大多情况下，我捕获的异常将被日志记录，产生问题相关的通道将被关闭，尽管这种方法的实现可以是不同的，这取决于你想怎么处理特殊情况，比如，
  * 你想发送一个错误的响应信息在连接关闭前
  * */
 @Override
 public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
  e.getCause().printStackTrace();
  Channel ch = e.getChannel();
  ch.close();
 }
}

 

package com.netty;

import java.net.InetSocketAddress;
import java.util.concurrent.Executors;

import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.ChannelFactory;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;

public class DiscardServer {
 public static void main(String[] args) throws Exception {

  /**
   * ChannelFactory is a factory which creates and manages Channels and
   * its related resources. It processes all I/O requests and performs I/O
   * to generate ChannelEvents. Netty provides various ChannelFactory
   * implementations. We are implementing a server-side application in
   * this example, and therefore NioServerSocketChannelFactory was used.
   * Another thing to note is that it does not create I/O threads by
   * itself. It is supposed to acquire threads from the thread pool you
   * specified in the constructor, and it gives you more control over how
   * threads should be managed in the environment where your application
   * runs, such as an application server with a security manager.
   *
   * ChannelFactory是一个创建和管理通道(Channels)和资源关系的工厂，它处理所有的IO请求和IO的执行生成通道事件(
   * ChannelEvents
   * ),Netty提供了一个可变的通道工厂(ChannelFactory)实现，在这个例子中我们能够提供一个服务端的应用
   * NioServerSocketChannelFactory被用了
   * ，要说明的是，它不创建IO线程，他提供了一个可以得到的线程的线程池通过构造函数
   * 它提供了更多的控制，比如，多少线程你可以管理，或者一个安全的管理者
   * */

  ChannelFactory factory = new NioServerSocketChannelFactory(Executors
    .newCachedThreadPool(), Executors.newCachedThreadPool());

  /**
   * ServerBootstrap is a helper class that sets up a server. You can set
   * up the server using a Channel directly. However, please note that
   * this is a tedious process and you do not need to do that in most
   * cases.
   *
   * ServerBootstrap是一个建立服务的辅助类，你可用一个通道直接建立服务，请注意这个繁琐的程序你没有必要去做
   * */
  ServerBootstrap bootstrap = new ServerBootstrap(factory);

  /**
   * Here, we configure the ChannelPipelineFactory. Whenever a new
   * connection is accepted by the server, a new ChannelPipeline will be
   * created by the specified ChannelPipelineFactory. The new pipeline
   * contains the DiscardServerHandler. As the application gets
   * complicated, it is likely that you will add more handlers to the
   * pipeline and extract this anonymous class into a top level class
   * eventually.
   *
   * 现在，我们能够配置 ChannelPipelineFactory，一个新的连接将被服务端接收，一个新的 ChannelPipelin
   * 将被ChannelPipelineFactory创建
   * ，新的管道包含了DiscardServerHandler，当应用变得复杂，你可能添加更多的处理 管道和，扩展匿名类最终到顶级类
   *
   * */

  bootstrap.setPipelineFactory(new ChannelPipelineFactory() {
   public ChannelPipeline getPipeline() {
    return Channels.pipeline(new DiscardServerHandler());
   }
  });

  /**
   * You can also set the parameters which are specific to the Channel
   * implementation. We are writing a TCP/IP server, so we are allowed to
   * set the socket options such as tcpNoDelay and keepAlive. Please note
   * that the "child." prefix was added to all options. It means the
   * options will be applied to the accepted Channels instead of the
   * options of the ServerSocketChannel. You could do the following to set
   * the options of the ServerSocketChannel:
   *
   * 你能设置参数实现特殊的通道，你能写一个TCP/IP服务，你也能够设置scoket比如tcpNoDelay，keepAlive
   * 请注意"child"前缀将被添加在所有选项上，他指这些选项将用与所有接收来的通道，而不是ServerSocketChannel
   * 你能够都做下面的事情设置ServerSocketChannel的选项
   *
   * */
  bootstrap.setOption("child.tcpNoDelay", true);

  bootstrap.setOption("child.keepAlive", true);
  /**
   * We are ready to go now. What's left is to bind to the port and to
   * start the server. Here, we bind to the port 8080 of all NICs (network
   * interface cards) in the machine. You can now call the bind method as
   * many times as you want (with different bind addresses.)
   *
   * 我们开始了，让他绑定端口开始服务，我们绑定机器上的8080端口，我们能够呼叫
   * 你能调用这个绑定方法任何多次
   * */
  bootstrap.bind(new InetSocketAddress(8080));
 }
}