Socket实现两台手机通信，定向转发数据

最近要面试了，想练习一下网络编程吧，想想来搞搞实现太手机聊天功能吧，其实聊天功能有集成好的框架，有apache的mina框架，想要知道这个框架怎么用，看我的下一篇博客吧，现在我们开讲讲怎么用socket通信吧
首先，什么叫socket？字面意思叫 插座; 灯座; 窝，穴; [解] 眼窝，孔窝
网络用语叫套接字原理是基于tcp/ip 协议的一种通信手段，
下面来看我的客户端程序吧，首先新建一个java工程。里面就有一个类用于客户端提供服务；

package javagreendao;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class SocketTest {
    private static List<Socket>listsocket=new LinkedList<Socket>();
    private static Map<String,Socket>mapsocket=new LinkedHashMap<>();
    public static void main(String[] args) {
        System.out.println("连接成功");
        int port=1001;
        try {
            @SuppressWarnings("resource")
            ServerSocket serverSocket=new ServerSocket(port);
            while (true) {
                //
                System.out.println("阻塞开始");
                final Socket socket=serverSocket.accept();
                listsocket.add(socket);
                ExecutorService executorService=Executors.newFixedThreadPool(listsocket.size());
                executorService.execute(new Runnable() {

                    @Override
                    public void run() {
                        try {
                            //输入流获取客户端数据
                            InputStream inputStream=socket.getInputStream();
                            //输出流给客户端发数据
                            OutputStream outputStream=socket.getOutputStream();
                            byte[] buffer=new byte[1024];
                            int len;
                            while((len=inputStream.read(buffer))!=-1){
                                String text=new String(buffer, 0, len);
                                System.out.println("内容"+text);
                                if (text.startsWith("#")) {
                                    mapsocket.put(text, socket);
                                    outputStream.write("收到".getBytes());
                                }else {
                                    String[] split=text.split(":");
                                    String key="#"+split[0];
                                    String countext=split[1];
                                    //给特定用户发送消息
                                    Socket tomapssoSocket=mapsocket.get(key);
                                    if (null!=tomapssoSocket){
                                        OutputStream toStream=tomapssoSocket.getOutputStream();
                                        toStream.write(countext.getBytes("UTF-8"));
                                    }
                                }

//                              //群发
//                              for (Socket pluSocket :listsocket) {
//                                  if (pluSocket!=socket) {
//                                      OutputStream giveclic=pluSocket.getOutputStream();
//                                      giveclic.write(text.getBytes());
//                                  }else {
//                                      outputStream.write("收到".getBytes());
//                                  }
//                              }
                            }

                        } catch (Exception e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
                });
            }


        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

服务端代码其实很简单，只要提供认证和类容就可以转发给指定的手机客户端了，下面我们来看看客户端代码吧，客户端其进入程序，就应该发一个认证连接服务端，然后在在客户端开启一个连接池。当有消息发送到大的是时候必须转发。这种东西就要写在service里面，然后定义动态广播，具体代码如下
activity类显示

package com.example.xutilsdemo;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.security.auth.PrivateCredentialPermission;

import com.lidroid.xutils.ViewUtils;
import com.lidroid.xutils.view.annotation.ViewInject;
import com.lidroid.xutils.view.annotation.event.OnClick;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class SocketActivity extends Activity{
    @ViewInject(R.id.but_login)
    private Button but_login;
//  @ViewInject(R.id.but_outh)
//  private Button but_outh;
//  @ViewInject(R.id.but_service)
//  private Button but_service;
//  @ViewInject(R.id.but_lose)
//  private Button but_lose;
    @ViewInject(R.id.edit_context)
    private EditText edit_context;
//  @ViewInject(R.id.edit_outh)
//  private EditText edit_outh;
    private String ip="10.188.20.129";
    private int port=1001;
    private Socket socket;


    /**
     * 监听广播
     */
    private SocketPushBroadcastReservcer spbr=new SocketPushBroadcastReservcer() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (SocketPushBroadcastReservcer.ACTION_STRING.equals(intent.getAction())) {
                String contextString=intent.getStringExtra(SocketPushBroadcastReservcer.DATA_KEY);
                Log.i("获取消息", contextString);
                if (!contextString.equals(null)) {
                    Log.i("获取消息", contextString);
                    Toast.makeText(getApplicationContext(), contextString, Toast.LENGTH_LONG).show();
                }
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ViewUtils.inject(this);
        startService(new Intent(this,SocketCorserviceService.class));
        IntentFilter intentFilter=new IntentFilter();
        //注册广播
        intentFilter.addAction(SocketPushBroadcastReservcer.ACTION_STRING);
        registerReceiver(spbr, intentFilter);
    }
    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        unregisterReceiver(spbr);//注销广播

    }

    @OnClick(R.id.but_login)
    public void but_login(View v){
        if (TextUtils.isEmpty(edit_context.getText())) {
            return ;
        }
        try { 
//          OutputStream outputStream = socket.getOutputStream();
//          outputStream.write(edit_context.getText().toString().getBytes());
           ExecutorService executorService=Executors.newFixedThreadPool(2);
           executorService.execute(new Runnable() {

            @Override
            public void run() {
                SocketConnectorMessager.getConnectorMessager().
                   putRequest(edit_context.getText().toString().trim());                
            }
        });

        } catch (Exception e1) {
            e1.printStackTrace();
        }
    }

提供服务类
SocketConnector

package com.example.xutilsdemo;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * socket 类容提供者
 * @author double
 *
 */
public class SocketConnector {
    private String ip="10.188.20.129";
    private int port=1001;
    private Socket socket;
    SocketConnectorLinstre soLinstre;
    private ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<>(8);
    public SocketConnector(){

    }
    private class RwquestWork implements Runnable{

        @Override
        public void run() {
            try {
                OutputStream outputStream=socket.getOutputStream();
                while (true) {
                    String context=queue.take();
                    outputStream.write(context.getBytes("UTF-8"));  
                }
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

        }

    }

//  /**
//   * 发送
//   */
//  public void send(String context){
//      OutputStream outputStream;
//      try {
//          outputStream = socket.getOutputStream();
//          outputStream.write(context.getBytes("UTF-8"));
//      } catch (Exception e) {
//          e.printStackTrace();
//      }
//  }
    public void putRequest(String context){
        System.out.println(">>>>>>>>>"+context);
        try {
            queue.put(context);
           System.out.println("queue.take()"+queue.take()); 
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 连接
     */
    public void connector(){


            try {
                if (null==socket||socket.isClosed()){
                socket=new Socket(ip, port);
                }
                 new Thread(new RwquestWork()).start();
                ExecutorService executorService=Executors.newFixedThreadPool(3);
                executorService.execute(new Runnable() {
                    @Override
                    public void run() {

                        try {
                            InputStream inputStream=socket.getInputStream();
                            byte[] buffer=new byte[1024];
                            int len;
                            while ((len=inputStream.read(buffer))!=-1) {
                                //服务端返回的结果
                                final String request=new String(buffer,0,len);
                                if (null!=soLinstre) {
                                    soLinstre.notfiyData(request);
                                }
                            }
//                          
//                          OutputStream outputStream=socket.getOutputStream();
//                          while (true) {
//                              String context=queue.take();
//                              System.out.println("---------"+context);
//                              outputStream.write(context.getBytes("UTF-8"));  
//                          }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }                       
                    }
                }); 

            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }

    }
    /**
     * 断开
     */
    public void disConnector(){
        try {
            if (null==socket||socket.isClosed()){
                socket.close();
                socket=null;
            }

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 认证
     */
    public  void Auth(String auth){
        OutputStream outputStream;
        try {
            outputStream = socket.getOutputStream();
            outputStream.write(auth.getBytes("UTF-8"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public void setSocketConnectorLinstre(SocketConnectorLinstre soLinstre ){
        this.soLinstre=soLinstre;
    }

    public interface SocketConnectorLinstre{
        public void notfiyData(String data);
    }
}

SocketConnectorMessager类主要用于认证

package com.example.xutilsdemo;

import com.example.xutilsdemo.SocketConnector.SocketConnectorLinstre;

/**
 * 消息提供者
 * @author double
 *
 */
public class SocketConnectorMessager implements SocketConnectorLinstre{
    private static  SocketConnectorMessager messager;
    private SocketConnector socketConnector;
     private SocketConnectorLinstre soLinstre;
    private SocketConnectorMessager(){

    }
    public static SocketConnectorMessager getConnectorMessager(){
        messager=new SocketConnectorMessager();
        return messager;
    }

    public void connect(String auth){
        socketConnector=new SocketConnector();
        socketConnector.setSocketConnectorLinstre(this);
        socketConnector.connector();//连接，   
        socketConnector.Auth(auth);//认证
    }
    public void putRequest(String request){
        if (socketConnector==null) {
            socketConnector=new SocketConnector();
        }
        socketConnector.connector();
        System.out.println("++++++++"+request);
        socketConnector.putRequest(request);
    }

    @Override
    public void notfiyData(String data) {
        if (soLinstre!=null) {
            soLinstre.notfiyData(data);
        }
    }

    public void setSocketConnectorLinstre(SocketConnectorLinstre soLinstre ){
        this.soLinstre=soLinstre;
    }

    public interface SocketConnectorLinstre{
        public void notfiyData(String data);
    }
}

SocketCorserviceService后台服务类

package com.example.xutilsdemo;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;



import com.example.xutilsdemo.SocketConnectorMessager.SocketConnectorLinstre;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
/**
 * socket服务
 * @author double
 *
 */
public class SocketCorserviceService extends Service
implements SocketConnectorLinstre{
private SocketConnector socketConnector;
private SocketConnectorMessager socketConnectorMessager;
private ExecutorService exec=Executors.newFixedThreadPool(3);
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    @SuppressWarnings("unused")
    @Override
    public void onCreate() {
        super.onCreate();
         socketConnectorMessager=SocketConnectorMessager.getConnectorMessager();

        exec.execute(new  Runnable() {
            public void run() {

                socketConnectorMessager.setSocketConnectorLinstre(SocketCorserviceService.this);
                socketConnectorMessager.connect("#A");
                //socketConnector=new SocketConnector();
            //  socketConnector.setSocketConnectorLinstre(SocketCorserviceService.this);
            //  socketConnector.connector();//连接，   
                //socketConnector.Auth("#A");//认证
            }
        });
        }

    @Override
    public void notfiyData(String data) {
        Intent intent=new Intent();
        intent.setAction(SocketPushBroadcastReservcer.ACTION_STRING);
        intent.putExtra(SocketPushBroadcastReservcer.DATA_KEY, data);
        sendBroadcast(intent);//发送广播
    }
}

广播监听
SocketPushBroadcastReservcer用于指定action动作

package com.example.xutilsdemo;

import android.content.BroadcastReceiver;
/**
 * 消息广播监听
 * @author twj
 *
 */
public abstract class SocketPushBroadcastReservcer extends BroadcastReceiver {

    public static final String ACTION_STRING="com.demo.action.text";
    public static final String DATA_KEY="data";
}

好了，吃饭去了，现在才去吃完饭，要源码的小伙伴留下邮箱

2016.05.29 .21 .34