Java高级Day36-网络编程

104.网络的相关概念

IP表示：对于IPV4 4个字节（32）表示，1个字节的范围是0~255

IP组成=网络地址 + 主机地址

IPV6用128位

域名：通过HTTP协议，将ip地址映射成域名

端口号：用于标识计算机上某个特定的网络程序

可以这么理解，通过IP+端口，可以找到确定网站的确定服务

网络通信协议：数据在网络编程中，数据的组织形式就是协议

可以这么理解：人和人交流依靠语言，汉语，日语，英语，这本身就是一种协议

TPC/IP：传输控制协议/因特网互联协议

接收方再一层层的拆包，得到最终的用户数据

105.TCP和UDP

106.InetAddress类

相关方法：

• 获取本机InetAddress对象 getLocalHost

• 根据指定主机名/域名获取ip地址对象 getByName

• 获取InetAddress对象的主机名 getHostName

• 获取InetAddress对象的地址 getHostAddress

107.Socket

基本介绍：

1. 套接字开发网络应用程序被广泛采用，以至于成为事实上的标准

2. 通信的两端都要有Socket，是两台机器间通信的端点

3. 网络通信其实就是Socket间的通信

4. Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输

5. 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端

107.TCP编程

字节流编程

//使用字节流完成编程
//1.编写一个服务器端和客户端
//2.服务器端在9999端口监听
//3.客户端连接到服务器端，发送“hello,server”，然后退出
//4.服务器端接收到 客户端发送的信息，输出，并退出
​
===================//服务器端//=====================
public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        //1.在本机的 9999端口 监听，等待连接
        //  细节：要求在本机没有其他服务在监听9999
        //  细节：这个 ServerSocket 可以通过accpet() 返回多个Socket[多并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        //2.当没有客户端连接9999端口时，程序会 阻塞，等待连接
        //  如果有客户端连接，则会返回Socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务器端 socket =" + socket.getClass());
​
        //3.通过socket.getInputStream() 读取客户端写入到数据通道的数据，显示
        InputStream inputStream = socket.getInputStream();
        //4.IO读取
        byte[] buf = new byte[1024];
        int readLine = 0;
        while ((readLine = inputStream.read(buf)) != -1){
            System.out.println(new String(buf,0,readLine));//根据读取到的实际长度，显示内容
        }
        //5.关闭流和socket
        inputStream.close();
        socket.close();
        serverSocket.close();
    }
}
​
​
​
===================//客户器端//=====================
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1.连接服务端（ip，端口）
        //解读：连接本机的 9999端口，如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);//因为在本机监听，所以用LocalHost
        System.out.println("客户端 socket返回=" + socket.getClass());
        //2.连接上后，生成Socket，通过socket.getOutputStream()
        //  得到 和 socket关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据 到 数据通道
        outputStream.write("hello,server".getBytes());
        //4.关闭流对象和socket，必须关闭
        outputStream.close();
        socket.close();
        System.out.println("客户端退出了");
    }
}

应用案例2

//1.编写一个服务器端和一个客户端
//2.服务器端在9999端口监听
//3.客户端连接到服务器端，发送“hello，server”并接收到服务器端回发的“hello，client”再退出
//4.服务器端接收到客户端发送的信息，输出，并发送“hello，client”再退出
​
===================//服务器端//=====================
public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        //1.在本机的 9999端口 监听，等待连接
        //  细节：要求在本机没有其他服务在监听9999
        //  细节：这个 ServerSocket 可以通过accpet() 返回多个Socket[多并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        //2.当没有客户端连接9999端口时，程序会 阻塞，等待连接
        //  如果有客户端连接，则会返回Socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务器端 socket =" + socket.getClass());
​
        //3.通过socket.getInputStream() 读取客户端写入到数据通道的数据，显示
        InputStream inputStream = socket.getInputStream();
        //4.IO读取
        byte[] buf = new byte[1024];
        int readLine = 0;
        while ((readLine = inputStream.read(buf)) != -1){
            System.out.println(new String(buf,0,readLine));//根据读取到的实际长度，显示内容
        }
        //5.获取socket相关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write("hello,client".getBytes());
        socket.shutdownOutput();//结束标记
        //6.关闭流和socket
        inputStream.close();
        socket.close();
        serverSocket.close();
        outputStream.close();
        System.out.println("服务器端退出了");
    }
}
​
​
​
===================//客户器端//=====================
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1.连接服务端（ip，端口）
        //解读：连接本机的 9999端口，如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);//因为在本机监听，所以用LocalHost
        System.out.println("客户端 socket返回=" + socket.getClass());
        //2.连接上后，生成Socket，通过socket.getOutputStream()
        //  得到 和 socket关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据 到 数据通道
        outputStream.write("hello,server".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.关闭流对象和socket，必须关闭
        outputStream.close();
        socket.close();
        inputStream.close();
        System.out.println("客户端退出了");
    }
}

字符流编程

