首页 > 编程语言 >Java反射详解,学以致用,实战案例(AOP修改参数、Mybatis拦截器实现自动填充)

Java反射详解,学以致用,实战案例(AOP修改参数、Mybatis拦截器实现自动填充)

时间:2022-10-05 21:45:09浏览次数:88  
标签:拦截器 Java System Class nzc AOP println public out

持续创作,加速成长!这是我参与「掘金日新计划 · 10 月更文挑战」的第1天,点击查看活动详情

作为Java开发者,你认为反射这个知识点重要程度,在你心里是什么样的呢?

以前我也只觉得反射非常重要,但总归是听这个文章说,听那个朋友说,学是学了,但却没怎么应用。

当我正式进入到社会当 cv 仔的时候,需要考虑的问题多了,慢慢思考问题了,就觉得反射是个力大无穷的东西,更会感觉反射是个无所不能的东西,如各种各样的框架的底层,各种各样的拦截器的实现,反射都是其中少不了的一部分~

如果平时着重于开发业务的话,那么确实可能会较少使用到反射机制,但并非是说反射它不重要,反射它是Java 框架的基础勒,可以说木有反射,Java的动态性是会受限的~

文章大致思路:

image.png

全文共 7500 字左右,案例均可运行,阅读时间大约需要20分钟左右,如有问题,请留言或发送邮件([email protected])。

编写的过程中,即使书写完已阅读过,但难免可能会出现遗漏,如有发现问题请及时联系修正,非常感谢你的阅读,希望我们都能成为技术道路上的朋友。

一、反射是什么?

JAVA 反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制

不过要想解剖一个类,就要先获取到该类的字节码文件对应的Class类型的对象.

稍后就会讲到~

"反射之所以被称为框架的灵魂",主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力,这种能力也就是我们常说的动态性,利用这种性质可以使编写的程序更灵活更通用。

反射机制可以用来:

  • 在运行时分析类的能力,如可以构造任意一个类,可以获取任意一个类的全部信息,
  • 在运行时检查对象,如在运行时判断任意一个对象所属的类
  • 实现泛型数组操作代码,因为在运行时可以获取泛型信息
  • 利用Method对象,如我们经常使用的动态代理,就是使用Method.invoke()来实现方法的调用。

反射是一种功能强大且复杂的机制,在开发Java工具或框架方面,反射更是不可缺少的一部分。

二、Class 对象详解

之前说到了,如果要分析一个类,就必须要获取到该类的字节码文件对应 Class 类型对象。

另外如果有听到类模板对象,这个说的其实就是Class对象,大家不要误会了。

2.1、如何获取到Class对象呢?

得到Class的方式总共有四种:

  • 通过对象调用 getClass()方法来获取
  • 直接通过类名.class 的方式得到
  • 通过 Class对象的 forName() 静态方法来获取
  • Classloader,通过类加载器进行获取
 /**
  * @description:
  * @author: Ning Zaichun
  * @date: 2022年09月15日 22:49
  */
 public class ClassDemo01 {
 ​
     @Test
     public void test1() throws Exception {
         //1、通过对象调用 getClass() 方法来获取
         //  类型的对象,而我不知道你具体是什么类,用这种方法
         Student student = new Student();
         Class studentClass1 = student.getClass();
         System.out.println(studentClass1);
         // out: class com.nzc.Student
 ​
         //2、直接通过`类名.class` 的方式得到
         // 任何一个类都有一个隐含的静态成员变量 class
         // Class studentClass2 = Student.class;
         Class<?> studentClass2 = Student.class;
         System.out.println(studentClass2);
         // out: class com.nzc.Student
         System.out.println("studentClass1和studentClass2 是否相等==>" + (studentClass1 == studentClass2));
         // studentClass1和studentClass2 是否相等==>true
 ​
         //3、通过 Class 对象的 forName() 静态方法来获取,使用的最多
         //   但需要抛出或捕获 ClassNotFoundException 异常
         Class<?> studentClass3 = Class.forName("com.nzc.Student");
         System.out.println(studentClass3);
         // out: class com.nzc.Student
         System.out.println("studentClass1和studentClass3 是否相等==>" + (studentClass1 == studentClass3));
         //studentClass1和studentClass3 是否相等==>true
 ​
         //4、 使用类的加载器:ClassLoader 来获取Class对象
         ClassLoader classLoader = ClassDemo01.class.getClassLoader();
         Class studentClass4 = classLoader.loadClass("com.nzc.Student");
         System.out.println(studentClass4);
         System.out.println("studentClass1和studentClass4 是否相等==>" + (studentClass1 == studentClass4));
         //studentClass1和studentClass4 是否相等==>true
     }
 }
