小白---反射(spring底层原理)

最新推荐文章于 2024-03-20 09:43:22 发布
最新推荐文章于 2024-03-20 09:43:22 发布
阅读量1k 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44786855/article/details/118941854
版权

反射

1.反射机制

Java的反射（reflection）机制是指在程序的运行状态中，可以构造任意一个类的对象，可以了解任意一个对象所属的类，可以了解任意一个类的成员变量和方法，可以调用任意一个对象的属性和方法。这种动态获取程序信息以及动态调用对象的功能称为Java语言的反射机制。反射被视为动态语言的关键。

1.1如何理解反射

首先反射是具有动态性的
1.反射是Java中特有的一种技术
2.Java中自省特性的一种实现(对象运行时动态发现对象成员,属性,方法)
3.反射是实现Java动态编程的基石(例如:AOP)

1.2反射的应用起点

反射应用的起点,也可以理解为反射应用的入口,在Java中这个入口是字节码对象(Class对象).
获取方式如下:
1.类名.class
2.Class.forName(“包名.类名”) 这种事最常用的
3.实例对象.getClass()
总结: 任意一个类在同一个JVM内部,类对象是唯一的,此类对象会在第一次类加载时创建

1.3反射的应用场景

1.框架中对象的构建:
例如:mybatis中的resultType,resultMap,spring中的Bean
如下代码:之前学习过的分页查询 xml方式
mybatis中的resultType="cn.mry.mybatis.pojo.User"映射的结果封装到这个对象中,
利用反射方式获取User对象
${pageSize}同样也是利用反射原理获取类中的属性,底层是将参数封装了Map集合中

<select id="getUserList2" resultType="User">
        select * from user
        <where>
            <if test="query != null and query !=''"> username like "%"#{query}"%"</if>
        </where>
        limlt ${(pageNum - 1) * pageSize},#{pageSize}
    </select>

spring中的bean注解,spring管理的对象都叫做bean对象,并且这个对象的名字一般与方法名相同,也可以在注解中给对象起名字.可以直接从spring的容器Beans中获取
2.框架中的方法的调用:
例如:对象的set,get方法,spring MVC 控制层方法
Bean对象,也是根据反射创建对象的

 @Bean//对象名默认为方法名
//    @Bean("bCryptPasswordEncoder")bean对象名字为bCryptPasswordEncoder
    public BCryptPasswordEncoder passwordEncoder (){
        return new BCryptPasswordEncoder();
    }

总之: 反射不能遇见未来,但是可以驾驭未来,通过反射可以更好构建一些编程框架,以实现通用变成,从而打到简单代码编写

2.反射起点创建对象

2.1验证:任意一个类在同一个JVM内部,类对象是唯一的,此类对象会在第一次类加载时创建

1.首先准备一个Configuration类.
2.以下为三种通过反射创建对象的方式:
3.用==判断对象是否为同一个对象
框架用的最多的就是这种方式
通过包路径+类名找到这个类,进而可以执行对象的创建,属性的赋值,方法的调用
Class<?> cls3 = Class.forName(“com.mry.reflect.Configuration”);

//首先准备一个类
class Configuration{
   }
   //测试
public class TestReflect01 {
    public static void main(String[] args) throws Exception {
       doClass01();
    }
}
//1.反射起点
    private static void doClass01() throws ClassNotFoundException{
        //获取反射起点对象(字节码对象): 一个JVM最多有一份 类对象只有一份
        //方式1
        Configuration c1 = new Configuration();
        Class<?> cls1 = c1.getClass();
        //方式2
        Class<?> cls2 = Configuration.class;
        //方式3   框架中用的最多的就是这种方式
        //框架用的最多的就是这种方式
        //resultType = "com.mry.reflect.Configuration"
        Class<?> cls3 = Class.forName("com.mry.reflect.Configuration");
        System.out.println(cls1 == cls2);
        System.out.println(cls2 == cls3);
        //说明: 此对象在类加载时即可创建
    }

2.2基于类对象创建无参实例对象

  1. 首先利用Class<?> cls3 = Class.forName(“com.mry.reflect.Configuration”);方式拿到这个对象,在通过这个对象构建类的实例对象
  2. 系统底层通过cls3.getDeclaredConstructor();方式获取无参构造函数,通过 con.newInstance();无参构造函数对象,构建类的无参实例对象
  3. 调用doInstance01(),就可以获取到实例对象了.但是这个前提是Configuration类中必须要有无参构造函数,如果没有无参构造函数的话会报错:com.mry.reflect.Configuration.()
