UDP+反射

TCP文件下载:

例:
  1. 编写客户端程序和服务器端程序
  2. 客户端可以输入一个 音乐 文件名,比如 高山流水,服务端 收到音乐名后,可以给客户端 返回这个音乐文件,如果服务器没有这个文件,返回一个默认的音乐即可
  3. 客户端收到文件后,保存到本地 e:\
  4. 可以使用使用自己封装的 StreamUtils.java
客户端:
    public static void main(String[] args) {

        //1、接受用户输入,指定下载文件名
        Scanner scanner = new Scanner(System.in);
        System.out.print("请输入下载文件名:");
        String downloadFileName = scanner.next();
        //2、客户端连接服务端,准备发送
        Socket socket = new Socket(InetAddress.getLocalHost(),9999);
        //3、获取和Socket关联的输出流
        OutputStream outputStream = socket.getOutputStream();
        outputStream.write(downLoadFileName.getBytes());
        //设置写入结束的标志
        socket.shutdownOutput();
        //4、读取服务端返回的文件(字节数据)
        BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
        //bytes就是返回的文件
        byte[] bytes = StreamUtils.streamToByteArray(bis);
        //5、得到一个输出流,准备将bytes写入磁盘文件
        //比如下载的是 高山流水 -> 下载的就是 高山流水.mp3
        //   下载的是 abc -> 下载的就是 无名.mp3 ,但 文件名是abc.mp3    
        String filePath = "e:\\" + downLoadFileName + ".mp3";
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
        bos.write(bytes);
        //6、关闭相关的资源
        bos.close();
        bis.close();
        outputStream.close();
        socket.close();
        System.out.print("客户端下载完毕,正确退出~~~");
    }
服务端:
    public static void main(String[] args) {
        //1、监听9999端口
        ServerSocket serverSocket = new ServerSocket(9999);
        //2、等待客户端链接
        Socket socket = serverSocket.accept();
        //3、读取 客户端发送要下载的文件名
        InputStream inputStream = socket.getInputStream();
        byte[] b = new byte[1024];
        int len = 0;
        String downLoadFileName = "";
        while ((len = inputStream.read(b)) != -1) {
            downLoadFileName += String(b, 0, len);
        }
        System.out.print("客户端把希望下载的文件名 = " + downLoadFileName);
        //如果客户下载的是 高山流水,就返回该文件;否则一律返回 无名.mp3(默认文件)
        String resFileName = "";
        if ("高山流水".equals(downLoadFileName)) {
            resFileName = "src\\高山流水.mp3";
        }else{
            resFileName = "src\\无名.mp3";
        }
        //4、创建一个输入流读取文件
        BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(resFileName));
        //5、使用工具类StreamUtils,读取文件到一个字节数组
        byte[] bytes = StreamUtils.streamUtils.streamToByteArray(bis);
        //6、得到Socket关联的输出流
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        //7、写入到数据通道,返回给客户端
        bos.write(bytes);
        socket.shutdownOutput();    //结束标记
        //8、关闭相关的资源
        bis.close();
        inputStream.close();
        socket.close();
        serverSocket.close();
        System.out.print("服务端退出~~");
    }

UDP网络开发编程(了解):

基本介绍:
  1. 类 DatagramSocket 和 DatagramPacket 实现类基于UDP协议网络程序
  2. UDP数据报通过数据报套接字 DatagramSocket发送和接收,系统不保证UDP数据报一定能够安全送到目的地,也不能确定什么时候可以抵达
  3. DatagramPacket 对象封装了UDP数据报,在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
  4. UDP协议中每个数据报都给出了完整的地址信息,因此无须建立发送方和接收方的链接
UDP说明:
  1. 没有明确的服务端和客户端,演变成数据的发送端和接收端
  2. 接收数据和发送数据是通过DatagramSocket对象完成
  3. 将数据封装到DatagramPacket对象/装包 发送
  4. 当接收到DatagramPacket对象,需要进行拆包,取出数据
  5. DatagramSocket可以指定在哪个端口接收数据
基本流程:
  1. 核心的两个类/对象 DatagramSocket与DatagramPacket
  2. 建立发送端,接收端(没有服务端和客户端概念)
  3. 发送数据前,建立数据包/报 DatagramPacket对象
  4. 调用DatagramSocket的发送、接收方法
  5. 关闭DatagramSocket
例1:

​ 1、编写一个接收端A,和一个发送端B

