`
liufei.fir
  • 浏览: 685141 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

java分布式系统通信框架

阅读更多
1.Jboss Netty项目-优秀的NIO框架
下载http://www.jboss.org/netty/downloads.html
简介http://www.jboss.org/netty
Jboss的Netty项目旨在提供异步驱动的网络应用程序的框架和工具, 可以用于快速开发, 可方便维护的、高性能的、高扩展性的服务器/客户端之间的通迅协议。
Plurk是一个快速成长,并且已经成为互联网上最大的几个使用python语言的网站之之一,Plurk尝试了以下一些框架/web容器:
Python Twisted:太耗资源了
Jetty:iGoogle的web容器,可惜一万并发的时候用了2G的内存
Apache Tomcat:太吃内存了
Apache MINA:文档很糟糕,可扩展性很差
最后,Plurk发现Netty非常优秀, 在一台四核的服务器上,10万的并发只用了some GB的内存和20%左右的CPU
JBoss社区最近发布了Netty 3.1.0,为用户提供了编写客户/服务网络应用的另一选择。Netty自称是:

    一款异步的事件驱动的网络应用框架和工具,用于快速开发可维护的高性能、高扩展性协议服务器和客户端。也就是说,Netty是一个NIO客户端/服务器框架,支持快速、简单地开发网络应用,如协议服务器和客户端。它极大简化了网络编程,如TCP和UDP套接字服务器。

关于Netty的分类,它与Apache Mina和Grizzly属于同一舞台。该最新版本包含了一系列功能和性能、API可用性的增强。其中包括:

    * 更简单的大数据流(例子)
    * 更多可靠的OutOfMemoryError预防机制
    * 新的传输
          o 基于OIO和NIO的UDP传输
          o VM内传输
          o HTTP隧道
    * 与Google Protocol Buffers集成
    * 与JBoss Microcontainer、OSGI、Guice和Spring集成

HTTP隧道功能满足了用户的迫切需求,在早期发布说明中总结到:

    HTTP隧道传输(位于org.jboss.netty.channel.socket.http)是一种套接字传输,支持任意已经存在的套接字应用在HTTP之上通过代理传输。这种传输在需要越过防火墙而不修改现存服务器应用时特别有用。工作原理如下:

    Http隧道客户端套接字通道 --> 对HTTP友好的防火墙 --> Servlet容器 (如Tomcat、Jetty) --> Http隧道Servlet --> 你的服务器应用

当然在选择一个框架用于开发网络应用时,性能和可扩展性是重要因素。Netty团队在他们的网站上提供了性能信息。你也可以在Apache Mina网站上找到它的性能数据。Nicholas Hagen发布了一系列博文,记录了他如何选择 Mina、Grizzly或者Netty。最终他决定选用Netty,不过指出:

    总的来说,在性能、内存和功能使用方面,我倾向于Netty,而不是Mina和Grizzly。请注意你需要通过自己的分析来决定哪种框架适合你的需求。

Netty下一版本3.2.0,目前正在开发过程中。

JBoss社区最近发布了Netty 3.1.0,为用户提供了编写客户/服务网络应用的另一选择。Netty自称是:

    一款异步的事件驱动的网络应用框架和工具,用于快速开发可维护的高性能、高扩展性协议服务器和客户端。也就是说,Netty是一个NIO客户端/服务器框架,支持快速、简单地开发网络应用,如协议服务器和客户端。它极大简化了网络编程,如TCP和UDP套接字服务器。

关于Netty的分类,它与Apache Mina和Grizzly属于同一舞台。该最新版本包含了一系列功能和性能、API可用性的增强。其中包括:

    * 更简单的大数据流(例子)
    * 更多可靠的OutOfMemoryError预防机制
    * 新的传输
          o 基于OIO和NIO的UDP传输
          o VM内传输
          o HTTP隧道
    * 与Google Protocol Buffers集成
    * 与JBoss Microcontainer、OSGI、Guice和Spring集成

HTTP隧道功能满足了用户的迫切需求,在早期发布说明中总结到:

    HTTP隧道传输(位于org.jboss.netty.channel.socket.http)是一种套接字传输,支持任意已经存在的套接字应用在HTTP之上通过代理传输。这种传输在需要越过防火墙而不修改现存服务器应用时特别有用。工作原理如下:

    Http隧道客户端套接字通道 --> 对HTTP友好的防火墙 --> Servlet容器 (如Tomcat、Jetty) --> Http隧道Servlet --> 你的服务器应用

当然在选择一个框架用于开发网络应用时,性能和可扩展性是重要因素。Netty团队在他们的网站上提供了性能信息。你也可以在Apache Mina网站上找到它的性能数据。Nicholas Hagen发布了一系列博文,记录了他如何选择 Mina、Grizzly或者Netty。最终他决定选用Netty,不过指出:

    总的来说,在性能、内存和功能使用方面,我倾向于Netty,而不是Mina和Grizzly。请注意你需要通过自己的分析来决定哪种框架适合你的需求。

Netty下一版本3.2.0,目前正在开发过程中,路线图可以在这里查看。


此版本的主要更新:
处理大容量数据流更简单
处理协议编码和单元测试更简单
I/O超时和idle状态检测
应用程序的关闭更简单,更安全
更可靠的OutOfMemoryError预防
新的传输方式:
   1.基于OIO和NIO的UDP传输
  2.本地传输(又名 in-VM传输)
  3.HTTP通道,可绕过防火墙
新的编码器:
   1.HTTP客户端和服务器端
   2.用于实现各种专有协议的工具
与其他技术的整合:
   1.Google Protocol Buffers
   2.JBoss Microcontainer, OSGi, Guice以及Spring



package example.helloword.server;

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

import org.jboss.netty.bootstrap.ServerBootstrap;
import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory;

import example.helloword.NetConstant;

public class Server
{
    private static Server server = new Server();
    
    private ServerBootstrap bootstrap;
    
    private Server()
    {}
    
    public static Server getInstance()
    {
        return server;
    }
    
    public void start()
    {
        bootstrap = new ServerBootstrap(new NioServerSocketChannelFactory(
                Executors.newCachedThreadPool(), Executors
                        .newCachedThreadPool()));
        bootstrap.setPipelineFactory(new ServerPipelineFactory());
        bootstrap.bind(new InetSocketAddress(NetConstant.server_port));
    }
    
    public void stop()
    {
        bootstrap.releaseExternalResources();
    }
    
    public static void main(String[] args)
    {
        Server server = Server.getInstance();
        server.start();
    }
}
package example.helloword.server;

import static org.jboss.netty.channel.Channels.pipeline;

import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;

public class ServerPipelineFactory implements ChannelPipelineFactory
{
    public ChannelPipeline getPipeline() throws Exception
    {
        ChannelPipeline pipleline = pipeline();
        pipleline.addLast("encode", new StringEncoder());
        pipleline.addLast("decode", new StringDecoder());
        pipleline.addLast("handler", new ServerHandler());
        return pipleline;
    }
}
package example.helloword.server;

import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;

public class ServerHandler extends SimpleChannelUpstreamHandler
{
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
            throws Exception
    {
        System.out.println("recive message,message content:" + e.getMessage());
        e.getChannel().write("byte");
        
    }
    
    public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
            throws Exception
    {
        e.getChannel().close();
    }
}
package example.helloword.client22;

import static org.jboss.netty.channel.Channels.pipeline;

import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.handler.codec.frame.LengthFieldBasedFrameDecoder;
import org.jboss.netty.handler.codec.frame.LengthFieldPrepender;
import org.jboss.netty.handler.codec.string.StringDecoder;
import org.jboss.netty.handler.codec.string.StringEncoder;

public class ClientPipelineFactory implements ChannelPipelineFactory
{
    public ChannelPipeline getPipeline() throws Exception
    {
        ChannelPipeline pipleline = pipeline();  
        pipleline.addLast("frameDecoder", new LengthFieldBasedFrameDecoder(Integer.MAX_VALUE, 0, 4, 0, 4));  
        pipleline.addLast("frameEncode", new LengthFieldPrepender(4, false));
        pipleline.addLast("encode", new StringEncoder());  
        pipleline.addLast("decode", new StringDecoder());  
        pipleline.addLast("handler", new ClinetHandler());  
        return pipleline;  
    }
}
package example.helloword.client22;

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

import org.jboss.netty.bootstrap.ClientBootstrap;
import org.jboss.netty.channel.ChannelFuture;
import org.jboss.netty.channel.socket.nio.NioClientSocketChannelFactory;

import example.helloword.NetConstant;
import example.helloword.client2.ClientPipelineFactory;

public class ClientPool
{
    public static ClientPool clientPool = new ClientPool();
    
    private ClientBootstrap bootstrap;
    
    private ClientPool()
    {
        bootstrap = new ClientBootstrap(new NioClientSocketChannelFactory(
                Executors.newCachedThreadPool(), Executors
                        .newCachedThreadPool()));
        
        bootstrap.setPipelineFactory(new ClientPipelineFactory());
        bootstrap.setOption("tcpNoDelay", true);
        bootstrap.setOption("keepAlive", true);
    }
    
    public static ClientPool getInstance()
    {
        return clientPool;
    }
    
    public void getChannelFuture(String host, int port, String message)
    {
        ChannelFuture future = bootstrap.connect(new InetSocketAddress(host,
                NetConstant.server_port));
        future.awaitUninterruptibly();
        if (!future.isSuccess())
        {
            future.getCause().printStackTrace();
            future.getChannel().getCloseFuture().awaitUninterruptibly(); 
            return;
        }
        future.getChannel().write(message);
    }
    
    public static void main(String[] args) throws InterruptedException
    {
        for (int i = 0; i < 1000; i++)
        {
            ClientPool.getInstance().getChannelFuture("127.0.0.1", 0,
                    "test" + i);
            Thread.sleep(1000 * 3);
        }
    }
}

2、apache mina
下载http://mina.apache.org/downloads.html
public class Test {
	public static void main(String[] args) throws IOException {
		HttpServer httpServer;
		httpServer = HttpServer.create(new InetSocketAddress(81), 5);
		httpServer.createContext("/", new Handler());
		httpServer.start();
	}

	static class Handler implements HttpHandler {
		public void handle(HttpExchange exchange) throws IOException {
			Headers requestHeaders = exchange.getRequestHeaders();
			Headers responseHeaders = exchange.getResponseHeaders();
			responseHeaders.set("Content-Type", "text/plain");
			exchange.sendResponseHeaders(200, 0L);
			OutputStream responseBody = new BufferedOutputStream(exchange.getResponseBody(), 64*1024);
			responseBody.write("Hello!".getBytes());
			responseBody.close();
			exchange.close();
		}
	}
}
import java.net.InetSocketAddress;

import org.apache.mina.core.filterchain.DefaultIoFilterChainBuilder;
import org.apache.mina.example.echoserver.ssl.BogusSslContextFactory;
import org.apache.mina.filter.ssl.SslFilter;
import org.apache.mina.transport.socket.SocketAcceptor;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

/**
 * (<b>Entry point</b>) Echo server
 *
 * @author The Apache MINA Project (dev@mina.apache.org)
 * @version $Rev: 677923 $, $Date: 2008-07-18 16:55:24 +0200 (Fri, 18 Jul 2008) $
 */
public class Main {
    /** Choose your favorite port number. */
    private static final int PORT = 8080;

    /** Set this to true if you want to make the server SSL */
    private static final boolean USE_SSL = false;

    public static void main(String[] args) throws Exception {
        SocketAcceptor acceptor = new NioSocketAcceptor();
        DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
        

        // Bind
        acceptor.setHandler(new EchoProtocolHandler());
        acceptor.bind(new InetSocketAddress(PORT));

        System.out.println("Listening on port " + PORT);
        
        for (;;) {
            System.out.println("R: " + acceptor.getStatistics().getReadBytesThroughput() + 
                ", W: " + acceptor.getStatistics().getWrittenBytesThroughput());
            Thread.sleep(3000);
        }
    }

 }
import org.apache.mina.core.buffer.IoBuffer;
import org.apache.mina.core.service.IoHandler;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.ssl.SslFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * {@link IoHandler} implementation for echo server.
 *
 * @author The Apache MINA Project (dev@mina.apache.org)
 * @version $Rev: 713957 $, $Date: 2008-11-14 10:27:16 +0100 (Fri, 14 Nov 2008) $,
 */
public class EchoProtocolHandler extends IoHandlerAdapter {
    private final Logger logger = LoggerFactory.getLogger(getClass());
    
    @Override
    public void sessionCreated(IoSession session) {
        session.getConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);

        // We're going to use SSL negotiation notification.
        session.setAttribute(SslFilter.USE_NOTIFICATION);
    }

    @Override
    public void sessionClosed(IoSession session) throws Exception {
        logger.info("CLOSED");
    }

    @Override
    public void sessionOpened(IoSession session) throws Exception {
        logger.info("OPENED");
    }

    @Override
    public void sessionIdle(IoSession session, IdleStatus status) {
        logger.info("*** IDLE #" + session.getIdleCount(IdleStatus.BOTH_IDLE) + " ***");
    }

    @Override
    public void exceptionCaught(IoSession session, Throwable cause) {
        session.close(true);
    }

    @Override
    public void messageReceived(IoSession session, Object message)
            throws Exception {
        // Write the received data back to remote peer
        session.write(((IoBuffer) message).duplicate());
    }
}
public class Test {
	public static void main(String[] args) throws IOException {
		HttpServer httpServer;
		httpServer = HttpServer.create(new InetSocketAddress(81), 5);
		httpServer.createContext("/", new Handler());
		httpServer.start();
	}

	static class Handler implements HttpHandler {
		public void handle(HttpExchange exchange) throws IOException {
			Headers requestHeaders = exchange.getRequestHeaders();
			Headers responseHeaders = exchange.getResponseHeaders();
			responseHeaders.set("Content-Type", "text/plain");
			exchange.sendResponseHeaders(200, 0L);
			OutputStream responseBody = new BufferedOutputStream(exchange.getResponseBody(), 64*1024);
			responseBody.write("Hello!".getBytes());
			responseBody.close();
			exchange.close();
		}
	}
}
分享到:
评论

相关推荐

    java分布式系统架构源码

    Java分布式系统架构是一种将应用程序分布在多个计算节点上运行的技术,以提高系统的可伸缩性、容错性和性能。源码分析对于理解这种架构至关重要,尤其是对于开发者来说,它提供了深入学习和自定义系统的机会。本资源...

    基于分布式系统的JAVA聊天系统

    本文将深入探讨一个基于分布式系统的JAVA聊天系统,它实现了客户端与服务器端的有效通信,并具备完善的容错机制。我们将从系统设计、核心技术、通信协议以及容错策略等多个角度进行详细解析。 首先,我们要理解什么...

    大型分布式系统java应用

    本文将深入探讨大型分布式系统中的Java应用,包括其核心概念、技术框架以及实现策略。 首先,我们要理解什么是分布式系统。分布式系统是由多台独立的计算机通过网络进行通信和协作,共同完成一个任务的系统。这些...

    大规模分布式存储系统:原理解析与架构实战,分布式服务框架原理与实践_李林锋著

    《大规模分布式存储系统:原理解析与架构实战》与...这些书籍对于IT从业者,尤其是希望深入理解分布式系统和微服务架构的开发者来说,是非常宝贵的资源。通过学习,读者能够掌握设计和实施大规模分布式系统的必备技能。

    一款Java分布式KV存储系统源码.zip

    《深入解析Java分布式KV存储系统源码》 Java分布式KV(Key-Value)存储系统是现代互联网服务中不可或缺的一部分,其高效、可扩展的特性使其在大数据处理、缓存服务等领域广泛应用。本篇文章将深入剖析一款基于Java...

    Java 分布式应用程序设计代码

    它是异步通信的重要工具,常用于分布式系统中的解耦和通信。 4. **JNDI(Java Naming and Directory Interface)Java命名和目录接口**:JNDI提供了一个查找和绑定对象的框架,使得分布式系统中的组件可以通过名称来...

    Java分布式实战指南.pdf

    《Java分布式实战指南》这本书详细介绍了如何构建一个完整的Java分布式系统,主要涵盖了技术选型、分布式基础设施环境构建以及项目运营与部署环境等多个方面。在Java微服务领域,它提供了丰富的实践经验和理论指导。...

    基于Java的Redkale 1.9.4 Java 分布式微服务框架.zip

    Redkale是一款强大的Java分布式微服务框架,专为构建高性能、高可用的互联网应用而设计。版本1.9.4代表了该框架的最新稳定版本,提供了诸多改进和新特性。下面将详细介绍Redkale的核心功能和在Java分布式微服务中的...

    Java分布式RPC服务框架教程,包括DubboDubbox,Motan,gRPC..zip

    Java分布式RPC服务框架是现代大型互联网应用中不可或缺的技术组件,它们允许不同的服务之间进行高效、透明的通信。本教程将深入探讨三个主流的Java RPC框架:Dubbo、Dubbox和Motan,以及gRPC,一个由Google推出的高...

    Redkale 1.9.4 Java 分布式微服务框架.zip

    Redkale是一款基于Java开发的高性能、轻量级的分布式微服务框架,旨在提供一套简单易用、功能全面、扩展性强的解决方案,帮助企业快速构建分布式系统。在1.9.4版本中,Redkale持续优化了其核心特性和性能,以满足日...

    Java 分布式应用程序设计

    4. **微服务架构**:随着微服务理念的普及,Java中的Spring Boot和Spring Cloud框架成为构建分布式系统的新宠。这些框架简化了服务发现、负载均衡、配置管理和容错管理等任务。 5. **并发与线程处理**:在分布式...

    tinympi4j是一款微型的java分布式离线计算框架

    tinympi4j是一款专为Java开发者设计的微型分布式离线计算框架,它的核心目标是提供一个简单、直观的工具,让开发人员能够轻松地进行大规模数据处理和计算任务。这款框架的设计理念是降低学习曲线,使得即使是对...

    JAVA分布式程序设计

    总结来说,Java分布式程序设计涵盖了RMI、EJB、JMS、Spring框架、Hadoop与HBase、分布式缓存和Zookeeper等多个知识点。理解并熟练掌握这些技术,可以帮助开发者构建出健壮、高效的分布式系统。在实际工作中,根据...

    J2ee分布式系统框架设计

    ### J2EE分布式系统框架设计:深度解析与关键要素 #### 概述 J2EE(Java 2 Platform, Enterprise Edition)是Sun Microsystems为大型企业级应用开发而设计的平台,它提供了一套完整的分布式计算环境,使得开发者...

    分布式RPC系统框架-Dubbo(2.7)教程(4.31G)

    分布式RPC系统框架-Dubbo(2.7)教程涵盖了在现代软件开发中至关重要的技术领域,主要涉及分布式系统、远程过程调用(RPC)以及相关的中间件和服务治理。Dubbo是阿里巴巴开源的一款高性能、轻量级的RPC框架,它极大地...

    Java 分布式面试 Java 分布式面试

    Java分布式面试主要涉及分布式系统的基础概念、异常处理、副本与一致性以及系统性能指标。以下是相关知识点的详细说明: 1. **分布式系统模型**: - **节点**:在分布式系统中,节点通常指的是运行在不同操作系统...

    Java分布式应用学习笔记

    Java分布式应用学习笔记 在Java世界中,分布式应用是指由多个独立组件通过网络通信协同工作的系统。这种架构模式常用于构建大规模、高可用性、可扩展的系统。本笔记将深入探讨Java分布式应用的核心概念、技术和实践...

    分布式系统概念与设计 原书第5版

    在Java相关的标签下,可以预期本书会讨论Java在构建分布式系统中的应用。这可能包括Java RMI(远程方法调用)、JMS(Java消息服务)和Java并发库,这些都是Java平台中用于分布式编程的重要工具。 安全性和隐私保护...

Global site tag (gtag.js) - Google Analytics