Mina源码阅读笔记（四）—Mina的连接IoConnector2-mysql教程-PHP中文网

首页

数据库

mysql教程

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

WBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWBOYWB

Jun 07, 2016 pm 03:15 PM

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 AbstractIoAcceptor extends AbstractIoService implements

013 IoAcceptor {

014

015 private final List<socketaddress> defaultLocalAddresses = </socketaddress>new ArrayList<socketaddress>();</socketaddress>

016

017 private final List<socketaddress> unmodifiableDeffaultLocalAddresses = Collections</socketaddress>

018 .unmodifiableList(defaultLocalAddresses);

019

020 private final Set<socketaddress> boundAddresses = </socketaddress>new HashSet<socketaddress>();</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();</socketaddress>

043 if (localAddresses.isEmpty()) {

044 return null;

045 }

046 return localAddresses.iterator().next();

047 }

048

049 @Override

050 public final Set<socketaddress> getLocalAddresses() {</socketaddress>

051 Set<socketaddress> localAddresses = </socketaddress>new HashSet<socketaddress>();</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 = </socketaddress>new ArrayList<socketaddress>();</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);</socketaddress>

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(</socketaddress>

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 = </acceptor>new` `AtomicReference<acceptor>();</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(</socketaddress>`

`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、pollingsession了。

声明

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn

MySQL：初学者的基本技能Apr 18, 2025 am 12:24 AM

MySQL适合初学者学习数据库技能。1.安装MySQL服务器和客户端工具。2.理解基本SQL查询，如SELECT。3.掌握数据操作：创建表、插入、更新、删除数据。4.学习高级技巧：子查询和窗口函数。5.调试和优化：检查语法、使用索引、避免SELECT*，并使用LIMIT。

MySQL：结构化数据和关系数据库Apr 18, 2025 am 12:22 AM

MySQL通过表结构和SQL查询高效管理结构化数据，并通过外键实现表间关系。1.创建表时定义数据格式和类型。2.使用外键建立表间关系。3.通过索引和查询优化提高性能。4.定期备份和监控数据库确保数据安全和性能优化。

MySQL：解释的关键功能和功能Apr 18, 2025 am 12:17 AM

MySQL是一个开源的关系型数据库管理系统，广泛应用于Web开发。它的关键特性包括：1.支持多种存储引擎，如InnoDB和MyISAM，适用于不同场景；2.提供主从复制功能，利于负载均衡和数据备份；3.通过查询优化和索引使用提高查询效率。

SQL的目的：与MySQL数据库进行交互Apr 18, 2025 am 12:12 AM

SQL用于与MySQL数据库交互，实现数据的增、删、改、查及数据库设计。1）SQL通过SELECT、INSERT、UPDATE、DELETE语句进行数据操作；2）使用CREATE、ALTER、DROP语句进行数据库设计和管理；3）复杂查询和数据分析通过SQL实现，提升业务决策效率。

初学者的MySQL：开始数据库管理Apr 18, 2025 am 12:10 AM

MySQL的基本操作包括创建数据库、表格，及使用SQL进行数据的CRUD操作。1.创建数据库：CREATEDATABASEmy_first_db;2.创建表格：CREATETABLEbooks(idINTAUTO_INCREMENTPRIMARYKEY,titleVARCHAR(100)NOTNULL,authorVARCHAR(100)NOTNULL,published_yearINT);3.插入数据：INSERTINTObooks(title,author,published_year)VA

MySQL的角色：Web应用程序中的数据库Apr 17, 2025 am 12:23 AM

MySQL在Web应用中的主要作用是存储和管理数据。1.MySQL高效处理用户信息、产品目录和交易记录等数据。2.通过SQL查询，开发者能从数据库提取信息生成动态内容。3.MySQL基于客户端-服务器模型工作，确保查询速度可接受。

mysql：构建您的第一个数据库Apr 17, 2025 am 12:22 AM

构建MySQL数据库的步骤包括：1.创建数据库和表，2.插入数据，3.进行查询。首先，使用CREATEDATABASE和CREATETABLE语句创建数据库和表，然后用INSERTINTO语句插入数据，最后用SELECT语句查询数据。

MySQL：一种对数据存储的初学者友好方法Apr 17, 2025 am 12:21 AM

MySQL适合初学者，因为它易用且功能强大。1.MySQL是关系型数据库，使用SQL进行CRUD操作。2.安装简单，需配置root用户密码。3.使用INSERT、UPDATE、DELETE、SELECT进行数据操作。4.复杂查询可使用ORDERBY、WHERE和JOIN。5.调试需检查语法，使用EXPLAIN分析查询。6.优化建议包括使用索引、选择合适数据类型和良好编程习惯。

See all articles