Java的反射机制，动态加载类（一）

时间 2019-11-07

标签 java 反射机制动态加载栏目 Java 繁體版

原文原文链接

那么什么是Java的反射呢？java

你们都知道，要让Java程序可以运行，那么就得让Java类要被Java虚拟机加载。Java类若是不被Java虚拟机加载，是不能正常运行的。如今咱们运行的全部的程序都是在编译期的时候就已经知道了你所须要的那个类的已经被加载了。程序员

Java的反射机制是在编译并不肯定是哪一个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特色就是反射。数据库

那么Java反射有什么做用呢？设计模式

假如咱们有两个程序员，一个程序员在写程序的时候，须要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码可否经过编译呢？这是不能经过编译的。利用Java反射的机制，就可让第一个程序员在没有获得第二个程序员所写的类的时候，来完成自身代码的编译。数组

Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，咱们称为Java类的“自审”。你们都用过Jcreator和eclipse。当咱们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象可以使用的全部的方法和属性所有都列出来，供用户进行选择。这就是利用了Java反射的原理，是对咱们建立对象的探知、自审。框架

Class类eclipse

要正确使用Java反射机制就得使用java.lang.Class这个类。它是Java反射机制的起源。当一个类被加载之后，Java虚拟机就会自动产生一个Class对象。经过这个Class对象咱们就能得到加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。工具

反射API性能

u反射API用于反应在当前Java虚拟机中的类、接口或者对象信息测试

u功能
—获取一个对象的类信息.

—获取一个类的访问修饰符、成员、方法、构造方法以及超类的信息.

—检获属于一个接口的常量和方法声明.

—建立一个直到程序运行期间才知道名字的类的实例.

—获取并设置一个对象的成员，甚至这个成员的名字是
在程序运行期间才知道.

—检测一个在运行期间才知道名字的对象的方法

利用Java反射机制咱们能够很灵活的对已经加载到Java虚拟机当中的类信息进行检测。固然这种检测在对运行的性能上会有些减弱，因此何时使用反射，就要靠业务的需求、大小，以及经验的积累来决定。

那么如何利用反射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();
   }
}

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

使用反射机制的步骤：

导入java.lang.relfect 包

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

得到Class对象的方法

若是一个类的实例已经获得，你可使用

【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);

例子一：

public class TestOne {
   static{
       System.out.println("静态代码块运行");
   }
   TestOne(){
       System.out.println("构造方法");
   }

   public static void main(String[]args) throws ClassNotFoundException, InstantiationException, IllegalAccessException{
       Class class1=Class.forName("reflect.TestOne");//输出：静态代码块运行
       /*其实是对com.TestOne进行类加载，这时候，会把静态属性、方法以及静态代码块都加载到内存中。因此这时候会打印出"静态代码块运行"。
       但这时候，对象却尚未产生。因此"构造方法"这几个字不会打印。当执行cla.newInstance()的时候，就是利用反射机制将Class对象生成一个该类的一个实例。
       */
       Object object=class1.newInstance();//输出：构造方法
       //当执行cla.newInstance()的时候，就是利用反射机制将Class对象生成一个该类的一个实例。这时候对象就产生了。因此打印"构造方法"。
       TestOne two=new TestOne();//输出：构造方法
       //当执行到TestOne two=new TestOne()语句时，又生成了一个对象。但这时候类已经加载完毕，静态的东西已经加载到内存中，而静态代码块只执行一次，因此不用再去加载类，因此只会打印"构造方法"，而"静态代码块运行"不会打印。
       //反射机制不但能够例出该类对象所拥有的方法和属性，还能够得到该类的构造方法及经过构造方法得到实例。也能够动态的调用这个实例的成员方法。
   }

}

反射机制不但能够例出该类对象所拥有的方法和属性，还能够得到该类的构造方法及经过构造方法得到实例。也能够动态的调用这个实例的成员方法。

例子二：

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);
           /*运行的结果是” 33 67”。说明咱们已经生成了Tests这个类的一个对象。
           一样，也能够经过反射模式，来执行Java类的方法*/

       } catch (Exception e) {
           e.printStackTrace();
       }
   }
}

class Tests{
   public Tests(int x,int y){
       System.out.println(x+" "+y);
   }
}

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

一样，也能够经过反射模式，来执行Java类的方法，构造器能够调用有参数的构造方法。

例子三：

/** * 本类测试反射得到类的方法对象，

* 并经过类对象和类方法对象，运行该方法

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)

/*单例模式(Singleton)
这个模式主要做用是保证在Java应用程序中，一个类Class只有一个实例存在。在不少操做中，好比创建目录数据库链接都须要这样的单线程操做。这样作就是为了节省内存空间，保证咱们所访问到的都是同一个对象。
单例模式要求保证惟一，那么怎么样才能保证惟一性呢？对了，这就是静态变量。单例模式有如下两种形式：
第一种形式：*/
public class SingletonHungry {
   /*注意这是private私有的构造方法，只供内部调用
   * 外部不能经过new的方式来生成该类的实例
   */
   private SingletonHungry() {
   }
   /* 在本身内部定义本身一个实例，是否是很奇怪？
   * 定义一个静态的实例，保证其惟一性
   */
   private static SingletonHungry instance = new SingletonHungry();

   // 这里提供了一个供外部访问本class的静态方法，能够直接访问
   public static SingletonHungry getInstance() {
           return instance;
   }
   public static void main(String[] args){
       //这样的调用不被容许，由于构造方法是私有的。
       //Singleton x=new Singleton();
               //获得一个Singleton类实例
       SingletonHungry x=SingletonHungry.getInstance();

       //获得另外一个Singleton类实例
       SingletonHungry y=SingletonHungry.getInstance();

       //比较x和y的地址，结果为true。说明两次得到的是同一个对象
       System.out.println(x==y);
   }

}

public class SingletonLazy {
   //先申明该类静态对象
   private static volatile SingletonLazy inSingletonLazy=null;

   private SingletonLazy(){}

   //建立一个静态访问器，得到该类实例。加上同步，表示防止两个线程同时进行对象的建立
   public static SingletonLazy getSingletonLazy(){
       if(null==inSingletonLazy){
           synchronized (SingletonLazy.class) {
               if(null==inSingletonLazy){
                   inSingletonLazy=new SingletonLazy();
               }
           }
       }
       return inSingletonLazy;
   }
}

工厂模式（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文件)的方式来加载类、调用类方法，以及使用类属性。这样的话，对于编码和维护带来至关大的便利。在程序进行改动的时候，也只会改动相应的功能就好了，调用的方法是不用改的。更不会一改就改全身。