java的反射机制

Posted 2020-12-01 laurarararararara

反射：将类的各个组成部分封装为其他对象，这就是反射机制

好处：1.在程序运行中，这些对象

2.可以解耦，提高程序的可扩展性

 

在Java开发特别是数据库开发中，经常会用到Class.forName( )这个方法。通过查询Java Documentation我们会发现使用Class.forName( )静态方法的目的是为了动态加载类。在加载完成后，一般还要调用Class下的newInstance( )静态方法来实例化对象以便操作。因此，单单使用Class.forName( )是动态加载类是没有用的，其最终目的是为了实例化对象。

这里有必要提一下就是Class下的newInstance()和new有什么区别？，首先，newInstance( )是一个方法，而new是一个关键字，其次，Class下的newInstance()的使用有局限，因为它生成对象只能调用无参的构造函数，而使用new关键字生成对象没有这个限制。

newInstance方法：通过反射生成Student对象，

Class c=Class.forName("com.Student");             

Student s1=(Student)c.newInstance();//调用默认的无参构造函数

 

//想调用三个参数的构造

Constructor con=c.getConstructor(String.class,int.class,String.class);  //用Consructor接收，参数指定类型的Class对象
con.newInstance("lauraa",20,"women");
（与这样的操作相同： Student s=new Student("lauraa",20,"women");

通过反射生成对象：
重写toString方法后，可打印  Student{name=\'lauraa\', age=20, sex=\'women\'}

Class c2=Class.forName("com.load.Student");//包路径

Student s1=(Student)c2.newInstance();

Constructor con=c2.getConstructor(String.class,int.class,String.class); //想调用三个参数的构造，参数为类型.class

Student stu=(Student)con.newInstance("lauraa",20,"women"); //后面的newInstance是Object类型，所以强转为Student类型；传入参数的值用stu接收
System.out.println(stu);

当一个类的构造函数被私有化，不能new对象访问该类。可以通过反射访问

 

 通过反射访问构造函数：

1.获取Class对象（Class类的c变量里面包含该类的全部信息）

2.c.getDeclaredConstructor()调用该类所有的构造函数用Constructor类的c4接收(

getMethod（）：获取自身能用所有的公共方法       

getDeclaredMethod（）：获取类自身声明的所有方法。)

 

3.设置c4是可访问的

4.再调用newInstance()函数传入构造函数的参数,可以填null或不填

        //Test t=new Test();//私有构造函数，不能new
        Class c=Test.class;
        //c.newInstance(); //运行异常
        Class com.load.ClassLoadTest can not access a member of class com.load.Test with modifiers "private"
        Constructor c4=c.getDeclaredConstructor();//打印构造函数
        //若想调用带参数的构造函数，在getDeclaredConstructor()里面加入int.class,在下面的newInstance方法里面传值
        c4.setAccessible(true);
        c4.newInstance();

       class Test{
        private Test(){
        System.out.println("测试类的私有构造");
          }
        private Test(int a){
        int b=a;
        System.out.println("b:"+b);
        }
   }

 访问带参数的构造和默认的构造实例：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

class Student {
    private String name;
    private int age;
    private String sex;

    private Student(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("66");
    }
    private Student(){
        System.out.println("Student()");
    }

    public static void main(String[] args)throws Exception {

    }
}
class A{
    public static void main(String[] args)throws Exception {
        Class c1=null;
        c1=Student.class;//获取类的Class对象
        Constructor con=c1.getDeclaredConstructor();//得到该类的默认构造函数，若传入参数，访问带参数的构造函数
        con.setAccessible(true);
        con.newInstance();//可以访问别的类默认的私有构造函数(构造函数私有化的时候不能new)

        Constructor con1=c1.getDeclaredConstructor(String.class,int.class,String.class);//得到该类的默认构造函数
         若传入参数，访问带参数的构造函数
        con1.setAccessible(true);
        con1.newInstance("aa",20,"male");//在上面得到参数类型时，newInstance应该传入对应类型的参数
    }
}

另一个例子：2020/1/20完善

 

 获取带参数和不带参数的私有方法、获取和设置私有成员变量的值：

 

 注：测试通过反射获取私有的方法和设置获得私有变量时，必须要获取该对象；所以只能将获取类中的构造函数设置成私有的，才能通过new得到该对象，才能调用invoke函数和seet函数来得到该方法与设置该值。

补充：getName方法，获取类或者方法或者成员变量的名字：

如c.getName( )  :包名.类名（Class c=Class.forName("TestCase01");）            con.getName( ):构造函数的名字    m.getName( ):方法的名字  f.getName( ):成员变量的名字

 完整测试类：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 2020/2/20改进
 */
public class TestCase01 {
    private int ma = 10;
    private TestCase01() {
        System.out.println("构造函数");
    }
    private TestCase01(int m) {
        this.ma=m;
        System.out.println(ma);
    }
}

 class TestCase02 {
    private int mam = 10;
    public TestCase02() {
        System.out.println("构造函数2");
    }
    private void show() {
        System.out.println("mam:" + mam);
    }
     private void show(String b) {
         System.out.println("mam:" + mam+" b:"+b);
     }
}

class Test {
    public static void main(String[] args) throws Exception {
            Class c=Class.forName("TestCase01");
            //1.调用无参的构造函数
            Constructor con=c.getDeclaredConstructor();
            con.setAccessible(true);
            con.newInstance();//创建对象10
            //2.调用有参的构造函数
            Constructor con2=c.getDeclaredConstructor(int.class);
            con2.setAccessible(true);
            con2.newInstance(40);//创建对象

            //当构造函数不private时，new对象反射私有成员变量和私有方法
            TestCase02 t2=new TestCase02();
            Class c2=t2.getClass();
            /**
             * 1.先获取私有方法
             * getDeclaredMethod("show", null); 方法名"show",参数列表show
             * invoke(t2, null);对象t2,参数方法
             */
            Method m = c2.getDeclaredMethod("show", null);
            m.setAccessible(true);
            m.invoke(t2, null);
            //获取带参数的私有方法
            Method m2 = c2.getDeclaredMethod("show", String.class);
            m2.setAccessible(true);
            m2.invoke(t2, "6");//mam:10 b:6
            /**
             * 2.设置私有成员变量的值
             * f1.set(t2, 20);//设置t2对象私有成员变量的值为20
             */
            Field f1 = c2.getDeclaredField("mam");
            f1.setAccessible(true);
            System.out.println("打印当前属性的值："+f1.get(t2));
            f1.set(t2, 20);
            //3.再次打印该方法，得到获取后的值
            Method m3 = c2.getDeclaredMethod("show", null);
            m3.setAccessible(true);
            m3.invoke(t2, null);
        }
    }

 

 

 反射的不足：但是，通过反射任意访问对象的私有成员并改变成员变量的值，类得不到保护

public class ClassLoadTest {
    public static void main(String[] args) throws Exception
//访问私有方法

 Test t1=new Test();
 Method m=c.getDeclaredMethod("show",null);
 m.setAccessible(true);
 m.invoke(t1,null);
 //访问私有成员变量并改变值
 Field f=c.getDeclaredField("ma");//参数为String类型，所以""双引号变量
 f.setAccessible(true);
 f.set(t1,8);   //将属性值设为8
 m.invoke(t1,null); //再次调用show方法打印私有属性ma的值
  }
}

