关于java:反射及暴力反射

反射及暴力反射

反射

一、概述

(1)反射的定位是很重要的,JVM和底层框架都离不开反射
(2)反射的原理是拿到你的class文件里的数据,进行数据的操作(CURD)
(3)反射提供了丰盛的办法,来操作类里的各种数据(属性/办法/结构)
(4)REflection(反射)是Java程序开发语言的特色之一,它容许运行中的Java程序对本身进行查看,或者说”自审”,也有称作”自省”。
反射十分弱小，它甚至能间接操作程序的公有属性，private的只能类外部拜访，内部是不行的，但这个规定被反射赤裸裸的突破了。

为什么须要反射？

有一个类,我想要拜访这个类中的成员变、构造方法和成员办法，失常状况下，咱们拿到的是这个类的.java文件,那么我间接通过new关键字创立一个类的实例对象,而后通过这个实例对象就能够拜访这个类的成员变量、构造方法、成员办法。然而当初我没有这个类的.java文件，而是只能拿到了这个类的.class文件，那么如何去拜访到这个类中的成员变量、构造方法和成员办法？这就是反射机制解决的问题。
在开发的世界里，spring就是业余的组织它能帮咱们创建对象，治理对象，咱们不在new对象，而间接从spring提供的容器中beans获取即可，Beans底层其实就是一个Map<String,Object>,最终通过getBean(“user”)来获取,而这其中最外围的实现就是利用反射技术。
总结：应用反射能够赋予jvm动静编译的能力，否则类的元数据信息只能用动态编译的形式实现。Java反射是Java被视为动静(或准动静)语言的一个要害性质。

二、Class对象

Class对象封装了.class文件里的所有数据,并提供了很多办法来操作数据

1、概述

(1)Class类的实例示意正在运行的Java应用程序中的类和接口。
(2)枚举是一品种，正文是一种接口，每个数组属于被映射为Class对象的一个类，所有具备雷同元素类型和维数的数组都共享该Class对象。
(3)根本的Java类型(boolean、byte、char、short、int、long、float和double)和关键字void也示意为Class对象。

2、获取Class类对象的三种形式

(1)static Class<?>forName(String className)—返回与带有给定字符串名的类或接口相关联的Class对象
(2)类名.class
(3)对象.getClass()
留神:同一个字节码文件(.class)在同一个程序当中只会被加载一次,不管用哪一种。每一个类对应一个字节码文件(.class)

3、.java文件的执行流程

4、罕用办法及测试

(1)创立Student类

package cn.tedu.reflection;
//测试 反射
public class Student {
 public String name = "皮皮霞";
 public int age = 22 ;
    //提供构造方法-右键-generate...constructor...
    public Student() {
    }
    public Student(String name) {
        this.name = name;
    }
    public Student(int age) {
        this.age = age;
    }
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
`public void show(){
        System.out.println("show()...");
    }
    public void test(String n){
        System.out.println("test()..."+n);
    }
    //为了能查看属性值,而不是地址值,提供重写的toString()
    //右键-generate...toString()-ok
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}`

(2)创立测试类

package cn.tedu.reflection;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;
//测试 反射
public class Test1_Reflect {
    public static void main(String[] args) throws Exception {
        //method();//通过反射的技术,获取Class对象
//        method2();//通过反射的技术,获取类中的所有构造方法
//        method3();//通过反射的技术,获取成员办法
//        method4();//通过反射的技术,获取成员变量
        method5();//通过反射的技术,创立实例
    }
    //通过反射的技术,创立实例
    private static void method5() throws Exception {
        //1,获取Class对象
        Class<Student> clazz = Student.class;
        //2,创立实例
        //newInstance()--会触发构造方法--触发无参结构
        Student s = clazz.newInstance();
        //s = Student{name='皮皮霞', age=22}
        System.out.println("s = " + s);

        //3,需要:能够触发含参结构吗?能够-然而你得指定想要触发哪个含参结构
        // --参数是class对象类型,和含参结构的参数类型匹配
        //public Student(String name){} -- new Student("jack");
        Constructor<Student> c = clazz.getConstructor(String.class);
        Student s2 = c.newInstance("jack");
        //s2 = Student{name='jack', age=22}
        System.out.println("s2 = " + s2);
    }
    //通过反射的技术,获取成员变量
    private static void method4() throws ClassNotFoundException {
        //1,获取Class对象
        Class<?> clazz = Class.forName("cn.tedu.reflection.Student");
        //2,获取成员变量--!!!!只能获取public的!!!!
        Field[] fs = clazz.getFields();
        //3,遍历数组,获取每个Field
        for (Field f : fs) {
            //获取变量名
            System.out.println( f.getName() );
            //获取变量类型
            System.out.println( f.getType().getName() );
        }
    }
    //通过反射的技术,获取成员办法
    private static void method3() {
        //1,获取Class对象
        Class clazz = Student.class;
        //2,获取成员办法们
        Method[] ms = clazz.getMethods();
        //3,遍历数组,获取每个Method
        for (Method m : ms) {
            //获取办法名
            System.out.println(m.getName());
            //获取办法参数
            Class<?>[] cs = m.getParameterTypes();
            System.out.println( Arrays.toString(cs) );
        }
    }
    //通过反射的技术,获取类中的构造方法
    private static void method2() {
        //1,获取Class对象
        Class<Student> clazz = Student.class;
        //2,获取构造方法们
        Constructor<?>[] cs = clazz.getConstructors();
        //3,foreach循环获取每个构造方法
        for (Constructor<?> c : cs) {
            //获取构造方法名
            System.out.println(c.getName());
            //获取构造方法的参数
            Class<?>[] cs2 = c.getParameterTypes();
            System.out.println(Arrays.toString(cs2));
        }
    }
    //通过反射的技术,获取Class对象//三种形式
    private static void method() throws ClassNotFoundException {
//        -- static Class<?> forName(String className)--参数是类的全门路
        Class<?> clazz = Class.forName("java.lang.Object");
//        -- 类名.class
        Class<String> clazz2 = String.class;
//        -- 对象.getClass()--泛型下限,最大是String类型,束缚了元素的类型<=String类型
        Class<? extends String> clazz3 = new String().getClass();

        System.out.println("clazz = " + clazz);
        System.out.println("clazz2 = " + clazz2);
        System.out.println("clazz3 = " + clazz3);
    }
}

暴力反射

1、概述

暴力的获取类中的公有资源顺便获取公开的。
暴力反射和一般反射的反射原理是一样的，都是拿到.class文件中的所有数据并封装成Class对象,通过各种办法来操作数据,只不过是换了一套API

2、罕用办法

–getFields()获取成员变量!只能获取public的!!!!
–getFirld()
–getMenthods()获取成员办法们
–getMenthod()
–getConstructors()获取构造方法们
–以上的办法,都能够获取类里的资源,只不过要求这些资源都是public的
–以下的办法,都能够实现暴力反射
–getDeclaredFields()
–getDeclaredField()
–getDeclaredMethods()
–getDeclaredMethod()
–getDeclaredConstructors()
–getDeclaredConstruction()

3、测试

(1)创立Person类

package cn.tedu.reflection;
//测试 暴力反射
public class Person {
    public String name ;
    private int age ;
    //提供结构--右键-generate...
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    private Person(int age) {
        this.age = age;
    }
    private Person(String name) {
        this.name = name;
    }

