Java反射机制
1、Java反射机制概述
1.1、Reflection API
1、反射(Reflection):是Java语言的一个特性,是被视为动态语言的关键。它允程序在运行时(注意不是编译的时候)来进行自我检查并且对内部的成员进行操作。例如它允许一个Java的类获取他所有的成员变量和方法并且显示出来。而这一特性的实现,需要借助于 Refection API。
2、反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息,并能直接操作任意对象的内部属性及方法。
3、加载完类之后,在堆内存的方法区中就产生了一个Class类型的对象(一个 类只有一个Class对象),这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子,透过这个镜子看 到类的结构,所以,我们形象的称之为:反射。
4、在JDK中,主要由以下类来实现Java反射机制,这些API都位于java.lang.reflect包中。
-
Class类:代表一个类。
-
Field类:代表类的成员变量(成员变量也称为类的属性)。
-
Method类:代表类的方法。
-
Constructor类:代表类的构造方法。
-
Array类:提供了动态创建数组,以及访问数组元素的静态方法。
1.2、静态语言与动态语言
前面我们已经知道,是因为反射机制的原因,Java被视为"动态语言"。其实Java只是因为这一特性,具备动态语言某些的特性,让Java成为"准动态语言",并不能真正当做动态语言。那么什么是动态语言?什么又是静态语言呢?
1、动态语言
-
是一类在运行时可以改变其结构的语言:例如新的函数、对象、甚至代码可以 被引进,已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
-
主要动态语言:Object-C、C#、JavaScript、PHP、Python、Erlang等
2、静态语言
-
与动态语言相对应的,运行时结构不可变的语言就是静态语言。如Java、C、 C++等。
-
Java不是动态语言,但Java可以称之为“准动态语言”。即Java有一定的动态性,我们可以利用反射机制、字节码操作获得类似动态语言的特性。 Java的动态性让编程的时候更加灵活。
1.3、Java反射机制提供的功能
1、在运行时判断任意一个对象所属的类
2、在运行时构造任意一个类的对象
3、在运行时判断任意一个类所具有的成员变量和方法
4、在运行时获取泛型信息
5、在运行时调用任意一个对象的成员变量和方法
6、在运行时处理注解
7、生成动态代理
1.4、反射的使用初体验
/*
Java反射的使用:
疑问1:通过直接new的方式或反射的方式都可以调用公共的结构,开发中到低用那个?
1.开发中建议使用 new 的方式创建对象
2.什么时候使用 反射的方式。反射的特征:动态性
疑问2:反射机制与面向对象中的封装性是不是矛盾的?如何看待这两个技术?
不矛盾。
*/
/**
* @description: 我们新建一个Person类用于测试反射,Person类里有属性(包括公私有属性)有getter和setter,和一些自定义方法(公私有),具体Person类在代码最下面。
* @author: laizhenghua
* @date: 2020/11/29 19:12
*/
public class ReflectionTest {
/* 反射之前,对Person类的操作 */
@Test
public void test1(){
// 1. 创建Person类的对象
Person p1 = new Person("韩信",22);
// 2. 通过对象调用其内部的属性与方法
p1.age = 10;
System.out.println(p1.toString());
p1.show();
// 3. 在Person类外部,不可以通过Person类的对象调用其内部私有结构
// 比如:私有构造器、name属性、showNation()私有方法
}
/* 反射之后,对Person类的操作 */
@Test
public void test2() throws Exception {
// 1. 通过反射,创建Person类的对象
Class clazz = Person.class; // Class<Person> personClass = Person.class
Constructor constructor1 = clazz.getConstructor(String.class,int.class); // Constructor<Person> constructor ...
Object obj1 = constructor1.newInstance("韩信",22);
Person p1 = (Person) obj1;
System.out.println(p1);
// 2. 通过反射,调用对象的属性和方法
// 调属性
Field age = clazz.getDeclaredField("age");
age.set(p1,10);
System.out.println(p1.toString()); // Person{name='韩信', age=10}
// 调方法
Method show = clazz.getDeclaredMethod("show");
show.invoke(p1);
// 3. 通过反射,调用Person类的私有结构,私有构造器、属性、方法
// 调私有构造器
Constructor constructor2 = clazz.getDeclaredConstructor(String.class);
constructor2.setAccessible(true);
Person p2 = (Person) constructor2.newInstance("李白");
System.out.println(p2); // Person{name='李白', age=0}
// 调私有方法
Method showNationMethod = clazz.getDeclaredMethod("showNation", String.class);
showNationMethod.setAccessible(true);
String nation = (String) showNationMethod.invoke(p2,"中国"); // 我的国籍是中国
System.out.println(nation);
// 调私有属性
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p2,"alex");
System.out.println(p2); // Person{name='alex', age=0}
}
}
/* Person类 */
class Person{
private String name;
public int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
private Person(String name){
this.name = name;
}
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("你好,我是一个人");
}
private String showNation(String nation){
System.out.println("我的国籍是:"+nation);
return nation;
}
}
2、Class类详解
2.1、关于java.lang.Class类的理解
1、类的加载过程:
- 程序经过java.exe命令以后,会生成一个或多个字节码文件(.class结尾)。
- 接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类,我们就称之为 [运行时类],此运行时类,就作为Class的一个实例。
2、换句话说,Class的实例就对应着一个运行时类。
3、在Object类中定义了public final Class getClass()
方法,此方法将被所有子类继承。此方法返回值的类型是一个Class类, 此类是Java反射的源头。
4、Class 类
可以把反射理解为对象照镜子,对象照镜子后可以得到的信息:某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言,JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。
- Class本身也是一个类
- Class 对象只能由系统建立对象
- 一个加载的类在 JVM 中只会有一个Class实例
- 一个Class对象对应的是一个加载到JVM中的一个.class文件
- 每个类的实例都会记得自己是由哪个 Class 实例所生成
- 通过Class可以完整地得到一个类中的所有被加载的结构
- Class类是Reflection的根源,针对任何你想动态加载、运行的类,唯有先获得相应的 Class对象
2.2、获取Class类的实例(4种方式)
1、加载到内存中的运行时类,会缓存一定的时间,我们可以通过不同的方式来获取此运行时类。
/* 获取Class的实例的方式,前3中使用较多是重点 */
@Test
public void test() throws ClassNotFoundException {
// 方式1:调用运行时类的属性 .class
Class<Person> clazz1 = Person.class;
System.out.println(clazz1);
// 方式2:通过运行时类的对象,调用getClass()
Person p1 = new Person();
Class clazz2 = p1.getClass();
System.out.println(clazz2);
// 方式3:调用Class的静态方法 forName(String classPath),参数classPath:类的全限定名称
Class clazz3 = null;
try {
clazz3 = Class.forName("com.lzh.java1.Person");
// Class clazz = Class.forName("java.lang.String");
System.out.println(clazz3);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
// 方式4:使用类的加载器 ClassLoader
ClassLoader classLoader = ReflectionTest2.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.lzh.java1.Person");
System.out.println(clazz4);
System.out.println(clazz1 == clazz2); // true
System.out.println(clazz1 == clazz3); // true
}
2、哪些类型可以有Class对象?
(1)class: 外部类,成员(成员内部类,静态内部类),局部内部类,匿名内部类
(2)interface:接口
(3)[]:数组
(4)enum:枚举
(5)annotation:注解@interface
(6)primitive type:基本数据类型
(7)void
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);
2.3、使用ClassLoader加载配置文件
1、前面我们已经知道ClassLoader是类的加载器,它可以获取Class类的实例。
2、ClassLoader负责载入系统的所有Resources(Class,文件,来自网络的字节流等),通过ClassLoader从而将资源载入JVM。每个class都有一个reference,指向自己的ClassLoaderClass.getClassLoader() 。
3、因为ClassLoader载入系统资源的特性,我们可以完成一个小案例,实现配置文件的载入!
首先我们在当前module下新建一个文件(db.properties)
name=alex
password=123
不是使用ClassLoader,传统读取方式
@Test
public void test3(){
File file = new File("db.properties");
Properties properties = new Properties();
FileReader reader = null;
try {
reader = new FileReader(file);
properties.load(reader);
String name = properties.getProperty("name");
String password = properties.getProperty("password");
System.out.println("debug name --> " + name); // debug name --> alex
System.out.println("debug password --> " + password); // debug password --> 123
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
assert reader != null;
reader.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
使用ClassLoader
/* ClassLoader的使用实例:读取配置文件(db.properties),此时db.properties需要移动到src目录下 */
@Test
public void test4(){
Properties properties = new Properties();
ClassLoader classLoader = this.getClass().getClassLoader();
InputStream inputStream = classLoader.getResourceAsStream("db.properties"); // 配置文件默认识别为:当前module的src下
try {
properties.load(inputStream);
String name = properties.getProperty("name");
String password = properties.getProperty("password");
System.out.println("debug name --> " + name); // debug name --> alex
System.out.println("debug password --> " + password); // debug password --> 123
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
assert inputStream != null;
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
小结:
- 类加载的作用:将class文件字节码内容加载到内存中,并将这些静态数据转换成方法区的运行时数据结构,然后在堆中生成一个代表这个类的java.lang.Class对象,作为方法区中类数据的访问入口。
- 类缓存:标准的JavaSE类加载器可以按要求查找类,但一旦某个类被加载到类加载器中,它将维持加载(缓存)一段时间。不过JM垃圾回收机制可以回收这些Class对象。
2.4、通过反射创建运行时类的对象
1、newInstance()
方法
/* 通过反射创建运行时类的对象 */
@Test
public void test1() throws IllegalAccessException, InstantiationException {
Class<Person> clazz = Person.class;
// Class<Person> c = Class.forName("com.lzh.java2.Person");
/*
newInstance(); 调用此方法,创建对应的运行时类的对象.内部调用了运行时类的空参构造器
要想此方法正常的创建运行时类的对象,要求:
1. 运行时类必须提供空参的构造器
2. 空参的构造器的访问权限的够。通常设置为public
在javabean中要去提供一个public的空参构造器。原因:
1. 便于通过反射,创建运行类的对象
2. 便于子类继承此运行时类时,默认调用super()时,保证父类有此构造器
*/
Person p1 = clazz.newInstance();
System.out.println(p1);
/*
newInstance() 调用此方法,创建运行时类的对象
我们可以做个试验,可以在公有无参构造器中添加一些输出的代码,运行
试验结果说明,本质上还是调用了构造器创建对象,也只有构造器能造对象
*/
}
2、体会反射的动态性
/* 体会反射的动态性 */
@Test
public void test2(){
for(int i = 0;i < 10;i++){
int number = new Random().nextInt(3); // 0 1 2
String classPath = "";
switch(number){
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.lang.Object";
break;
case 2:
classPath = "com.lzh.java2.Person";
break;
}
try {
Object obj = getInstance(classPath);
System.out.println(obj);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/*
创建一个指定类的对象,classPath:指定类的全名
*/
public Object getInstance(String classPath) throws Exception {
Class clazz = Class.forName(classPath);
return clazz.newInstance();
}
2.5、通过反射获取运行时类的完整结构
我们知道Java反射机制的源头是java.lang.Class类,我们可以通过这个类获取运行时类的完整结构,包括类的属性、方法和构造器、某个类到底实现了哪些接口等。所以我们要想获取某个运行时类的的结构,就必须先获取这个类对应的Class类的实例,并调用实例的某些方法从而获取我们想要信息。
为了方便测试,我们先编写测试代码,包括父类,子类,自定义的接口,自定义的注解,私有方法,私有属性,公有方法,公有属性,泛型等。为了方便查看,我全部写在一个类里面:
@MyAnnotation(value="hi")
public class Man extends Creature<String> implements Comparable<String>,MyInterface {
private String name;
int age;
public int id;
public Man(){}
@MyAnnotation(value="abc")
private Man(String name){
this.name = name;
}
Man(String name,int age){
this.name = name;
this.age = age;
}
@MyAnnotation
private String showNation(String nation){
System.out.println("我的国籍是:" + nation);
return nation;
}
public String display(String interest){
System.out.println();
return interest;
}
@Override
public void info() {
System.out.println("我是一个人");
}
@Override
public int compareTo(String o) {
return 0;
}
}
// 提供Man的父类Creature<T>
class Creature<T> implements Serializable {
private char gender;
public double weight;
private void breath(){
System.out.println("生物呼吸");
}
public void eat(){
System.out.println("生物吃东西");
}
}
// 自定义接口
interface MyInterface{
void info();
}
// 提供注解
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, MODULE})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation{
String value() default "hello";
}
1、通过反射获取运行时类的全部属性(Field)
-
public Field[] getFields()
返回此Class对象所表示的类或接口的public的Field。 -
public Field[] getDeclaredFields()
返回此Class对象所表示的类或接口的全部Field。
Field类包含的方法:
-
public int getModifiers()
以整数形式返回此Field的修饰符 -
public Class<?> getType()
得到Field的属性类型 -
public String getName()
返回Field的名称
代码测试
/**
* @description: 获取当前运行时类的属性结构
* @author: laizhenghua
* @date: 2020/12/1 12:39
*/
public class FieldTest {
/* Class类实例的方法 */
@Test
public void test1(){
Class<Man> clazz = Man.class;
// 获取属性结构
// getFields():获取当前运行类及其父类中声明为public访问权限的属性
Field[] fields1 = clazz.getFields();
for(Field field:fields1){
System.out.println(field);
}
// getDeclaredFields():获取当前运行类中声明的所有属性(不包含父类中声明的属性)
Field[] fields2 = clazz.getDeclaredFields();
for(Field field:fields2){
System.out.println(field);
}
}
/* Field类里的方法,包括权限修饰符、数据类型、变量名 */
@Test
public void test2(){
try {
Class clazz = Class.forName("com.lzh.java2.Man");
Field[] fields1 = clazz.getDeclaredFields();
for(Field field:fields1){
// 1. 权限修饰符
// int modifier = field.getModifiers();
System.out.print(Modifier.toString(field.getModifiers()) + "\t");
// 2. 数据类型
Class type = field.getType();
System.out.print(type.getName() + "\t");
// 3. 变量名
// String name = field.getName();
System.out.print(field.getName() + "\t");
System.out.println();
}
}catch (ClassNotFoundException e){
e.printStackTrace();
}
}
}
2、通过反射获取运行时类的全部方法
-
public Method[] getDeclaredMethods()
返回此Class对象所表示的类或接口的全部方法(不包含父类中声明的方法)。 -
public Method[] getMethods()
返回此Class对象(当前运行时类)所声明的类、父类或接口的public权限的方法。
Method类中包含的方法:
-
public Class<?> getReturnType()
取得全部的返回值 -
public Class<?>[] getParameterTypes()
取得全部的参数 -
public int getModifiers()
取得修饰符 -
public Class<?>[] getExceptionTypes()
取得异常信息
关于代码的测试,可自行完成。
3、通过反射获取运行时类的全部构造器
-
public Constructor<T>[] getConstructors()
返回此 Class 对象所表示的类的所有public构造方法。 -
public Constructor<T>[] getDeclaredConstructors()
返回此 Class 对象表示的类声明的所有构造方法。
Constructor类中包含的方法:
-
取得修饰符:
public int getModifiers();
-
取得方法名称:
public String getName();
-
取得参数的类型:
public Class<?>[] getParameterTypes();
有关方法的测试,可自行完成。
4、通过反射获取运行时类的父类
public Class<? Super T> getSuperclass()
返回表示此 Class 所表示的实体(类、接口、基本类型)的父类的 Class。- 测试
@Test
public void test2(){
Class<Person> personClass = Person.class;
// 获取运行时类父类的Class
Class<? super Person> superclass = personClass.getSuperclass();
System.out.println(superclass); // class com.howie.pojo.Creature
// 获取运行时类带泛型的父类
Type genericSuperclass = personClass.getGenericSuperclass();
System.out.println(genericSuperclass); // com.howie.pojo.Creature<java.lang.String>
// 获取运行时类带泛型的父类的泛型
ParameterizedType parameterized = (ParameterizedType) genericSuperclass;
Type[] actualTypeArguments = parameterized.getActualTypeArguments(); // 获取泛型参数
System.out.println(actualTypeArguments[0]); // class java.lang.String
// System.out.println(actualTypeArguments[0].getTypeName());
}
5、通过反射获取运行实类实现的接口
public Class<?>[] getInterfaces()
确定此对象所表示的类或接口实现的接口。- 测试
@Test
public void test3(){
Class<Person> personClass = Person.class;
// 获取运行类实现的接口
Class<?>[] interfaces = personClass.getInterfaces();
for (Class c : interfaces){
System.out.println(c);
}
// 获取运行时类父类的实现的接口
Class<?>[] superInterfaces = personClass.getSuperclass().getInterfaces();
for (Class c : superInterfaces){
System.out.println(c);
}
}
6、通过反射获取运行时类所在包
Package getPackage()
获取运行时类所包- 测试
@Test
public void test(){
Class<Person> personClass = Person.class;
Package classPackage = personClass.getPackage();
System.out.println(classPackage); // package com.howie.pojo
}
7、通过反射获取运行时类声明的注解
getAnnotation(Class<T> annotationClass)
返回该元素的指定类型的注释getDeclaredAnnotations()
返回直接存在于此运行时类上的所有注释(不包含父类中声明)Annotation[] getAnnotations()
获取运行时类声明的注解
@Test
public void test(){
Class<Person> personClass = Person.class;
Annotation[] annotations = personClass.getAnnotations();
for(Annotation annotation : annotations){
System.out.println(annotation); // @com.howie.pojo.MyAnnotation(value=world)
}
}
8、泛型相关
- 获取父类泛型类型:
Type getGenericSuperclass()
- 泛型类型:
ParameterizedType
- 获取实际的泛型类型参数数组:
getActualTypeArguments()
小结
-
在实际的操作中,取得类的信息的操作代码,并不会经常开发。
-
一定要熟悉java.lang.reflect包的作用,反射机制。
-
如何取得属性、方法、构造器的名称,修饰符等
3、调用运行时类指定的结构
3.1、调用指定的属性
在反射机制中,可以直接通过Field类操作类中的属性,通过Field类提供的set()
和 get()
方法就可以完成设置和取得属性内容的操作。
1、获取指定属性的方法
public Field getField(String name)
返回此Class对象表示的类或接口的指定的public的Field。public Field getDeclaredField(String name)
返回此Class对象表示的类或接口的指定的Field。
2、在Field类中包含的方法:
-
public Object get(Object obj)
取得指定对象obj上此Field的属性内容 -
public void set(Object obj,Object value)
设置指定对象obj上此Field的属性内容
3、代码测试
@Test
public void FieldTest(){
// 获取指定的属性
try {
Class clazz = Class.forName("com.lzh.java2.Man");
// 获取运行时类的对象
Man man = (Man) clazz.newInstance();
// 获取指定的属性:要求运行时类的属性声明为 public
Field id = clazz.getField("id"); // 开发中通常不适用此方法
/*
设置当前属性的值 set()方法
参数1:指明设置那个对象的属性
参数2:将此属性值设置为多少
*/
id.set(man,1001);
// 获取当前属性的值:get(Object obj) 参数obj:获取哪个对象的当前属性值
int manId = (int) id.get(man); // 1001
System.out.println(manId);
}catch (Exception e){
e.printStackTrace();
}
}
@Test
/*
如何操作运行时中类指定的属性 --> 需要掌握
*/
public void test1(){
try{
// 获取运行时类对象
Class clazz = Class.forName("com.lzh.java2.Man");
Man man = (Man) clazz.newInstance();
// 获取指定的属性
// 1 getDeclaredField(String field) 获取运行时类中指定变量名的属性(忽略权限)
Field name = clazz.getDeclaredField("name");
name.setAccessible(true); // 2 保证当前属性是可以访问的(可以理解为取消封装)
// 3 获取、设置指定对象的此属性值
name.set(man,"李白");
String manName = (String) name.get(man);
System.out.println(manName);
}catch(Exception e){
e.printStackTrace();
}
}
关于setAccessible方法的使用
-
Method和Field、Constructor对象都有
setAccessible()
方法。 -
setAccessible启动和禁用访问安全检查的开关。
-
参数值为true则指示反射的对象在使用时应该取消Java语言访问检查。
-
提高反射的效率。如果代码中必须用反射,而该句代码需要频繁的被 调用,那么请设置为true。
-
使得原本无法访问的私有成员也可以访问
- 参数值为false则指示反射的对象应该实施Java语言访问检查
3.2、调用指定的方法
1、通过反射调用类中的方法,通过Method类完成步骤:
-
通过Class类的
getMethod(String name, Class<?>... parameterTypes)
方法取得 一个Method对象,并设置此方法操作时所需要的参数类型。但是以上方法不常用,我们常用的方法是Method getDeclaredMethod(String name, Class<?>... parameterTypes)
来获取运行时类中指定的方法。 -
之后使用
Object invoke(Object obj, Object[] args)
进行调用,并向方法中传递要设置的obj对象的参数信息。
2、代码测试
@Test
/*
如何操作运行时类中指定的方法 --> 需要掌握
*/
public void methodTest(){
// 操作非静态方法
Class clazz = null;
try{
// 1. 获取运行时类的对象
clazz = Class.forName("com.lzh.java2.Man");
Man man = (Man) clazz.newInstance();
// 2. 获取运行时类中指定的某个方法
// getDeclaredMethod(String name,Class<?>) 参数1:指明获取方法的名称 参数2:指明获取的方法的形参列表
Method showNation = clazz.getDeclaredMethod("showNation", String.class);
showNation.setAccessible(true); // 保证当前方法可以访问
// invoke(Object obj,Object...arg) 参数1:方法的调用这 参数2:给方法形参赋值的实参
// invoke()方法的返回值即为运行时类方法执行时返回的返回值
showNation.invoke(man,"china"); // 3. 调用invoke()方法
// Object nation = showNation.invoke(man,"china");
// 执行结果
// 我的国籍是:china
}catch(Exception e){
e.printStackTrace();
}
// 操作静态方法
// public static void speak() --> 静态方法
try {
Method speak = clazz.getDeclaredMethod("speak");
speak.setAccessible(true);
Object value = speak.invoke(clazz.newInstance());
System.out.println(value); // null
// 说明:如果调用的运行时类中的方法没有返回值,则此invoke()方法返回null
}catch(Exception e){
e.printStackTrace();
}
}
Object invoke(Object obj, Object … args)说明:
-
Object 对应原方法的返回值,若原方法无返回值,此时返回null
-
若原方法若为静态方法,此时形参Object obj可为null
-
若原方法形参列表为空,则Object[] args为null
-
若原方法声明为private,则需要在调用此invoke()方法前,显式调用 方法对象的setAccessible(true)方法,将可访问private的方法。
3.3、调用指定的构造器
前面我们已经知道,通过反射我们也可以获取运行时类中声明的构造器,同样我们也可以调用运行时类中指定的构造器。
- 通过Class类的
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
取得一个Constructor对象。 - 通过Constructor对象的
T newInstance(Object ... initargs)
就可以造出一个对象!
代码测试:
/*
如何调用运行时类中指定的构造器
*/
@Test
public void constructorTest(){
// private Man(String name) 指定运行时类的构造器
Class clazz = null;
try{
// 1. 获取Class的实例
clazz = Class.forName("com.lzh.java2.Man");
// 2. 获取运行时类中指定的构造器
// getDeclaredConstructor() 参数:指明构造器的参数列表
Constructor constructor = clazz.getDeclaredConstructor(String.class);
// Man类里的有参构造器 private Man(String name){...}
// 3. 保证此构造器是可以被访问的
constructor.setAccessible(true);
// 4. 调用此构造器创建运行时类的对象
Man man = (Man) constructor.newInstance("韩信");
System.out.println(man);
}catch (Exception e){
e.printStackTrace();
}
}
4、反射机制的应用:动态代理
4.1、动态代理模式介绍
1、代理设计模式的原理:使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
2、之前为大家讲解过代理机制的操作,属于静态代理,特征是代理类和目标对象的类都是在编译期间确定下来,不利于程序的扩展。同时,每一个代理类只能为一个接口服务,这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。
3、动态代理是指客户通过代理类来调用其它对象的方法,并且是在程序运行时根据需要动态创建目标类的代理对象。
4、动态代理使用场合:
-
调试
-
远程方法调用
5、动态代理相比于静态代理的优点:
抽象角色中(接口)声明的所有方法都被转移到调用处理器一个集中的方法中处理,这样我们可以更加灵活和统一的处理众多的方法。
4.2、Java动态代理相关API
-
Proxy :专门完成代理的操作类,是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
-
提供用于创建动态代理类和动态代理对象的静态方法
4.3、实现动态代理的步骤
1、创建一个实现接口InvocationHandler的类,它必须重写invoke方法,以完成代理的具体操作。
2、创建被代理的类以及接口
3、通过Proxy的静态方法 newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
创建 一个Subject接口代理。
4、通过 Subject代理调用RealSubject实现类的方法
4.4、动态代理代码示例
1、静态代理
/*
静态代理举例:
特点:编译期间,代理类和被代理类就已经确定下来了
*/
// 定义代理接口
interface ClothFactory{
void produceCloth();
}
// 创建代理类
class ProxyClothFactory implements ClothFactory {
private ClothFactory clothFactory; // 用被代理类进行实例化
public ProxyClothFactory(ClothFactory clothFactory){
this.clothFactory = clothFactory;
}
@Override
public void produceCloth(){
System.out.println("代理工厂做一些准备工作");
clothFactory.produceCloth();
System.out.println("代理工厂做一些后续的收尾工作");
}
}
// 创建被代理类
class NikeClothFactory implements ClothFactory {
@Override
public void produceCloth(){
System.out.println("nike工厂生产一批运动服");
}
}
public class StaticProxyTest {
public static void main(String[] args){
// NikeClothFactory nikeClothFactory = new NikeClothFactory(); 创建代理类对象
ClothFactory proxy = new ProxyClothFactory(new NikeClothFactory()); // 创建被代理类对象
proxy.produceCloth();
}
}
2、动态代理
// 创建代理接口
interface Human{
String getBelief(); // 获取信仰
void eat(String food);
}
// 创建被代理类
class SuperMan implements Human{
@Override
public String getBelief(){
return "I believe I can fly!";
}
@Override
public void eat(String food){
System.out.println("我喜欢吃:" + food);
}
}
/*
要想实现动态代理,需要解决的问题:
问题1:如何根据加载到内存中的被代理类,动态的创建一个代理类及其对象
问题2:当通过代理类的对象调用方法时,如何动态的去调用被代理类中同名方法
*/
// 创建代理类
class ProxyFactory{
// 调用此方法,返回一个代理类的对象。解决问题1
public static Object getProxyInstance(Object obj){ // obj:被代理类的对象
MyInvocationHandler handler = new MyInvocationHandler();
handler.bank(obj);
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
}
}
class MyInvocationHandler implements InvocationHandler {
private Object obj; // 需要使用被代理类的对象进行赋值
public void bank(Object obj){
this.obj = obj;
}
// 当我们通过代理类的对象,调用方法a时,就会自动调用如下方法:invoke()
// 将别代理类要执行的方法a的功能,就声明在invoke()方法中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// method:即为代理类对象调用的方法,此方法也就作为被代理类对象要调用的方法
// obj:被代理类的对象
Object returnValue = method.invoke(obj,args);
// 上述方法的返回值就作为当前类中的invoke()
return returnValue;
}
}
public class ProxyTest {
public static void main(String[] args) {
// 创建代理类的对象
// SuperMan superMan = new SuperMan(); 代理类对象
Human proxyInstance = (Human) ProxyFactory.getProxyInstance(new SuperMan());
// 当通过代理类对象调用方法时,会自动的调用被代理类中同名的方法
String belief = proxyInstance.getBelief();
System.out.println(belief);
proxyInstance.eat("四川麻辣烫");
ClothFactory clothFactory = (ClothFactory) ProxyFactory.getProxyInstance(new NikeClothFactory());
clothFactory.produceCloth();
}
}