class Configuration{
   // private String path;
    public Configuration(){ }
   // public Configuration(String path){
        this.path = path;
    }
}
//测试
public class TestReflect01 {
    public static void main(String[] args) throws Exception {
       doInstance01();
    }
}
//2.基于类对象创建实例 无参
private static void doInstance01() throws Exception{
        //利用这种方式，构建类的实例对象
        //通过反射构建对象时，需要类里有无参构造函数
        //如果类中没有无参构造函数的话，会报错com.mry.reflect.Configuration.<init>()
        Class<?> cls3 = Class.forName("com.mry.reflect.Configuration");
        //获取无参构造方法的对象   系统底层通过这种方式获取,这是默认的无参构造函数
        Constructor<?> con = cls3.getDeclaredConstructor();
        //获取类中的私有方法  也就是暴力反射
        con.setAccessible(true);
        //构建类的实例对象  获取的对象都是Object类型的
        Object obj = con.newInstance();
        System.out.println(obj);
    }

2.3基于类对象创建含参实例对象

  1. 利用cls3.getDeclaredConstructor(String.class)获取含参的构造函数
  2. 创建对象时,就需要传参数Object obj = con.newInstance(“classpath:cfg.xml”);
class Configuration{
    private String path;
    public Configuration(){ }
    public Configuration(String path){
        this.path = path;
    }
}
//测试
public class TestReflect01 {
    public static void main(String[] args) throws Exception {
       doInstance02();
    }
}
//3.基于类对象创建实例 含参
private static void doInstance02() throws Exception{
        //利用这种方式，构建类的实例对象
        Class<?> cls3 = Class.forName("com.mry.reflect.Configuration");
        //获取含参构造方法的对象   系统底层通过这种方式获取对象
        Constructor<?> con = cls3.getDeclaredConstructor(String.class);
        //获取类中的私有方法  也就是暴力反射
        con.setAccessible(true);
        //构建类的实例对象  获取的对象都是Object类型的
        Object obj = con.newInstance("classpath:cfg.xml");
        System.out.println(obj);
    }

2.4基于类对象创建实例 包含@Component注解时创建对象 调用无参/含参

如果创建对象时需要判断是否有注解修饰时,有注解修饰就创建对象,没有注解修饰就不创建这个对象

  1. 自定义注解Component,该注解可以描述类,并且在运行时有效
  2. 首先判断类是否被Component注解修饰boolean flag = cls3.isAnnotationPresent(Component.class);
  3. 假如需要把对象注入到容器中,可以给对象起个名字,也可以默认(默认名是类的首字母小写)
  4. 以config作为key,实例对象作为value,存储到Map集合中
    利用con.newInstance(“classpath:cfg.xml”)获取实例对象也就是Map中的value,利用cls3.getAnnotation(Component.class)方式,拿到注解.利用comp.value()获取属性,也就是Map中的key
  5. map.put(beanName, obj); beanName=config obj=实例对象
    这就是模拟spring中获取对象的原理
@Retention(RetentionPolicy.RUNTIME)//运行时有效
@Target(ElementType.TYPE)//可以描述的类型   类中有效
@interface Component{
	String value() default "";
}//注解组件

