• JAVA【反射机制】

    目录

    一、反射机制概述

     二、理解Class类并获取Class的实例

    获取class实例的方式

    三、类的加载与ClassLoader的理解 

    四、创建运行时类的对象

    五、获取运行时类的完整结构

    获取上述运行时类的属性结构

     获取权限修饰符，数据类型，变量名

     获取运行时类中的方法

     获取方法的具体结构

     获取构造器结构

     获取运行时类的父类 

     获取运行时类带泛型的父类

    获取运行时类实现的接口

     获取运行时类所在的包

     获取运行时类声明的注释

    六、调用运行时类的指定结构

     1.如何操作运行时类中的指定的属性

     2.如何操作运行时类中的指定的方法

     七、动态代理

    一、反射机制概述

    Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。


    加载完类之后， 在堆内存的方法区中就产生了一个Class类型的对象（ 一个类只有一个Class对象） ， 这个对象就包含了完整的类的结构信息。 我们可以通过这个对象看到类的结构。 这个对象就像一面镜子， 透过这个镜子看到类的结构， 所以， 我们形象的称之为： 反射。

     1、动态语言
    是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
    主要动态语言： Object-C、 C#、 JavaScript、 PHP、 Python、 Erlang。


    2、静态语言
    与动态语言相对应的， 运行时结构不可变的语言就是静态语言。如Java、 C、C++。


    补充：动态语言 vs 静态语言
    Java不是动态语言， 但Java可以称之为“准动态语言” 。 即Java有一定的动态性， 我们可以利用反射机制、 字节码操作获得类似动态语言的特性。

     Java反射机制提供的功能
            在运行时判断任意一个对象所属的类
            在运行时构造任意一个类的对象
            在运行时判断任意一个类所具有的成员变量和方法
            在运行时获取泛型信息
            在运行时调用任意一个对象的成员变量和方法
            在运行时处理注解
            生成动态代理

    反射相关地API

    java.lang.Class:代表一个类
            java.lang.reflect.Method:代表类的方法
            java.lang.reflect.Field:代表类的成员变量
            java.lang.reflect.Constructor:代表类的构造器 

     二、理解Class类并获取Class的实例

    创建一个person类

    1. public class Person {
    2.  
    3.     private String name;
    4.     public int age;
    5.  
    6.     @Override
    7.     public String toString() {
    8.         return "Person{" +
    9.                 "name='" + name + '\'' +
    10.                 ", age=" + age +
    11.                 '}';
    12.     }
    13.  
    14.     public String getName() {
    15.         return name;
    16.     }
    17.  
    18.     public void setName(String name) {
    19.         this.name = name;
    20.     }
    21.  
    22.     public int getAge() {
    23.         return age;
    24.     }
    25.  
    26.     public void setAge(int age) {
    27.         this.age = age;
    28.     }
    29.  
    30.     public Person(String name, int age) {
    31.  
    32.         this.name = name;
    33.         this.age = age;
    34.     }
    35.  
    36.     private Person(String name) {
    37.         this.name = name;
    38.     }
    39.  
    40.     public Person() {
    41.         System.out.println("Person()");
    42.     }
    43.  
    44.     public void show(){
    45.         System.out.println("你好，我是催逝员");
    46.     }
    47.  
    48.     private String showNation(String nation){
    49.         System.out.println("我的国籍是：" + nation);
    50.         return nation;
    51.     }
    52. }

    反射之前对于person的操作

    1. //反射之前，对于Person的操作
    2.     @Test
    3.     public void test1() {
    4.  
    5.         //1.创建Person类的对象
    6.         Person p1 = new Person("催逝员", 12);
    7.  
    8.         //2.通过对象，调用其内部的属性、方法
    9.         p1.age = 10;
    10.         System.out.println(p1.toString());
    11.  
    12.         p1.show();
    13.  
    14.         //在Person类外部，不可以通过Person类的对象调用其内部私有结构。
    15.         //比如：name、showNation()以及私有的构造器
    16.     }

     使用反射机制之后对于person的操作

    1. //反射之后，对于Person的操作
    2.     @Test
    3.     public void test2() throws Exception{
    4.         //反射的源头，只有当创建了如下面这行代码中的clazz之后才能使用反射
    5.         //从这里我们可以看出类的本身也是一个对象，这正好验证了我们所说的王五皆对象
    6.         Class clazz = Person.class;
    7.         //1.通过反射，创建Person类的对象
    8.         //获取构造器
    9.         Constructor cons = clazz.getConstructor(String.class,int.class);
    10.         Object obj = cons.newInstance("催逝员", 42);
    11.         Person p = (Person) obj;
    12.         System.out.println(p.toString());
    13.         //2.通过反射，调用对象指定的属性、方法
    14.         //调用属性
    15.         Field age = clazz.getDeclaredField("age");
    16.         age.set(p,52);
    17.         System.out.println(p.toString());
    18.  
    19.         //调用方法
    20.         Method show = clazz.getDeclaredMethod("show");
    21.         show.invoke(p);
    22.  
    23.         System.out.println("*******************************");
    24.  
    25.         //通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
    26.         //调用私有的构造器
    27.         Constructor cons1 = clazz.getDeclaredConstructor(String.class);
    28.         cons1.setAccessible(true);
    29.         Person p1 = (Person) cons1.newInstance("催逝员");
    30.         System.out.println(p1);
    31.  
    32.         //调用私有的属性
    33.         Field name = clazz.getDeclaredField("name");
    34.         name.setAccessible(true);
    35.         name.set(p1,"王大队长");
    36.         System.out.println(p1);
    37.  
    38.         //调用私有的方法
    39.         Method showNation = clazz.getDeclaredMethod("showNation", String.class);
    40.         showNation.setAccessible(true);
    41.         String nation = (String) showNation.invoke(p1,"中国");//相当于String nation = p1.showNation("中国")
    42.         System.out.println(nation);
    43.  
    44.  
    45.     }

    什么情况下我们需要用反射？

    这里我们举一个例子：比方说我们有一个服务器正在运行，提供给用户访问一个具体的网页。用户可能需要登录或者是注册，我们在开服务器之前是不知道用户要干什么的。当用户给我们发送URL，解析之后知道用户想要使用登录功能，在这个时候，就通过反射造login类的方法，如果是想注册，就创建一个注册的对象。（这里的过程都是动态的，不是直接在Java代码中写死一定要创建哪一个对象的）

    既然反射性可以获取私有结构，那么反射机制和面向对象的封装性是否矛盾？

    封装性表示的是建议你去调用那些公有的，私有的功能一般是被公有的方法所调用的。

    而反射是能不能调用的问题。封装性是建议你不要调用私有的方法，但是如果真的想要调用，也是可以调用的

    获取class实例的方式

    1. 关于java.lang.Class类的理解
    2.     1.类的加载过程：
    3.     程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。
    4.     接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件
    5.     加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此
    6.     运行时类，就作为Class的一个实例。
    7.  
    8.     2.换句话说，Class的实例就对应着一个运行时类。
    9.     3.加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式
    10.     来获取此运行时类。
    1. @Test
    2.     public void test3() throws ClassNotFoundException {
    3.         //方式一：调用运行时类的属性：.class
    4.         Class clazz1 = Person.class;
    5.         System.out.println(clazz1);
    6.         //方式二：通过运行时类的对象,调用getClass()
    7.         Person p1 = new Person();
    8.         Class clazz2 = p1.getClass();
    9.         System.out.println(clazz2);
    10.  
    11.         //方式三：调用Class的静态方法：forName(String classPath)
    12.         Class clazz3 = Class.forName("com.zhuyuan.java.Person");
    13. //        clazz3 = Class.forName("java.lang.String");
    14.         System.out.println(clazz3);
    15.  
    16.         System.out.println(clazz1 == clazz2);
    17.         System.out.println(clazz1 == clazz3);
    18.  
    19.         //方式四：使用类的加载器：ClassLoader  (了解)
    20.         ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    21.         Class clazz4 = classLoader.loadClass("com.zhuyuan.java.Person");
    22.         System.out.println(clazz4);
    23.  
    24.         System.out.println(clazz1 == clazz4);
    25.  
    26.     }

     那些类型可以有class对象？

    （1） class：外部类， 成员(成员内部类， 静态内部类)， 局部内部类， 匿名内部类
    （2） interface： 接口
    （3） []：数组
    （4） enum：枚举
    （5） annotation：注解@interface
    （6） primitive type：基本数据类型
    （7） void

    1. //Class实例可以是哪些结构的说明：
    2.     @Test
    3.     public void test4(){
    4.         Class c1 = Object.class;
    5.         Class c2 = Comparable.class;
    6.         Class c3 = String[].class;
    7.         Class c4 = int[][].class;
    8.         Class c5 = ElementType.class;
    9.         Class c6 = Override.class;
    10.         Class c7 = int.class;
    11.         Class c8 = void.class;
    12.         Class c9 = Class.class;
    13.  
    14.         int[] a = new int[10];
    15.         int[] b = new int[100];
    16.         Class c10 = a.getClass();
    17.         Class c11 = b.getClass();
    18.         // 只要数组的元素类型与维度一样，就是同一个Class
    19.         System.out.println(c10 == c11);
    20.  
    21.     }

     

    三、类的加载与ClassLoader的理解 

     类的加载过程

    当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

    类的加载（load）：将类的class文件读入内存，并为之创建一个java.lang.Class对象。此过程由类加载器完成。

    类的链接（link）：将类的二进制数据合并到JRE中

    类的初始化（initialize）：JVM负责对类进行初始化

    加载：

            将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时
    数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问
    入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的
    过程需要类加载器参与。

    链接：

            将Java类的二进制代码合并到JVM的运行状态之中的过程。
            验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
            准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存
    都将在方法区中进行分配。
            解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

    初始化：
            执行类构造器()方法的过程。 类构造器()方法是由编译期自动收集类中
    所有类变量的赋值动作和静态代码块中的语句合并产生的。 （类构造器是构造类信
    息的，不是构造该类对象的构造器） 。
            当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类
    的初始化。
            虚拟机会保证一个类的()方法在多线程环境中被正确加锁和同步。 

    类的加载器的作用：

    类加载的作用： 将class文件字节码内容加载到内存中， 并将这些静态数据转换成方法区的运行时数据结构， 然后在堆中生成一个代表这个类的java.lang.Class对象， 作为方法区中类数据的访问入口。
    类缓存： 标准的JavaSE类加载器可以按要求查找类， 但一旦某个类被加载到类加载器中， 它将维持加载（缓存） 一段时间。 不过JVM垃圾回收机制可以回收这些Class对象

    了解classloader

    类加载器作用是用来把类(class)装载进内存的。 JVM 规范定义了如下类型的类的加载器。

    引导类加载器：用C++编写的，是JVM自带的类加载器， 负责Java平台核心库，用来装载核心类库。该加载器无法直接获取。

    扩展类加载器：负责jre/lib/ext目录下的jar包或 –D java.ext.dirs 指定目录下的jar包装入工作库

    系统类加载器：负责java –classpath 或 –Djava.class.path所指的目录下的类与jar包装入工
    作 ，是最常用的加载器

    1. @Test
    2.     public void test1(){
    3.         //对于自定义类，使用系统类加载器进行加载
    4.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    5.         System.out.println(classLoader);
    6.         //调用系统类加载器的getParent()：获取扩展类加载器
    7.         ClassLoader classLoader1 = classLoader.getParent();
    8.         System.out.println(classLoader1);
    9.         //调用扩展类加载器的getParent()：无法获取引导类加载器
    10.         //引导类加载器主要负责加载java的核心类库，无法加载自定义类的。
    11.         ClassLoader classLoader2 = classLoader1.getParent();
    12.         System.out.println(classLoader2);
    13.  
    14.         ClassLoader classLoader3 = String.class.getClassLoader();
    15.         System.out.println(classLoader3);
    16.  
    17.     }

    使用classloader读取配置文件。 

    1. @Test
    2.     public void test2() throws Exception {
    3.  
    4.         Properties pros =  new Properties();
    5.         //此时的文件默认在当前的module下。
    6.         //读取配置文件的方式一：
    7. //        FileInputStream fis = new FileInputStream("jdbc.properties");
    8. //        FileInputStream fis = new FileInputStream("src\\jdbc1.properties");
    9. //        pros.load(fis);
    10.  
    11.         //读取配置文件的方式二：使用ClassLoader
    12.         //配置文件默认识别为：当前module的src下
    13.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    14.         InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
    15.         pros.load(is);
    16.  
    17.  
    18.         String user = pros.getProperty("user");
    19.         String password = pros.getProperty("password");
    20.         System.out.println("user = " + user + ",password = " + password);
    21.  
    22.  
    23.  
    24.     }

    四、创建运行时类的对象

    1.  @Test
    2.     public void test1() throws IllegalAccessException, InstantiationException {
    3.  
    4.         Class clazz = Person.class;
    5.         /*
    6.         newInstance():调用此方法，创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。
    8.         要想此方法正常的创建运行时类的对象，要求：
    9.         1.运行时类必须提供空参的构造器
    10.         2.空参的构造器的访问权限得够。通常，设置为public。
    13.         在javabean中要求提供一个public的空参构造器。原因：
    14.         1.便于通过反射，创建运行时类的对象
    15.         2.便于子类继承此运行时类时，默认调用super()时，保证父类有此构造器
    17.          */
    18. //从我们结果来看，我们的newInstance在这里调用了我们Person的空参构造器
    19.         Person obj = clazz.newInstance();
    20.         System.out.println(obj);
    21.  
    22.     }

     反射的动态性

    在下面的代码中，我们并没有直接指明我们生成的对象是什么，而是通过一个随机的方式生成不同的类。

    1.  //体会反射的动态性
    2.     @Test
    3.     public void test2(){
    4.  
    5.         for(int i = 0;i < 5;i++){
    6.             int num = new Random().nextInt(3);//0,1,2
    7.             String classPath = "";
    8.             switch(num){
    9.                 case 0:
    10.                     classPath = "java.util.Date";
    11.                     break;
    12.                 case 1:
    13.                     classPath = "java.lang.Object";
    14.                     break;
    15.                 case 2:
    16.                     classPath = "com.zhuyuan.java.Person";
    17.                     break;
    18.             }
    19.  
    20.             try {
    21.                 Object obj = getInstance(classPath);
    22.                 System.out.println(obj);
    23.             } catch (Exception e) {
    24.                 e.printStackTrace();
    25.             }
    26.         }
    27.  
    28.  
    29.  
    30.     }
    31.  
    32.     /*
    33.     创建一个指定类的对象。
    34.     classPath:指定类的全类名
    35.      */
    36.     public Object getInstance(String classPath) throws Exception {
    37.        Class clazz =  Class.forName(classPath);
    38.        return clazz.newInstance();
    39.     }

    五、获取运行时类的完整结构

    java反射机制的ppt
    ppt 5星 超过95%的资源 112KB
    下载

    创建一个复杂的people类

    1. public class Creature implements Serializable {
    2.     private char gender;
    3.     public double weight;
    4.  
    5.     private void breath(){
    6.         System.out.println("生物呼吸");
    7.     }
    8.  
    9.     public void eat(){
    10.         System.out.println("生物吃东西");
    11.     }
    12.  
    13. }
    1. public interface MyInterface {
    2.     void info();
    3. }

    1. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. public @interface MyAnnotation {
    4.     String value() default "hello";
    5.  
    6. }
    1. @MyAnnotation(value="hi")
    2. public class Person extends Creature implements Comparable,MyInterface{
    3.  
    4.     private String name;
    5.     int age;
    6.     public int id;
    7.  
    8.     public Person(){}
    9.  
    10.     @MyAnnotation(value="abc")
    11.     private Person(String name){
    12.         this.name = name;
    13.     }
    14.  
    15.      Person(String name,int age){
    16.         this.name = name;
    17.         this.age = age;
    18.     }
    19.     @MyAnnotation
    20.     private String show(String nation){
    21.         System.out.println("我的国籍是：" + nation);
    22.         return nation;
    23.     }
    24.  
    25.     public String display(String interests,int age) throws NullPointerException,ClassCastException{
    26.         return interests + age;
    27.     }
    28.  
    29.  
    30.     @Override
    31.     public void info() {
    32.         System.out.println("我是一个人");
    33.     }
    34.  
    35.     @Override
    36.     public int compareTo(String o) {
    37.         return 0;
    38.     }
    39.  
    40.     private static void showDesc(){
    41.         System.out.println("我是一个可爱的人");
    42.     }
    43.  
    44.     @Override
    45.     public String toString() {
    46.         return "Person{" +
    47.                 "name='" + name + '\'' +
    48.                 ", age=" + age +
    49.                 ", id=" + id +
    50.                 '}';
    51.     }
    52. }

    获取上述运行时类的属性结构

    1. @Test
    2.     public void test1(){
    3.  
    4.         Class clazz = Person.class;
    5.  
    6.         //获取属性结构
    7.         //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
    8.         Field[] fields = clazz.getFields();
    9.         for(Field f : fields){
    10.             System.out.println(f);
    11.         }
    12.         System.out.println();
    13.  
    14.         //getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
    15.         Field[] declaredFields = clazz.getDeclaredFields();
    16.         for(Field f : declaredFields){
    17.             System.out.println(f);
    18.         }
    19.     }

     获取权限修饰符，数据类型，变量名

    1. //权限修饰符  数据类型 变量名
    2.     @Test
    3.     public void test2(){
    4.         Class clazz = Person.class;
    5.         Field[] declaredFields = clazz.getDeclaredFields();
    6.         for(Field f : declaredFields){
    7.             //1.权限修饰符
    8.             int modifier = f.getModifiers();
    9.             System.out.print(Modifier.toString(modifier) + "\t");
    10.  
    11.             //2.数据类型
    12.             Class type = f.getType();
    13.             System.out.print(type.getName() + "\t");
    14.  
    15.             //3.变量名
    16.             String fName = f.getName();
    17.             System.out.print(fName);
    18.  
    19.             System.out.println();
    20.         }
    21.  
    22.  
    23.     }

     获取运行时类中的方法

    1. @Test
    2.     public void test1(){
    3.  
    4.         Class clazz = Person.class;
    5.  
    6.         //getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
    7.         Method[] methods = clazz.getMethods();
    8.         for(Method m : methods){
    9.             System.out.println(m);
    10.         }
    11.         System.out.println();
    12.         //getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
    13.         Method[] declaredMethods = clazz.getDeclaredMethods();
    14.         for(Method m : declaredMethods){
    15.             System.out.println(m);
    16.         }
    17.     }

     

     获取方法的具体结构

    权限修饰符，返回值类型，方法名（参数类型1 形参名1，……）throws xxxException{}

    1.  @Test
    2.     public void test2(){
    3.         Class clazz = Person.class;
    4.         Method[] declaredMethods = clazz.getDeclaredMethods();
    5.         for(Method m : declaredMethods){
    6.             //1.获取方法声明的注解
    7.             Annotation[] annos = m.getAnnotations();
    8.             for(Annotation a : annos){
    9.                 System.out.println(a);
    10.             }
    11.  
    12.             //2.权限修饰符
    13.             System.out.print(Modifier.toString(m.getModifiers()) + "\t");
    14.  
    15.             //3.返回值类型
    16.             System.out.print(m.getReturnType().getName() + "\t");
    17.  
    18.             //4.方法名
    19.             System.out.print(m.getName());
    20.             System.out.print("(");
    21.             //5.形参列表
    22.             Class[] parameterTypes = m.getParameterTypes();
    23.             if(!(parameterTypes == null && parameterTypes.length == 0)){
    24.                 for(int i = 0;i < parameterTypes.length;i++){
    25.  
    26.                     //如果是最后一个的话就不要打印出逗号了。
    27.                     if(i == parameterTypes.length - 1){
    28.                         System.out.print(parameterTypes[i].getName() + " args_" + i);
    29.                         break;
    30.                     }
    31.  
    32.                     System.out.print(parameterTypes[i].getName() + " args_" + i + ",");
    33.                 }
    34.             }
    35.  
    36.             System.out.print(")");
    37.  
    38.             //6.抛出的异常
    39.             Class[] exceptionTypes = m.getExceptionTypes();
    40.             if(exceptionTypes.length > 0){
    41.                 System.out.print("throws ");
    42.                 for(int i = 0;i < exceptionTypes.length;i++){
    43.                     if(i == exceptionTypes.length - 1){
    44.                         System.out.print(exceptionTypes[i].getName());
    45.                         break;
    46.                     }
    47.  
    48.                     System.out.print(exceptionTypes[i].getName() + ",");
    49.                 }
    50.             }
    51.  
    52.  
    53.             System.out.println();
    54.         }
    55.  
    56.  
    57.  
    58.     }

     获取构造器结构

    1. @Test
    2.     public void test1(){
    3.  
    4.         Class clazz = Person.class;
    5.         //getConstructors():获取当前运行时类中声明为public的构造器
    6.         Constructor[] constructors = clazz.getConstructors();
    7.         for(Constructor c : constructors){
    8.             System.out.println(c);
    9.         }
    10.  
    11.         System.out.println();
    12.         //getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
    13.         Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
    14.         for(Constructor c : declaredConstructors){
    15.             System.out.println(c);
    16.         }
    17.  
    18.     }

     获取运行时类的父类 

    1. @Test
    2.     public void test2(){
    3.         Class clazz = Person.class;
    4.  
    5.         Class superclass = clazz.getSuperclass();
    6.         System.out.println(superclass);
    7.     }

     获取运行时类带泛型的父类

    1.  @Test
    2.     public void test3(){
    3.         Class clazz = Person.class;
    4.  
    5.         Type genericSuperclass = clazz.getGenericSuperclass();
    6.         System.out.println(genericSuperclass);
    7.     }

     获取运行时类的带泛型的父类的泛型

    1.  @Test
    2.     public void test4(){
    3.         Class clazz = Person.class;
    4.  
    5.         Type genericSuperclass = clazz.getGenericSuperclass();
    6.         //带参数的类型
    7.         ParameterizedType paramType = (ParameterizedType) genericSuperclass;
    8.         //获取泛型类型
    9.         Type[] actualTypeArguments = paramType.getActualTypeArguments();
    10. //        System.out.println(actualTypeArguments[0].getTypeName());
    11.         System.out.println(((Class)actualTypeArguments[0]).getName());
    12.     }

    C#反射在实际应用中的实例代码
    pdf 0星 超过10%的资源 47KB
    下载

    获取运行时类实现的接口

    1.  @Test
    2.     public void test5(){
    3.         Class clazz = Person.class;
    4.  
    5.         Class[] interfaces = clazz.getInterfaces();
    6.         for(Class c : interfaces){
    7.             System.out.println(c);
    8.         }
    9.  
    10.         System.out.println();
    11.         //获取运行时类的父类实现的接口
    12.         Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
    13.         for(Class c : interfaces1){
    14.             System.out.println(c);
    15.         }
    16.  
    17.     }

     

     获取运行时类所在的包

    1.  @Test
    2.     public void test6(){
    3.         Class clazz = Person.class;
    4.  
    5.         Package pack = clazz.getPackage();
    6.         System.out.println(pack);
    7.     }

     获取运行时类声明的注释

    1. @Test
    2.     public void test7(){
    3.         Class clazz = Person.class;
    4.  
    5.         Annotation[] annotations = clazz.getAnnotations();
    6.         for(Annotation annos : annotations){
    7.             System.out.println(annos);
    8.         }
    9.     }

    六、调用运行时类的指定结构

     1.如何操作运行时类中的指定的属性

    方式一： 采用实例化验一个对象之后使用getfield的方式，但是这种方式获取到的属性必须是public属性的，比较具有局限性，所以不常用

    1.  @Test
    2.     public void testField() throws Exception {
    3.         Class clazz = Person.class;
    4.  
    5.         //创建运行时类的对象
    6.         Person p = (Person) clazz.newInstance();
    7.  
    8.  
    9.         //获取指定的属性：要求运行时类中属性声明为public
    10.         //通常不采用此方法
    11.         Field id = clazz.getField("id");
    12.  
    13.         /*
    14.         设置当前属性的值
    16.         set():参数1：指明设置哪个对象的属性   参数2：将此属性值设置为多少
    17.          */
    18.  
    19.         id.set(p,1001);
    20.  
    21.         /*
    22.         获取当前属性的值
    23.         get():参数1：获取哪个对象的当前属性值
    24.          */
    25.         int pId = (int) id.get(p);
    26.         System.out.println(pId);
    27.  
    28.  
    29.     }

     方式二：下面的方法在声明了setAccessible之后就能够保证是可访问的，不管是不是公有的类，所以用途比第一种方法更加广泛，推荐使用。

    1. @Test
    2.     public void testField1() throws Exception {
    3.         Class clazz = Person.class;
    4.  
    5.         //创建运行时类的对象
    6.         Person p = (Person) clazz.newInstance();
    7.  
    8.         //1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
    9.         Field name = clazz.getDeclaredField("name");
    10.  
    11.         //2.保证当前属性是可访问的
    12.         name.setAccessible(true);
    13.         //3.获取、设置指定对象的此属性值
    14.         name.set(p,"催逝员");
    15.  
    16.         System.out.println(name.get(p));
    17.     }

     2.如何操作运行时类中的指定的方法

    1.  @Test
    2.     public void testMethod() throws Exception {
    3.  
    4.         Class clazz = Person.class;
    5.  
    6.         //创建运行时类的对象
    7.         Person p = (Person) clazz.newInstance();
    8.  
    9.         /*
    10.         1.获取指定的某个方法
    11.         getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
    12.          */
    13.         Method show = clazz.getDeclaredMethod("show", String.class);
    14.         //2.保证当前方法是可访问的
    15.         show.setAccessible(true);
    16.  
    17.         /*
    18.         3. 调用方法的invoke():参数1：方法的调用者  参数2：给方法形参赋值的实参
    19.         invoke()的返回值即为对应类中调用的方法的返回值。
    20.          */
    21.         Object returnValue = show.invoke(p,"CHN"); //String nation = p.show("CHN");
    22.         System.out.println(returnValue);
    23.  
    24.         System.out.println("*************如何调用静态方法*****************");
    25.  
    26.         // private static void showDesc()
    27.  
    28.         Method showDesc = clazz.getDeclaredMethod("showDesc");
    29.         showDesc.setAccessible(true);
    30.         //如果调用的运行时类中的方法没有返回值，则此invoke()返回null
    31. //        Object returnVal = showDesc.invoke(null);
    32.         Object returnVal = showDesc.invoke(Person.class);
    33.         System.out.println(returnVal);//null
    34.  
    35.     }

     调用运行时类中指定的构造器

    1. @Test
    2.     public void testConstructor() throws Exception {
    3.         Class clazz = Person.class;
    4.  
    5.         //private Person(String name)
    6.         /*
    7.         1.获取指定的构造器
    8.         getDeclaredConstructor():参数：指明构造器的参数列表
    9.          */
    10.  
    11.         Constructor constructor = clazz.getDeclaredConstructor(String.class);
    12.  
    13.         //2.保证此构造器是可访问的
    14.         constructor.setAccessible(true);
    15.  
    16.         //3.调用此构造器创建运行时类的对象
    17.         Person per = (Person) constructor.newInstance("催逝员");
    18.         System.out.println(per);
    19.  
    20.     }

     七、动态代理

            使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
            之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。 最好可以通过一个代理类完成全部的代理功能

    下面是一个简单的静态代理

    特点：代理类和被代理类在编译期间就被确定下来了。

    1. interface ClothFactory{
    2.  
    3.     void produceCloth();
    4.  
    5. }
    6.  
    7. //代理类
    8. class ProxyClothFactory implements ClothFactory{
    9.  
    10.     private ClothFactory factory;//用被代理类对象进行实例化
    11.  
    12.     public ProxyClothFactory(ClothFactory factory){
    13.         this.factory = factory;
    14.     }
    15.  
    16.     @Override
    17.     public void produceCloth() {
    18.         System.out.println("代理工厂做一些准备工作");
    19.  
    20.         factory.produceCloth();
    21.  
    22.         System.out.println("代理工厂做一些后续的收尾工作");
    23.  
    24.     }
    25. }
    26.  
    27. //被代理类
    28. class NikeClothFactory implements ClothFactory{
    29.  
    30.     @Override
    31.     public void produceCloth() {
    32.         System.out.println("Nike工厂生产一批运动服");
    33.     }
    34. }
    35.  
    36. public class StaticProxyTest {
    37.     public static void main(String[] args) {
    38.         //创建被代理类的对象
    39.         ClothFactory nike = new NikeClothFactory();
    40.         //创建代理类的对象
    41.         ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
    42.  
    43.         proxyClothFactory.produceCloth();
    44.  
    45.     }
    46. }

    动态代理的简单举例

    1. interface Human{
    2.  
    3.     String getBelief();
    4.  
    5.     void eat(String food);
    6.  
    7. }
    8. //被代理类
    9. class SuperMan implements Human{
    10.  
    11.  
    12.     @Override
    13.     public String getBelief() {
    14.         return "I believe I can fly!";
    15.     }
    16.  
    17.     @Override
    18.     public void eat(String food) {
    19.         System.out.println("我喜欢吃" + food);
    20.     }
    21. }
    22.  
    23. class HumanUtil{
    24.  
    25.     public void method1(){
    26.         System.out.println("====================通用方法一====================");
    27.  
    28.     }
    29.  
    30.     public void method2(){
    31.         System.out.println("====================通用方法二====================");
    32.     }
    33.  
    34. }
    35.  
    36. /*
    37. 要想实现动态代理，需要解决的问题？
    38. 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
    39. 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
    42.  */
    43.  
    44. class ProxyFactory{
    45.     //调用此方法，返回一个代理类的对象。解决问题一
    46.     public static Object getProxyInstance(Object obj){//obj:被代理类的对象
    47.         MyInvocationHandler handler = new MyInvocationHandler();
    48.  
    49.         handler.bind(obj);
    50.         //使用反射创建一个被代理类的对象，第一个参数为类的加载器，第二个参数为接口，
    51.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    52.     }
    53.  
    54. }
    55.  
    56. class MyInvocationHandler implements InvocationHandler{
    57.  
    58.     private Object obj;//需要使用被代理类的对象进行赋值
    59.  
    60.     public void bind(Object obj){
    61.         this.obj = obj;
    62.     }
    63.  
    64.     //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    65.     //将被代理类要执行的方法a的功能就声明在invoke()中
    66.     @Override
    67.     //第一个参数为代理类的对象，第二个参数为代理类的对象所调用的方法
    68.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    69.  
    70.         HumanUtil util = new HumanUtil();
    71.         util.method1();
    72.  
    73.         //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
    74.         //obj:被代理类的对象
    75.         Object returnValue = method.invoke(obj,args);
    76.  
    77.         util.method2();
    78.  
    79.         //上述方法的返回值就作为当前类中的invoke()的返回值。
    80.         return returnValue;
    81.  
    82.     }
    83. }
    84.  
    85. public class ProxyTest {
    86.  
    87.     public static void main(String[] args) {
    88.         SuperMan superMan = new SuperMan();
    89.         //proxyInstance:代理类的对象
    90.         Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
    91.         //当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
    92.         String belief = proxyInstance.getBelief();
    93.         System.out.println(belief);
    94.         proxyInstance.eat("四川麻辣烫");
    95.  
    96.         System.out.println("*****************************");
    97.  
    98.         NikeClothFactory nikeClothFactory = new NikeClothFactory();
    99.  
    100.         ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
    101.  
    102.         proxyClothFactory.produceCloth();
    103.  
    104.     }
    105. }

     

     

  • 相关阅读:
    C语言IO操作fread/fwrite/fflush
    qt实现sqlite数据库文件与csv文件相互转换
    国内Api行业，可以内卷到什么程度？
    结构体(Struct)
    robotframework+selenium+ride测试环境搭建和如何把环境迁移到不能连接互联网的环境
    AWS入门实践－S3 精细化权限控制
    Vue 2 生命周期与 Vue 3 生命周期：介绍与差别对比
    【校招VIP】计算机网络之TCP/IP模型归纳
    2012年认证杯SPSSPRO杯数学建模B题(第一阶段)减缓热岛效应全过程文档及程序
    LVS负载均衡群集
  • 原文地址：https://blog.csdn.net/weixin_62684026/article/details/125988716