java反射笔记

1.反射引入与示范：

对于一个配置文件，里面有需要实现的类和方法，传统方法为眼睛抄过来
xx xx = new xx;
xx.xx;
这样子有个弊端，就是一旦配置文件修改，就必须修改这里的源码，非常不好用

然后引出可以使用properties文件引入流

		Properties properties = new Properties();		//新建一个对象
        properties.load(new FileReader("src\\peizhi.properties"));  //把对应文件加载到对象里，首先要加载到流里，再把流加载到对象 
       // 通过键值获取对应信息，返回的是Object，需要用toString转成字符串
        String classfullpath = properties.get("classfullpath").toShring; //得到的是com.hspedu.Cat，也就是类的路径加类名
       String method = properties.get("method").toString();		//通过键值获取对应信息，返回的是object

这样确实，不用再手动抄写了。但是存在个问题，就是get键值得到的数据为字符串，字符串是没法用起来的。因为他只是一个字符串而已。

这里就引入了反射的使用

		//新建properties对象，并且用文件输入流把文件输入到properties对象中
        Properties properties = new Properties();
        properties.load(new FileReader("src\\abc.properties"));
        
        //通过get方法获取键值对应的值，返回的是object类，用同toString转成字符串
        String classfullpath = properties.get("classfullpath").toString();
        String method = properties.get("method").toString();
        
        /返回 这个类的加载类，然后通过加载类的newInstance方法获取这个类的对象
        //返回的是Object的编译类型，但是为具体类的运行类型
        Class cla = Class.forName(classfullpath);
        Object o = cla.newInstance();
        
        //这里Method是反射包提供的类，它的作用是把方法作为了一个对象
        //cla.getMethod是把方法名对应的字符串传进来，就可以得到对应的方法对象了
        ///这里方法的使用，不是常规的对象.方法，而是  方法的对象.invoke(对象)
        Method method1 = cla.getMethod(method);
        method1.invoke(o);

这里先提出一个疑问：
根据动态绑定机制，如果子类想要使用多态的方式新建对象，

Object object = new Cat();

此时，父类是编译类型，子类Cat是运行类型。
那么要调用子类的方法，需要父类也要有子类的此方法名（子类要重写父类的）。

但是在反射这里，加载类加载出来的对象编译类型就是object，怎么直接能用的方法呢？

2.反射机制

1. 反射机制允许程序在执行期借助于reflection API取得任何类的内部信息（比如成员变量，构造器，成员方法等待），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。
2. 加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），**这个对象包含了类的完整结构信息。通过这个对象得到类的结构。**这个对象就像一面镜子，透过这个镜子看到类的结构，所以称之为反射。
3. 这里有个注意的点，就是类在新建对象的时候，就已经有了Class对象。然后我们使用的时候，就是通过 Class.forName(类名);这个静态方法获取对应的类对象而已。
   

3.反射的优缺点

可以通过关闭访问检查的方式来优化：method、field、constructor都有setAccessible方法，他的作用是启动和禁用访问安全检查的开关，参数为true就是不检查。

4.关于Class类

4. Class也是类。因此也继承object
5. Class类对象不是new出来的，而是系统创建的（在加载的时候，创建）
   这时候就有个问题，什么时候加载？显然 Cat cat = new cat()，这样传统方法创建一个对象的时候，会自动把类加载。另一方面，使用反射的方法：Class.forName(”Cat“)，这样也会加载Cat这个类，同时，会返回一个针对Cat的Class对象。Class对象不是new出来的，而是Cat的加载器创建的。那Class这个类什么时候加载的呢？很明显，使用一个类的静态属性与方法的时候，这个类也就加载了。
6. 对于某个类的Class对象，在内存中只有一份，即使使用两次Class.forName(”Cat“)返回给两个名字，那他们也是同一个对象。
7. 每个类的实例都会记得自己是由哪个Class实例生成的。
8. 通过Class可以完整的得到一个类的完整结构，通过一系列API：
   
9. Class对象是存放在堆区的

5.反射基本使用

1. 先生成Class类对象，有三种方法

//通过类名生成Class
// 这种方式需要已知一个类的全类名，多用于已知配置文件，读取全路径名，加载类。

Class cls = forName("java.lang.Cat");

//已知具体的类，通过类的class获取，该方法最为安全可靠，性能最高
//多用于参数传递，比如通过反射得到对应的构造器对象。

Class cls = Cat.class;