​ 2、接收端A在9999端口等待接收数据(receive)

​ 3、发送端B向接收端A发送数据”hello,明天吃火锅~”

​ 4、接收端A接收到 发送端B发送端数据,回复”好的,明天见”,再退出

​ 5、发送端接收 回复的数据 ,再退出

接收端A:
        public static void main(String[] args) {
            //1、创建一个 DatagramSocket 对象,准备在9999发送和接收数据
            DatagramSocket socket = new DatagramPacket(9999);
            //2、构建一个 DatagramPacket 对象,准备接收数据,UDP一个数据包最大64k
            byte[] buf = new byte[1024];
            DatagramPacket packet = new DatagramPacket(buf,buf.length);
            //3、调用 接受方法,将通过网络传输的 DatagramPacket 对象填充到 packet对象
            //提示:当有数据包发送到 本机的9999端口时,就会接收到数据
            //     如果没有数据包发送到 本机的9999端口,就会阻塞等待
            System.out.print("接收端A 等待接收数据...");
            socket.receive(packet);
            //4、可以把packet进行拆包,取出数据,并显示
            int length = packet.getLength();    //实际接收到的数据字节长度
            byte[] data = packet.getData();     //接收到数据
            String s = new String(data, 0, length);
            System.out.print(s);
            //回复信息给B端
            //将需要发送的数据,封装到DatagramPacket对象
            data = "好的,明天见~~".getBytyes();
            //说明:封装的DatagramPacket对象 data 内容字节数组,data.length,主机(IP)
            packet = new DatagramPacket(data,data.length,InetAddress.getBuname("192.168.0.1"),9998);
            socket.send(packet);//发送
            //5、关闭资源
            socket.close();
            System.out.print("A端退出~~~");
        }
发送端B:
        public static void main(String[] args) {
            //1、创建 DatagramSocket对象,准备在9998端口 发送和接收数据
            DatagramSocket socket = new DatagramSocket(9998);
            //2、将需要发送的数据,封装到DatagramPacket对象
            byte[] data = "hello,明天吃火锅~~".getBytyes();
            //说明:封装的DatagramPacket对象 data 内容字节数组,data.length,主机(IP)
            DatagramPacket packet = new DatagramPacket(data,data.length,InetAddress.getBuname("192.168.0.1"),9999);
            socket.send(packet);//发送
            //3、接受从A端回复的信息
            //构建一个 DatagramPacket 对象,准备接受数据,UDP一个数据包最大64k
            byte[] buf = new byte[1024];
            packet = new DatagramPacket(buf,buf.length);
            //调用 接受方法,将通过网络传输的 DatagramPacket 对象填充到 packet对象
            //提示:当有数据包发送到 本机的9998端口时,就会接收到数据
            //     如果没有数据包发送到 本机的9998端口,就会阻塞等待
            socket.receive(packet);             
            //可以把packet进行拆包,取出数据,并显示
            int length = packet.getLength();    //实际接受到的数据字节长度
            data = packet.getData();        //接收到数据
            String s = new String(data, 0, length);
            System.out.print(s);
            //关闭资源
            socket.close();
            System.out.print("B端退出~~~");
        }

反射:

引出:
  1. 根据配置文件re.properties指定信息,创建Cat对象并调用方法hi
        classfullpath=com.hspeduCat
        method=hi
    
  2. 这样的需求,即通过外部文件配置,在不修改源码情况下,来控制程序,也符合设计模式的ocp原则(开闭原则:不修改源码,扩容功能)
    //1、使用Properties类,可以读写配置文件
    Properties properties = new Properties();
    //加载配置文件的键值对到Properties对象
    properties.load(new FileInputStream("src\\re.properties"));
    String classfullpath = properties.get("classfullpath").toString();//"com.hspedu.Cat"
    String methodName = properties.get("method").toString();//hi
    System.out.print("classfullpath=" + classfullpath);
    System.out.print("method=" + method);
    
    //2、创建对象,传统的方法行不通 ---> 反射机制
    //不可以 new classfullpath() ,因为classfullpath是String,不是类的全路径
    
    //3、使用反射机制解决
    //(1)加载类,返回Class类型的对象cls
    Class cls = Class.forName(classfullpath);   //Class是一个类,名字就叫Class
    //(2)通过 cls 得到加载的类 com.hspedu.Cat 的对象实例
    Object o = cls.newInstance();//运行类型:Cat
    //(3)通过 cls 得到加载的类 com.hspedu.Cat 的 methodName"hi" 的方法对象
    //  即:在反射中,可以把方法视为对象(万物皆对象)
    Method method1 = cls.getMethod(methodName);
    //(4)通过method1调用方法 : 即通过方法对象来调用方法
    System.out.print("======================");
    method1.invoke(o);
    //传统方法:对象.方法()
    //反射机制:方法.invoke(对象)
    
