使用mina实现Android长连接

一.概述
android长连接的实现有很多种,最常用的是使用第三方的长连接,比如推送服务的实现.使用第三方的长连接虽然在实现上最简单,但是扩展性缺少最差,要受限于三方的api,所以在这里介绍使用mina来实现android的长连接服务.

二.服务端的实现
首先来说说服务端的实现,这里只是举个简单的实例,目的只是告诉大家如何实现.

• 导入需要的jar包
  

• 具体的代码实现

import java.net.InetSocketAddress;
import java.util.Date;

import org.apache.mina.core.service.IoAcceptor;
import org.apache.mina.core.service.IoHandlerAdapter;
import org.apache.mina.core.session.IdleStatus;
import org.apache.mina.core.session.IoSession;
import org.apache.mina.filter.codec.ProtocolCodecFilter;
import org.apache.mina.filter.codec.serialization.ObjectSerializationCodecFactory;
import org.apache.mina.filter.logging.LoggingFilter;
import org.apache.mina.transport.socket.nio.NioSocketAcceptor;

/**
 * mina服务端
 */
public class MainService {

    public static void main(String[] args) {
        IoAcceptor acceptor = new NioSocketAcceptor();
        //添加日志过滤
        acceptor.getFilterChain().addLast("logger", new LoggingFilter());
        acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
        //设置回调监听
        acceptor.setHandler(new DemoServerHandler());
        //设置读取大小
        acceptor.getSessionConfig().setReadBufferSize(2048);
        //设置超时时间
        acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);

        try {
            //开启监听
            acceptor.bind(new InetSocketAddress(9123));

        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }
    }

    private static class  DemoServerHandler extends  IoHandlerAdapter{

        @Override
        public void sessionCreated(IoSession session) throws Exception {
            // TODO Auto-generated method stub
            super.sessionCreated(session);


        }

        /**
         * 一个客户端连接时回调的方法
         * @param session
         * @throws Exception
         */
        @Override
        public void sessionOpened(IoSession session) throws Exception {
            // TODO Auto-generated method stub
            super.sessionOpened(session);

        }

        /**
         * 接收到消息时回调的方法
         * @param session
         * @param message
         * @throws Exception
         */
        @Override
        public void messageReceived(IoSession session, Object message)
                throws Exception {
            // TODO Auto-generated method stub
            super.messageReceived(session, message);
            //接收客户端的消息
            String msg = message.toString();
            Date date = new Date();
            //发送消息给客户端
            session.write(msg+date.toString());
        }

        /**
         * 发送消息时回调的方法
         * @param session
         * @param message
         * @throws Exception
         */
        @Override
        public void messageSent(IoSession session, Object message)
                throws Exception {
            // TODO Auto-generated method stub
            super.messageSent(session, message);
        }

        /**
         * 一个客户端断开时回调的方法
         * @param session
         * @throws Exception
         */
        @Override
        public void sessionClosed(IoSession session) throws Exception {
            // TODO Auto-generated method stub
            super.sessionClosed(session);

        }

    }

}

服务端代码非常简单,只是简单的开启,然后接收客户端的信息,在将进行回传给客户端.

三.Android客户端的实现
Android客户端的实现流程就是一个用户界面,用来开启服务,发送消息和显示消息->一个服务,用来完成长连接->一个长连接的管理类,用来完成长连接具体实现->一个配置文件类,用来配置长连接实现需要的参数.

• 用户界面的具体代码

public class MainActivity extends AppCompatActivity {
    private TextView tv;
    private Button btn,btn2;
    private MyBroadcaseRedceiver mBroadcaseRedceiver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) findViewById(R.id.tv);
        btn = (Button) findViewById(R.id.btn);
        btn2 = (Button) findViewById(R.id.btn2);

        //注册广播 用来接收服务器返回的信息
        IntentFilter filter = new IntentFilter(ConnectManager.BROADCAST_ACTION);
        mBroadcaseRedceiver = new MyBroadcaseRedceiver();
        registerReceiver(mBroadcaseRedceiver, filter);
        //设置按钮的点击事件
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                SessionManager.getmInstance().writeToServer("发给服务器的消息 ");
            }
        });
        btn2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                //开启服务
                Intent intent = new Intent(MainActivity.this, ConnectService.class);
                startService(intent);
            }
        });
    }





    public class MyBroadcaseRedceiver extends BroadcastReceiver{

        @Override
        public void onReceive(Context context, Intent intent) {
            //更新界面
            tv.setText(intent.getStringExtra(ConnectManager.MESSAGE));
        }
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(mBroadcaseRedceiver);
    }
}

