亚洲欧洲日产国产综合网,国产欧美精品一区二区三区 ,999国产精品999久久久久久

Hadoop-详解

陈睿 — Fri, 30 Mar 2012 02:14:00 GMT

之前有接触过hadoop�Q�但都比较浅显，对立面的东东不是很清楚！
打算后面在hadoop上花旉��把里面的内容�Q�好好学学，�q�篇博客��在后面陆箋更新hadoop学习(f��n)�W�记�?img src ="http://www.aygfsteel.com/mikechen/aggbug/373028.html" width = "1" height = "1" />

陈睿 2012-03-30 10:14 发表评论

底层架构-�q�程通讯-Mina

陈睿 — Thu, 15 Mar 2012 06:49:00 GMT

一�Q�Mina概要
Apache Mina是一个能够帮助用户开发高性能和高伸羃性网�l�应用程序的框架。它通过Java nio技术基于TCP/IP和UDP/IP协议提供了抽象的、事仉��动的、异步的API�?div>如下的特性：(x��)

1�? ��Z��Java nio的TCP/IP和UDP/IP实现

��Z��RXTX的串口通信�Q�RS232�Q?/div>

VM 通道通信

2、通过filter接口实现扩展�Q�类��g��Servlet filters

3、low-level�Q�底层）和high-level�Q�高�U�封装）的api�Q?/div>

low-level�Q��用ByteBuffers

High-level�Q��用自定义的消息对象和解码�?/div>

4、Highly customizable�Q�易用的�Q�线�E�模式（MINA2.0 已经��用�U�程模型了）�Q?/div>

单线�E?/div>

�U�程�?/div>

多个�U�程�?/div>

5、基于java5 SSLEngine的SSL、TLS、StartTLS支持

6、负载��^�?/div>

7、��用mock�q�行单元��试

8、jmx整合

9、基于StreamIoHandler的流式I/O支持

10、IOC容器的整合：(x��)Spring、PicoContainer

11、��^滑迁�U�d��Netty�q�_��

二：(x��)实践
首先讲一下客��L(f��ng)��的通信�q�程�Q?br />

1.通过SocketConnector同服务器端徏立连�?nbsp;

2.链接建立之后I/O的读写交�l�了I/O Processor�U�程�Q�I/O Processor是多�U�程�?nbsp;

