网络编程

IP对象——InetAddress

package my.demo;

import java.io.IOException;
import java.net.*;

public class IPdemo {
    public static void main(String[] args) throws UnknownHostException {
        //获取本地主机的ip地址对象
        InetAddress ip = InetAddress.getLocalHost();
        //获取其他主机ip地址对象
        InetAddress ip_other = InetAddress.getByName("www.baidu.com");//InetAddress ip_other = InetAddress.getByName("my_think");
        System.out.println("name:"+ip.getHostAddress());
        System.out.println("name:"+ip.getHostName());
        System.out.println("name:"+ip_other.getHostName());
        //有的主机对应ip地址不唯一
        //域名解析
        //DNS域名解析服务
        //UDP传输 DatagramPacket

    }
    //UDP传输 DatagramPacket SendDemo
    public static void UDP_demo() throws IOException {
        /**
         * 创建UDP传输的发送端
         * 思路：
         * 1.创建UDP的socket服务
         * 2.将要发送的数据封装到数据包中
         * 3.通过udp的socket服务将数据包发送出去
         * 4.关闭socket服务
         */
        //1.udp的socket服务.使用DatagramSocket对象
        DatagramSocket ds = new DatagramSocket();
        //2.将要发送的数据封装到数据包中
        String str = "hello udpDemo!";
        //使用DatagramPacket将数据封装到该对象包中
        byte[] buf = str.getBytes();
        DatagramPacket dp =
                new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.1.106"),10000);//port:0-65535
        //3.通过udp的socket服务将数据包发送出去，使用send方法
        ds.send(dp);
        //4.关闭资源
        ds.close();
    }
}

UDP协议
Rece.java

