Socket在Android中的用法

Socket的简介

网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。

在Android中我们常用的Socket形式为一方是客户端一方是服务端，分别具有数据的发送与接受的功能
在客户端使用Soket时，首先应了解服务端的Ip地址（只有知道，才能找到服务器）并知道服务器所监听
的端口号，才能顺利的建立连接

在服务端使用Socket时，应首先规定出需要监听的端口号，以便准确监听。

客户端Soket的简单用法

 public class MsgClient {        public DataOutputStream outs;        public static void main(String[] args) {            try {                MsgClient client = new MsgClient();                client.connServer("127.0.0.1", 9090);            } catch (UnknownHostException e) {                e.printStackTrace();            } catch (IOException e) {                e.printStackTrace();            }        }        public void sendTextMsg(DataOutputStream out, String msg) throws IOException {            byte[] bytes = msg.getBytes();            out.write(bytes);            out.flush();        }        public void connServer(String ip, int port) throws UnknownHostException, IOException {            Socket client = new Socket(ip, port);            InputStream in = client.getInputStream();            OutputStream out = client.getOutputStream();            outs = new DataOutputStream(out);            sendTextMsg(outs, "我发送啦");        }    }

Socket客户端的用法比较简单，如上述一样，指定客户端Ip和监听端口，然后在连接成功后，就能够通过获取相应的流来进行数据的发送与接收操作