复制代码

在这四种方式中,最常使用的是第三种方式,第一种都直接new对象啦,完全没有必要再使用反射了;第二种方式也已经明确了类的名称,相当于已经固定下来,失去了一种动态选择加载类的效果;而第三种方式,只要传入一个字符串,这个字符串可以是自己传入的,也可以是写在配置文件中的。

像在学 JDBC 连接的时候,大家肯定都使用过 Class对象的 forName() 静态方法来获取Class对象,再加载数据库连接对象,但可能那时候只是匆匆而过罢了。

注意:不知道大家有没有观察,我把各种方式所获取到的class对象,都进行了一番比较,并且结果都为true,这是因为一个类在 JVM 中只会有一个 Class 实例,为了解释此点,我把类加载过程也简单的做了一个陈述。

2.2、类的加载过程

当我们需要使用某个类时,如果该类还未被加载到内存中,则会经历下面的过程对类进行初始化。

image.png 即类的加载 ---> 链接 ---> 初始化三个阶段。

在这里我只着眼于类的加载过程了,想要了解更为详细的,就需要大家去找找资料看看啦~

加载过程

1、在我们进行编译后(javac.exe命令),会生成一个或多个字节码文件(就是项目中编译完会出现的 target 目录下的以.class结尾的文件)

2、接着当我们使用 java.exe 命令对某个字节码文件进行解释运行时。

3、加载过程

  • 就相当于将 class 文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构;
  • 并生成一个代表这个类的 java.lang.Class 对象,这个加载到内存中的类,我们称为运行时类,此运行时类,就是 Class的一个实例,所有需要访问和使用类数据只能通过这个 Class 对象。
  • 所谓Class对象,也称为类模板对象,其实就是 Java 类在 JVM 内存中的一个快照,JVM 将从字节码文件中解析出的常量池、 类字段、类方法等信息存储到模板中,这样 JVM 在运行期便能通过类模板而获 取 Java 类中的任意信息,能够对 Java 类的成员变量进行遍历,也能进行 Java 方法的调用。
  • 反射的机制即基于这一基础。如果 JVM 没有将 Java 类的声明信息存储起来,则 JVM 在运行期也无法进行反射。

4、这个加载的过程还需要类加载器参与,关于类加载器的类型大家可以去了解了解,还有双亲委派机制等,此处我便不再多言

2.3、为了更便于记忆的图

image.png (图片说明:为更好的描述JVM中只有一个Class对象,而画下此图,希望通过这张简图,让你记忆更为深刻)

2.4、Class 常用的API

通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等

  • getName():获得类的完整名字。
  • getFields():获得类的public类型的属性。
  • getDeclaredFields():获得类的所有属性。包括private声明的和继承类
  • getMethods():获得类的public类型的方法。
  • getDeclaredMethods():获得类的所有方法。包括private声明的和继承类
  • getMethod(String name, Class[] parameterTypes):获得类的特定方法,name参数指定方法的名字,parameterTypes 参数指定方法的参数类型。
  • getConstructors():获得类的public类型的构造方法。
  • getConstructor(Class[] parameterTypes):获得类的特定构造方法,parameterTypes参数指定构造方法的参数类型。
  • newInstance():通过类的不带参数的构造方法创建这个类的一个对象。

另外就还有反射包下的几个常用的对象Constructor、Filed、Method等,分别表示类的构造器、字段属性、方法等等

这些都会在下文慢慢陈述出来~

三、获取运行时类完整信息并使用

所谓运行时类,就是程序运行时所创建出来的类,你直接理解为通过反射获取到的类也可。大体意思是如此。

在讲述这一小节时,先要理解Java中一切皆对象这句话。

我们平常编写一个类,我们会将它称为一个Java对象,但是在反射这里将此概念再次向上抽象了。

类的基本信息:构造方法、成员变量,方法,类上的注解,方法注解,成员变量注解等等,这些都是Java对象,也是证明了Java中一切皆对象这句话。

其中Constructor就表示构造方法的对象,他包含了构造方法的一切信息,

Field、Method等等都是如此。

不要太过于麻烦和重复书写,我将案例中操作的所有相关代码,都放在此处了,案例中的依赖全部基于此。

 public interface TestService {
 }