3.通过I/O Processor��d��的数据经�q�IoFilterChain里所有配�|�的IoFilter�Q�IoFilter�q�行消息的过滤，格式的�{换，在这个层面可以制定一些自定义的协�?nbsp;

4.最后IoFilter��数据交�l�Handler�q�行业务处理�Q�完成了整个��d��的过�E?nbsp;

5.写入�q�程也是�c�M��Q�只是刚好倒过来，通过IoSession.write写出数据�Q�然后Handler�q�行写入的业务处理，处理完成后交�l�IoFilterChain�Q�进行消息过滤和协议的�{换，最后通过I/O Processor��数据写出到socket通道

IoFilterChain作�ؓ(f��)消息�q��o(h��)�?nbsp;

1.��d��的时候是从低�U�协议到高��协议的过�E�，一般来说从byte字节逐渐转换成业务对象的�q�程

2.写入的时候一般是从业务对象到字节byte的过�E?nbsp;

IoSession贯穿整个通信�q�程的始�l?nbsp;

客户端通信�q�程

1.创徏服务�?br /> package com.gewara.web.module.base;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.charset.Charset;

import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

/**
* Mina服务�?br /> *
* @author mike
*
* @since 2012-3-15
*/
public class HelloServer {

        private static final int PORT = 8901;// 定义监听端口

        public static void main(String[] args) throws IOException{
            // 创徏服务端监控线�E?/span>
            IoAcceptor acceptor = new NioSocketAcceptor();

            // 讄��日志记录�?/span>
            acceptor.getFilterChain().addLast("logger", new LoggingFilter());

            // 讄��~�码�q��o(h��)�?/span>
            acceptor.getFilterChain().addLast("codec",new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));

            // 指定业务逻辑处理�?/span>
            acceptor.setHandler(new HelloServerHandler());

            // 讄��端口�?/span>
            acceptor.setDefaultLocalAddress(new InetSocketAddress(PORT));

            // 启动监听�U�程
            acceptor.bind();
        }
}

2.创徏服务器端业务逻辑

package com.gewara.web.module.base;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;

/**
* 服务器端业务逻辑
*
* @author mike
*
* @since 2012-3-15
*/
public class HelloServerHandler extends IoHandlerAdapter {
         @Override
        /**
         * �q�接创徏事�g
         */
        public void sessionCreated(IoSession session){
            // 昄��客户端的ip和端�?/span>
            System.out.println(session.getRemoteAddress().toString());
        }

        @Override
        /**
         * 消息接收事�g
         */
        public void messageReceived(IoSession session, Object message) throws Exception{
            String str = message.toString();
            if (str.trim().equalsIgnoreCase("quit")){
                // �l�束�?x��)�?/span>
                session.close(true);
                return;
            }

            // �q�回消息字符�?/span>
            session.write("Hi Client!");
            // 打印客户端传来的消息内容
            System.out.println("Message written" + str);
        }
}

3.创徏客户�?br /> package com.gewara.web.module.base;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;

import org.apache.mina.core.future.ConnectFuture;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.textline.TextLineCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketConnector;

/**
* Mina客户�?br /> *
* @author mike
*
* @since 2012-3-15
*/
public class HelloClient {
       public static void main(String[] args){
            // 创徏客户端连接器.
            NioSocketConnector connector = new NioSocketConnector();

            // 讄��日志记录�?/span>
            connector.getFilterChain().addLast("logger", new LoggingFilter());

            // 讄��~�码�q��o(h��)�?/span>
            connector.getFilterChain().addLast("codec",
                    new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));

            // 讄��q�接��时��(g��)查时�?/span>
            connector.setConnectTimeoutCheckInterval(30);

            // 讄��事�g处理�?/span>
            connector.setHandler(new HelloClientHandler());

            // 建立�q�接
            ConnectFuture cf = connector.connect(new InetSocketAddress("192.168.2.89", 8901));

            // �{�待�q�接创徏完成
            cf.awaitUninterruptibly();

            // 发送消�?nbsp;
            cf.getSession().write("Hi Server!");

            // 发送消�?/span>
            cf.getSession().write("quit");

            // �{�待�q�接断开
            cf.getSession().getCloseFuture().awaitUninterruptibly();

            // 释放�q�接
            connector.dispose();
        }
}

4.客户端业务逻辑

package com.gewara.web.module.base;

import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IoSession;

public class HelloClientHandler extends IoHandlerAdapter {
        @Override
        /**
         * 消息接收事�g
         */
        public void messageReceived(IoSession session, Object message) throws Exception{
            //昄��接收到的消息
            System.out.println("server message:"+message.toString());
        }
}

5.先启动服务器端，然后启动客户�?br />

2012-03-15 14:45:41,456  INFO  logging.LoggingFilter - CREATED
/192.168.2.89:2691
2012-03-15 14:45:41,456  INFO  logging.LoggingFilter - OPENED
2012-03-15 14:45:41,487  INFO  logging.LoggingFilter - RECEIVED: HeapBuffer[pos=0 lim=11 cap=2048: 48 69 20 53 65 72 76 65 72 21 0A]
2012-03-15 14:45:41,487  DEBUG codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 1
Message writtenHi Server!
2012-03-15 14:45:41,487  INFO  logging.LoggingFilter - SENT: HeapBuffer[pos=0 lim=0 cap=0: empty]
2012-03-15 14:45:41,487  INFO  logging.LoggingFilter - RECEIVED: HeapBuffer[pos=0 lim=5 cap=2048: 71 75 69 74 0A]
2012-03-15 14:45:41,487  DEBUG codec.ProtocolCodecFilter - Processing a MESSAGE_RECEIVED for session 1
2012-03-15 14:45:41,487  INFO  logging.LoggingFilter - CLOSED

