javase复习day33网络编程

网络编程

常见的软件架构

BS架构

CS架构

网络编程小结

网络编程三要素

三要素小结

IP

IPV4

IPV6

IP小结

IPV4的地址分类形式

常用的CMD命令

小结

InetAddress的使用

public class Demo1 {
    public static void main(String[] args) throws UnknownHostException {
        //获取IP对象
        /**
         * 通过InetAddress.getByName方法获取到InetAddress对象
         * 方法的形参可以是主机名，也可以是IP地址
         */
        InetAddress byName = InetAddress.getByName("DESKTOP-0MCCNFM");
        System.out.println(byName);

        //获取到该对象的主机名，如果该主句无法链接，将返回该对象的IP地址
        String hostName = byName.getHostName();
        System.out.println(hostName);

        //获取该对象的IP地址
        String hostAddress = byName.getHostAddress();
        System.out.println(hostAddress);
    }
}

端口号

协议

UDP协议

UDP发送

public class udpSendDemo {
    public static void main(String[] args) throws IOException {
        //创建一个链接对象
        /**
         * DatagramSocket的参数是指定端口号，如果为无参构造则表示随机一个端口号
         */
        DatagramSocket ds = new DatagramSocket();

        //创建一个对象用来打包数据
        //创建一个字符数组用来保存要传输的数据
        /**
         * 参数一：保存数据的字符数组
         * 参数二：字符数组传输的开始位置(可不输入，表述从头开始）
         * 参数三：字符数组传输的长度
         * 参数四：目标设备的地址（IP）
         * 参数五：目标设备的接受端口
         */
        String str = "你好，万维";
        byte[] bytes = str.getBytes();
        //目标设备的地址（本地环回地址）
        InetAddress byName = InetAddress.getByName("127.0.0.1");
        //目标设备的接收端口
        int port = 10086;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,byName,port);
        //使用DatagramSocket对象发送DatagramPacket对象（数据包）
        ds.send(dp);

        //释放资源
        ds.close();
    }
}

UDP接收

public class udpresurt {
    public static void main(String[] args) throws IOException {
        /**
         * 接收数据
         */
        //接收数据要创建DatagramSocket对象
        //DatagramSocket对象必须要指定端口号，且端口号应该和发送端发送的端口号相同
        DatagramSocket ds = new DatagramSocket(10086);

        //创建字符数组用于存储接受到的数据
        byte[] arr = new byte[1024];
        //接收数据只需要将字符数组存入即可
        DatagramPacket dp = new DatagramPacket(arr,arr.length);

        /**
         * 该方法用于接受数据
         * 该方法是阻塞的
         * 即只用该方法获取到传输的数据时才会向下执行
         */
        ds.receive(dp);

        //解析数据
        //写入的数据
        byte[] data = dp.getData();
        //发送数据的设备的地址
        InetAddress address = dp.getAddress();
        //发送端要发送的真实数据的数据的长度
        int length = dp.getLength();
        //发送端的端口号
        int port = dp.getPort();
        //new String(data,0,length)表示将data字符数组中的数据从0开始到length转为字符串，即将发送端要传输的字符串转换出来
        //data中的其他字符串转换会出现乱码
        System.out.println(new String(data,0,length));
        System.out.println(length);
        System.out.println(address);
        System.out.println(port);

        /**
         * 你好，万维
         * 15
         * /127.0.0.1
         * 55623
         */

        //关闭资源
        ds.close();

    }
}

练习：聊天室

public class udpSendTest {
    public static void main(String[] args) throws IOException {
        //创建一个链接对象
        /**
         * DatagramSocket的参数是指定端口号，如果为无参构造则表示随机一个端口号
         */
        DatagramSocket ds = new DatagramSocket();

        Scanner sc = new Scanner(System.in);

        while (true) {
            System.out.println("请输入要说的话");
            String str = sc.nextLine();
            if (str.equals("886")){
                break;
            }
            byte[] bytes = str.getBytes();
            //目标设备的地址（本地环回地址）
            InetAddress byName = InetAddress.getByName("127.0.0.1");
            //目标设备的接收端口
            int port = 10086;
            DatagramPacket dp = new DatagramPacket(bytes,bytes.length,byName,port);
            //使用DatagramSocket对象发送DatagramPacket对象（数据包）
            ds.send(dp);
        }

        //释放资源
        ds.close();
    }
}

