10.网络编程-CSDN博客

本文链接：https://blog.csdn.net/m0_71369720/article/details/141713137

1.InetAddress类

1.获取本机InetAddress对象 getLocalHost
2.根据指定主机名/域名获取ip地址对象 getByName
3.获取InetAddress对象的主机名 getHostName
4.获取InetAddress对象的地址 getHostAddress

public class API_ {
    public static void main(String[] args) throws UnknownHostException {
        //1.获取本机InetAddress 对象 getLocalHost
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);//DESKTOP-9SHT7OS/192.168.86.20(主机名/域名)

        //2.根据指定(主机名)获取ip地址对象 getByName
        InetAddress byName1 = InetAddress.getByName("DESKTOP-9SHT7OS");
        System.out.println(byName1);//DESKTOP-9SHT7OS/192.168.86.20

        //3.根据指定(域名)获取对象InetAddress getByName,比如 www.baidu.com()域名
        InetAddress byName2 = InetAddress.getByName("www.baidu.com");
        System.out.println(byName2);//www.baidu.com/110.242.68.3

        //4.通过InetAddress 对象获取对应的地址 getHostAddress
        String hostAddress = byName2.getHostAddress();//110.242.68.3
        System.out.println(hostAddress);

        //5.通过InetAddress 对象获取对应的主机名或域名
        String hostName = byName2.getHostName();
        System.out.println(hostName);//www.baidu.com


    }
}

2.Socket

1.套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准通信的两端都要有Socket，是两台机器间通信的端点
3.网络通信其实就是Socket间的通信。
4.Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输
5.一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

Socket理解：TCP编程和UDP编程

TCP网络编程：当客户端连接到服务端后，实际上客户端也是通过一个端口和服务端进行通讯的，这个端口是TCP/IP 来分配的

(了解)UDP1网络编程：
1.没有明确的服务端，客户端(只有接收端和发送端)
2.接收和发送数据通过Datagramsocket 对象，可以指定端口
3.数据封装到DatagramPacket 对象
4.接收到DatagramPacket 对象需要拆包，取出数据

3.netstat

1.netstat -an 可以查看当前主机网络情况，包括端口监听情况和网络连接情况
2.netstat -an l more 可以分页显示(竖杆)，输入空格显示下一页
3.要求在dos控制台下执行

4.练习

4.1

TCP网络通信编程(使用字节流)
1.编写一个服务器端,和一个客户端
2.服务器端在 9999端口监听
3.客户端连接到服务器端，发送“hello”，然后退出
4.服务器端接收到客户端发送的信息，输出，并退出

客户端思路：
1.连接服务端(ip，端口)
2.连接上后，生成Socket, 通过socket.getOutputStream)
3.通过输出流，写入数据到数据通道

服务端思路：
1.在本机的9999端口监听,等待连接
2.当没有客户端连接9999端口时，程序阻塞，等待连接
3.通过socket.getlnputStream0 读取客户端写入到数据通道的数据,显示

/**
 * @author qhx
 * @version 1.0
 * 服务端
 */
