（Java总结）C/S（客户端和服务器）、B/S（网页和服务器）

一时失言乱红尘 2023-06-13 09:57 5阅读 0赞

package Demo47;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    /**
     * TCP通信的客户端：向服务器发送链接请求，给服务器发送数据，读取服务器回写的数据
     * 表示客户端的类：
     *          java.net.Socket:此类实现客户端套接字，套接字是两台机器之间通信的端点
     *          套接字：包含了IP地址和端口号的网络单位
     *构造方法：
     *      Socket(String host, int port)创建一个流套接字并将其连接到指定的主机的指定端口号
     *      参数：
     *          String host:服务器主机的名称/服务器的IP地址
     *          int port:服务器的端口号
     *成员方法：
     *      OutputStream getOutputStream():返回此套接字的输出流
     *      InputStream getInputStream()：返回此套接字的输入流
     *      void close()关闭此套接字
     * 实现步骤：
     *      1、创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
     *      2、使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
     *      3、使用 网络字节输出流OutputStream对象的方法write,给服务器发送数据
     *      4、使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
     *      5、使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
     *      6、释放资源
     *注意：
     *      1、客户端和服务器进行交互，必须使用Socket中提供的网络流，不能使用自己曾经的流对象
     *      2、当我们曾经客户端对象Socket的时候，就会去请求服务器和服务器经过3次握手连接通路
     *          如果服务器没有启动，那么久会抛出异常
     *          启动就可以正常交互了
     */
    public class TCPClient {
        
        public static void main(String[] args) throws IOException {
        
            // 1、创建一个客户端对象Socket,构造方法绑定服务器的IP地址和端口号
            Socket socket = new Socket("127.0.0.1",8888);
            //2、使用Socket对象中的方法getOutputStream()获取网络字节输出流OutputStream对象
            OutputStream os = socket.getOutputStream();
            //3、使用 网络字节输出流OutputStream对象的方法write,给服务器发送数据
            os.write("你好服务器".getBytes());
            //4、使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
            InputStream is = socket.getInputStream();
            //5、使用网络字节输入流InputStream对象中的方法read,读取服务器回写的数据
            byte[] bytes = new byte[1024];
            int len = is.read(bytes);
            System.out.println(new String(bytes,0,len));
            //6、释放资源
            socket.close();
        }
    }

package Demo47;
    
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * TCP通信的服务器端：接受客户端的请求，读取客户端发送的数据，给客户端回写数据
     * 表示服务器的类：
     *      java.netServerSocket:此类实现服务器套接字
     * 构造方法：
     *      ServerSocket(int port)创建绑定到特定端口的服务器套接字
     *
     * 服务器端必须明确一件事情，必须知道是哪个特定端口的服务器套接字
     * 所以可以用accept方法获取到请求 的客户端对象Socket
     *
     * 成员方法：
     *      Socket accept() 侦听并接受套接字的连接
     *
     * 服务器的实现步骤：
     *      1、创建服务器ServerSocket对象和系统要指定的端口号
     *      2、使用serverSocket对象中的方法accept，获取到请求的客户端对象Socket
     *      3、使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
     *      4、使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
     *      5、使用Socket对象中的方法getOutStream()获取网络字节输出流OutputStream对象
     *      6、使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
     *      7、释放资源(Socket,ServerSocket)
     *
     */
    public class TCPServer {
        
        public static void main(String[] args) throws IOException {
        
            //1、创建服务器ServerSocket对象和系统要指定的端口号
            ServerSocket server = new ServerSocket(8888);
            //2、使用serverSocket对象中的方法accept，获取到请求的客户端对象Socket
            Socket socket = server.accept();
            //3、使用Socket对象中的方法getInputStream()获取网络字节输入流InputStream对象
            InputStream is = socket.getInputStream();
            //4、使用网络字节输入流InputStream对象中的方法read，读取客户端发送的数据
            byte[] bytes = new byte[1024];
            int len = is.read(bytes);
            System.out.println(new String(bytes,0,len));
            //5、使用Socket对象中的方法getOutStream()获取网络字节输出流OutputStream对象
            OutputStream os = socket.getOutputStream();
            //6、使用网络字节输出流OutputStream对象中的方法write，给客户端回写数据
            os.write("收到，谢谢".getBytes());
            //7、释放资源(Socket,ServerSocket)
            socket.close();
            server.close();
        }
    }