public class udpresurtTest {
    public static void main(String[] args) throws IOException {
        /**
         * 接收数据
         */
        //接收数据要创建DatagramSocket对象
        //DatagramSocket对象必须要指定端口号，且端口号应该和发送端发送的端口号相同
        DatagramSocket ds = new DatagramSocket(10086);

        //创建字符数组用于存储接受到的数据
        byte[] arr = new byte[1024];
        //接收数据只需要将字符数组存入即可
        DatagramPacket dp = new DatagramPacket(arr,arr.length);

        /**
         * 该方法用于接受数据
         * 该方法是阻塞的
         * 即只用该方法获取到传输的数据时才会向下执行
         */
        while (true) {
            ds.receive(dp);

            //解析数据
            //写入的数据
            byte[] data = dp.getData();
            //发送数据的设备的地址
            InetAddress address = dp.getAddress();
            String hostAddress = address.getHostAddress();
            String hostName = address.getHostName();
            //发送端要发送的真实数据的数据的长度
            int length = dp.getLength();
            //发送端的端口号
            int port = dp.getPort();

            String s = new String(data,0,length);
            //new String(data,0,length)表示将data字符数组中的数据从0开始到length转为字符串，即将发送端要传输的字符串转换出来
            //data中的其他字符串转换会出现乱码
            System.out.println("ip为："+hostAddress+" 主机名为："+hostName+" 的人发来了话："+s);
        }



        //关闭资源
//        ds.close();

    }
}

UDP的三种通讯方式

组播

public class udpresurt {
    public static void main(String[] args) throws IOException {
        /**
         * 接收数据
         */
        //接收数据要创建MulticastSocket对象,用于组播
        //MulticastSocket对象必须要指定端口号，且端口号应该和发送端发送的端口号相同
        MulticastSocket ds = new MulticastSocket(10086);

        //将主机添加到224.0.0.1的这一组中
        InetAddress byName = InetAddress.getByName("224.0.0.1");
        ds.joinGroup(byName);

        //创建字符数组用于存储接受到的数据
        byte[] arr = new byte[1024];
        //接收数据只需要将字符数组存入即可
        DatagramPacket dp = new DatagramPacket(arr,arr.length);


        /**
         * 该方法用于接受数据
         * 该方法是阻塞的
         * 即只用该方法获取到传输的数据时才会向下执行
         */
        ds.receive(dp);

        //解析数据
        //写入的数据
        byte[] data = dp.getData();
        //发送数据的设备的地址
        InetAddress address = dp.getAddress();
        //发送端要发送的真实数据的数据的长度
        int length = dp.getLength();
        //发送端的端口号
        int port = dp.getPort();
        //new String(data,0,length)表示将data字符数组中的数据从0开始到length转为字符串，即将发送端要传输的字符串转换出来
        //data中的其他字符串转换会出现乱码
        System.out.println(new String(data,0,length));
        System.out.println(length);
        System.out.println(address);
        System.out.println(port);


        //关闭资源
        ds.close();

    }
}

public class udpSendDemo {
    public static void main(String[] args) throws IOException {
        //创建一个链接对象
        /**
         * DatagramSocket的参数是指定端口号，如果为无参构造则表示随机一个端口号
         */
        MulticastSocket ds = new MulticastSocket();


        //创建一个对象用来打包数据
        //创建一个字符数组用来保存要传输的数据
        /**
         * 参数一：保存数据的字符数组
         * 参数二：字符数组传输的开始位置(可不输入，表述从头开始）
         * 参数三：字符数组传输的长度
         * 参数四：目标设备的地址（IP）
         * 参数五：目标设备的接受端口
         */
        String str = "你好，万维";
        byte[] bytes = str.getBytes();
        //目标设备的地址（本地环回地址）
        InetAddress byName = InetAddress.getByName("224.0.0.1");
        //目标设备的接收端口
        int port = 10086;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,byName,port);
        //使用DatagramSocket对象发送DatagramPacket对象（数据包）
        ds.send(dp);

