发财!发财!发财!发财!|

Carl-Zhang

园龄:6年4个月粉丝:3关注:3

📂JAVASE
🔖JAVASE
2022-01-08 17:48阅读: 43评论: 0推荐: 0

二十、反射(完结)

二十、反射


20.1 类的加载


20.1.1 类的加载概述

程序运行后,某个类在第一次使用时,会将该类的 class 文件读取到内存,并将此类的所有信息存储到一个Class 对象中

20.1.2 类加载的时机

  1. 创建类的实例
  2. 访问类的成员
  3. 使用反射方式来强制创建某个类或接口对应的 java.lang.Class对象。
  4. 初始化某个类的子类,父类会先加载。
  5. 直接使用 java.exe 命令来运行某个主类。
    总结:用到就加载,不用就不加载

20.1.3  类加载的过程介绍

当一个**Java**** 文件要被加载到内存中使用执行的过程**

  1. 需要把当前的 Java 文件通过 Javac 编译成字节码文件(.class 文件)
  2. 字节码文件需要进行 加载 , 连接 , 初始化 三个动作
  3. 字节码数据加载到 jvm 方法区内存中, 在堆内存中创建此类的对象 , Java 程序进行使用

注意 : 把一个字节码文件加载到内存过程 , 就需要用到类加载进行完成
image.png

20.2 类的加载过程各阶段的任务


Java 程序中需要使用到某个类时,虚拟机会保证这个类已经被加载、连接和初始化。而连接又包含验证、准备和解析这三个子过程,这个过程必须严格按照顺序执行

20.2.3 加载

  • 通过类的全类名(包名和类名) , 查找此类的字节码文件,把类的.class 文件中的二进制数据流读入到内存中,并存放在运行时数据区的方法区内,然后利用字节码文件创建一个 Class 对象,用来封装类在方法区内的数据结构并存放在堆区内。
  • 简单来说 : 就是把硬盘中的字节码文件 , 加载到 jvm 中的方法区以字节码对象的形式存在 , 并存放在堆内存。

image.png

20.2.2 连接

  1. 验证 : 确保被加载类的正确性。class  文件的字节流中包含的信息符合当前虚拟机要求,不会危害虚拟机自身的安全。
  2. 准备 : 为类的静态变量分配内存,并将其设置为默认值。此阶段仅仅只为静态类变量(即 static  修饰的字段变量)分配内存,并且设置该变量的初始值。(比如 static int num = 5 ,这里只将 num  初始化为0,5的值将会在初始化时赋值)。对于 final static  修饰的变量,编译的时候就会分配了,也不会分配实例变量的内存。
  3. 解析 : 把类中的符号引用转换为直接引用。符号引用就是一组符号来描述目标,而直接引用就是直接指向目标在内存的位置,即地址,如果引用的这个类没加载进内存就会先加载,加载了就直接替换。
  • 简单理解就是如果当前类中用到了其他类, 就将符号引用替换成其他类地址

image.png

20.2.3 初始化

  • 类加载最后阶段,为静态变量赋值,静态代码块的代码也将被初始化
  • 若该类具有父类,则先对父类进行初始化
  • 底层的初始化方法加了锁,做了线程同步校验:如果多个线程同时对一个类继续初始化,一次只有一个线程会执行,其他线程会阻塞等待。

20.3  类加载器


20.3.1  Java虚拟机自带的类加载器 (了解)

类加载器:是负责将磁盘上的某个class文件读取到内存并生成Class的对象。

Java 中有三种类加载器,它们分别用于加载不同种类的 class

  • 启动类加载器( Bootstrap ClassLoader ):用于加载系统类库 <JAVA_HOME>\bin目录下的class ,例如:rt.jar
  • 扩展类加载器( Extension ClassLoader ):用于加载扩展类库 <JAVA_HOME>\lib\ext 目录下的 class
  • 应用程序类加载器( Application ClassLoader ):用于加载我们自定义类的加载器。
public class Test{
  public static void main(String[] args){
      //通过Class对象,获取类加载器的方法 --> public ClassLoader getClassLoader() : 返回该类的类加载器
      //如果该类由启动类加载器加载(例如核心类库中的类String 等),则将返回 null。 
      
    System.out.println(Test.class.getClassLoader());//sun.misc.Launcher$AppClassLoader
    System.out.println(String.class.getClassLoader());//null
  }
}

总结:

  • 在程序开发中,类的加载几乎是由上述3种类加载器相互配合执行的,同时我们还可以自定义类加载器
  • 需要注意的是,java 虚拟机对class 文件采用的是按需加载的方式,也就是说当需要使用该类时才会将它的 class 文件加载到内存中生成 class 对象
  • 而且加载某个类的 class 文件时,Java 虚拟机采用的是双亲委派模式,即把加载类的请求交由父加载器处理,它是一种任务委派模式

20.3.2  类加载器--双亲委派机制介绍

image.png
上图展示了"类加载器"的层次关系,这种关系称为类加载器的 "双亲委派模型":

  • "双亲委派模型"中,除了顶层的启动类加载器外,其余的类加载器都应当有自己的"父级类加载器"。
  • 这种关系不是通过"继承"实现的,通常是通过"组合"实现的。通过"组合"来表示父级类加载器。
  • "双亲委派模型"的工作过程
    • 某个"类加载器"收到类加载的请求,它首先不会尝试自己去加载这个类,而是把请求交给父级类加载器。
    • 因此,所有的类加载的请求最终都会传送到顶层的"启动类加载器"中。
    • 如果"父级类加载器"无法加载这个类,然后子级类加载器再去加载。
