• 反射、注解、元注解、动态代理

    反射

    反射就是：加载类，并允许以编程的方式解剖类中的各种成分（成员变量、方法、构造器等

    学习反射就是学习如何获取类的信息并操作它们

    1. 加载类，获取类的字节码：Class对象
    2. 获取类的构造器：Constructor对象
    3. 获取类的成员变量：Field对象
    4. 获取类的成员方法：Method对象

    1.获取类的三种方式

    1. Class c1 = 类名.class

    2. 调用Class提供方法：public static Class forName(String package)

    3. Object供的方法：public Class getClass(); Class c3 = 对象.getClass()

    1. public class Test1Class {
    2.     public static void main(String[] args) throws Exception {
    3.         //1.使用class c1 = 类名.class方式加载类
    4.         Class c1 = Student.class;
    5.         String name = c1.getName();//获取全类名
    6.         System.out.println(name);// com.lmh.reflect.Student
    7.         String simpleName = c1.getSimpleName();//获取简类名，不包含包名
    8.         System.out.println(simpleName);// Student
    9.  
    10.         //2.使用public static Class forName(String package)加载类
    11.         //入参为类的全类名
    12.         Class c2 = Class.forName("com.lmh.reflect.Student");
    13.  
    14.         //3.使用对象.getClass()方法加载类
    15.         Student student = new Student();
    16.         Class c3 = student.getClass();
    17.         System.out.println(c1 == c2);//true
    18.         System.out.println(c1 == c3);//true
    19.         //因为Student类的字节码文件只有一份，所以该类在内存中也只有一个，故c1、c2、c3都是同一个对象
    20.     }
    21. }

    2.获取类的构造器Constructor对象

           Class对象提供的从类中获取构造器的方法
    方法说明
    Constructor[ ] getConstructors( )获取所有public修饰的构造器
    Constructor[ ] getDeclaredConstructors( )获取所有构造器，无论什么关键字修饰
    Constructor getConstructor(Class … parameterTypes)入参为可变参数类型，根据参数类型获取public修饰的某个构造器
    Constructor getDeclaredConstructor(Class … parameterTypes)入参为可变参数类型，根据参数类型获取某个构造器，无论什么关键字修饰
    1. public class Test2Constructor {
    2.     @Test
    3.     public void testGetConstructors() throws Exception {
    4.         //1. 加载类
    5.         Class c = Student.class;
    6.         //2. 获取所有public修饰的构造方法
    7.         Constructor[] cs1 = c.getConstructors();
    8.         //3. 获取所有构造方法(推荐使用)
    9.         Constructor[] cs2 = c.getDeclaredConstructors();
    10.         //4. 遍历构造方法
    11.         print(cs1);
    12.         print(cs2);
    13.         //5. 获取public修饰的指定的构造方法
    14.         Constructor c1 = c.getConstructor(String.class, int.class, double.class);
    15.         //6. 获取指定的构造方法
    16.         Constructor c2 = c.getDeclaredConstructor(String.class);
    17.         System.out.println(c1.getName() + "----->"
    18.                 + c1.getParameterCount());
    19.         System.out.println("--------------------");
    20.         System.out.println(c2.getName() + "----->"
    21.                 + c2.getParameterCount());
    22.     }
    23.     
    24.     public void print(Constructor[] cs){
    25.         for (Constructor constructor : cs) {
    26.             //获取构造方法的名字和参数个数
    27.             System.out.println(constructor.getName() + "----->"
    28.                     + constructor.getParameterCount());
    29.         }
    30.         System.out.println("--------------------");
    31.     }
    32. }
    Constructor对象的方法

    获取类构造器的作用：初始化对象并返回

    方法说明
    T newInstance( Object … initargs )调用此构造器对象表示的构造器，并传入参数，完成对象的初始化并返回
    public void setAccessible( boolean flag )设置为true,表示禁止检查访问控制（暴力反射），private修饰的构造器也可以直接使用
    1. public class Test2Constructor {
    2.     @Test
    3.     public void testConstructorMethod() throws Exception {
    4.         Class c = Student.class;
    5.         Constructor constructor = c.getDeclaredConstructor(String.class);
    6.         /*
    7.         无论是否为public修饰，均可以用以下方法创建对象，是通用模板
    8.          */
    9.         //当构造方法是private修饰时，需要先设置为ture，才能调用，否则会报错
    10.         constructor.setAccessible(true);
    11.         //调用构造方法
    12.         Student s = (Student) constructor.newInstance("张三");
    13.         System.out.println(s.getName());//张三
    14.     }
    15. }


    3.获取类的成员变量

    获取成员变量的方法
    方法说明
    public Field[ ] getFields( )获取所有public修饰的成员变量
    public Field[ ] getDeclaredFields( )获取所有成员变量，无论什么关键字修饰
    public Field getField( String name )获取public修饰的指定成员变量，入参为变量名
    public Field getDeclaredField( String name )获取任意关键字修饰的指定成员变量，入参为变量名
    1. public class Test3Field {
    2.     private Class c;
    3.     private Constructor constructor;
    4.     Student student;
    5.     @Before
    6.     public void init() throws Exception {
    7.         c = Student.class;
    8.         constructor = c.getDeclaredConstructor(String.class, int.class, double.class);
    9.         constructor.setAccessible(true);
    10.         student = (Student) constructor.newInstance("lmh", 18, 100);
    11.     }
    12.     @Test
    13.     public void testGetFields() throws Exception {
    14.         // 获取所有的public修饰的成员变量
    15.         Field[] fs1 = c.getFields();
    16.         print(fs1);
    17.         // 获取所有的成员变量
    18.         Field[] fs2 = c.getDeclaredFields();
    19.         print(fs2);
    20.         // 获取指定的public修饰的成员变量
    21.         Field address = c.getField("address");
    22.         System.out.println(address.getName() + "---->"
    23.                 + address.getType());
    24.         System.out.println("===================================");
    25.         // 获取指定的成员变量
    26.         Field age = c.getDeclaredField("age");
    27.         System.out.println(age.getName() + "---->"
    28.                 + age.getType());
    29.     }
    30.     public void print(Field[] fs) {
    31.         for (Field f : fs) {
    32.             System.out.println(f.getName() + "---->"
    33.                     + f.getType());
    34.         }
    35.         System.out.println("===================================");
    36.     }
    37. }
    Field对象的方法

    获取成员变量的作用：对成员变量进行赋值与取值

    方法   说明
    void set( object obj, object value )赋值，第一个参数为实体类对象，第二个参数为要赋的值
    public void setAccessible( boolean flag )设置为true,表示禁止检查访问控制（暴力反射），private修饰的成员变量也可以直接操作
    object get( object obj )取值，入参为实体类对象
    1. public class Test3Field {
    2.     private Class c;
    3.     private Constructor constructor;
    4.     Student student;
    5.     @Before
    6.     public void init() throws Exception {
    7.         c = Student.class;
    8.         constructor = c.getDeclaredConstructor(String.class, int.class, double.class);
    9.         constructor.setAccessible(true);
    10.         student = (Student) constructor.newInstance("lmh", 18, 100);
    11.     }
    12.  
    13.     @Test
    14.     public void testFieldMethod() throws Exception{
    15.         Field Fname = c.getDeclaredField("name");
    16.         //设置访问权限
    17.         Fname.setAccessible(true);
    18.         //获取成员变量的值
    19.         String name = (String) Fname.get(student);
    20.         System.out.println(name);//lmh
    21.         //设置成员变量的值
    22.         Fname.set(student, "dadada");
    23.         System.out.println(student.getName());//dadada
    24.     }
    25. }

    4.获取类的成员方法

    Class对象提供的从类中获取成员方法的方法
    方法说明
    Method[ ] getMethods( )获取所有public修饰的成员方法
    Method[ ] getDeclaredMethods( )获取所有成员方法，无论什么关键字修饰
    Method getMethod(String name, class … parameterTypes)入参为可变参数类型，根据方法名和参数类型获取public修饰的某个成员方法
    Method getDeclaredMethod(String name, class … parameterTypes)入参为可变参数类型，根据方法名和参数类型获取某个成员方法，无论什么关键字修饰
    1. public class Test4Method {
    2.     private Class c;
    3.     private Constructor constructor;
    4.     Student student;
    5.     @Before
    6.     public void init() throws Exception {
    7.         c = Student.class;
    8.         constructor = c.getDeclaredConstructor(String.class, int.class, double.class);
    9.         constructor.setAccessible(true);
    10.         student = (Student) constructor.newInstance("lmh", 18, 100);
    11.     }
    12.  
    13.     @Test
    14.     public void testGetMethod() throws Exception {
    15.         // 获取所有的public修饰的方法
    16.         Method[] methods1 = c.getMethods();
    17.         print(methods1);
    18.         // 获取所有的方法
    19.         Method[] methods2 = c.getDeclaredMethods();
    20.         print(methods2);
    21.         // 获取public修饰的指定的方法
    22.         Method m1 = c.getMethod("show");
    23.         System.out.println(m1.getName() + "---->"
    24.                 + m1.getReturnType() + "---->"
    25.                 + m1.getParameterCount());
    26.         System.out.println("===================================");
    27.         // 获取指定的方法
    28.         Method m2 = c.getDeclaredMethod("privateMethod", String.class);
    29.         System.out.println(m2.getName() + "---->"
    30.                 + m2.getReturnType() + "---->"
    31.                 + m2.getParameterCount());
    32.     }
    33.     public void print(Method[] ms) {
    34.         for (Method m : ms) {
    35.             System.out.println(m.getName() + "---->"
    36.                     + m.getReturnType() + "---->"
    37.                     + m.getParameterCount());
    38.         }
    39.         System.out.println("===================================");
    40.     }
    41. }

    Method对象的方法

    获取成员变量的作用：运行方法

    方法说明
    public object invoke( object obj, object … args )运行方法，第一个参数为实体类对象，第二个参数为可变参数，为传入的成员方法的参数
    public void setAccessible( boolean flag )设置为true,表示禁止检查访问控制（暴力反射），private修饰的成员方法也可以直接访问
    1. public class Test4Method {
    2.     private Class c;
    3.     private Constructor constructor;
    4.     Student student;
    5.     @Before
    6.     public void init() throws Exception {
    7.         c = Student.class;
    8.         constructor = c.getDeclaredConstructor(String.class, int.class, double.class);
    9.         constructor.setAccessible(true);
    10.         student = (Student) constructor.newInstance("lmh", 18, 100);
    11.     }
    12.     
    13.     @Test
    14.     public void testMethod() throws Exception{
    15.         Method m = c.getDeclaredMethod("privateMethod", String.class);
    16.         m.setAccessible(true);
    17.         m.invoke(student, "ddd");
    18.         //我是一个重载的私有方法，名字是：ddd
    19.     }
    20. }

    5.反射的作用

    基本作用：可以解析一个类的全部成分并进行操作

    可以通过设置访问权限破坏对象的封装性

    最主要用途：适合做Java的框架，基本上主流的框架都会基于反射设计出一些通用的功能

    注解

    注解概述

    • 就是Java代码里的特殊标记，比如：@Override、@Test等，作用是让其他程序根据注解信息来决定怎么执行该程序
    • 注意：注解可以用在类上、构造器上、方法上、成员变量上、参数上等位置

    格式

    1. //定义自定义注解
    2. public @interface MyTest1 {
    3.     String name();
    4.     int age() default 18;//默认值为18
    5.     String[] hobby();
    6. }

    1. /*
    2. 使用自定义注解的简单实例
    3.  */
    4. @MyTest1(name = "lmh", age = 20, hobby = {"basketball", "football"})
    5. public class AnnotationTest1 {
    6.     /*
    7.     因为age有默认值，所以可以不用赋值，默认为18
    8.      */
    9.     @MyTest1(name = "ddd", hobby = {"basl", "fl"})
    10.     public void test() {
    11.         System.out.println("test");
    12.     }
    13. }
    特殊属性名：value

    当自定义注解只有value这一个属性或者有其他属性但是都有默认值时，在使用注解时无需写value，直接传值即可

    1. public @interface MyTest2 {
    2.     String value();
    3.     int age() default 18;//默认值为18
    4. }
    1. //只有value或者只有一个属性时，可以省略属性名
    2. //如果其他属性都有默认值，只有value没有默认值，那么只需要给value赋值，value不必写出来
    3.  
    4. @MyTest2("lmh")//默认给value赋值
    5. public class AnnotationTest2 {
    6.     
    7. }

    元注解

    用于修饰注解的注解

    1. //用于声明注解可以使用的位置，下面代码表示该注解只能用于类和方法上
    2. @Target({ElementType.TYPE, ElementType.METHOD})
    3. //用于表示注解的保留周期，下面代码表示该注解会一直保留到运行阶段，可以通过反射机制读取到
    4. @Retention(RetentionPolicy.RUNTIME)//开发中一般都是RUNTIME
    5. public @interface MyTest3 {
    6. }
    1. @MyTest3()
    2. public class AnnotationTest2 {
    3.     @MyTest3()//会报错，因为声明的范围是TYPE和METHOD，而FIELD不在范围内
    4.     private String s;
    5. }

    注解的解析

    判断类上、方法上、成员变量上是否存在注解，并把注解里的内容给解析出来

    • 如果要解析类上面的注解，就要先通过反射拿到该类对应的Class对象，再通过Class对象解析注解
    • 如果要解析方法上面的注解，就要先通过反射拿到该方法对应的Method对象，再通过Method对象解析注解
    • Class、Method、Field、Constructor都实现了AnnotatedElement接口，所以都拥有解析注解的能力
    AnnotatedElement接口提供的方法说明
    public Annotation[ ] getDeclaredAnnotations( )获取当前对象上面的注解对象的集合
    public T getDeclaredAnnotation(Class annotationClass)获取指定的注解对象，入参为注解的类对象
    public boolean isAnnotationPresent( Class annotationclass )判断当前对象上是否存在某个注解，入参为注解的类对象
    1. @Target({ElementType.TYPE, ElementType.METHOD})
    2. @Retention(RetentionPolicy.RUNTIME)
    3. public @interface MyTest4 {
    4.     String value();
    5.     double aaa() default 100;
    6.     String[] bbb();
    7. }
    1. @MyTest4(value = "abc", bbb = {"aaa", "bbb"})
    2. public class Demo {
    3.     @MyTest4(value = "dadada", aaa = 1, bbb = {"a", "b"})
    4.     public void test1(){
    5.  
    6.     }
    7. }
    1. public class AnnotationTest3 {
    2.     @Test
    3.     public void parseClass(){
    4.         //获取类对象
    5.         Class c = Demo.class;
    6.         //解析类上的注解
    7.         if (c.isAnnotationPresent(MyTest4.class)){
    8.             MyTest4 myTest4 =
    9.                     (MyTest4) c.getDeclaredAnnotation(MyTest4.class);
    10.             System.out.println(myTest4.value());
    11.             System.out.println(myTest4.aaa());
    12.             System.out.println(Arrays.toString(myTest4.bbb()));
    13.             System.out.println("====================================");
    14.         }
    15.     }
    16.  
    17.     @Test
    18.     public void parseMethod() throws Exception {
    19.         Class c = Demo.class;
    20.         Method m = c.getDeclaredMethod("test1");
    21.         Annotation[] annotations = m.getDeclaredAnnotations();
    22.         if (annotations.length > 0){
    23.             for (Annotation annotation : annotations) {
    24.                 //instanceof判断左边的对象是否是右边类的实例
    25.                 if (annotation instanceof MyTest4){
    26.                     MyTest4 myTest4 = (MyTest4) annotation;
    27.                     System.out.println(myTest4.value());
    28.                     System.out.println(myTest4.aaa());
    29.                     System.out.println(Arrays.toString(myTest4.bbb()));
    30.                 }
    31.             }
    32.         }
    33.     }
    34. }

    动态代理

    实现动态代理的前提是代理的对象和被代理的对象必须实现同一个接口

    动态代理对应的类：java.lang.reflect.Proxy，提供了为对象产生代理对象的方法

    小案例：

    1. //接口，必须让代理类和被代理类实现同一个接口
    2. public interface Star {
    3.     String sing(String SongName);
    4.     void dance();
    5. }
    1. //被代理类，实现接口
    2. public class SuperStar implements Star{
    3.     private String name;//明星的名字
    4.  
    5.     public SuperStar(String name) {
    6.         this.name = name;
    7.     }
    8.  
    9.     @Override
    10.     public String sing(String SongName) {
    11.         System.out.println(name + "唱了一首歌：" + SongName);
    12.         return "歌唱完了，谢谢大家！";
    13.     }
    14.  
    15.     @Override
    16.     public void dance() {
    17.         System.out.println(name + "跳了一支舞！");
    18.     }
    19. }
    1. //代理类
    2. public class ProxyUtil {
    3.     public static Star createProxy(SuperStar superStar){
    4.         //第一个参数固定，第二个参数用于绑定被代理类实现的接口，
    5.         // 第三个参数是一个匿名内部类，用于实现代理对象需要实现的功能
    6.         Star starProxy =
    7.                 (Star) Proxy.newProxyInstance(ProxyUtil.class.getClassLoader(),
    8.                 new Class[]{Star.class}, new InvocationHandler() {
    9.                     @Override
    10.                     //第一个参数是代理对象，第二个参数是被代理对象的方法对象，第三个参数是被代理对象的方法的入参
    11.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    12.                         //代理需要完成的功能
    13.                         if (method.getName().equals("sing")) {
    14.                             System.out.println("准备话筒，收钱20万");
    15.                         } else if (method.getName().equals("dance")) {
    16.                             System.out.println("准备场地，收钱1000万");
    17.                         }
    18.                         //指定被代理对象的方法并执行
    19.                         //如果有返回值，需要将返回值返回给代理对象
    20.                         return method.invoke(superStar, args);
    21.                     }
    22.                 });
    23.         //返回代理对象
    24.         return starProxy;
    25.     }
    26. }

    1. //测试类
    2. public class Test {
    3.     public static void main(String[] args) {
    4.         SuperStar s = new SuperStar("吴晗");
    5.         Star proxy = ProxyUtil.createProxy(s);
    6.  
    7.         System.out.println(proxy.sing("蓝莲花"));
    8.         proxy.dance();
    9.     }
    10. }

  • 相关阅读:
    RabbitMQ 安装
    2022-9月报
    【c++】解决使用 std::map 时报错 no match for ‘operator＜’
    2023最新SSM计算机毕业设计选题大全（附源码+LW）之java高校师生党建管理系统4d8du
    图解LeetCode——1779. 找到最近的有相同 X 或 Y 坐标的点（难度：简单）
    【Java】volatile-内存可见性问题
    技术实践干货 | 初探大规模 GBDT 训练
    关于分布式锁的那些事儿
    深度学习-消融实验
    Sphinx Docstring
  • 原文地址：https://blog.csdn.net/qq_41325698/article/details/133929312