java 反射 取stream_Java 之反射

反射概述

反射概述：

反射(Reflection) 是被视为 动态语言 的关键，反射机制允许程序在执行期间借助于Reflection API 取得任何内部类的信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class 类的对象(一个类只有一个Class 对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以我们形象的称之为 反射。

反射主要涉及到的包：

java.lang.Class

java.lang.reflect.Constructor;

java.lang.reflect.Field;

java.lang.reflect.Method;

反射演示

比如我们有一个 Person 类，如下代码演示如何动态获取 Person 类，并对其属性和方法进行操作。

@Test

public void test1() throws Exception {

Class clazz = Person.class;

//1.通过反射，创建Person 类的对象

Constructor cons = clazz.getConstructor(String.class, int.class);

Object obj = cons.newInstance("Tom", 22);

Person p = (Person) obj;

System.out.println(p.toString());

//2.通过反射，调用对象指定的属性、方法

//调用属性，这里可以调用和设置私有属性

Field age = clazz.getDeclaredField("age");

//通过反射设置当前实例Person的age属性

age.setAccessible(true);

age.set(p, 10);

//3.调用方法

Method show = clazz.getDeclaredMethod("show");

show.invoke(p);

//4.调用私有方法,指定一个参数：

Method showNation = clazz.getDeclaredMethod("showNation", String.class);

showNation.setAccessible(true);//调用私有方法，必须去指定它的访问权限，权限为true，才可以调用该方法

showNation.invoke(p, "China");

//5.调用方法，带返回值的

Method getName = clazz.getDeclaredMethod("getName");

String name1 = (String) getName.invoke(p);//这里需要强转下返回值

System.out.println(name1);

//6.调用静态方法

Method showDesc = clazz.getDeclaredMethod("showDesc", String.class);

showDesc.setAccessible(true);

Object returnVal = showDesc.invoke(Person.class, "Jerry description");//这里是void方法，所以返回值是null

//Object returnVal = showDesc.invoke(null,"Jerry description");//或者填null也是可以的

System.out.println("Return value is: " + returnVal);

}

获取Class 的方式

有四种方式可以动态获取大Class

方式1：使用.class

//方式一：调用运行时的类的属性： .class

Class clazz1 = Person.class;

System.out.println(clazz1);

方式2：使用getClass()

//方式二：通过运行时类的对象，调用getClass()

Person p2 = new Person();

Class clazz2 = p2.getClass();

System.out.println(clazz2);

方式3：使用forName(String classPath)

//方式三：调用Class 的静态方法，forName(String classPath)

Class clazz3 = Class.forName("com.jerry.reflection1.Person");

System.out.println(clazz3);

方式4：使用ClassLoader

//方式四：使用ClassLoader(作为了解)

ClassLoader classLoader = ReflectionTest.class.getClassLoader();

Class> clazz4 = classLoader.loadClass("com.jerry.reflection1.Person");

System.out.println(clazz4);

注意： 4种方式创建的实例对象，指向同一个实例

System.out.println(clazz1 == clazz2);

System.out.println(clazz1 == clazz3);

System.out.println(clazz1 == clazz4);

理解java.lang.Class

类的加载过程：

程序通过javac.exe 命令以后，会生成一个或多个字节码文件(.class结尾的文件)，

接着我们使用java.exe命令，对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中，此过程称为类的加载。

加载到内存类中，我们就称为运行时类，此时运行时类，就作为Class 的一个实例。

简单来说：大Class 类其实就是对应运行时类的一个实例。

体现出：万事万物皆对象

可以获取Class 场景

可以动态获取 Class 实例的场景如下：

@Test

public void test3() throws Exception {

Class c1 = Object.class;

Class c2 = Comparable.class;

Class c3 = String[].class;

Class c4 = int[][].class;

Class c5 = ElementType.class;

Class c6 = Override.class;

Class c7 = int.class;

Class c8 = void.class;

Class c9 = Class.class;

int[] a = new int[10];

int[] b = new int[100];

Class c10 = a.getClass();

Class c11 = b.getClass();

//只要元素类型与维度一样，就是同一个Class

System.out.println(c10 == c11);

}

示例：反射文件获取内容

例如： 我们有一个jdbc.properties 的资源文件，如下：

我们要获取其中配置文件的 user 和 password 可以按如下办法：

方式1：FileInputStream

通过 FileInputStream 文件流的方式，获取配置文件中的内容

Properties props = new Properties();

//通过读取文件方式，获取配置文件中的内容，使用这种方式配置文件前面加src\\

FileInputStream fis = new FileInputStream("src\\jdbc.properties");

props.load(fis);

String user = props.getProperty("user");

String password = props.getProperty("password");

System.out.println("User: " + user + " Password: " + password);

方式2：getClassLoader

通过反射 getClassLoader 在获取文件流方式，获取配置文件中内容

//通过类的加载器获取资源文件中的内容,配置文件是在当前文件目录下

Properties props = new Properties();

ClassLoader classLoader = ReflectionTest.class.getClassLoader();

InputStream is = classLoader.getResourceAsStream("jdbc.properties");

props.load(is);

String user1 = props.getProperty("user");

String password1 = props.getProperty("password");

System.out.println("User1: " + user1 + " Password1: " + password1);

创建运行时类的对象

概述：我们通常需要根据反射，来动态的创建运行时类的对象，可以按如下方法：

@Test

public void test5() throws Exception {

Class clazz = Person.class;

Person person = clazz.newInstance();

System.out.println(person);

//这里是新创建的对象，所以不相等

Person person1 = clazz.newInstance();

Person person2 = clazz.newInstance();

System.out.println(person1 == person2);//false

}

注意： newInstance() 方法调用时，对应实例类中必须有对应的空参构造器，没有的话就会报错

总结：要想此方法正常的创建运行时类的对象，要求：

1.运行时类必须提供空参的构造器

2.空参的构造器访问权限得够，通常为public

扩展：在javabean 中通常要求提供一个public 的空参构造器，好处如下：

1.便于通过反射，创建运行时类的对象

2.便于子类继承此运行类时，默认调用super() 时，保证父类有此构造器

示例：体会反射的动态性

@Test

public void test6() {

for (int i = 0; i < 50; i++) {

int num = new Random().nextInt(3);

String classPath = "";

switch (num) {

case 0:

classPath = "java.util.Date";

break;

case 1:

classPath = "java.lang.Object";

break;

case 2:

classPath = "com.jerry.reflection1.Person";

break;

}

try {

Object obj = getInstance(classPath);

System.out.println(obj);

} catch (Exception e) {

e.printStackTrace();

}

}

}

public Object getInstance(String classPath) throws Exception {

Class clazz = Class.forName(classPath);

return clazz.newInstance();

}

**总结： **上述代码，通过switch-case通过传入的 classPath 的 name 不同，既可以动态创建实例，这里就体现了反射的动态性。

附录：Person 类代码

public class Person {

private String name;

private int age;

public Person() {

System.out.println("Person constructor");

}

public Person(String name, int age) {

this.name = name;

this.age = age;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

@Override

public String toString() {

return "Person{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

public void show() {

System.out.println("This is a person");

}

private void showNation(String nation) {

System.out.println("My nation is : " + nation);

}

private static void showDesc(String desc) {

System.out.println("My description is: " + desc );

}

}