精华内容
下载资源
问答
  • JAVA反射原理

    2019-03-01 16:29:39
    JAVA反射原理1 JAVA反射原理2 JAVA反射原理3

    What,s 反射

    反射是个啥?
    为啥要反射?
    反射怎么弄?

    要弄懂反射,首先需要回答关于反射的这三大问题。
    这篇博客的主要目的就是深入浅出地来回答这三个问题。

    RTTI

    “卧槽,这是啥,为啥带我到这里,我要知道啥是反射,这四个让人看不懂的字母是个啥。”
    骚年,别着急,一步一步来学习,要搞懂反射,先要认识反射他爸(干爸吧),RTTI(Runtime Type Information,运行时类型信息)

    并不是所有的Class都能在编译时明确,因此在某些情况下需要在运行时再发现和确定类型信息(比如:基于构建编程,),这就是RTTI(Runtime Type Information,运行时类型信息)。

    在java中,有两种RTTI的方式,一种是传统的,即假设在编译时已经知道了所有的类型;还有一种,是利用反射机制,在运行时再尝试确定类型信息。

    本文主要讲反射方式实现的RTTI,建议在阅读本文之前,先了解类的加载机制(参考我的博客:JAVA类加载详解)。

    传统的RTTI

    严格的说,反射也是一种形式的RTTI,不过,一般的文档资料中把RTTI和反射分开,因为一般的,大家认为RTTI指的是传统的RTTI,通过继承和多态来实现,在运行时通过调用超类的方法来实现具体的功能(超类会自动实例化为子类,或使用instance of)。

    传统的RTTI有3种实现方式:

    • 向上转型或向下转型(upcasting and downcasting),在java中,向下转型(父类转成子类)需要强制类型转换
    • Class对象(用了Class对象,不代表就是反射,如果只是用Class对象cast成指定的类,那就还是传统的RTTI)
    • instanceof或isInstance()

    传统的RTTI与反射最主要的区别,在于RTTI在编译期需要.class文件,而反射不需要。传统的RTTI使用转型或Instance形式实现,但都需要指定要转型的类型。

    public void rtti(Object obj){
        Toy toy = Toy(obj);
        // Toy toy = Class.forName("myblog.rtti.Toy")
        // obj instanceof Toy
    }
    

    obj虽然是被转型了,但在编译期,就需要知道要转成的类型Toy,也就是需要Toy的.class文件。

    相对的,反射完全在运行时在通过Class类来确定类型,不需要提前加载Toy的.class文件。

    反射

    那到底什么是反射(Reflection)呢?反射有时候也被称为内省(Introspection),事实上,反射,就是一种内省的方式,**Java不允许在运行时改变程序结构或类型变量的结构,但它允许在运行时去探知、加载、调用在编译期完全未知的class,可以在运行时加载该class,生成实例对象(instance object),调用method,或对field赋值。

    关于Java的反射API,没必要去记忆,可以在任何JDK API中查询即可:

    Class类:http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/Class.html

    reflect包:http://www.ostools.net/uploads/apidocs/jdk-zh/java/lang/reflect/package-summary.html

    反射的缺点

    这世界上没有什么东西是完美的,口中完美的东西反而死的越快。就像…,能举出来的例子就像省略号一样多。

    • 复杂(本来JAVA敲得好好的,你突然出来个反射)
    • 效率低(18弯的山路肯定要比直直的大马路效率要低)

    反射有什么用

    灵活,没错,反射的优点就只有这一个,但却是最致命的那一个。它让JAVA变成了一个风骚的绅士,颇具魅力。让其在各大语言的战斗中,深得程序员的深爱。
    如果JAVA没有反射,就像哈士奇没有了傻二,就像猫咪没有了可爱,就像我没有了帅气。真的太严重了。

    没有了反射首先:
    1.所有简单好用的框架和骚代码都消失了

    没错,就这一点就足够致命了,所以真的难以想象失去了反射的JAVA还能走多远,就像真的难以想象失去帅气的我还有什么用。(写到这里我有点被自己感动的想哭)

    反射的底层原理

    反射的底层,这里主要讲解Method的获取与执行

    Method获取

    调用Class类的getDeclaredMethod可以获取指定方法名和参数的方法对象Method。

    getDeclaredMethod
    在这里插入图片描述
    这里,我们看到privateGetDeclaredMethods和searchMethods两个看起来陌生又重要的方法,privateGetDeclaredMethods方法从缓存或JVM中获取该Class中申明的方法列表,searchMethods方法将从返回的方法列表里找到一个匹配名称和参数的方法对象。

    searchMethods
    在这里插入图片描述

    如果找到一个匹配的Method,则重新copy一份返回,即Method.copy()方法。
    所次每次调用getDeclaredMethod方法返回的Method对象其实都是一个新的对象,且新对象的root属性都指向原来的Method对象,如果需要频繁调用,最好把Method对象缓存起来。

    privateGetDeclaredMethods
    从缓存或JVM中获取该Class中申明的方法列表,实现如下:
    在这里插入图片描述

    其中reflectionData()方法实现如下:
    在这里插入图片描述

    这里有个比较重要的数据结构ReflectionData,用来缓存从JVM中读取类的如下属性数据:
    在这里插入图片描述

    从reflectionData()方法实现可以看出:reflectionData对象是SoftReference类型的,说明在内存紧张时可能会被回收,不过也可以通过-XX:SoftRefLRUPolicyMSPerMB参数控制回收的时机,只要发生GC就会将其回收,如果reflectionData被回收之后,又执行了反射方法,那只能通过newReflectionData方法重新创建一个这样的对象了,newReflectionData方法实现如下:
    在这里插入图片描述

    通过unsafe.compareAndSwapObject方法重新设置reflectionData字段;

    在privateGetDeclaredMethods方法中,如果通过reflectionData()获得的ReflectionData对象不为空,则尝试从ReflectionData对象中获取declaredMethods属性,如果是第一次,或则被GC回收之后,重新初始化后的类属性为空,则需要重新到JVM中获取一次,并赋值给ReflectionData,下次调用就可以使用缓存数据了。

    Method调用

    获取到指定的方法对象Method之后,就可以调用它的invoke方法了,invoke实现如下:
    在这里插入图片描述

    应该注意到:这里的MethodAccessor对象是invoke方法实现的关键,一开始methodAccessor为空,需要调用acquireMethodAccessor生成一个新的MethodAccessor对象,MethodAccessor本身就是一个接口,实现如下:
    在这里插入图片描述
    在acquireMethodAccessor方法中,会通过ReflectionFactory类的newMethodAccessor创建一个实现了MethodAccessor接口的对象,实现如下:
    在这里插入图片描述

    在ReflectionFactory类中,有2个重要的字段:noInflation(默认false)和inflationThreshold(默认15),在checkInitted方法中可以通过-Dsun.reflect.inflationThreshold=xxx和-Dsun.reflect.noInflation=true对这两个字段重新设置,而且只会设置一次;

    如果noInflation为false,方法newMethodAccessor都会返回DelegatingMethodAccessorImpl对象,DelegatingMethodAccessorImpl的类实现
    在这里插入图片描述

    其实,DelegatingMethodAccessorImpl对象就是一个代理对象,负责调用被代理对象delegate的invoke方法,其中delegate参数目前是NativeMethodAccessorImpl对象,所以最终Method的invoke方法调用的是NativeMethodAccessorImpl对象invoke方法,实现如下:

    在这里插入图片描述
    这里用到了ReflectionFactory类中的inflationThreshold,当delegate调用了15次invoke方法之后,如果继续调用就通过MethodAccessorGenerator类的generateMethod方法生成MethodAccessorImpl对象,并设置为delegate对象,这样下次执行Method.invoke时,就调用新建的MethodAccessor对象的invoke()方法了。

    这里需要注意的是:
    generateMethod方法在生成MethodAccessorImpl对象时,会在内存中生成对应的字节码,并调用ClassDefiner.defineClass创建对应的class对象,实现如下:
    在这里插入图片描述

    在ClassDefiner.defineClass方法实现中,每被调用一次都会生成一个DelegatingClassLoader类加载器对象
    在这里插入图片描述

    这里每次都生成新的类加载器,是为了性能考虑,在某些情况下可以卸载这些生成的类,因为类的卸载是只有在类加载器可以被回收的情况下才会被回收的,如果用了原来的类加载器,那可能导致这些新创建的类一直无法被卸载,从其设计来看本身就不希望这些类一直存在内存里的,在需要的时候有就行了。

    参考链接:
    JAVA反射原理0
    JAVA反射原理1
    JAVA反射原理2
    JAVA反射原理3

    展开全文
  • Java反射原理

    千次阅读 2018-08-14 13:37:39
    Java反射原理 1.将Java文件保存到本地硬盘 2.编译Java文件,生成.class文件 3.使用Java虚拟机(JVM)将字节码文件加载到内存 4.字节码文件在内存中使用Class类表示 5.使用反射的时候,首先获取到Class类,就...

    了解:大部分框架实现的原理就是利用的反射。

    Java反射原理

    1.将Java文件保存到本地硬盘

    2.编译Java文件,生成.class文件

    3.使用Java虚拟机(JVM)将字节码文件加载到内存

    4.字节码文件在内存中使用Class类表示

    5.使用反射的时候,首先获取到Class类,就可以得到class文件里的所有内容,包含属性、构造方法、普通方法

    6.属性通过Filed类表示

    7.构造方法通过Constructor表示

    8.普通方法通过Method表示

    得到Class类的三种方法

    以Person.java为例

    package reflect;
    
    public class Person {
    
    	private String name;
    	private String age;
    
    	public String getName() {
    		return name;
    	}
    
    	public void setName(String name) {
    		this.name = name;
    	}
    
    	public String getAge() {
    		return age;
    	}
    
    	public void setAge(String age) {
    		this.age = age;
    	}
    
    	public Person(String name, String age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    
    	public Person() {
    		super();
    	}
    
    }
    
    //第一种方法
    Class class1 = Person.class
    
    //第二种方法
    Class class2 = new Person().getClass();
    
    //第三种方法
    Class class3 = Class.forName("Person.java的路径");

    具体操作属性、构造器、方法

    注意:当方法或属性用静态修饰,某些方法用到对象时,用null表示。如:m.invoke(null, "wangmazi");

    使用反射操作属性

    private static void field()
    			throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    		// 使用反射操作属性(变量)
    		Class class1 = Class.forName("reflect.Person");
    
    		// 得到所有的属性
    		// class1.getDeclaredFields();
    
    		// 得到对象
    		Person p = (Person) class1.newInstance();
    
    		// 得到指定的属性
    		Field f = class1.getDeclaredField("name");
    
    		// 设置方法允许操作私有属性
    		f.setAccessible(true);
    
    		// 赋值
    		f.set(p, "zhangsan");
    
    		// 获取值(Person中设置属性为私有,需要设置一个方法setAccessible(true))
    		System.out.println(f.get(p));
    	}

    使用反射操作构造器

    private static void constructor() throws ClassNotFoundException, NoSuchMethodException, InstantiationException,
    			IllegalAccessException, InvocationTargetException {
    		Class class2 = Class.forName("reflect.Person");
    
    		// 得到所有的构造方法
    		// class2.getConstructor();
    
    		// 得到指定的构造方法
    		Constructor c = class2.getConstructor(String.class, String.class);
    
    		// 得到对象
    		Person p = (Person) c.newInstance("lisi", "100");
    
    		System.out.println(p.getName() + p.getAge());
    	}

    使用反射操作方法

    private static void method() throws ClassNotFoundException, InstantiationException, IllegalAccessException,
    			NoSuchMethodException, InvocationTargetException {
    		Class class3 = Class.forName("reflect.Person");
    
    		// 得到对象
    		Person p = (Person) class3.newInstance();
    
    		// 获取所有普通方法
    		class3.getDeclaredMethods();
    
    		// 获取指定参数普通方法
    		Method m = class3.getDeclaredMethod("setName", String.class);
    
    		m.invoke(p, "wangmazi");
    
    		System.out.println(p.getName());
    	}

     

    展开全文
  • java反射原理

    千次阅读 多人点赞 2011-03-03 10:52:00
    java反射原理 知道了java反射实现,了解了java反射性能,现在发掘一下java反射原理

    写在转载前:

    知道了java反射实现,了解了java反射性能,现在发掘一下java反射原理

    转载:

    一、预先需要掌握的知识(java虚拟机) 

    java虚拟机的方法区: 

    java虚拟机有一个运行时数据区,这个数据区又被分为方法区,堆区和栈区,我们这里需要了解的主要是方法区。方法区的主要作用是存储被装载的类的类型信息,当java虚拟机装载某个类型的时候,需要类装载器定位相应的class文件,然后将其读入到java虚拟机中,紧接着虚拟机提取class中的类型信息,将这些信息存储到方法区中。这些信息主要包括: 

    1、这个类型的全限定名 

    2、这个类型的直接超类的全限定名 

    3、这个类型是类类型还是接口类型 

    4、这个类型的访问修饰符 

    5、任何直接超接口的全限定名的有序列表 

    6、该类型的常量池 

    7、字段信息 

    8、方法信息 

    9、除了常量以外的所有类变量 

    10、一个到class类的引用 

    等等(读者可以参考《深入java虚拟机》这本书的叙述) 

    Class类: 

    Class类是一个非常重要的java基础类,每当装载一个新的类型的时候,java虚拟机都会在java堆中创建一个对应于新类型的Class实例,该实例就代表此类型,通过该Class实例我们就可以访问该类型的基本信息。上面说到在方法区中会存储某个被装载类的类型信息,我们就可以通过Class实例来访问这些信息。比如,对于上面说到的信息Class中都有对应的方法,如下: 

    1、getName();这个类型的全限定名 

    2、getSuperClass();这个类型的直接超类的全限定名 

    3、isInterface();这个类型是类类型还是接口类型 

    4、getTypeParamters();这个类型的访问修饰符 

      5、getInterfaces();任何直接超接口的全限定名的有序列表 

      6、getFields();字段信息 

    7、getMethods();方法信息 

    等等(读者可以自己参看jdk帮助文档,得到更多的信息) 

    二、java反射详解 

    反射的概念:所谓的反射就是java语言在运行时拥有一项自观的能力,反射使您的程序代码能够得到装载到JVM中的类的内部信息,允许您执行程序时才得到需要类的内部信息,而不是在编写代码的时候就必须要知道所需类的内部信息,这使反射成为构建灵活的应用的主要工具。 

    反射的常用类和函数:Java反射机制的实现要借助于4个类:Class,Constructor,Field,Method;其中class代表的是类对象,Constructor-类的构造器对象,Field-类的属性对象,Method-类的方法对象,通过这四个对象我们可以粗略的看到一个类的各个组成部分。其中最核心的就是Class类,它是实现反射的基础,它包含的方法我们在第一部分已经进行了基本的阐述。应用反射时我们最关心的一般是一个类的构造器、属性和方法,下面我们主要介绍Class类中针对这三个元素的方法: 

    1、得到构造器的方法 

    Constructor getConstructor(Class[] params) -- 获得使用特殊的参数类型的公共构造函数, 

    Constructor[] getConstructors() -- 获得类的所有公共构造函数 

    Constructor getDeclaredConstructor(Class[] params) -- 获得使用特定参数类型的构造函数(与接入级别无关) 

    Constructor[] getDeclaredConstructors() -- 获得类的所有构造函数(与接入级别无关) 

    2、获得字段信息的方法 

    Field getField(String name) -- 获得命名的公共字段 

    Field[] getFields() -- 获得类的所有公共字段 

    Field getDeclaredField(String name) -- 获得类声明的命名的字段 

    Field[] getDeclaredFields() -- 获得类声明的所有字段 
    3、获得方法信息的方法 

    Method getMethod(String name, Class[] params) -- 使用特定的参数类型,获得命名的公共方法 

    Method[] getMethods() -- 获得类的所有公共方法 

    Method getDeclaredMethod(String name, Class[] params) -- 使用特写的参数类型,获得类声明的命名的方法 

    Method[] getDeclaredMethods() -- 获得类声明的所有方法 

    应用反射的基本步骤: 

    1、获得你想操作的类的Class对象; 

         方法一:Class c=Class.forName("java.lang.String") 

         方法二:对于基本数据类型可以用形如Class c=int.class或Class c=Integer.TYPE的语句 

         方法三:Class c=MyClass.class 

    2、调用Class中的方法得到你想得到的信息集合,如调用getDeclaredFields()方法得到类的所有属性; 

      3、处理第2步中得到的信息,然后进行你想做的实际操作。 

      反射实例: 

    下面我将针对类的构造器、属性和方法分别举三个例子,向大家演示一下反射的应用过程。 

    1、构造器 

    步骤为:通过反射机制得到某个类的构造器,然后调用该构造器创建该类的一个实例 

    import java.lang.reflect.*; 
    public class ConstructorDemo{ 
       public ConstructorDemo(){ } 
       public ConstructorDemo(int a, int b){ 
           System.out.println("a="+a+"b="+b); 
       } 

       public static void main(String args[]){ 
           try { 
               Class cls = Class.forName("ConstructorDemo"); 
               Class partypes[] = new Class[2]; partypes[0] = Integer.TYPE;   
               partypes[1] = Integer.TYPE; 
               Constructor ct= cls.getConstructor(partypes); 
               Object arglist[] = new Object[2]; 
               arglist[0] = new Integer(37); 
               arglist[1] = new Integer(47); 
               Object retobj = ct.newInstance(arglist); 
             } catch (Throwable e) { 
               System.err.println(e); } 
             } 
       } 

    2、属性 

    步骤为:通过反射机制得到某个类的某个属性,然后改变对应于这个类的某个实例的该属性值 

    import java.lang.reflect.*; 
    public class FieldDemo1{ 
      public double d; 

      public static void main(String args[]){ 
      try { 
        Class cls = Class.forName("FieldDemo1"); 
        Field fld = cls.getField("d"); 
        FieldDemo1 fobj = new FieldDemo1(); 
        System.out.println("d = " + fobj.d); 
        fld.setDouble(fobj, 12.34); 
        System.out.println("d = " + fobj.d); 
      } catch (Throwable e){ 
        System.err.println(e); } 
      } 


    3、方法 

    步骤为:通过反射机制得到某个类的某个方法,然后调用对应于这个类的某个实例的该方法 

    //通过使用方法的名字调用方法 
    import java.lang.reflect.*; 
    public class MethodDemo1{ 
      public int add(int a, int b){ 
      return a + b; 
      } 

      public static void main(String args[]){ 
        try { 
          Class cls = Class.forName("MethodDemo1"); 
          Class partypes[] = new Class[2]; 
          partypes[0] = Integer.TYPE; 
          partypes[1] = Integer.TYPE; 
          Method meth = cls.getMethod("add", partypes); 
          MethodDemo1 methobj = new MethodDemo1(); 
          Object arglist[] = new Object[2]; 
          arglist[0] = new Integer(37); 
          arglist[1] = new Integer(47); 
          Object retobj= meth.invoke(methobj, arglist); 
          Integer retval = (Integer)retobj; 
          System.out.println(retval.intValue()); 
        } catch (Throwable e) { 
          System.err.println(e); 
        } 
      } 


    三、java反射的应用(Hibernate) 

    我们在第二部分中对java反射进行了比较系统的阐述,也举了几个简单的实例,下面我们就来讨论一下java反射的具体应用。前面我们已经知道,Java反射机制提供了一种动态链接程序组件的多功能方法,它允许程序创建和控制任何类的对象(根据安全性限制)之前,无需提前硬编码目标类。这些特性使得反射特别适用于创建以非常普通的方式与对象协作的库。例如,反射经常在持续存储对象为数据库、XML或其它外部格式的框架中使用。下面我们就已Hibernate框架为例像大家阐述一下反射的重要意义。 

    Hibernate是一个屏蔽了JDBC,实现了ORM的java框架,利用该框架我们可以抛弃掉繁琐的sql语句而是利用Hibernate中Session类的save()方法直接将某个类的对象存到数据库中,也就是所涉及到sql语句的那些代码Hibernate帮我们做了。这时候就出现了一个问题,Hibernate怎样知道他要存的某个对象都有什么属性呢?这些属性都是什么类型呢?如此,它在向数据库中存储该对象属性时的sql语句该怎么构造呢?解决这个问题的利器就是我们的java反射! 

    下面我们以一个例子来进行阐述,比如我们定义了一个User类,这个User类中有20个属性和这些属性的get和set方法,相应的在数据库中有一个User表,这个User表中对应着20个字段。假设我们从User表中提取了一条记录,现在需要将这条记录的20个字段的内容分别赋给一个User对象myUser的20个属性,而Hibernate框架在编译的时候并不知道这个User类,他无法直接调用myUser.getXXX或者myUser.setXXX方法,此时就用到了反射,具体处理过程如下: 

    1、根据查询条件构造PreparedStament语句,该语句返回20个字段的值; 

    2、Hibernate通过读取配置文件得到User类的属性列表list(是一个String数组)以及这些属性的类型; 

    3、创建myUser所属类的Class对象c;c=myUser.getClass(); 

    4、构造一个for循环,循环的次数为list列表的长度; 

         4.1、读取list[i]的值,然后构造对应该属性的set方法; 

         4.2、判断list[i]的类型XXX,调用PreparedStament语句中的getXXX(i),进而得到i出字段的值; 

         4.3、将4.2中得到的值作为4.1中得到的set方法的参数,这样就完成了一个字段像一个属性的赋值,如此循环即可; 

    看到了吧,这就是反射的功劳,如果没有反射很难想象如果完成同样的功能会有多么难!但是反射也有缺点,比如性能比较低、安全性比较复杂等,这里就不在讨论这些东西,感兴趣的读者可以在网上找到答案,有很多的!

    展开全文
  • Java反射原理与使用

    万次阅读 2020-12-21 16:23:09
    当类加载器将类加载进jvm之后,jvm会创建每一个类的元数据对象(Class),java语言允许通过元数据对象动态的创建对象实例,这种机制就称为java反射机制,基本上所有框架的底层都用到了反射机制,spring、mybatis、servlet...

    当类加载器将类加载进jvm之后,jvm会创建每一个类的元数据对象(Class),这个元数据对象(Class)记录着这类的所有信息,java语言允许通过元数据对象动态的创建对象实例,这种机制就称为java的反射机制,基本上所有框架的底层都用到了反射机制,spring、mybatis、servlet都用到了

    1.如何获取一个类的元数据对象(Class)呢

    现在有一个User类

    package com.niu.demo;
    
    public class User {
        private String name;
        private String password;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    }
    

    获取User的元数据对象(Class)方式

    public class Main2 {
        public static void main(String[] args) {
            Class<User> aClass1 = User.class; // 1、类名.class
            Class<?> aClass2 = Class.forName("com.niu.demo.User"); //2、类完整的路径名
            User user = new User();
            Class<? extends User> aClass = user.getClass(); //3、对象引用.getClass()方式
        }
    }

    2.如何通过类的元数据对象(Class)创建对象呢

    我们采用第一种获取Class对象的方式

    Class<User> aClass1 = User.class; // 1、类名.class
    User user = aClass1.newInstance();

    这样就完成了通过反射的方式完成了类的创建

    3.还可以对通过Class对象做什么

    我们可以通过元数据Class对象获取对象的所有信息,如方法、属性、父类、接口、构造器。。。。

    3.1 给属性赋值

    public class Main2 {
        public static void main(String[] args) throws Exception {
            //1、第一种方式
            User user = new User();
            user.setName("张三");
            System.out.println(user.getName());
            //通过反射给属性赋值 传入属性名
            Field field = user.getClass().getDeclaredField("name");
            field.setAccessible(true);
            field.set(user,"李四");
            System.out.println(user.getName());
            
            //2、第二种方式
            User user1 = User.class.newInstance();
            user1.setName("王五");
            System.out.println(user1.getName());
    
        }
    }

    输出

    3.2 反射调用对象方法

    我们在User加入如下方法

        public boolean passwordCheck(String password){
            if (password==null || password.length()<3){
                System.out.println("password can't be used");
                return false;
            }else {
                System.out.println("password is ok");
                return true;
            }
        }
    

    调用测试

        public static void main(String[] args) throws Exception {
            User user = new User();
            //传入方法名和参数类型
            Method passwordCheck = user.getClass().getDeclaredMethod("passwordCheck",String.class);
            Object invoke1 = passwordCheck.invoke(user, "12");
            System.out.println(invoke1);
    
            Object invoke2 = passwordCheck.invoke(user, "123");
            System.out.println(invoke2);
        }

    输出

    4、框架里是如何使用反射的

    tomcat里web.xml

     <servlet>
      	<servlet-name>HelloServlet</servlet-name>
      	<servlet-class>servlet.HelloServlet</servlet-class>
      </servlet>
      <servlet-mapping>
      	<servlet-name>HelloServlet</servlet-name>
      	<url-pattern>/servlet/HelloServlet</url-pattern>
      </servlet-mapping>
    

    其中:<servlet-class>配置的完整类路径,然后通过Class.forName()来实例化servlet

    spring的ioc  mybatis的mapper等等等等。。。 都是用到了反射

    展开全文
  • 面试官这样问我Java反射原理,我刚好都会

    千次阅读 多人点赞 2020-04-11 11:46:30
    上周我投递出了简历,岗位是java后端开发工程师。这周美团面试官给我进行了面试,面试过程中他问了Java的反射原理。于是今天结合面试问题先详细讲一讲Java反射原理
  • java反射原理-重要

    万次阅读 多人点赞 2018-11-20 23:00:19
    1,JAVA反射机制是在运行状态中 对于任意一个类,都能够知道这个类的所有属性和方法; 对于任意一个对象,都能够调用它的任意一个方法和属性; 这种动态获取的信息以及动态调用对象的方法的功能称为java语言的...
  • 反射原理:每一个类都有一个Class对象。所有类都是在第一次使用时,动态加载到JVM中,当程序创建第一个对类的静态成员引用时,会加载这个类。一旦你一个类的Class对象被载入到内存,它便被用来创建这个类的所有对象...
  • Java反射原理分析

    千次阅读 2015-03-07 18:45:56
    一:Java反射就是把Java类中的各种成分映射成相应的Java类。 例如:一个Java类中用一个Class类的对象来表示此Java类中的组成部分:成员变量,方法,构造方法,包等信息也用一个个的Java类来表示。 比如汽车是一...
  • 深入浅出Java反射原理和使用场景

    万次阅读 多人点赞 2019-04-19 16:38:56
    反射非常重要,特别是Spring这类框架离不开反射,而反射对于初学者理解起来其实还是有一定的难度的,本帖希望把晦涩的反色用最易懂的方式给你讲明白。 先不说反射是什么先看一个问题:如果不知道对象的真实类型...
  • Java反射与Class 目录 反射原理概述 反射的概念是什么? 为什么要使用反射? 反射的作用是什么? 反射的实现 Class类 Class类的对象 1、反射原理概述 1.1 反射的概念 反射就是在运行...
  • Java反射原理及应用(二)

    千次阅读 2012-07-18 14:23:20
    一、什么是反射反射的概念是由Smith在1982年首次提出的,主要是指程序可以访问、检测和修改它本身...其中LEAD/LEAD++ 、OpenC++ 、MetaXa和OpenJava等就是基于反射机制的语言。最近,反射机制也被应用到了视窗系统
  • JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法(类名,方法名,参数类型,返回值类型);对于任意一个对象,都能够调用它任意的一个方法和属性;这种动态获取的信息以及动态调用...
  • 首先了解一下反射原理,什么是反射?所谓的反射就是指java 语言在运行时拥有一项自观的能力,反射能使你得到装载到 jvm 中的类的内部信息,它不需要你在编码的时候就知道所需类的内部信息,允许程序执行时才得到所...
  • java反射原理,作用

    万次阅读 多人点赞 2018-10-17 14:31:44
    什么是反射,反射原理 Java反射的原理:java类的执行需要经历以下过程, 编译:.java文件编译后生成.class字节码文件 加载:类加载器负责根据一个类的全限定名来读取此类的二进制字节流到JVM内部,并存储在运行时...
  • 思考:在讲反射之前,先思考一个问题,java中如何创建一个对象,有哪几种方式? Java中创建对象大概有这几种方式: 1、使用new关键字:这是我们最常见的也是最简单的创建对象的方式 2、使用Clone的方法:无论何时...
  • Java反射原理与Spring的自动注入 反射的定义 java的反射机制就是在运行状态中, 对于任意一个类都能够知道这个类的所有属性和方法; 对于任意一个对象,都能够调用它的任意一个方法和属性。 这种动态获取的信息以及...
  • java反射底层原理

    千次阅读 2017-12-27 17:04:25
    反射的Method.invoke前15次是调用navite code用C++实现的,后面使用java实现 原因: Java实现的版本在初始化时需要较多时间,但长久来说性能较好;native版本正好相反,启动时相对较快,但运行时间长了之后速度...
  • Java反射

    万次阅读 多人点赞 2019-08-28 22:58:42
    Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性。这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。 用途 ...
  • java反射机制的原理

    2018-03-19 11:45:45
    什么是java的反射:1....反射的作用:java程序可以加载一个运行时才得知名称的class,通过class的全限定名,利用java反射机制就可以获取该类的全部信息,可以动态的创建对象和编译。三、反射的原理JAVA语言编译...
  • java 反射机制原理 简述

    千次阅读 2019-03-23 16:16:03
    这种动态获取信息以及动态调用对象的方法的功能称为JAVA反射反射的作用 1、在运行时判断任意一个对象所属的类; 2、在运行时构造任意一个类的对象; 3、在运行时判断任意一个类所具有的成员变量和方法; 4...
  • JAVA反射机制及其原理实现

    千次阅读 2020-03-10 23:08:34
    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;public、protected、private。 OO(面向对象),private私有的,不能访问。...
  • Java反射机制的原理和用途

    万次阅读 多人点赞 2017-09-07 11:19:14
    看了好多关于Java反射机制的文章,大多都太过官方,消化起来比较稍显费劲,本篇,我会依据自己的理解去阐述什么是Java的反射机制,反射用在什么地方,以及怎么来使用? 开篇前,我们还是要了解一下,什么是Java的...
  • java反射底层原理

    千次阅读 2019-08-18 22:14:15
    Java反射机制是java的这门语言所独有的,这也是面试官喜欢问的知识点之一,我们不能仅仅从会使用反射这个类以及类中方法,来认定自己会这个知识点,我认为这太过于表面,不是我们学习java的正确的方式。 首先我们先...
  • 浅谈Java反射的实现原理

    千次阅读 2017-04-30 10:54:54
    Java反射的实现原理

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 108,073
精华内容 43,229
关键字:

java反射原理

java 订阅