Java代码审计---反射

简介

java的反射就是在程序运行中动态的创建对象，并且和new不同的是，反射创建对象不需要考虑访问权限，可以直接查看类的私有属性以及调用私有方法，并且new创建对象时在编译时期将对象的.class加载进内存，而反射创建对象则时在运行时期加载进内存。

加载过程

在进行反射时，我们首先需要创建对应类的Class对象，然后再通过Class对象的newInstance方法或者Constructor对象的 newInstance() 方法来创建对象，这种方式下，对象的加载是在程序执行过程中动态进行的，而不是在编译时确定的。

主要使用方法

获取对应的Class对象

Class.forName()
实例对象.getClass()
类名.class

Class.forName()只需要知道某个类的名字或者类的全限命名，就可以获取到这个类的class对象，并且这种方法会默认加载该类的static代码块,其他两种并不会。
实例对象.getClass()如果上文已经存在一个实例化的类，那么可以直接使用getClass()方法获取Class对象
类名.class如果已经加载了一个类，只需要直接调用class属性即可后去对应的class对象
首先我们创建一个类

package org.Reflex.entity;  
  
public class User {  
    class Userinternal{  
        public void PrintC(){  
            System.out.println("执行了内部类的PrintC方法");  
        }  
    }  
    static {  
//        System.out.println("aaa");  
    }  
  
    public User() {  
        System.out.println("调用了无参构造方法");  
    }  
  
    public User(String user_name, String user_phone) {  
        this.user_name = user_name;  
        this.user_phone = user_phone;  
        System.out.println(user_name+" "+user_phone);  
    }  
  
    public String user_name;  
    private String user_phone;  
  
    public String getUser_name() {  
        return user_name;  
    }  
  
    public void setUser_name(String user_name) {  
        this.user_name = user_name;  
    }  
  
    public String getUser_phone() {  
        return user_phone;  
    }  
  
    public void setUser_phone(String user_phone) {  
        this.user_phone = user_phone;  
    }  
  
    private void PrintAll(){  
        System.out.println("调用了私有化方法");  
    }  
    public String Print(String connect){  
        return connect;  
    }  
    public void PrintA(){  
        System.out.println("调用了PrintA方法");  
    }  
  
    public static void PringB(){  
        System.out.println("调用了static PrintB方法");  
    }  
}

下面是一个测试demo

@Test  
public void testStart() throws ClassNotFoundException {  
    User user = new User();  
    //第一种方法  
    Class<?> aClass = Class.forName("com.entity.User");  
    //第二种方法  
    Class<? extends User> aClass1 = user.getClass();  
    //第三种方法  
    Class<User> userClass = User.class;  
}

Class对象和new创建对象的区别

• 使用new关键字创建对象返回的是该类的实例对象。
• Class.forName()返回的是对应类的Class对象，可以通过这个Class对象来创建实例对象、访问类的静态成员和方法，但不会直接创建实例对象。

通过Class对象获取实例化对象

Class<?> aClass = Class.forName("org.Reflex.entity.User");
Object o = aClass.newInstance();

setAccessible 方法

在反射中，这个方法会经常用到，如：

Field userPhone = aClass.getDeclaredField("user_phone");  
userPhone.setAccessible(true);

这个方法可以启用或禁用安全访问检查，如果为true表示禁用，以此来给私有属性赋值，以及调用私有方法等操作。

反射获取类的成员变量

 Field getField(String name)          获取指定的public变量
 Field[] getFields()                  获取所有的public变量 
 Field getDeclaredField(String name)  获取指定的变量,不论是不是public
 Field[] getDeclaredFields()          获取所有的变量，不论是不是public

还是使用上面的User类，这次就删除里面的static代码块，当我们获取到一个属性的时候，还可以使用下面方法进行操作。

String getName()   //获取变量的名字
int getModifiers()  //获取变量的修饰符，返回的是一个数字，需要配合Modifier.tostring使用
Class<?> getType()   //返回属性的类型，一般配合getSimpleName()方法一起使用
void set(Object obj, Object value)   //设置属性的值
Object get(Object obj)  //读取属性的值

使用示例