//有这个注解才允许构建对象
@Component("config")
class Configuration{
    private String path;
    public Configuration(){ }
    public Configuration(String path){
        this.path = path;
    }
    public void setPath(String path) {
        this.path = path;
    }
    public String getPath() {
        return path;
    }
    @Override
    public String toString() {
        return "Configuration{" +
                "path='" + path + '\'' +
                '}';
    }
}
//测试
public class TestReflect01 {
    public static void main(String[] args) throws Exception {
       doInstance03();
    }
}
//4.基于类对象创建实例 包含@Component注解时创建对象  调用无参/含参
    private static void doInstance03() throws Exception{
        //利用这种方式，构建类的实例对象
        // @Component修饰这个类，spring扫描时会将带有注解的扫描进内存
        Class<?> cls3 = Class.forName("com.mry.reflect.Configuration");
        //判断是否有Component这个注解    方法同理
        boolean flag = cls3.isAnnotationPresent(Component.class);
        if (!flag)return;
        //获取含参构造方法的对象   系统底层通过这种方式获取对象
        Constructor<?> con = cls3.getDeclaredConstructor(String.class);
        //获取类中的私有方法  也就是暴力反射
        con.setAccessible(true);

        //  Value       构建类的实例对象  获取的对象都是Object类型的
        Object obj = con.newInstance("classpath:cfg.xml");
        //将对象以K,V方式存储到Spring容器中
        Map<String,Object> map = new HashMap<>();

        //拿到注解
        Component comp = cls3.getAnnotation(Component.class);
        //拿到注解后   通过注解.value()获取属性 作为key
        String beanName = comp.value();
        //模拟spring中的原理  将对象存到map容器中
        map.put(beanName, obj);
        //spring中就是以K-V方式存储对象
        System.out.println(map);
    }

2.5基于类对象创建实例 访问属性，给属性赋值

  1. 想要获取属性,首先还是要获取实例对象Class.forName(“com.mry.reflect.Configuration”);
  2. 可以利用cls3.getDeclaredField(“path”);获取属性
  3. 想为属性赋值,首先还是要先创建对象的con.newInstance();
  4. 获取到的属性中有set方法可以为属性赋值f1.set(obj, “classpath:cfg.xml”);
  5. 但是需要注意一点,属性是私有的,所以需要暴力反射,设置属性可以访问f1.setAccessible(true);
@Retention(RetentionPolicy.RUNTIME)//运行时有效
@Target(ElementType.TYPE)//可以描述的类型   类中有效
@interface Component{   //想要把对象存储到容器中，可以给对象起个名字，系统底层也可以是类名首字母小写
    String value() default "";//定义
}//注解组件

//类对象
@Component("config")
class Configuration{
    private String path;
    public Configuration(){ }
    public Configuration(String path){
        this.path = path;
    }
    public void setPath(String path) {
        this.path = path;
    }
    public String getPath() {
        return path;
    }
    @Override
    public String toString() {
        return "Configuration{" +
                "path='" + path + '\'' +
                '}';
    }
}

//测试
public class TestReflect01 {
    public static void main(String[] args) throws Exception {
       doField01();
    }
}
public static void doField01() throws Exception{
        //在框架中不知道写的是什么类，所以通过这种方式获取对象
        Class<?> cls3 = Class.forName("com.mry.reflect.Configuration");
        //获取对象中的属性
        Field f1 = cls3.getDeclaredField("path");
        //想为属性赋值一定是要有对象的情况下才能给对象的属性赋值
        System.out.println(f1);
        //获取无参构造方法的对象   系统底层通过这种方式获取对象
        Constructor<?> con = cls3.getDeclaredConstructor();
        //获取类中的私有方法  也就是暴力反射
        con.setAccessible(true);
        //构建类的实例对象  获取的对象都是Object类型的
        Object obj = con.newInstance();
        //获取类中的私有属性  暴力反射
        f1.setAccessible(true);
        //属性是私有的  要给目标对象赋值，不能直接赋值  需要加con.setAccessible(true)
//        Class com.mry.reflect.TestReflect01 can not access a member of class com.mry.reflect.Configuration with modifiers "private"
        f1.set(obj, "classpath:cfg.xml");
    }

2.6基于类对象创建实例 调用类中某个对象的方法

  1. 对于框架来说,框架不知道属性具体的类型,所以不能直接通过obj直接调用,所以只能通过放射方式调用
  2. 与属性类似,利用反射cls3.getDeclaredMethod(“setPath”, String.class);调用set方法给属性赋值
  3. 调用到set方法后利用method.invoke(obj,“classpath:cfg.xml”);给属性赋值
@Retention(RetentionPolicy.RUNTIME)//运行时有效
@Target(ElementType.TYPE)//可以描述的类型   类中有效
@interface Component{   //想要把对象存储到容器中，可以给对象起个名字，系统底层也可以是类名首字母小写
    String value() default "";//定义
}//注解组件

