Spring中应用反射机制浅析

最新推荐文章于 2023-03-29 11:02:06 发布
最新推荐文章于 2023-03-29 11:02:06 发布
阅读量668 收藏
点赞数
分类专栏： spring

我们知道,Spring中大量使用了反射机制，那么究竟是什么地方使用了呢？就从源头说起吧。

一  反射源头Class类

对类的概念我们已经非常熟悉了。比如可以有Student这个类，Person这个类。但是我们要知道，有一个叫Class的类，它是反射的源头。

正常方式：通过完整的类名—>通过new实例化—>取得实例化对象

反射方式：实例化对象—>getClass()方法—>通过完整的类名

一个简单的例子：

双击代码全选
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package cn.classes;  
        
public class OneClass {  
        
}  
        
        
package cn.test;  
        
import cn.classes.OneClass;  
        
public class Test {  
     public static void main(String[] args) {  
         OneClass c = new OneClass();  
         System.out.println(c.getClass().getName());  
    }  
}

输出结果：cn.classes.OneClass

我们需要使用反射，就要获得Class这个类，有三种方法：

双击代码全选
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package cn.classes;  
        
public class OneClass {  
        
}  
        
        
import cn.classes.OneClass;  
        
public class Test {  
public static void main(String[] args) {  
      Class<?> c1 = null ;  
      Class<?> c2 = null ;  
      Class<?> c3 = null ;  
        
      try
     {  
          // 方法一：forName(重要)  
          c1 = Class.forName( "cn.classes.OneClass" );  
     }  
     catch (ClassNotFoundException e)  
     {  
          e.printStackTrace();  
     }  
      // 方法二  
      c2 = new OneClass().getClass();  
          
      // 方法三  
      c3 = OneClass. class ;  
        
      System.out.println(c1.getName());  
      System.out.println(c2.getName());  
      System.out.println(c3.getName());  
    }  
}

输出结果：cn.classes.OneClass

二 利用Class这个类实例化类

①无参构造

双击代码全选
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package cn.classes;  
        
public class Person {  
     private String name;  
     private int age;  
        
      .............省略getter,setter..............  
        
     @Override
     public String toString()  
     {  
           return "Person [name=" + name + ", age=" + age + "]" ;  
     }  
        
}  
        
        
package cn.test;  
        
import cn.classes.Person;  
        
public class Test  
{  
     // 这样做必须在类中有一个空构造方法  
     public static void main(String[] args)  
     {  
               Class<?> c = null ;  
                try
                {  
                       c = Class.forName( "cn.classes.Person" );  
                       Person p = (Person)c.newInstance();  
                       p.setName( "xy" );  
                       p.setAge( 20 );  
                       System.out.println(p);  
                }  
               catch (Exception e)  
               {  
                       e.printStackTrace();  
                }    
      }  
}

②有参构造

双击代码全选
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package cn.classes;  
        
public class Person  
{  
     private String name;  
     private int age;  
        
      public Person(Stringname, int age){  
        
                  this .name = name;  
        
                  this .age = age;  
        
     }  
        
     .............省略getter,setter..............      
        
     @Override
     public String toString()  
     {  
           return "Person [name=" + name + ", age=" + age + "]" ;  
     }  
}  
        
        
package cn.test;  
        
import java.lang.reflect.Constructor;  
        
import cn.classes.Person;  
        
public class Test  
{  
     // 如果没有一个空构造方法  
     public static void main(String[] args)  
     {  
           Class<?> c = null ;  
           try
           {  
                   c = Class.forName( "cn.classes.Person" );  
                   Constructor<?> con = c.getConstructors(String. class , int . class );  
                   Person p = (Person)con.newInstance( "xy" , 20 );  
                   System.out.println(p);  
           }  
          catch (Exception e)  
          {  
                 e.printStackTrace();  
          }    
     }  
}

三 Spring中使用Class实例化

双击代码全选
1
2
bean.xml  
<bean id= "id" class = "com.xy.Student" />

Spring将采用的代码创建代码Java实例

双击代码全选
1
2
Class c = Class.forName( "com.xy.Student" );  
Object bean = c.newInstance();

四 Class类调用方法

双击代码全选
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package cn.classes;  
        
public class Person  
{  
     public void add()  
     {  
            System.out.println( "add" );  
     }  
        
     public void addWithParameters(String name, int age)  
     {  
             System.out.println( "add带参数方法" + name + age);  
     }  
}  
        
        
package cn.test;  
        
import java.lang.reflect.Method;  
        