反射机制:
  1. 反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息(比如成员变量,构造器,成员方法等等),并能操作对象的属性及方法。反射在设计模式和框架底层都会用到
  2. 加载完类之后,在堆中就产生了一个Class类型的对象(一个类只有一个Class对象),这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个Class对象就像一面镜子,透过这个镜子看到类的结构,所以,形象的称之为:反射

反射机制可以完成:
  1. 在运行时判断任意一个对象所属的类
  2. 在运行时构造任意一个类的对象
  3. 在运行时得到任意一个类所具有的成员变量和方法
  4. 在运行时调用任意一个对象的成员变量和方法
  5. 生成动态代理
反射相关的主要类:
  1. java.lang.Class:代表一个类,Class对象表示某个类加载后在堆中的对象
  2. java.lang.reflect.Method:代表类的方法
  3. java.lang.reflect.Field:代表类的成员变量,Field对象表示某个类的成员变量
  4. java.lang.reflect.Constructor:代表类的构造方法 Constructor对象表示构造器

这些类在java.lang.reflection

    private String name;
    public int age;

    //java.lang.reflect.Field:代表类的成员变量,Field对象表示某个类的成员变量
    //getField不能得到私有的属性
    //Field nameField = cls.getField("name");   会报错
    Field nameField = cls.getField("age");
    System.out.print(nameField.get(o)); //传统写法:对象.成员变量   ,反射:成员变量对象.get(对象)

    //java.lang.reflect.Constructor:代表类的构造方法    Constructor对象表示构造器
    Constructor constructor = cls.getConstructor(); //()中可以指定构造器参数类型,这里返回无参构造器
    System.out.print(constructor);  //输出:public com.hspedu.Cat()

    //这里传入的String.class就是String类的Class对象
    Constructor constructor2 = cls.getConstructor(String.class);
    System.out.print(constructor2);//输出:public com.hspedu.Cat(java.lang.String)
反射优点和缺点:
  1. 优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑
  2. 缺点:使用反射基本都是解释执行,对执行速度有影响
反射调用优化——关闭访问检查
  1. Method和Field、Constructor对象都有setAccessible()方法
  2. setAccessible作用是启动和禁止访问安全检查的开关
  3. 参数值为true表示 反射的对象在使用时取消访问检查,提高反射的效率。

参数值为false则表示反射的对象执行访问检查

创作不易!转载请注明作者及文章链接或作者博客链接——
- 作者:pidanxia
- 链接:https://pidanxia.ink
(链接可为:**文章链接**或者**作者博客链接**)
暂无评论

发送评论 编辑评论


				
|´・ω・)ノ
ヾ(≧∇≦*)ゝ
(☆ω☆)
(╯‵□′)╯︵┴─┴
 ̄﹃ ̄
(/ω\)
∠( ᐛ 」∠)_
(๑•̀ㅁ•́ฅ)
→_→
୧(๑•̀⌄•́๑)૭
٩(ˊᗜˋ*)و
(ノ°ο°)ノ
(´இ皿இ`)
⌇●﹏●⌇
(ฅ´ω`ฅ)
(╯°A°)╯︵○○○
φ( ̄∇ ̄o)
ヾ(´・ ・`。)ノ"
( ง ᵒ̌皿ᵒ̌)ง⁼³₌₃
(ó﹏ò。)
Σ(っ °Д °;)っ
( ,,´・ω・)ノ"(´っω・`。)
╮(╯▽╰)╭
o(*////▽////*)q
>﹏<
( ๑´•ω•) "(ㆆᴗㆆ)
😂
😀
😅
😊
🙂
🙃
😌
😍
😘
😜
😝
😏
😒
🙄
😳
😡
😔
😫
😱
😭
💩
👻
🙌
🖕
👍
👫
👬
👭
🌚
🌝
🙈
💊
😶
🙏
🍦
🍉
😣
Source: github.com/k4yt3x/flowerhd
颜文字
Emoji
小恐龙
花!
上一篇
下一篇