java socket网络编程增强

最新推荐文章于 2021-05-16 01:12:02 发布
最新推荐文章于 2021-05-16 01:12:02 发布
阅读量221 收藏 1
点赞数
分类专栏： java 文章标签： socket url 聊天室
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15797229/article/details/53896876
版权

网络基础知识

  • 端口号1024以下的尽量不要使用（大多已被互联网厂商使用）
  • 资源定位：
    URL（Uniform Resource Locator） 统一资源定位器，他是一种具体的URI
    URI（Uniform Resource Identifier） 统一资源标识符，用来唯一的标识一个资源

InetAddress类和InetSocketAddress类

/**
 * InetAddress类的使用
 * 没有封装端口
 * @author L J
 */
public class InetDemo {
    public static void main(String[] args) throws UnknownHostException {
        //通过getLocalHost()方法创建InetAddress对象
        InetAddress addr = InetAddress.getLocalHost();
        System.out.println(addr.getHostAddress()); //本机IPv4地址：10.56.0.107
        System.out.println(addr.getHostName());    //输出本机计算机名

        //根据域名得到InetAddress对象
        addr = InetAddress.getByName("www.baidu.com");
        System.out.println(addr.getHostAddress()); //返回百度服务器的IP地址：180.97.33.107
        System.out.println(addr.getHostName());    //www.baidu.com

        //根据IP地址得到InetAddress对象
        addr = InetAddress.getByName("180.97.33.107");
        System.out.println(addr.getHostAddress()); //返回百度服务器的IP地址：180.97.33.107
        System.out.println(addr.getHostName());    //180.97.33.107
    }
}
/**
 * InetSocketAddress类的使用
 * 在InetAddress的基础上+端口
 * @author L J
 */
public class InetDemo2 {
    public static void main(String[] args) {
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 9999);
        System.out.println(address.getHostName());  //127.0.0.1
        System.out.println(address.getPort());      //9999
        InetAddress addr = address.getAddress();
        System.out.println(addr.getHostAddress());  //127.0.0.1
        System.out.println(addr.getHostName());     //127.0.0.1
    }
}

URL

组成：协议+资源所在的主机域名+端口号+资源文件

public class URLDemo {
    public static void main(String[] args) throws MalformedURLException {
        //绝对路径构建
        URL url = new URL("http://www.baidu.com:80/index.html#a?username = root");
        System.out.println("协议:" + url.getProtocol()); //http
        System.out.println("域名:" + url.getHost());     //www.baidu.com
        System.out.println("端口:" + url.getPort());      //80
        System.out.println("资源:" + url.getFile());     //   /index.html
        System.out.println("相对路径:" + url.getPath());  //   /index.html
        System.out.println("锚点:" + url.getRef());       //a?username = root
        //getQuery方法，如果存在锚点，返回null；不存在就返回参数
        System.out.println("参数:" + url.getQuery());    //null,如果去掉#a,返回username = root

        //相对路径构建
        url = new URL("http://www.baidu.com:80/a/");
        url = new URL(url, "b");
        System.out.println(url.toString()); //  http://www.baidu.com:80/a/b
    }
}
/**
 * 获取资源
 * 爬虫第一步
 * @author L J
 */
public class URLDemo2 {
    public static void main(String[] args) throws IOException {
        URL url = new URL("http://www.baidu.com");

        /*获取资源网络流
        InputStream is = url.openStream();
        byte[] buf = new byte[1024];
        int len = 0;
        while(-1 != (len = is.read(buf))) {
            System.out.println(new String(buf, 0 ,len));
        }
        is.close();
        */

        BufferedReader br = 
            new BufferedReader(new InputStreamReader(url.openStream(), "utf-8"));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:/DB/baidu.html"), "UTF-8"));
        String msg = null;
        while((msg = br.readLine()) != null) {
            bw.append(msg);
            bw.newLine();
        }
        bw.flush();
        bw.close();
        br.close();
    }
}

聊天室+私聊

发送数据线程：

/**
 * 发送数据线程
 * @author L J
 */
public class Send implements Runnable{
    private BufferedReader console; //控制台输入流
    private DataOutputStream dos;   //输出流
    private boolean isRunning = true; //线程是否存活
    private String name;  //昵称

    public Send() {
        console = new BufferedReader(new InputStreamReader(System.in));
    }

    public Send(Socket client, String name) {
        this();
        try {
            dos = new DataOutputStream(client.getOutputStream());
            this.name = name;
            send(this.name);
        } catch (IOException e) {
            isRunning = false;
            //关闭输出流和控制台输入流
            CloseUtil.close(dos, console);
        }
    }

    //从控制台读取数据
    private String getMsgFromConsole() {
        try {
            return console.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "";
    }

    //发送数据
    public void send(String msg) {
        try {
            if(msg != null && !msg.equals("")) {
                dos.writeUTF(msg);
                dos.flush();
            }
        } catch (IOException e) {
            isRunning = false;
            //关闭输出流和控制台输入流
            CloseUtil.close(dos, console);
        }
    }

    /**
     * 1、从控制台读取数据
     * 2、发送数据
     */
    @Override
    public void run() {
        while(isRunning) {
            send(getMsgFromConsole());
        }
    }
}

接收数据线程：

/**
 * 接收数据线程
 * @author L J
 */
public class Receive implements Runnable{
    private DataInputStream dis; //输入流
    private boolean isRunning = true; //线程是否存活

