Title: 3.3 - Acceptor
NavPrev: ch3.2-io-service-details.html
NavPrevText: 3.2 - IoService Details
NavUp: ch3-service.html
NavUpText: Chapter 3 - Service
NavNext: ch3.4-connector.html
NavNextText: 3.4 - Connector
Notice:    Licensed to the Apache Software Foundation (ASF) under one
           or more contributor license agreements.  See the NOTICE file
           distributed with this work for additional information
           regarding copyright ownership.  The ASF licenses this file
           to you under the Apache License, Version 2.0 (the
           "License"); you may not use this file except in compliance
           with the License.  You may obtain a copy of the License at
           .
             http://www.apache.org/licenses/LICENSE-2.0
           .
           Unless required by applicable law or agreed to in writing,
           software distributed under the License is distributed on an
           "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
           KIND, either express or implied.  See the License for the
           specific language governing permissions and limitations
           under the License.

# 3.3 - Acceptor

In order to build a server, you need to select an implementation of the _IoAcceptor_ interface.

## IoAcceptor

Basically, this interface is named because of the _accept()_ method, responsible for the creation of new connection between a client and the server. The server accepts incoming connection request.

At some point, we could have named this interface 'Server'.

As we may deal with more than one kind of transport (TCP/UDP/...), we have more than one implementation for this interface. It would be very unlikely that you need to implement a new one.

We have many of those implementing classes

* __NioSocketAcceptor__ : the non-blocking Socket transport _IoAcceptor_
* __NioDatagramAcceptor__ : the non-blocking UDP transport _IoAcceptor_
* __AprSocketAcceptor__ : the blocking Socket transport _IoAcceptor_, based on APR
* __VmPipeSocketAcceptor__ : the in-VM _IoAcceptor_

Just pick the one that fit your need.

Here is the class diagram for the _IoAcceptor_ interfaces and classes :

![](../../../staticresources/images/mina/IoServiceAcceptor.png)

## Creation

You first have to select the type of _IoAcceptor_ you want to instanciate. This is a choice you will made early in the process, as it all boils down to which network protocol you will use. Let's see with an example how it works :

	:::java
    public TcpServer() throws IOException {
		// Create a TCP acceptor
        IoAcceptor acceptor = new NioSocketAcceptor();

		// Associate the acceptor to an IoHandler instance (your application)
        acceptor.setHandler(this);

		// Bind : this will start the server...
        acceptor.bind(new InetSocketAddress(PORT));

        System.out.println("Server started...");
    }

That's it ! You have created a TCP server. If you want to start an UDP server, simply replace the first line of code :

	:::java
	...
	// Create an UDP acceptor
	IoAcceptor acceptor = new NioDatagramAcceptor();
	...
	
## Disposal

The service can be stopped by calling the _dispose()_ method. The service will be stopped only when all the pending sessions have been processed :

	:::java
	// Stop the service, waiting for the pending sessions to be inactive
	acceptor.dispose();
	
You can also wait for every thread being executed to be properly completed by passing a boolean parameter to this method :

	:::java
	// Stop the service, waiting for the processing session to be properly completed
	acceptor.dispose( true );
	
## Status

You can get the _IoService_ status by calling one of the following methods :

* _isActive()_ : true if the service can accept incoming requests
* _isDisposing()_ : true if the _dispose()_ method has been called. It does not tell if the service is actually stopped (some sessions might be processed)
* _isDisposed()_ : true if the _dispose(boolean)_ method has been called, and the executing threads have been completed.

## Managing the IoHandler

You can add or get the associated _IoHandler_ when the service has been instanciated. Youjust have to call the _setHandler(IoHandler)_ or _getHandler()_ methods.

## Managing the Filters chain

if you want to manage the filters chain, you will have to call the _getFilterChain()_ method. Here is an example :

	:::java
	// Add a logger filter
	DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
	chain.addLast("logger", new LoggingFilter());

You can also create the chain before and set it into the service :

	:::java
	// Add a logger filter
	DefaultIoFilterChainBuilder chain = new DefaultIoFilterChainBuilder();
	chain.addLast("logger", new LoggingFilter());
	
	// And inject the created chain builder in the service
	acceptor.setFilterChainBuilder(chain);
	
##