public class ClassLoaderDemo4 {
    /*
        当前是根据自己定义的类进行获取的类加载器对象
        getParent方法获取父类加载器
        第一条输出语句打印的是 : 系统类加载器
        第二条输出语句打印的是 : 扩展类加载器
        第三条输出语句打印的是 : null是根类加载器
     */
public static void main(String[] args) {
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        System.out.println(classLoader);// sun.misc.Launcher$AppClassLoader@b4aac2
        System.out.println(classLoader.getParent());// sun.misc.Launcher$ExtClassLoader@16d3586
        System.out.println(classLoader.getParent().getParent());// null
}

20.3.3 双亲委派模型的优点

  • 避免类的重复加载
    • 当父类加载器已经加载了该类时,就没有必要子 ClassLoader  再加载一次 , 字节码文件只加载一次
  • 考虑到安全因素,java 核心 api  中定义类型不会被随意替换,假设通过网络传递一个名为 java.lang.Object 的类,通过双亲委托模式传递到启动类加载器,而启动类加载器在核心 Java API 发现这个名字的类,发现该类已被加载,并不会重新加载网络传递过来的 java.lang.Object ,而直接返回已加载过的 Object.class这样便可以防止核心 **API**  库被随意篡改!!!
package java.lang;

/**
 * @author: Carl Zhang
 * @create: 2022-01-07 13:59
 *  举例 : 如果我们自己定义一个包名字叫做java.lang , 在当前这个包下创建一个类叫做MyObject类
 *  因为java.lang包属于核心包,只能由根类加载器进行加载,而根据类加载的双亲委派机制,根类加载不到这个MyObject类的(自定义的)**
 *  所以只能由AppClassLoader进行加载,而这又是不允许的,因为java.lang下的类需要使用根加载器进行加载**
 *  所以会报出"Prohilbited package name:java.lang"(禁止的包名)异常"
 */
public class MyObject {
    public static void main(String[] args) {
        System.out.println(MyObject.class.getClassLoader()); //java.lang.SecurityException: Prohibited package name: java.lang
    }
}

20.4 反射的介绍


20.4.1 反射的引入

  • 需求:如何根据配置文件 re.properties  里的不同的信息,创建指定的对象,调用各自的方法
  • 以前的方式:读取配置文件里的信息,通过 switch 格式判断class 键对应的值,创建不同的对象,调用方法
  • 问题:代码冗余,不方便
  • 引入反射:实现动态创建对象,动态调用方法,这样的需求在学习框架时特别多,即通过外部文件配置,在不修改源码情况下,来控制程序,也符合设计模式的 ocp 原则(开闭原则:不修改源码,扩容功能)

20.4.2 反射的概念

  • 反射是一种机制,利用该机制可以在程序运行过程中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性
  • 利用反射可以无视修饰符获取类里面所有的属性和方法。先获取配置文件中的信息,动态获取信息并创建对象和调用方法

20.4.3 反射的使用前提和场景

  • 使用反射操作类成员的前提
    • 要获得该类字节码文件对象,就是 Class  对象
  • 反射在实际开发中的应用:
    • 开发 IDE (集成开发环境),比如 IDEAEclipse
    • 各种框架的设计和学习 比如 SpringHibernateStructMybaits ....

20.5  Class对象的获取方式


20.5.1 三种获取方法

  • 方式1: 类名.class 获得

  • 方式2:对象名.getClass() 方法获得,该方法是继承 Object  类的

  • 方式3:Class 类的静态方法获得: static Class forName("类全名")

    • 每一个类的 Class 对象都只有一个。
  • 示例代码

package com.itheima._03反射;
public class Student{
    
}
public class ReflectDemo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        // 获得Student类对应的Class对象
        Class c1 = Student.class;

        // 创建学生对象
        Student stu = new Student();
        // 通过getClass方法
        Class c2 = stu.getClass();
        System.out.println(c1 == c2);

        // 通过Class类的静态方法获得: static Class forName("类全名")
        Class c3 = Class.forName("com.itheima._03反射.Student");
        System.out.println(c1 == c3); //true
        System.out.println(c2 == c3); //true
    }
}

20.5.2 Class类常用方法

image.png

  • String getSimpleName();  获得类名字符串:类名
  • String getName(); 获得类全名:包名+类名
  • T newInstance() ;   创建 Class对象关联类的对象

示例代码

public class ReflectDemo02 {
    public static void main(String[] args) throws Exception {
        // 获得Class对象
        Class c = Student.class;
        // 获得类名字符串:类名
        System.out.println(c.getSimpleName());
        // 获得类全名:包名+类名
        System.out.println(c.getName());
        // 创建对象
        //此方式相当于通过类的空参构造创建对象,如果目标类没有空参构造,会报错 InstantiationException
        Student stu = (Student) c.newInstance();
        System.out.println(stu);
    }
}

20.6  反射之操作构造方法


20.6.1 Constructor类概述

  • 反射之操作构造方法的目的
    • 获得 Constructor 对象来创建类的对象。
  • Constructor 类概述
    • 类中的每一个构造方法都是一个 Constructor 类的对象

