Java——网络编程练习

练习一(黑马程序员面试题)：客户端向服务器写字符串(键盘录入)，服务器(多线程)将字符串反转后写回，客户端再次读取到的是反转后的字符串

相关代码如下：

package com.wsq.test;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Test1_Client {
/**
 * 客户端向服务器写字符串(键盘录入)，服务器(多线程)将字符串反转后写回，客户端再次读取到的是反转后的字符串
 * @throws IOException 
 * @throws UnknownHostException 
 * 
 * 
 * */
    public static void main(String[] args) throws UnknownHostException, IOException {
        Scanner sc = new Scanner(System.in);            //创建键盘录入对象
        Socket wsq = new Socket("192.168.1.182",1014);  //创建Socket客户端，指定IP地址和端口号(不超过65535即可)

        BufferedReader br = new BufferedReader(new InputStreamReader(wsq.getInputStream()));        //获取输入流
        PrintStream ps = new PrintStream(wsq.getOutputStream());            //获取输出流
        //对getInputStream()和getOutputStream()进行包装


        ps.println(sc.nextLine());                                      //客户端将字符串(键盘录入)写到服务器去
        System.out.println(br.readLine());                              //将反转后的结果读出来

        wsq.close();                            //只需要关Socket就行(wsq是Socket对象)
        //public void close()throws IOException 
        //关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。 
        //也就是说，只要把Socket关闭，InputStream和OutputStream也会关闭

    }

}

package com.wsq.test;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Test2_Server {

    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(1014);//创建多线程服务器
        //public ServerSocket(int port)throws IOException创建绑定到特定端口的服务器套接字。端口 0 在所有空闲端口上创建套接字。
        //参数：port - 端口号；或者为 0，表示使用任何空闲端口。 



        System.out.println("服务器已启动，已绑定1014端口");//输出一句提示语句

        while(true){                                //不断地接收客户端的请求
            final Socket wsq = server.accept();     //接收客户端的请求
            //public Socket accept()throws IOException侦听并接受到此套接字的连接。
            //返回：新套接字 
            //匿名内部类所用到的局部变量必须被final修饰
            new Thread(){                           //运用匿名内部类，来开启一条线程
                public void run(){                  //重写Thread()这个(线程)抽象类里面的run方法
                    try {
                        BufferedReader br = new BufferedReader(new InputStreamReader(wsq.getInputStream()));        //获取输入流
                        PrintStream ps = new PrintStream(wsq.getOutputStream());        //获取输出流
                        //客户端将内容给发送到服务端
                        //再对getInputStream()和getOutputStream()方法进行包装


                        String line = br.readLine();            //将客户端写过来的数据读取出来
                        line = new StringBuilder(line).reverse().toString();    //链式编程
                        //line = new StringBuilder(line)先把line封装成一个StringBuilder对象，变成一个缓冲区 
                        //再.reverse(),进行反转(倒序)
                        //然后再.toString()将数据转化成字符串

                        ps.println(line);                       //把反转后的内容给写回去，然后再在Client(客户端)把写出来的数据给读出来
                        //服务端进行将客户端发送的数据进行给读写出来


                        wsq.close();                            //只需要关Socket就行(wsq是Socket对象)
                        //public void close()throws IOException 
                        //关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。 
                        //也就是说，只要把Socket关闭，InputStream和OutputStream也会关闭

                    } catch (Exception e) {

                        e.printStackTrace();
                    }

                }
            }.start();
        }

    }

}

练习二(黑马程序员面试题)：客户端向服务器上传文件

相关步骤如下：
 * 1，提示输入要上传的文件路径，验证路径是否存在以及是否是文件夹
 * 2，发送文件名到服务器
 * 3，建立多线程的服务器
 * 4，读取文件名
 * 5，判断文件是否存在，将结果发回客户端
 * 6，接收结果，如果存在给予提示，程序直接退出
 * 7，如果不存在，定义FileInputStream读取文件，写出到网络
 * 8，定义FileOutputStream，从网络读取数据，存储到本地

相关代码如下：

