Android 通过Socket 和服务器通讯-阿里云开发者社区

开发者社区> 一叶飘舟> 正文

Android 通过Socket 和服务器通讯

简介:
+关注继续查看

Android 通过Socket 和服务器通讯,是一种比较常用的通讯方式,时间比较紧,说下大致的思路,希望能帮到使用socket 进行通信的人

(1)开启一个线程发送消息    SocketOutputThread

      消息是放在队列里的,当有消息后,进入队列,线程唤醒,发送消息,并反馈发送是否成功的回调

(2)开启一个线程接受服务器消息 SocketInputThread

       为了防止一直收数据,浪费电池的电,采用NIO的方式读socket的数据,这个是本文的关键 

(3)开启一个线程,做心跳,防止socket连接终断 , SocketHeartThread

(4)构建 SocketThreadManager对以上三个thread进行管理

(5)构建 TCPClient 发送socket消息

     在NIO的方式实现TCP,特别是在接收服务器的数据,不用写个线程定时去读了。

 

DEMO 截图

 

主要代码如下,详细代码在附件里。

SocketOutPutThread 类

package com.example.socketblockdemo;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;


/**
 * 客户端写消息线程
 * 
 * @author way
 * 
 */
public class SocketOutputThread extends Thread
{
    private boolean isStart = true;
    private static String tag = "socketOutputThread";
    private List<MsgEntity> sendMsgList;
    
    public SocketOutputThread( )
    {

        sendMsgList = new CopyOnWriteArrayList<MsgEntity>();
    }
    
    public void setStart(boolean isStart)
    {
        this.isStart = isStart;
        synchronized (this)
        {
            notify();
        }
    }

    // 使用socket发送消息
    public boolean sendMsg(byte[] msg) throws Exception
    {
                
        
        if (msg == null)
        {
            CLog.e(tag, "sendMsg is null");
            return false;
        }
        
        try
        {
            TCPClient.instance().sendMsg(msg);
            
        } catch (Exception e)
        {
            throw (e);
        }
        
        return true;
    }
    
    // 使用socket发送消息
    public void addMsgToSendList(MsgEntity msg) 
    {

        synchronized (this)
        {
            this.sendMsgList.add(msg);
            notify();
        }
    }
    
    @Override
    public void run()
    {
        while (isStart)
        {
            // 锁发送list
            synchronized (sendMsgList)
            {
                // 发送消息
                for (MsgEntity msg : sendMsgList)
                {
                    
                    Handler handler = msg.getHandler();
                    try
                    {
                        sendMsg(msg.getBytes());
                        sendMsgList.remove(msg);
                        // 成功消息,通过hander回传
                        if (handler != null)
                        {
                            Message message =  new Message();
                            message.obj = msg.getBytes();
                            message.what =1;
                           handler.sendMessage(message);
                        //    handler.sendEmptyMessage(1);
                        }
                        
                    } catch (Exception e)
                    {
                        e.printStackTrace();
                        CLog.e(tag, e.toString());
                        // 错误消息,通过hander回传
                        if (handler != null)
                        {
                            Message message =  new Message();
                            message.obj = msg.getBytes();
                            message.what = 0;;
                            handler.sendMessage(message);
                        
                        }
                    }
                }
            }
            
            synchronized (this)
            {
                try
                {
                    wait();
                    
                } catch (InterruptedException e)
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }// 发送完消息后,线程进入等待状态
            }
        }
        
    }
}

SocketInputThread

package com.example.socketblockdemo;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.channels.CancelledKeyException;
import java.nio.channels.ClosedSelectorException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;


import android.content.Intent;
import android.text.TextUtils;

/**
 * 客户端读消息线程
 * 
 * @author way
 * 
 */
public class SocketInputThread extends Thread
{
    private boolean isStart = true;
    
    private static String tag = "socket";
    
    // private MessageListener messageListener;// 消息监听接口对象
    
    public SocketInputThread()
    {
    }
    
    public void setStart(boolean isStart)
    {
        this.isStart = isStart;
    }
    