public class Test  
{  
     public static void main(String[] args)  
     {  
              Class<?> c1 = null ;  
              try
              {  
        
                    c1 = Class.forName( "cn.classes.Person" );  
        
                    // 不带参数的方法调用  
                    Method m = c1.getMethod( "add" );  
                    m.invoke(c1.newInstance());  
        
         
        
                    // 带参数方法调用  
                    Method m1 = c1.getMethod( "addWithParameters" , String. class , int . class );  
                    m1.invoke(c1.newInstance(), "xy" , 22 );  
             }  
             catch (Exception e)  
             {  
                    e.printStackTrace();  
             }  
     }  
}

五 Class获得getter，setter方法

Class这个类可以获得类的很多信息，比如获得该类的接口，构造函数，属性，方法等。我们来看如何获得getter，setter方法。

双击代码全选
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package cn.classes;  
        
public class Person  
{  
     private String name;  
     private int age;  
        
     省略getter,setter    
        
  }  
        
         
        
package cn.test;  
        
import java.lang.reflect.Method;  
        
public class Test  
{  
     public static void main(String[] args)  
     {  
            Class<?> c1 = null ;  
            Object obj = null ;  
            try
            {  
                      c1 = Class.forName( "cn.classes.Person" );  
                      obj = c1.newInstance();  
                      setter(obj, "name" , "xy" , String. class );  
                      setter(obj, "age" , 20 , int . class );  
                      getter(obj, "name" );  
                      getter(obj, "age" );  
            }  
            catch (Exception e)  
             {  
                     e.printStackTrace();  
             }  
    }  
        
    /**  
     * @param obj：要操作的对象  
     * @param att：要操作的属性  
     * @param value：要设置的属性内容  
     * @param type：要设置的属性类型  
     */
     public static void setter(Object obj, String att, Object value, Class<?> type)  
     {  
          try
          {  
             // 得到setter方法  
           Method m = obj.getClass().getMethod( "set" + initStr(att), type);  
           m.invoke(obj, value);  
          }  
          catch (Exception e)  
          {  
           e.printStackTrace();  
          }  
    }  
        
    /**  
     * @param obj：要操作的对象  
     * @param att：要操作的属性  
     */
    public static void getter(Object obj, String att)  
    {  
         try
         {  
                // 得到getter方法  
                Method m = obj.getClass().getMethod( "get" + initStr(att));  
                System.out.println(m.invoke(obj));  
         }  
        catch (Exception e)  
        {  
                e.printStackTrace();  
        }  
    }  
        
    public static String initStr(String oldStr)  
    {  
          String newStr = oldStr.substring( 0 , 1 ).toUpperCase() + oldStr.substring( 1 );  
          return newStr;  
    }  
}

六 Spring调用getter,setter方法

我们以setter注入例子

双击代码全选
1
2
3
4
bean.xml  
<bean id= "id" class = "com.xy.Student" >  
     <property name= "stuName" value= "xy" />  
</bean>

Spring将采用的代码创建代码Java实例，并注入值：

双击代码全选
1
2
Class c = Class.forName( "com.xy.Student" );  
Object bean = c.newInstance();

通过一些操作获取对stuName对应的setter方法名

双击代码全选
1
2
3
String setname = "set" + "StuName" ;  
Method method = c.getMehod(setname,String.Class);  
method.invoke(bean, "xy" );

这样就完成了最基本的注入操作。当然，Spring还可以通过构造函数进行注入。这样就参考第二点有参构造的Class的使用。

Class还可以访问Annotation，这样就Spring使用注解的时候，可以完成注入的功能。

七 总结

反射的内容还是很多的，需要系统的学习。当然，Spring也是。

本文出自 “IT Fat Man” 博客，请务必保留此出处http://woshixy.blog.51cto.com/5637578/1060263