20.6.2 Class类中与Constructor相关的方法

  • Constructor getConstructor(Class... parameterTypes) :返回单个公共构造方法对象
  • Constructor getDeclaredConstructor(Class... parameterTypes) :返回单个构造方法对象,不受修饰符影响
  • Constructor[] getConstructors() :返回所有公共构造方法对象的数组,只能获得 public
  • Constructor[] getDeclaredConstructors() :返回所有构造方法对象的数组,不受修饰符影响

20.6.3 Constructor对象常用方法

  • T newInstance(Object... initargs) —— 根据指定的参数创建对象
  • void setAccessible(true) :设置"暴力反射"——是否取消权限检查,true 取消权限检查,false 表示不取消

示例代码

public class Student{
   private String name;
   private String sex;
   private int age;
   
   //公有构造方法
   public Student(String name,String sex,int age){
       this.name = name;
       this.sex = sex;
       this.age = age;
   }
   //私有构造方法
   private Student(String name,String sex){
       this.name = name;
       this.sex = sex;
   }
}
public class ReflectDemo03 {

    /*
      Constructor[] getConstructors()
           获得类中的所有构造方法对象,只能获得public的
      Constructor[] getDeclaredConstructors()
            获得类中的所有构造方法对象,包括private修饰的
    */
    @Test
    public void test03() throws Exception {
        // 获得Class对象
        Class c = Student.class;
        //  获得类中的所有构造方法对象,只能获得public的
        // Constructor[] cons = c.getConstructors();
        // 获取类中所有的构造方法,包括public、protected、(默认)、private的
        Constructor[] cons = c.getDeclaredConstructors();
        for (Constructor con:cons) {
            System.out.println(con);
        }
    }

    /*
       Constructor getDeclaredConstructor(Class... parameterTypes)
           根据参数类型获得对应的Constructor对象
    */
    @Test
    public void test02() throws Exception {
        // 获得Class对象
        Class c = Student.class;
        // 获得两个参数构造方法对象
        Constructor con = c.getDeclaredConstructor(String.class,String.class);
        // 取消权限检查(暴力反射)
        con.setAccessible(true);
        // 根据构造方法创建对象
        Object obj = con.newInstance("rose","女");
        System.out.println(obj);
    }

    /*
        Constructor getConstructor(Class... parameterTypes)
            根据参数类型获得对应的Constructor对象
     */
    @Test
    public void test01() throws Exception {
        // 获得Class对象
        Class c = Student.class;
        // 获得无参数构造方法对象
        Constructor con = c.getConstructor();
        // 根据构造方法创建对象
        Object obj = con.newInstance();
        System.out.println(obj);

        // 获得有参数的构造方法对象
        Constructor con2 = c.getConstructor(String.class, String.class,int.class);
        // 创建对象
        Object obj2 = con2.newInstance("jack", "男",18);
        System.out.println(obj2);
    }
}

20.7 反射之操作成员方法


20.7.1 Method类概述

  • 反射之操作成员方法的目的
    • 操作 Method 对象来调用成员方法
  • Method 类概述
    • 每一个成员方法都是一个 Method 类的对象。

20.7.2 Class类中与Method相关的方法

  • Method getMethod(String name,Class...args); 返回单个公共的成员方法对象
  • Method getDeclaredMethod(String name,Class...args); 返回单个的成员方法对象,不受访问修饰符限制
  • Method[] getMethods(); 返回所有公共的成员方法对象,包括继承的
  • Method[] getDeclaredMethods(); 返回所有的成员方法对象,不包括继承的

20.7.3  Method对象常用方法

  • Object invoke(Object obj, Object... args)
    • 调用指定对象 obj 的该方法
    • args: 调用方法时传递的参数
    • 没有返回值,则返回 null
  • void setAccessible(true)
    设置"暴力访问"——是否取消权限检查,true 取消权限检查,false 表示不取消

示例代码

public class Student{
    private void eat(String str){
        System.out.println("我吃:" + str);
    }
    
    private void sleep(){
        System.out.println("我睡觉...");
    }
    
    public void study(int a){
        System.out.println("我学习Java,参数a = " + a);
    }
}
public class ReflectDemo04 {

    // 反射操作静态方法
    @Test
    public void test04() throws Exception {
        // 获得Class对象
        Class c = Student.class;
        // 根据方法名获得对应的公有成员方法对象
        Method method = c.getDeclaredMethod("eat",String.class);
        // 通过method执行对应的方法
        method.invoke(null,"蛋炒饭");
    }

    /*
     * Method[] getMethods();
        * 获得类中的所有成员方法对象,返回数组,只能获得public修饰的且包含父类的
     * Method[] getDeclaredMethods();
        * 获得类中的所有成员方法对象,返回数组,只获得本类的,包含private修饰的
   */
    @Test
    public void test03() throws Exception {
        // 获得Class对象
        Class c = Student.class;
        // 获得类中的所有成员方法对象,返回数组,只能获得public修饰的且包含父类的
        // Method[] methods = c.getMethods();
        // 获得类中的所有成员方法对象,返回数组,只获得本类的,包含private修饰的
        Method[] methods = c.getDeclaredMethods();
        for (Method m: methods) {
            System.out.println(m);
        }

    }

