• 十五章：Java反射机制

    目录

    15.1：Java反射机制概述

            15.1.1：概述

            15.1.2：Java反射机制提供的功能

    15.2：理解Class类并获取Class实例

    15.3：类的加载与ClassLoader的理解

    15.4：创建运行时类的对象

    15.5：获取运行时类的完整结构

    15.6：调用运行时类的指定结构（开发中使用）

    15.7：反射的应用：动态代理

    15.1：Java反射机制概述

            15.1.1：概述

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

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

            正常方式：引入需要的“包类”名称->通过new实例化->取得实例化对象

            反射方式：实例化对象->getClass()方法->得到完整的“包类”名称

             补充：

                    1.动态语言

                            是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件

    改变自身结构

                    2.静态语言

                            是与动态语言相对应的，运行时结构不可变的语言就是静态语言

                            例如：Java、C、C++

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

            15.1.2：Java反射机制提供的功能

                    1.在运行时判断任意一个对象所属的类

                    2.在运行时构造任意一个类的对象

                    3.在运行时判断任意一个类所具有的成员变量和方法

                    4.在运行时获取泛型信息

                    5.在运行时调用任意一个对象的成员变量和方法

                    6.在运行时处理注解

                    7.生成动态代理

    15.2：理解Class类并获取Class实例

    1. package com.jiayifeng.java;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.lang.annotation.ElementType;
    6. import java.lang.reflect.Constructor;
    7. import java.lang.reflect.Field;
    8. import java.lang.reflect.InvocationTargetException;
    9. import java.lang.reflect.Method;
    10.  
    11. /**
    12.  * author 爱编程的小贾
    13.  * create 2023-10-16 15:18
    14.  *
    15.  * 一：反射
    16.  *      疑问1：通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底使用哪一个？
    17.  *          建议：直接new的方式
    18.  *          什么时候会使用反射的方式？
    19.  *              反射的特征：动态性
    20.  *
    21.  *      疑问2：反射机制与面向对象中的封装性是不是矛盾的？如何看待这两个技术？
    22.  *          不矛盾
    23.  *
    24.  * 二：关于java.lang.Class类的理解
    25.  *      1.类的加载过程：
    26.  *          程序经过javac.exe命令以后，会生成一个或多个字节码文件（.class结尾）
    27.  *          接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码
    28.  *          文件加载到内存中。此过程就是类的加载。加载到内存中的类，我们就称之为运行时类，
    29.  *          此运行时类，就作为Class的一个实例
    30.  *
    31.  *      2.换句话说，Class的实例就对应着一个运行时类
    32.  *
    33.  *      3.加载到内存中的运行时类，会缓存一定的时间。在此时间内，我们可以通过不同的方式来
    34.  *      获取此运行时类
    35.  */
    36. public class ReflectionTest {
    37. //    反射之前,对Person类的操作
    38.     @Test
    39.     public void test(){
    40. //        1.创建Person类的对象
    41.         Person p1 = new Person("Tom",12);
    42.  
    43. //        2.通过对象，调用其内部的属性、方法
    44.         p1.age = 10;
    45.         System.out.println(p1.toString());
    46.         p1.show();
    47.  
    48. //        在Person类外部，不可以通过Person类的对象调用其内部私有结构
    49. //        比如：name、showNation()、以及私有的构造器
    50.     }
    51.  
    52. //    反射之后，对Person类的操作
    53.     @Test
    54.     public void test1() throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    55.         Class clazz = Person.class;
    56. //        1.通过反射，创建Person类的对象
    57.         Constructor cons = clazz.getConstructor(String.class, int.class);
    58.         Object obj = cons.newInstance("Tom",12);
    59.         Person p = (Person)obj;
    60.         System.out.println(p.toString());
    61. //        2.通过反射，调用对象指定的属性、方法
    62. //        调用属性
    63.         Field age = clazz.getDeclaredField("age");
    64.         age.set(p,10);
    65.         System.out.println(p.toString());
    66.  
    67. //        调用方法
    68.         Method show = clazz.getDeclaredMethod("show");
    69.         show.invoke(p);
    70.  
    71. //        通过反射，可以调用Person类的私有结构的。比如：私有的构造器、方法、属性
    72.         Constructor cons1 = clazz.getDeclaredConstructor(String.class);
    73.         cons1.setAccessible(true);
    74.         Person p1 = (Person)cons1.newInstance("Jerry");
    75.         System.out.println(p1);
    76.  
    77. //        调用私有属性
    78.         Field name = clazz.getDeclaredField("name");
    79.         name.setAccessible(true);
    80.         name.set(p1,"hanmeimei");
    81.         System.out.println(p1);
    82.  
    83. //        调用私有方法
    84.         Method showNation = clazz.getDeclaredMethod("showNation", String.class);
    85.         showNation.setAccessible(true);
    86.         String nation = (String) showNation.invoke(p1, "中国");//相当于String nation = p1.showNation("中国")
    87.         System.out.println(nation);
    88.     }
    89.  
    90.     @Test
    91.     public void test2() throws ClassNotFoundException {
    92. //        获取Class的实例的方式
    93. //        方式一：调用运行时类的属性：.class
    94.         Class clazz1 = Person.class;
    95.         System.out.println(clazz1);
    96.  
    97. //        方式二：通过运行时类的对象，调用getClass()
    98.         Person p1 = new Person();
    99.         Class clazz2 = p1.getClass();
    100.         System.out.println(clazz2);
    101.  
    102. //        方式三：调用Class的静态方法：forName(String classPath)（使用频率高）
    103.         Class clazz3 = Class.forName("com.jiayifeng.java.Person");
    104.         System.out.println(clazz3);
    105.  
    106.         System.out.println(clazz1 == clazz2);//true
    107.         System.out.println(clazz1 == clazz3);//true
    108.         System.out.println(clazz2 == clazz3);//ture
    109.  
    110. //        方式四：使用类的加载器：ClassLoader(了解)
    111.         ClassLoader classLoader = ReflectionTest.class.getClassLoader();
    112.         Class clazz4 = classLoader.loadClass("com.jiayifeng.java.Person");
    113.         System.out.println(clazz4);
    114.         System.out.println(clazz1 == clazz4);
    115.     }
    116.  
    117.     @Test
    118.     public void test3(){
    119.         Class c1 = Object.class;
    120.         Class c2 = Comparable.class;
    121.         Class c3 = String[].class;
    122.         Class c4 = int[][].class;
    123.         Class c5 = ElementType.class;
    124.         Class c6 = Override.class;
    125.         Class c7 = int.class;
    126.         Class c8 = void.class;
    127.         Class c9 = Class.class;
    128.  
    129.         int[] a = new int[10];
    130.         int[] b = new int[100];
    131.         Class c10 = a.getClass();
    132.         Class c11 = b.getClass();
    133. //        只要数组的元素类型与维度一样，就是同一个Class
    134.         System.out.println(c10 == c11);//true
    135.  
    136.     }
    137. }
    1. package com.jiayifeng.java;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-16 15:21
    6.  */
    7. public class Person {
    8.     private String name;
    9.     public int age;
    10.  
    11.     public Person() {
    12.     }
    13.  
    14.     public Person(String name, int age) {
    15.         this.name = name;
    16.         this.age = age;
    17.     }
    18.  
    19.     private Person(String name) {
    20.         this.name = name;
    21.     }
    22.  
    23.     public String getName() {
    24.         return name;
    25.     }
    26.  
    27.     public void setName(String name) {
    28.         this.name = name;
    29.     }
    30.  
    31.     public int getAge() {
    32.         return age;
    33.     }
    34.  
    35.     public void setAge(int age) {
    36.         this.age = age;
    37.     }
    38.  
    39.     @Override
    40.     public String toString() {
    41.         return "Person{" +
    42.                 "name='" + name + '\'' +
    43.                 ", age=" + age +
    44.                 '}';
    45.     }
    46.  
    47.     public void show(){
    48.         System.out.println("你好，我是一个人！");
    49.     }
    50.  
    51.     private String showNation(String nation){
    52.         System.out.println("我的国籍是：" + nation);
    53.         return nation;
    54.     }
    55. }

    15.3：类的加载与ClassLoader的理解

    1. package com.jiayifeng.java;
    2.  
    3. import org.junit.Test;
    4.  
    5. import java.io.FileInputStream;
    6. import java.io.FileNotFoundException;
    7. import java.io.IOException;
    8. import java.io.InputStream;
    9. import java.util.Properties;
    10.  
    11. /**
    12.  * author 爱编程的小贾
    13.  * create 2023-10-16 16:44
    14.  */
    15. public class ClassLoaderTest {
    16.     @Test
    17.     public void test1(){
    18. //        对于自定义类，使用系统类加载器进行加载
    19.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    20.         System.out.println(classLoader);
    21.  
    22. //        调用系统类加载器的getParent()：获取扩展类加载器
    23.         ClassLoader classLoader1 = classLoader.getParent();
    24.         System.out.println(classLoader1);
    25.  
    26. //        调用扩展类加载器的getParent()：无法获取引导类加载器
    27. //        引导类加载器主要负责加载java的核心类库，无法加载自定义类的
    28.         ClassLoader classLoader2 = classLoader1.getParent();
    29.         System.out.println(classLoader2);
    30.  
    31.         ClassLoader classLoader3 = String.class.getClassLoader();
    32.         System.out.println(classLoader3);
    33.     }
    34.  
    35.     /*
    36.     Properties：用来读取配置文件
    37.      */
    38.     @Test
    39.     public void test2() throws IOException {
    40.         Properties pros = new Properties();
    41. //        此时的文件默认在当前的module下
    42. //        读取配置文件的方式一：
    43. //        FileInputStream fis = new FileInputStream("jdbc.properties");
    44. //        pros.load(fis);
    45.  
    46. //        读取配置文件的方式二：
    47. //        配置文件默认识别为：当前的module的src下
    48.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
    49.         InputStream is = classLoader.getResourceAsStream("jdbc1.properties");
    50.         pros.load(is);
    51.  
    52.         String user = pros.getProperty("user");
    53.         String password = pros.getProperty("password");
    54.         System.out.println("user = " + user + ",password = " + password);
    55.     }
    56. }

    15.4：创建运行时类的对象

    1. package com.jiayifeng.java;
    2.  
    3. import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
    4. import org.junit.Test;
    5.  
    6. import java.util.Random;
    7.  
    8. /**
    9.  * author 爱编程的小贾
    10.  * create 2023-10-16 17:05
    11.  *
    12.  * 一：通过发射创建对应的运行时类的对象
    13.  */
    14. public class NewInstanceTest {
    15.     @Test
    16.     public void test1() throws InstantiationException, IllegalAccessException {
    17.         Class clazz = Person.class;
    18. //        newInstance()：调用此方法，创建对应的运行时类的对象
    19. //        内部调用了运行时类的空参的构造器
    20.         /*
    21.         要想此方法正常的创建运行时类的对象，要求：
    22.             1.运行时类必须提供空参的构造器
    23.             2.空参的构造器的访问权限得够。通常，设置为public
    25.             在javabean中要求提供一个public的空参构造器。原因：
    26.                 1.便于通过反射，创建运行时类的对象
    27.                 2.便于子类继承此运行时类时，默认使用super()时，保证父类有此构造器
    28.          */
    29.         Person obj = clazz.newInstance();
    30.         System.out.println(obj);
    31.     }
    32.  
    33. //    体会反射的动态性
    34.     @Test
    35.     public void test2(){
    36.         for(int i = 0;i < 100;i++){
    37.             int num = new Random().nextInt(3);//0 1 2
    38.             String classPath = "";
    39.             switch (num){
    40.                 case 0:
    41.                     classPath = "java.util.Date";
    42.                     break;
    43.                 case  1:
    44.                     classPath = "java.lang.Object";
    45.                     break;
    46.                 case 2:
    47.                     classPath = "com.jiayifeng.java.Person";
    48.                     break;
    49.             }
    50.  
    51.             try {
    52.                 Object obj = getInstance(classPath);
    53.                 System.out.println(obj);
    54.             } catch (Exception e) {
    55.                 throw new RuntimeException(e);
    56.             }
    57.         }
    58.     }
    59.  
    60. //    创建一个指定类的对象。
    61. //    ClassPath：指定类的全类名
    62.     public Object getInstance(String classPath) throws Exception {
    63.         Class clazz = Class.forName(classPath);
    64.         return clazz.newInstance();
    65.     }
    66. }

    15.5：获取运行时类的完整结构

    1. package com.jiayifeng.java1;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-18 13:49
    6.  */
    7. @MyAnnotation(value = "hi")
    8. public class Person extends Creature implements Comparable,MyInterface{
    9.     private String name;
    10.     int age;
    11.     public int id;
    12.  
    13.     public Person(){
    14.  
    15.     }
    16.  
    17.    @MyAnnotation(value = "abc")
    18.     private Person(String name){
    19.         this.name = name;
    20.     }
    21.  
    22.     Person(String name,int age){
    23.         this.name = name;
    24.         this.age = age;
    25.     }
    26.  
    27.     @MyAnnotation
    28.     public String show(String nation){
    29.         System.out.println("我的国籍是：" + nation);
    30.         return nation;
    31.     }
    32.  
    33.     public String display(String interests) throws Exception{
    34.         return interests;
    35.     }
    36.     @Override
    37.     public void info() {
    38.         System.out.println("我是一个人");
    39.     }
    40.  
    41.     @Override
    42.     public int compareTo(String o) {
    43.         return 0;
    44.     }
    45. }
    1. package com.jiayifeng.java1;
    2.  
    3. import java.lang.annotation.Retention;
    4. import java.lang.annotation.RetentionPolicy;
    5. import java.lang.annotation.Target;
    6.  
    7. import static java.lang.annotation.ElementType.*;
    8. import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
    9.  
    10. /**
    11.  * author 爱编程的小贾
    12.  * create 2023-10-18 13:59
    13.  */
    14.  
    15. @Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    16. @Retention(RetentionPolicy.RUNTIME)
    17. public @interface MyAnnotation {
    18.     String value() default "hello";
    19. }
    1. package com.jiayifeng.java1;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-18 13:52
    6.  */
    7. public interface MyInterface {
    8.     void info();
    9. }
    1. package com.jiayifeng.java1;
    2.  
    3. import java.io.Serializable;
    4.  
    5. /**
    6.  * author 爱编程的小贾
    7.  * create 2023-10-18 13:49
    8.  */
    9. public class Creature implements Serializable {
    10.     private char gender;
    11.     public double weight;
    12.  
    13.     private void breate(){
    14.         System.out.println("生物呼吸");
    15.     }
    16.  
    17.     public void eat(){
    18.         System.out.println("生物吃东西");
    19.     }
    20. }

     属性测试：

    1. package com.jiayifeng.java2;
    2.  
    3. import com.jiayifeng.java1.Person;
    4. import org.junit.Test;
    5.  
    6. import java.lang.reflect.Field;
    7. import java.lang.reflect.Modifier;
    8.  
    9. /**
    10.  * author 爱编程的小贾
    11.  * create 2023-10-18 14:03
    12.  *
    13.  * 一：获取当前运行时类的属性结构
    14.  */
    15. public class FieldTest {
    16.     @Test
    17.     public void test(){
    18.         Class clazz = Person.class;
    19.  
    20. //        获取属性结构
    21. //        getFields()：获取当前运行时类及其父类中声明为public访问权限的属性
    22.         Field[] fileds = clazz.getFields();
    23.         for(Field f : fileds){
    24.             System.out.println(f);
    25.         }
    26.         System.out.println();
    27. //        public int com.jiayifeng.java1.Person.id
    28. //        public double com.jiayifeng.java1.Creature.weight
    29.  
    30. //        getDeclaredFields()：获取当前运行时类中声明的所有属性（不包含父类中声明的属性）
    31.         Field[] declareFileds = clazz.getDeclaredFields();
    32.         for(Field f : declareFileds){
    33.             System.out.println(f);
    34.         }
    35. //        private java.lang.String com.jiayifeng.java1.Person.name
    36. //        int com.jiayifeng.java1.Person.age
    37. //        public int com.jiayifeng.java1.Person.id
    38.     }
    39.  
    40.     @Test
    41.     public void test1(){
    42.         Class clazz = Person.class;
    43.         Field[] declareFields = clazz.getDeclaredFields();
    44.         for(Field f : declareFields){
    45. //            1.权限修饰符
    46.             int modifiers = f.getModifiers();
    47.             System.out.print(Modifier.toString(modifiers));
    48.  
    49. //            2.数据类型
    50.             Class type = f.getType();
    51.             System.out.print(type.getName() + "\t");
    52.  
    53. //            3.变量名
    54.             String fName = f.getName();
    55.             System.out.println(fName);
    56.  
    57.             System.out.println();
    58.         }
    59.     }
    60. }

    方法测试：

    1. package com.jiayifeng.java2;
    2.  
    3. import com.jiayifeng.java1.Person;
    4. import org.junit.Test;
    5.  
    6. import java.lang.annotation.Annotation;
    7. import java.lang.reflect.Method;
    8. import java.lang.reflect.Modifier;
    9.  
    10. /**
    11.  * author 爱编程的小贾
    12.  * create 2023-10-18 14:21
    13.  *
    14.  * 一：获取运行时类的方法结构
    15.  */
    16. public class MethodTest {
    17.     @Test
    18.     public void test1(){
    19.         Class clazz = Person.class;
    20. //        clazz.getMethods()：获取当前运行时类及其所有父类中声明为public权限的方法
    21.         Method[] methods = clazz.getMethods();
    22.         for(Method m : methods){
    23.             System.out.println(m);
    24.         }
    25.         System.out.println();
    26.  
    27. //        getDeclaredMethods()：获取当前运行时类中声明的所有方法（不包含父类中声明的方法）
    28.         Method[] declaredMethods = clazz.getDeclaredMethods();
    29.         for(Method m : declaredMethods){
    30.             System.out.println(m);
    31.         }
    32.     }
    33.  
    34.     @Test
    35.     public void test2(){
    36.         Class clazz = Person.class;
    37.         Method[] declaredMethods = clazz.getDeclaredMethods();
    38.         for(Method m : declaredMethods){
    39. //            1.获取方法声明的注解
    40.             Annotation[] annotations = m.getAnnotations();
    41.             for(Annotation a :annotations){
    42.                 System.out.println(a);
    43.             }
    44.  
    45. //            2.权限修饰符
    46.             System.out.print(Modifier.toString(m.getModifiers()) + "\t");
    47.  
    48. //            3.返回值类型
    49.             System.out.println(m.getReturnType().getName() + "\t");
    50.  
    51. //            4.方法名
    52.             System.out.println(m.getName());
    53.  
    54. //            5.形参列表
    55.             System.out.print("(");
    56.             Class[] parameterTypes = m.getParameterTypes();
    57.             if (!(parameterTypes == null && parameterTypes.length == 0)) {
    58.                 for(int i = 0;i < parameterTypes.length;i++){
    59.                     if(i == parameterTypes.length - 1) {
    60.                         System.out.print(parameterTypes[i].getName() + "args_" + i);
    61.                         break;
    62.                     }
    63.                     System.out.println(parameterTypes[i].getName() + "args_" + i + ",");
    64.                 }
    65.             }
    66.             System.out.print(")");
    67.  
    68. //            6.抛出的异常
    69.             Class[] exceptionTypes = m.getExceptionTypes();
    70.             if(exceptionTypes.length > 0){
    71.                 System.out.print("throws：");
    72.                 for(int i = 0;i < exceptionTypes.length;i++){
    73.                     if(i == exceptionTypes.length - 1){
    74.                         System.out.print(exceptionTypes[i].getName());
    75.                         break;
    76.                     }
    77.                     System.out.print(exceptionTypes[i].getName() + ",");
    78.                 }
    79.             }
    80.             System.out.println();
    81.  
    82.         }
    83.     }
    84. }

     其它测试：

    1. package com.jiayifeng.java2;
    2.  
    3. import com.jiayifeng.java1.Person;
    4. import org.junit.Test;
    5.  
    6. import java.lang.annotation.Annotation;
    7. import java.lang.reflect.Constructor;
    8. import java.lang.reflect.ParameterizedType;
    9. import java.lang.reflect.Type;
    10. import java.sql.SQLOutput;
    11.  
    12. /**
    13.  * author 爱编程的小贾
    14.  * create 2023-10-18 14:47
    15.  */
    16. public class OtherTest {
    17.     /*
    18.     获取构造器结构
    19.      */
    20.     @Test
    21.     public void test1() {
    22.         Class clazz = Person.class;
    23. //        getConstructors()：获取当前运行时类中声明为public的构造器
    24.         Constructor[] constructors = clazz.getConstructors();
    25.         for(Constructor c : constructors){
    26.             System.out.println(c);
    27.         }
    28.         System.out.println();
    29.  
    30. //        getDeclaredConstructors()：获取当前运行时类中声明的所有的构造器
    31.         Constructor[] declaredConstructor = clazz.getDeclaredConstructors();
    32.            for(Constructor c : declaredConstructor){
    33.                System.out.println(c);
    34.         }
    35.     }
    36.  
    37.     /*
    38.     获取运行时的父类
    39.      */
    40.     @Test
    41.     public void test2(){
    42.          Class clazz = Person.class;
    43.         Class superclass = clazz.getSuperclass();
    44.         System.out.println(superclass);
    45.     }
    46.  
    47.     /*
    48.     获取运行时带泛型的父类
    49.      */
    50.     @Test
    51.     public void test3(){
    52.         Class clazz = Person.class;
    53.         Type genericSuperclass = clazz.getGenericSuperclass();
    54.         System.out.println(genericSuperclass);
    55.     }
    56.  
    57.     /*
    58.     获取运行时类的带泛型的父类的泛型
    59.      */
    60.     @Test
    61.     public void test4(){
    62.         Class clazz = Person.class;
    63.         Type genericSuperclass = clazz.getGenericSuperclass();
    64.         ParameterizedType parameterizedType = (ParameterizedType) genericSuperclass;
    65. //        获取泛型类型
    66.         Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
    67.         System.out.println(actualTypeArguments[0].getTypeName());
    68.  
    69.     }
    70.  
    71.     /*
    72.     获取运行时类实现的接口
    73.      */
    74.     @Test
    75.     public void test5(){
    76.         Class clazz = Person.class;
    77.         Class[] interfaces = clazz.getInterfaces();
    78.         for(Class c : interfaces){
    79.             System.out.println(c);
    80.         }
    81.  
    82.         System.out.println();
    83.  
    84.         Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
    85.         for(Class c : interfaces){
    86.             System.out.println(c);
    87.         }
    88.     }
    89.  
    90.     /*
    91.     获取当前运行时类所在的包
    92.      */
    93.     @Test
    94.     public void test6(){
    95.         Class clazz = Person.class;
    96.         Package aPackage = clazz.getPackage();
    97.         System.out.println(aPackage);
    98.     }
    99.  
    100.     /*
    101.     获取运行时类所声明的注解
    102.      */
    103.     @Test
    104.     public void test7(){
    105.         Class clazz = Person.class;
    106.         Annotation[] annotations = clazz.getAnnotations();
    107.         for(Annotation a : annotations){
    108.             System.out.println(a);
    109.         }
    110.     }
    111. }

    15.6：调用运行时类的指定结构（开发中使用）

    1. package com.jiayifeng.java2;
    2.  
    3. import com.jiayifeng.java1.Person;
    4. import org.junit.Test;
    5.  
    6. import java.lang.reflect.Field;
    7. import java.lang.reflect.InvocationTargetException;
    8. import java.lang.reflect.Method;
    9.  
    10. /**
    11.  * author 爱编程的小贾
    12.  * create 2023-10-18 15:13
    13.  *
    14.  * 一：调用运行时类中指定的结构：属性、方法、构造器
    15.  */
    16. public class ReflectionTest {
    17.     @Test
    18.     public void test1() throws InstantiationException, IllegalAccessException, NoSuchFieldException {
    19.         Class clazz = Person.class;
    20. //        创建运行时类的对象
    21.         Person p = (Person)clazz.newInstance();
    22. //        获取指定的属性：要求运行时类中的属性声明为public
    23. //        通常不采用此方法
    24.         Field id = clazz.getField("id");
    25.  
    26.         /*
    27.         设置当前属性的值
    28.             set()：参数1：指明设置哪个对象的属性 参数2：将此属性值设置为多少
    29.          */
    30.         id.set(p,1001);
    31.  
    32.         /*
    33.         获取当前属性的值
    34.             get()：参数1：获取哪个对象的当前属性值
    35.          */
    36.         int Pid = (int)id.get(p);
    37.         System.out.println(Pid);
    38.     }
    39.  
    40.     /*
    41.     如何操作运行时类中的指定的属性
    42.      */
    43.     @Test
    44.     public void test2() throws InstantiationException, IllegalAccessException, NoSuchFieldException {
    45.         Class clazz = Person.class;
    46. //        创建运行时类的对象
    47.         Person p = (Person)clazz.newInstance();
    48. //        1.getDeclaredField()：获取运行时类中指定变量名的属性
    49.         Field name = clazz.getDeclaredField("name");
    50.  
    51. //        2.setAccessible()：保证当前属性是可访问的
    52.         name.setAccessible(true);
    53. //        3.获取、设置指定对象的此属性值
    54.         name.set(p,"Tom");
    55.         System.out.println(name.get(p));
    56.     }
    57.  
    58.     /*
    59.     如何获取运行时类中的指定的方法
    60.      */
    61.     @Test
    62.     public void test3() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
    63.         Class clazz = Person.class;
    64. //        创建运行时类的对象
    65.         Person p = (Person)clazz.newInstance();
    66. //        1.获取指定的某个方法
    67. //        getDeclaredMethod()：参数1：指明获取的方法的名称 参数2：指明获取的方法的形参列表
    68.         Method show = clazz.getDeclaredMethod("show", String.class);
    69. //        2.保证当前方法是可访问的
    70.         show.setAccessible(true);
    71. //        3.调用方法invoke()：参数1：方法的调用者 参数2：给方法形参赋值的实参
    72. //        invoke()的返回值即为对应类中调用的方法的返回值
    73.         Object returnValue = show.invoke(p, "CHN");
    74.         System.out.println(returnValue);
    75.  
    76.         System.out.println("******如何调用静态方法*******");
    77.         Method showDesc = clazz.getDeclaredMethod("showDesc");
    78.         showDesc.setAccessible(true);
    79. //        如果调用的运行时类中的方法没有返回值，则此invoke()返回null
    80.         Object returnVal = showDesc.invoke(Person.class);
    81.         System.out.println(returnVal);
    82.     }
    83.  
    84.     @Test
    85.     public void test4(){
    86.         
    87.     }
    88. }

    15.7：反射的应用：动态代理

    代理设计模式的原理：

            使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上

    静态代理的特征：

            代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理。最好可以通过一个代理类完成全部的代理功能

    动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象

    动态代理的使用场合 ：

            调试

            远程方法调用

    1. package com.jiayifeng.java3;
    2.  
    3. /**
    4.  * author 爱编程的小贾
    5.  * create 2023-10-18 18:52
    6.  *
    7.  * 一：静态代理举例
    8.  *      特点：代理类和被代理类在编译期间就确定下来了
    9.  */
    10. interface ClothFactory{
    11.     void produceCloth();
    12. }
    13.  
    14. //代理类
    15. class ProxyClothFactory implements ClothFactory{
    16.     private ClothFactory factory;
    17.  
    18.     public ProxyClothFactory(ClothFactory factory){
    19.         this.factory = factory;
    20.     }
    21.  
    22.  
    23.     @Override
    24.     public void produceCloth() {
    25.         System.out.println("代理工厂做一些准备工作");
    26.  
    27.         factory.produceCloth();
    28.  
    29.         System.out.println("代理工厂做一些后续的收尾工作");
    30.     }
    31. }
    32.  
    33. //被代理类
    34. class NikeClothFactory implements ClothFactory{
    35.  
    36.     @Override
    37.     public void produceCloth() {
    38.         System.out.println("Nike工厂生产一批运动服");
    39.     }
    40. }
    41. public class StaticProxyTest {
    42.     public static void main(String[] args) {
    43. //        创建被代理类的对象
    44.         NikeClothFactory nike = new NikeClothFactory();
    45. //        创建代理类的对象
    46.         ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);
    47.  
    48.         proxyClothFactory.produceCloth();
    49.     }
    50.  
    51. }
    52.  
    53.  
    54.  
    1. package com.jiayifeng.java3;
    2.  
    3. import java.lang.reflect.InvocationHandler;
    4. import java.lang.reflect.Method;
    5. import java.lang.reflect.Proxy;
    6.  
    7. /**
    8.  * author 爱编程的小贾
    9.  * create 2023-10-18 19:06
    10.  *
    11.  * 一：动态代理的举例
    12.  */
    13. interface Human{
    14.     String getBelief();
    15.     void eat(String food);
    16. }
    17.  
    18. //被代理类
    19. class SuperMan implements Human{
    20.  
    21.  
    22.     @Override
    23.     public String getBelief() {
    24.         return "I belive I can fly!";
    25.     }
    26.  
    27.     @Override
    28.     public void eat(String food) {
    29.         System.out.println("我喜欢吃" + food);
    30.     }
    31. }
    32.  
    33. /*
    34. 要想实现动态代理，需要解决的问题？
    35.     问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象
    36.     问题二：当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法
    37.  */
    38. class ProxyFactory{
    39. //    调用此方法，返回一个代理类的对象。解决问题一
    40.     public static Object getProxyInstance(Object obj){//obj：被代理类的对象
    41.         MyInvocationHandler handler = new MyInvocationHandler();
    42.  
    43.         handler.bind(obj);
    44.  
    45.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
    46.                 obj.getClass().getInterfaces(),handler);
    47.     }
    48. }
    49.  
    50. class MyInvocationHandler implements InvocationHandler{
    51.     private Object obj;//赋值时也需要使用被代理类的对象进行赋值
    52.  
    53.     public void bind(Object obj){
    54.         this.obj = obj;
    55.     }
    56. //    当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    57. //    将被代理类要执行的方法a的功能就声明在invoke()中
    58.     @Override
    59.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    60. //        method：即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
    61. //        obj：被代理类的对象
    62.         Object returnValue = method.invoke(obj, args);
    63. //        上述方法的返回值就作为当前类中的invoke()的返回值
    64.         return returnValue;
    65.     }
    66. }
    67. public class ProxyTest {
    68.     public static void main(String[] args) {
    69.         SuperMan superMan = new SuperMan();
    70.         Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan);
    71. //        当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
    72.         String belief = proxyInstance.getBelief();
    73.         System.out.println(belief);
    74.         proxyInstance.eat("四川麻辣烫");
    75.         System.out.println("***************");
    76.  
    77.         NikeClothFactory nikeClothFactory = new NikeClothFactory();
    78.         ClothFactory proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
    79.         proxyClothFactory.produceCloth();
    80.     }
    81. }
  • 相关阅读:
    element日历插件获取显示的第一天和最后一天
    设计模式之保护性暂停
    【工作技术栈】记录一次jvm参数顺序导致的参数不生效问题，远程debug出现connection refused问题
    【和小白一起学elk】CH1：elasticsearch8.4.1及其插件head和kibana的安装
    回归预测 | MATLAB实现带蒙特卡洛模拟的Bayes贝叶斯线性回归预测
    第二章 Java基础语法
    java计算机毕业设计航帆学院网站MyBatis+系统+LW文档+源码+调试部署
    红队web打点信息收集
    web前端-javascript-运算符的优先级(如果遇到的优先级不清楚的,可以使用()来改变优先级)
    remote: The project you were looking for could not be found
  • 原文地址：https://blog.csdn.net/weixin_63925896/article/details/133858723