    public Receive() {
    }

    public Receive(Socket client) {
        try {
            dis = new DataInputStream(client.getInputStream());
        } catch (IOException e) {
            isRunning = false;
            CloseUtil.close(dis);
        }
    }

    /**
     * 接收数据
     * @return 接收到的数据
     */
    public String receive() {
        String msg = "";
        try {
            msg = dis.readUTF();
        } catch (IOException e) {
            isRunning = false;
            CloseUtil.close(dis);
        }
        return msg;
    }

    @Override
    public void run() {
        while(isRunning) {
            System.out.println(receive());
        }
    }
}

关闭流工具：

/**
 * 关闭流工具类
 * @author L J
 */
public class CloseUtil {
    //关闭流
    public static void close(Closeable ... io) {
        for(Closeable temp : io) {
            if(temp != null) {
                try {
                    temp.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端：

/**
 * 聊天客户端
 * 1、写出数据：输出流
 * 2、读取数据：输入流
 * 
 * 输入与输出在同一个线程内，应该独立处理
 * 
 * @author L J
 */
public class ChatClient {
    public static void main(String[] args) throws IOException, IOException {
        Socket client = new Socket("localhost", 9999);
        System.out.println("请输入昵称:");
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String name = br.readLine();

        if(name.equals("")) {
            return;
        }

        //发送数据,一条独立的路径
        new Thread(new Send(client, name)).start();

        //接收数据,一条独立的路径
        new Thread(new Receive(client)).start();
    }
}

服务器端：

/**
 * 聊天服务器
 * 
 * @author L J
 */
public class ChatServer {
    //管理道路
    private List<MyChannel> all = new ArrayList<MyChannel>();

    public static void main(String[] args) throws IOException {
        new ChatServer().start();
    }

    public void start() throws IOException {
        ServerSocket server = new ServerSocket(9999);
        while(true) {
            Socket client = server.accept();
            MyChannel channel = new MyChannel(client);
            all.add(channel); //统一管理所有的道路
            new Thread(channel).start();  //一条道路
        }
    }

    /**
     * 一个客户端一条道路
     * @author L J
     */
    private class MyChannel implements Runnable {
        // 输入流
        private DataInputStream dis;
        // 输出流
        private DataOutputStream dos;
        //昵称
        private String name;
        // 线程是否存活
        private boolean isRunning = true;

        // 一个客户端一条道路
        public MyChannel(Socket client) {
            try {
                dis = new DataInputStream(client.getInputStream());
                dos = new DataOutputStream(client.getOutputStream());
                this.name = dis.readUTF();
                this.send("欢迎进入聊天室！");
                sendToOthers(this.name + "加入了聊天室！", true);
            } catch (IOException e) {
                isRunning = false;
                CloseUtil.close(dos, dis);
            }
        }

        /**
         * 接收数据
         * @return 接收到的数据
         */
        public String receive() {
            String msg = "";
            try {
                msg = dis.readUTF();
            } catch (IOException e) {
                isRunning = false;
                CloseUtil.close(dis);
                all.remove(this); //将出错的道路移除
            }
            return msg;
        }

        /**
         * 发送数据
         * 
         * @param msg
         */
        public void send(String msg) {
            if (msg == null && msg.equals("")) {
                return;
            }
            try {
                dos.writeUTF(msg);
                dos.flush();
            } catch (IOException e) {
                isRunning = false;
                // 关闭输入输出流
                CloseUtil.close(dos);
                all.remove(this); //将出错的道路移除
            }
        }

        /**
         * 发送数据给其他客户端
         */
        private void sendToOthers(String msg, boolean sys) {
            //是否为私聊
            if(msg.startsWith("@") && msg.indexOf(":") > -1) {//私聊
                //获取昵称
                String name = msg.substring(1, msg.indexOf(":"));
                String content = msg.substring(msg.indexOf(":") + 1);
                for(MyChannel theOne : all) {
                    if(theOne.name.equals(name)) {
                        theOne.send(this.name + ":" + content);
                    }
                }
            }else{//群聊
                //遍历容器
                for(MyChannel other : all) {
                    //不发送给自己
                    if(other == this) {
                        continue;
                    }else{
                        if(sys) {//系统信息
                            other.send("系统信息:" + msg);
                        }else{
                            //发送给其它客户端
                            other.send(this.name + ":" + msg);
                        }
                    }
                }
            }
        }

        /**
         * 接收数据，并发送给其他客户端
         */
        @Override
        public void run() {
            while(isRunning) {
                sendToOthers(receive(), false);
            }
        }
    }
}
kd_myway
关注
专栏目录
java网络编程NIO视频教程
09-12
### Java网络编程NIO视频教程知识点汇总 #### 1. Java NIO-课程简介 - **主要内容**：简述Java NIO（New IO）的概念及其与传统IO的区别。 - **学习目标**：理解NIO的基本原理及应用场景。 #### 2. Java NIO-概述 -...
web项目中加入socket（加强版）
weixin_34123613的博客
08-20 301
2019独角兽企业重金招聘Python工程师标准>>> ...
提高linux上socket的性能(linux优化),提高 Linux 上 socket 性能
weixin_34226447的博客
05-16 2952
使用 SocketsAPI，我们可以开发客户机和服务器应用程序，它们可以在本地网络上进行通信，也可以通过 Internet 在全球范围内进行通信。与其他 API一样，您可以通过一些方法使用 Sockets API，从而提高 Socket 的性能，或者限制 Socket 的性能。本文探索了 4 种使用Sockets API 来榨取应用程序的最大性能并对 GNU/Linux® 环境进行优化从而达到最好...
Java网络编程期末考试复习题库+答案
07-06
在Java中，网络编程主要依赖于Java的Socket编程、ServerSocket、URL类以及NIO（非阻塞I/O）等核心API。这份"Java网络编程期末考试复习题库+答案"为学生提供了全面的复习资源，涵盖了Java网络编程的主要知识点。 1. ...
JAVA Socket网络编程分析
03-31
在Java Socket编程中，常用的设计模式是客户端/服务器（C/S）结构。服务器端创建ServerSocket，监听特定端口，当客户端通过Socket发起连接请求时，服务器响应并创建新的Socket进行通信。在多线程环境下，服务器可以...
利用Java语言的Socket编程实现网络环境下两台计算机之间的字符聊
最新发布
08-10
Java语言的Socket编程是构建网络通信应用的基础，尤其在实现如聊天系统这样的实时交互功能时。本设计旨在利用Java的Socket编程技术，构建一个简单的网络环境下两台计算机之间的字符聊天功能，模拟QQ系统的部分功能。...
Java socket编程实例.pdf
10-30
本文将通过一个具体的Java Socket编程实例来深入探讨如何使用Java实现客户端与服务端之间的通信。 #### 二、基础知识概述 在开始具体实例之前，我们需要了解一些基本概念： - **Socket**：Socket是一种用于在网络...
java 注解与反射
qq_15797229的博客
01-03 1133
注解可以当做一种接口来看待；注意四个元注解；利用反射可以读取注解的信息和泛型的信息；@Retention(RetentionPolicy.RUNTIME)，注解要设成这样才可以利用反射读取信息
java 动态编译与用Rhino引擎执行javascript代码
qq_15797229的博客
01-03 842
动态编译后可以用RuntTime类动态运行程序，也可以通过URLClassLoader加载编译好的文件，利用反射运行main方法；Rhino引擎用来运行JavaScript脚本，还有其他引擎可以运行pathon等脚本
java 字节码操作（javassist）
qq_15797229的博客
01-04 660
学会用javassist生成类；操作类，属性，构造器，方法，注解等
java 手写服务器
qq_15797229的博客
12-30 658
思路：利用ServerSocket监听客户端；封装好Response和Request；在Dispatcher里面封装一个Response和一个Request，保证多线程；然后抽象Servlet父类；要实现自己的业务，只需要实现Servlet类的doGet()方法和doPost()方法；在这之前，要配置web.xml文件；然后用SAX解析xml文件，用上下文容器存储解析结果；用反射找到对应的ServLet；然后输出。
java 内部类
qq_15797229的博客
01-06 447
内部类分为静态内部类和非静态内部类；非静态内部类分为普通内部类，匿名内部类，方法内部类
java面向对象
qq_15797229的博客
11-29 437
面向对象的三大特性：封装，继承，多态；接口和抽象类；内部类等
java泛型
qq_15797229的博客
12-20 429
泛型，extends,super,通配符；泛型继承，泛型擦除；迭代器，比较器；TreeSet与TreeMap；队列和双端队列；HashTable类和Properties类；引用分类；guava与commons对集合的扩展
java集合框架增强
qq_15797229的博客
12-06 428
自定义的集合类，理解集合的底层实现；ArrayList的底层实现是数组，LinkedList的底层实现是链表，HashMap底层实现是数组+链表，解决了Hash冲突问题，Set底层由Map实现；Iterator接口和Map的迭代；AbstractList的内部类Itr实现了Iterator接口
java 多线程入门
qq_15797229的博客
09-04 284
多线程入门
java IO增强
qq_15797229的博客
12-24 272
重点掌握文件的拷贝和目录的拷贝；文件的分割与合并
java 基础增强
qq_15797229的博客
07-03 267
枚举 可变参数 集合迭代 增强for循环 文件复制 自动拆装箱 静态导入 junit和断点的使用
Java Socket网络编程技术深度研究
Java Socket网络编程是Java网络编程的核心技术之一，主要涉及两方面：一是Socket编程，二是基于URL的高级网络编程。Socket编程允许Java程序能够通过网络与其它程序进行通信。Socket是网络上运行的两个程序间双向通信...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值