        //释放资源
        ds.close();
    }
}

广播（只需要单播，将IP改为255.255.255.255）

public class udpSendDemo2 {
    public static void main(String[] args) throws IOException {
        //创建一个链接对象
        /**
         * DatagramSocket的参数是指定端口号，如果为无参构造则表示随机一个端口号
         */
        DatagramSocket ds = new DatagramSocket();


        //创建一个对象用来打包数据
        //创建一个字符数组用来保存要传输的数据
        /**
         * 参数一：保存数据的字符数组
         * 参数二：字符数组传输的开始位置(可不输入，表述从头开始）
         * 参数三：字符数组传输的长度
         * 参数四：目标设备的地址（IP）
         * 参数五：目标设备的接受端口
         */
        String str = "你好，万维";
        byte[] bytes = str.getBytes();
        //目标设备的地址（本地环回地址）
        InetAddress byName = InetAddress.getByName("255.255.255.255");
        //目标设备的接收端口
        int port = 10086;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,byName,port);
        //使用DatagramSocket对象发送DatagramPacket对象（数据包）
        ds.send(dp);

        //释放资源
        ds.close();
    }
}

TCP

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //客户端，发送数据
        //"127.0.0.1",指定服务器地址和端口号
        Socket s = new Socket("127.0.0.1",10001);

        //通过s.getOutputStream();方法获取到输出流，写出数据
        OutputStream os = s.getOutputStream();
        //目前传输中文会报错
//        os.write("你好你好".getBytes());
        os.write("halloword".getBytes());

        //关闭资源
        os.close();
        s.close();
    }
}