//类对象
@Component("config")
class Configuration{
    private String path;
    public Configuration(){ }
    public Configuration(String path){
        this.path = path;
    }
    public void setPath(String path) {
        this.path = path;
    }
    public String getPath() {
        return path;
    }
    @Override
    public String toString() {
        return "Configuration{" +
                "path='" + path + '\'' +
                '}';
    }
}

//测试
public class TestReflect01 {
    public static void main(String[] args) throws Exception {
       doMethod01();
    }
}
public static void doMethod01() throws Exception{
        //在框架中不知道写的是什么类，所以通过这种方式获取对象
        Class<?> cls3 = Class.forName("com.mry.reflect.Configuration");
        //获取无参构造方法的对象   系统底层通过这种方式获取对象
        Constructor<?> con = cls3.getDeclaredConstructor();
        //获取类中的私有方法  也就是暴力反射
        con.setAccessible(true);
        //构建类的实例对象  获取的对象都是Object类型的
        Object obj = con.newInstance();
        //调用对象的方法
        Method method = cls3.getDeclaredMethod("setPath", String.class);
        //通过反射执行方法
        method.invoke(obj,"classpath:cfg.xml");
        System.out.println(obj);
        Method method1 = cls3.getDeclaredMethod("getPath");
        method1.invoke(obj);
        method.invoke(obj);
        System.out.println(obj);
    }