package my.demo.UDP;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Rece implements Runnable{
    private DatagramSocket ds;
    public Rece(DatagramSocket ds){
        this.ds = ds;
    }
    @Override
    public void run() {
        try{

            while (true) {
                //2.创建数据包
                byte[] buf = new byte[1024];
                DatagramPacket dp = new DatagramPacket(buf, buf.length);
                System.out.println("接收端启动");
                //3.使用接收方法将数据存储到数据包中
                ds.receive(dp);//阻塞式的
                System.out.println("接收端启动");
                //4.通过数据包对象方法，解析其中的数据，比如，地址，端口，数据内容。
                String ip = dp.getAddress().getHostAddress();
                int port = dp.getPort();//发送端端口
                String str = new String(dp.getData(), 0,dp.getLength());
                System.out.println("ip:" + ip);
                System.out.println("port:" + port);
                System.out.println("text:" + str);
                //5.关闭资源
//            ds.close();
            }
//            ds.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Send.java

package my.demo.UDP;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;

public class Send implements Runnable {
    private DatagramSocket ds;

    public Send(DatagramSocket ds) {
        this.ds = ds;
    }
    @Override
    public void run() {
        try {
            System.out.println("发送端启动");
            //2.将要发送的数据封装到数据包中
//        String str = "....";
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String line = null;
            while ((line = br.readLine()) != null) {

                byte[] buf = line.getBytes();
                DatagramPacket dp =
                        new DatagramPacket(buf, buf.length, InetAddress.getByName("169.254.138.4"), 10000);//port:0-65535
                ds.send(dp);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        ds.close();
    }
}

ChatDemo.java

package my.demo.UDP;

import java.net.DatagramSocket;
import java.net.SocketException;

public class ChatDemo {
    public static void main(String[] args) throws SocketException {
        DatagramSocket send_ds = new DatagramSocket();
        DatagramSocket rece_ds = new DatagramSocket(10000);
        Send send = new Send(send_ds);
        Rece rece = new Rece(rece_ds);
        //创建线程
        new Thread(send).start();
        new Thread(rece).start();
    }
}

TCP协议
ServerDemo.java

package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerDemo2 {
    public static void main(String[] args) throws IOException {
        //服务端接收客户端发来的数据并打印在控制台上
        /**
         * 建立TCP服务端的思路：
         * 1.创建服务端socket服务。通过ServerSocket对象。
         * 2.服务端必须对外提供一个端口，否则客户端无法连接。
         * 3.获取连接过来的客户端对象。
         * 4.通过客户端对象获取socket流读取客户端发来的数据
         * 5.关闭资源.关客户端，关服务端
         */
        //1.创建服务端对象
        ServerSocket ss = new ServerSocket(10000);
        //2.获取连接过来的客户端对象
        Socket s = ss.accept();
        String ip = s.getInetAddress().getHostAddress();
        //3.通过socket对象获取输入流，要读取客户端发来的数据
        InputStream in = s.getInputStream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        String text = new String(buf,0,len);
        System.out.println(ip+"server:"+text);
        //使用客户端socket对象的输出流给客户端返回数据
        OutputStream out = s.getOutputStream();
        out.write("收到".getBytes());
        s.close();//关闭客户端
        ss.close();//关闭服务端
    }
}

ClientDemo.java

package TCP;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ClientDemo2 {
    public static void main(String[] args) throws IOException {
    //客户端发数据到服务端去
        /**
         * TCP传输时，客户端建立过程
         * 1.创建TCP客户端socket服务，使用Socket对象
         *      建议该对象一创建就明确目的地。要连接的主机。
         * 2.如果连接建立成功，说明数据传输通道已建立。
         *      该通道就是就是Socket流，是底层建立好的，既然是流
         *      说明这里既有输入，又有输出，想要输入或者输出流对象，可以找Socket来获取
         *      可以通过getOutputStream和getInputStream来获取两个字节流
         * 3.使用输出流，将数据写出。
         * 4.关闭资源
         */
        //创建客户端socket服务
        Socket socket = new Socket("192.168.1.101",10000);
        //获取socket流中的输出流
        OutputStream out = socket.getOutputStream();
        //使用输出流将指定数据写出去
        out.write("TCP演示".getBytes());
        //读取服务端返回的数据，使用socket读取流
        InputStream in = socket.getInputStream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        String text = new String(buf,0,len);
        System.out.println(text);

        //关闭资源
        socket.close();
    }
}

TCP练习-文本转换
client

package TCP;

import java.io.*;
import java.net.Socket;
import java.nio.Buffer;

//TCP协议 文本转换客户端
public class e1c {
    public static void main(String[] args) throws IOException {
        /**
         * 客户端输入数据发送给服务端
         * 服务端收到后显示到控制台，并将数据转成大写返回给客户端
         * 直到客户端输入over，转换结束
         *
         * 创建一个英文大写转换服务器
         *
         * 分析：有客户端和服务端，用TCP传输
         */
        /**
         * 客户端：
         * 1.需要socket断点
         * 2.客户端的数据源：键盘
         * 3.客户端的目的：socket
         * 4.接收服务端的数据，源：socket
         * 5.将数据显示在控制台
         * 6.在这些流中操作的数据都是文本数据。
         * 转换客户端：
         * 1.创建socket客户端对象
         * 2.获取键盘录入
         * 3.将录入信息发给socket输出流
         */
        //1.创建socket客户端对象
        Socket socket = new Socket("192.168.1.101",10000);
        //2.获取键盘录入
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        //3.socket输出流
//        new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        PrintWriter out = new PrintWriter(socket.getOutputStream(),true);//自动刷新
        //4.socket输入流，读取服务端返回的大写数据
        BufferedReader burIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String line = null;
        while ((line=bufr.readLine())!=null){
            if("over".equals(line)){
                break;
            }
            out.println(line);
            //读取服务端发回的一段大写数据
            String upperstr = burIn.readLine();
            System.out.println(upperstr);
        }
        socket.close();
    }
}

server

package TCP;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Locale;

public class e1s {
    public static void main(String[] args) throws IOException {
        /**
         * 转换服务端：
         * 分析：
         * 1.serversocket服务
         * 2.获取socket对象
         * 3.源：socket，读取客户端发过来需要转换的数据
         * 4.目的：显示在服务端控制台上，
         * 5.将数据转成大写发回客户端
         */
        //1.serversocket
        ServerSocket serverSocket = new ServerSocket(10000);
        //2.获取socket对象
        Socket socket = serverSocket.accept();
        //获取ip
        String ip = socket.getInetAddress().getHostAddress();
        System.out.println("ip:"+ip);
        //3.获取socket读取流，并装饰
        BufferedReader bufrIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        //4.获取输出流，并装饰
        PrintWriter out = new PrintWriter(socket.getOutputStream(),true);
        String line = null;
        while ((line=bufrIn.readLine())!=null){
            System.out.println(line);
            out.println(line.toUpperCase(Locale.ROOT));
        }
        serverSocket.close();
        socket.close();
    }
}

TCP练习-上传文本文件
客户端

package TCP;

import java.io.*;
import java.net.Socket;

public class uploadClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("192.168.1.101",10000);
        BufferedReader bufr = new BufferedReader(new FileReader("D:/ideas/VSCode/CppCode/JavaTest/demo/src/TCP/demo.txt"));
        PrintWriter out = new PrintWriter(socket.getOutputStream(),true);
        String line = null;
        while ((line=bufr.readLine())!=null){
            out.println(line);
        }
        //告诉服务端数据传输结束
//        out.println("over");//over容易与文件内容重复
        //告诉服务端客户端写完了
        socket.shutdownOutput();
        //4.读取
        BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        String str = bufIn.readLine();
        System.out.println(str);
        socket.close();
    }
}

服务器端

package TCP;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class uploadServer {
    public static void main(String[] args) throws IOException {
        //1.
        ServerSocket serverSocket = new ServerSocket(10000);
        Socket socket = serverSocket.accept();
        BufferedReader bufIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        BufferedWriter bufw = new BufferedWriter(new FileWriter("D:/ideas/VSCode/CppCode/JavaTest/demo/src/TCP/democ.txt"));
        String line = null;
        while ((line=bufIn.readLine())!=null){
//            if("over".equals(line))
//                break;
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }
        PrintWriter out = new PrintWriter(socket.getOutputStream(),true);
        out.println("收到");
        serverSocket.close();
        socket.close();
    }
}