    /*
       Method getDeclaredMethod(String name,Class...args);
           * 根据方法名和参数类型获得对应的构造方法对象,
    */
    @Test
    public void test02() throws Exception {
        // 获得Class对象
        Class c = Student.class;

        // 根据Class对象创建学生对象
        Student stu = (Student) c.newInstance();
        // 获得sleep方法对应的Method对象
        Method m =  c.getDeclaredMethod("sleep");
        // 暴力反射
        m.setAccessible(true);

        // 通过m对象执行stuy方法
        m.invoke(stu);
    }

    /*
        Method getMethod(String name,Class...args);
            * 根据方法名和参数类型获得对应的构造方法对象,
     */
    @Test
    public void test01() throws Exception {
        // 获得Class对象
        Class c = Student.class;
        
        // 根据Class对象创建学生对象
        Student stu = (Student) c.newInstance();
        // 获得study方法对应的Method对象
        Method m =  c.getMethod("study");
        // 通过m对象执行stuy方法
        m.invoke(stu);


        /// 获得study方法对应的Method对象
        Method m2  = c.getMethod("study", int.class);
        // 通过m2对象执行stuy方法
        m2.invoke(stu,8);
    }
}

20.7.4 案例1:在泛型的集合里添加其他类型数据

import java.lang.reflect.Method;
import java.util.ArrayList;

/**
 * @author Carl Zhang
 * @description
 * 1. 现有集合:ArrayList<Integer>list = new ArrayList();
 * 2. 利用反射机制在这个泛型为Integer的ArrayList中存放一个String类型的对象。
 * @date 2022/1/8 18:28
 */
public class Homework02 {
    public static void main(String[] args) throws Exception {
        ArrayList<Integer> list = new ArrayList();
        //获取list的字节码对象,从而获取add方法,指定类型为Object.class,从而添加字符串
        Class<? extends ArrayList> aClass = list.getClass();
        Method add = aClass.getMethod("add", Object.class); //因为泛型只在编译时期对代理进行规范,运行时期就变成了Object
        add.invoke(list, "张三");

        System.out.println(list);

    }
}

20.7.5 案例2:反射加载配置文件

import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Properties;


/**
 * @author Carl Zhang
 * @description
 * (2)写一个程序,读取这个Properties配置文件,获得类的完整名称并加载这个类,
 *
 * (3)用反射的方式运行run方法。
 * @date 2022/1/8 19:08
 */
@SuppressWarnings("ALL")
public class Homework05 {
    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();

        //加载本地的properties文件的键值对到集合里
        //方式一:直接获取配置文件的字节流然后加载
        //FileInputStream inputStream = new FileInputStream("src\\config.properties");

        //方式二:用系统类加载器(应用程序类加载器)获取配置文件的字节流
        //getSystemResourceAsStream() 方法默认是从src目录下开始找,所以要把配置文件放到src根目录下
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); //获取系统类加载器
        InputStream inputStream = systemClassLoader.getSystemResourceAsStream("config.properties");

        //从字节流里加载配置文件的键值对到集合
        properties.load(inputStream);

        //从集合中找到全类名
        String className = properties.getProperty("className");
        System.out.println(className);

        //根据全类名获取字节码对象
        Class<?> aClass = Class.forName(className);

        //获取构造然后创建对象
        Constructor<?> constructor = aClass.getConstructor();
        Object o = constructor.newInstance();

        //拿到run方法对象并运行
        Method run = aClass.getMethod("run");
        run.invoke(o);
    }
}

20.8 反射之操作成员变量


20.8.1 Field类概述

  • 反射之操作成员变量的目的
    • 通过 Field 对象给对应的成员变量赋值和取值
  • Field 类概述
    • 每一个成员变量都是一个 Field 类的对象。

20.8.2 Class类中与Field相关的方法

  • Field getField(String name); 返回单个公共的成员变量对象
  • Field getDeclaredField(String name);  返回单个成员变量,不受修饰符限制
  • Field[] getFields(); 返回所有的公共的成员变量对象
  • Field[] getDeclaredFields(); 返回所有的成员变量对象

20.8.3 Field对象常用方法

  • void set(Object obj, Object value) :给对象obj 的属性设置值
  • Object get(Object obj) :获取对象obj 对应的属性值
  • void setAccessible(true); 暴力反射,设置为可以直接访问私有类型的属性。
  • Class getType(); 获取属性的类型,返回 Class 对象。

示例代码

public class Student{
    public String name; 
    private String gender;
    
    public String toString(){
        return "Student [name = " + name + " , gender = " + gender + "]";
    }
}
public class ReflectDemo05 {
    /*
        Field[] getFields();
            * 获得所有的成员变量对应的Field对象,只能获得public的
        Field[] getDeclaredFields();
            * 获得所有的成员变量对应的Field对象,包含private的
     */
    @Test
    public void test02() throws Exception {
        // 获得Class对象
        Class c  = Student.class;
        // 获得所有的成员变量对应的Field对象
        // Field[] fields = c.getFields();
        // 获得所有的成员变量对应的Field对象,包括private
        Field[] fields = c.getDeclaredFields();
        for (Field f: fields) {
            System.out.println(f);
        }
    }