//1.编写一个服务器端和客户端
//2.服务端在9999端口监听
//3.客户端连接到服务器，发送“hello,server”并接收到服务器端回发的“hello，client”再退出
//4.服务端接收到 客户端发送的信息，输出，并发送“”hello，client“再退出
​
​
===================//服务器端//=====================
public class SocketTCP01Server {
    public static void main(String[] args) throws IOException {
        //1.在本机的 9999端口 监听，等待连接
        //  细节：要求在本机没有其他服务在监听9999
        //  细节：这个 ServerSocket 可以通过accpet() 返回多个Socket[多并发]
        ServerSocket serverSocket = new ServerSocket(9999);
        System.out.println("服务端，在9999端口监听，等待连接...");
        //2.当没有客户端连接9999端口时，程序会 阻塞，等待连接
        //  如果有客户端连接，则会返回Socket对象，程序继续
        Socket socket = serverSocket.accept();
        System.out.println("服务器端 socket =" + socket.getClass());
​
        //3.通过socket.getInputStream() 读取客户端写入到数据通道的数据，显示
        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("hello,client 字符流");
        bufferedWriter.newLine();//插入换行流，表示回复内容结束
        bufferedWriter.flush();//需要手动刷新
        //6.关闭流和socket
        bufferedWriter.close();
        socket.close();
        serverSocket.close();
        bufferedReader.close();
        System.out.println("服务器端退出了");
      
        }   
 }     
===================//服务器端//=====================
public class SocketTCP01Client {
    public static void main(String[] args) throws IOException {
        //1.连接服务端（ip，端口）
        //解读：连接本机的 9999端口，如果连接成功，返回Socket对象
        Socket socket = new Socket(InetAddress.getLocalHost(), 9999);//因为在本机监听，所以用LocalHost
        System.out.println("客户端 socket返回=" + socket.getClass());
        //2.连接上后，生成Socket，通过socket.getOutputStream()
        //  得到 和 socket关联的输出流对象
        OutputStream outputStream = socket.getOutputStream();
        //3.通过输出流，写入数据 到 数据通道，使用字符流
        BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
        bufferedWriter.write("hello,server 字符流");
        bufferedWriter.newLine();//插入一个换行符，表示写入结束，注意：要求对方使用readLine()
        bufferedWriter.flush();//如果使用字符流，需要手动刷新，否则数据不会写入数据通道
        //  设置写入结束标记
        socket.shutdownOutput();
​
        //4.获取和socket相关联的输入流，读取数据并显示
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        String s = bufferedReader.readLine();
        System.out.println(s);
​
        //5.关闭流对象和socket，必须关闭
        outputStream.close();
        socket.close();
        bufferedReader.close();//关闭外层流
        System.out.println("客户端退出了");
    }
}

108.网络上传文件

//1.编写一个服务端和客户端
//2.服务器端在8888端口监听
//3.客户端连接到服务器端，发送一张照片 e:\\qie.png
//4.服务器端接收到客户端发送的图片，保存到src下，发送”收到图片“
//5.客户端接收到服务端发送的”收到图片“再退出
//6.该程序要求使用StreamUtils.java
​
===============//服务器端//===============
public class SocketTCP01Server {
    public static void main(String[] args) throws Exception {
        //1.服务端在本机监听8888端口
        ServerSocket serverSocket = new ServerSocket(8888);
        System.out.println("服务端在8888端口监听...");
        //2.等待连接
        Socket socket = serverSocket.accept();
        //3.读取客户端发送的数据
        //  通过Socket得到输入流
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        byte[] bytes = streamToByteArray(bis);
        //4.将得到bytes数组，写入到指定的路径，就得到一个文件
        String destFilePath = "s\\qie2.png";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
        bos.write(bytes);
        bos.close();
        //向客户端回复收到图片
        //通过socket获得输出流
        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
        writer.write("收到信息");
        writer.flush();
        socket.shutdownOutput();
        
        //关闭其他资源
        writer.close();
        bis.close();
        socket.close();
        serverSocket.close();
    }
    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);//把读取到的数据，写入bos
        }
        byte[] array = bos.toByteArray();//然后将bos转成字节数组
        bos.close();
        return array;
    }
}
​
​
===============//客户端//===============
public class SocketTCP01Client {
    public static void main(String[] args) throws Exception {
        //1.创建客户端，得到Socekt对象
        Socket socket = new Socket(InetAddress.getLocalHost(),8888);
        //2.创建读取磁盘文件的输入流
        String filePath = "e:\\qie.png";
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
        //3.bytes就是filePath对应的字节数组
        byte[] bytes = streamToByteArray(bis);
        //4.通过socket获取到输出流，将bytes数据发送给服务器
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        bos.write(bytes);//将文件对应的字节数组，写入数据通道
        bis.close();
        socket.shutdownOutput();//设置写入数据的结束标记
        //接收从服务端回复的信息
        InputStream inputStream = socket.getInputStream();
        //使用StreamUtils的方法，将inputStream读取到的内容转换成String
        String s = StreamUtils.streamToString(inputStream);
        System.out.println(s);
        
        //关闭相关的流
        inputStream.close();
        bos.close();
        socket.close();
    }
    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);//把读取到的数据，写入bos
        }
        byte[] array = bos.toByteArray();//然后将bos转成字节数组
        bos.close();
        return array;
    }
}