`

java Netty远程编译代码(收藏学习)

阅读更多
客户端

设置消息的长度:buffer.writeInt(classByte.length);
写入消息内容:buffer.writeBytes(classByte);
传输内容:channel.write(buffer);

package hotswap.client;

import hotswap.JavacTool;
import hotswap.NamedThreadFactory;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.Executors;

import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelFactory;
import org.jboss.netty.channel.ChannelFuture;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;
import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;

public class HotSwapClient {

	// 因ChannelFactory的关闭有DirectMemory泄露,采用静态化规避
	// https://issues.jboss.org/browse/NETTY-424
	private static final ChannelFactory channelFactory = new NioClientSocketChannelFactory(
					Executors.newSingleThreadExecutor(new NamedThreadFactory("HotSwapClient_Boss", true)),
					Executors.newSingleThreadExecutor(new NamedThreadFactory("HotSwapClient_Worker", true)),
					1);

	public static void main(String[] args) {
		send(connect());
	}

	public static void send(ChannelFuture future) {
		if (future.isCancelled()) {
			// Connection attempt cancelled by user
			System.out.println("isCanncelled");
		} else if (!future.isSuccess()) {
			future.getCause().printStackTrace();
			System.out.println("isNotSuccess");
		} else {
			// Connection established successfully
			Channel channel = future.getChannel();
			channel.setInterestOps(Channel.OP_READ_WRITE);

			// 编译参数
			List<String> otherArgs = Arrays.asList("-classpath", HotSwapClient.class.getProtectionDomain().getCodeSource().getLocation().toString());
			// 编译
			byte[] classByte = JavacTool.callJavac(otherArgs, "test.HotSwap");
			ChannelBuffer buffer = ChannelBuffers.buffer(classByte.length + 4);
			buffer.writeInt(classByte.length);
			buffer.writeBytes(classByte);
			channel.write(buffer);
		}
	}

	public static ChannelFuture connect() {
		ClientBootstrap bootstrap = new ClientBootstrap(channelFactory);
		bootstrap.setPipelineFactory(new ChannelPipelineFactory() {

			@Override
			public ChannelPipeline getPipeline() throws Exception {
				return Channels.pipeline(new SimpleChannelHandler() {

					@Override
					public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
						System.out.println("channelConnected");
					}

					@Override
					public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
						ChannelBuffer buffer = (ChannelBuffer) e.getMessage();
						System.out.println(buffer.toString(Charset.forName("UTF-8")));
						System.out.flush();
						e.getChannel().close();
					}

					@Override
					public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
						System.out.println("client exceptionCaught");
						e.getCause().printStackTrace();
						e.getChannel().close();
					}
				});
			}
		});
		bootstrap.setOption("tcpNoDelay", true);
		bootstrap.setOption("keepAlive", true);
		ChannelFuture future = bootstrap.connect(new InetSocketAddress("127.0.0.1", 20001));
		future.awaitUninterruptibly();
		return future;
	}
}



服务端

读取消息长度:int msgBodyLen = buffer.readInt();

判断是否相等:if (buffer.readableBytes() >= msgBodyLen )

package hotswap.server;

import hotswap.JavaClassExecuter;
import hotswap.NamedThreadFactory;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.jboss.netty.bootstrap.Bootstrap;
import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelException;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.Channels;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelHandler;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;
import org.jboss.netty.handler.codec.frame.FrameDecoder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The HotSwapServer represents
 * @version $Id$
 * @author fengjiachun
 */
public class HotSwapServer extends AbstractNettyServer {

	private static final Logger LOG = LoggerFactory.getLogger(HotSwapServer.class);

	static {
		try {
			new HotSwapServer().startServer();
		} catch (Exception e) {
			LOG.error("start HotSwapServer error {}", e);
		}
	}

	@Override
	public Bootstrap createServerBootstrap() {
		ExecutorService boss = Executors.newSingleThreadExecutor(new NamedThreadFactory("HotSwapServer_Boss"));
		ExecutorService worker = Executors.newSingleThreadExecutor(new NamedThreadFactory("HotSwapServer_Worker"));
		this.serverBootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(boss, worker, 1));

		return this.serverBootstrap;
	}

	@Override
	public TRANSMISSION_PROTOCOL getTransmissionProtocol() {
		return TRANSMISSION_PROTOCOL.TCP;
	}

	@Override
	public void startServer() throws Exception {
		startServer(20001);
	}

	@Override
	public void startServer(int port) throws Exception {
		InetSocketAddress socketAddress = new InetSocketAddress(port);
		startServer(socketAddress);
	}

	@Override
	public void startServer(InetSocketAddress socketAddress) throws Exception {
		setPipelineFactory(new HotSwapPipelineFactory());

		String[] optionsList = new String[2];
		optionsList[0] = "child.tcpNoDelay";	// 关闭Nagle算法
		optionsList[1] = "child.keepAlive";		// TCP定期发送心跳包,应用层不应该依赖这个选项,应用层有自己的心跳机制
		configureServerBootStrap(optionsList);
		try {
			((ServerBootstrap) this.serverBootstrap).bind(socketAddress);
			if (LOG.isInfoEnabled()) {
				LOG.info("HotSwapServer start, port=" + socketAddress.getPort());
			}
		} catch (ChannelException e) {
			LOG.error("Unable to start HotSwapServer due to error {}", e);
			throw e;
		}
	}

	class HotSwapPipelineFactory implements ChannelPipelineFactory {

		private SimpleChannelHandler messageReceivedHandler = new SimpleChannelHandler() {

			@Override
			public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
				byte[] classByte = (byte[]) e.getMessage();
				//  执行传过来的字节
				String resultMsg = JavaClassExecuter.execute(classByte);
				byte[] resultByte = resultMsg.getBytes(Charset.forName("UTF-8"));
				ChannelBuffer buffer = ChannelBuffers.buffer(resultByte.length);
				buffer.writeBytes(resultByte);
				e.getChannel().write(buffer);
			}

			@Override
			public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) {
				LOG.error("HotSwap Exception Caught: {}. Going to close channel.", e.getCause());
				e.getChannel().close();
			}

			@Override
			public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
				if (LOG.isInfoEnabled()) {
					LOG.info("HotSwap Connected Channel with ip: {}.", e.getChannel().getRemoteAddress());
				}
			}

			@Override
			public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
				if (LOG.isInfoEnabled()) {
					LOG.info("HotSwap Disconnected Channel with ip: {}.", e.getChannel().getRemoteAddress());
				}
			}
		};

		@Override
		public ChannelPipeline getPipeline() throws Exception {
			return addHandlers(Channels.pipeline());
		}

		public ChannelPipeline addHandlers(ChannelPipeline pipeline) {
			if (null == pipeline) {
				return null;
			}
			pipeline.addLast("hotSwapDecoder", new FrameDecoder() {

				@Override
				protected Object decode(ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) throws Exception {
					if (buffer.readableBytes() >= 4) {
						buffer.markReaderIndex();			// 标记ReaderIndex
						int msgBodyLen = buffer.readInt();	// 前四个字节存放消息的长度
						if (buffer.readableBytes() >= msgBodyLen) {
							ChannelBuffer dst = ChannelBuffers.buffer(msgBodyLen);
							buffer.readBytes(dst, msgBodyLen);
							return dst.array();
						} else {
							buffer.resetReaderIndex();
							return null;
						}
					}
					return null;
				}
			});
			pipeline.addLast("hotSwapHandler", messageReceivedHandler);
			return pipeline;
		}
	}
}




转自:http://budairenqin.iteye.com/blog/1788839
分享到:
评论
发表评论

文章已被作者锁定,不允许评论。

相关推荐

    java开源包3

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    Netty-TCP-thymeleaf.zip

    thymeleaf.zip"项目中,开发者整合了这两个技术,创建了一个系统,使得硬件设备能够通过TCP协议与Netty服务器进行通信,然后将接收到的硬件运行数据实时展示在基于Thymeleaf的Web页面上,实现了硬件状态的远程监控和...

    java项目实例_远程控制

    在Java编程领域,远程控制是一项重要的技术,它允许一台计算机通过网络对另一台计算机...它涵盖了项目结构、配置管理、网络通信、安全性以及多线程等多个关键知识点,对于学习和理解Java远程控制技术具有很高的价值。

    JAVA版基于netty的物联网高并发智能网关.zip

    总的来说,"JAVA版基于netty的物联网高并发智能网关"是一个实用的项目,对于理解物联网系统架构、学习Netty框架以及提升Java网络编程技能都有很大的帮助。通过深入研究和实践,我们可以构建出更强大、更适应实际需求...

    基于java实现远程采集华为逆变器使用modbus tcp协议进行通讯的设备数据

    本项目主要用于远程采集华为逆变器使用modbus tcp协议进行通讯的设备数据。 主要使用对象是华为逆变器。 主要采用对接文档是 SUN2000L V100R001 MODBUS 接口定义描述 采用netty 4.1.22.Final 版本作为高并发的底层...

    netty+protobuf开发一个聊天室实例

    2. **编译器**: 使用protoc将.proto文件编译为不同语言的代码(如Java、Python、C++),生成的消息类可以方便地序列化和反序列化。 3. **消息类型**: Protobuf中的基本数据结构,可以包含多个字段,每个字段都有唯一...

    中微子代理(neutrino-proxy)是一个基于netty的、开源的java内网穿透项目

    中微子代理(neutrino-proxy)是一款专为程序员和IT专业人员设计的开源Java内网穿透工具,它基于高...对于想要深入学习网络编程、内网穿透技术和Java框架应用的开发者来说,中微子代理及其源代码是一个宝贵的学习资源。

    java开源包10

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    java开源包8

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    java实现485自由协议通讯

    在IT行业中,485通讯通常指的是使用RS-485接口进行通信的方式,它是一种广泛应用于工业控制、远程监控等领域的串行通信标准。RS-485提供了一个多点、半双工的通信环境,允许在一条总线上连接多个设备。自由协议则是...

    java开源包4

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    java开源包101

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    java开源包6

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    java开源包9

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    java开源包5

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    java开源包1

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    Java资源包01

    6、支持多种通信框架(Mina/Netty/Grizzly),支持多种序列化/反序列化(Java/Hessian/PB); 7、支持自定义通信协议,可完全替换NFS-RPC自带的协议。 淘宝开放平台JAVA版SDK top4java 设计原则 容易维护扩展(不...

    netty-websocket-proxy-1.3.2-bin .zip

    Netty 是一个高性能、异步事件驱动的网络应用程序框架,用于快速开发可维护的高...通过学习和使用这个项目,开发者可以提升对 Netty 框架以及 WebSocket 协议的理解,同时也能掌握如何构建高效、灵活的网络代理服务。

    0.14.1的libthrift.jar,以及netty-all-4.1.50.Final.jar

    在给定的上下文中,我们有两个关键的JAR文件:`libthrift.jar` 和 `netty-all-4.1.50.Final.jar`,它们在Java开发中扮演着重要角色,特别是对于网络通信和分布式系统。以下是关于这两个文件和它们所涉及的技术点的...

    JAVA核心知识点整理.pdf

    JVM是Java程序运行的底层平台,它负责将Java代码编译成字节码执行,并且提供内存管理、垃圾回收等机制。JVM内存区域包括程序计数器、虚拟机栈、本地方法栈、堆和方法区。程序计数器、虚拟机栈和本地方法栈是线程私有...

Global site tag (gtag.js) - Google Analytics