美文网首页
学习java网络编程

学习java网络编程

作者: 小猪Harry | 来源:发表于2018-06-12 20:32 被阅读0次

InetAddress类

public class InetAddressTest {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机的InetAddressTest实例
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println("计算机名："+localHost.getHostName());
        System.out.println("ip地址："+localHost.getHostAddress());

        System.out.println();

        System.out.println(localHost);
    }
}

运行结果：
计算机名：LAPTOP-FVORT239
ip地址：192.168.216.1

LAPTOP-FVORT239/192.168.216.1

多线程服务器

服务器端
public class SimpleSocketServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(6666);
        System.out.println("服务器启动");

        while (true)
        {
            Socket socket = serverSocket.accept();//监听，等待客户端连接上来
            InetAddress inetAddress= socket.getInetAddress();//得到客户端的地址信息
            System.out.println("客户端："+ inetAddress.getHostAddress() + "连接上来了");
            ServerThread serverThread = new ServerThread(socket);
            new Thread(serverThread).start();
        }

    }
}
服务器端线程
public class ServerThread implements Runnable {

    private Socket socket;

    public ServerThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        while (true)
        {
            InputStream is = null;
            try {
                is = socket.getInputStream();
            } catch (IOException e) {
                e.printStackTrace();
            }
            OutputStream os = null;
            try {
                os = socket.getOutputStream();
            } catch (IOException e) {
                e.printStackTrace();
            }
            DataInputStream dataInputStream = new DataInputStream(is);
            DataOutputStream dataOutputStream = new DataOutputStream(os);

            String string = null;
            try {
                string = dataInputStream.readUTF();

            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println(string);

            try {
                dataOutputStream.writeUTF(string);
                if(string.equals("byebye"))
                {
                    System.out.println("客户端下线了，我也退出了");
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}
客户端
public class TcpClient {
//    public static boolean isDead = false;
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",6666);

        ClientThread clientThread = new ClientThread(socket);
        Thread child = new Thread(clientThread);
        child.start();

        OutputStream os = socket.getOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(os);

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入要发给服务器的信息：byebye 退出");
        while (scanner.hasNext())//阻塞在此处，等待用户在控制台的输入
        {
            String string = scanner.nextLine();
            dataOutputStream.writeUTF(string);
            if(string.equals("byebye"))
            {
                break;
            }
            System.out.println("请输入要发给服务器的信息：byebye 退出");
        }
    }
}
客户端线程
public class ClientThread implements Runnable{

    private Socket socket;

    public ClientThread(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        while (true)
        {
            try {
                InputStream inputStream = socket.getInputStream();
                DataInputStream dataInputStream = new DataInputStream(inputStream);
                String response = dataInputStream.readUTF();//阻塞
                System.out.println("服务器回应：" + response);
                if(response.equals("byebye"))
                {
                    System.out.println("退出");
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
运行结果
SimpleSocketServer
------------------------------------------
服务器已启动！
用户/192.168.216.1已上线！
zhangsan
lisi
用户/192.168.216.1已上线！
王五
张飞
byebye
客户下线了，服务器也下线！
byebye
客户下线了，服务器也下线！

TcpClient 1
------------------------------------------
请输入服务器IP地址：
192.168.216.1
请输入用户想要发的信息，输入byebye退出！
zhangsan
请输入用户想要发的信息，输入byebye退出！
服务器回应：zhangsan
lisi
请输入用户想要发的信息，输入byebye退出！
服务器回应：lisi
byebye
用户选择退出程序！
服务器回应：byebye
服务器关闭客户端线程！

TcpClient 2
------------------------------------------
请输入服务器IP地址：
192.168.216.1
请输入用户想要发的信息，输入byebye退出！
王五
请输入用户想要发的信息，输入byebye退出！
服务器回应：王五
张飞
请输入用户想要发的信息，输入byebye退出！
服务器回应：张飞
byebye
用户选择退出程序！
服务器回应：byebye
服务器关闭客户端线程！

基于socket公共聊天室的实现

1.客户端

public class TcpClient {

    static String username = "";

    public static void helpList() {
        System.out.println("提示：进入聊天室，默认公聊!!");
        System.out.println("/L 用户在线列表，用户#信息 私聊，/C 查看聊天记录，/Q 退出系统");
    }

    public static void main(String[] args) throws IOException {

        //用IP地址建立与服务器对应的socket
        Scanner scanner1 = new Scanner(System.in);
        System.out.println("请输入服务器IP地址：");
        String ServerIP = scanner1.nextLine();

        Socket socket = new Socket(ServerIP,8899);

        //用户输入
        System.out.println("请输入用户名：");
        username = scanner1.nextLine();
        System.out.println(username + "上线了");
        System.out.println("欢迎进入聊天室，需要帮助请输入/A");


        //开启客户端进程
        ClientThread clientThread = new ClientThread(socket);
        Thread child = new Thread(clientThread);
        child.start();

        //输出用户名以便服务器接收
        OutputStream os = socket.getOutputStream();
        DataOutputStream dataOutputStream = new DataOutputStream(os);
        dataOutputStream.writeUTF(username);
        dataOutputStream.flush();

        //判断命令
        while (scanner1.hasNext())
        {
            String message = scanner1.next();
            if (message.equalsIgnoreCase("/A"))
            {
                helpList();
            }
            else if (message.equalsIgnoreCase("/C"))
            {
                //根据路径在控制台上输出文件信息
                File file = new File(username + ".txt");
                BufferedReader br = new BufferedReader(new FileReader(file));

                String str = null;
                while (br.readLine() != null)
                {
                    str = br.readLine();
                    System.out.println(str);
                }
                br.close();
            }
            else
            {
                dataOutputStream.writeUTF(message);
                if (message.equalsIgnoreCase("/Q"))
                {
                    //向服务器输出该退出用户的用户名
                    dataOutputStream.writeUTF(username);
                    System.out.println(username + "已退出聊天室！");
                    System.exit(0);
                }
            }
        }
    }
}

ClientThread.java

public class ClientThread implements Runnable {

    Socket socket;

    public ClientThread(Socket socket) {
        this.socket = socket;
    }

    public void writeFile(String strMsg){

        try {
            //向文件中写入服务器发来的信息
            File file = new File(TcpClient.username + ".txt");
            FileWriter fw = new FileWriter(file,true);
            BufferedWriter bw = new BufferedWriter(fw);
            bw.write(strMsg);

            bw.newLine();
            bw.close();
            fw.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    @Override
    public void run() {
        while (true)
        {
            //输入流
            InputStream is = null;
            try {
                is = socket.getInputStream();
            } catch (IOException e) {
                e.printStackTrace();
            }

            //包装输入流
            DataInputStream dataInputStream = new DataInputStream(is);
            try {
                //接收输入文字
                String response = dataInputStream.readUTF();

                writeFile(response);

                System.out.println(response);


            } catch (SocketException s){
                //关闭用户端socket
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                //退出当前进程
                System.out.println("服务器断开~~~~~~~~~");
                System.exit(0);
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

2.服务端

public class SimpleSocketServer {

    //建立MAP用于存放用户信息，static后面可以直接调用
    public static Map<String,Socket> name2client = new HashMap<>();

    public static void main(String[] args) throws IOException {

        //启动服务器
        ServerSocket serverSocket = new ServerSocket(8899);
        System.out.println("服务器已启动！");

        //循环接收
        while (true)
        {
            //接收socket
            Socket socket = serverSocket.accept();
            //通过socket拿到用户IP地址
            InetAddress inetAddress = socket.getInetAddress();
            System.out.println("客户端"+ inetAddress + "已上线！");

            //接收用户发送来的用户名
            InputStream is = socket.getInputStream();
            DataInputStream dataInputStream = new DataInputStream(is);
            String client_name = dataInputStream.readUTF();

            //将用户名和接收到的socket加入MAP
            name2client.put(client_name,socket);

            //启动服务器线程
            ServerThread serverThread = new ServerThread(client_name,socket);
            Thread server = new Thread(serverThread);
            server.start();
        }
    }
}

ServerThread.java

public class ServerThread implements Runnable{

    String client_name;
    Socket socket;

    public ServerThread(String client_name, Socket socket) {
        this.client_name = client_name;
        this.socket = socket;
    }

    @Override
    public void run() {

        send_msg_to_all_users(client_name + "进入了聊天室！");
        //循环启动
        while (true)
        {
            String message = null;
            try {
                //接收用户发来的信息
                InputStream is = socket.getInputStream();
                DataInputStream dataInputStream = new DataInputStream(is);
                message = dataInputStream.readUTF();

                String[] cmd = message.split("#");

                //判断信息属性值
                if (cmd.length == 2)
                {
                    if (SimpleSocketServer.name2client.containsKey(cmd[0]))
                    {
                        send_msg_personally(cmd[0],cmd[1]);
                    }
                    else
                    {
                        OutputStream os = socket.getOutputStream();
                        DataOutputStream dataOutputStream = new DataOutputStream(os);
                        dataOutputStream.writeUTF("用户不存在！");
                    }

                }
                else if (message.equalsIgnoreCase("/L"))
                {
                    getList();
                }
                else if (message.equalsIgnoreCase("/Q"))
                {
                    send_msg_to_all_users(client_name + "退出了聊天室！");
                    System.out.println(client_name + "刚刚退出了聊天室！");
                    //退出聊天室的时候从MAP中清除该用户
                    SimpleSocketServer.name2client.remove(client_name);

                    //服务器线程用return退出就可以
                    return;
                }
                else
                {
                    send_msg_to_all_users(client_name + "说：" + message);
                }
            } catch (SocketException s){
                try {
                    //关闭当前socket
                    System.out.println("用户掉线，关闭当前服务器上连接" + client_name +"的socket!");
                    SimpleSocketServer.name2client.remove(client_name);
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                //退出线程
                System.out.println("退出当前服务于" + client_name + "的服务器线程!");
                return;
            }
            catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //公聊
    public void send_msg_to_all_users(String msg){
        for (Map.Entry<String,Socket> entry : SimpleSocketServer.name2client.entrySet())
        {
            try {
                OutputStream os = entry.getValue().getOutputStream();
                DataOutputStream dataOutputStream = new DataOutputStream(os);
                dataOutputStream.writeUTF(getDate() + " " + msg);
                dataOutputStream.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //私聊
    public void send_msg_personally(String specific_user,String msg){
        Socket socket1 = SimpleSocketServer.name2client.get(specific_user);

        try {
            OutputStream os = socket1.getOutputStream();
            DataOutputStream dataOutputStream = new DataOutputStream(os);
            dataOutputStream.writeUTF(getDate() + " " + client_name + "对你说：" + msg);
            dataOutputStream.flush();

            OutputStream os1 = socket.getOutputStream();
            DataOutputStream dataOutputStream1 = new DataOutputStream(os1);
            dataOutputStream1.writeUTF(getDate() + " " + "你对" + specific_user + "说：" + msg);
            dataOutputStream1.flush();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //获得在线用户列表
    public void getList(){
        OutputStream os = null;
        try {
            os = socket.getOutputStream();
            DataOutputStream dataOutputStream = new DataOutputStream(os);
            dataOutputStream.writeUTF("在线用户列表：");
            dataOutputStream.writeUTF("在线人数为：" + SimpleSocketServer.name2client.size());

            for (Map.Entry<String,Socket> entry : SimpleSocketServer.name2client.entrySet())
            {
                dataOutputStream.writeUTF("用户名称为：" + entry.getKey());
                dataOutputStream.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    // 时间
    public String getDate() {
        // 获得data对象
        Date nowTime = new Date();
        // 创建格式化参数
        String pattern = "HH:mm:ss";
        // 创建SimpleDateFormat对象
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        // 定义一个变量接收时间
        String timePattern = sdf.format(nowTime);
        // 返回当前时间
        return timePattern;
    }
}
运行结果
SimpleSocketServer
---------------------------------------
服务器已启动！
客户端/127.0.0.1已上线！
客户端/10.25.44.142已上线！
客户端/192.168.234.1已上线！
客户端/192.168.190.1已上线！
奇异博士刚刚退出了聊天室！
用户掉线，关闭当前服务器上连接美国队长的socket!
退出当前服务于美国队长的服务器线程!

Process finished with exit code 1


TcpClient 1
---------------------------------------
请输入服务器IP地址：
127.0.0.1
请输入用户名：
钢铁侠
钢铁侠上线了
欢迎进入聊天室，需要帮助请输入/A
13:41:06 钢铁侠进入了聊天室！
13:41:34 雷神进入了聊天室！
13:42:14 奇异博士进入了聊天室！
13:42:49 美国队长进入了聊天室！
大家好
13:43:06 钢铁侠说：大家好
13:43:37 美国队长说：我们是复仇者联盟
13:45:20 奇异博士说：我要下线了
13:45:50 奇异博士退出了聊天室！
服务器要断
13:46:36 钢铁侠说：服务器要断
服务器断开~~~~~~~~~

Process finished with exit code 0


TcpClient 2
---------------------------------------
请输入服务器IP地址：
10.25.44.142
请输入用户名：
雷神
雷神上线了
欢迎进入聊天室，需要帮助请输入/A
13:41:34 雷神进入了聊天室！
13:42:14 奇异博士进入了聊天室！
13:42:49 美国队长进入了聊天室！
13:43:06 钢铁侠说：大家好
13:43:37 美国队长说：我们是复仇者联盟
美国队长#小声点儿
13:43:58 你对美国队长说：小声点儿
13:45:20 奇异博士说：我要下线了
13:45:50 奇异博士退出了聊天室！
/l
在线用户列表：
在线人数为：2
用户名称为：钢铁侠
用户名称为：雷神
13:46:36 钢铁侠说：服务器要断
服务器断开~~~~~~~~~

Process finished with exit code 0


TcpClient 3
---------------------------------------
请输入服务器IP地址：
192.168.234.1
请输入用户名：
奇异博士
奇异博士上线了
欢迎进入聊天室，需要帮助请输入/A
13:42:14 奇异博士进入了聊天室！
13:42:49 美国队长进入了聊天室！
13:43:06 钢铁侠说：大家好
13:43:37 美国队长说：我们是复仇者联盟
我要下线了
13:45:20 奇异博士说：我要下线了
/c
13:42:14 奇异博士进入了聊天室！
13:42:49 美国队长进入了聊天室！
13:43:06 钢铁侠说：大家好
13:43:37 美国队长说：我们是复仇者联盟
13:45:20 奇异博士说：我要下线了
/q
奇异博士已退出聊天室！

Process finished with exit code 0


TcpClient 4
---------------------------------------
请输入服务器IP地址：
192.168.190.1
请输入用户名：
美国队长
美国队长上线了
欢迎进入聊天室，需要帮助请输入/A
13:42:49 美国队长进入了聊天室！
13:43:06 钢铁侠说：大家好
/a
提示：进入聊天室，默认公聊!!
/L 用户在线列表，用户#信息 私聊，/C 查看聊天记录，/Q 退出系统
/l
在线用户列表：
在线人数为：4
用户名称为：钢铁侠
用户名称为：雷神
用户名称为：奇异博士
用户名称为：美国队长
我们是复仇者联盟
13:43:37 美国队长说：我们是复仇者联盟
13:43:58 雷神对你说：小声点儿
13:45:20 奇异博士说：我要下线了
13:45:50 奇异博士退出了聊天室！

Process finished with exit code 1

相关文章

  • 《Netty实战》读书笔记01——第一章

    第 1 章 笔记 Java 网络编程 早期Java的网络编程，需要学习很多C语言套接字（Socket）的知识，但...

  • socket通讯编程

    这一块属于网络编程，主要是学习TCP/IP四层的网络体系结构，学习TCP编程和UDP编程。 java.net中 一...

  • Java网络编程（第四版） PDF 超清版

    《Java网络编程（第四版）》是一本关于Java编程相关的电子书资源，介绍了关于Java、网络编程、Java编程方...

  • 学习java网络编程

    InetAddress类 多线程服务器 服务器端 服务器端线程 客户端 客户端线程 运行结果 基于socket公共...

  • 4月5日TestServerSocket

    于2017/4/5复习学习的java - Socket网络编程. 本次完成的是网络聊天编程功能(没有GUI).我想...

  • Android应用开发：网络编程2

    网络编程 Java基础：网络编程 Uri、URL、UriMatcher、ContentUris详解 Android...

  • Http协议

    网络编程 Java基础：网络编程 Uri、URL、UriMatcher、ContentUris详解 Android...

  • Java网络编程模型（一）

    本系列主要介绍java网络编程的模型，沿着模型的进化线结合案例分析学习。本文主要介绍基于OIO的网络编程模型。 基...

  • Java开发学习之路

    Java开发的学习之路 基础知识 编程语言：Java Python C 基本算法 基本网络知识：TCP/IP HT...

  • java网络编程-学习总结

    文章所写内容是我自己对学习java网络编程阶段做一个小小的总结，把自己所学之物与大家分享一下,希望能与各位共同学习...

网友评论

      本文标题：学习java网络编程

      本文链接：https://www.haomeiwen.com/subject/dnureftx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|学习java网络编程|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！