ccecwg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring中的反射机制浅析
qq_44884300的博客
04-13 353
Spring中的反射机制浅析
Spring(反射机制)
欢迎来到懒羊羊的世界
03-29 131
Spring的用途不仅限于服务器端的开发。通过IOC和AOP等机制，能够对项目中的组件进行解耦合管理，建立一个低耦合的应用框架，并提供了更多的企业应用功能。SpringFramework的5版本目前没有最新的架构图，而最新的是4版本，所以接下来主要研究的是4的架构图。SpringFramework:Spring框架，是Spring中最早最核心的技术，也是所有其他技术的基础。Spring并不是单一的一个技术，而是一个大家族可以从官网的projects中查看其包含的所有技术。
【Spring】spring的反射机制详解
Luck_And_Destiny的博客
08-25 7462
一、什么是反射： （1）Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。 （2）Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。 二、反射的原理： 下图是类的正常加载过程、
Java反射机制
weixin_67224308的博客
03-23 552
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法。所以先要获取到每一个字节码文件对应的Class类型的对象。使用的前提条件：必须先得到代表的字节码的Class，Class类用于表示.class文件（字节码）2、反射机制的相关类在哪个包3、反射能做什么？
spring框架哪些地方用到反射
weixin_43110846的博客
01-19 831
spring框架哪些地方用到反射
spring中的反射机制
qq_35383788的博客
01-12 1191
1.首先需要知道一点，Class这个类才是反射的源头 正常方式：通过完整的类名—>通过new实例化—>取得实例化对象 反射方式：实例化对象—>getClass()方法—>通过完整的类名 2.反射的三种方式 参考：https://zhidao.baidu.com/question/808071433707589172.html 但是需要明白一点的就是:Class.forName("")；是最常用的方式。 3.Class.forName的具体用法： 参考：https://w
Spring入门之反射机制
Hrgge的博客
03-29 1094
作为轻量级的框架，它大大简化了Java企业级开发，提供了强大、稳定的功能。除了上面的这三个技术外，还有很多其他的技术，也比较流行，如SpringData,SpringSecurity等，这些都可以被应用在我们的项目中。Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。SpringFramework的5版本目前没有最新的架构图，而最新的是4版本，所以接下来主要研究的是4的架构图。
深入浅析Java反射机制
09-03
在Spring、Hibernate等Java框架中，反射机制被广泛应用于配置加载、依赖注入、AOP（面向切面编程）等方面，极大地提高了代码的可维护性和灵活性。 总的来说，Java反射机制是Java语言的精髓之一，它使得Java具备了...
浅析Java 反射机制的用途和缺点
08-27
例如，在 Spring 框架中，反射机制被用于实例化 Bean 对象、调用 setter 方法、注入依赖项等。在 Hibernate 框架中，反射机制被用于实例化对象、调用 getter 和 setter 方法等。 反射机制的缺点： 尽管反射机制...
Java反射机制应用实践
12-22
引言 　Java反射机制是一个非常强大的功能，在很多大型项目比如Spring， Mybatis都可以看见反射的身影。... 　在应用反射机制之前，首先我们先来看一下如何获取一个对象对应的反射类Class，在Java中我们有三种方法可以
使用反射和注解模拟Spring的依赖注入
07-27
NULL 博文链接：https://zmx.iteye.com/blog/688299
一文搞懂Java中的反射机制
08-24
例如，在 Spring 框架中，我们可以使用反射机制来实现依赖注入，动态地加载和使用 Bean。 此外，Java 反射机制还可以用来实现动态配置、热部署等功能。例如，我们可以使用反射机制来加载配置文件，然后使用配置文件...
Java反射机制你还不会？那你怎么看Spring
12-21
在Spring框架中，反射机制的应用非常广泛： 1. **依赖注入（DI）**：Spring通过反射来实例化对象并注入依赖。例如，通过@Autowired注解，Spring容器能在运行时查找合适的依赖并注入到目标对象的构造器或属性中。 2...
Java反射机制在Spring IOC中的应用
weixin_33712881的博客
03-28 686
IOC：即“控制反转”，不是什么技术，而是一种思想。使用IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。 本篇文章主要讲解一下IOC底层实现的原理（反射），Bean容器的实现，就不对IOC的概念进行详述了。 在Spring的配置文件中，经常看到如下配置： &lt;bean id="courseDao" class="com.qcjy.learning.Dao...
spring 中使用反射
qq_26462567的博客
03-12 8410
通过BeanId 获取Bean package cn.com.kgo.eventhand.util; import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.Applic...
spring 的反射应用
weixin_43807628的博客
02-05 1482
spring中反射的应用 https://blog.csdn.net/mlc1218559742/article/details/52774805 spring解析xml文件拿出bean元素，接着通过反射（newinstance）来创建实例 （此处是根据元素名字用反射找到对应的类） 为什么要用反射来创建对象呢？ 首先知道耦合，当在一个类里面new出另外一个类，会增加这两个类的...
工业视觉智能-分割模型基础知识
最新发布
08-18
根据《阿里云工业视觉智能高级工程师ACP认证免费课程》（https://edu.aliyun.com/course/3128115/lesson/342981389）创建的个人笔记
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值