您现在的位置: 365建站网 > 365学习 > java反射机制(原理/应用场景/创建对象)详解

java反射机制(原理/应用场景/创建对象)详解

文章来源:365jz.com     点击数:554    更新时间:2017-11-27 15:26   参与评论
JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。
JAVA反射(放射)机制:“程序运行时,允许改变程序结构或变量类型,这种语言称为动态语言”。从这个观点看,Perl,Python,Ruby是动态语言,C++,Java,C#不是动态语言。但是JAVA有着一个非常突出的动态相关机制:Reflection,用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说,Java程序可以加载一个运行时才得知名称的class,获悉其完整构造(但不包括methods定义),并生成其对象实体、或对其fields设值、或唤起其methods。

Java的反射机制是Java特性之一,反射机制是构建框架技术的基础所在。灵活掌握Java反射机制,对大家以后学习框架技术有很大的帮助。
那么什么是Java的反射呢?
       大家都知道,要让Java程序能够运行,那么就得让Java类要被Java虚拟机加载。Java类如果不被Java虚拟机加载,是不能正常运行的。现在我们运行的所有的程序都是在编译期的时候就已经知道了你所需要的那个类的已经被加载了。
Java的反射机制是在编译并不确定是哪个类被加载了,而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。
那么Java反射有什么作用呢?
假如我们有两个程序员,一个程序员在写程序的时候,需要使用第二个程序员所写的类,但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢?这是不能通过编译的。利用Java反射的机制,就可以让第一个程序员在没有得到第二个程序员所写的类的时候,来完成自身代码的编译。
Java的反射机制它知道类的基本结构,这种对Java类结构探知的能力,我们称为Java类的“自审”。大家都用过Jcreator和eclipse。当我们构建出一个对象的时候,去调用该对象的方法和属性的时候。一按点,编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来,供用户进行选择。这就是利用了Java反射的原理,是对我们创建对象的探知、自审。
Class类
       要正确使用Java反射机制就得使用java.lang.Class这个类。它是Java反射机制的起源。当一个类被加载以后,Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。
反射API
        u反射API用于反应在当前Java虚拟机中的类、接口或者对象信息
u功能
—获取一个对象的类信息.
       —获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息.
       —检获属于一个接口的常量和方法声明.
       —创建一个直到程序运行期间才知道名字的类的实例.
       —获取并设置一个对象的成员,甚至这个成员的名字是
   在程序运行期间才知道.
       —检测一个在运行期间才知道名字的对象的方法
    利用Java反射机制我们可以很灵活的对已经加载到Java虚拟机当中的类信息进行检测。当然这种检测在对运行的性能上会有些减弱,所以什么时候使用反射,就要靠业务的需求、大小,以及经验的积累来决定。

          反射,当时经常听他们说,自己也看过一些资料,也可能在设计模式中使用过,但是感觉对它没有一个较深入的了解,这次重新学习了一下,感觉还行吧!

           一,先看一下反射的概念:
              主要是指程序可以访问,检测和修改它本身状态或行为的一种能力,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。
             反射是java中一种强大的工具,能够使我们很方便的创建灵活的代码,这些代码可以再运行时装配,无需在组件之间进行源代码链接。但是反射使用不当会成本很高!
             看概念很晕的,继续往下看。

      二,反射机制的作用:
              1,反编译:.class-->.java
              2,通过反射机制访问java对象的属性,方法,构造方法等;
             这样好像更容易理解一些,下边我们具体看怎么实现这些功能。

      三,在这里先看一下sun为我们提供了那些反射机制中的类:

java.lang.Class;               
java.lang.reflect.Constructor; java.lang.reflect.Field;       
java.lang.reflect.Method;
java.lang.reflect.Modifier;


            很多反射中的方法,属性等操作我们可以从这四个类中查询。还是哪句话要学着不断的查询API,那才是我们最好的老师。

         四,具体功能实现:
                1,反射机制获取类有三种方法,我们来获取Employee类型

//第一种方式: 
Classc1 = Class.forName("Employee"); 
//第二种方式: 
//java中每个类型都有class 属性. 
Classc2 = Employee.class; 
  
//第三种方式: 
//java语言中任何一个java对象都有getClass 方法 
Employeee = new Employee(); 
Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee) 



    2,创建对象:获取类以后我们来创建它的对象,利用newInstance:

Class c =Class.forName("Employee"); 
 
//创建此Class 对象所表示的类的一个新实例 
Objecto = c.newInstance(); //调用了Employee的无参数构造方法. 



    3,获取属性:分为所有的属性和指定的属性:
      a,先看获取所有的属性的写法:

//获取整个类 
            Class c = Class.forName("java.lang.Integer"); 
              //获取所有的属性? 
            Field[] fs = c.getDeclaredFields(); 
      
                   //定义可变长的字符串,用来存储属性 
            StringBuffer sb = new StringBuffer(); 
            //通过追加的方法,将每个属性拼接到此字符串中 
            //最外边的public定义 
            sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n"); 
            //里边的每一个属性 
            for(Field field:fs){ 
                sb.append("\t");//空格 
                sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符,例如public,static等等 
                sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字 
                sb.append(field.getName()+";\n");//属性的名字+回车 
            } 
     
            sb.append("}"); 
     
            System.out.println(sb); 


       b,获取特定的属性,对比着传统的方法来学习:

public static void main(String[] args) throws Exception{ 
             
<span style="white-space:pre">  </span>//以前的方式: 
    /*
    User u = new User();
    u.age = 12; //set
    System.out.println(u.age); //get
    */ 
             
    //获取类 
    Class c = Class.forName("User"); 
    //获取id属性 
    Field idF = c.getDeclaredField("id"); 
    //实例化这个类赋给o 
    Object o = c.newInstance(); 
    //打破封装 
    idF.setAccessible(true); //使用反射机制可以打破封装性,导致了java对象的属性不安全。 
    //给o对象的id属性赋值"110" 
    idF.set(o, "110"); //set 
    //get 
    System.out.println(idF.get(o)); 


 4,获取方法,和构造方法,不再详细描述,只来看一下关键字:

方法关键字

含义

getDeclaredMethods()

获取所有的方法

getReturnType()

获得方法的放回类型

getParameterTypes()

获得方法的传入参数类型

getDeclaredMethod("方法名",参数类型.class,……)

获得特定的方法

 

 

构造方法关键字

含义

getDeclaredConstructors()

获取所有的构造方法

getDeclaredConstructor(参数类型.class,……)

获取特定的构造方法

 

 

父类和父接口

含义

getSuperclass()

获取某类的父类

getInterfaces()

获取某类实现的接口

  

         这样我们就可以获得类的各种内容,进行了反编译。对于JAVA这种先编译再运行的语言来说,反射机制可以使代码更加灵活,更加容易实现面向对象

  五,反射加配置文件,使我们的程序更加灵活:
             在设计模式学习当中,学习抽象工厂的时候就用到了反射来更加方便的读取数据库链接字符串等,当时不是太理解,就照着抄了。看一下.NET中的反射+配置文件的使用:
             当时用的配置文件是app.config文件,内容是XML格式的,里边填写链接数据库的内容:

 

      <configuration
lt;appSettings> 
<add     key=""  value=""/> 
lt;/appSettings> 
        </configuration


反射的写法:  
 

assembly.load("当前程序集的名称").CreateInstance("当前命名空间名称".要实例化的类名); 



          这样的好处是很容易的方便我们变换数据库,例如我们将系统的数据库从SQL Server升级到Oracle,那么我们写两份D层,在配置文件的内容改一下,或者加条件选择一下即可,带来了很大的方便。
           
         当然了,JAVA中其实也是一样,只不过这里的配置文件为.properties,称作属性文件。通过反射读取里边的内容。这样代码是固定的,但是配置文件的内容我们可以改,这样使我们的代码灵活了很多!

    综上为,JAVA反射的再次学习,灵活的运用它,能够使我们的代码更加灵活,但是它也有它的缺点,就是运用它会使我们的软件的性能降低,复杂度增加,所以还要我们慎重的使用它。

 

      那么如何利用反射API在运行的时候知道一个类的信息呢?

 代码示例:

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import javax.swing.JOptionPane;

/**

  *本类用于测试反射API,利用用户输入类的全路径,

*找到该类所有的成员方法和成员属性

  */

public class MyTest {

 

    /**

     *构造方法

     */

    public MyTest(){

      

       String classInfo=JOptionPane.showInputDialog(null,"输入类全路径");//要求用户输入类的全路径

      

       try {

           Class cla=Class.forName(classInfo);//根据类的全路径进行类加载,返回该类的Class对象

          

           Method[] method=cla.getDeclaredMethods();//利用得到的Class对象的自审,返回方法对象集合

          

           for(Method me:method){//遍历该类方法的集合

              System.out.println(me.toString());//打印方法信息

           }

          

           System.out.println("********");

          

           Field[] field=cla.getDeclaredFields();//利用得到的Class对象的自审,返回属性对象集合

           for(Field me:field){ //遍历该类属性的集合

              System.out.println(me.toString());//打印属性信息

           }

       } catch (ClassNotFoundException e) {

           e.printStackTrace();

       }

    }

    public static void main(String[] args) {

       new MyTest();

    }

}

运行的时候,我们输入javax.swing.JFrame,那么运行结果如下:

 public void javax.swing.JFrame.remove(java.awt.Component)

public void javax.swing.JFrame.update(java.awt.Graphics)

…………

 

********

public static final int javax.swing.JFrame.EXIT_ON_CLOSE

private int javax.swing.JFrame.defaultCloSEOperation

 …………

     大家可以发现,类的全路径是在程序运行的时候,由用户输入的。所以虚拟机事先并不知道所要加载类的信息,这就是利用反射机制来对用户输入的类全路径来对类自身的一个自审。从而探知该类所拥有的方法和属性。

 通过上面代码,大家可以知道编译工具为什么能够一按点就能列出用户当前对象的属性和方法了。它是先获得用户输入对象的字符串,然后利用反射原理来对这样的类进行自审,从而列出该类的方法和属性。

使用反射机制的步骤:

u导入java.lang.relfect 

u遵循三个步骤
第一步是获得你想操作的类的 java.lang.Class 对象
第二步是调用诸如 getDeclaredMethods 的方法
第三步使用 反射API 来操作这些信息

 获得Class对象的方法

 u如果一个类的实例已经得到,你可以使用

       Class c = 对象名.getClass(); 

      例: TextField t = new TextField();

              Class c = t.getClass();

              Class s = c.getSuperclass();

u如果你在编译期知道类的名字,你可以使用如下的方法

Class c = java.awt.Button.class; 
或者

         Class c = Integer.TYPE;

u如果类名在编译期不知道但是在运行期可以获得你可以使用下面的方法

          Class c = Class.forName(strg);

package

public class MyTest {

    public static void main(String[] args) {

       TestOne  one=null;

       try{

       Class  cla=Class.forName("com.TestOne");//进行com.TestOne类加载,返回一个Class对象

       System.out.println("********");

       one=(TestOne)cla.newInstance();//产生这个Class类对象的一个实例,调用该类无参的构造方法,作用等同于new TestOne()

       }catch(Exception e){

           e.printStackTrace();

       }

       TestOne two=new TestOne();

  System.out.println(one.getClass() == two.getClass());//比较两个TestOne对象的Class对象是否是同一个对象,在这里结果是true。说明如果两个对象的类型相同,那么它们会有相同的Class对象

    }

}

class TestOne{

    static{

       System.out.println("静态代码块运行");

    }

    TestOne(){

       System.out.println("构造方法");

    }

}

静态代码块运行

***********

构造方法

构造方法

Class.forName("com.TestOne")的时候,实际上是对com.TestOne进行类加载,这时候,会把静态属性、方法以及静态代码块都加载到内存中。所以这时候会打印出"静态代码块运行"。但这时候,对象却还没有产生。所以"构造方法"这几个字不会打印。当执行cla.newInstance()的时候,就是利用反射机制将Class对象生成一个该类的一个实例。这时候对象就产生了。所以打印"构造方法"。当执行到TestOne two=new TestOne()语句时,又生成了一个对象。但这时候类已经加载完毕,静态的东西已经加载到内存中,而静态代码块只执行一次,所以不用再去加载类,所以只会打印"构造方法",而"静态代码块运行"不会打印。

 反射机制不但可以例出该类对象所拥有的方法和属性,还可以获得该类的构造方法及通过构造方法获得实例。也可以动态的调用这个实例的成员方法。

 代码示例:

 

package reflect;

import java.lang.reflect.Constructor;

/**

 *

 * 本类测试反射获得类的构造器对象,

 * 并通过类构造器对象生成该类的实例

 *

 */

public class ConstructorTest {

     public static void main(String[] args) {

       try {

           //获得指定字符串类对象

           Class cla=Class.forName("reflect.Tests");

           //设置Class对象数组,用于指定构造方法类型

           Class[] cl=new Class[]{int.class,int.class};

           //获得Constructor构造器对象。并指定构造方法类型

           Constructor con=cla.getConstructor(cl);

          //给传入参数赋初值

           Object[] x={new Integer(33),new Integer(67)};

           //得到实例

           Object obj=con.newInstance(x);

       } catch (Exception e) {

           e.printStackTrace();

       }

    }

}

class Tests{

    public Tests(int x,int y){

       System.out.println(x+"    "+y);

    }

}

运行的结果是” 33    67。说明我们已经生成了Tests这个类的一个对象。

同样,也可以通过反射模式,来执行Java类的方法

代码示例:

package reflect;

import java.lang.reflect.Method;

/**

 *

 * 本类测试反射获得类的方法对象,

 * 并通过类对象和类方法对象,运行该方法

 *

 */

public class MethodTest {

    public static void main(String[] args) {

       try {

           //获得窗体类的Class对象

           Class cla=Class.forName("javax.swing.JFrame");

           //生成窗体类的实例

           Object obj=cla.newInstance();

       //获得窗体类的setSize方法对象,并指定该方法参数类型为int,int

           Method methodSize=cla.getMethod("setSize"new Class[]{int.class,int.class});

           /*

            * 执行setSize()方法,并传入一个Object[]数组对象,

            * 作为该方法参数,等同于  窗体对象.setSize(300,300);

            */

           methodSize.invoke(obj, new Object[]{new Integer(300),new Integer(300)});

       //获得窗体类的setSize方法对象,并指定该方法参数类型为boolean

           Method methodVisible=cla.getMethod("setVisible"new Class[]{boolean.class});

           /*

            * 执行setVisible()方法,并传入一个Object[]数组对象,              *作为该方法参数。 等同于  窗体对象.setVisible(true);

            */

           methodVisible.invoke(obj, new Object[]{new Boolean(true)});

       } catch (Exception e) {

           e.printStackTrace();

       }

    }

}

反射技术大量用于Java设计模式和框架技术,最常见的设计模式就是工厂模式(Factory)和单例模式(Singleton)

单例模式(Singleton)

       这个模式主要作用是保证在Java应用程序中,一个类Class只有一个实例存在。在很多操作中,比如建立目录 数据库连接都需要这样的单线程操作。这样做就是为了节省内存空间,保证我们所访问到的都是同一个对象。

       单例模式要求保证唯一,那么怎么样才能保证唯一性呢?对了,这就是静态变量。单例模式有以下两种形式:

第一种形式:

package reflect;

public class Singleton {

    /*

     * 注意这是private私有的构造方法, 只供内部调用

     * 外部不能通过new的方式来生成该类的实例

     */

    private Singleton() {

    }

    /*

     * 在自己内部定义自己一个实例,是不是很奇怪?

     * 定义一个静态的实例,保证其唯一性

     */

    private static Singleton instance = new Singleton();

    // 这里提供了一个供外部访问本class的静态方法,可以直接访问

    public static Singleton getInstance() {

           return instance;

    }

}

/**

 *测试单例模式

 */

class SingRun{

    public static void main(String[] args){

       //这样的调用不被允许,因为构造方法是私有的。

       //Singleton x=new Singleton();

       //得到一个Singleton类实例

       Singleton x=Singleton.getInstance();

       //得到另一个Singleton类实例

       Singleton y=Singleton.getInstance();

       //比较x和y的地址,结果为true。说明两次获得的是同一个对象

       System.out.println(x==y);

    }

}

第二种形式:

public class Singleton {

    //先申明该类静态对象

    private static Singleton instance = null;

    //创建一个静态访问器,获得该类实例。加上同步,表示防止两个线程同时进行对象的创建

    public static synchronized Singleton getInstance() {

       //如果为空,则生成一个该类实例

       if (instance == null){

           instance = new Singleton();

       }

       return instance;

    }

}

工厂模式(Factory

        工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式,工厂模式在Java程序系统可以说是随处可见。

为什么工厂模式是如此常用?是因为工厂模式利用Java反射机制和Java多态的特性可以让我们的程序更加具有灵活性。用工厂模式进行大型项目的开发,可以很好的进行项目并行开发。就是一个程序员和另一个程序员可以同时去书写代码,而不是一个程序员等到另一个程序员写完以后再去书写代码。其中的粘合剂就是接口和配置文件。

之前说利用接口可以将调用和实现相分离。

那么这是怎么样去实现的呢?工厂模式可以为我们解答。

 我们先来回顾一下软件的生命周期,分析、设计、编码、调试与测试。其中分析就是指需求分析,就是知道这个软件要做成什么样子,要实现什么样的功能。功能知道了,这时就要设计了。设计的时候要考虑到怎么样高效的实现这个项目,如果让一个项目团队并行开发。这时候,通常先设计接口,把接口给实现接口的程序员和调用接口的程序员,在编码的时候,两个程序员可以互不影响的实现相应的功能,最后通过配置文件进行整合。

代码示例:

/**

 *

 *定义接口

 */

interface InterfaceTest{

    public void getName();//定义获得名字的方法

}

接口有了,那么得到这个接口,进行实现编码的程序员应该怎么做呢?对了,实现这个接口,重写其中定义的方法

 接口实现方:

/**

 *第一个程序员书写的,实现这个接口的类

 */

class Test1 implements InterfaceTest{

    /*

     * 根据业务,重写方法

     */

    public void getName() {

       System.out.println("test1");

    }

}

/**

 *第二个程序员书写的,实现这个接口的类

 */

class Test2 implements InterfaceTest{

    /*

     * 根据业务,重写方法

     */

    public void getName() {

       System.out.println("test2");

    }

}

大家可以发现,当接口定义好了以后,不但可以规范代码,而且可以让程序员有条不紊的进行功能的实现。实现接口的程序员根本不用去管,这个类要被谁去调用。

 那么怎么能获得这些程序员定义的对象呢?在工厂模式里,单独定义一个工厂类来实现对象的生产,注意这里返回的接口对象。

 工厂类,生产接口对象:

/**

 * 本类为工厂类,用于生成接口对象

 */

class Factory{

    //创建私有的静态的Properties对象

    private static Properties pro=new Properties();

    //静态代码块

    static{

       try {

           //加载配置文件

           pro.load(new FileInputStream("file.txt"));

       } catch (Exception e) {

           e.printStackTrace();

       }

    }

    /**

     * 单例模式,保证该类只有一个对象

     */

    private static Factory factory=new Factory();

    private Factory(){}

    public static Factory getFactory(){

       return factory;

    }

    /**

     * 本方法为公有方法,用于生产接口对象

     * @return InterfaceTest接口对象

     */

    public  InterfaceTest getInterface(){

       InterfaceTest interfaceTest=null;//定义接口对象

       try {

           //根据键,获得值,这里的值是类的全路径

           String classInfo=pro.getProperty("test");

           //利用反射,生成Class对象

           Class c=Class.forName(classInfo);

           //获得该Class对象的实例

           Object obj=c.newInstance();

           //将Object对象强转为接口对象

           interfaceTest=(InterfaceTest)obj;

       } catch (Exception e) {

           e.printStackTrace();

       }

       //返回接口对象

       return interfaceTest;

    }

}

配置文件内容:

test=factory.Test2

通过这个类,大家可以发现,在调用的时候,得到的是个接口对象。而一个接口变量可以指向实现了这个接口的类对象。在利用反射的时候,我们并没有直接把类的全路径写出来,而是通过键获得值。这样的话,就有很大的灵活性,只要改变配置文件里的内容,就可以改变我们调用的接口实现类,而代码不需做任何改变。在调用的时候,我们也是通过接口调用,甚至我们可以连这个接口实现类的名字都不知道。

调用方:

public class FactoryTest {

    public static void main(String[] args) {

       //获得工厂类的实例

       Factory factory=Factory.getFactory();

       //调用获得接口对象的方法,获得接口对象

       InterfaceTest inter=factory.getInterface();

       //调用接口定义的方法

       inter.getName();

    }

}

 上面的代码就是调用方法。大家可以发现,在调用的时候,我们根本没有管这个接口定义的方法要怎么样去实现它,我们只知道这个接口定义这个方法起什么作用就行了。上面代码运行结果要根据配置文件来定。如果配置文件里的内容是test=factory.Test2。那么表示调用factory.Test2这个类里实现接口的方法,这时候打印“test2”。如果配置文件里的内容是test=factory.Test1。那么表示调用factory.Test1这个类里实现接口的方法,这时候打印“test1”。

 

反射机制是框架技术的原理和核心部分。通过反射机制我们可以动态的通过改变配置文件(以后是XML文件)的方式来加载类、调用类方法,以及使用类属性。这样的话,对于编码和维护带来相当大的便利。在程序进行改动的时候,也只会改动相应的功能就行了,调用的方法是不用改的。更不会一改就改全身。

如对本文有疑问,请提交到交流论坛,广大热心网友会为你解答!! 点击进入论坛


发表评论 (554人查看0条评论)
请自觉遵守互联网相关的政策法规,严禁发布色情、暴力、反动的言论。
用户名: 验证码: 点击我更换图片
最新评论
------分隔线----------------------------