界面的效果图如下:

• 服务的具体代码

/**
 * 开启长连接的服务
 * Created by lyf on 2017/5/20.
 */

public class ConnectService extends Service {
    private ConnectThred connectThred;

    @Nullable
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        super.onCreate();
        //使用子线程开启连接
        connectThred = new ConnectThred("mina",getApplicationContext());
        connectThred.start();
    }



    @Override
    public void onDestroy() {
        super.onDestroy();
        connectThred.disConnection();
        connectThred=null;
    }

    /**
     * 负责调用connectmanager类来完成与服务器的连接
     */
    class ConnectThred extends HandlerThread {

        boolean isConnection;
        ConnectManager mManager;
        public ConnectThred(String name,Context context) {
            super(name);
            //创建配置文件类
            ConnectConfig config = new ConnectConfig.Builder(context)
                    .setIp("192.168.0.113")
                    .setPort(9123)
                    .setReadBufferSize(10240)
                    .setConnectionTimeout(10000)
                    .bulid();
            //创建连接的管理类
            mManager = new ConnectManager(config);
        }

        @Override
        protected void onLooperPrepared() {
            //利用循环请求连接
            while (true) {
                isConnection = mManager.connect();
                if (isConnection) {
                    //当请求成功的时候,跳出循环
                    break;
                }
                try {
                    Thread.sleep(3000);
                } catch (Exception e) {

                }
            }
        }

        /**
         *断开连接
         */
        public void disConnection(){
            mManager.disConnect();
        }

    }

因为长连接一般都是在后台运行的,所以推荐用服务开启,为了保证长连接的开启,我们在这里利用子线程开启死循环请求连接,直到成功为止.

• 长连接实现的管理类的代码

/**
 * 连接的管理类
 * Created by lyf on 2017/5/20.
 */

public class ConnectManager {
    public static final String BROADCAST_ACTION="com.example.lyf.longconnect";
    public static final String MESSAGE="message";

    private ConnectConfig mConfig;//配置文件
    private WeakReference<Context> mContext;
    private NioSocketConnector mConnection;
    private IoSession mSessioin;
    private InetSocketAddress mAddress;

    public ConnectManager(ConnectConfig mConfig) {
        this.mConfig = mConfig;
        this.mContext = new WeakReference<Context>(mConfig.getmContext());
        init();
    }