我想睡到自然醒y
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Spring使用反射机制模拟注解方式完成注入的本质-----Spring框架
春风若有怜花意，可否许我再少年
08-14 80
Spring使用反射机制模拟注解方式完成注入的本质-----Spring框架
Spring注解的原理
梧桐树的博客
07-30 342
注解（Annotation）在Java中是一种元数据，它可以为代码提供额外的信息，但本身不会影响程序的执行。在Spring框架中，注解被广泛用于标记组件、配置依赖关系以及进行AOP等操作。我们平时是使用注解的场景有很多,原理却知之甚少,下面来详细剖析一下注解的原理理解注解的原理需要从Java的反射机制开始讲起,对反射不清楚的请先补习一下java反射的原理,
Java面试——反射的底层实现原理
最新发布
weixin_45594172的博客
03-20 443
在底层实现中，JVM 使用一些数据结构来表示类的信息，如符号引用、运行时常量池、方法区等。通过这些数据结构，JVM 能够在运行时动态地获取类的信息，并实现反射机制的各种功能。反射机制的底层实现基于这些数据结构和字节码执行过程，在运行时动态地加载和执行类，实现动态性和灵活性。这个示例演示了如何使用反射动态地创建类实例、调用方法和操作字段，展示了反射的强大功能。反射的底层实现原理涉及到 Java 虚拟机（JVM）的类加载机制和字节码执行过程。
Spring之反射
qq_37978623的博客
06-04 3872
反射 在运行状态中，对于任意一个类都能够知道它的属性和方法，对于任意一个对象都能够调用他的属性和方法，这样的动态获取属性和方法和动态调用属性和方法的功能就叫做反射。 获取Class对象的方法 调用对象的getClass()方法（这种方法，已经有对象了，为什么还需要得到其Class对象？） 通过调用对象的class属性，每一个数据类型都有一个静态的静态属性class Cla...
【进阶】Spring中的注解与反射
weixin_43248862的博客
06-07 645
注解（Annotation）不是程序，但可以对程序作出解释，也可以被其它程序（如编译器）读取。 注解的格式：以@注释名在代码中存在，还可以添加一些参数值例如@SuppressWarnings(value="unchecked")。 注解可在package、class、method、field等上面使用，作用是为它们添加了额外的辅助信息，从而可以通过反射机制实现对这些元数据的访问。...
Spring 反射原理及用法
qq_44747728的博客
12-14 571
Spring反射机制是一种在运行状态中动态获取类信息，并能够任意使用该类的属性和方法的功能。它允许程序在运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。这种机制使得程序在运行时能够动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。
反射那些事 -- 献给像我一样的小白的礼物
潘小蓝的博客
06-24 297
反射: 一、反射是什么？ 在说反射之前，先来侃侃什么是正射: 小时候我们常常会拿手电筒照天空，这实际上就是一种正射，生活中有很多常见的例子。 什么是反射呢？ 上图在我们的生活中也是比较常见的,包括我们每天的照镜子实际上都是反射的一种体现。 反射在 Java 中的体现? 1、Reflection(反射) 是被视为动态语言的关键，通过反射可以使得 Java 变得动态化,反射机制允许程序在运行期间 借助于 反射 的一些 API(接口、类、等等)取得任何类的内部信息,并能直接操作任意对象的内部属性和方法。 注
java反射三种方法_反射及暴力反射
weixin_39586353的博客
12-01 2168
作者：逯小逯出自：SegmentFault 思否原文：segmentfault.com/a/1190000037432381反射一、概述(1)反射的定位是很重要的,JVM和底层框架都离不开反射(2)反射的原理是拿到你的class文件里的数据,进行数据的操作(CURD)(3)反射提供了丰富的方法,来操作类里的各种数据(属性/方法/构造)(4)REflection(反射)是Java程序开发语言的特征之...
spring-framework-5.3.29.zip
08-31
spring-framework-5.3.29.zip 源码
spring-cloud
08-19
spring-cloud
spring-startup-analysis：用于分析Java Spring中的bean构建的简单模块
02-05
弹簧启动分析仪 该项目被设计为一个模块，您可以通过Maven引入，它会生成类似于下... <artifactId>spring-startup-analysis <version>1.1.0 将以下基本软件包添加到您的组件中： com.github.lwaddicor.springstartu
利用反射和代理实现简单的Spring
12-14
利用反射和代理实现简单的Spring，有良好的注释，代码清晰、简单。
spring-cloud-codegen__Spring Cloud代码生成器
01-17
spring-cloud-codegen__Spring Cloud代码生成器
spring-framework-4.3.30.RELEASE-dist.zip
01-07
spring-framework-4.3.30.RELEASE-dist.zip： docs文件夹 libs文件夹（jar包） schema文件夹
反射底层原理
bejsoiv的博客
04-16 2118
反射底层原理 反射作用 首先回顾一下反射的作用，反射可以根据一个类的Class对象获得该类的Field、Constructor、Method对象，并对这三类对象进行操作。 反射获得Class对象的方法有三种： 已知类名：Clazz.class 已知全限定名：Class.forName(“xx.xx.Clazz”) 已知对象：instance.getClass() 反射底层实现原理 反射的缓存 利用Class对象从JVM获得的Field、Constructor、Method对象的存储定义在Class类中的
Java反射机制基本原理（Spring中IOC底层原理）
pkx1993的博客
01-08 7497
原文：https://blog.csdn.net/codejas/article/details/78635926  一、反射机制概述 Java 反射机制是在运行状态中，对于任意一个类，都能够获得这个类的所有属性和方法，对于任意一个对象都能够调用它的任意一个属性和方法。这种在运行时动态的获取信息以及动态调用对象的方法的功能称为 Java 的反射机制。 Class 类与 java.lang.re...
Spring 启动过程--基于xml配置的bean
圆师傅的博客
08-21 369
既然是基于xml配置bean，那么首先看一下book.xml文件： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance...
Java注解与反射原理说明
weixin_44782075的博客
03-20 926
一 点睛 注解若想发挥更大作用，还需借助反射机制之力。通过反射，可以取得一个方法上声明的注解的全部内容。 一般有两种需求： 1 取得方法中全部的注解，通过调用getAnnotations来实现。 2 判断操作是否是指定注解，通过调用getAnnotation来实现。 下面从源码角度来说明怎样获取这些注解信息。 二 源码导读——取得方法中全部的注解 public class AccessibleOb...
Spring框架反射构建对象的代码原理（一）
u012658005的专栏
12-16 2095
使用Spring框架的都知道，获取Class的对象时，Spring提拱了两种方式，只要在配置文件填写Class的id与class的包位置，通过getBean(String id)就可以直接获得Class的对象了。其中了，在配置上，提拱了两种方式。 1。单个具体的Class配置：（本篇讲的是这一种方式）  id="..." class="..."> 2。扫描方式配置（下一篇再讲
Spring-Aop的底层原理
06-10
Spring AOP的底层原理主要涉及到以下几个方面： 1. 动态代理：Spring AOP通过JDK动态代理和CGLIB动态代理技术，在运行时动态地生成代理对象，从而实现对目标对象的增强。 2. 切点：切点是Spring AOP中的一个重要...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我想睡到自然醒y

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值