Netty学习笔记
来源：互联网 发布：windows xp pe u盘版 编辑：程序博客网 时间：2024/05/17 09:07
1.新建NettyTest工程
工程结构如图所示:
2.各个类：
ClientPipelineFactory.java
public class ClientPipelineFactory implements ChannelPipelineFactory {
@Override
public ChannelPipeline getPipeline() throws Exception {
ChannelPipeline pipeline = Channels.pipeline();
pipeline.addLast("encode", new StringEncoder());
pipeline.addLast("decode", new StringDecoder());
pipeline.addLast("handler", new ClientHandler());
return pipeline;
}
}
ClientThread.java(未用)
public class ClientThread implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
NettyClient n = new NettyClient();
n.run();
}
}
NettyClient.java
public class NettyClient {
final static Logger log = Logger.getLogger(NettyClient.class);
String host = "localhost";
int port = 8882;
// 实例化一个客户端Bootstrap实例，其中NioClientSocketChannelFactory实例由Netty提供
static ChannelFactory factory = new NioClientSocketChannelFactory(
Executors.newCachedThreadPool(), Executors.newCachedThreadPool());
static ClientBootstrap bootstrap = new ClientBootstrap(factory);
private ChannelFuture future;
public ChannelFuture getFuture() {
return future;
}
public void setFuture(ChannelFuture future) {
this.future = future;
}
/**
*
* @author linfenliang
* @date 2012-7-2
* @version V1.0.0 void
*/
public void run() {
// TODO Auto-generated method stub
// 设置PipelineFactory,由客户端自己实现
bootstrap.setPipelineFactory(new ClientPipelineFactory());
bootstrap.setOption("tcpNoDelay", true);
bootstrap.setOption("keepAlive", true);
bootstrap.setOption("remoteAddress", new InetSocketAddress(host, port));
// 向目标地址发起一个连接
future = bootstrap.connect();
// 等待链接成功，成功后发起的connected事件将会使handler开始发送信息并且等待messageRecive
future.awaitUninterruptibly();
log.info(future.isSuccess() ? "连接服务器成功！" : "连接服务器失败！");
}
/**
* 发送消息
*
* @author linfenliang
* @date 2012-7-3
* @version V1.0.0 void
*/
public void sendMessage(String value) {
if (future != null) {
Channel ch = future.getChannel();
if (value != null && value.length()!=0) {
ch.write(value);
} else {
ch.write("SHUTDOWN_CHANNELL/r/r");
}
} else {
log.info("未建立连接");
}
}
/**
* 客户端关闭
*
* @author linfenliang
* @date 2012-7-4
* @version V1.0.0
* @param future
* void
*/
public static void shutdown(ChannelFuture future) {
if (future.getChannel().isOpen())
future.getChannel().close().awaitUninterruptibly();
bootstrap.releaseExternalResources();
System.exit(0);
}
/**
* 多线程并发测试
*
* @author linfenliang
* @date 2012-7-4
* @version V1.0.0
* @param runnable
* @param daemon
* void
*/
public static void thread(Runnable runnable, boolean daemon) {
Thread brokerThread = new Thread(runnable);
brokerThread.setDaemon(daemon);
brokerThread.start();
}
}
ClientHandler.java
public class ClientHandler extends SimpleChannelHandler {
final static Logger log = Logger.getLogger(ClientHandler.class);
@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
throws Exception {
// 异常处理
log.error(e.getCause());
e.getChannel().close();
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
throws Exception {
// 客户端消息的接收
// ChannelBuffer buf = (ChannelBuffer) e.getMessage();
// byte[] b = new byte[200];
// int i=0;
// while(buf.readable()){
// b[i++]=buf.readByte();
// }
// byte[] dest = new byte[i];
// System.arraycopy(b, 0, dest,0, i);
// message = new Message(dest);
// System.out.println("获取服务器端下发的消息："+message.getValue());
Object message = e.getMessage();
if (message instanceof String) {
log.info("获取服务器端下发的消息：" + message);
}
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
log.info("。。通道已连接。。");
}
}
Message.java(未用到)
public class Message implements Serializable {
/**
*
*/
private static final long serialVersionUID = 1L;
private String value;
private String clientName;
public String getClientName() {
return clientName;
}
public void setClientName(String clientName) {
this.clientName = clientName;
}
public Message(byte[] valueBytes) {
try {
value = new String(valueBytes, "utf-8");
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
NettyServer.java
public class NettyServer {
final static Logger log = Logger.getLogger(NettyServer.class);
static ChannelFactory CHANNEL_FACTORY = new NioServerSocketChannelFactory(
Executors.newCachedThreadPool(),
Executors.newCachedThreadPool());
static ServerBootstrap SERVER_BOOTSTRAP = new ServerBootstrap(CHANNEL_FACTORY);
/**
*
* @author linfenliang
* @date 2012-7-2
* @version V1.0.0
* @param args
* void
*/
public static void serverStartUp() {
// TODO Auto-generated method stub
SERVER_BOOTSTRAP.setPipelineFactory(new ServerPipelineFactory());
// 这个配置项仅适用于我们接收到的通道实例，而不是ServerSocketChannel实例
SERVER_BOOTSTRAP.setOption("child.tcpNoDelay", true);
SERVER_BOOTSTRAP.setOption("child.keepAlive", true);
SERVER_BOOTSTRAP.setOption("reuseAddress", true);
// SERVER_BOOTSTRAP.setOption("child.backlog", 1000);
// 绑定这个服务使用的端口
SERVER_BOOTSTRAP.bind(new InetSocketAddress(8882));
log.info("....服务器已启动....");
}
public static void serverShutDown(){
Tools.CHANNEL_GROUP.close();
Tools.CHANNEL_MAP.clear();
SERVER_BOOTSTRAP.releaseExternalResources();
System.exit(1);
}
}
ServerPipelineFactory.java
public class ServerPipelineFactory implements ChannelPipelineFactory {
@Override
public ChannelPipeline getPipeline() throws Exception {
// TODO Auto-generated method stub
ChannelPipeline pipeline = Channels.pipeline();
// LengthFieldBasedFrameDecoder 解决数据量过大分包传输时不同client之间数据混乱的问题
// pipeline.addLast("decode",new LengthFieldBasedFrameDecoder(Tools.MAXBYTELENGTH,0,4,0,4));
// pipeline.addLast("framer", new DelimiterBasedFrameDecoder(8192,
// Delimiters.lineDelimiter()));
pipeline.addLast("decoder", new StringDecoder());
// pipeline.addLast("decode",new
// LengthFieldBasedFrameDecoder(Tools.MAXBYTELENGTH,0,4,0,4));
pipeline.addLast("encoder", new StringEncoder());
// 任何时候当服务器接收到一个新的连接，一个新的ChannelPipeline管道对象将被创建，
// 并且所有在这里添加的ChannelHandler对象将被添加至这个新的ChannelPipeline管道对象。
pipeline.addLast("handler", new ServerHandler());
return pipeline;
}
}
Server2ClientMessage.java
final static Logger log = Logger.getLogger(Server2ClientMessage.class);
public void sendMessage(String value, String clientName) {
Channel ch = null;
for (Entry<Integer, Object> entry : Tools.CHANNEL_MAP.entrySet()) {
if (entry.getValue() != null && entry.getValue().equals(clientName)) {
ch = Tools.CHANNEL_GROUP.find(entry.getKey());
}
}
// 消息流（数据下发）
if (ch != null && ch.isOpen()) {
value = "client ID:" + ch.getId() + ",data :" + value;
log.info("服务器向客户端下发的数据：" + value);
try {
ch.write(new String(value.getBytes(),"utf-8"));
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
log.error(e.getMessage());
}
} else {
log.error("消息下发失败，通道未连接或未注册");
}
}
}
ServerHandler.java
public class ServerHandler extends SimpleChannelHandler {
final static Logger log = Logger.getLogger(ServerHandler.class);
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
Channel ch = e.getChannel();
log.info("连接管道已建立，管道ID：" + ch.getId());
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
// TODO Auto-generated method stub
Tools.CHANNEL_MAP.remove(e.getChannel().getId());
Tools.CHANNEL_GROUP.remove(e.getChannel());
super.channelClosed(ctx, e);
}
@Override
public void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
// TODO Auto-generated method stub
log.info("管道已打开，管道记录到Map中");
Channel ch = e.getChannel();
Tools.CHANNEL_MAP.put(ch.getId(), null);
Tools.CHANNEL_GROUP.add(ch);
super.channelOpen(ctx, e);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
throws Exception {
// 异常捕获
e.getCause().printStackTrace();
e.getChannel().close();
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
throws Exception {
Channel ch = e.getChannel();
// Tools.CHANNEL_GROUP.add(ch);
// 判断消息类型，解析 消息
Object msg = e.getMessage();
String clientName = null;
if (msg instanceof String) {
log.info("服务器端接收到客户端传来的String消息："
+ new String(msg.toString().getBytes(),"utf-8"));
String[] str = new String(msg.toString().getBytes(),"utf-8").split("/r/r");
if(str[0].equals("SHUTDOWN_CHANNELL")){
log.info("MAP中原有管道："+Tools.CHANNEL_MAP.entrySet()+"要关闭的客户端通道："+Tools.CHANNEL_MAP.get(ch.getId()));
Tools.CHANNEL_GROUP.remove(ch);
Tools.CHANNEL_MAP.remove(ch.getId());
ch.close().awaitUninterruptibly();
log.info("MAP中执行remove后管道："+Tools.CHANNEL_MAP.entrySet());
}else{
clientName = str[0];
}
// if(msg.toString().equals("SHUTDOWN_CHANNELL")){
// System.out.println("MAP中原有管道数量："+Tools.CHANNEL_MAP.size());
// Tools.CHANNEL_GROUP.remove(ch);
// Tools.CHANNEL_MAP.remove(ch.getId());
// System.out.println("MAP中执行remove后管道数量："+Tools.CHANNEL_MAP.size());
// }
// clientName = msg.toString().split("/r/r")[0];
} else if (msg instanceof ChannelBuffer) {
ChannelBuffer cb = (ChannelBuffer) e.getMessage();
Message m = (Message) Tools.bytes2Obj(cb.array());
// Message m = (Message) e.getMessage();
log.info("服务器端接收到客户端传来的Object消息：" + m.getValue()
+ e.getChannel().getId());
} else {
log.info("接收到的数据类型不匹配");
}
if (Tools.CHANNEL_MAP.containsKey(ch.getId())
&& Tools.CHANNEL_MAP.get(ch.getId()) == null) {
Tools.CHANNEL_MAP.put(ch.getId(), clientName);
Server2ClientMessage scm = new Server2ClientMessage();
scm.sendMessage("client "+clientName+" register success", clientName);
}
log.info("管道："+Tools.CHANNEL_MAP.entrySet());
}
}
ClientTest.java
public class ClientTest {
final static Logger log = Logger.getLogger(ClientTest.class);
/**标记服务器端是否准备好发送信息*/
static boolean isReady = false;
/**
* 运行于命令行
*
* @author linfenliang
* @date 2012-7-4
* @version V1.0.0
* @param args
* void
* @throws UnsupportedEncodingException
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
NettyClient n = new NettyClient();
n.run();
boolean isSuccess = n.getFuture().isSuccess();
log.info(isSuccess ? "已成功连接到服务器..."
: "连接服务器失败，系统即将退出...");
if (!isSuccess) {
log.info("...系统退出...");
System.exit(0);
}
log.info("，请输入要发往服务器的信息");
log.info("信息和客户端名称以冒号分隔(仅第一次时需要),直接回车为关闭本通道,\";\"为退出)：");
while (true) {
Scanner scan = new Scanner(System.in);
String value = scan.nextLine();
String[] ss = value.split(":");
isReady = ss.length>1 || isReady;
try {
if (value.equals(";")) {
n.sendMessage(null);
Thread.sleep(1000);
NettyClient.shutdown(n.getFuture());
System.exit(0);
} else if (isReady) {
String s = null;
if(ss.length>1){
s = new String((ss[1]
+ "/r/r" + ss[0]).getBytes(), "utf-8");
}else{
s = new String(("/r/r" + value).getBytes(), "utf-8");
}
n.sendMessage(s);
} else if (value == null || value.length() == 0) {
n.sendMessage(null);
}
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
log.error(e.getMessage());
} catch (InterruptedException e) {
// TODO Auto-generated catch block
log.error(e.getMessage());
}
}
}
}
ServerTest.java
public class ServerTest {
final static Logger log = Logger.getLogger(ServerTest.class);
/**
*
* @author linfenliang
* @date 2012-7-4
* @version V1.0.0
* @param args
* void
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
NettyServer.serverStartUp();
Server2ClientMessage scm = new Server2ClientMessage();
log.info("请输入发往客户端的信息以及客户端名称，以冒号分隔");
log.info("退出系统输入 ; ");
while (true) {
// Scanner scan = new Scanner(System.in);
// System.out.println(scan.nextLine().toString());
String value = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in, "GBK"));
value = br.readLine();
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
log.error(e.getMessage());
} catch (IOException e) {
// TODO Auto-generated catch block
log.error(e.getMessage());
}
log.info(value);
String[] v = value.split(":");
if(value.equals(";")){
NettyServer.serverShutDown();
System.exit(0);
}
else if (v.length > 1) {
scm.sendMessage("hello,client:"+v[1]+",this is a message from server:" + v[0], v[1]);
} else {
log.error("数据格式错误:" + value);
}
}
}
}
FileOperate.java(未用到)
public class FileOperate {
public static Logger log = Logger.getLogger(FileOperate.class);
/**
*
* 概述：读取文件保存到byte数组中
*
* @Title: readFile
* @param file：源文件路径
* @return byte[]
* @author <a href=mailto:linfenliang@126.com>林芬亮</a>
*/
public static byte[] fileTobyte(String file) {
if (file == null || "".equals(file)) {
return null;
}
File f = new File(file);
if (!f.isFile()) {
return null;
}
ByteArrayOutputStream baos = null;
try {
baos = new ByteArrayOutputStream();
FileInputStream in = new FileInputStream(file);
int c;
byte buffer[] = new byte[1024];
while ((c = in.read(buffer)) != -1) {
for (int i = 0; i < c; i++)
baos.write(buffer[i]);
}
in.close();
baos.close();
} catch (Exception e) {
log.error(e);
throw new RuntimeException();
}
byte[] buf = baos.toByteArray();
return buf;
}
}
Tools.java
public class Tools {
public static final int MAXBYTELENGTH = 999999999;
/** 服务器活动的管道集合 */
public static ChannelGroup CHANNEL_GROUP = null;
/** 服务器建立连接的管道数量 */
public static Map<Integer, Object> CHANNEL_MAP = null;
public static int INCREASE_NUM = 0;
static {
/*-----------数据初始化-------------*/
CHANNEL_GROUP = new DefaultChannelGroup();
CHANNEL_MAP = new HashMap<Integer, Object>();
}
}
log4j.properties
#配置日志的输出级别，此级别及以上的级别的日志可输出显示
log4j.rootLogger=INFO,info,f
#,drfa,DATABASE,MAIL,html,xml
#打印到控制台，便于项目开发及测试
log4j.appender.info = org.apache.log4j.ConsoleAppender
#日志编码方式
log4j.appender.info.Encoding=UTF-8
#是否立即输出(false时不输出)
log4j.appender.info.ImmediateFlush=true
#使用System.err输出
log4j.appender.info.Target=System.err
#布局方式为表达式布局
log4j.appender.info.layout=org.apache.log4j.PatternLayout
log4j.appender.info.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss.SSS} [%C]-[%p] %m%n
log4j.logger.com.opensymphony=INFO
log4j.logger.org.apache.struts2=DEBUG
#需要单独设置的包名(org.com.utils)及级别(WARN)
#log4j.category.org.com.utils=WARN
#打印到日志，一般项目正常工作的时候设置为此模式（按大小滚动文件）
log4j.appender.f=org.apache.log4j.RollingFileAppender
#日志名称及路径
log4j.appender.f.File=D://worklog.log
#${WORKDIR}/log/worklog.log
#${catalina.home}/webapps/MyBlog/WEB-INF/log/worklog.log
#追加文件内容(默认为true)
log4j.appender.f.Append=true
#文件达到10M自动改名
log4j.appender.f.MaxFileSize=10MB
#最多备份10个文件
log4j.appender.f.MaxBackupIndex=10
log4j.appender.f.Encoding=UTF-8
log4j.appender.f.layout=org.apache.log4j.PatternLayout
log4j.appender.f.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss.SSS} [%C]-[%p] %m%n
导出后的文件夹结构：
bat 命令
SERVER_RUN.bat：java -jar SERVER_RUN.jar
ClIENT_RUN.bat：java -jar CLIENT_RUN.jar
- 【Netty】netty学习笔记一
- Netty源码学习笔记
- Netty学习笔记一
- Netty 学习笔记
- Netty学习笔记
- Netty学习笔记
- Netty学习笔记 开始
- Netty学习笔记：1
- Netty学习笔记：2
- Netty源码学习笔记
- Netty 学习笔记
- Netty学习笔记
- Netty学习笔记
- netty 学习笔记
- netty学习笔记
- Netty学习笔记
- netty学习笔记
- Netty 学习笔记一、Hello Netty
- 使用log4j记录日志
- PHP的exec()函数无返回值排查方法
- java.util.concurrent.Delayed
- 华为机试之广度优先遍历
- 大神的博客
- Netty学习笔记
- 并发编程一：CopyOnWriteArrayList
- 你该了解的10个Python 模块
- Unity3D架构设计NavMesh寻路(未完待续)
- VirtualBox虚拟机上网设置
- hibernate配置文件
- 本地添加mvn
- JAVAweb
- java按钮事件处理程序