Socket服务端

 public static void main(String[] args) {        try {            MsgServer server = new MsgServer();            server.setUpServer(9090);        } catch (IOException e) {            e.printStackTrace();        }    }    public void setUpServer(int port) throws IOException {        ServerSocket server = new ServerSocket(port);        while(true) {            Socket client = server.accept();//阻塞状态,生成            System.out.println("客户端IP："+client.getRemoteSocketAddress());            processMesage(client);        }    }    private void processMesage(Socket client) throws IOException {        InputStream ins = client.getInputStream();        DataInputStream dins = new DataInputStream(ins);        //服务端接收数据        while(true) {             String msg = dins.readLine();            System.out.println("发来的内容是:"+msg);        }    }

服务器的原理也和客户端相似，通过指定对应的Port来监听客户端的连接，当 server.accept(); 的时候处于阻塞状态等待客户端的连接，当客户端连接时生成Socket实例，针对新的socket对象可进行相关操作

Socket心跳包

在使用过程中，由于客户端和服务端的机制原因，客户端和服务器端无法准确的了解对方是否还存在，所以心跳包也就此出现，基本原理就是客户端定时向服务端报告自己在线，服务端进行接收信息了解客户端在线，并会送客户端信息，具体代码如下

public class Server {    /**     * 要处理客户端发来的对象，并返回一个对象，可实现该接口。     */    public interface ObjectAction{        Object doAction(Object rev);    }    public static final class DefaultObjectAction implements ObjectAction{        public Object doAction(Object rev) {            System.out.println("处理并返回："+rev);            return rev;        }    }    public static void main(String[] args) {        int port = 65432;        Server server = new Server(port);        server.start();    }    private int port;    private volatile boolean running=false;    private long receiveTimeDelay=3000;    private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();    private Thread connWatchDog;    public Server(int port) {        this.port = port;    }    public void start(){        if(running)return;        running=true;        connWatchDog = new Thread(new ConnWatchDog());        connWatchDog.start();    }    @SuppressWarnings("deprecation")    public void stop(){        if(running)running=false;        if(connWatchDog!=null)connWatchDog.stop();    }    public void addActionMap(Class<Object> cls,ObjectAction action){        actionMapping.put(cls, action);    }    class ConnWatchDog implements Runnable{        public void run(){            try {                ServerSocket ss = new ServerSocket(port,5);                while(running){                    Socket s = ss.accept();                    new Thread(new SocketAction(s)).start();                }            } catch (IOException e) {                e.printStackTrace();                Server.this.stop();            }        }    }    class SocketAction implements Runnable{        Socket s;        boolean run=true;        //逻辑问题，上次接收时间默认应为0        long lastReceiveTime = System.currentTimeMillis();//        long lastReceiveTime = 0;        public SocketAction(Socket s) {            this.s = s;        }        public void run() {            while(running && run){                if(System.currentTimeMillis()-lastReceiveTime>receiveTimeDelay){                    System.out.println("我进来了");                    overThis();                }else{                    try {                        InputStream in = s.getInputStream();                        if(in.available()>0){                            ObjectInputStream ois = new ObjectInputStream(in);                            Object obj = ois.readObject();                            lastReceiveTime = System.currentTimeMillis();                            System.out.println("接收：\t"+obj);                            ObjectAction oa = actionMapping.get(obj.getClass());                            oa = oa==null?new DefaultObjectAction():oa;                            Object out = oa.doAction(obj);                            if(out!=null){                                ObjectOutputStream oos = new ObjectOutputStream(s.getOutputStream());                                oos.writeObject(out);                                oos.flush();                            }                        }else{                            Thread.sleep(10);                        }                    } catch (Exception e) {                        e.printStackTrace();                        overThis();                    }                }            }        }        private void overThis() {            if(run)run=false;            if(s!=null){                try {                    s.close();                } catch (IOException e) {                    e.printStackTrace();                }            }            System.out.println("关闭："+s.getRemoteSocketAddress());            System.out.println("断开连接");        }    }}

public class Client {    /**     * 处理服务端发回的对象，可实现该接口。     */    public static interface ObjectAction{        void doAction(Object obj,Client client);    }    public static final class DefaultObjectAction implements ObjectAction{        public void doAction(Object obj,Client client) {            System.out.println("处理：\t"+obj.toString());        }    }    public static void main(String[] args) throws UnknownHostException, IOException {        String serverIp = "127.0.0.1";        int port = 65432;        Client client = new Client(serverIp,port);        client.start();    }    private String serverIp;    private int port;    private Socket socket;    private boolean running=false;    private long lastSendTime;    private ConcurrentHashMap<Class, ObjectAction> actionMapping = new ConcurrentHashMap<Class,ObjectAction>();    public Client(String serverIp, int port) {        this.serverIp=serverIp;this.port=port;    }    public void start(){        if(running)return;        try {            socket = new Socket(serverIp,port);            System.out.println("本地端口："+socket.getLocalPort());            lastSendTime=System.currentTimeMillis();            running=true;            new Thread(new KeepAliveWatchDog()).start();            new Thread(new ReceiveWatchDog()).start();        } catch (IOException e) {            System.out.println("u发发");            try {                Thread.sleep(10000);            } catch (InterruptedException e1) {                e1.printStackTrace();            }            System.out.println(port+"");            Client client = new Client(serverIp,port);            client.start();            e.printStackTrace();        }    }    public void stop(){        if(running)running=false;        System.out.println("Client stop");    }    /**     * 添加接收对象的处理对象。     * @param cls 待处理的对象，其所属的类。     * @param action 处理过程对象。     */    public void addActionMap(Class<Object> cls,ObjectAction action){        actionMapping.put(cls, action);    }    public void sendObject(Object obj) {        try {            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());            oos.writeObject(obj);            System.out.println("发送：\t"+obj);            oos.flush();        } catch (IOException e) {            System.out.println("尼玛炸了");            stop();            start();            e.printStackTrace();        }    }    class SendMessage implements Runnable {        @Override        public void run() {            while (true) {                Scanner scanner = new Scanner(System.in);                String s = scanner.nextLine();            }        }    }    class KeepAliveWatchDog implements Runnable{        long checkDelay = 10;        long keepAliveDelay = 2000;        public void run() {            while(running){                if(System.currentTimeMillis()-lastSendTime>keepAliveDelay){                    Client.this.sendObject(new KeepAlive());                    lastSendTime = System.currentTimeMillis();                }else{                    try {                        Thread.sleep(checkDelay);                    } catch (InterruptedException e) {                        e.printStackTrace();                        Client.this.stop();                    }                }            }        }    }    class ReceiveWatchDog implements Runnable{        public void run() {            while(running){                try {                    InputStream in = socket.getInputStream();                    if(in.available()>0){                        ObjectInputStream ois = new ObjectInputStream(in);                        Object obj = ois.readObject();                        System.out.println("接收：\t"+obj);                        ObjectAction oa = actionMapping.get(obj.getClass());                        oa = oa==null?new DefaultObjectAction():oa;                        oa.doAction(obj, Client.this);                    }else{                        Thread.sleep(10);                    }                } catch (Exception e) {                    e.printStackTrace();                    Client.this.stop();                }            }        }    }}

public class KeepAlive implements Serializable {    private static final long serialVersionUID = -2813120366138988480L;    /* 覆盖该方法，仅用于测试使用。     * @see java.lang.Object#toString()     */    @Override    public String toString() {        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+"\t维持连接包";    }}

Socket中传输文件（并能传递文件名）

/** * Created by admin on 2016/9/20/0020. * * 客户端给服务端发送文件夹 */public class TCPServer {    static int size=10*1024;    static byte[] buf=new byte[size];    static int len=-1;    public static void main(String[] args) throws Exception{        ServerSocket ss=null;        OutputStream out=null;        Socket s=null;        try {            ss=new ServerSocket(9987);            System.out.println("等待客户端连接");            s=ss.accept();            System.out.println("连接成功");//          InputStream in=s.getInputStream();            out=s.getOutputStream();            long start=System.currentTimeMillis();            System.out.println("开始发送文件");            String fileName="D:\\新建文件夹\\demo1";//"I:"+File.separator;            if(!fileName.endsWith(File.separator)){                fileName+=File.separator;            }            File file=new File(fileName);            String parent=file.getParent();            if(parent==null){                File[] fs=file.listFiles();                for(int i=0;i<fs.length;i++){                    if(fs[i].isHidden())                    {                        System.out.println("隐藏文件"+fs[i].getAbsolutePath()+",不会被发送");                        continue;                    }                    test(fs[i],out,fs[i].getParent());                }            }else{                test(file,out,parent);            }            System.out.println("文件发送成功"+(System.currentTimeMillis()-start)+"ms");          out.write("接受成功".getBytes());            out.flush();        } finally {            if(out!=null)out.close();            if(s!=null)s.close();            if(ss!=null)ss.close();        }    }    private static void test(File file,OutputStream out,String sendFileName)throws Exception{        FileInputStream in=null;        String fname=file.getAbsolutePath();        String name=fname.replace(sendFileName, "");        if(file.isDirectory()){            File[] fs=file.listFiles();            out.write(new byte[]{(byte)2}, 0, 1);//2:文件夹名            int fileLength=name.getBytes().length;            out.write(intToBytes(fileLength),0,4);//文件名的长度            out.write(name.getBytes(),0,name.getBytes().length);//文件名            System.out.println("文件夹："+name+"   "+name.length());            out.flush();            for(int i=0;i<fs.length;i++){                if(fs[i].isHidden())                {                    System.out.println("隐藏文件"+fs[i].getAbsolutePath()+",不会被发送");                    continue;                }                test(fs[i],out,sendFileName);            }        }else{            out.write(new byte[]{(byte)1}, 0, 1);//1：文件名            int fileLength=name.getBytes().length;            out.write(intToBytes(fileLength),0,4);//文件夹名的长度            out.write(name.getBytes(),0,name.getBytes().length);//文件夹名            System.out.println("文件："+name+"   "+name.length()+"  "+file.length());            out.flush();            in=new FileInputStream(file);            out.write(new byte[]{(byte)0}, 0, 1);//0表示文件数据            out.write(longToBytes(file.length()),0,8);//文件的长度            out.flush();            while((len=in.read(buf,0,size))!=-1){                out.write(buf,0,len);                out.flush();            }            in.close();        }    }    private static byte[] intToBytes(int i){        byte[] b=new byte[4];        b[0]=(byte)((i>>>24)&255);        b[1]=(byte)((i>>>16)&255);        b[2]=(byte)((i>>>8)&255);        b[3]=(byte)(i&255);        return b;    }    private static byte[] longToBytes(long i){        byte[] b=new byte[8];        b[0]=(byte)((i>>>56)&255);        b[1]=(byte)((i>>>48)&255);        b[2]=(byte)((i>>>40)&255);        b[3]=(byte)((i>>>32)&255);        b[4]=(byte)((i>>>24)&255);        b[5]=(byte)((i>>>16)&255);        b[6]=(byte)((i>>>8)&255);        b[7]=(byte)(i&255);        return b;    }}

public class TCPClient {    public static void main(String[] args) throws Exception{        System.setOut(new PrintStream(new FileOutputStream("D:\\log.txt")));        Socket s=null;        InputStream in=null;        try {            s=new Socket("127.0.0.1", 9987);            String savePath="D:\\新建文件夹\\demo2";//"D:"+File.separator+"test"+File.separator;            in=s.getInputStream();            int size=10*1024;            byte[] buf=new byte[size];            int len=-1;            byte[] bs=new byte[size];            while((len=in.read(buf, 0, size))!=-1){                writeData(buf,0,len,savePath,bs);            }            if(out!=null){                out.flush();                out.close();            }        } finally {            if(in!=null)                in.close();            if(s!=null)                s.close();        }    }    static FileOutputStream out=null;    static long count=0;//计算是否完成数据的读取，开始下一条命令    static int cmd=-1;    static int bsl=0;    private static void writeData(byte[] buf,int off, int len,String savePath,byte[] bs) throws Exception{        if(len-off==0)return;        System.out.println("偏移量："+off+"命令"+cmd+"数量："+count);        int i=off;        if(count==0l){//如果一条命令的数据已经读完就开始读取下一条命令            cmd=buf[i++];            System.out.println("获取命令："+cmd);            count=-1l;            if(len-i==0)return;            writeData(buf,i,len,savePath,bs);        }else if(count==-1l){//读取文件（夹）名称的长度或文件的大小            System.out.println("获取长度");            switch (cmd){                case 0:                    if(len-i+bsl<8){                        System.arraycopy(buf, i, bs, bsl, len-i);                        System.out.println("读取长度1："+(len-i)+"  未读取完");                        bsl=len-i;                        i=0;                        return;                    }                    System.arraycopy(buf, i, bs, bsl, 8-bsl);                    System.out.println("读取长度1："+(8-bsl)+"  读取完");                    count=bytesToLong(bs, 0);                    i+=8-bsl;                    bsl=0;                    writeData(buf,i,len,savePath,bs);                    break;                case 1:                case 2:                    if(len-i+bsl<4){                        System.arraycopy(buf, i, bs, bsl, len-i);                        System.out.println("读取长度2："+(len-i)+"  未读取完");                        bsl=len-i;                        i=0;                        return;                    }                    System.arraycopy(buf, i, bs, bsl, 4-bsl);                    System.out.println("读取长度2："+(4-bsl)+"  读取完");                    count=bytesToInt(bs, 0);                    i+=4-bsl;                    bsl=0;                    writeData(buf,i,len,savePath,bs);                    break;            }        }else{//写入文件或创建文件夹、创建文件输出流            System.out.println("3");            switch (cmd){                case 0:                    System.out.println("写入文件");                    if(len-i-count>0){                        try{                            System.out.println("写入文件      长度："+count+"文件写入完成");                            out.write(buf, i, (int)count);                            i+=count;                            count=0;                            out.flush();                        }finally{                            if(out!=null)out.close();                        }                        writeData(buf,i,len,savePath,bs);                    }else{                        System.out.println("写入文件      长度："+(len-i)+"文件写入没有完成");                        out.write(buf,i,len-i);                        count-=len-i;                        i=0;                    }break;                case 1:                    if(len-i-count<0){                        System.out.println("获取文件名字："+(len-i)+"写入没有完成    剩余长度"+count);                        System.arraycopy(buf, i, bs, bsl, len-i);                        bsl+=len-i;                        count-=bsl;                        i=0;                        return;                    }else{                        System.out.println("获取文件名字："+(count-bsl)+"写入完成    剩余长度");                        System.arraycopy(buf, i, bs, bsl, (int)count);                        String name=new String(bs,0,(int)count+bsl);                        System.out.println("文件："+savePath+name);                        out=new FileOutputStream(savePath+name);                        bsl=0;                        i+=count;                        count=0;                        writeData(buf,i,len,savePath,bs);                    }                    break;                case 2:                    if(len-i-count<0){                        System.out.println("获取文件夹名字："+(len-i)+"写入没有完成    剩余长度"+count);                        System.arraycopy(buf, i, bs, bsl, len-i);                        bsl+=len-i;                        count-=bsl;                        i=0;                        return;                    }else{                        System.out.println(len+"   "+count+"   "+bsl+"  ");                        System.out.println("获取文件夹名字："+(count-bsl)+"写入完成    剩余长度");                        System.arraycopy(buf, i, bs, bsl, (int)count);                        String name=new String(bs,0,bsl+(int)count);                        File file=new File(savePath+name);                        bsl=0;                        i+=count;                        count=0;                        if(!file.exists()){                            file.mkdirs();                        }                        System.out.println("文件夹："+savePath+name);                        writeData(buf,i,len,savePath,bs);                    }                    break;            }        }    }    private static int bytesToInt(byte[] buf,int off){        int i=0;        i=i|((buf[off]&255)<<24);        i=i|((buf[off+1]&255)<<16);        i=i|((buf[off+2]&255)<<8);        i=i|(buf[off+3]&255);        return i;    }    private static long bytesToLong(byte[] buf,int off){        long i=0;        i=i|(((long)buf[off]&255)<<56)                |(((long)buf[off+1]&255)<<48)                |(((long)buf[off+2]&255)<<40)                |(((long)buf[off+3]&255)<<32)                |(((long)buf[off+4]&255)<<24)                |(((long)buf[off+5]&255)<<16)                |(((long)buf[off+6]&255)<<8)                |((long)buf[off+7]&255);        return i;    }}

具体实现原理我也没看懂···（好尴尬），再次作为记录，如果小伙伴们知道，欢迎帮本宝宝指个明路。