复制代码
 @Target({ElementType.TYPE,ElementType.PARAMETER, ElementType.METHOD, ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 public @interface MarkAnnotation {
 ​
     String value() default "";
 ​
 }
复制代码
 public class Generic<T> {
 }
 ​
复制代码
 public interface GenericInterface<T> {
 }
 ​
复制代码
 // TYPE 表示可以标记在类上
 //  PARAMETER 表示可以标记在方法形式参数
 //  METHOD 方法
 //  FIELD 成员属性上
 @Target({ElementType.TYPE,ElementType.METHOD, ElementType.FIELD,ElementType.PARAMETER})
 @Retention(RetentionPolicy.RUNTIME) // 这里表明是运行时注解
 @Documented
 public @interface LikeAnnotation {
 ​
     String value() default "";
 ​
 ​
     String[] params() default {};
 }
复制代码
 @Data
 @MarkAnnotation
 public class Person implements TestService{
     private String sex;
 ​
     public Integer age;
 ​
     private void mySex(String sex){
         System.out.println("我的性别"+sex);
     }
 ​
     public void myAge(Integer age){
         System.out.println("我的年龄"+age);
     }
 ​
 ​
 }
复制代码
 @ToString(callSuper = true) // 增加这行是为了打印时将父类属性也打印出来,方便查看~
 @Data
 @LikeAnnotation(value = "123")
 public class Student extends Person implements Serializable {
     @LikeAnnotation
     private String username;
 ​
     @LikeAnnotation
     public String school;
 ​
     private Double score;
 ​
     public Student() {
     }
 ​
     private Student(String username) {
         this.username = username;
     }
 ​
     public Student(String username, String school) {
         this.username = username;
         this.school = school;
     }
 ​
     @LikeAnnotation
     public void hello() {
         System.out.println("世界,你好");
     }
 ​
     public void say( String username) {
         System.out.println("你好,我叫" + username);
     }
 ​
     private void myScore(Double score) {
         System.out.println("我的分数是一个私密东西," + score);
     }
 ​
     public void annotationTest(@LikeAnnotation  String username,@MarkAnnotation String str){
         System.out.println( "测试获取方法参数中的注解信息");
     }
 }
复制代码

3.1、反射获取运行时类构造方法并使用

class获取构造方法的相关API

 // 获取所有的构造函数
 Constructor<?>[] getConstructors()
 ​
 // 获取 public或 private 修饰的狗赞函数,只要参数匹配即可
 Constructor<?>[] getDeclaredConstructors()
 ​
 // 获取所有 public 修饰的 构造函数
 Constructor<T> getConstructor(Class<?>... parameterTypes)
     
 //调用此方法,创建对应的运行时类的对象。
 public T newInstance(Object ... initargs)
复制代码

newInstance():调用此方法,创建对应的运行时类的对象。内部调用了运行时类的空参的构造器。

要想此方法正常的创建运行时类的对象,要求:

  • 运行时类必须提供空参的构造器;
  • 空参的构造器的访问权限得够。通常,设置为 public。

为什么要 javabean 中要求提供一个 public 的空参构造器?

原因: 1、便于通过反射,创建运行时类的对象;2、便于子类继承此运行时类时,默认调用 super() 时,保证父类有此构 造器。

想要更详细的了解,建议去看生成的字节码文件,在那里能够给出你答案。

测试

 /**
  * @description:
  * @author: Ning Zaichun
  * @date: 2022年09月17日 1:17
  */
 public class ConstructorTest {
 ​
     /**
      * 获取公有、私有的构造方法 并调用创建对象
      */
     @Test
     public void test1() throws Exception {
         Class<?> aClass = Class.forName("com.nzc.Student");
 ​
         System.out.println("======获取全部public 修饰的构造方法=========");
         Constructor<?>[] constructors = aClass.getConstructors();
         for (Constructor<?> constructor : constructors) {
             System.out.println(constructor);
         }
         System.out.println("======获取 public、private 修饰的构造方法,只要参数匹配即可=========");
         /**
          * 这里的参数 Class<?>... parameterTypes 填写的是参数的类型,而并非某个准确的值信息
          */
         Constructor<?> constructor = aClass.getDeclaredConstructor(String.class);
         System.out.println(constructor);
         // 因为此构造函数是 private 修饰,如果不设置暴力反射,则没有权限访问。
         // 这里setAccessible(true) 是设置暴力反射,如果不设置,则会报错,
         constructor.setAccessible(true);
         // 这里调用的有参构造,所以在调用 newInstance 方法时,也需要填写参数
         Object o1 = constructor.newInstance("宁在春");
         constructor.setAccessible(false);
         System.out.println("o1===>"+o1);
 ​
         /**
          * 如果需要获取有参构造,只需要填写对应的参数类型即可,
          * 获取无参构造,填null或不填都可。
          */
         Constructor<?> constructor1 = aClass.getConstructor();
         Constructor<?> constructor2 = aClass.getConstructor(String.class,String.class);
         System.out.println("无参构造==>"+constructor1);
         System.out.println("有参构造==>"+constructor2);
         Object o2 = constructor1.newInstance();
         Object o3 = constructor2.newInstance("宁在春2","xxxx社会");
         System.out.println("o2===>"+o2);
         System.out.println("o3===>"+o3);
     }
 }
复制代码

既然能够获取到构造方法,那么也就是可以使用的,用Constructor.newInstance()方法来调用构造方法即可,在下列的打印信息中,也可以看出来确实如此,如果明确要获取为Student对象的话,进行强转即可。

 ======获取全部public 修饰的构造方法=========
 public com.nzc.Student(java.lang.String,java.lang.String)
 public com.nzc.Student()
 ======获取 public、private 修饰的构造方法,只要参数匹配即可=========
 private com.nzc.Student(java.lang.String)
 o1===>Student(username=宁在春, school=null, age=null)
 无参构造==>public com.nzc.Student()
 有参构造==>public com.nzc.Student(java.lang.String,java.lang.String)
 o2===>Student(username=null, school=null, age=null)
 o3===>Student(username=宁在春2, school=xxxx社会, age=null)
复制代码

3.2、反射获取运行时类成员变量信息

class对象中获取类成员信息使用到的API

 Field[] getFields();
  
 Field[] getDeclaredFields();
 ​
 Field getDeclaredField(String name);
 ​
 public native Class<? super T> getSuperclass();
复制代码

这里的 Field 类对象,其实就是表示类对象中的成员属性,不过还有多了很多其他在反射时需要用到的属性和API罢了~

3.2.1、获取私有公有类成员信息

为了有更好的对比,我先编写了一段不使用反射时的正常操作。

 /**
      * 不使用反射的进行操作
      */
 @Test
 public void test1() {
     Student student = new Student();
     student.setUsername("username");
     student.setSchool("xxxx社会");
     student.setScore(100.0);
     // 永远三岁的小伙子 哈哈 

标签:拦截器,Java,System,Class,nzc,AOP,println,public,out
From: https://www.cnblogs.com/konglxblog/p/16756478.html

相关文章

  • heiamJava16IO流
    JavaI/O流按流的方向分输入输出流I表示intput(输入),是数据从硬盘文件读入到内存的过程,称之输入,负责读。O表示output(输出),是内存程序的数据从内存到写出硬盘文件的过......
  • java之String的一些常用方法
    string--字符串#######equals和==的区别?-equals:是比较两个对象是否一样(比较的内容->属性值)-==:比较两个地址是否一样-java8之前,常量池存放在堆中,java8以......
  • Java在线聊天功能
    封装工具类封装工具类packageutils;importjava.io.IOException;importjava.io.UnsupportedEncodingException;importjava.net.URLEncoder;importorg.apache......
  • 面试+学习+做项目+最全Java视频讲解
    关注公众号:计算机视觉与图形学实战​​Java零基础教程视频(适合Java0基础,Java初学入门)​​​​尚硅谷Java零基础入门教程(含百道Java真题,2万多行Java代码实战)​​​​黑马程......
  • 超详细Java基础-多态
    茫茫人海千千万万,感谢这一秒你看到这里。希望我的能对你的有所帮助!共勉!愿你在未来的日子,保持热爱,奔赴山海!Java基础知识(多态)多态多态就是指程序中定义的引用变量所......
  • java开发环境的安装之IDEA
    一、JDK、JRE、JVM本文编写思路来自于博主狂神说1、定义jdk:JavaDevelopmentKit(Java语言的软件开发工具包)JDK的说明jre:JavaRuntimeEnvironment(java运行环境)JRE......
  • java注解与反射--3
    java注解与反射--3类的加载与ClassLoaderjava内存堆存放new的对象和数组可以被所有的线程共享,不会存放别的对象引用栈存放基本变量类型引用对象的变量方法......
  • Java冒泡排序
    publicclassArrayDome7{/*冒泡拍寻是最为出名的排序算法之一,总共又八大paixu冒泡排序的代码是:两层循环,外层冒泡轮数,里层依次比较时间......
  • 常用的前端JavaScript方法封装
    [常用的前端JavaScript方法封装]1、输入一个值,返回其数据类型functiontype(para){returnObject.prototype.toString.call(para)}复制代码2、数组去重functio......
  • 力扣138(java)- 复制带随机指针的链表(中等)
    题目:给你一个长度为n的链表,每个节点包含一个额外增加的随机指针random,该指针可以指向链表中的任何节点或空节点。构造这个链表的 深拷贝。 深拷贝应该正好由n个......