    @Override
    public void run()
    {
        while (isStart)
        {
            // 手机能联网,读socket数据
            if (NetManager.instance().isNetworkConnected())
            {
                
                if (!TCPClient.instance().isConnect())
                {
                    CLog.e(tag, "TCPClient connet server is fail read thread sleep second" +Const.SOCKET_SLEEP_SECOND );
                    
                    try
                    {
                        sleep(Const.SOCKET_SLEEP_SECOND * 1000);
                    } catch (InterruptedException e)
                    {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                readSocket();
                
                // 如果连接服务器失败,服务器连接失败,sleep固定的时间,能联网,就不需要sleep
                
                CLog.e("socket","TCPClient.instance().isConnect() " + TCPClient.instance().isConnect() );
                
                
            }
        }
    }
    
    public void readSocket()
    {
        Selector selector = TCPClient.instance().getSelector();
        if (selector == null)
        {
            return;
        }
        try
        {
            // 如果没有数据过来,一直柱塞
            while (selector.select() > 0)
            {
                for (SelectionKey sk : selector.selectedKeys())
                {
                    // 如果该SelectionKey对应的Channel中有可读的数据
                    if (sk.isReadable())
                    {
                        // 使用NIO读取Channel中的数据
                        SocketChannel sc = (SocketChannel) sk.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        try
                        {
                            sc.read(buffer);
                        } catch (IOException e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                            // continue;
                        }
                        buffer.flip();
                        String receivedString = "";
                        // 打印收到的数据
                        try
                        {
                            receivedString = Charset.forName("UTF-8")
                                    .newDecoder().decode(buffer).toString();
                            
                            CLog.e(tag, receivedString);
                            

                            Intent i = new Intent(Const.BC);
                            
                            i.putExtra("response", receivedString);
                            
                            MainActivity.s_context.sendBroadcast(i );
                            
                        } catch (CharacterCodingException e)
                        {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                        buffer.clear();
                        buffer = null;
                        
                        try
                        {
                            // 为下一次读取作准备
                            sk.interestOps(SelectionKey.OP_READ);
                            // 删除正在处理的SelectionKey
                            selector.selectedKeys().remove(sk);
                            
                        } catch (CancelledKeyException e)
                        {
                            e.printStackTrace();
                        }
                        
                    
                    }
                }
            }
            // selector.close();
            // TCPClient.instance().repareRead();
            
        } catch (IOException e1)
        {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        } catch (ClosedSelectorException e2)
        {
        }
    }
    
}

SocketHeartHread 心跳类

package com.example.socketblockdemo;

import java.io.IOException;

import android.text.TextUtils;


class SocketHeartThread extends Thread
{
    boolean isStop = false;
    boolean mIsConnectSocketSuccess = false;
    static SocketHeartThread s_instance;
    
    private TCPClient mTcpClient = null;
    
    static final String tag = "SocketHeartThread";
    
    public static synchronized SocketHeartThread instance()
    {
        if (s_instance == null)
        {
            s_instance = new SocketHeartThread();
        }
        return s_instance;
    }
    
    public SocketHeartThread()
    {
       TCPClient.instance();
                // 连接服务器
    //    mIsConnectSocketSuccess = connect();

    }

    public void stopThread()
    {
        isStop = true;
    }
    
    /**
     * 连接socket到服务器, 并发送初始化的Socket信息
     * 
     * @return
     */
    
    
    private boolean reConnect()
    {
        return TCPClient.instance().reConnect();
    }

    
    public void run()
    {
        isStop = false;
        while (!isStop)
        {
                // 发送一个心跳包看服务器是否正常
                boolean canConnectToServer = TCPClient.instance().canConnectToServer();
                
                if(canConnectToServer == false){
                    reConnect();
                }
                try
                {
                    Thread.sleep(Const.SOCKET_HEART_SECOND * 1000);
                    
                } catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
            }
    }
}
线程管理类

package com.example.socketblockdemo;

import android.os.Handler;
import android.text.TextUtils;


public class SocketThreadManager
{
    
    private static SocketThreadManager s_SocketManager = null;
    
    private SocketInputThread mInputThread = null;
    
    private SocketOutputThread mOutThread = null;
    
    private SocketHeartThread mHeartThread = null;

    
    // 获取单例
    public static SocketThreadManager sharedInstance()
    {
        if (s_SocketManager == null)
        {
            s_SocketManager = new SocketThreadManager();
            s_SocketManager.startThreads();
        }
        return s_SocketManager;
    }
    
    // 单例,不允许在外部构建对象
    private SocketThreadManager()
    {
        mHeartThread = new SocketHeartThread();
        mInputThread = new SocketInputThread();
        mOutThread = new SocketOutputThread();
    }
    
    /**
     * 启动线程
     */
    
    private void startThreads()
    {
        mHeartThread.start();
        mInputThread.start();
        mInputThread.setStart(true);
        mOutThread.start();
        mInputThread.setStart(true);
        // mDnsthread.start();
    }
    
    /**
     * stop线程
     */
    public void stopThreads()
    {
        mHeartThread.stopThread();
        mInputThread.setStart(false);
        mOutThread.setStart(false);
    }
    
    public static void releaseInstance()
    {
        if (s_SocketManager != null)
        {
            s_SocketManager.stopThreads();
            s_SocketManager = null;
        }
    }
    
    public void sendMsg(byte [] buffer, Handler handler)
    {
        MsgEntity entity = new MsgEntity(buffer, handler);
        mOutThread.addMsgToSendList(entity);
    }
    
}

TCPClient ,采用NIO的方式构建

package com.example.socketblockdemo;

import java.io.IOException;
import java.net.ConnectException;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.net.SocketTimeoutException;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;


/**
 * NIO TCP 客户端
 * 
 */
public class TCPClient
{
    // 信道选择器
    private Selector selector;
    
    // 与服务器通信的信道
    SocketChannel socketChannel;
    
    // 要连接的服务器Ip地址
    private String hostIp;
    
    // 要连接的远程服务器在监听的端口
    private int hostListenningPort;
    
    private static TCPClient s_Tcp = null;
    
    public boolean isInitialized = false;
    
    public static synchronized TCPClient instance()
    {
        if (s_Tcp == null)
        {
            
            s_Tcp = new TCPClient(Const.SOCKET_SERVER,
                    Const.SOCKET_PORT);
        }
        return s_Tcp;
    }
    
    /**
     * 构造函数
     * 
     * @param HostIp
     * @param HostListenningPort
     * @throws IOException
     */
    public TCPClient(String HostIp, int HostListenningPort)
    {
        this.hostIp = HostIp;
        this.hostListenningPort = HostListenningPort;
        
        try
        {
            initialize();
            this.isInitialized = true;
        } catch (IOException e)
        {
            this.isInitialized = false;
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e)
        {
            this.isInitialized = false;
            e.printStackTrace();
        }
    }
    
    /**
     * 初始化
     * 
     * @throws IOException
     */
    public void initialize() throws IOException
    {
        boolean done = false;
        
        try
        {
            // 打开监听信道并设置为非阻塞模式
            socketChannel = SocketChannel.open(new InetSocketAddress(hostIp,
                    hostListenningPort));
            if (socketChannel != null)
            {
                socketChannel.socket().setTcpNoDelay(false);
                socketChannel.socket().setKeepAlive(true);
                // 设置 读socket的timeout时间
                socketChannel.socket().setSoTimeout(
                        Const.SOCKET_READ_TIMOUT);
                socketChannel.configureBlocking(false);
                
                // 打开并注册选择器到信道
                selector = Selector.open();
                if (selector != null)
                {
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    done = true;
                }
            }
        } finally
        {
            if (!done && selector != null)
            {
                selector.close();
            }
            if (!done)
            {
                socketChannel.close();
            }
        }
    }
    
    static void blockUntil(SelectionKey key, long timeout) throws IOException
    {
        
        int nkeys = 0;
        if (timeout > 0)
        {
            nkeys = key.selector().select(timeout);
            
        } else if (timeout == 0)
        {
            nkeys = key.selector().selectNow();
        }
        
        if (nkeys == 0)
        {
            throw new SocketTimeoutException();
        }
    }
    
    /**
     * 发送字符串到服务器
     * 
     * @param message
     * @throws IOException
     */
    public void sendMsg(String message) throws IOException
    {
        ByteBuffer writeBuffer = ByteBuffer.wrap(message.getBytes("utf-8"));
        
        if (socketChannel == null)
        {
            throw new IOException();
        }
        socketChannel.write(writeBuffer);
    }
    
    /**
     * 发送数据
     * 
     * @param bytes
     * @throws IOException
     */
    public void sendMsg(byte[] bytes) throws IOException
    {
        ByteBuffer writeBuffer = ByteBuffer.wrap(bytes);
        
        if (socketChannel == null)
        {
            throw new IOException();
        }
        socketChannel.write(writeBuffer);
    }
    
    /**
     * 
     * @return
     */
    public synchronized Selector getSelector()
    {
        return this.selector;
    }
    
    /**
     * Socket连接是否是正常的
     * 
     * @return
     */
    public boolean isConnect()
    {
        boolean isConnect = false;
        if (this.isInitialized)
        {
            isConnect =  this.socketChannel.isConnected();
        }
        return isConnect;
    }
    
    /**
     * 关闭socket 重新连接
     * 
     * @return
     */
    public boolean reConnect()
    {
        closeTCPSocket();
        
        try
        {
            initialize();
            isInitialized = true;
        } catch (IOException e)
        {
            isInitialized = false;
            e.printStackTrace();
        }
        catch (Exception e)
        {
            isInitialized = false;
            e.printStackTrace();
        }
        return isInitialized;
    }
    
    /**
     * 服务器是否关闭,通过发送一个socket信息
     * 
     * @return
     */
    public boolean canConnectToServer()
    {
        try
        {
            if (socketChannel != null)
            {
                socketChannel.socket().sendUrgentData(0xff);
            }
        } catch (IOException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return false;
        }
        catch (Exception e){
            e.printStackTrace();
            return false;
        }
        return true;
    }
    
    /**
     * 关闭socket
     */
    public void closeTCPSocket()
    {
        try
        {
            if (socketChannel != null)
            {
                socketChannel.close();
            }
            
        } catch (IOException e)
        {
            
        }
        try
        {
            if (selector != null)
            {
                selector.close();
            }
        } catch (IOException e)
        {
        }
    }
    
    /**
     * 每次读完数据后,需要重新注册selector,读取数据
     */
    public synchronized void repareRead()
    {
        if (socketChannel != null)
        {
            try
            {
                selector = Selector.open();
                socketChannel.register(selector, SelectionKey.OP_READ);
            } catch (ClosedChannelException e)
            {
                e.printStackTrace();
                
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
    }
}

如何使用

// 发送消息,失败或者成功的handler
            SocketThreadManager.sharedInstance().sendMsg(str.getBytes(), handler);

代码下载 http://files.cnblogs.com/likwo/SocketBlockDemo.zip

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
Java Socket服务端客户端通信实例
本文目录 1. Socket是啥 2. 运行机制 3. 代码示例 4. 测试 5. 小结
6 0
Android Studio 通过一个登录功能介绍SQLite数据库的使用
前言:         SQLite简介:是一款轻型的数据库,是遵守ACID的关系型数据库管理系统,它包含在一个相对小的C库中。它是D.RichardHipp建立的公有领域项目。它的设计目标是嵌入式的,而且目前已经在很多嵌入式产品中使用了它,它占用资源非常的低,在嵌入式设备中,可能只需要几百K的内存就够了。
4151 0
通过Android逆向之签名算法分析看apk安全防护
android安全问题日益验证,作为一名移动安全渗透人员,有时需要对移动apk进行全面的渗透测试,而不能仅仅局限于apk本身,此时往往就需要结合静态分析和动态分析进行。
1575 0
WebSocket的C++服务器端实现
由于需要在项目中增加Websocket协议,与客户端进行通信,不想使用开源的库,比如WebSocketPP,就自己根据WebSocket协议实现一套函数,完全使用C++实现。 代码已经实现,放在个人github上面,地址:https://github.com/jice1001/websocket.git。
1598 0
Android socket服务器通信
下面是一个demo,Android客户端通过socket与服务器通信。  由于Android里面可以完全使用java.io.*包和java.net.*包,那么,实际上,逻辑部分与J2SE没有区别。
546 0
在IIS上搭建WebSocket服务器(三)
原文:在IIS上搭建WebSocket服务器(三) 编写客户端代码 1.新建一个*.html文件。 ws = new WebSocket('ws://192.168.85.128:8086/Handler1.
1493 0
Android客户端与服务器端的json数据交互(很详细)
分类: Android学习2014-03-17 21:20 1426人阅读 评论(0) 收藏 举报  Android客户端与服务器端的json数据交互,主要是通过json形式的数据交互,就是json的写入和解析。
691 0
+关注
1635
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载