package Demo47;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.InputStream;
    import java.io.OutputStream;
    import java.net.Socket;
    
    /**
     * 文件上传案例的客户端：
     *         读取本地文件，上传到服务器，读取服务器回写的数据
     *  明确：
     *     数据源：E:\hadoop\testfile\\ceshi.jpg
     *  实现步骤：
     *         1、创建有一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
     *         2、创建一个客户端Socket对象，构造方法中绑定服务器的Ip和端口号
     *         3、使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
     *         4、使用本地字节输入流FileInputStream对象在的方法read，读取本地文件
     *         5、使用Socket中的方法getInputStream的方法write,把读取到的文件上传到服务器
     *         6、使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
     *         7、使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
     *         8、释放资源(FIleInputStream,Socket)
     */
    public class TCPClient1 {
        
        public static void main(String[] args) throws Exception {
        
            //1、创建有一个本地字节输入流FileInputStream对象，构造方法中绑定要读取的数据源
            FileInputStream fil = new FileInputStream("E:\\hadoop\\testfile\\ceshi.jpg");
    
            //2、创建一个客户端Socket对象，构造方法中绑定服务器的Ip和端口号
            Socket socket = new Socket("127.0.0.1",8888);
    
            //3、使用Socket中的方法getOutputStream，获取网络字节输出流OutputStream对象
            OutputStream os = socket.getOutputStream();
    
            //4、使用本地字节输入流FileInputStream对象在的方法read，读取本地文件
            int len = 0;
            byte[] bytes = new byte[1024];
            while ((len = fil.read(bytes))!=-1){
        
                //5、使用Socket中的方法getInputStream的方法write,把读取到的文件上传到服务器
                os.write(bytes,0,len);
            }
    
            /*
            解决程序运行无法结束的问题
                上传完文件，给服务器一个结束标记
                void shutdownOutput()禁用此套接字的输出流
                对于TCP套接字，任何以前写入的数据都将被发送，并且后跟TCP的正常连接终止序列
             */
            socket.shutdownOutput();
    
            //6、使用Socket中的方法getInputStream，获取网络字节输入流InputStream对象
            InputStream is = socket.getInputStream();
    
    
            while ((len = is.read(bytes))!=-1){
        
            //7、使用网络字节输入流InputStream对象中的方法read读取服务器回写的数据
                System.out.println(new String(bytes,0,len));
            }
            //8、释放资源(FIleInputStream,Socket)
            fil.close();
            socket.close();
        }
    }

package Demo47;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Random;
    
    /**
     * 文件上传案列服务器端，读取客户端上传的文件。保存到服务器的硬盘，给客户端回写上传成功
     * 明确：
     *      数据源：客户端上传的文件
     *      目的地：服务器的硬盘：E:\hadoop\testfile\testfile1\\ceshi.jpg
     *
     * 实现步骤：
     *      1、创建一个ServerSocket对象，和系统指定的端口号
     *      2、使用ServerSocket对象中的方法accept，获取带请求的客户端Socket对象
     *      3、使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
     *      4、判断E:\hadoop\testfile\testfile1文件夹是否存在，不存在则创建
     *      5、创建一个本地字节输出流FileOutputStream对象，构造方法中药绑定输出的目的地
     *      6、使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
     *      7、使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
     *      8、使用Socket对象中的方法getOutputStream。获取到网络字节输出流OutputStream对象
     *      9、使用网络字节输出流OutputStream对象在的方法write，给客户端回写上传成功
     *      10、释放资源(FileOutputStream，Socket，ServerSocket)
     */
    public class TCPServer1 {
        
        public static void main(String[] args) throws IOException {
        
            // 1、创建一个ServerSocket对象，和系统指定的端口号
            ServerSocket server = new ServerSocket(8888);
            while (true) {
        
                // 2、使用ServerSocket对象中的方法accept，获取到请求的客户端Socket对象
                Socket socket = server.accept();
                /*
                使用多线程技术，提高程序的效率
                有一个客户端上传文件，就开启一个线程，完成文件的上传
                 */
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        try {
        
    
                            // 3、使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
                            InputStream is = socket.getInputStream();
                            // 4、判断E:\hadoop\testfile\testfile1文件夹是否存在，不存在则创建
                            File file = new File("E:\\hadoop\\testfile\\testfile1");
                            if (!file.exists()) {
        
                                file.mkdir();
                            }
                            //自定义一个文件的命名规则：防止同名的文件夹被覆盖
                            //规则：域名 + 毫秒值 + 随机数
                            String fileName = "itcat" + System.currentTimeMillis() + new Random().nextInt(9999) + ".jpg";
    
                            // 5、创建一个本地字节输出流FileOutputStream对象，构造方法中药绑定输出的目的地
                            FileOutputStream fos = new FileOutputStream(file + "\\" + fileName);
                            // 6、使用网络字节输入流InputStream对象中的方法read，读取客户端上传的文件
                            int len = 0;
                            byte[] bytes = new byte[1024];
                            while ((len = is.read(bytes)) != -1) {
        
                                // 7、使用本地字节输出流FileOutputStream对象中的方法write，把读取到的文件保存到服务器的硬盘上
                                fos.write(bytes, 0, len);
                            }
                            // 8、使用Socket对象中的方法getOutputStream。获取到网络字节输出流OutputStream对象
                            OutputStream os = socket.getOutputStream();
                            // 9、使用网络字节输出流OutputStream对象在的方法write，给客户端回写上传成功
                            os.write("收到".getBytes());
                            // 10、释放资源(FileOutputStream，Socket，ServerSocket)
                            fos.close();
                            socket.close();
    
                        } catch (IOException e) {
        
                            System.out.println(e);
                        }
                    }
    
                }).start();
    
                //一直循环就不用关闭流了
                //server.close();
            }
        }
    }