    public void show(int a){
       System.out.println("show()..."+a);
    }
    private void test(String n){
        System.out.println("test()..."+n);
    }
    //为了查看属性值,重写的toString()--右键-generate...
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

(2)创立测试类

package cn.tedu.reflection;

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

//测试 暴力反射
//外围:用对API(getDeclaredXxx())  +  设置拜访权限(setAccessible())
public class Test2_BaoliReflect {
    public static void main(String[] args) throws Exception {
    //        method();//暴力反射成员变量
        method2();//暴力反射成员办法
    }
    //暴力反射成员办法
    private static void method2() throws Exception {
        //1,反射Class对象
        Class<Person> clazz = Person.class;
        //2,反射成员办法们~~
        Method[] ms = clazz.getDeclaredMethods();
        //3,遍历
        for (Method m : ms) {
            //获取办法名
            System.out.println( m.getName() );
        }
        //4,执行指定的办法
     //getDeclaredMethod(m,n)-m是办法名-n是办法的参数类型的 Class对象
        Method m = clazz.getDeclaredMethod("test", String.class);
        //!!!!!6，设置拜访权限!!!!!!
        m.setAccessible(true);
        //5,执行办法--invoke(m,n)--m是哪个对象--n是具体的办法须要的参数
        Object obj = clazz.newInstance();
        m.invoke(obj,"hellotest");
    }
    //暴力反射成员变量
    private static void method() throws Exception {
        //1,反射Class对象
        Class<Person> clazz = Person.class;
        //2,反射成员变量们~~
        Field[] fs = clazz.getDeclaredFields();
        //3,遍历
        for (Field f : fs) {
            //获取变量名
            System.out.println(f.getName());
            //获取变量类型
            System.out.println(f.getType().getName());
        }
        //4,获取指定的属性
        Field f = clazz.getDeclaredField("age");
        //!!7,设置拜访权限,否则IllegalAccessException
        f.setAccessible(true);
        //5,设置属性的值--set(m,n)--m是要给哪个对象--n是具体的值
        Object obj = clazz.newInstance();
        f.set(obj,100);
        //6,获取属性的值
        System.out.println( f.get(obj) );
    }
}

4、反射机制的毛病

(1)性能问题。应用反射机制基本上是一种解释操作，咱们能够通知JVM，咱们心愿做什么并且它满足咱们的要求，用于字段和办法接入时反射要远满于间接代码。
性能问题的水平取决于程序中是如何应用反射的，如果它作为程序运行中绝对很少波及的局部，迟缓的性能将不会是一个问题。
(2)应用反射会含糊程序外部理论要产生的事件，程序人员心愿在源代码中看到程序的逻辑，反射等绕过了源代码的技术会带来保护问题。反射代码比响应的间接代码更简单。解决这些问题的最佳计划是激进的应用反射–尽在它能够真正减少灵活性的中央–记录其在指标来中的应用。