目录
一、Java反射机制概述
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！
Java反射机制研究及应用 :
-
在运行时判断任意一个对象所属的类
-
在运行时构造任意一个类的对象
-
在运行时判断任意一个类所具有的成员变量和方法
-
在运行时获取泛型信息
-
在运行时调用任意一个对象的成员变量和方法
-
在运行时处理注解
-
生成动态代理
反射相关的主要API :
-
java.lang.Class : 代表一个类
-
java.lang.reflect.Method : 代表类的方法
-
java.lang.reflect.Field : 代表类的成员变量
-
java.lang.reflect.Constructor : 代表类的构造器
-
… …
通过代码初步认识反射 :
public class ReflectionTest {
//使用反射之前 对于Person类的操作
@Test
public void test01(){
//1. 创建Person类的对象
Person p1 = new Person("Tom", 12);
//2 通过对象调用其内部的属性和方法
p1.age = 10;
System.out.println(p1.toString());//Person{name='Tom', age=10}
p1.show();//你好，我是一个人
//在Person类的外部 不能通过Person类的对象来调用其内部的私有方法
//比如 : name 、showNation() 、私有的构造器
}
//使用反射之后 对于Person类的操作
@Test
@SuppressWarnings("rawtypes")
public void test02() throws Exception {
//1. 通过反射，创建Person类的对象
Class clazz = Person.class;
Constructor cons = clazz.getConstructor(String.class, int.class);
Object obj = cons.newInstance("Tom", 12);
Person p = (Person) obj;
System.out.println(p);//Person{name='Tom', age=12}
//2. 通过反射，调用对象指定的属性和方法
//调用属性
Field age = clazz.getDeclaredField("age");
age.set(p, 10);
System.out.println(p);//Person{name='Tom', age=10}
//调用方法
Method show = clazz.getDeclaredMethod("show");
show.invoke(p);//你好，我是一个人
//通过反射，可以调用Person类的私有结构 : 私有的构造器 属性 方法
//私有的构造器
Constructor priCons = clazz.getDeclaredConstructor(String.class);
priCons.setAccessible(true);//暴力进入
Object obj2 = priCons.newInstance("Jerry");
Person p2 = (Person) obj2;
System.out.println(p2);//Person{name='Jerry', age=0}
//私有的属性
Field name = clazz.getDeclaredField("name");
name.setAccessible(true);
name.set(p2, "Jack");
System.out.println(p2);//Person{name='Jack', age=0}
//私有的方法
Method showNation = clazz.getDeclaredMethod("showNation", String.class);
showNation.setAccessible(true);
String nation = (String) showNation.invoke(p2, "China");//我的国籍是 : China
System.out.println(nation);//China
}
}疑问一 : 通过直接new的方式或反射的方式都可以调用公共的结构，开发中到底用哪个?
建议 : 直接new的方式。什么时候会使用反射的方式呢 --> 反射的特征 : 动态性，在运行期间不知道创建哪个类的对象。
疑问二 : 反射机制与面向对象中的封装性是不是矛盾的?如何看待两个技术?
不矛盾。封装性解决的是建议调什么的问题，反射技术解决的是能不能调的问题。
二、理解Class类并获取Class实例
1. Class类
关于java.lang.Class类的理解
-
类的加载过程 : 程序经过javac.exe命令以后，会生成一个或多个字节码文件 ( .class结尾 ) 。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。
-
换句话说，Class的实例就对应着一个运行时类。
-
加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。
-
体现了万事万物皆对象，类、属性、方法、构造器都可作为一个对象。
-
Class 对象只能由系统建立对象
-
一个加载的类在 JVM 中只会有一个Class实例
-
一个Class对象对应的是一个加载到JVM中的一个.class文件
-
每个类的实例都会记得自己是由哪个 Class 实例所生成
-
通过Class可以完整地得到一个类中的所有被加载的结构
-
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
2. 如何获取Class实例
-
调用运行时类的属性 : .class
-
通过运行时类的对象，调用getClass()
-
调用Class的静态方法 : forName(String classPath)
-
使用类的加载器 : ClassLoader (了解)
/*
如何获取Class类的实例, 前三张方式需要掌握
*/
@SuppressWarnings("rawtypes")
@Test
public void test03() throws ClassNotFoundException {
//方式一 : 调用运行时类的属性 : .class
Class clazz1 = Person.class;
System.out.println(clazz1);//class com.atguigu.study.Person
//方式二 : 通过运行时类的对象，调用getClass()
Person p = new Person();
Class clazz2 = p.getClass();
System.out.println(clazz2);//class com.atguigu.study.Person
//方式三 : 调用Class的静态方法 : forName(String classPath)
Class clazz3 = Class.forName("com.atguigu.study.Person");
//Class.forName("java.lang.String")
System.out.println(clazz3);//class com.atguigu.study.Person
System.out.println(clazz1 == clazz2);//true
System.out.println(clazz1 == clazz2);//true
//方式四 : 使用类的加载器 : ClassLoader (了解)
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class clazz4 = classLoader.loadClass("com.atguigu.study.Person");
System.out.println(clazz4);//class com.atguigu.study.Person
}3. 哪些类型可以有Class对象
-
class : 外部类，成员(成员内部类，静态内部类)，局部内部类，匿名内部类
-
interface : 接口
-
[] : 数组
-
enum : 枚举
-
annotation : 注解@interface
-
primitive type : 基本数据类型
-
void
/*
Class实例可以是哪些类的结构
*/
@SuppressWarnings("rawtypes")
@Test
public void test04(){
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);
}三、类的加载与ClassLoader的理解
1. 类的加载过程
JVM简图 :
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。
加载 : 将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。
链接 : 将Java类的二进制代码合并到JVM的运行状态之中的过程。
-
验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
-
准备：正式为类变量（static）分配内存并设置类变量默认初始值(int 类型赋值为0等)的阶段，这些内存都将在方法区中进行分配。
-
解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
初始化 :
执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。
public class ClassLoadingTest {
public static void main(String[] args) {
System.out.println(A.m);//100
}
}
class A{
static {
m = 300;
}
static int m = 100;
}
/*
第二步 : 链接结束后 m = 0
第三步 : 初始化后，m的值由<clinit>()方法执行决定
这个A的类构造器<clinit>()方法由类变量的赋值和静态代码块中的语句按照顺讯产生。
*/2.什么时候发生类的初始化?
类的主动引用（一定会发生类的初始化）
-
当虚拟机启动，先初始化main方法所在的类
-
new一个类的对象
-
调用类的静态成员（除了final常量）和静态方法
-
使用java.lang.reflect包的方法对类进行反射调用
-
当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
类的被动引用（不会发生类的初始化）
-
当访问一个静态域时，只有真正声明这个域的类才会被初始化
当通过子类引用父类的静态变量，不会导致子类初始化
-
通过数组定义类引用，不会触发此类的初始化
-
引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
public class ClassLoadingTest {
public static void main(String[] args) {
//主动引用 : 一定会导致A和Father的初始化
// A a = new A();//一定会初始化A及其父类
// System.out.println(A.m);//只会初始化A类
// Class.forName("com.atguigu.java2.A");//会初始化A及其父类
//被动引用
//创建一个数组
A[] arr = new A[5];//不会导致A和Father的初始化
//通过子类调用父类的静态属性
System.out.println(A.b);//只会初始化Father
//调用常量
System.out.println(A.M);//不会导致A和Father的初始化
}
}
class Father {
static int b = 2;
static {
System.out.println("父类被加载");
} }
class A extends Father{
static {
System.out.println("子类的加载");
m = 300;
}
static int m = 100;
static final int M = 1;
}3. 类加载器的作用
类加载的作用 : 将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存 : 标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。
-
引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来装载核心类库。该加载器无法直接获取
-
扩展类加载器：负责jre/lib/ext目录下的jar包或 –D java.ext.dirs 指定目录下的jar包装入工作库
-
系统类加载器：负责java –classpath 或 –D java.class.path所指的目录下的类与jar包装入工作 ，是最常用的加载器
类的加载时通过双亲委派机制来完成的，双亲委派机制 :
当一个类需要被加载时，首先是对应改类的加载器检测此类有无被改加载器加载过然后从路径中找是否可以加载此类，不管该加载器是否可以加载此类，都要委托给上一层加载器来判断是否被加载过和能否加载，一直到根加载器。如果根加载器可以加载，那么就交给根加载器加载。如果根加载器不能加载，再交给下层可以加载的加载器加载。如果所有加载器都不能加载此类，那么就抛出ClassNotFoundException。
在这样一个机制的背景下，如果想自定义一个类全名为java.lang.String，那么加载这个类时，委托到根加载器加载，那么就会按照核心API的路径去找名为java.lang.String，自然加载的就是核心API里的类而不是自定义类。Java中不允许自定义java.lang这种包名。
双亲委派机制的优点 :
-
避免了类的重复加载
-
保护程序安全，防止核心API被随意篡改
/*
了解类的加载器
*/
@Test
public void test01(){
//对于自定义类使用的是系统类加载器加载
ClassLoader classLoader1 = ClassLoaderTest.class.getClassLoader();
System.out.println(classLoader1);//sun.misc.Launcher$AppClassLoader@18b4aac2
//调用系统类加载器getParent() : 获取扩展类加载器
ClassLoader classLoader2 = classLoader1.getParent();
System.out.println(classLoader2);//sun.misc.Launcher$ExtClassLoader@78308db1
//调用扩展类加载器getParent() : 无法获取引导类加载器
//引导类加载器主要负责加载java核心类库，无法加载自定义类
ClassLoader classLoader3 = classLoader2.getParent();
System.out.println(classLoader3);//null
//String类是引导类加载器加载的
ClassLoader classLoader = String.class.getClassLoader();
System.out.println(classLoader);//null
}使用ClassLoader加载配置文件 :
/*
使用FileInputStream加载配置文件
*/
@Test
public void test02(){
Properties pros = new Properties();
FileInputStream fis = null;
try {
fis = new FileInputStream("jdbc.properties");//默认的相对路径是当前module下
pros.load(fis);
String name = pros.getProperty("name");
String password = pros.getProperty("password");
System.out.println("name = " + name + " password = " + password);
//name = hjc password = 85276573
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
/*
使用ClassLoader加载配置文件
*/
@Test
public void test03(){
Properties pros = new Properties();
//获取类加载器
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
InputStream is = null;
try {
//获取流
is = classLoader.getResourceAsStream("jdbc.properties");//默认的相对路径是当前src下
pros.load(is);
String name = pros.getProperty("name");
String password = pros.getProperty("password");
System.out.println("name = " + name + " password = " + password);
//name = hdy password = 85276573
} catch (IOException e) {
e.printStackTrace();
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}说明 : getResourceAsStream() 默认的相对路径是当前module的src下。
四、创建运行时类的对象
通过反射创建对应的运行时类的对象。
newInstance() : 调用此方法，创建对应运行时类的对象，内部调用了空参构造器
要想此方法正常的创建运行时类的对象，要求 :
-
运行时类必须提供空参的构造器
-
空参的构造器的访问权限要够。通常，设置为public。
@Test
public void test01() throws InstantiationException, IllegalAccessException {
Class<Person> clazz = Person.class;
/*
newInstance() : 调用此方法，创建对应运行时类的对象，内部调用了空参构造器
*/
Person p = clazz.newInstance();
System.out.println(p);//Person{name='null', age=0}
}在JavaBean中要求提供一个public的空参构造器，原因 :
-
便于通过反射，创建运行时类的对象
-
便于子类继承此运行时类时，默认调用super()，保证父类有此构造器。
1. 体会反射的动态性
无法在编译期间看出要创建什么类，通过从键盘上输入的类名来动态的创建类，所以用到反射技术来创建运行时类的对象。
/*
体会反射的动态性
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String classPath = sc.next();//输入 : java.lang.Date
Object instance = getInstance(classPath);
System.out.println(instance);//Mon Sep 05 15:27:26 CST 2022
}
/**
* @Description 创建一个指定类的对象
* @author hjc
* @param classPath 指定类的全名
* @returnType java.lang.Object
*/
public static Object getInstance(String classPath){
Object obj = null;
try {
Class<?> clazz = Class.forName(classPath);
obj = clazz.newInstance();
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
e.printStackTrace();
}
return obj;
}五、获取运行时类的完整结构
1. 创建一个丰富的自定义类
首先创建一个丰富的Person类结构 :
public class Creature<T> implements Serializable {
private char gender;
public double weight;
private void breath(){
System.out.println("生物呼吸");
}
public void eat(){
System.out.println("生物吃东西");
}
}
@MyAnnotation(value="hi")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{
private String name;
int age;
public int id;
public Person(){}
@MyAnnotation(value="abc")
private Person(String name){
this.name = name;
}
Person(String name,int age){
this.name = name;
this.age = age;
}
@MyAnnotation
private String show(String nation){
System.out.println("我的国籍是：" + nation);
return nation;
}
public String display(String interests,int age) throws NullPointerException,ClassCastException{
return interests + age;
}
@Override
public void info() {
System.out.println("我是一个人");
}
@Override
public int compareTo(String o) {
return 0;
}
private static void showDesc(){
System.out.println("我是一个可爱的人");
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
", id=" + id +
'}';
}
}2. 获取运行时类的属性结构
/*
获取当前运行时类的属性结构
*/
public class FiledTest {
@Test
public void test01() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
//获取运行时类的所有属性
//getFields() : 获取当前运行时类及其父类中声明为public访问权限的属性
Field[] fields = clazz.getFields();
for (Field field : fields){
System.out.println(field);
}
//public int com.atguigu.java.Person.id
//public double com.atguigu.java.Creature.weight
//getDeclaredFields() : 获取当前运行时类中声明的所有属性(不包含父类的)
Field[] declaredFields = clazz.getDeclaredFields();
for (Field field : declaredFields){
System.out.println(field);
}
//private java.lang.String com.atguigu.java.Person.name
//int com.atguigu.java.Person.age
//public int com.atguigu.java.Person.id
}
/*
获取属性的内部结构
权限修饰符 数据类型 变量名
*/
@Test
public void test0() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
Field[] declaredFields = clazz.getDeclaredFields();
for (Field field : declaredFields){
//权限修饰符
int modifier = field.getModifiers();
System.out.print(Modifier.toString(modifier) + "\t");
//数据类型
Class<?> type = field.getType();
System.out.print(type.getName() + "\t");
//变量名
String name = field.getName();
System.out.println(name);
}
//private java.lang.String name
// int age
//public int id
}
}3. 获取运行时类的方法结构
/*
获取方法的内部结构
@Xxx(注解)
权限修饰符 返回值 方法名 (参数类型1 形参名1, ...) throws XxxException{}
*/
@Test
public void test02() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods){
//获取方法声明的注解
Annotation[] annos = method.getAnnotations();//只获取RUNTIME的注解
for (Annotation a : annos){
System.out.println(a);
}
//@com.atguigu.java.MyAnnotation(value=hello)
//获取权限修饰符
int modifier = method.getModifiers();
System.out.print(Modifier.toString(modifier) + "\t");
//获取返回值类型
Class<?> returnType = method.getReturnType();
System.out.print(returnType.getName() + "\t");
//获取方法名
String name = method.getName();
System.out.print(name);
System.out.print("(");
//获取形参列表
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes != null && parameterTypes.length != 0){
for (int i = 0; i < parameterTypes.length; i++) {
if (i == parameterTypes.length-1){
System.out.print(parameterTypes[i].getName() + " args_" + i);
break;
}
System.out.print(parameterTypes[i].getName() + " args_" + i + ", ");
}
}
System.out.print(")");
//获取异常
Class<?>[] exceptionTypes = method.getExceptionTypes();
if (exceptionTypes != null && exceptionTypes.length != 0) {
System.out.print(" throws ");
for (int i = 0; i < exceptionTypes.length; i++) {
if (i == exceptionTypes.length-1){
System.out.print(exceptionTypes[i].getName());
break;
}
System.out.print(exceptionTypes[i].getName() + ",");
}
}
System.out.println();
}
}
//public java.lang.String toString()
//public int compareTo(java.lang.String args_0)
//public volatile int compareTo(java.lang.Object args_0)
//public void info()
//public java.lang.String display(java.lang.String args_0, int args_1)
// throws java.lang.NullPointerException,java.lang.ClassCastException
//@com.atguigu.java.MyAnnotation(value=hello)
//private java.lang.String show(java.lang.String args_0)
//private static void showDesc()4. 获取运行时类的构造器结构
public class ConstructorTest {
/*
获取运行时类的构造器结构
*/
@Test
public void test01() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
//getConstructors() : 获取运行时类声明为public的构造器
Constructor<?>[] constructors = clazz.getConstructors();
for (Constructor<?> cons : constructors){
System.out.println(cons);
}
//public com.atguigu.java.Person()
System.out.println();
getDeclaredConstructors() : 获取运行时类声明的所有的构造器
Constructor<?>[] declaredConstructors = clazz.getDeclaredConstructors();
for (Constructor<?> cons : declaredConstructors){
System.out.println(cons);
}
//com.atguigu.java.Person(java.lang.String,int)
//private com.atguigu.java.Person(java.lang.String)
//public com.atguigu.java.Person()
}
}5. 获取运行时类的父类
/*
获取运行时类的父类
*/
@Test
public void test01() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
Class<?> superClazz = clazz.getSuperclass();
System.out.println(superClazz);//class com.atguigu.java.Creature
}
/*
获取运行时类的带泛型的父类
*/
@Test
public void test02() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
//Type是一个接口 Class实现了这个接口
Type genericSuperclass = clazz.getGenericSuperclass();
System.out.println(genericSuperclass);//com.atguigu.java.Creature<java.lang.String>
//获取运行时类的带泛型的父类的泛型
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
//获取泛型类型
Type[] actualTypeArguments = paramType.getActualTypeArguments();
System.out.println(actualTypeArguments[0].getTypeName());//java.lang.String
System.out.println(((Class<?>) actualTypeArguments[0]).getName());//java.lang.String
}6. 获取运行时类实现的接口
/*
获取运行时类实现的接口
*/
@Test
public void test03() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
Class<?>[] interfaces = clazz.getInterfaces();
for (Class<?> inter : interfaces){
System.out.println(inter);
}
//interface java.lang.Comparable
//interface com.atguigu.java.MyInterface
System.out.println();
//拿到运行时类父类实现的接口
Class<?>[] ins = clazz.getSuperclass().getInterfaces();
for (Class<?> inter : ins){
System.out.println(inter);
}
//interface java.io.Serializable
}7. 获取运行时类所在的包
/*
获取运行时类所在的包
*/
@Test
public void test04() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
Package pa = clazz.getPackage();
System.out.println(pa);//package com.atguigu.java
}8. 获取运行时类声明的注解
//获取运行时类声明的注解
@Test
public void test05() throws ClassNotFoundException {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
Annotation[] annos = clazz.getAnnotations();
for (Annotation annotation : annos){
System.out.println(annotation);
}
//@com.atguigu.java.MyAnnotation(value=hi)
}六、调用运行时类的指定结构
步骤 :
-
获取到这个结构
-
保证这个结构可以访问
-
调用相关方法来运行
1. 调用运行时类中的指定属性
/*
不理想 只能获取public的属性
*/
@Test
public void testField() throws Exception {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
//创建运行时类对象
Object obj = clazz.newInstance();
Person p = (Person) obj;
//获取指定的属性 : 要求运行时类中属性声明为public的
//通常不采用此方法
Field id = clazz.getField("id");
//设置当前属性的值
//set(Object o, Object value) : 参数1 指明设置哪个对象的属性 参数2 将此属性值设置为多少
id.set(p, 1001);
//获取当前对象属性的值
//get(Object obj) : 参数1 获取哪个对象的当前属性值
Object value = id.get(p);
System.out.println(value);//1001
}
/*
如何操作运行时类中指定的属性(规范的)
*/
@Test
public void testField1() throws Exception {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
//创建运行时类对象
Object obj = clazz.newInstance();
Person p = (Person) obj;
//获取指定的属性 :
//getDeclaredField(String fieldName) : 获取运行时类中指定变量名的属性
Field name = clazz.getDeclaredField("name");
//暴力进入 保证当前属性是可访问的
name.setAccessible(true);
//设置当前属性的值
//set(Object o, Object value) : 参数1 指明设置哪个对象的属性 参数2 将此属性值设置为多少
name.set(p, "Tom");
//获取当前对象属性的值
//get(Object obj) : 参数1 获取哪个对象的当前属性值
Object value = name.get(p);
System.out.println(value);//Tom
}2. 调用运行时类中的指定方法
/*
如何操作运行时类中指定的方法(规范的)
*/
@Test
public void testMethod() throws Exception {
Class<?> clazz = Class.forName("com.atguigu.java.Person");
//创建运行时类对象
Object obj = clazz.newInstance();
Person p = (Person) obj;
//获取指定的方法 :
//getDeclaredMethod(String methodName, Class<?>... parameterTypes) :
// 获取运行时类中指定变量名的方法 参数1 方法名 参数2... 方法的参数类型
Method show = clazz.getDeclaredMethod("show", String.class);
//暴力进入 保证当前方法是可访问的
show.setAccessible(true);
//invoke() : 参数1 方法的调用者 参数2 给方法形参赋值的实参
//invoke方法的返回值 即为对应类中调用的方法的返回值
Object nation = show.invoke(p, "CHN");//我的国籍是：CHN
System.out.println((String) nation);//CHN
System.out.println("************如何调用静态方法***********");
Method showDesc = clazz.getDeclaredMethod("showDesc");
showDesc.setAccessible(true);
Object returnValue = showDesc.invoke(Person.class);//静态方法调用参数填当前类(填null也可以)
//我是一个可爱的人
System.out.println(returnValue);//如果对应类中调用的方法没有返回值的话返回null
}3. 调用运行时类中的指定构造器
/*
如何调用运行时类中指定的构造器
*/
@Test
public void test() throws Exception{
Class<?> clazz = Class.forName("com.atguigu.java.Person");
//调用 private Person(String name) 构造器
//getDeclaredConstructor() : 参数 : 指明构造器的形参列表
Constructor<?> cons = clazz.getDeclaredConstructor(String.class);
//保证此构造器时可访问的
cons.setAccessible(true);
//创建运行时类的对象
Person person = (Person) cons.newInstance("Tom");
System.out.println(person);//Person{name='Tom', age=0, id=0}
}七、反射的应用 : 动态代理
代理设计模式的原理:
使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
之前讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。
1. 静态代理
静态代理举例 : 创建多线程方式二，实现Runnable接口
class MyThread implements Runnable {} //被代理类
class Thread implements Runnable {} //代理类
public static void main(String[] args){
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);
thread.start();//启动线程 调用内部的run方法
}静态代理举例 :
/*
静态代理举例
特点 : 代理类和代理对象在编译期间就确定下来
*/
interface ClothFactory{
void produceCloth();
}
//代理类
class ProxyClothFactory implements ClothFactory{
private ClothFactory factory;//用被代理类对象进行实例化
public ProxyClothFactory(ClothFactory factory){
this.factory = factory;
}
@Override
public void produceCloth() {
System.out.println("代理工厂做一些准备工作");
factory.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) {
//创建被代理类的对象
ClothFactory nike = new NikeClothFactory();
//创建代理类的对象
ClothFactory proxyClothFactory = new ProxyClothFactory(nike);
proxyClothFactory.produceCloth();
//代理工厂做一些准备工作
//Nike工厂生产一批运动服
//代理工厂做一些收尾工作
}
}2. 动态代理
例子 : 有两个明星，需要经纪人来帮其处理事务，在程序运行过程中，不清楚需要用哪个明星来表演唱歌，需要用户自行输入。使用动态代理，来动态的创建明星经纪人来帮助明星处理事务。
首先有两个接口 : CanSing和CanPerform代表一个明星的能力
public interface CanSing {
void sing(String name);
}
public interface CanPerform {
void perform(String name);
}声明一个Actor接口，继承上述两个接口 :
public interface Actor extends CanSing, CanPerform{
void eat();
}创建两个明星类，Star1和Star2代表两个不同的明星 :
public class Star1 implements Actor{
private String name;
private int age;
public Star1(){}
public Star1(String name, int age){
this.age = age;
this.name = name;
}
@Override
public void perform(String name) {
System.out.println("Star1 perform " + name);
}
@Override
public void sing(String name) {
System.out.println("Star1 sing " + name);
}
@Override
public void eat() {
System.out.println("Star1 is eating...");
}
}
public class Star2 implements Actor{
private String name;
private int age;
public Star2(){}
public Star2(String name, int age){
this.age = age;
this.name = name;
}
@Override
public void perform(String name) {
System.out.println("Star2 perform " + name);
}
@Override
public void sing(String name) {
System.out.println("Star2 sing" + name);
}
@Override
public void eat() {
System.out.println("Star2 is eating");
}
}创建动态生成代理人的工厂类 :
/*
要想实现动态代理所要解决的问题?
问题一 : 如何根据加载到内存中的被代理类 动态的创建一个代理类及其对象
问题二 : 当通过代理类的对象调用方法时，如何动态的去调用被代理类中的同名方法
*/
public class ProxyFactory {
//调用此方法返回一个代理类的对象 解决问题一
public static Object getProxyInstance(Object obj){//obj 创建的被代理类的对象
//创建一个方法的调用者(InvocationHandler接口实现类) 解决问题二
MyInvocationHandler handler = new MyInvocationHandler();
handler.bind(obj);
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
}
}
class MyInvocationHandler implements InvocationHandler{
private Object obj;//需要使用被代理类的对象进行赋值
public MyInvocationHandler(){}
public void bind(Object obj){
this.obj = obj;
}
//当我们通过代理类的对象，调用方法a时，就会自动调用如下的方法 : invoke()
//将被代理类要执行的方法a的功能就声明在invoke()中
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//method : 即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
//obj : 被代理类的对象
//对方法信息进行拦截 可根据不同的方法采取不同的动作
if ("sing".equals(method.getName()) || "perform".equals(method.getName())) {
System.out.println("---------经纪人洽谈---------");
}
Object returnValue = method.invoke(obj, args);
if ("sing".equals(method.getName()) || "perform".equals(method.getName())) {
System.out.println("---------经纪人收尾---------");
}
//上述方法的返回值就作为当前类中invoke方法的返回值
return returnValue;
}
}动态代理测试 : 从键盘输入需要表演唱歌的明星
public class ProxyTest {
public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
//输入被代理类名
StringBuilder path = new StringBuilder("com.atguigu.proxy.");
String className = sc.next();
path.append(className);
//获取运行时类的Class对象
Class<?> clazz = Class.forName(path.toString());
//创建被代理类对象
Actor actor = (Actor) clazz.newInstance();
//获得代理对象 --> 体现了在运行时动态创建代理类对象
Actor proxyActor = (Actor) ProxyFactory.getProxyInstance(actor);
//执行方法 当通过代理类对象调用方法时，会自动调用被代理类中同名的方法
proxyActor.sing("BangBangBang");
proxyActor.eat();
proxyActor.perform("Big Mouth");
}
}运行结果 :
输入 :
Star1
输出 :
---------经纪人洽谈---------
Star1 sing BangBangBang
---------经纪人收尾---------
Star1 is eating...
---------经纪人洽谈---------
Star1 perform Big Mouth
---------经纪人收尾---------
Process finished with exit code 0
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