package com.wsq.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Test1_UpdateClient {
/**
 * 
 * 客户端向服务器上传文件
 * 
 * 
 * 1，提示输入要上传的文件路径，验证路径是否存在以及是否是文件夹
 * 2，发送文件名到服务器
 * 6，接收结果，如果存在给予提示，程序直接退出
 * 7，如果不存在，定义FileInputStream读取文件，写出到网络
 * @throws IOException 
 * @throws UnknownHostException 
 * 
 * 
 * */
    public static void main(String[] args) throws UnknownHostException, IOException {
//1，提示输入要上传的文件路径，验证路径是否存在以及是否是文件夹
        File file = getFile();
//2，发送文件名到服务器
        Socket socket = new Socket("192.168.1.182",1014);
        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintStream ps = new PrintStream(socket.getOutputStream());     //创建输出流
        ps.println(file.getName());                                     //把文件名发送给服务端
//6，接收结果，如果存在给予提示，程序直接退出
        String result = br.readLine();                  //读取 “存在”或者“不存在”的结果
        if("存在".equals(result)){
            System.out.println("您上传的文件已经存在，请不要重复上传");
            socket.close();
            return;
        }
//7，如果不存在，定义FileInputStream读取文件，写出到网络
        FileInputStream fis = new FileInputStream(file);    //这里一定要用字节流，因为上传的文件可能是文本，也可能是音频，视频等文件，字节流可以拷贝任何文件
        byte [] arr = new byte[8192];
        int len;

        while((len = fis.read(arr)) != -1){
            ps.write(arr,0,len);                            //将读到的内容写到服务器上去
        //PrintStream既可以写字符串，也可以写字节，而BufferedWriter，是字符流，没办法写字节
        }                                           
        fis.close();
        socket.close();
    }

    private static File getFile() {//生成方11法，为了需要获取到文件
        Scanner sc = new Scanner(System.in);        // 创建键盘录入对象
        System.out.println("请输入一个文件路径");

        while(true){
            String line =sc.nextLine();
            File file = new File(line);

            if(! file.exists()){
                System.out.println("您录入的文件录入不存在，请重新录入：");
            }else if(file.isDirectory()){
                System.out.println("您录入的是文件夹路径，请录入一个文件路径：");
            }else{
                return file;

            }
        }



    }

}

package com.wsq.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Test2_UpdateServer {
/**
 * 
 * 3，建立多线程的服务器
 * 4，读取文件名
 * 5，判断文件是否存在，将结果发回客户端
 * 6，定义FileOutputStream，从网络读取数据，存储到本地
 * @throws IOException   
 * 
 * 
 * 
 * */
    public static void main(String[] args) throws IOException {
//3，建立多线程的服务器
        ServerSocket server = new ServerSocket(1014); 
        System.out.println("服务器已启动，已绑定1014端口号");

//4，读取文件名
        while(true){
            final Socket socket = server.accept();      //接收客户端的请求 
            new Thread(){
                public void run(){
                    try {
                        InputStream is = socket.getInputStream();
                        BufferedReader br = new BufferedReader(new InputStreamReader(is));
                        PrintStream ps = new PrintStream(socket.getOutputStream());     //创建输出流
                        String fileName = br.readLine();    //读取文件名

//5，判断文件是否存在，将结果发回客户端
                        File dir = new File("update");
                        dir.mkdir();                        //创建文件夹
                        File file = new File(dir,fileName); //封装成File镀锡


                        if(file.exists()){                  //如果服务器已经存在这个文件
                            ps.println("存在");               //将“存在”写给客户端
                            socket.close();                 //关闭socket;
                            return;
                        }else {
                            ps.println("不存在");
                        }
//8，定义FileOutputStream，从网络读取数据，存储到本地
                        FileOutputStream fos = new FileOutputStream(file);
                        byte [] arr = new byte [8192];
                        int len;

                        while((len = is.read(arr)) != -1){
                            fos.write(arr, 0, len);
                        }
                        fos.close();
                        socket.close();
                    } catch (IOException e) {

                        e.printStackTrace();
                    }

                }
            }.start();

        }
    }

}