Socket，IO（一）

初识socket简单创简单你server连接

基于tcp协议，建立稳定性连接的点对点通信。
实时、快速。安全性高、占用系统资源多。效率低
“请求-响应” 模式
客户端:在网络通讯中，第一次主动发起通讯的程序被称作客户端（client）程序
服务器：第一次通讯中等待连接的程序被称作服务器端（Server）程序
Socket：发送TCP消息
ServerSocket：创建服务器
套接字：是一种进程间的数据交换机制。这些进程既可以在同一机器上，也可以在网络连接的不通机器上
换句话说，套接字起到通信端点的作用。单个套接字是一个端点，而一对套接字则构成了一个双向通信信道
使非关联进程可以在本地或通过网络进行数据交换。一旦建立套接字连接，数据即可在相同或不通的系统中双向或单项发送，
直到其中一个端点关闭连接。

简单的Socket连接
server端：

    public class Server{
        public static void main(String[] args) throws IOException {
            //1.创建 服务器制定端口
            ServerSocket server = new ServerSocket(8888);
            //2.接收客户端连接，阻塞式（表示没有客户端接入不会向下运行）
            Socket socket = server.accept();
            System.out.println("一个客户端进行了连接！");
        }
    }

client端：

    public class Client {
        //使用下面方式进行简单的连接：一直端口和ip进行连接
        Socket client = new Socket("localhost", 8888);
    }

先运行server中的main方法，然后运行client重的main方法，
在服务器端的控制台会打印：

一个客户端进行连接字样

使用DataInputStream和DataOutputStream流传输

客户端代码:

    public class Client {

        public static void main(String[] args) throws UnknownHostException, IOException {
        //1.创建客户端，必须制定服务器+端口  
        Socket client = new Socket("localhost", 8888);

        //2.接收数据
        /*
        BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
        String echo = br.readLine();//阻塞式方法   分行接收不会报错（解决方法：在server的传输字符串可以+  /r/n   或者在 write方法后面+newLine（））
        System.out.println(echo);
        */

        DataInputStream da = new DataInputStream(client.getInputStream());
        String re = da.readUTF();
            System.out.println(re);

        }
    }

服务器端：
使用while死循环使server一直在与你系那个状体，（后续会改进，使用多线程进行开发）

    public class Server{
        public static void main(String[] args) throws IOException {

            //1.创建 服务器制定端口
            ServerSocket server = new ServerSocket(8888);
            //2.接收客户端连接，阻塞式
            while(true){
                //死循环,一个accrpt一个客户端
                Socket socket = server.accept();
                System.out.println("一个客户端进行了连接！");
                //3.发送数据
                String msg = "欢迎使用";
                //输出流    输出流和输入流是成对的
            /*
            BufferedWriter bw = new BufferedWriter(
                    new OutputStreamWriter(
                            socket.getOutputStream()));
            bw.write(msg);
            bw.newLine();
            bw.flush();
            */
                DataOutputStream da = new DataOutputStream(socket.getOutputStream());
                da.writeUTF(msg);
                da.flush();
            }
        }
    }

这其中的BufferedWriter 和BufferedReader 不推荐使用

运行方式，首先运行Server中的main方法，控制台会显示

之后运行client的main方法

表示接收到server传过来的数据

使用InputStream和OutputStream传输

和使用DataInputStream和DataOutputStream类似，

server端：

    public class Server {
    public static void main(String[] args) throws IOException {

        //1.创建 服务器制定端口
            ServerSocket server = new ServerSocket(8888);
            //2.接收客户端连接，阻塞式
            while(true){
                //死循环,一个accrpt一个客户端
                Socket socket = server.accept();
                System.out.println("一个客户端进行了连接！");
                //3.发送数据
                String msg = "欢迎使用";
                OutputStream os = socket.getOutputStream();
                try {
                    byte[] by = LoUtils.hexStr2Bytes(LoUtils.str2HexStr(msg)); //传入shuju 
                    String len = "0000" + by.length;
                    len = len.substring(len.length() - 4);
                    byte[] lenlen = len.getBytes("UTF-8");
                    byte[] true_body = LoUtils.assemble(lenlen,by);
                    os.write(true_body);
                    os.flush();
                } catch (Exception e) {
                }
            }
        }
    }

client端：

    public class Client {
        public static void main(String[] args) throws UnknownHostException, IOException {
            //1.创建客户端，必须制定服务器+端口  
            Socket client = new Socket("localhost", 8888);
            //2.接收数据
            byte[] lenbtyte = new byte[4];
            input.read(lenbtyte, 0, 4);
            int resplen = Integer.parseInt(new String(lenbtyte, "UTF-8"));
            byte[] pack = new byte[resplen];
            input.read(pack, 0, resplen);
            String res = new String(pack, "UTF-8");
            System.out.println(res);

        }
    }

运行成功后和上面的结果相同，就表示正确了。

工具类LoUtils：

    public class LoUtils {
        //2进制到16进制Str转换
        public static String str2HexStr(String str) throws Exception {
            char[] chars = "0123456789ABCDEF".toCharArray();
            StringBuilder sb = new StringBuilder("");
            byte[] bs = str.getBytes("UTF-8");
            int bit;
            for (int i = 0; i < bs.length; i++) {
                bit = (bs[i] & 0x0f0) >> 4;
                sb.append(chars[bit]);
                bit = bs[i] & 0x0f;
                sb.append(chars[bit]);
            }
            return sb.toString();
        }

        /**
        * 十六进制字符串转换成bytes
         * 
         * @param src
         * @return
         */
        public static byte[] hexStr2Bytes(String src) {
            int m = 0, n = 0;
            int l = src.length() / 2;
            byte[] ret = new byte[l];
            for (int i = 0; i < l; i++) {
                m = i * 2 + 1;
                n = m + 1;
                ret[i] = uniteBytes(src.substring(i * 2, m), src.substring(m, n));
            }
            return ret;
        }

        //转换成 已只长度的 数组段 
        public static byte[] assemble(byte[]... b) throws Exception {
            int length = 0;
            for (byte[] bl : b) {
                if (bl != null)
                    length += bl.length;
            }
            byte[] data = new byte[length];
            int count = 0;
            for (int i = 0; i < b.length; i++) {
                if (b[i] != null) {
                    System.arraycopy(b[i], 0, data, count, b[i].length);
                    count += b[i].length;
                }
            }
            return data;
        }
    }

本人相对比较习惯使用DataInputStream和DataOutputStream
传输比较简单容易理解。

Tips：亲测上述方法可用特此分享