实际项目汇中的socket通讯

演示过程

首先开启服务器

打开一个SDK大于4.4的手机－－－B

打开一个SDK小于4.4的手机－－－A

相互发送一条消息，对方就可以收到，当然这些消息都是通过服务器【转发】过来的

MainActivity

/**

 *  Activity启动以后就开启服务，服务开启后就通过ConnectorManager调用Connector中的connect方法对客户端进行认证

 *  认证是通过三次握手完成的，服务器为所有认证的客户端新建一个线程，通过此线程和客户端通讯

 *  当点击发送按钮后，通过ConnectorManager调用Connector中的方法把消息发送到一个阻塞队列中，最终发给服务器

 *  服务器收到消息后将其【转发】给指定客户端的Connector的阻塞队列中，客户端又通过listener.pushData(text)转发消息

 *  由于ConnectorManager注册了Connector的回调，ConnectorService又注册了ConnectorManager的回调

 *  所以最终调用的是ConnectorService的回调方法pushData(data) ，而此方法又通过发送一条广播将消息转发出去

 *  此广播会被PushReceiver接收到，因为其是在MainActivity注册的，所以最终MainActivity也收到了服务器转发过来的消息

 */

public class MainActivity extends Activity implements OnClickListener {

    private EditText et;

    private Button send;

    private PushReceiver receiver = new PushReceiver();

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        et = (EditText) findViewById(R.id.et);

        send = (Button) findViewById(R.id.send);

        send.setOnClickListener(this);

        //Activity启动以后就开启服务

        startService(new Intent(this, ConnectorService.class));

        //在代码中动态注册广播，这种类型的广播不是常驻型广播，也就是说广播跟随程序的生命周期

        IntentFilter filter = new IntentFilter();

        filter.addAction(PushReceiver.ACTION_TEXT);

        registerReceiver(receiver, filter);

    }

    @Override

    protected void onDestroy() {

        super.onDestroy();

        unregisterReceiver(receiver);

    }

    @Override

    public void onClick(View v) {

        switch (v.getId()) {

        case R.id.send:

            sendMessage();

            break;

        default:

            break;

        }

    }

    public void sendMessage() {

        final String content = et.getText().toString().trim();

        if (TextUtils.isEmpty(content)) return;

        String sender = null;

        String token = null;

        String receiver = null;

        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) {

            sender = "B";

            receiver = "A";

            token = "B";

        } else {

            sender = "A";

            token = "A";

            receiver = "B";

        }

        Request request = new TextRequest(sender, token, receiver, content);

        ConnectorManager.getInstance().putRequest(request);

    }

}

PushReceiver

public class PushReceiver extends BroadcastReceiver {

    /**发送文本信息的事件*/

    public static final String ACTION_TEXT = "com.bqt.action.text";

    public static final String DATA_KEY = "data";

    @Override

    public void onReceive(Context context, Intent intent) {

        String action = intent.getAction();

        Log.d("activity", "receive");

        if (PushReceiver.ACTION_TEXT.equals(action)) {

            String text = intent.getStringExtra(PushReceiver.DATA_KEY);

            Toast.makeText(context, text, Toast.LENGTH_SHORT).show();

        }

    }

}

Connector 

/**用一个类把与Socket相关的连接、发送消息、断开连接等方法抽离出来，并通过回调方式把结果返回*/

public class Connector {

    public static final String DST_NAME = "192.168.31.165";

    public static final int DST_PORT = 10002;

    private Socket client;

    //有界阻塞队列，当容量满时往BlockingQueue中添加数据时会阻塞，当容量为空时取元素操作会阻塞。

    private ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<String>(8);

    private ConnectorListener listener;

    /**连接*/