    /*
        Field getField(String name);
            根据成员变量名获得对应Field对象,只能获得public修饰
        Field getDeclaredField(String name);
            *  根据成员变量名获得对应Field对象,包含private修饰的
     */
    @Test
    public void test01() throws Exception {
        // 获得Class对象
        Class c  = Student.class;
        // 创建对象
        Object obj = c.newInstance();
        // 获得成员变量name对应的Field对象
        Field f = c.getField("name");
        // 给成员变量name赋值
        // 给指定对象obj的name属性赋值为jack
        f.set(obj,"jack");

        // 获得指定对象obj成员变量name的值
        System.out.println(f.get(obj)); // jack
        // 获得成员变量的名字
        System.out.println(f.getName()); // name


        // 给成员变量gender赋值
        // 获得成员变量gender对应的Field对象
        Field f1 = c.getDeclaredField("gender");
        // 暴力反射
        f1.setAccessible(true);
        // 给指定对象obj的gender属性赋值为男
        f1.set(obj,"男");

        System.out.println(obj);

    }
}

20.9 使用反射解析注解


注:注解的基本介绍见 11.6 注解介绍

20.9.1 AnnotatedElement接口介绍

AnnotatedElement  : 是一个接口,定义了解析注解的方法

1. boolean isAnnotationPresent(Class<Annotation> annotationClass)
   参数 : 注解的字节码对象
   作用 : 判断当前对象是否使用了指定的注解,如果使用了则返回true,否则false
  
2. T getAnnotation(Class<T> annotationClass) 
   参数 : 注解的字节码对象
   返回值 : 根据注解类型获得对应注解对象 , 有了注解对象就可以调用属性(抽象方法),获取属性值

20.9.2 注解的解析原理

前提:Class,Constructor,Method,Field都实现了AnnotatedElement 接口。

解析注解的原理:获取注解作用位置的对象,来调用方法解析注解

  • 解析类上的注解:借助字节码对象(Class对象)
  • 解析构造方法上的注解 :借助构造器对象(Constructor对象)
  • 解析方法上的注解 :借助方法对象(Method对象)
  • 解析字段上的注解 :借助字段对象(Field对象)

相关方法:

  • isAnnotationPresent() :判断是否存在注解
  • getAnnotation():如果存在获取注解对象

20.9.3 注解的解析案例

需求如下:

1. 定义注解 `Book,要求如下:
   - 包含属性:String value()   书名
   - 包含属性:double price()  价格,默认值为 100
   - 包含属性:String[] authors() 多位作者  
   - 限制注解使用的位置 :类和成员方法上 【Target】
   - 指定注解的有效范围 :RUNTIME  【Retention】
2. 定义BookStore类,在类和成员方法上使用Book注解
3. 定义TestAnnotation测试类获取Book注解上的数据

给成员注入四大名著信息 :
    西游记     --- 施耐庵
    水浒传     --- 吴承恩
    三国演义   --- 罗贯中
    红楼梦     --- 曹雪芹 , 高鹗

Book注解 :

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

//定义一个书的注解,包含属性书名,价格(默认100),作者。作者要求可以有多名作者
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Book {

    String value();

    double price() default 100;

    String[] author();

}

BookStore类 :

@Book(value = "水浒传", author = "施耐庵")
public class BookStore {

    @Book(value = "三国演义", author = {"罗贯中"})
    public void buy() {

    }
}

**TestAnnotation**** 类:**

import java.lang.reflect.Method;
import java.util.Arrays;
/**
	思路:
	1. 类型上的注解,使用Class对象解析
	2. 方法上的注解,使用Method对象解析
*/

public class TestAnnotation {
    public static void main(String[] args) throws NoSuchMethodException {

        //解析类型上的注解
        Class<BookStore> cls = BookStore.class;
        //判断是否有Book注解,如果有进行解析
        if (cls.isAnnotationPresent(Book.class)) {
            //有
            Book book = cls.getAnnotation(Book.class);
            String name = book.value();
            double price = book.price();
            String[] author = book.author();
            System.out.println(name);
            System.out.println(price);
            System.out.println(Arrays.toString(author));
        }

        //解析方法上面的注解
        Method buyMethod = cls.getMethod("buy");
        if (buyMethod.isAnnotationPresent(Book.class)) {
            Book book = buyMethod.getAnnotation(Book.class);
            String name = book.value();
            double price = book.price();
            String[] author = book.author();
            System.out.println(name);
            System.out.println(price);
            System.out.println(Arrays.toString(author));
        }
    }
}

20.10 设计模式 - 代理模式


20.10.1 代理模式介绍

为什么要有 “代理” ?

  • 生活中就有很多例子,比如委托业务,黄牛(票贩子)等等
  • 代理就是被代理者没有能力或者不愿意去完成某件事情,需要找个人代替自己去完成这件事,这才是“代理”存在的原因。
  • 例如要租房子,房产中介可以在我们住房前代理我们找房子。中介就是代理,而自己就是被代理了。

在代码设计中,代理模式作用主要就是让   "被代理对象"  的某个方法执行之或者执行之加入其他增强逻辑。

前增强 : 例如获取当前时间

被代理对象调用方法

后增强 : 例如获取当前时间

计算方法执行的时间

20.10.2 代理的前提条件

  • 抽象角色 :声明功能 ,相当于父接口
  • 代理角色 :实现抽象功能 , 完成代理逻辑,相当于接口的实现类
  • 被代理角色 :实现抽象功能,相当于接口的实现类

意味着被代理角色和代理角色有着共同的父类型(既抽象角色) , 例如我要租房子, 我只能找房产中介, 不能找票贩子

image.png

20.10.3 代理模式的两种实现方式

  • 静态代理 (了解 , 用于对动态代理做铺垫)
  • 动态代理 (为后面学习的框架做铺垫)

20.11 静态代理模式


20.11.1 静态代理模式的介绍

  • 静态代理是由程序员创建  或 工具生成代理类的源码,再编译代理类。在程序运行前就已经存在代理类的字节码文件,代理类和被代理类的关系在运行前就确定了。
  • 简单理解 : 在程序运行之前 , 代理类就存在了,这就是静态代理 ; 动态代理是程序运行时动态生成代理类

20.11.2 静态代理实现的步骤

  • 存在一个抽象角色
  • 定义被代理角色
  • 定义代理,增强被代理角色的功能

20.11.3 静态代理案例

案例:以现实中经纪人代理明星

已知存在接口:

// 1.抽象角色
interface Star {
    // 真人秀方法
    double liveShow(double money);

    void sleep();
}

定义被代理类:

  • 定义王宝强类,实现Star方法

// 定义被代理角色(宝强)
class BaoQiang implements Star {

    @Override
    public double liveShow(double money) {
        System.out.println("参加了真人秀节目 , 赚了" + money + "元");
        return money;
    }

    @Override
    public void sleep() {
        System.out.println("宝强累了 , 睡觉了...");
    }
}

定义代理类:

  • 定义宋喆经纪人类
// 定义代理角色(宋喆),增强被代理角色的功能
class SongZhe implements Star {
    BaoQiang baoQiang = new BaoQiang();

    @Override
    public double liveShow(double money) {// 1000
        // 前增强
        System.out.println("宋喆帮宝强接了一个真人秀的活动,获取佣金" + money * 0.8 + "元");

        double v = baoQiang.liveShow(money * 0.2);

        // 后增强
        System.out.println("宋喆帮宝强把赚的钱存起来...");

        return v;
    }

    @Override
    public void sleep() {
        System.out.println("宋喆帮宝强找了一家五星级大酒店...");
        baoQiang.sleep();
        System.out.println("宋喆帮宝强退房..");
    }
}

定义测试类进行测试

public class StaticAgentDemo {
    public static void main(String[] args) {
        // 被代理角色
        BaoQiang baoQiang = new BaoQiang();
        double v = baoQiang.liveShow(1000);
        System.out.println(v);
        baoQiang.sleep();

        System.out.println("===========================");

        SongZhe songZhe = new SongZhe();
        double v1 = songZhe.liveShow(1000);
        System.out.println(v1);
        songZhe.sleep();
    }
}

关系图 :宋喆和宝强都有共同的父类型。他们的业务方法都是一样。

image.png

20.11.4 静态代理和装饰模式的区别

相同:

  • 都要实现与目标类相同的业务接口
  • 在俩个类中都要声明目标对象

不同

  • 目标不同
    • 装饰者模式考虑的是对象某个功能的扩展,是在原有功能基础上增加
    • 静态代理模式考虑的是对象某个功能的调用,对这个功能的流程把控和辅助
  • 对象获取方式不同
    • 装饰者模式是通过构造方法的传参来获取被装饰的对象
    • 静态代理模式是内部直接创建被装饰的对象

注意:设计模式本身是为了提升代码的可扩展性,灵活应用即可,不必生搬硬套,非要分出个所以然来,装饰器模式和代理模式的区别也是如此

20.12  动态代理模式


20.12.1 动态代理模式介绍

  • 在实际开发过程中往往我们自己不会去创建代理类而是通过JDK 提供的Proxy类在程序运行时,运用反射机制动态创建而成这就是我们所谓的动态代理
  • 与静态代理之间的区别,在于不用自己写代理类
  • 虽然我们不需要自己定义代理类创建代理对象,但是我们要定义对被代理对象直接访问方法的拦截,原因就是对拦截的方法做增强
  • 动态代理技术在框架中使用居多,例如:很快要学到的数据库框架 MyBatis 框架等后期学的一些主流框架技术(SpringSpringMVC )中都使用了动态代理技术。

20.12.2 动态代理相关API

  • Proxy类
    • java.lang.reflect.Proxy 类提供了用于创建动态代理类和对象的静态方法
    • 它还是由这些方法创建的所有动态代理类的超类(代理类的父类是 Proxy )。
//获取代理对象的方法
public static Object newProxyInstance (ClassLoader loader, Class<?>[] interfaces, InvocationHandler h )  

/**解析:
- 返回值:该方法返回就是动态生成的代理对象

- 参数列表说明:
  1. ClassLoader loader 	- 定义代理类的类加载器 = 被代理对象.getClass().getClassLoader();
  2. Class<?>[] interfaces 	- 代理类要实现的接口列表,要求与被代理类的接口一样。 = 被代理对象.getClass().getInterfaces();
  3. InvocationHandler h 	- 调用处理器:就是具体实现代理逻辑的接口
*/
  • **InvocationHandler**** 接口**
    • java.lang.reflect.InvocationHandler 是代理对象实际处理代理逻辑的接口,具体代理实现逻辑在其 invoke 方法中。
    • **所有代理对象调用的方法,执行是都会经过 ****invoke**。因此如果要对某个方法进行代理增强,就可以在这个 invoke 方法中进行定义。
interface InvocationHandler{
	public Object invoke(Object proxy, Method method, Object[] args);  //代理逻辑
    
    1. 返回值:方法被代理后执行的结果。
    2. 参数列表:
   		1. proxy  - 就是代理对象
  		2. method - 
  	 	3. args   - 代理对象调用方法传入参数值的对象数组.
}

20.12.3 动态代理案例

需求:将经纪人代理明星的案例使用动态代理实现

分析

  1. 把父接口定义
  2. 定义被代理类:宝强
  3. 动态生成代理类对象
  4. 创建执行代理逻辑的调用处理器
  5. 通过代理对象执行代理方法
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author Carl Zhang
 * @description 动态代理模式对BaoQiang的show方法进行处理
 * @date 2022/1/8 14:37
 */
public class DynamicProxy {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.获取被代理的对象
        BaoQiang baoQiang = new BaoQiang();

        Class<?> aClass = aClass = baoQiang.getClass(); //被代理类的字节码对象
        ClassLoader classLoader = aClass.getClassLoader(); //被代理类的类加载器
        Class<?>[] interfaces = aClass.getInterfaces(); //被代理类实现的所以的接口的数组

        //获取自定义的调用处理器对象 -- 即真正执行代理逻辑的对象
        MyInvocationHandler myInvocationHandler = new MyInvocationHandler(baoQiang);

        //2. 获取被代理类的代理对象
        Star songZhe = (Star) Proxy.newProxyInstance(classLoader,
                interfaces, myInvocationHandler);

        //3. 通过代理对象执行要代理的方法 -- 此处会执行调用处理器的invoke方法
        //double v = songZhe.liveShow(1000); -- 如果方法执行完返回null,会报空指针异常
        songZhe.liveShow(1000);
        songZhe.sleep();
    }
}

/**
 * 创建代理对象的调用处理器 -- 用来执行代理的逻辑
 */
@SuppressWarnings("ALL")
class MyInvocationHandler implements InvocationHandler {
    BaoQiang baoQiang; //被代理的对象

    public MyInvocationHandler(BaoQiang baoQiang) {
        this.baoQiang = baoQiang;
    }

    /**
     * 代理行为 - 代理对象的所有方法都会执行此处
     * @param proxy  代理对象,即songZhe
     * @param method 被代理的方法 , 即BaoQiang的show方法的Method对象
     * @param args   被代理方法的参数
     * @return 代理方法执行后的结果
     * @throws Throwable 异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object invoke = null; //用来保存被代理的方法执行的结果

        //如果是show方法就执行代理逻辑
        if (method.getName().equals("liveShow")) {
            double money = (double) args[0];

            //前增强
            System.out.println("宋喆帮宝强接真人秀,赚了" + money * 0.2);

            //查看proxy的运行时类型 -- com.heima.agent.$Proxy0 ,匿名内部类 即动态创建的代理类
            //System.out.println(proxy.getClass().getName());

            //被代理对象执行被代理方法 -- 即baoqiang执行liveShow方法
            //Object money = method.invoke(proxy, args[0]);
            invoke = method.invoke(baoQiang, money * 0.8);

            //后增强
            System.out.println("宋哲帮宝强存钱");
            return invoke;
        }

        invoke = method.invoke(baoQiang, args);
        return invoke;
    }
}


//1.抽象角色
interface Star {
    double liveShow(double money);

    void sleep();
}

//2.被代理角色
class BaoQiang implements Star {

    @Override
    public double liveShow(double money) {
        System.out.println("宝强参加了一个真人秀节目,赚了" + money + "元");
        return money;
    }

    @Override
    public void sleep() {
        System.out.println("宝强累了,睡觉了!!");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

20.12.4 动态代理调用流程

image.png

20.12.5 动态代理的缺点

只能针对接口的实现类做代理对象,普通类是不能做代理对象的。后面框架学习的时候会接触到 CGLibCode Genneration Library )可以实现对类的代理

本文作者:Carl-Zhang

本文链接:https://www.cnblogs.com/Carl-Zhang/p/15779020.html

版权声明:本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。

posted @   Carl-Zhang  阅读(43)  评论(0编辑  收藏  举报
点击右上角即可分享
微信分享提示
评论
收藏
关注
推荐
深色
回顶
收起
  1. 1 斤两十足 许冠杰
斤两十足 - 许冠杰
00:00 / 00:00
An audio error has occurred.

作词 : 许冠杰/黎彼得

作曲 : 许冠杰

我地呢班打工仔

通街走跌直投系啊坏肠胃

稳个些少到月底呀点够使(死俾你睇)

确系认真湿滞

(大英雄)六婶(上)

三太公(碰)

大众开台啦面似莲容(吃啊)

又放工 打餐蒙

围埋彻几圈啊论呀论英雄

谁是 大英雄

甩到手软起晒泡 兼侧侧膊

将的色仔密甘搏

求六索有六索

敲崩台角 呢铺真系代表作

你有天才佢有天才应该要自爱

红桃绿柳春花开皆因变灌溉

长春不老朝朝起身练跳高(身体会好好好)

晨运托住块石也几里路

螳螂太极剑术要耍几套

要长春不老 郁多的最着数(尼支签话涅)

啦啦声即刻走去揾野做

人必须知道自己嘅用途

快去奋斗你实会攀得高

你要坐benz靠自己个脑

玛丽我好钟意你

玛丽我好钟意你

你你你要有心理预备

因为我决心追上你

你你你莫逃避

财神到财神到(玛丽我好钟意你)

好心得好报(你你你要有心理预备)

财神话财神话揾钱以正路(因为我决心追上你)

财神到财神到 好走快两步(你你你莫逃避)

得到佢睇起你你有前途

香港地的飞仔打劫好新潮

香港地的飞仔打劫好新潮

下下都出的怪招

出趁街金表火钻好招摇

最怕有甘岩得甘巧

你名叫叮当 个样似蜜糖

平易近人清新开朗

我名叫kingkong 个款似james邦

最佳拍挡

学生哥好咪书咯米日夜挂住拍拖

顾住十几科 科科剐

面懵懵一肚火

饮胜 饮胜乱甘通街甩

湾仔当系秀茂坪 兴到就尽情

快乐长伴我这一生

皆因我是快乐人

锡晒你 你乖乖地我实行锡晒你

我洗衫洗裤又会整几味

跟d飞仔无得比

饮番杯冰冻啤酒

高歌一曲气量厚

无谓再去为情悔疚

你赞心厄得个嫐

为你从此相处永远 同命年恩爱绵绵

愿你长相思始终痴心一片

愿真情今生永莫变

夜夜念奴娇 轻轻把名叫

相思知多少 初恋真美妙

爱意像狂潮

梨涡浅笑 悲欢竟亦料

乐极痴恋变恨苗

情丝寸断 一朝了

梦已消 花依旧玉人沓

命里有时终需有

命里无时莫强求

人皆寻梦 梦里不分西东

显赫春风得意 未知景物朦胧

仓促岁月 世事如棋

每局都充满传奇

但求共你棋艺相比较

了解做人道理

痛别离 惜分飞

缘分一朝忍心抛弃

往日情未泯 泣咽凄声怨苍天太狠

星星会明白我心

早知恋爱像怜悯

谁料此际被情困

叹息知音梦里寻

滴滴雨点仿佛似流泪

滴在我冰冷的身躯

看看手中那玉坠

家中的她已熟睡

渐渐觉得眼眶湿遍 是雨是泪

独回味 甜蜜的往事

我共你 绿野中散步

柔情无限 百般心思 体贴尽至

若她终于见只纸船

盘旋梦里千百转

望她珍惜当中意义

齐齐把相思转

如果跟她去 惆怅没入睡

难堪枕冷空虚

还请你梦乡紧记

这一曲送给你

谁令我当晚举止失常

难自禁望君你能见谅

但觉万分紧张 皆因跟你遇上

留下了这个深刻印象

故梦去匆匆 塞雁隔西东

情恨终朝思晚盼

一封音信通

酒千盅 半天苦痛 断长梦

曳摇共对轻舟飘

互传誓约庆春晓

两心相邀影相照

愿化海鸥轻唱悦情调

千般相思似毛毛雨

抑郁苦恼一於作首诗

写遍艳丽艳词合你意

夜半轻私语

铁塔凌云 望不见欢欣人面

富士怂峙 听不见游人欢笑

自由神像在远方迷雾

山长水远未入其怀抱

檀岛滩岸 点点磷光

岂能及鱼灯在彼邦

难忘你的姿态动静

略带忧郁的一双眼睛

曾话过再不想你但今天扔忘不了你

还是深深爱着你

十个女仔九个认细

明明系老佢话唔系

三张几野扎起辫仔

青春美丽就无失礼

成日要钱多 (no money no talk...)

干水乜都窝

借钱最折堕

趴低唉契哥

有乜野会令你心花怒放

谂得多卒之更癫癫丧丧

有左佢就算打跛双脚都冇相干

无得挡 无得挡

边个系天才

边个系白痴

扮懵定蠢材

无甘易会知

天才与白痴

天才与白痴

天才与白痴

为两餐乜都肯制呀前世

撞正输晒心医滞无谓

求望发达一味靠搵丁

鬼马双星眼晾晾

米贵 冇乜问题

谂计 咪懵懵闭

度掂 就要发威

的钱就会继续来

尖沙嘴susie 屋企多靓衫

橙沟绿 米衬蓝 套套惹火抢眼

一张张买身契

枕住甘累你一世(做到甩肺)

唉 总之一句阿里吉帝

佛跳墙 整得甘鬼香

肥佬黎倒眼辉 散仔威软脚龟

咪拆了喂

傀儡求名利一世做工具

他朝跌倒可怜寄望谁

friend friend...跟你做个friend

跟你做个friend

咖真两份听

有雨抓紧伞柄 咪当沙煲乱订

知己可以做成

佢尊翁绰号包顶颈(三寸丁)

屋企住响茶果岭 (茶果岭)

见我口轻轻 当我花靓ken

实在阿啦面懵兼心精

sa yo na ra 忍着泪说goodbye啦

thanks thanks thanks monika

摸摸个袋唉洗净八个几喳

蚀埋份粮添哩次衰着啦

回头望过去始终个句

有酒应该今朝醉

(回头望过去始终个句)

有酒应该今朝醉