public class SocketServer {
    public static void main(String[] args) throws IOException {
        //1.在本机 的9999端口监听,等待连接
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.当没有客户端连接9999端口时，程序阻塞，等待连接
        //如果客户端连接，则会返回Socket 对象，程序继续
        Socket socket = serverSocket.accept();
        //3.通过socket.getlnputStream0 读取客户端写入到数据通道的数据,显示
        InputStream inputStream = socket.getInputStream();
        //4.IO读取
        byte[] buf =new byte[1024];
        int readlen=0;
        while ( (readlen=inputStream.read(buf))!=-1 ){
            System.out.println(new String(buf,0,readlen));
        }
        //5.关闭
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @author qhx
 * @version 1.0
 * 客户端
 */
public class SocketClient_ {
    public static void main(String[] args) throws IOException {
        //1.连接服务端(ip，端口)
        Socket socket=new Socket(InetAddress.getLocalHost(),9999);
        //2.连接上后，生成Socket, 通过socket.getOutputStream)
        //得到和socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据到 数据通道
        outputStream.write("hello".getBytes());
        //4.关闭
        outputStream.close();
        socket.close();

    }
}

4.2

TCP网络通信编程(使用字节流)

1.编写一个服务端,和一个客户端
2.服务器端在 9999端口监听
3.客户端连接到服务端，发送“hello”,并接收服务器端回发的"hi”再退出
服务器端接收到客户端发送的信息，输出，并发送“hello”,再退出

设置标志：输出结束后设置结束标志

/**
 * @author qhx
 * @version 1.0
 * 服务端
 */
public class SocketServer02 {
    public static void main(String[] args) throws IOException {
        //1.在本机 的9999端口监听,等待连接
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.当没有客户端连接9999端口时，程序阻塞，等待连接
        //如果客户端连接，则会返回Socket 对象，程序继续
        Socket socket = serverSocket.accept();
        //3.通过socket.getlnputStream0 读取客户端写入到数据通道的数据,显示
        InputStream inputStream = socket.getInputStream();
        //设置结束标记

        //4.IO读取
        byte[] buf =new byte[1024];
        int readlen=0;
        while ( (readlen=inputStream.read(buf))!=-1 ){
            System.out.println(new String(buf,0,readlen));
        }
        //5.获取socket 相关的输入流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hi".getBytes());
        socket.shutdownOutput();
        //6.关闭
        inputStream.close();
        outputStream.close();
        socket.close();
        serverSocket.close();
    }
}

/**
 * @author qhx
 * @version 1.0
 * 客户端
 */
public class SocketClient02 {
    public static void main(String[] args) throws IOException {
        //1.连接服务端(ip，端口)
        Socket socket=new Socket(InetAddress.getLocalHost(),9999);
        //2.连接上后，生成Socket, 通过socket.getOutputStream)
        //得到和socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据到 数据通道
        outputStream.write("hello".getBytes());
        //设置结束标记
        socket.shutdownOutput();
        //4.获取和socket 关联的输入流，读取数据并显示
        InputStream inputStream = socket.getInputStream();
        byte[] buf =new byte[1024];
        int readlen=0;
        while ( (readlen=inputStream.read(buf))!=-1 ){
            System.out.println(new String(buf,0,readlen));
        }

        //5.关闭
        inputStream.close();
        outputStream.close();
        socket.close();

    }
}

4.3

TCP网络通信编程(使用字节流)

1.编写一个服务端,和一个客户端
2.服务器端在 9999端口监听
3.客户端连接到服务端，发送“hello”,并接收服务器端回发的"hi”再退出
服务器端接收到客户端发送的信息，输出，并发送“hello”,再退出

/**
 * @author qhx
 * @version 1.0
 * 客户端
 */
public class SocketClient03 {
    public static void main(String[] args) throws IOException {
        //1.连接服务端(ip，端口)
        Socket socket=new Socket(InetAddress.getLocalHost(),9999);
        //2.连接上后，生成Socket, 通过socket.getOutputStream)
        //得到和socket 对象关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据到 数据通道
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello字符流");
        bufferedWriter.newLine();//插入换行符，表示写入结束,并且要求对方使用readLine()
        bufferedWriter.flush();//使用的字符流要手动刷新，否则数据不会写入

        //4.获取和socket 关联的输入流，读取数据并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s=bufferedReader.readLine();//按行读取
        System.out.println(s);

        //5.关闭
        bufferedWriter.close();//转换这个是关闭外层流
        bufferedReader.close();
        socket.close();


    }
}

/**
 * @author qhx
 * @version 1.0
 * 服务端
 */
public class SocketServer03 {
    public static void main(String[] args) throws IOException {
        //1.在本机 的9999端口监听,等待连接
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.当没有客户端连接9999端口时，程序阻塞，等待连接
        //如果客户端连接，则会返回Socket 对象，程序继续
        Socket socket = serverSocket.accept();
        //3.通过socket.getlnputStream0 读取客户端写入到数据通道的数据,显示
        InputStream inputStream = socket.getInputStream();

        //4.IO读取,使用字符流,用inputstreamReader 将 inputstream 转成字符流
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s=bufferedReader.readLine();//按行读取
        System.out.println(s);
        //5.获取socket 相关的输出流
        OutputStream outputStream = socket.getOutputStream();
        //使用字符流的方式回复
        BufferedWriter bufferedWriter=new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hi");
        bufferedWriter.newLine();//插入换行符，表示回复结束
        //6.关闭
        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
        serverSocket.close();
    }
}

4.4

1.编写一个服务端,和一个客户端

2.服务器端在 8888端口监听
3客户端连接到服务端，发送一张图片 D: xiao.jpg
4.服务器端接收到客户端发送的图片，保存到 src下发送“收到图片”再退出
5.客户端接收到服务端发送的“收到图片”，再退出
6.该程序要求使用 StreamUtils.java

/**
 * @author qhx
 * @version 1.0
 * 客户端
 */
public class TCPClient {
    public static void main(String[] args) throws Exception {
        //客户端连接服务端，得到Socket 对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
        //创建读取磁盘文件的输入流
        String filepath="D:\\xiao.jpg";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filepath));

        //bytes 就是filepath对应的字节数组
        byte[]bytes=StreamUtils.streamToByteArray(bis);

        //通过socket获取输出流，将bytes发送给服务端
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//把数据写入通道
        bis.close();
        socket.shutdownOutput();//结束标记

        //接收从服务端回复的消息
        InputStream inputStream = socket.getInputStream();
        //使用方法，把输入流读取到的，转成字符串
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);