�?分析源码
1.首先看服务器

  // 创徏服务端监控线�E?/span>
            IoAcceptor acceptor = new NioSocketAcceptor();

            // 讄��日志记录�?/span>
            acceptor.getFilterChain().addLast("logger", new LoggingFilter());

            // 讄��~�码�q��o(h��)�?/span>
            acceptor.getFilterChain().addLast("codec",new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));

            // 指定业务逻辑处理�?/span>
            acceptor.setHandler(new HelloServerHandler());

            // 讄��端口�?/span>
            acceptor.setDefaultLocalAddress(new InetSocketAddress(PORT));

            // 启动监听�U�程
            acceptor.bind();

1)先创�?span style="font-size: 13px; background-color: #eeeeee; ">NioSocketAcceptor nio的接收器�Q�谈到Socket��p��说到Reactor模式
当前分布式计��　Web Services盛行天下�Q�这些网�l�服务的底层都离不开对socket的操作。他们都有一个共同的�l�构�Q?/span>
1. Read request
2. Decode request
3. Process service
4. Encode reply
5. Send reply

但这�U�模式在用户负蝲增加�Ӟ��性能��下降非常的快。我们需要重新寻找一个新的方案，保持数据处理的流畅，很显�Ӟ��事�g触发机制是最好的解决办法�Q�当有事件发生时�Q�会(x��)触动handler,然后开始数据的处理�?br />Reactor模式�c�M��于AWT中的Event处理�?/p>

Reactor模式参与�?/strong>

1.Reactor 负责响应IO事�g�Q�一旦发生，�q�播发送给相应的Handler��d��?�q�类��g��AWT的thread
2.Handler 是负责非堵塞行�ؓ(f��)�Q�类��g��AWT ActionListeners�Q�同时负责将handlers与event事�g�l�定�Q�类��g��AWT addActionListener

�q�发�pȝ��帔R��用reactor模式�Q�简�U�观察者模式，代替常用的多�U�程处理方式�Q?strong>利用有限的系�l�的资源�Q�提高系�l�的吞吐�?/strong>�?br />

可以看一下这��文章，讲解的很生动具体�Q�一看就明白reactor模式的好�?a >http://daimojingdeyu.iteye.com/blog/828696
Reactor模式是编写高性能�|�络服务器的必备技术之一�Q�它��h��如下的优点：(x��)
    1�Q�响应快�Q�不必�ؓ(f��)单个同步旉��所��d��Q�虽然Reactor本��n依然是同步的�Q?/span>
    2�Q�编�E�相对简单，可以最大程度的避免复杂的多�U�程�?qi��ng)同步问题，�q�且避免了多�U�程/�q�程的切换开销�Q?/span>
    3�Q�可扩展性，可以方便的通过增加Reactor实例个数来充分利用CPU资源�Q?/span>
    4�Q�可复用性，reactor框架本��n与具体事件处理逻辑无关�Q�具有很高的复用性；

2)其次�Q�再说说NIO的基本原理和使用
  NIO 有一个主要的�c�Selector,�q�个�c�M��一个观察者，只要我们把需要探知的socketchannel告诉Selector,我们接着做别的事情，当有事�g发生�Ӟ��他会(x��)通知我们�Q�传回一�l?SelectionKey,我们��d��q�些Key,��׃��(x��)获得我们刚刚注册�q�的socketchannel,然后�Q�我们从�q�个Channel中读取数据，攑ֿ��Q�包准能够读刎ͼ�接着我们可以处理�q�些数据�?div>　　Selector内部原理实际是在做一个对所注册的channel的轮询访问，不断的轮�?目前��p��一个算�?�Q�一旦轮询到一个channel有所注册的事情发生，比如数据来了�Q�他��׃��(x��)站�v来报告，交出一把钥匙，让我们通过�q�把钥匙(SelectionKey表示 SelectableChannel �?Selector 中的注册的标记�?)来读取这个channel的内宏V�?/div>