public class SocketDemo {
    public static void main(String[] args) throws IOException {
        //服务端的接收对象，要指定客户端的访问端口
        ServerSocket ss = new ServerSocket(10001);

        //用于监听客户端连接，一旦有链接则继续执行
        Socket socket = ss.accept();

        InputStream inputStream = socket.getInputStream();

        int ch;
        while ((ch = inputStream.read())!= -1){
            System.out.println((char) ch);
        }

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

中文乱码的解决

将接收流使用转换流包装，客户端不需要更改

public class SocketDemo {
    public static void main(String[] args) throws IOException {
        //服务端的接收对象，要指定客户端的访问端口
        ServerSocket ss = new ServerSocket(10001);

        //用于监听客户端连接，一旦有链接则继续执行
        Socket socket = ss.accept();

        InputStream is = socket.getInputStream();
        //InputStreamReader包装InputStream可以避免乱码
        InputStreamReader isr = new InputStreamReader(is);
        //提高效率
        BufferedReader br = new BufferedReader(isr);
        int ch;
        while ((ch = br.read())!= -1){
            System.out.println((char) ch);
        }

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

三次握手，四次挥手

综合练习

练习一：多发多收

public class udpsend {
    public static void main(String[] args) throws IOException {
        //udp发送
        DatagramSocket ds = new DatagramSocket();


        Scanner sc  = new Scanner(System.in);
        while (true){
            System.out.println("请输入数据");
            String s = sc.nextLine();
            if (s.equals("886")){
                break;
            }
            byte[] bytes = s.getBytes();
            InetAddress address = InetAddress.getByName("127.0.0.1");
            DatagramPacket dp = new DatagramPacket(bytes,0,bytes.length,address,10000);

            ds.send(dp);
        }
        ds.close();
    }
}

public class udpresure {
    public static void main(String[] args) throws IOException {
        //UDP接受
        DatagramSocket ds = new DatagramSocket(10000);

        byte[] bytes = new byte[1024];

        DatagramPacket dp = new DatagramPacket(bytes,0,bytes.length);

        while (true) {
            ds.receive(dp);
            //解析数据
            InetAddress address = dp.getAddress();
            int port = dp.getPort();
            int len = dp.getLength();
            byte[] data = dp.getData();
            String s = new String(data, 0, len);
            System.out.println("ip为："+address.getHostAddress()+"主机名为"+address.getHostName()+"发来了消息："+s);
        }
    }
}

练习二：接收和反馈

public class udpresure {
    public static void main(String[] args) throws IOException {
        //UDP服务端
        DatagramSocket ds = new DatagramSocket(10000);

        byte[] bytes = new byte[1024];

        DatagramPacket dp = new DatagramPacket(bytes, 0, bytes.length);

        //接收数据
        ds.receive(dp);
        //解析数据
        InetAddress address = dp.getAddress();
        int port = dp.getPort();
        int len = dp.getLength();
        byte[] data = dp.getData();
        String s = new String(data, 0, len);
        System.out.println("ip为：" + address.getHostAddress() + "主机名为" + address.getHostName() + "发来了消息：" + s);
        //发送数据发送
        String string = "服务端接收到了请求";
        bytes = string.getBytes();
        DatagramPacket dp2 = new DatagramPacket(bytes, 0, bytes.length, address, port);
        ds.send(dp2);

        ds.close();

    }
}

public class udpsend {
    public static void main(String[] args) throws IOException {
        //udp客户端
        //接收端口是10002
        DatagramSocket ds = new DatagramSocket();


        Scanner sc = new Scanner(System.in);
        //开始发送信息
        System.out.println("请输入数据");
        String s = sc.nextLine();
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");
        DatagramPacket dp = new DatagramPacket(bytes, 0, bytes.length, address, 10000);

        ds.send(dp);

        //开始接收数据

        ds.receive(dp);
        //解析数据
        InetAddress address2 = dp.getAddress();
        int port = dp.getPort();
        int len = dp.getLength();
        byte[] data = dp.getData();
        String s2 = new String(data, 0, len);
        System.out.println("ip为：" + address2.getHostAddress() + "主机名为" + address2.getHostName() + "发来了消息：" + s2);

        ds.close();
    }
}

练习三：上传文件

public class TcpFileget {
    public static void main(String[] args) throws IOException {
        //使用TCP链接来接受文件
        ServerSocket ss = new ServerSocket(10003);

        Socket s = ss.accept();

        InputStream is = s.getInputStream();



        FileOutputStream fos = new FileOutputStream("D:\\Test\\b.rar");

        byte[] bytes = new byte[1024];
        int ch;
        while ((ch = is.read(bytes))!= -1){
            fos.write(bytes,0,ch);
        }

        //接收完毕给客户端一个反馈
        //获取一个发送流
        OutputStream os = s.getOutputStream();
        String string = "文件接受完毕，上传成功";
        System.out.println(string);
        byte[] bytes1 = string.getBytes();
        os.write(bytes1);

        os.close();
        fos.close();
        is.close();
        s.close();
        ss.close();
    }

}

public class TcpFilesend {
    public static void main(String[] args) throws IOException {
        //使用TCP链接来发送文件
        Socket s = new Socket("127.0.0.1",10003);

        OutputStream os = s.getOutputStream();

        FileInputStream fis = new FileInputStream("C:\\Users\\20724\\Desktop\\代码.rar");

        //接收文件，并通过OS法除去
        byte[] bytes = new byte[1204];
        int ch;
        while ((ch = fis.read(bytes))!= -1){
            os.write(bytes,0,ch);
        }
        //表示文件传输已经结束
        s.shutdownOutput();

        //获取接受流
        InputStream is = s.getInputStream();
        byte[] bytes1 = new byte[1024];
        int c;
        while ((c = is.read(bytes1)) != -1) {
//            StringBuilder sb = new StringBuilder();
            String string = new String(bytes1,0,c);
            System.out.println("服务区传输的数据："+string);
        }

        is.close();
        fis.close();
        os.close();
        s.close();
    }
}

练习四：文件重名

//只需将接受代码中保存文件的名称的代码进行修改即可

        //解决重名问题可以添加一个UUID
        UUID uuid = UUID.randomUUID();//36a05678-f015-4d47-b641-4598918f2269
        //将UUID中的-去掉
        String s1 = uuid.toString().replaceAll("-", "");


        FileOutputStream fos = new FileOutputStream("D:\\Test\\"+s1+".rar");

练习五：上传文件（多线程）

public class TcpFileget {
    public static void main(String[] args) throws IOException {
        //使用TCP链接来接受文件
        ServerSocket ss = new ServerSocket(10004);
        Socket s = null;
        while (true) {
            s = ss.accept();
            MyThread myThread = new MyThread(s);
            Thread thread = new Thread(myThread);

            thread.start();
        }
    }
}

public class MyThread implements Runnable{
    Socket s;

    MyThread(Socket s){
        this.s = s;
    }
    @Override
    public void run() {
            try {
                InputStream is = s.getInputStream();

                //解决重名问题可以添加一个UUID
                UUID uuid = UUID.randomUUID();//36a05678-f015-4d47-b641-4598918f2269
                //将UUID中的-去掉
                String s1 = uuid.toString().replaceAll("-", "");


                FileOutputStream fos = new FileOutputStream("D:\\Test\\"+s1+".rar");

                byte[] bytes = new byte[1024];
                int ch;
                while ((ch = is.read(bytes))!= -1){
                    fos.write(bytes,0,ch);
                }

                //接收完毕给客户端一个反馈
                //获取一个发送流
                OutputStream os = s.getOutputStream();
                String string = "文件接受完毕，上传成功";
                System.out.println(string);
                byte[] bytes1 = string.getBytes();
                os.write(bytes1);
                s.shutdownOutput();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
    }
}

public class TcpFilesend {
    public static void main(String[] args) throws IOException {
        //使用TCP链接来发送文件
        Socket s = new Socket("127.0.0.1",10004);
        OutputStream os = s.getOutputStream();
        FileInputStream fis = new FileInputStream("C:\\Users\\20724\\Desktop\\代码.rar");
        //接收文件，并通过OS法除去
        byte[] bytes = new byte[1204];
        int ch;
        while ((ch = fis.read(bytes))!= -1){
            os.write(bytes,0,ch);
        }
        //表示文件传输已经结束
        s.shutdownOutput();
        //获取接受流
        InputStream is = s.getInputStream();
        byte[] bytes1 = new byte[1024];
        int c;
        while ((c = is.read(bytes1)) != -1) {
//            StringBuilder sb = new StringBuilder();
            String string = new String(bytes1,0,c);
            System.out.println("服务区传输的数据："+string);
        }
        s.close();
    }
}

练习六：上传文件（线程池优化）

其他代码同上

public class TcpFilesend {
    public static void main(String[] args) throws IOException {
        //使用TCP链接来发送文件
        Socket s = new Socket("127.0.0.1",10004);
        OutputStream os = s.getOutputStream();
        FileInputStream fis = new FileInputStream("C:\\Users\\20724\\Desktop\\代码.rar");
        //接收文件，并通过OS法除去
        byte[] bytes = new byte[1204];
        int ch;
        while ((ch = fis.read(bytes))!= -1){
            os.write(bytes,0,ch);
        }
        //表示文件传输已经结束
        s.shutdownOutput();
        //获取接受流
        InputStream is = s.getInputStream();
        byte[] bytes1 = new byte[1024];
        int c;
        while ((c = is.read(bytes1)) != -1) {
//            StringBuilder sb = new StringBuilder();
            String string = new String(bytes1,0,c);
            System.out.println("服务区传输的数据："+string);
        }
        s.close();
    }
}

练习七：(接收浏览器的数据并打印）

public class GetTCP {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10008);
        Socket socket = ss.accept();
        InputStream inputStream = socket.getInputStream();

        InputStreamReader isr = new InputStreamReader(inputStream);
        int a;
        while ((a = isr.read())!= -1){
            System.out.print((char) a);
        }
        isr.close();
        ss.close();
    }
}

练习八：网络编程（大作业）

zhangsan=123
lisi=123
wangwu=123
qwqwq=123
sdsds=1231username

public class Service {
    //用静态记录一登录成功的信息
    static ArrayList<Socket> list = new ArrayList<>();
    //服务器端
    public static void main(String[] args) throws IOException {

        //使用集合存储登录的用户的链接
        HashMap<String,String> userMap = new HashMap<>();
        //获取数据
        FileReader fr = new FileReader("javaday34dzy\\src\\main\\java\\userdata.txt");
        BufferedReader br = new BufferedReader(fr);
        String str;
        while ((str = br.readLine())!= null){
            String[] split = str.split("=");
            userMap.put(split[0],split[1]);
        }
        //获取所有已注册的数据
        ServerSocket ss =  new ServerSocket(10086);//启动服务
        Socket s = null;

        while (true) {

            //创建接受流
            s = ss.accept();
            System.out.println("有客户端来链接");
            //创建线程
            Thread t = new Thread(new serviceThread(s,userMap));
            t.start();
        }
    }
}

public class serviceThread implements Runnable{
    Socket s;
    HashMap<String,String> hashMap;

    public serviceThread(Socket socket, HashMap<String, String> hashMap) {
        this.s = socket;
        this.hashMap = hashMap;
    }

    @Override
    public void run() {
        try {
            //开始接收数据，并对接收的数据进行处理
            InputStream is = s.getInputStream();
            OutputStream os = s.getOutputStream();
            //使用字符缓冲流包装
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));

            //接受第一次传来的等录或注册
            int s1 = br.read();
            System.out.println(s1);
            if (s1=='1'){
                //登录
                userjoin(br, bw);
            }else {
                userresuie(br, bw);
            }


//            //开始接收数据
//            String str;
//            while ((str = br.readLine()) != null){
//                System.out.println(str);
//                //判断数据
//                //将数据拆分
//
//            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private void userresuie(BufferedReader br, BufferedWriter bw) throws IOException {
        //注册
//        String s1 = br.readLine();
        String s2 = br.readLine();
        System.out.println("正在注册");
        System.out.println("================");
        System.out.println(s2);
        //解析数据
        String[] split = s2.split("&");
        String[] split1 = split[0].split("=");
        String[] split2 = split[1].split("=");
        boolean flag = true;
        //遍历
        Set<String> strings = hashMap.keySet();
        for (String string : strings) {
            if (split1[1].equals(string)){
                flag = false;
                //已经有账号，不可在注册
                bw.write(0);
                //刷新将数据发出
                bw.flush();
                break;
            }
        }
        if (flag){
            //没有账号开始注册
            //整理数据
            String userdata = split1[1]+"="+split2[1];
            FileWriter fw = new FileWriter("javaday34dzy\\src\\main\\java\\userdata.txt",true);
            BufferedWriter bw1 = new BufferedWriter(fw);
            bw1.write(userdata);
            //换行
            bw1.newLine();
            //关闭资源
            bw1.close();
            System.out.println("账号注册成功");
        }
    }

    private void userjoin(BufferedReader br, BufferedWriter bw) throws IOException {
        String s2 = br.readLine();
        //解析数据
        String[] split = s2.split("&");
        String[] split1 = split[0].split("=");
        String[] split2 = split[1].split("=");
        boolean flag = true;
        //判断
        //遍历
        Set<String> strings = hashMap.keySet();
        for (String string : strings) {
            if (split1[1].equals(string)){
                //判断密码是否一样
                String password = hashMap.get(string);
                if (password.equals(split2[1])){
                    flag = false;
                    //密码正确，登录
                    bw.write(1);
                    //刷新将数据发出
                    bw.flush();
                    //将信息写入集合中
                    Service.list.add(s);
                    //写一个while(){}表示正在聊天
                    //接收客户端发送过来的消息，并打印在控制台
                    talk2All(br, string);
                }else {
                    密码不正确
                    bw.write(0);
                    //刷新将数据发出
                    bw.flush();
                }
            }
        }
        if (flag){
            //没有账号，先注册账号
            bw.write(-1);
            //刷新将数据发出
            bw.flush();
        }
    }

    private void talk2All(BufferedReader br, String username) throws IOException {
        while (true) {
            String message = br.readLine();
            System.out.println(username + "发送过来消息：" + message);

            //群发
            for (Socket s : Service.list) {
                //s依次表示每一个客户端的连接对象
                writeMessage2Client(s, username + "发送过来消息：" + message);
            }
        }
    }

    private void writeMessage2Client(Socket s, String message) throws IOException {
        //获取输出流
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        bw.write(message);
        bw.newLine();
        bw.flush();
    }
}

public class Join {
    //用户端
    //选择登录还是注册

    //服务器已经连接成功
    //==============欢迎来到黑马聊天室================
    //1登录
    //2注册
    //请输入您的选择：
    public static void main(String[] args) throws IOException {
        //和服务端进行连接
        Socket s = new Socket("127.0.0.1",10086);
        //获取发送流
        OutputStream os = s.getOutputStream();
        //获取接受流
        InputStream is = s.getInputStream();
        //向服务端发送请求，如果回复则显示 服务器已经连接成功
        //使用缓冲字符包装
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
        BufferedReader br = new BufferedReader(new InputStreamReader(is));
        Scanner sc = new Scanner(System.in);
//
        while (true) {
            System.out.println("服务器已经连接成功");
            System.out.println("==============欢迎来到黑马聊天室================");
            System.out.println("1登录");
            System.out.println("2注册");
            System.out.println("请输入您的选择：");
            String str = sc.next();
            //判断输入的试什么
            switch (str){
                case "1":
                    joinin(sc, bw, br, s);
                    break;
                case "2":
                    resurt(sc, bw);
                    break;
                default:
                    System.out.println("您输入的数据有误，请重新选择");
            }
        }

    }

    private static void resurt(Scanner sc, BufferedWriter bw) throws IOException {
        //调用注册函数
        System.out.println("请输入用户名");
        String usernamere = sc.next();
        System.out.println("请输入密码");
        String passwordre = sc.next();
        //将两个数据进行加工并发送给服务端,1username=zhangsan&password=123,最前边的1表述告诉服务器这是登录操作
        String joinstrre = "username="+usernamere+"&password="+passwordre;
        System.out.println(joinstrre);
        bw.write(2);
        bw.flush();
        //第二次发送
        bw.write(joinstrre);
        bw.newLine();
        bw.flush();
        //开始监听服务器的返回数据
    }

    private static void joinin(Scanner sc, BufferedWriter bw, BufferedReader br, Socket s) throws IOException {
        //调用登录函数
        /**
         * 请输入用户名
         * zhangsan
         * 请输入密码
         * 123
         */
        System.out.println("请输入用户名");
        String username = sc.next();
        System.out.println("请输入密码");
        String password = sc.next();
        //将两个数据进行加工并发送给服务端,1username=zhangsan&password=123,最前边的1表述告诉服务器这是登录操作
        String joinstr = "username="+username+"&password="+password;
        bw.write("1");
        bw.flush();
        //第二次发送
        bw.write(joinstr);
        bw.newLine();
        bw.flush();
        //开始监听服务器的返回数据
        int joinresult = br.read();
        //判断返回的数据
        if (joinresult==1){
            System.out.println("登录成功");
            //登陆成功的操作
            //开一条单独的线程，专门用来接收服务端发送过来的聊天记录
            //创建一个对应的线程用于接受发来的数据
            new Thread(new joinThread(s)).start();
            //开始聊天
            talk2All(bw);
        } else if (joinresult==0) {
            System.out.println("密码有误");
            //重新进行操作
        }else {
            System.out.println("用户名不存在");
            //重新进行操作
        }
    }

    private static void talk2All(BufferedWriter bw) throws IOException {
        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请输入您要说的话");
            String str = sc.nextLine();
            //把聊天内容写给服务器
            bw.write(str);
            bw.newLine();
            bw.flush();
        }
    }
}

public class joinThread implements Runnable{

    Socket s;

    public joinThread(Socket s) {
        this.s = s;
    }

    @Override
    public void run() {
        //循环，重复的接受
        while (true) {
            try {
                //接收服务器发送过来的聊天记录
                BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
                String msg = br.readLine();
                System.out.println(msg);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}