        //关闭
        bos.close();
        socket.close();

    }
}

/**
 * @author qhx
 * @version 1.0
 * 服务端
 */
public class TCPServer {
    public static void main(String[] args) throws Exception {
        //1服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        //2.等待连接
        Socket accept = serverSocket.accept();
        //3.读取客户端发送的数据
        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
        byte[]bytes=StreamUtils.streamToByteArray(bis);//把bis里的数据放到数组

        //4.将得到的bytes 数组写入指定路径，就得到了一个文件
        String destpath ="src\\xiao1.jpg";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destpath));
        bos.write(bytes);
        bos.close();

        //向客户端回复“收到图片”
        //通过socket 获取输出流(字符)
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
        writer.write("收到图片");
        writer.flush();//刷新
        accept.shutdownOutput();//设置结束标记

        //关闭其他资源
        bis.close();
        accept.close();
        serverSocket.close();
    }
}

import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.InputStream;
public class StreamUtils {
    //功能：将输入流转换成byte[]
    public static byte[] streamToByteArray(InputStream is) throws Exception{
        ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
        byte[] b = new byte[1024];
        int len;
        while((len=is.read(b))!=-1) {
            bos.write(b, 0, len);
        }
        byte[] array = bos .toByteArray();
        bos .close();
        return array;
    }

    //功能：把InputStream转换成String
    public static String streamToString(InputStream is) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(is));
        StringBuilder builder = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            builder.append(line + "\r\n");
        }
        return builder.toString();
    }
}

4.5

/**
 * @author qhx
 * @version 1.0
 * 发送端
 */
public class UDPSender {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket 对象,准备在9999端口接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        //2.将要发送的数据封装到DatagramPacket 对象
        byte[]data="hello".getBytes();
        //封装的内容:数组，长度，主机ip，端口
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.12.1"),9999);
        socket.send(packet);
        
        //3.接收
        byte[]buf=new byte[1024];
        packet=new DatagramPacket(buf, buf.length);
        socket.receive(packet);
        int length=packet.getLength();
        data=packet.getData();//读取数据
        String s=new String(data,0,length);
        System.out.println(s);
        //4.关闭
        socket.close();
        
    }
}

