JAVA——网络编程

IP地址与端口概念

IP地址

在网络中每台计算机都必须有一个的IP地址；
32位，4个字节，常用点分十进制的格式表示，例如：192.168.1.100
127.0.0.1 是固定ip地址，代表当前计算机，相当于面向对象里的 “this”

端口

两台计算机进行连接，总有一台服务器，一台客户端。
服务器和客户端之间的通信通过端口进行。如图：

ip地址是 192.168.1.100的服务器通过端口 8080
与ip地址是192.168.1.189的客户端 的1087端口通信

获取本机IP地址

InetAddress host = InetAddress.getLocalHost();
String ip =host.getHostAddress();

package socket;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class TestSocket {

    public static void main(String[] args) throws UnknownHostException {
        InetAddress host = InetAddress.getLocalHost();
        String ip =host.getHostAddress();
        System.out.println("本机ip地址：" + ip);
    }
}

ping命令

使用ping判断一个地址是否能够到达
ping不是java的api，是windows中的一个小工具，用于判断一个地址的相应时间

ping 192.168.2.106 可以返回这个地址的响应时间 time<1ms表示很快，局域网一般就是这个响应时间

ping 192.168.2.206 返回Request timed out表示时间较久都没有响应返回，基本判断这个地址不可用

使用java 执行ping命令

借助 Runtime.getRuntime().exec() 可以运行一个windows的exe程序
使用java运行 ping 192.168.2.106，返回这样的字符串

package socket;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class TestSocket {

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

        Process p = Runtime.getRuntime().exec("ping " + "192.168.2.106");
        BufferedReader br = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line = null;
        StringBuilder sb = new StringBuilder();
        while ((line = br.readLine()) != null) {
            if (line.length() != 0)
                sb.append(line + "\r\n");
        }
        System.out.println("本次指令返回的消息是：");
        System.out.println(sb.toString());
    }

}

JAVA SOCKET 收发消息入门例子

使用 Socket(套接字)进行不同的程序之间的通信

收发数字

一旦建立了连接，服务端和客户端就可以通过Socket进行通信了
1. 客户端打开输出流，并发送数字 110
2. 服务端打开输入流，接受数字 110，并打印
Client:

public class Client {

    public static void main(String[] args) {

        try {
            Socket s = new Socket("127.0.0.1", 8888);

            // 打开输出流
            OutputStream os = s.getOutputStream();

            // 发送数字110到服务端
            os.write(110);
            os.close();

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

Server

public class Server {

    public static void main(String[] args) {
        try {

            ServerSocket ss = new ServerSocket(8888);

            System.out.println("监听在端口号:8888");
            Socket s = ss.accept();

            //打开输入流
            InputStream is = s.getInputStream();

            //读取客户端发送的数据
            int msg = is.read();
            //打印出来
            System.out.println(msg);
            is.close();

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

    }
}

收发字符串

直接使用字节流收发字符串比较麻烦，使用数据流对字节流进行封装，这样收发字符串就容易了
1. 把输出流封装在DataOutputStream中
使用writeUTF发送字符串 “Legendary!”
2. 把输入流封装在DataInputStream
使用readUTF读取字符串,并打印
只需将输入与输出流进行封装成数据流即可

InputStream is = s.getInputStream();

            //把输入流封装在DataInputStream
            DataInputStream dis = new DataInputStream(is);
            //使用readUTF读取字符串
            String msg = dis.readUTF();
            System.out.println(msg);
            dis.close();

OutputStream os = s.getOutputStream();

            //把输出流封装在DataOutputStream中
            DataOutputStream dos = new DataOutputStream(os);
            //使用writeUTF发送字符串
            dos.writeUTF("Legendary!");
            dos.close();

使用Scanner

在上个步骤中，每次要发不同的数据都需要修改代码
可以使用Scanner读取控制台的输入，并发送到服务端，这样每次都可以发送不同的数据了。

public class Client {

    public static void main(String[] args) {

        try {
            Socket s = new Socket("127.0.0.1", 8888);

            OutputStream os = s.getOutputStream();
            DataOutputStream dos = new DataOutputStream(os);

            //使用Scanner读取控制台的输入，并发送到服务端
            Scanner sc = new Scanner(System.in);
             //逐行
            String str = sc.next();
            dos.writeUTF(str);

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

使用 JAVA SOCKET 开发多线程聊天程序

如果使用单线程开发Socket应用，那么同一时间，要么收消息，要么发消息，不能同时进行。

为了实现同时收发消息，就需要用到多线程

同时收发消息

在练习-服务端和客户端互聊 中，只能一人说一句，说了之后，必须等待另一个人的回复，才能说下一句。

这是因为接受和发送都在主线程中，不能同时进行。 为了实现同时收发消息，基本设计思路是把收发分别放在不同的线程中进行

1. SendThread 发送消息线程
2. RecieveThread 接受消息线程
3. Server一旦接受到连接，就启动收发两个线程
4. Client 一旦建立了连接，就启动收发两个线程

发送线程

public class SendThread extends Thread{

    private Socket s;

    public SendThread(Socket s){
        this.s = s;
    }
    public void run(){
        try {
            OutputStream os = s.getOutputStream();
            DataOutputStream dos = new DataOutputStream(os);

            while(true){
                Scanner sc = new Scanner(System.in);
                String str = sc.next();
                dos.writeUTF(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

接收

public class RecieveThread extends Thread {

    private Socket s;

    public RecieveThread(Socket s) {
        this.s = s;
    }

    public void run() {
        try {
            InputStream is = s.getInputStream();

            DataInputStream dis = new DataInputStream(is);
            while (true) {
                String msg = dis.readUTF();
                System.out.println(msg);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

}

客户端

public class Client {

    public static void main(String[] args) {

        try {
            Socket s = new Socket("127.0.0.1", 8888);

            // 启动发送消息线程
            new SendThread(s).start();
            // 启动接受消息线程
            new RecieveThread(s).start();

        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务端

public class Server {

    public static void main(String[] args) {
        try {

            ServerSocket ss = new ServerSocket(8888);

            System.out.println("监听在端口号:8888");
            Socket s = ss.accept();

            //启动发送消息线程
            new SendThread(s).start();
            //启动接受消息线程
            new RecieveThread(s).start();

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

    }
}