//构造器如下：
String.class，就是用的这种方法，我们可以获得一个含参构造器
Constructor constructor = cls.getConstructor(String.class);

//已知某个类的实例，也就是有对象了，那么可以通过getClass方法获得
//一般用于已经创建好的对象

Class cls = 对象.getClass();

//通过类加载器获取
ClassLoader cl = 对象.getClass().getClassLoader();
Class cls = cl.loadClass("java.lang.Cat")

2. 然后用获取的Class对象，生成类的对象（可以分别用有参和无参构造器创建）

//无参构造器
object o = cls.newInstance();

//公有的有参构造器，里面是数据类型的Class对象，我们可以用String.class来获取
//先获取有参构造器对象，再传参数
Constructor constructor = cls.getConstructor(String.class);
Object o = comstructor.newInstance("hsp");

//私有构造器，私有的不能用getConstructor，需要用getDeclaredConsteuctor，返回所有构造器
Constructor constructor = cls.getDeclaredConsteuctor(String.class,int.class);
//使用构造器时候直接用还是不行，因为还是私有的。需要爆破！
constructor.setAccessible(true); //这样是用反射来暴力破解私有（构造器、属性、方法都可以）
//破了以后就和上面一样了，直接newInstance

3. 通过反射使用这个对象的一系列属性和方法，这里，无论是属性还是方法还是构造器，都是当做对象来处理，所以使用要先把这些实例化，分别为Method，Field,Constructor

//方法
Method method = cls.getMethod(字符串类型的方法名)
method.invoke(对象名);	//这里可以使用这个对象的这个方法
method.invoke(对象名,实参列表);	//有参方法如此

//属性
Field field = cls.getField(字符串类型的属性名)
field.get(对象名) 	//这里可以显示这个对象的这个属性

field.set(对象名,属性新值) 		//这里给属性赋值

6.类加载

静态加载：编译过程就加载。Cat cat = new Cat();这样创建对象，那就是静态加载，如果这个类还没有被定义，编译的时候就会报错

动态加载：执行的时候才会加载。反射是动态加载的基础。
也就是说用反射来创建对象，第一步生成Class文件那里，就是加载过程。

加载流程

1. 加载loading：JVM在该阶段主要目的是将字节码从不同的数据源（可能是class文件，也可能是jar包，甚至网络）转化为二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class文件。<总的来说，就是转成二进制放到内存中的方法区，然后生成Class对象放在堆区>
   
2. 验证：目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。包括：文件格式验证，元数据验证，字节码验证符号和符号引用验证。（可以考虑使用-Xverify:none参数关闭大部分的类验证操作，缩短虚拟机加载时间，在项目比较庞大时为了提高性能可以考虑这样做）
3. 准备：JVM会在该阶段堆静态变量分配内存并默认初始化，可以理解为，静态变量的产生分为两个阶段，第一个阶段是申请空间赋一个默认值（不同数据类型默认值不同，有0，0L，null，false）。第二个阶段是把真正的值赋给他，准备就是第一个阶段，而后边的初始化是第二个阶段。
   这里注意：对于成员变量，属于实例变量，只有有对象的时候才产生。静态变量需要在准备阶段申请空间并赋给默认值。而static final ，属于常量，在准备阶段就会赋给真实值，一步到位。
4. 解析：符号引用变成直接引用的过程。
5. 初始化：到初始化阶段，才真正执行java中的定义代码，此阶段是执行下面这个方法的过程。

<clinit>()

这个方法是由编译器按语句在源文件中出现的顺序，依此自动收集类中所有静态变量的赋值动作和静态代码块中的语句，并进行合并操作。
同时，虚拟机会保证一个类的这个方法在多线程的环境中被正确的加锁、同步，如果多个线程同时初始化一个类，那么只有一个线程去执行这个类的这个方法，其他都会阻塞，直到执行完毕。

7.一些常用API（详情可以看jdk文档）

对于一些返回集合的，就直接增强for就行
1.java.lang.Class类

2. java.lang.reflect.Field

3. java.lang.reflect.Method

4. java.lang.reflect.Constructor

8.暴力破解

构造器、方法、属性，如果是私有的
首先获取的时候，要加declared

Field name = cls.getDeclaredField("name");

然后破解一下

name.setAccessible(true);

然后直接用

name.get(o);
name.set(o,"老刘")
name.get(null)	//静态的可以直接用null，因为跟对象无关。set也如此