class Test{
    private int ma = 10;
    public Test(){
        System.out.println("测试类的私有构造");
    }
    private void show(){
        System.out.println("ma:" + ma);
    }
}

 

 •案例需求：2020/1/20

写一个框架，在不改变框架类代码的前提下，可以创建任意类的对象，并且可以执行其中的方法

实现该需求：1.配置文件  2.反射机制

步骤：1.将需要创建的对象的类名与方法定义在配置文件中

2.在程序中加载并读取配置文件

3.使用反射技术加载类文件进入内存

4.创建对象

5.执行方法

创建配置文件的方法：src下-New -File

具体代码：

package test;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;

public class ReflectTest {
    public static void main(String[] args) throws Exception {
        //提供一个模板（写一个框架类），可以创建任意类的对象，但是不能改变该类的对象的代码，但是不能改变框架的代码
        //1.加载配置文件  1)创建pro对象  2).加载配置文件，转换为一个集合(  (1)获取class目录下的配置文件  (2)将配置文件用load方法加载进去)
        Properties pro=new Properties();
        ClassLoader classLoader=ReflectTest.class.getClassLoader();//将ReflectTest类加载进内存
        InputStream is= classLoader.getResourceAsStream("pro.properties");//获取资源对应的字节流InputStream类型，将配置文件传进去
        pro.load(is);//需要抛异常

        //2.获取配置文件中定义的数据
        String className=pro.getProperty("className");
        String methodName=pro.getProperty("methodName");

        //3.加载该类进内存
        Class cls=Class.forName(className);
        //4.创建对象
        Object obj= cls.newInstance();
        //5.获取方法对象
        Method method=cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
    }
}

配置文件：  className=包名.类名

 

 

 出现的错误及处理：

错误原因：InstantiationEcxeption 实例化异常              原因：创建的类没有无参构造

 

 在Person类添加无参构造之后：

也可以同时加载两个类或者两个方法（方法要求public),只需要在配置文件添加methodName2=person(方法名) 即可：

 

 注：访问私有的方法但是设置权限之后，会出现NoSuchMethodsException异常，不明所以？？

改配置文件的好处：改代码工程庞大，需要重新测试等；该配置文件使程序扩展性更强，更简单（使用到了反射机制）！

 

 

 

 总结：反射的步骤

         * 通过Java的反射访问类的成员或者是构造对象（访问构造函数），步骤是：
         * 1. 先获取类的Class对象
         * 2. 构造函数类Constructor，方法类Method， 属性类Field
                通过Class的getDeclaredConstructor，getDeclaredMethod,  getDeclaredField三个方法，分别获取三个对象
         * 3. 如果方法是private的，需要调用反射对象的setAccessible设置访问权限
         * 4. 访问相应的成员
         *    newInstance - 构造对象
         *    invoke - 成员方法调用
         *    set - 成员变量设置  get-获取成员变量的值

解释java的反射：       

         *  Java之所以支持反射，是因为java的每一个类，都有一个Class对象，
         *  通过Class对象可以获取这个类的构造方法，成员方法，成员变量，通过 反射的方式进行调用或者修改，而不是通常的通过对象调用相应的成员进行访问，反               射提供了setAccessible方法，可以通过返回访问对象任意的成员
         *  反射涉及的类，都在java.lang.reflect包下面，分别是import java.lang.reflect.Field;    import java.lang.reflect.Method;