Java 网络编程

一、概述

        java.net.InetAddress类

                一个该类的对象就代表一个IP地址对象

        成员方法：

                - public static InetAddress getLocalHost()：获取本地IP地址对象
                - public sstatic InetAddress getByName(String host)：根据ip地址字符串或主机名称获得对应的ip地址对象
                - String getHost()：获得主机名称
                - String getHostAddress()：获得IP地址字符串

        方法演示：

                1.获得主机IP地址

        InetAddress ip1 = InetAddress.getLocalHost();
        System.out.println(ip1);

        输出结果：
            DKT/192.168.137.1

                2.根据ip地址字符串或主机名称对应的ip地址对象

        // 根据ip地址字符串或主机名称获得对应的ip地址对象
        InetAddress ip2 = InetAddress.getByName("192.168.137.1");
        System.out.println(ip2);

        输出结果：
            /192.168.137.1

        // 根据ip地址字符串或主机名称获得对应的ip地址对象
        InetAddress ip3 = InetAddress.getByName("www.baidu.com");
        System.out.println(ip3);

        输出结果：
            www.baidu.com/110.242.68.3

                3.获取主机名称

        // 获取主机名称
        String hostName = ip3.getHostName();
        System.out.println(hostName);
    
        输出结果：
            www.baidu.com

              4.获取ip地址

        // 获取ip地址
        String hostAddress = ip3.getHostAddress();
        System.out.println(hostAddress);

        输出结果：
            110.242.68.3

二、模拟——客户端向服务器端发送文字转换

        需求:客户端向服务器端发送字符串数据

                先来模拟创建一个客户端  Client

public class Client {
    public static void main (String[] args) throws IOException {
        // 1.创建Socket对象，指定要连接的服务器ip和端口号
        Socket socket = new Socket("127.0.0.1",521);
        while (true){
            // 2.通过套接字符获取输出流
            OutputStream outputStream = socket.getOutputStream();
            // 3.写出数据到服务器
            //  3.1 创建键盘录入，输入要发送给服务器的字符串
            Scanner scanner = new Scanner(System.in);
            String s = scanner.next();
            outputStream.write(s.getBytes());
            // 4.通过套接字符获得输入流对象
            InputStream inputStream = socket.getInputStream();
            // 5.读取服务器写过来的数据
            byte[] bytes = new byte[8192];
            int len = inputStream.read(bytes);
            System.out.println(new String(bytes,0,len));
            // 6.关闭socket
            //socket.close();
        }
    }
}

                再来模拟创建服务器端  Server

public class Server {
    public static void main (String[] args) throws IOException {
        // 1.创建ServerSocket对象，指定服务器和端口号
        ServerSocket serverSocket = new ServerSocket(521);
        // 2.调用接收(方法，接收客户端的请求，返回Socket对象)
        Socket socket = serverSocket.accept();
        while (true){
            // 3.使用返回的Socket对象获得输入流
            InputStream inputStream = socket.getInputStream();
            // 4.读取客户端写过来的数据
            byte[] bytes = new byte[8192];
            int len = inputStream.read(bytes);
            System.out.println(new String(bytes,0,len));

            // 5.使用返回的Socket对象获得输出流
            OutputStream outputStream = socket.getOutputStream();
            // 6.写出数据到客户
            // 6.1 创建键盘输入
            Scanner scanner = new Scanner(System.in);
            String s = scanner.next();
            outputStream.write(s.getBytes());
            // 7.关闭ServerSocket
            //serverSocket.close();
        }
    }
}

        先启动服务器端，再启动客户端，由客户端给服务器端发送数据，服务器端再给客户端返回

  演示效果：

        客户端发送请求：

        服务器端返回响应：

 

三、模拟——文件上传案例

        需求：客户端向服务器发送文件，服务器负责接收
        这里我上传的是一个图片

                先模拟创建一个客户端

public class Client {

    public static void main (String[] args) throws IOException {
        // 1.创建Socket对象，指定要连接的服务器的ip和端口号
        Socket socket = new Socket("192.168.0.111",6666);
        // 2.创建字节输入流对象，关联数据源文件路径
        FileInputStream fileInputStream = new FileInputStream("day14_网络编程\\resources\\image\\b.png");
        // 3.通过Socket对象获得输出流
        OutputStream outputStream = socket.getOutputStream();
        // 4.定义一个字节数组，用来存储读到的字节数据
        byte[] bytes = new byte[8192];
        // 5.定义一个int变量，用来存储读到的字节个数
        int len;
        // 6.循环读取数据
        while ((len = fileInputStream.read(bytes)) != -1){
            // 7.在循环中，写出数据
            outputStream.write(bytes,0,len);
        }

        // 通知服务器发送结束
        socket.shutdownOutput();

        // 8.通过socket对象获得输入流
        InputStream inputStream = socket.getInputStream();
        // 9.读取服务器端写回的字符串数据
        int read = inputStream.read(bytes);
        System.out.println(new String(bytes,0,read));
        // 10.关闭流
        fileInputStream.close();
        socket.close();
    }
}

                再模拟创建一个服务器端

public class Server {
    //当前时间
    public static String now_date(){
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
        String format = sdf.format(date);
        return format;
    }
    public static void main (String[] args) throws IOException {
        // 1.创建ServerSocket对象，指定端口号即可
        ServerSocket serverSocket = new ServerSocket();
        while (true){
            // 2.调用accept()方法，接收客户端的请求，得到Socket对象
            Socket socket = serverSocket.accept();
            new Thread(new Runnable() {
                @Override
                public void run () {
                    FileOutputStream fileOutputStream = null;
                    try {
                        // 3.通过返回的Socket对象获得输入流
                        InputStream inputStream = socket.getInputStream();
                        // 4.创建字节输出流对象，关联目的地文件路径
                        fileOutputStream = new FileOutputStream("day14_网络编程\\resources\\image2\\"+now_date()+"ab.png");
                        // 5.定义一个字节数组，用来存储读到的字节数据
                        byte[] bytes = new byte[8192];
                        // 6.定义一个int类型的变量，用来存储读到的字节个数
                        int len;
                        // 7.循环读取数据
                        while ((len = inputStream.read(bytes)) != -1){
                            // 8.循环中写出数据
                            fileOutputStream.write(bytes,0,len);
                        }

                        System.out.println("=================================================开始回写数据给客户端=================================================");
                        // 9.通过Socket对象获取输出流
                        OutputStream outputStream = socket.getOutputStream();
                        // 10.写出字符串给客户端
                        outputStream.write("文件上传成功".getBytes());
                    } catch (IOException e) {
                        e.printStackTrace();
                    } finally {
                        // 9关闭流
                        try {
                            fileOutputStream.close();
                            socket.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }

    }
}

                一样的原理，也是先启动服务器端，再启动客户端，上传完毕后会：