陈睿 2012-03-15 14:49 发表评论

底层架构-�q�程通讯

陈睿 — Mon, 12 Mar 2012 01:57:00 GMT
一�Q�基本原�?/strong>
主要是要实现�|�络之间的通讯�Q?span style="font-family: Helvetica, Tahoma, Arial, sans-serif; line-height: 25px; text-align: left; background-color: #ffffff; ">�|�络通信需要做的就是将��从一台计��机传输到另外一台计��机�Q�基于传输协议和�|�络IO来实玎ͼ�其中传输协议比较出名的有http�?tcp、udp�{�等�Q�http、tcp、udp都是在基于Socket概念上�ؓ(f��)某类应用场景而扩展出的传输协议，�|�络IO�Q�主要有bio、nio、aio 三种方式�Q�所有的分布式应用通讯都基于这个原理而实现�?br />
二：(x��)实践
在分布式服务框架中，一个最基础的问题就是远�E�服务是怎么通讯的，在Java领域中有很多可实现远�E�通讯的技�?RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS
既然引入��Z��q�么多技术，那我们就��道深入挖掘下去�Q�了解每个技术框架背后的东西�Q?br />1.首先看RMI
   RMI主要包含如下内容�Q?nbsp;
�q�程服务的接口定�?nbsp;
      ·�q�程服务接口的具体实�?nbsp;
      ·桩（Stub�Q�和框架�Q�Skeleton�Q?/span>文�g
      ·一个运行远�E�服务的服务�?nbsp;
      ·一个RMI命名服务�Q�它允许客户�?/a>��d��现这个远�E�服�?nbsp;
      ·�c?/a>文�g的提供者（一个HTTP或者FTP服务器）
      ·一个需要这个远�E�服务的客户端程�?/span>

  来看下基于RMI的一�ơ完整的�q�程通信�q�程的原理：(x��)
    1)客户端发赯��求，��h��转交至RMI客户端的stub�c�；
    2)stub�c�d��h��的接口、方法、参数等信息�q�行序列化；
    3)��Z��tcp/ip��序列化后的��传输至服务器端�Q?/div>
    4)服务器端接收到流后�{发至相应的skelton�c�；
    5)skelton�c�d��h��的信息反序列化后调用实际的处理类�Q?/div>
    6)处理�c�d��理完毕后��结果返回给skelton�c�；
    7)Skelton�c�d��l�果序列化，通过tcp/ip��流传送给客户端的stub�Q?/div>
    8)stub在接收到��后反序列化�Q�将反序列化后的Java Object�q�回�l�调用者�?br />
RMI应用�U�协议内容：(x��)
1、传输的标准格式是什么？
是Java ObjectStream�?/div>
2、怎么样将��h��转化��Z��输的��？
��Z��Java串行化机制将��h��的java object信息转化为流�?/div>
3、怎么接收和处理流�Q?/div>
�Ҏ(gu��)��采用的协议启动相应的监听端口�Q�当有流�q�入后基于Java串行化机制将��进行反序列化，�q�根据RMI协议获取到相应的处理对象信息�Q�进行调用�ƈ处理�Q�处理完毕后的结果同样基于java串行化机制进行返回�?/div>
4、传输协议是�Q?/div>
tcp/ip�?br />
原理讲了�Q�开始实践：(x��)
创徏RMI�E�序�?个步骤：(x��)
1、定义一个远�E�接口的接口�Q�该接口中的每一个方法必��d��明它?y��u)��生一个RemoteException异常�?nbsp;
2、定义一个实现该接口的类�?nbsp;
3、��用RMIC�E�序生成�q�程实现所需的残根和框架�?nbsp;
4、创��Z��个服务器�Q�用于发�?中写好的�c�R�?nbsp;
5. 创徏一个客��L(f��ng)��序进行RMI调用�?nbsp;
6、启动rmiRegistry�q�运行自��q��q�程服务器和客户�E�序


