这篇博客详细介绍了Java的反射机制，包括动态语言与静态语言的区别、反射的使用场景、Class类、类加载器的理解、创建运行时类对象、获取类的完整结构以及调用指定结构的方法。此外，还探讨了Java的动态代理，从静态代理到动态代理的实现步骤，并将其与AOP结合，展示了动态代理在实际开发中的应用。
目录
3.4 使用ClassLoader加载配置文件（Properties）
01 Java反射机制概述
- Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
- 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
1.1 动态语言
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以
被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是 在运
行时代码可以根据某些条件改变自身结构 。
主要动态语言： Object C 、 C# 、 JavaScript 、 PHP 、 Python 、 Erlang
1.2 静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程的时候更加灵活！
Java反射机制提供的功能
- 在运行时判断任意一个对象所属的类
- 在运行时构造任意一个类的对象
- 在运行时判断任意一个类所具有的成员变量和方法
- 在运行时获取泛型信息
- 在运行时调用任意一个对象的成员变量和方法
- 在运行时处理注解
- 生成动态代理
反射相关的主要API
- java.lang.Class:代表一个类
- java.lang.reflect.Method:代表类的方法
- java.lang.reflect.Field:代表类的成员变量
- java.lang.reflect.Constructor:代表类的构造器
1.3 代码实例
Person类
public 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 string){
return string;
}
}反射之前测试类
import org.junit.Test;
public class ReflectionTest {
//反射之前，对于Person的操作
@Test
public void test(){
//1.创建类的对象
Person p1 = new Person("Tom",16);
//2.调用对象,调用其内部的属性和方法
p1.age = 15;
System.out.println(p1.toString());
p1.show();
//在Person类的外部，不可以通过Person类的对象调用其内部私有（private）的结构。
//比如：name、showNation以及私有的构造器。
}
}
1.3.1 利用反射实现类的调用
//有了反射之后，对于Person类的操作
@Test
public void test1() throws Exception {
Class cla = Person.class; //Person.class 作为Class类的实例
// 1.通过反射，创建Person类对象
Constructor cons = cla.getConstructor(String.class,int.class);
Object obj = cons.newInstance("TOM",12);
Person p = (Person) obj;
System.out.println(obj.toString());
// 2. 通过反射的调用对象指定属性和方法
Field age = cla.getDeclaredField("age");
age.set(p,10);
System.out.println(p.toString());
// 调用方法
Method show = cla.getDeclaredMethod("show");
show.invoke(p); // 调用p类的show方法
}1.3.2 调用私有属性和方法
@Test
public void test1() throws Exception {
Class cla = Person.class; //Person.class 作为Class类的实例
// 1.通过反射，创建Person类对象
// 3. 通过反射调用对象的私有方法和属性
Constructor cons1 = cla.getDeclaredConstructor(String.class);
cons1.setAccessible(true);
Person p1 = (Person) cons1.newInstance("Jerry" );
System.out.println(p1.toString());//Person{name='Jerry', age=0}
// 调用私有属性
Field name = cla.getDeclaredField("name");
name.setAccessible(true);
name.set(p1,"Tom");
System.out.println(p1);//Person{name='Tom', age=0}
// 调用带参数的私有方法
Method showNation = cla.getDeclaredMethod("showNation",String.class) ;
showNation.setAccessible(true);
String str = (String) showNation.invoke(p1,"中国"); // 相当于p1.showNation("中国")
System.out.println(str);疑问
1. 有了反射之后，封装还有什么意义？ 不矛盾，反射解决能不能调用，封装解决是否建议调用的问题
2. 通过直接new对象或反射的方式都可以调用公共结构，开发中使用？ 建议：用直接new的方式， 什么时候用反射的方式（动态性）： */
02 理解Class类并获取Class实例
/**
* 关于 java.lang.class
* 1. 类的加载过程：
* 程序经过javac.exe命令后，会生成一个或多个字节码文件（.class）结尾，接着我们
* 使用java.exe命令对某个字节码文件进行解释运行，相当于将某个字节码文件加载到内存中
* 此过程成为类的加载。
*
* 加载到内存中的类，我们就成为 运行时类，此运行时类，就作为Class的一个实例。
*
* 2.换句话说，Class实例对应着一个 运行时类，2.1 Class类常用方法
2.2 获取Class类实例的四种方法
3.且运行时类加载到内存后，会存放在缓存区，在此时间之内可以通过不同方式获取此运行时类。
cla == cla1 == cla3
@Test
// 获取Class实例的方式（前三种掌握）
public void test3() throws ClassNotFoundException {
// 方式一: 调用运行时类的属性.class
Class cla = Person.class;
System.out.println(cla); //class Person
// 方式二： 通过运行时类的对象
Person p = new Person();
Class cla1 = p.getClass();
System.out.println(cla1); //class Person
// 方式三： 调用Class的静态方法： forName(String classPath),用的最多！！
Class cla3 = Class.forName("Person"); // 这里要写全
System.out.println(cla3);//class Person
Class cla4 = Class.forName("java.lang.String");
System.out.println(cla4);//class java.lang.String
// 方式四（类的加载器）
ClassLoader classLoader = ReflectionTest.class.getClassLoader();
Class cla5 = classLoader.loadClass("Person");
System.out.println(cla5);
System.out.println(cla == cla5); //true
System.out.println(cla == cla1); //true
}2.3 哪些类型可以有Class对象
4.Class相当于加载到内存中的结构，
class，interface，数组，enum 枚举；annotation 注解， 基本数据类型， void 都算import org.junit.Test;
import java.lang.annotation.ElementType;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
@Test
public void test4() {
Class s1 = Object.class;
Class s2 = Comparable.class;
Class s3 = String[].class;
Class s4 = int[][].class;
Class s5 = ElementType.class;
Class s6 = Override.class;
Class s7 = int.class;
Class s8 = void.class;
Class s9 = Class.class;
int[] a = new int[10];
int[] b = new int[100];
Class s10 = a.getClass();
Class s11 = b.getClass();
// 只要数组的元素类型与维度一样，就是同一个Class
System.out.println(s10 == s11); (true: int型一维数组)
}
03 类的加载与ClassLoader的理解
3.1 类的加载过程（了解）
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。
加载
将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个 Class 对象。这个加载的过程需要类加载器参与
链接
- 链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。
- 验证：确保加载的类信息符合 JVM 规范，例如：以 cafe 开头，没有安全方面的问题
- 准备：正式为类变量（ static ）分配内存并 设置类变量默认初始值 的阶段，这些内存都将在方法区中进行 分配 。
- 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的 过程 。
初始化
- 执行 类构造器 <clinit> 方法的过程。 类构造器 <clinit>() 方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。 （类构造器是构造类信息的，不是构造该类对象的构造器 。
- 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
- 虚拟机会保证一个类的 <clinit> 方法在多线程环境中被正确加锁和 同步 。
3.2 什么时候会发生类初始化(了解)
- 类的主动引用（一定会发生类的初始化）
- 当虚拟机启动，先初始化main方法所在的类
- new一个类的对象
- 调用类的静态成员（除了final常量）和静态方法
- 使用java.lang.reflect包的方法对类进行反射调用
- 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类
- 类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化
- 当通过子类引用父类的静态变量，不会导致子类初始化
- 通过数组定义类引用，不会触发此类的初始化
- 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常量池中了）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化
A 和Father类
3.3 类加载器（了解）
- 类加载器的作用：
- 类加载的作用：将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口。
- 类缓存：标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
- 类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。
Test
public class ClassLoaderTest {
@Test
public void test(){
// 对于自定义类，使用系统类加载器进行加载
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
System.out.println(classLoader);
// 调用系统类加载器的getParent(),获取扩展类加载器
ClassLoader classLoader1 = classLoader.getParent();
System.out.println(classLoader1);
// 调用扩展类加载器的getParent(),无法获取引导类加载器
ClassLoader classLoader2 = classLoader1.getParent();
System.out.println(classLoader2); //null
ClassLoader classLoader3 = String.class.getClassLoader();
System.out.println(classLoader3);//null 引导类加载器
}3.4 使用ClassLoader加载配置文件（Properties）
@Test
/*
Properties: 用来读取配置文件，掌握
*/
public void test2() throws IOException {
Properties properties = new Properties();
// 此时文件默认在当前module下
// 读取配置文件方式一
// FileInputStream fis = new FileInputStream("jdbc");
//properties.load(fis);
// 读取配置文件方式二： 用系统加载器classLoader读取
ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();
InputStream fis = classLoader.getResourceAsStream("jdbc"); // 此时读取文件默认位置在src下
properties.load(fis);
String user = properties.getProperty("user");
String password = properties.getProperty("password");
System.out.println("user = " + user + " password = " + password);
}04 创建运行时类对象
4.1 newInstance创建运行时类
/**
* 通过反射创建对应的运行时类对象
* 1.运行时类必须提供空参构造器
* 2.空参构造器的访问权限得够： 通常为Public
*
* 在javabean中要求提供一个public佛如空参构造器，原因：
* 1.便于通过反射，创建运行时类对象
* 2.便于子类继承此运行时类，默认调用super()时，保证父类有此构造器
*/NewInstanceTest
@Test
public void test() throws NoSuchMethodException, InstantiationException, IllegalAccessException {
Class<Person> cla = Person.class;
Object obj = cla.newInstance();
System.out.println(obj); //空参构造器
}4.2 体会反射的动态性
@Test
// 体会反射创造对象的动态性
public void test1() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
int num = new Random().nextInt(3); // 0 1 2
String classPath = "";
switch (num){
case 0:
classPath = "java.util.Date";
break;
case 1:
classPath = "java.sql.Date"; //没有空参构造器，不能这么用，报异常
break;
case 2:
classPath = "Person";
break;
}
Object obj = getInstance(classPath); // 不能确定会造什么对象，运行时才确定造哪个对象
System.out.println(obj);
}
05 获取运行时类完整结构
5.1 提供结构丰富的类
Person类
@MyAnnotation(value="java")
public class Person extends Creature<String> implements Comparable<String>,MyInterface{
private String name;
int age;
public int id;
public Person() {
}
@MyAnnotation(value="C++")
Person(String name){
this.name = name;
}
private Person(String name,int age){
this.name = name;
this.age = age;
}
@MyAnnotation
private String show(String nation){
System.out.println("我来自" + nation);
return nation;
}
@Override
public void info() {
System.out.println("今天天气不错");
}
public String display(String play){
return play;
}
@Override
public int compareTo(String o) {
return 0;
}
}
2、Creature类
import java.io.Serializable;
public abstract class Creature <T> implements Serializable {
private char gender;
public double weight;
private void breath(){
System.out.println("呼吸");
}
public void eat(){
System.out.println("吃饭");
}
}
3、MyInterface
public interface MyInterface {
void info();
}
4、MyAnnotation
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
String value() default "hello world";
}
5.2 获取运行时类内部属性
获取当前运行时类的属性结构
import github2.Person;
import org.junit.Test;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
/**
* 获取当前运行时类的属性结构
*/
public class FieldTest {
@Test
public void test(){
Class clazz = Person.class;
//获取属性结构
//getFields():获取当前运行时类及其父类中声明为public访问权限的属性
Field[] fields = clazz.getFields();
for(Field f : fields){
System.out.println(f);
}
System.out.println("*************");
//getDeclaredFields():获取当前运行时类中声明的所有属性。（不包含父类中声明的属性）
Field[] declaredFields = clazz.getDeclaredFields();
for(Field f : declaredFields){
System.out.println(f);
}
}
}
权限修饰符 数据类型 变量名
@Test
// 权限修饰符 数据类型 变量名
public void test2(){
Class clazz = Person.class;
Field[] declaredFields = clazz.getDeclaredFields();
for (Field f : declaredFields){
// 权限修饰符
int modifiers = f.getModifiers();
System.out.println(modifiers); // 2 1 将修饰符类型定义为 int型数据
System.out.println(Modifier.toString(modifiers)); // private public
// 变量数据类型
Class type = f.getType();
System.out.println(type.getName());
// 变量名
String fName = f.getName();
System.out.println(fName);
}
}5.3 获取运行时类的方法结构
package github3;
import github2.Person;
import org.junit.Test;
import java.lang.reflect.Method;
/**
* 获取运行时类的方法结构
*/
public class MythodTest {
@Test
public void test(){
Class clazz = Person.class;
//getMethods():获取当前运行时类及其所有父类中声明为public权限的方法
Method[] methods = clazz.getMethods();
for(Method m : methods){
System.out.println(m + "****");
}
System.out.println("***********");
//getDeclaredMethods():获取当前运行时类中声明的所有方法。（不包含父类中声明的方法）
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
System.out.println(m);
}
}
}
获取方法的内部结构
@Test
// 方法结构： 注解 权限修饰符， 返回值类型 方法名 throws
public void test4(){
Class clazz = Person.class;
Method[] declaredMethods = clazz.getDeclaredMethods();
for(Method m : declaredMethods){
// 关于注解
Annotation[] annotations = m.getAnnotations(); // 数组，需要的话可以遍历
// 权限修饰符
System.out.println(Modifier.toString(m.getModifiers()));
// 返回值类型
System.out.println(m.getReturnType());
//方法名
System.out.println(m.getName());
// 形参列表
Class<?>[] parameterTypes = m.getParameterTypes();
if (!(parameterTypes == null && parameterTypes.length == 0)){
}
}
}5.4 获取运行时类的构造器结构
public class OtherTest {
/**
* 获取构造器的结构
*/
@Test
public void test(){
Class clazz = Person.class;
//getConstructors():获取当前运行时类中声明为public的构造器，没有父类构造器
Constructor[] constructors = clazz.getConstructors();
for(Constructor c : constructors){
System.out.println(c);
}
System.out.println("************************");
//getDeclaredConstructors():获取当前运行时类中声明的所有的构造器
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for(Constructor c : declaredConstructors){
System.out.println(c);
}
}
}
5.5 获取运行时类的父类及父类的泛型
public class OtherTest {
/**
* 获取运行时类的父类
*/
@Test
public void test2(){
Class clazz = Person.class;
Class superclass = clazz.getSuperclass();
System.out.println(superclass);
}
/**
* 获取运行时类的带泛型的父类
*/
@Test
public void test3(){
Class clazz = Person.class;
Type genericSuperclass = clazz.getGenericSuperclass();
System.out.println(genericSuperclass);
}
/**
* 获取运行时类的带泛型的父类的泛型
*/
@Test
public void test4(){
Class clazz = Person.class;
Type genericSuperclass = clazz.getGenericSuperclass();
ParameterizedType paramType = (ParameterizedType) genericSuperclass;
//获取泛型类型
Type[] actualTypeArguments = paramType.getActualTypeArguments();
// System.out.println(actualTypeArguments[0].getTypeName());
System.out.println(((Class)actualTypeArguments[0]).getName());
}
}
5.6 获取运行时类的接口、所在包、注解等
public class OtherTest {
/**
* 获取运行时类实现的接口
*/
@Test
public void test5(){
Class clazz = Person.class;
Class[] interfaces = clazz.getInterfaces();
for(Class c : interfaces){
System.out.println(c);
}
System.out.println("***************");
//获取运行时类的父类实现的接口
Class[] interfaces1 = clazz.getSuperclass().getInterfaces();
for(Class c : interfaces1){
System.out.println(c);
}
}
/**
* 获取运行时类所在的包
*/
@Test
public void test6(){
Class clazz = Person.class;
Package pack = clazz.getPackage();
System.out.println(pack);
}
/**
* 获取运行时类声明的注解
*/
@Test
public void test7(){
Class clazz = Person.class;
Annotation[] annotations = clazz.getAnnotations();
for(Annotation annos : annotations){
System.out.println(annos);
}
}
}
06 调用运行时类指定结构
6.1 获取运行时类指定属性
获取指定属性
@Test
/*
调用运行时类的指定结构： 属性 方法 构造器
*/
public void testField() throws NoSuchFieldException, InstantiationException, IllegalAccessException {
Class clazz = Person.class;
// 获取指定属性
Person p = (Person) clazz.newInstance();
Field age = clazz.getField("age"); // 要求属性设置为public
// 设置当前值属性： set(),参数1：指明设置哪个对象的属性 参数2 将此属性值设置为多少
age.set(p,1001);
/*
获取当前属性的值
get(): 参数1，获取哪个对象的当前属性值
*/
int pAge = (int) age.get(p);
System.out.println(pAge);
}获取私有属性
/**
* 如何操作运行时类中的指定的属性 -- 需要掌握
*/
@Test
public void testField1() throws Exception {
Class clazz = Person.class;
//创建运行时类的对象
Person p = (Person) clazz.newInstance();
//1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
Field name = clazz.getDeclaredField("name"); // (private)
//2.保证当前属性是可访问的
name.setAccessible(true);
//3.获取、设置指定对象的此属性值
name.set(p,"Jam");
System.out.println(name.get(p));
}6.2 获取运行时类指定方法
package github3;
import github2.Person;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 调用运行时类中指定的结构：属性、方法、构造器
*/
public class ReflectionTest {
/**
* 如何操作运行时类中的指定的方法 -- 需要掌握
*/
@Test
public void testMethod() throws Exception {
Class clazz = Person.class;
//创建运行时类的对象
Person p = (Person) clazz.newInstance();
//1.获取指定的某个方法
//getDeclaredMethod():参数1 ：指明获取的方法的名称 参数2：指明获取的方法的形参列表
Method show = clazz.getDeclaredMethod("show", String.class);
//2.保证当前方法是可访问的
show.setAccessible(true);
//3.调用方法的invoke():参数1：方法的调用者 参数2：给方法形参赋值的实参
//invoke()的返回值即为对应类中调用的方法的返回值。
Object returnValue = show.invoke(p,"nation"); //String nation = p.show("nation");
System.out.println(returnValue);
System.out.println("***********如何调用静态方法***********");
// private static void showDesc()
Method showDesc = clazz.getDeclaredMethod("showDown");
showDesc.setAccessible(true);
//如果调用的运行时类中的方法没有返回值，则此invoke()返回null
// Object returnVal = showDesc.invoke(null);
Object returnVal = showDesc.invoke(Person.class);
System.out.println(returnVal);//null
}
}
6.3 调用运行时类指定构造器
import github2.Person;
import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
* 调用运行时类中指定的结构：属性、方法、构造器
*/
public class ReflectionTest {
/**
* 如何调用运行时类中的指定的构造器
*/
@Test
public void testConstructor() throws Exception {
Class clazz = Person.class;
//private Person(String name)
//1.获取指定的构造器
//getDeclaredConstructor():参数：指明构造器的参数列表
Constructor constructor = clazz.getDeclaredConstructor(String.class);
//2.保证此构造器是可访问的
constructor.setAccessible(true);
//3.调用此构造器创建运行时类的对象
Person per = (Person) constructor.newInstance("Tom");
System.out.println(per);
}
}
6.4 关于setAccessible
- Method 和 Field 、 Constructor 对象都有 setAccessible() 方法 。
- setAccessible 启动和禁用访问安全检查的开关 。
- 参数 值 为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查 。
- 提高反射的效率，如果代码中必须用反射而该句代码需要频繁的被调用那么请设置为true。
- 使得原本无法访问的私有成员也可以访问
- 参数值为 false 则指示反射的对象应该实施 Java 语言访问检查 。
07 动态代理
7.1 代理模式概述
代理设计模式的原理:
使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。
静态代理
之前为大家讲解过代理机制的操作，属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。
动态代理
动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
- 动态代理使用场合:
- 调试
- 远程方法调用
动态代理相比于静态代理的优点：
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法
7.2 静态代理举例
接口
/*
静态代举例
*/
// 接口
interface ClothFactory {
void produceCloth();
}代理类
// 代理类
class ProxyClothFactory implements ClothFactory{
// 声明属性: 接口类型
private ClothFactory factory; // 用被代理类对象进行实例化
//构造器： 传入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 JingtaiDaili {
public static void main(String[] args){
// 先造一个被代理类对象
NikeClothFactory nike = new NikeClothFactory();
//新建一个代理类对象
ProxyClothFactory proxyClothFactory = new ProxyClothFactory(nike);
// 代理类对象调用被代理类方法(代理类和被代理类都声明了这个方法)
proxyClothFactory.produceCloth();
}
}7.3 动态代理
7.3.1 动态代理步骤
7.3.2 动态代理举例
动态代理举例：接口得有， 被代理类得有只是代理类改成动态
接口
interface Human{
String getBelief();
void eat(String food);
}被代理类
// 被代理类
class superMan implements Human{
@Override
public String getBelief() {
return "i can fly";
}
@Override
public void eat(String food) {
System.out.println("我喜欢吃" + food);
}
}/* 动态代理，要解决的问题 问题一：如何根据内存中的被代理类，动态创建一个代理类及其对象 问题二：当通过代理类对象调用方法时，如何动态的调用被代理类中的同名方法 */
// 生产代理类的工厂
class ProxyFactory{
// 通过调用此方法，返回一个代理类对象，解决问题1
public static Object getProxyInstance(Object obj){ // obj就是被代理类的对象
myInvocationHandler myInvocationHandler = new myInvocationHandler(); // 新建接口实现类的实例，作为第三个参数传入
myInvocationHandler.bind(obj);// 被代理类对象，通过Handler调用方法
Object o = Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), myInvocationHandler);
return o;
}
}
class myInvocationHandler implements InvocationHandler{
// 当我们通过代理类的对象，调用方法a时就会自动调用如下的方法
private Object obj; // 需要使用被代理类对象赋值
public void bind(Object obj){
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//体现问题二： 将被代理类要执行的方法a 声明在invoke中
Object returnValue = method.invoke(obj,args); // obj： 即为被代理类对象
// 上述方法的返回值 作为当前类中的invoke()的返回值
return returnValue;
}
}测试
public class ProxyTest {
public static void main(String[] args){
superMan superMan = new superMan(); //被代理类对象
// 此时proxyInstance 就是代理类对象
Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan); // 返回的是代理类,所以转换为Huamn
//
proxyInstance.getBelief();
proxyInstance.eat("火锅");
}7.4 动态代理与AOP
前面介绍的Proxy和InvocationHandler，很难看出这种动态代理的优势，下面介绍一种更实用的动态代理机制
使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理
这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理。
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class AOP {
}
interface Dog{
void info();
void run();
}
class HuntingDog implements Dog{
@Override
public void info() {
System.out.println("我是一只猎狗");
}
@Override
public void run() {
System.out.println("我跑的很快");
}
}
class DogUtil{
public void method1(){
System.out.println("模拟通用方法一");
}
public void method2(){
System.out.println("模拟通用方法二");
}
}
class myInvocationHandler1 implements InvocationHandler{
// 需要被代理的对象
private Object Target;
public void setTarget(Object Target){
this.Target = Target;
}
// 执行动态代理对象的方法时，被替换成如下的invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
DogUtil du = new DogUtil();
du.method1();
// 以Target作为主调执行method方法
Object result = method.invoke(Target,args);
du.method2();
return result;
}
}
class MyProxyFactory{
// 为指定Target生成动态代理对象
public static Object getProxy(Object target){
myInvocationHandler1 handler = new myInvocationHandler1();
handler.setTarget(target);
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),handler);
}
}
class test{
public static void main(String[] args){
//创建Target
Dog target = new HuntingDog();
//以指定的Target创建动态代理
Dog dog = (Dog) MyProxyFactory.getProxy(target);
dog.info();
dog.run();
}
}
7.5 动态代理步骤小结
- 构建接口并声明方法（human \ Dog）
interface Dog{
void info();
void run();
}- 声明被代理类实现接口，并重写方法(superMan\ HuntingDog)
class HuntingDog implements Dog{
@Override
public void info() {
System.out.println("我是一只猎狗");
}
@Override
public void run() {
System.out.println("我跑的很快");
}
}- 声明一个实现InvocationHandler接口的类----myInvocationHandler用于指定被代理类并实现被代理类方法
- 1. 设置属性: Object Target(被代理类)
- 2. public setTarget（Object Target）（设置被代理类）
- 3. 重写接口中的Invoke(Object Proxy, Method method, Object[] args)方法，
- 调用Target中需要调用的方法 method.invoke(Target, args)
class myInvocationHandler1 implements InvocationHandler{
// 需要被代理的对象
private Object Target;
public void setTarget(Object Target){
this.Target = Target;
}
// 执行动态代理对象的方法时，被替换成如下的invoke方法
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
DogUtil du = new DogUtil();
du.method1();
// 以Target作为主调执行method方法
Object result = method.invoke(Target,args);
du.method2();
return result;
}
}- 声明一个生产代理类的工厂class myProxyFactory（），设置方法getProxy（Target），为指定Target生成动态代理对象：
- 在方法中声明myInvocationHandeler 设置被代理类对象（Target）
- 返回Proxy类中的Proxy.newProxyInstance(ClassLoader classloader, Class<>[] interface, InvocationHandler h),得到一个代理类，返回类型为 (开始声明的接口)，以调用接口中的方法
class MyProxyFactory{
// 为指定Target生成动态代理对象
public static Object getProxy(Object target){
myInvocationHandler1 handler = new myInvocationHandler1();
handler.setTarget(target);
return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),handler);
}- 主程序中调用
- 先创建一个被代理类实例(Target)
- 将被代理类实例作为参数传递到MyProxyFactory.getProxy(Target),返回代理类实例
- 利用的代理类实例调用被代理类实例中的方法
class test{
public static void main(String[] args){
//创建Target
Dog target = new HuntingDog();
//以指定的Target创建动态代理
Dog dog = (Dog) MyProxyFactory.getProxy(target);
dog.info();
dog.run();
}
}
扫一扫
4361
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