    private void init() {
        mAddress = new InetSocketAddress(mConfig.getIp(),mConfig.getPort());
        //创建连接对象
        mConnection = new NioSocketConnector();
        //设置连接地址
        mConnection.setDefaultRemoteAddress(mAddress);
        mConnection.getSessionConfig().setReadBufferSize(mConfig.getReadBufferSize());
        //设置过滤
        mConnection.getFilterChain().addLast("logger",new LoggingFilter());
        mConnection.getFilterChain().addLast("codec",new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
        //设置连接监听
        mConnection.setHandler(new DefaultHandler(mContext.get()));
    }

    private static class DefaultHandler extends IoHandlerAdapter{
        private Context context;

        public DefaultHandler(Context context) {
            this.context = context;
        }

        /**
         * 连接成功时回调的方法
         * @param session
         * @throws Exception
         */
        @Override
        public void sessionOpened(IoSession session) throws Exception {
            //当与服务器连接成功时,将我们的session保存到我们的sesscionmanager类中,从而可以发送消息到服务器
            SessionManager.getmInstance().setIoSession(session);
        }

        /**
         * 接收到消息时回调的方法
         * @param session
         * @param message
         * @throws Exception
         */
        @Override
        public void messageReceived(IoSession session, Object message) throws Exception {

            if (context != null) {
                //将接收到的消息利用广播发送出去
                Intent intent = new Intent(BROADCAST_ACTION);
                intent.putExtra(MESSAGE,message.toString());
                context.sendBroadcast(intent);
            }
        }
    }

    /**
     * 与服务器连接的方法
     * @return
     */
    public boolean connect(){
       try{
           ConnectFuture future =mConnection.connect();
           future.awaitUninterruptibly();
           mSessioin = future.getSession();
       }catch (Exception e){
           e.printStackTrace();
            return false;
       }
        return mSessioin==null?false:true;
    }

    /**
     * 断开连接的方法
     */
    public void disConnect(){
        mConnection.dispose();
        mConnection=null;
        mSessioin=null;
        mAddress=null;
        mContext=null;
    }

这个管理类就是利用mina框架的api来实现的与服务器连接的方法.具体的分析看注释.

• 配置文件类

/**
 * 连接的配置文件
 * Created by lyf on 2017/5/20.
 */

public class ConnectConfig {
    private Context mContext;
    private String ip;
    private int port;
    private int readBufferSize; //缓存大小
    private long connectionTimeout;//连接超时时间

    public Context getmContext() {
        return mContext;
    }



    public String getIp() {
        return ip;
    }



    public int getPort() {
        return port;
    }


    public int getReadBufferSize() {
        return readBufferSize;
    }



    public long getConnectionTimeout() {
        return connectionTimeout;
    }



    public static class Builder{
        private Context mContext;
        private String ip="";
        private int port=9123;
        private int readBufferSize=10240; //缓存大小
        private long connectionTimeout=10000;//连接超时时间


        public Builder(Context mContext) {
            this.mContext = mContext;
        }

        public Builder setConnectionTimeout(long connectionTimeout) {
            this.connectionTimeout = connectionTimeout;
            return this;
        }

        public Builder setIp(String ip) {
            this.ip = ip;
            return this;
        }

        public Builder setmContext(Context mContext) {
            this.mContext = mContext;
            return this;
        }

        public Builder setPort(int port) {
            this.port = port;
            return this;
        }

        public Builder setReadBufferSize(int readBufferSize) {
            this.readBufferSize = readBufferSize;
            return this;
        }

        public ConnectConfig bulid(){
            ConnectConfig connectConfig = new ConnectConfig();
            connectConfig.connectionTimeout = this.connectionTimeout;
            connectConfig.ip = this.ip;
            connectConfig.port = this.port;
            connectConfig.mContext = this.mContext;
            connectConfig.readBufferSize = this.readBufferSize;
            return  connectConfig;
        }
    }
}

这里就是利用Builder模型来方便创建配置文件对象,就是配置一些实现长连接需要的参数.

• 与服务器通信的单例

/**
 * session管理类,通过ioSession与服务器通信
 * Created by lyf on 2017/5/21.
 */

public class SessionManager {
    private static  SessionManager mInstance = null;

    private IoSession ioSession;//最终与服务器 通信的对象

    public static SessionManager getmInstance(){
        if (mInstance == null) {
            synchronized (SessionManager.class) {
                if (mInstance == null) {
                    mInstance = new SessionManager();
                }
            }
        }
        return mInstance;
    }
    private SessionManager(){

    }

    public void setIoSession(IoSession ioSession) {
        this.ioSession = ioSession;
    }

    /**
     * 将对象写到服务器
     */
    public void writeToServer(Object msg) {
        if (ioSession != null) {
            ioSession.write(msg);
        }
    }

    /**
     * 关闭连接
     */
    public void closeSession() {
        if (ioSession != null) {
            ioSession.closeOnFlush();
        }
    }

    public void removeSession() {
        ioSession = null;
    }


}

通过这个单例的writeToServer方法就可以将信息发送到服务器了.

四.总结
以上就是通过mina框架实现的一套简单长连接,通过mina框架来实现长连接虽然比第三方的复杂,好处就是便于扩展,想要什么功能都可以实现.本文的代码我都放到了github