接着Mina源码阅读笔记(四)—Mina的连接IoConnector1,,我们继续:

AbstractIoAcceptor:

001 package org.apache.mina.core.rewrite.service;
002  
003 import java.io.IOException;
004 import java.net.SocketAddress;
005 import java.util.ArrayList;
006 import java.util.Collections;
007 import java.util.HashSet;
008 import java.util.List;
009 import java.util.Set;
010 import java.util.concurrent.Executor;
011  
012 public abstract class AbstractIoAcceptor extends AbstractIoService implements
013         IoAcceptor
{
014  
015     private final List<SocketAddress>
defaultLocalAddresses = 
new ArrayList<SocketAddress>();
016  
017     private final List<SocketAddress>
unmodifiableDeffaultLocalAddresses = Collections
018             .unmodifiableList(defaultLocalAddresses);
019  
020     private final Set<SocketAddress>
boundAddresses = 
new HashSet<SocketAddress>();
021  
022     private boolean disconnectOnUnbind
true;
023  
024     /**
这里不是很明白,为什么要用protected 而 不是private */
025     protected final Object
bindLock = 
new Object();
026  
027     /**
028      *
注意这个构造方法是一定要写的,否则编译不通过:抽象类继承时候,构造方法都要写,而且必须包含super
029      *
030      *
@param param
031      *           
sessionConfig
032      *
@param executor
033      */
034     protected AbstractIoAcceptor(Object
param, Executor executor) {
035         super(param,
executor);
036         defaultLocalAddresses.add(null);
037     }
038  
039     @Override
040     public SocketAddress
getLocalAddress() {
041  
042         Set<SocketAddress>
localAddresses = getLocalAddresses();
043         if (localAddresses.isEmpty())
{
044             return null;
045         }
046         return localAddresses.iterator().next();
047     }
048  
049     @Override
050     public final Set<SocketAddress>
getLocalAddresses() {
051         Set<SocketAddress>
localAddresses = 
new HashSet<SocketAddress>();
052         synchronized (boundAddresses)
{
053             localAddresses.addAll(boundAddresses);
054         }
055         return localAddresses;
056     }
057  
058     @Override
059     public void bind(SocketAddress
localAddress) 
throws IOException
{
060         //
TODO Auto-generated method stub
061  
062     }
063  
064     @Override
065     public void bind(Iterable<? extends SocketAddress>
localAddresses)
066             throws IOException
{
067         //
TODO isDisposing()
068  
069         if (localAddresses
== 
null)
{
070             throw new IllegalArgumentException("localAddresses");
071         }
072  
073         List<SocketAddress>
localAddressesCopy = 
new ArrayList<SocketAddress>();
074  
075         for (SocketAddress
a : localAddresses) {
076             //
TODO check address type
077             localAddressesCopy.add(a);
078         }
079  
080         if (localAddressesCopy.isEmpty())
{
081             throw new IllegalArgumentException("localAddresses
is empty"
);
082         }
083  
084         boolean active
false;
085  
086         synchronized (bindLock)
{
087             synchronized (boundAddresses)
{
088                 if (boundAddresses.isEmpty())
{
089                     active
true;
090                 }
091             }
092         }
093         /**
implement in abstractIoService */
094         if (getHandler()
== 
null)
{
095             throw new IllegalArgumentException("handler
is not set"
);
096         }
097  
098         try {
099             Set<SocketAddress>
addresses = bindInternal(localAddressesCopy);
100  
101             synchronized (boundAddresses)
{
102                 boundAddresses.addAll(addresses);
103             }
104         catch (IOException
e) {
105             throw e;
106         catch (RuntimeException
e) {
107             throw e;
108         catch (Throwable
e) {
109             throw new RuntimeException("Filed
ti bind"
);
110         }
111          
112         if(active){
113             //do
sth
114         }
115     }
116  
117     protected abstract Set<SocketAddress>
bindInternal(
118             List<? extends SocketAddress>
localAddress) 
throws Exception;
119  
120     @Override
121     public void unbind(SocketAddress
localAddress) {
122         //
TODO Auto-generated method stub
123          
124     }
125 }

polling:

01 package org.apache.mina.core.rewrite.polling;
02  
03 import java.net.SocketAddress;
04 import java.nio.channels.ServerSocketChannel;
05 import java.util.List;
06 import java.util.Set;
07 import java.util.concurrent.Executor;
08 import java.util.concurrent.Semaphore;
09 import java.util.concurrent.atomic.AtomicReference;
10  
11 import org.apache.mina.core.rewrite.service.AbstractIoAcceptor;
12  
13 public abstract class AbstractPollingIoAcceptor extends AbstractIoAcceptor
{
14  
15     private final Semaphore
lock = 
new Semaphore(1);
16  
17     private volatile boolean selectable;
18  
19     private AtomicReference<Acceptor>
acceptorRef = 
new AtomicReference<Acceptor>();
20  
21     /**
22      *
define the num of sockets that can wait to be accepted.
23      */
24     protected int backlog
50;
25  
26     /**
27      *
一样的,这个构造方法也要写
28      *
29      *
@param param
30      *
@param executor
31      */
32     protected AbstractPollingIoAcceptor(Object
param, Executor executor) {
33         super(param,
executor);
34         //
TODO Auto-generated constructor stub
35     }
36  
37     /**
38      *
init the polling system. will be called at construction time
39      *
40      *
@throws Exception
41      */
42     protected abstract void init() throws Exception;
43  
44     protected abstract void destory() throws Exception;
45  
46     protected abstract int select() throws Exception;
47     /**这里有点儿变动*/
48     protected abstract ServerSocketChannel
open(SocketAddress localAddress) 
throws Exception;
49  
50     @Override
51     protected Set<SocketAddress>
bindInternal(
52             List<? extends SocketAddress>
localAddress) 
throws Exception
{
53         //
...
54         try {
55             lock.acquire();
56             Thread.sleep(10);
57         finally {
58             lock.release();
59         }
60         //
...
61         return null;
62     }
63  
64     /**
65      *
this class is called by startupAcceptor() method it's a thread accepting
66      *
incoming connections from client
67      *
68      *
@author ChenHui
69      *
70      */
71     private class Acceptor implements Runnable
{
72         @Override
73         public void run()
{
74             assert (acceptorRef.get()
== 
this);
75  
76             int nHandles
0;
77  
78             lock.release();
79  
80             while (selectable)
{
81                 try {
82                     int selected
= select();
83  
84                     //
nHandles+=registerHandles();
85  
86                     if (nHandles
== 
0)
{
87                         acceptorRef.set(null);
88                         //
...
89                     }
90                 catch (Exception
e) {
91  
92                 }
93             }
94         }
95     }
96 }

好了最后看NioSoeketAcceptor:

001 package org.apache.mina.rewrite.transport.socket.nio;
002  
003 import java.net.InetSocketAddress;
004 import java.net.ServerSocket;
005 import java.net.SocketAddress;
006 import java.nio.channels.SelectionKey;
007 import java.nio.channels.Selector;
008 import java.nio.channels.ServerSocketChannel;
009 import java.util.concurrent.Executor;
010  
011 import org.apache.mina.core.rewrite.polling.AbstractPollingIoAcceptor;
012 import org.apache.mina.rewrite.transport.socket.SocketAcceptor;
013  
014 public final class NioSocketAcceptor extends AbstractPollingIoAcceptor
015         implements SocketAcceptor
{
016  
017     private volatile Selector
selector;
018  
019     protected NioSocketAcceptor(Object
param, Executor executor) {
020         super(param,
executor);
021         //
TODO Auto-generated constructor stub
022     }
023  
024     @Override
025     public int getManagedSessionCount()
{
026         //
TODO Auto-generated method stub
027         return 0;
028     }
029  
030     /**
031      *
这个方法继承自AbstractIoAcceptor
032      *
033      *
The type NioSocketAcceptor must implement the inherited abstract method
034      *
SocketAcceptor.getLocalAddress() to override
035      *
AbstractIoAcceptor.getLocalAddress()
036      */
037     @Override
038     public InetSocketAddress
getLocalAddress() {
039         //
TODO Auto-generated method stub
040         return null;
041     }
042  
043     @Override
044     public void setDefaultLocalAddress(InetSocketAddress
localAddress) {
045         //
TODO Auto-generated method stub
046  
047     }
048  
049     @Override
050     public boolean isReuseAddress()
{
051         //
TODO Auto-generated method stub
052         return false;
053     }
054  
055     @Override
056     protected void init() throws Exception
{
057         selector
= Selector.open();
058     }
059  
060     @Override
061     protected void destory() throws Exception
{
062         if (selector
!= 
null)
{
063             selector.close();
064         }
065     }
066  
067     @Override
068     protected int select() throws Exception
{
069         return selector.select();
070     }
071  
072     @Override
073     protected void dispose0() throws Exception
{
074         //
TODO Auto-generated method stub
075  
076     }
077  
078     protected ServerSocketChannel
open(SocketAddress localAddress)
079             throws Exception
{
080         ServerSocketChannel
channel =ServerSocketChannel.open();
081          
082         boolean success=false;
083          
084         try{
085             channel.configureBlocking(false);
086              
087             ServerSocket
socket=channel.socket();
088              
089             socket.setReuseAddress(isReuseAddress());
090              
091             socket.bind(localAddress);
092              
093             channel.register(selector,
SelectionKey.OP_ACCEPT);
094              
095             success=true;
096         }finally{
097             if(!success){
098                 //close(channel);
099             }
100         }
101         return channel;
102     }
103  
104     @Override
105     public boolean isActive()
{
106         //
TODO Auto-generated method stub
107         return false;
108     }
109  
110 }

------------------------------------------------------

到此为止将连接部分都写完了,在连接部分还有些零碎的东西,比如handler、polling,这些都只是稍稍提了一下,具体后面会在介绍其他部分是肯定还会碰上,我还是想把重心放在最主要的部分去写,下一篇应该要写到session了。

Mina源码阅读笔记(四)—Mina的连接IoConnector2的更多相关文章

  1. Mina源码阅读笔记(一)-整体解读

    今天的这一节,将从整体上对mina的源代码进行把握,网上已经有好多关于mina源码的阅读笔记,但好多都是列举了一下每个接口或者类的方法.我倒是想从mina源码的结构和功能上对这个框架进行剖析.源码的阅 ...

  2. Mina源码阅读笔记(二)- IoBuffer的封装

    在阅读IoBuffer源码之前,我们先看Mina对IoBuffer的描述:A byte buffer used by MINA applications. This is a replacement ...

  3. Mina源码阅读笔记(七)—Mina的拦截器FilterChain

    Filter我们很熟悉,在Mina中,filter chain的用法也类似于Servlet的filters,这种拦截器的设计思想能够狠轻松的帮助我们实现对资源的统一处理.我们先大致连接下mina中的f ...

  4. Mina源码阅读笔记(四)—Mina的连接IoConnector1

    上一篇写的是IoAcceptor是服务器端的接收代码,今天要写的是IoConnector,是客户端的连接器.在昨天,我们还留下一些问题没有解决,这些问题今天同样会产生,但是都要等到讲到session的 ...

  5. Mina源码阅读笔记(三)-Mina的连接IoAccpetor

    其实在mina的源码中,IoService可以总结成五部分service责任.Processor线程处理.handler处理器.接收器和连接器,分别对应着IoService.IoProcessor.I ...

  6. Mina源码阅读笔记(六)—Mina异步IO的实现IoFuture

    IoFuture是和IoSession紧密相连的一个类,在官网上并没有对它的描述,因为它一般不会显示的拿出来用,权当是一个工具类被session所使用.当然在作用上,这个系列可并不简单,我们先看源码的 ...

  7. Mina源码阅读笔记(五)—Mina对连接的操作IoSession

    IoSession是Mina管理两端的一个重要部分,也是Mina的核心,Session具有了生命周期的概念,它的生命周期和连接时紧密相关的,这点在后面的介绍中会涉及.另外,好像hibernate中也有 ...

  8. Werkzeug源码阅读笔记(四)

    今天主要讲一下werkzeug中的routing模块.这个模块是werkzeug中的重点模块,Flask中的路由相关的操作使用的都是这个模块 routing模块的用法 在讲解模块的源码之前,先讲讲这个 ...

  9. 源码阅读笔记 - 1 MSVC2015中的std::sort

    大约寒假开始的时候我就已经把std::sort的源码阅读完毕并理解其中的做法了,到了寒假结尾,姑且把它写出来 这是我的第一篇源码阅读笔记,以后会发更多的,包括算法和库实现,源码会按照我自己的代码风格格 ...

随机推荐

  1. Hadoop:hadoop fs、hadoop dfs与hdfs dfs命令的区别

    http://blog.csdn.net/pipisorry/article/details/51340838 'Hadoop DFS'和'Hadoop FS'的区别 While exploring ...

  2. 06_NoSQL数据库之Redis数据库:Redis的高级应用之登录授权和主从复制

     Redis高级实用特征 安全性(登录授权和登录后使用auth授权) 设置客户端连接后进行任何其他指定前需要使用的密码. 警告:因为redis速度相当快,所以在一台比较好的服务器下,一个外部的用户 ...

  3. UNIX网络编程——套接字选项(setsockopt)

    setsockopt的一些用法: close socket(一般不会立即关闭而经历TIME_WAIT的过程)后想继续重用该socket: BOOL bReuseaddr=TRUE; setsockop ...

  4. CSS 控制table 滑动及调整列宽等问题总结

    一. 通过css控制table y方向上滚动 html中没有滚动条,可以根据overflow属性的scroll来对table显示不完全的内容进行滚动. 只是y方向上滚动,很简单,只要设置div的hei ...

  5. 【一天一道LeetCode】#98. Validate Binary Search Tree

    一天一道LeetCode 本系列文章已全部上传至我的github,地址:ZeeCoder's Github 欢迎大家关注我的新浪微博,我的新浪微博 欢迎转载,转载请注明出处 (一)题目 Given a ...

  6. 基于IMX515EVK+WINCE6.0---支持PB6.0通过USB下载镜像文件

    基于IMX515EVK+WINCE6.0---支持PB6.0通过USB下载镜像文件 在INAND还没有写入镜像文件之前,通过ATK工具烧录xldr.nb0和eboot.nbo到INAND中,见相关链接 ...

  7. Ubuntu安装JDK与环境变量配置

    Ubuntu安装JDK与环境变量配置 一.getconf LONG_BIT 查看系统位数,并下载相应的jdk.我的系统是32位的,所以下载的jdk是:jdk-8u77-linux-i586.gz.并且 ...

  8. Linux的mount命令简介

    在Linux系统中,如果要使用硬盘.光盘.软盘或MO盘等存储设备,必须先进行挂装(Mount).当存储设备挂装完成之后,就可以将其作为一个目录来进行访问了.挂装设备需要使用mount命令.执行这一命令 ...

  9. 小强的HTML5移动开发之路(8)——坦克大战游戏2

    来自:http://blog.csdn.net/cai_xingyun/article/details/48629015 在上一篇文章中我们已经画出了自己的坦克,并且可以控制自己的坦克移动,我们继续接 ...

  10. (二十)即时通信的聊天气泡的实现I

    Tip:通过xib和storyboard不可能将一个控件作为ImageView的子控件,只能通过代码的addSubview方法实现. 设置图片的细节:如果button比图片大(为了方便对齐),将图片设 ...