/**
 * @author qhx
 * @version 1.0
 * 接收端
 */
public class UDPReceiver {
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket 对象,准备在9998端口接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2.创建一个DatagramPacket 对象接收数据包
        byte[]buf=new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf,buf.length);//空的
        //3.调用接收方法，接收数据包
        socket.receive(packet);//有数据就接收，没有就阻塞
        //4.取出数据包的数据
        int length=packet.getLength();//实际数据长度
        byte[]data=packet.getData();//读取数据
        String s=new String(data,0,length);
        System.out.println(s);

        //5.发送数据
        data="好的".getBytes();
        packet = new DatagramPacket(data, data.length, InetAddress.getByName("192,168.12.1"), 9998);
        socket.send(packet);
        //6.关闭
        socket.close();

    }
}

4.6

1.客户端发送"name"和"hobby"

2.服务端接收问题，如果是name返回"我是XXX"，如果是hobby，返回“我爱编程"，其他问题返回我不知道

/**
 * @author qhx
 * @version 1.0
 * 客户端
 */
public class TCPClinet {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        //从键盘读取用户数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入问题");
        String question=scanner.next();

        bufferedWriter.write(question);
        bufferedWriter.newLine();
        bufferedWriter.flush();

        bufferedWriter.close();
        socket.close();
    }
}

public class TCPServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s= bufferedReader.readLine();//按行读取
        String answer="";

        if ("name".equals(s)){
            answer="qwq";
        }else if("hobby".equals(s)){
            answer="编写java程序";
        }else {
            answer="你说什么";
        }
        OutputStream outputStream = socket.getOutputStream();
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write(answer);
        bufferedWriter.newLine();
        bufferedWriter.flush();

        bufferedWriter.close();
        bufferedReader.close();
        socket.close();
    }
}

4.7

1.客户端发送"高山流水"或其他内容

2.服务端接收客户端发送的内容，如果是高山流水返回"高山流水.mp3"文件，否则返回"无名.mp3"文件

3.客户端接收服务端发送的文件，并保存到磁盘

public class TCPClinet01 {
    public static void main(String[] args) throws Exception {
        //1.输入
        Scanner scanner = new Scanner(System.in);
        System.out.println("输入文件名：");
        String downName=scanner.next();
        //2.连接服务端
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
        //3.获取socket输出流,发送文件名字
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(downName.getBytes());
        //4.获取输入流，读取文件(字节数据)
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //5.把文件写到磁盘
        String filePath="D://"+downName+".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);
        //6.关闭
        bos.close();
        bis.close();
        socket.close();
        outputStream.close();
    }
}

/**
 * @author qhx
 * @version 1.0
 * 服务端
 */
public class TCPServer01 {
    public static void main(String[] args) throws Exception {
        //接收客户端要的文件名
        //1.监听9999端口
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.等待连接
        Socket socket = serverSocket.accept();
        //3.读取文件名
        InputStream inputStream = socket.getInputStream();
        byte[]bytes=new byte[1024];
        int len=0;
        String filename="";
        while ((len=inputStream.read())!=-1){
            filename+=new String(bytes,0,len);//读取到的文件名
        }
        System.out.println("客户端发送的文件名："+filename);
        //4.比较文件名，src下面有"高山流水.mp3"和"无名.mp3"
        String readname="";//返回文件的名字
        if ("高山流水".equals(filename)){
            readname="src\\高山流水.mp3";
        }else {
            readname="src\\无名.mp3";
        }
        //5.创建输入流读取src文件
        BufferedInputStream bim = new BufferedInputStream(new FileInputStream(readname));
        //6.使用工具类StremUtils,把文件--->数组
        bytes=StreamUtils.streamToByteArray(bim);
        //7.获取输出流
        BufferedOutputStream bom = new BufferedOutputStream(socket.getOutputStream());
        //8.把数据写到socket通道
    }
}