1�Q�首先创��E�接口：(x��)
/**
* �q�程接口
*
* @author mike
*
* @since 2012-3-14
*/
public interface Hello extends Remote {
    /**
     * ��试r(sh��)mi
     *
     * @return   hello
     * @throws RemoteException
     */
    public String hello()throws RemoteException;
}

     2�Q�创建接口实�?br />   package com.gewara.rmi;

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

/**
* �q�程接口实现
*
* @author mike
*
* @since 2012-3-14
*/
public class HelloImpl extends UnicastRemoteObject implements Hello {

    /**
     * seria id
     */
    private static final long serialVersionUID = -7931720891757437009L;

    protected HelloImpl() throws RemoteException {
        super();
    }

    /**
     * hello实现
     *
     * @return hello world
     * @throws RemoteException
     */
    public String hello() throws RemoteException {
        return "hello world";
    }

}

3)创徏服务器端
  package com.gewara.rmi;

import java.rmi.Naming;
import java.rmi.registry.LocateRegistry;

public class Server {

    private static final String RMI_URL="rmi://192.168.2.89:10009/server";

    /**
     * RMI Server
     */
    public Server() {
        try {
            //创徏�q�程对象
            Hello hello=new HelloImpl();

            //启动注册�?/span>
            LocateRegistry.createRegistry(10009);

            //��名�U�绑定到对象
            Naming.bind(RMI_URL, hello);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * @param args
     */
    public static void main(String[] args) {
        new Server();

    }

}

4)创徏客服�?br />   package com.gewara.rmi;

import java.rmi.Naming;

public class Client {

    private static final String RMI_URL="rmi://192.168.2.89:10009/server";
    /**
     * @param args
     */
    public static void main(String[] args) {
         try {
                   String result=((Hello)Naming.lookup(RMI_URL)).hello();
                System.out.println(result);
            } catch (Exception e) {
                e.printStackTrace();
            }
    }

}

5)先启动服务器端，然后再启动客��L(f��ng)��
昄��l�果�Q�hello world

�׃��涉及(qi��ng)到的内容比较多，打算每一��里讲一个远�E�通讯框架�Q��l�详解RMI

三：(x��)详解RMI内部原理
1. RMI基本�l�构�Q�包含两个独立的�E�序�Q�服务器和客��L(f��ng)��Q�服务器创徏多个�q�程对象�Q�让�q�程对象能够被引用，�{�待客户端调用这些远�E�对象的�Ҏ(gu��)��。客��L(f��ng)��从服务器获取��C��个或则多个远�E�对象的引用�Q�然后调用远�E�对象方法，主要涉及(qi��ng)到RMI接口、回调等技术�?br />
2.RMI回调�Q�服务器提供�q�程对象引用供客��L(f��ng)��调用�Q�客��L(f��ng)��d��调用服务器，如果服务器主动打��调用客��L(f��ng)��Q�这��叫回调�?br />
3.命名�q�程对象�Q�客��L(f��ng)��通过一个命名或则一个查找服务找到远�E�服务，�q�程服务包含Java的命名和查找接口(Java Naming and Directory Interface)JNDI
RMI提供了一�U�服�?RMI注册rmiregistry,默认端口�Q?099�Q�主机提供远�E�服务，接受服务�Q�启动注册服务的命��o(h��)�Q�start rmiregistry
客户端��用一个静态类Naming到达RMI注册处，通过�Ҏ(gu��)��lookup()�Ҏ(gu��)��Q�客��h��询问注册�?/div>

陈睿 2012-03-12 09:57 发表评论