    public void connect() {

        try {

            // 三次握手

            if (client == null || client.isClosed()) client = new Socket(DST_NAME, DST_PORT);

            new Thread(new Runnable() {

                @Override

                public void run() {

                    // 数据通讯

                    OutputStream os;

                    try {

                        os = client.getOutputStream();

                        // os.write(content.getBytes());

                        while (true) {

                            String content = queue.take();

                            os.write(content.getBytes());

                        }

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                }

            }).start();

            new Thread(new Runnable() {

                @Override

                public void run() {

                    try {

                        InputStream is = client.getInputStream();

                        byte[] buffer = new byte[1024];

                        int len = -1;

                        while ((len = is.read(buffer)) != -1) {

                            final String text = new String(buffer, 0, len);

                            System.out.println("服务器转发的消息 : " + text);

                            //获取服务器向客户端转发的消息

                            if (listener != null) listener.pushData(text);

                        }

                    } catch (Exception e) {

                        e.printStackTrace();

                    }

                }

            }).start();

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

    /**认证*/

    public void auth(String auth) {

        putRequest(auth);

    }

    /**发送消息*/

    public void putRequest(String content) {

        try {

            queue.put(content);

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

    /**断开连接*/

    public void disconnect() {

        try {

            if (client != null && !client.isClosed()) {

                client.close();

                client = null;

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

    public void setConnectorListener(ConnectorListener listener) {

        this.listener = listener;

    }

}

ConnectorListener

public interface ConnectorListener {

    void pushData(String data);

}

ConnectorManager

/**管理Connector的方法，目的：隐藏实现细节，简化对外暴露的方法*/

public class ConnectorManager implements ConnectorListener {

    private static ConnectorManager instance;

    private Connector connector;

    private ConnectorListener listener;

    private ConnectorManager() {

    }

    public static ConnectorManager getInstance() {

        if (instance == null) {

            synchronized (ConnectorManager.class) {

                if (instance == null) instance = new ConnectorManager();

            }

        }

        return instance;

    }

    /**连接、注册监听、认证*/

    public void connnect(AuthRequest auth) {

        connector = new Connector();

        connector.setConnectorListener(this);

        connector.connect();

        connector.auth(auth.getData());

    }

    /**发送消息*/

    public void putRequest(Request request) {

        connector.putRequest(request.getData());

    }

    @Override

    public void pushData(String data) {

        if (listener != null) listener.pushData(data);

    }

    public void setConnectorListener(ConnectorListener listener) {

        this.listener = listener;

    }

}

ConnectorService

/**

 * 作用①：Activity启动以后就开启服务通过ConnectorManager调用Connector中的connect方法对客户端进行认证

 * 作用②：客户端收到服务器转发过来的消息后通过ConnectorService的pushData通过发送一条广播将消息转发出去

 * 注意：为简化代码，若客户端（手机）SDK版本小于4.4则定义为A手机，否则就定义为B手机，请演示时一定注意！

 */

public class ConnectorService extends Service implements ConnectorListener {

    private ConnectorManager connectorManager;

    @Override

    public IBinder onBind(Intent intent) {

        return null;

    }

    @Override

    public void onCreate() {

        super.onCreate();

        connectorManager = ConnectorManager.getInstance();

        new Thread(new Runnable() {

            @Override

            public void run() {

                connectorManager.setConnectorListener(ConnectorService.this);

                //认证

                AuthRequest request = null;

                //当前SDK版本大于4.4－－－暂时这么区分两部手机，实际肯定不是这么搞得

                if (Build.VERSION.SDK_INT > Build.VERSION_CODES.KITKAT) request = new AuthRequest("B", "B");

                else request = new AuthRequest("A", "A");

                connectorManager.connnect(request);

            }

        }).start();

    }

    @Override

    public void pushData(String data) {

        Log.d("coreService", "data : " + data);

        Intent intent = new Intent();

        intent.setAction(PushReceiver.ACTION_TEXT);

        intent.putExtra(PushReceiver.DATA_KEY, data);

        sendBroadcast(intent);

    }

}

服务端代码

public class TCPServer {

    private static final int port = 10002;

    /**保存并标记所有建立连接的客户端*/

    private static Map<String, Socket> clients = new LinkedHashMap<String, Socket>();

    public static void main(String[] args) {

        try {

            ServerSocket server = new ServerSocket(port);

            while (true) {

                System.out.println("准备阻塞...");

                // 获得客户端连接，阻塞式方法

                final Socket client = server.accept();

                System.out.println("阻塞完成...");

                //每连接一个客户端就新建一个线程

                new Thread(new Runnable() {

                    @Override

                    public void run() {

                        try {

                            // 获取客户端的输入流，也即客户端发送的数据。

                            //注意输入流和输出流相对于内存设备而言，将外设中的数据读取到内存中就是输入

                            InputStream is = client.getInputStream();

                            // 输出流，给客户端写数据

                            OutputStream os = client.getOutputStream();

                            byte[] buffer = new byte[1024];

                            int len = -1;

                            System.out.println("准备read...");

                            while ((len = is.read(buffer)) != -1) {

                                System.out.println("read完成...");

                                String text = new String(buffer, 0, len);

                                System.out.println(text);

                                //将客户端发送的json串转换为map

                                Map<String, String> map = new Gson().fromJson(text, new TypeToken<Map<String, String>>() {

                                }.getType());

                                String type = map.get("type");

                                if ("request".equals(type)) {

                                    String action = map.get("action");

                                    if ("auth".equals(action)) {

                                        // 认证消息处理

                                        String sender = map.get("sender");

                                        System.out.println(sender + "认证");

                                        // 放到容器当中

                                        clients.put(sender, client);

                                    } else if ("text".equals(action)) {

                                        // 文本消息

                                        String sender = map.get("sender");//客户端写死了

                                        String receiver = map.get("receiver");

                                        String content = map.get("content");

                                        Socket s = clients.get(receiver);

                                        if (s != null) {// 在线

                                            OutputStream output = s.getOutputStream();

                                            output.write(content.getBytes());

                                        } else {    // 离线

                                        }

                                    }

                                } else System.out.println("格式错误");

                            }

                        } catch (Exception e) {

                            e.printStackTrace();

                        }

                    }

                }).start();

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}