package Demo48;
    
    import java.io.*;
    import java.net.ServerSocket;
    import java.net.Socket;
    
    /**
     * 创建BS版本的服务器
     */
    public class TCPServer {
        
        public static void main(String[] args) throws IOException {
        
            //创建一个服务器ServerSocket，和系统要指定的端口号
            ServerSocket server = new ServerSocket(8080);
            //浏览器解析服务器回写的html，页面中如果有图片，那么浏览器就会单独开启一个线程，读取服务器的图片
            //我们就让服务器一直处于监听状态，客户端请求一次，服务器就回写一次
            while (true) {
        
                //使用accept方法回去到请求的客户端对象
                Socket socket = server.accept();
                new Thread(new Runnable() {
        
                    @Override
                    public void run() {
        
                        try {
        
                            //使用Socket对象中的方法getInputStream，获取到网络字节输入流InputStream对象
                            InputStream is = socket.getInputStream();
                            //使用网络字节输入流InputStream对象中的方法read读取客户端的请求信息
    //        byte[] bytes = new byte[1024];
    //        int len = 0;
    //        while ((len = is.read(bytes))!=-1){
        
    //            System.out.println(new String(bytes,0,len));
    //        }
    
                            //把is网络字节输入流对象转换为字符缓冲输入流
                            BufferedReader br = new BufferedReader(new InputStreamReader(is));
    
                            //把客户端请求信息的第一行读取出来，
                            String line = br.readLine();
    
                            //把读取的信息进行切割，只要中间部分
                            String[] arr = line.split(" ");
    
                            //把路径前边的/去掉，进行截取
                            String htmlPath = arr[1].substring(1);
    
                            //创建一个本地字节输入流，构造方法中绑定要读取的html的路径
                            FileInputStream fls = new FileInputStream(htmlPath);
    
                            //使用Socket中的方法getOutputStream获取网络字节输出流OutputStream对象
                            OutputStream os = socket.getOutputStream();
    
                            //写入HTTP协议的响应头，固定写法
                            os.write("HTTP/1.1 200 OK\r\n".getBytes());
                            os.write("Connect-Type:text/html\r\n".getBytes());
    
                            //必须要写入空行，否则浏览器不解析
                            os.write("\r\n".getBytes());
    
                            //一读一写复制文件，把服务器读取的html文件回写到客户端
                            int len = 0;
                            byte[] bytes = new byte[1024];
                            while ((len = fls.read()) != -1) {
        
                                os.write(bytes, 0, len);
                            }
                            //释放资源
                            fls.close();
                            socket.close();
                        } catch (IOException e) {
        
                            System.out.println(e);
                        }
                    }
                }).start();
    
                //
                //server.close();
            }
        }
    }