Class<?> aClass = Class.forName("org.Reflex.entity.User");  
//获取所有的属性  
Field[] declaredFields = aClass.getDeclaredFields();  
for (Field f:declaredFields){  
    System.out.println("属性名:"+f.getName()); //依次打印属性名  
    System.out.println("修饰符:"+ Modifier.toString(f.getModifiers()));   //获取权限修饰符  
    System.out.println("Type:"+f.getType().getSimpleName());  
}
//获取指定属性  
Field userPhone = aClass.getDeclaredField("user_phone");  
userPhone.setAccessible(true);  
//实例化class类  
Object o = aClass.newInstance();  
//为指定实例化对象的指定属性赋值  
userPhone.set(o,"12356456");  
//通过get方法获取属性的值  
System.out.println(userPhone.get(o));

反射调用类的方法

　getMethods()   //获取当前类的所有public方法
　getDeclaredMethods()  //获取当前类的所有方法
　getMethod(String name, Class[] parameterTypes)    //获取类的指定方法，第一个参数是方法名，第二个参数是不定长参数，输入当前方法的所有参数类型

当我们获取到一个方法是，可以使用下面函数进行操作

getName() //获取方法的名字
getModifiers() //获取方法的访问权限，需要配合Modifier.toString使用
getParameterTypes()  //获取方法的参数类型
getDeclaringClass()   //返回声明该方法的类或接口的Class对象
invoke() //使用指定的参数在具有指定参数的指定对象上调用此方法
//参数 `obj` 是调用方法的对象实例，如果是静态方法，则可以为 null ,参数 args 是方法调用的参数。

下面是一些使用的示例

@Test  
public void testMethods() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {  
    Class<?> aClass = Class.forName("org.Reflex.entity.User");  
    //查看所有的方法  
    Method[] methods = aClass.getDeclaredMethods();  
    for (Method m:methods){  
        System.out.print(Modifier.toString(m.getModifiers())+" ");   //获取方法的权限  
        System.out.print(m.getName()+"  ");   //获取方法的名字  
        System.out.print(Arrays.toString(m.getParameterTypes())+" ");   //获取方法的参数类型  
        System.out.print(m.getDeclaringClass());  
        System.out.println();  
    }  
    //获取指定方法  
    Method pring = aClass.getDeclaredMethod("Print",String.class);  
    //实例化User类  
    Object o = aClass.newInstance();  
    //调用实例化User类的Print方法  
    Object invoke = pring.invoke(o, "测试指定方法调用");  
    //输出方法调用的返回值  
    System.out.println(invoke.toString());  
    
    //获取指定的私有化方法  
    Method printAll = aClass.getDeclaredMethod("PrintAll");  
    //禁用安全检查  
    printAll.setAccessible(true);  
    //调用方法  
    Object invoke1 = printAll.invoke(o);  
  
    //调用静态方法  
    Method pringB = aClass.getDeclaredMethod("PringB");  
    //因为为静态方法，所以不需要传入实例化的类，直接调用就可以  
    Object invoke2 = pringB.invoke(null);  
}

反射类的构造方法

构造方法和普通方法基本基本上差不多，但是也有所不同

• 构造方法命名要和类名一致
• 构造方法不能有返回值，但是普通方法有

getConstructors()   //获取所有的public 构造方法
getDeclaredConstructors()   //获取所有的构造方法
getConstructor()   //获取一个指定的public 构造方法
getDeclaredConstructor()   //获取一个指定的构造方法，不限于public

基本上获取到的构造方法都和上面的方法函数差不多

@Test  
public void testConstructor() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {  
    Class<?> aClass = Class.forName("org.Reflex.entity.User");  
    //获取当前类的所有构造方法  
    Constructor<?>[] constructors = aClass.getConstructors();  
   for (Constructor c:constructors){  
       //打印构造方法的权限  
       System.out.print(Modifier.toString(c.getModifiers())+" ");  
       //打印构造方法的名字  
       System.out.print(c.getName());  
       //打印当前构造方法所有的  
       System.out.print(Arrays.toString(c.getParameterTypes()));  
       //打印当前构造方法的引用  
       System.out.println(c.getDeclaringClass());  
   }  
   //获取类的无参构造方法  
    Constructor<?> constructor = aClass.getConstructor();  
   //调用类的无参构造方法  
    Object o = constructor.newInstance();  
    //调用类的有参构造方法  
    Constructor<?> constructor1 = aClass.getConstructor(String.class, String.class);  
    constructor1.newInstance("pwjcw","123456");  
}

调用方法和上面的有所不同，直接调用newInstance函数即可。
相关笔记代码已上传至Git仓库：JavaCodeAudit