mina mysql_Mina源码阅读笔记（四）

接着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; 0

接着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 AbstractIoAcceptorextends AbstractIoServiceimplements

013

IoAcceptor

{

014

015

private final ListdefaultLocalAddresses =new ArrayList();

016

017

private final ListunmodifiableDeffaultLocalAddresses = Collections

018

.unmodifiableList(defaultLocalAddresses);

019

020

private final SetboundAddresses =new HashSet();

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

SetlocalAddresses = getLocalAddresses();

043

if (localAddresses.isEmpty())

{

044

return null;

045

}

046

return localAddresses.iterator().next();

047

}

048

049

@Override

050

public final SetgetLocalAddresses() {

051

SetlocalAddresses =new HashSet();

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(Iterableextends SocketAddress>

localAddresses)

066

throws IOException

{

067

TODO isDisposing()

068

069

if (localAddresses

==null)

{

070

throw new IllegalArgumentException("localAddresses");

071

}

072

073

ListlocalAddressesCopy =new ArrayList();

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

Setaddresses = 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 SetbindInternal(

118

Listextends SocketAddress>

localAddress)throws Exception;

119

120

@Override

121

public void unbind(SocketAddress

localAddress) {

122

TODO Auto-generated method stub

123

124

}

125

}

polling:

package org.apache.mina.core.rewrite.polling;

import java.net.SocketAddress;

import java.nio.channels.ServerSocketChannel;

import java.util.List;

import java.util.Set;

import java.util.concurrent.Executor;

import java.util.concurrent.Semaphore;

import java.util.concurrent.atomic.AtomicReference;

import org.apache.mina.core.rewrite.service.AbstractIoAcceptor;

public abstract class AbstractPollingIoAcceptorextends AbstractIoAcceptor

{

private final Semaphore

lock =new Semaphore(1);

private volatile boolean selectable;

private AtomicReferenceacceptorRef =new AtomicReference();

/**

define the num of sockets that can wait to be accepted.

protected int backlog

=50;

/**

一样的，这个构造方法也要写

@param param

@param executor

protected AbstractPollingIoAcceptor(Object

param, Executor executor) {

super(param,

executor);

TODO Auto-generated constructor stub

}

/**

init the polling system. will be called at construction time

@throws Exception

protected abstract void init()throws Exception;

protected abstract void destory()throws Exception;

protected abstract int select()throws Exception;

/**这里有点儿变动*/

protected abstract ServerSocketChannel

open(SocketAddress localAddress)throws Exception;

@Override

protected SetbindInternal(

Listextends SocketAddress>

localAddress)throws Exception

{

...

try {

lock.acquire();

Thread.sleep(10);

}finally {

lock.release();

}

...

return null;

}

/**

this class is called by startupAcceptor() method it's a thread accepting

incoming connections from client

@author ChenHui

private class Acceptorimplements Runnable

{

@Override

public void run()

{

assert (acceptorRef.get()

==this);

int nHandles

=0;

lock.release();

while (selectable)

{

try {

int selected

= select();

nHandles+=registerHandles();

if (nHandles

==0)

{

acceptorRef.set(null);

...

}

}catch (Exception

e) {

}

好了最后看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 NioSocketAcceptorextends 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、pollingsession了。

本文原创发布php中文网，转载请注明出处，感谢您的尊重！

mina mysql_Mina源码阅读笔记（四）—Mina的连接IoConnector2相关推荐

Werkzeug源码阅读笔记(四)
今天主要讲一下werkzeug中的routing模块.这个模块是werkzeug中的重点模块,Flask中的路由相关的操作使用的都是这个模块 routing模块的用法在讲解模块的源码之前,先讲讲这个 ...
代码分析：NASM源码阅读笔记
NASM源码阅读笔记 NASM(Netwide Assembler)的使用文档和代码间的注释相当齐全,这给阅读源码提供了很大的方便.按作者的说法,这是一个模块化的,可重用的x86汇编器, 而且能够被 ...
【Flink】Flink 源码阅读笔记（15）- Flink SQL 整体执行框架
1.概述转载:Flink 源码阅读笔记(15)- Flink SQL 整体执行框架在数据处理领域,无论是实时数据处理还是离线数据处理,使用 SQL 简化开发将会是未来的整体发展趋势.尽管 SQL ...
HashMap源码阅读笔记
HashMap是Java编程中常用的集合框架之一. 利用idea得到的类的继承关系图可以发现,HashMap继承了抽象类AbstractMap,并实现了Map接口(对于Serializable和Clo ...
Live555源码阅读笔记（一）：源码介绍文档及源码目录结构
目录一.Live555介绍 1.Live555项目介绍 2.官网及帮助文档介绍二.源码目录结构 1.UsageEnvironment 2.BasicUsageEnvironment 3.group ...
LinkedList源码阅读笔记
LinkedList源码阅读笔记初始化无参的 public LinkedList() {} 初始化的同时添加一个Collection public LinkedList(Collection< ...
syzkaller 源码阅读笔记1（syz-extract syz-sysgen）
文章目录 1. syz-extract 1-0 总结 1-1. `main()` 1-2 `archList()` - `1-1 (3)` 获取架构 name list 1-3 `createArch ...
Transformers包tokenizer.encode()方法源码阅读笔记
Transformers包tokenizer.encode()方法源码阅读笔记_天才小呵呵的博客-CSDN博客_tokenizer.encode
源码阅读笔记 BiLSTM+CRF做NER任务流程图
源码阅读笔记 BiLSTM+CRF做NER任务(二) 源码地址:https://github.com/ZhixiuYe/NER-pytorch 本篇正式进入源码的阅读,按照流程顺序,一一解剖. 一.流 ...
CI框架源码阅读笔记4 引导文件CodeIgniter.php
到了这里,终于进入CI框架的核心了.既然是"引导"文件,那么就是对用户的请求.参数等做相应的导向,让用户请求和数据流按照正确的线路各就各位.例如,用户的请求url: http:// ...

mina mysql_Mina源码阅读笔记（四）—Mina的连接IoConnector2

mina mysql_Mina源码阅读笔记（四）—Mina的连接IoConnector2相关推荐

最新文章

热门文章