Spring源码前奏——Java反射

川长思鸟来 2023-03-01 10:11 6阅读 0赞

## 一、引言 ##

在日常的工作中，如果是做业务开发，反射机制这个知识点很少有机会用到，当然也就不会放在心上，但如果想去看一些框架的源码或者深入一点学习，如果对Java反射机制不是很了解，那就会一头雾水。

最近又想去再看一下Spring的源码，想起自己第一次看Spring源码时的那种痛苦，我觉得很有必要还是先学习一下反射。希望对你有所帮助~~

恩，书读百遍其义自见。

## 二、反射基础介绍 ##

###### 1、反射的原理 ######

Java反射机制就是程序在运行状态中，对于任意一个类，都能知道这个类的所有属性和方法，对于任意一个对象，都能调用它的任意方法和属性，这种动态获取信息以及动态调用对象的功能称为Java语言的反射机制。

粗略的理解：反射就是在程序运行时，能够动态的操作类的成员。

###### 2、反射的相关类 ######

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Class类</td> 
   <td>代表类和接口</td> 
  </tr> 
  <tr> 
   <td>Field类</td> 
   <td>代表类的属性</td> 
  </tr> 
  <tr> 
   <td>Method类</td> 
   <td>代表类的方法</td> 
  </tr> 
  <tr> 
   <td>Constructor类</td> 
   <td>代表类的构造方法</td> 
  </tr> 
 </tbody> 
</table>

###### 3、Class类 ######

Class类是描述类的类。能理解吗？

###### （1）、Class这个类中提供类很多的方法。 ######

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getClassLoader()</td> 
   <td>获得类的加载器</td> 
  </tr> 
  <tr> 
   <td>getClasses()</td> 
   <td>返回一个数组，数组中包含该类中所有公共（public）类和接口类的对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredClasses()</td> 
   <td>返回一个数组，数组中包含该类中所有（public、private、default）类和接口类的对象</td> 
  </tr> 
  <tr> 
   <td>forName(String className)</td> 
   <td>根据类名（包含包名）返回类的对象</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>获得类的完整路径名字(包含包名)</td> 
  </tr> 
  <tr> 
   <td>newInstance()</td> 
   <td>创建类的实例</td> 
  </tr> 
  <tr> 
   <td>getPackage()</td> 
   <td>获得类的包</td> 
  </tr> 
  <tr> 
   <td>getSimpleName()</td> 
   <td>获得类的名字</td> 
  </tr> 
  <tr> 
   <td>getSuperclass()</td> 
   <td>获得当前类继承的父类的名字</td> 
  </tr> 
  <tr> 
   <td>getInterfaces()</td> 
   <td>获得当前类实现的类或是接口</td> 
  </tr> 
  <tr> 
   <td>asSubclass(Class clazz)</td> 
   <td>把传递的类的对象转换成代表其子类的对象</td> 
  </tr> 
  <tr> 
   <td>Cast</td> 
   <td>把对象转换成代表类或是接口的对象</td> 
  </tr> 
 </tbody> 
</table>

###### （2）、获取类中属性相关的方法 ######

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getField(String name)</td> 
   <td>获得某个公有（public）属性对象</td> 
  </tr> 
  <tr> 
   <td>getFields()</td> 
   <td>获得所有公有（public）属性对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredField(String name)</td> 
   <td>获得某个属性（public、private、default）对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredFields()</td> 
   <td>获得所有属性（public、private、default）对象</td> 
  </tr> 
 </tbody> 
</table>

###### （3）、获取类中注解的相关方法 ######

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getAnnotation(Class annotationClass)</td> 
   <td>返回该类中与参数类型匹配的公有（public）注解对象</td> 
  </tr> 
  <tr> 
   <td>getAnnotations()</td> 
   <td>返回该类所有的公有（public）注解对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredAnnotation(Class annotationClass)</td> 
   <td>返回该类中与参数类型匹配的所有（public、private、default）注解对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredAnnotations()</td> 
   <td>返回该类所有（public、private、default）的注解对象</td> 
  </tr> 
 </tbody> 
</table>

###### （4）、获取类中构造器相关的方法 ######

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getConstructor(Class&lt;?&gt; parameterTypes)</td> 
   <td>获得该类中与参数类型匹配的公有（public）构造方法</td> 
  </tr> 
  <tr> 
   <td>getConstructors()</td> 
   <td>获得该类的所有公有（public）构造方法</td> 
  </tr> 
  <tr> 
   <td>getDeclaredConstructor(Class&lt;?&gt; parameterTypes)</td> 
   <td>获得该类中与参数类型匹配的构造方法，包含私有</td> 
  </tr> 
  <tr> 
   <td>getDeclaredConstructors()</td> 
   <td>获得该类所有（public、private、default）构造方法</td> 
  </tr> 
 </tbody> 
</table>

###### （5）、获取类中方法的相关方法 ######

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getMethod(String name, Class&lt;?&gt; parameterTypes)</td> 
   <td>获得该类某个公有（public）的方法</td> 
  </tr> 
  <tr> 
   <td>getMethods()</td> 
   <td>获得该类所有公有（public）的方法</td> 
  </tr> 
  <tr> 
   <td>getDeclaredMethod(String name, Class&lt;?&gt; parameterTypes)</td> 
   <td>获得该类某个方法（public、private、default）</td> 
  </tr> 
  <tr> 
   <td>getDeclaredMethods()</td> 
   <td>获得该类所有方法（public、private、default）</td> 
  </tr> 
 </tbody> 
</table>

###### （6）、类中其他重要的方法 ######

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>isAnnotation()</td> 
   <td>如果是注解类型则返回true</td> 
  </tr> 
  <tr> 
   <td>isAnnotationPresent(Class&lt;? extends Annotation&gt; annotationClass)</td> 
   <td>如果是指定类型注解类型则返回true</td> 
  </tr> 
  <tr> 
   <td>isAnonymousClass()</td> 
   <td>如果是匿名类则返回true</td> 
  </tr> 
  <tr> 
   <td>isArray()</td> 
   <td>如果是一个数组类则返回true</td> 
  </tr> 
  <tr> 
   <td>isEnum()</td> 
   <td>如果是枚举类则返回true</td> 
  </tr> 
  <tr> 
   <td>isInstance(Object obj)</td> 
   <td>如果obj是该类的实例则返回true</td> 
  </tr> 
  <tr> 
   <td>isInterface()</td> 
   <td>如果是接口类则返回true</td> 
  </tr> 
  <tr> 
   <td>isLocalClass()</td> 
   <td>如果是局部类则返回true</td> 
  </tr> 
  <tr> 
   <td>isMemberClass()</td> 
   <td>如果是内部类则返回true</td> 
  </tr> 
 </tbody> 
</table>

###### 4、Field类 ######

Field代表类的成员变量对象（类的属性）

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>equals(Object obj)</td> 
   <td>属性与obj相等则返回true</td> 
  </tr> 
  <tr> 
   <td>get(Object obj)</td> 
   <td>获得obj中对应的属性值</td> 
  </tr> 
  <tr> 
   <td>set(Object obj, Object value)</td> 
   <td>设置obj中对应属性值</td> 
  </tr> 
  <tr> 
   <td>getName()</td> 
   <td>获取类中属性的名字</td> 
  </tr> 
 </tbody> 
</table>

###### 5、Method类 ######

Method代表类的方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>invoke(Object obj, Object… args)</td> 
   <td>传递object对象及参数调用该对象对应的方法</td> 
  </tr> 
 </tbody> 
</table>

###### 6、Constructor类 ######

Constructor代表类的构造方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>newInstance(Object… initargs)</td> 
   <td>根据传递的参数创建类的对象</td> 
  </tr> 
 </tbody> 
</table>

## 三、反射示列 ##

上面介绍了与反射有关的类，我们知道反射机制是在运行状态中通过字节码得到类的具体信息，然后去操作类，所以，反射的前提是通过字节码.class来获取Class对象。

我们再来回忆一下Java程序的运行过程：

源文件经过编译(javac.exe)以后，得到一个或多个.class文件。.class文件经过运行(java.exe)以后，就需要进行类的加载（通过JVM的类的加载器），加载到内存中的缓存中，每一个放入缓存中的.class文件就是一个Class的实例。

反射需要的代码类：

public class Creature<T>{ 
    	public double weight;
    	public void breath(){ 
    		System.out.println("呼吸！");
    	}
    }
    
    // 注解类
    @Target({ TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface MyAnnotation { 
    	String value();
    }
    
    // 接口
    public interface MyInterface extends Serializable{ 
    
    }
    
    
    // Person类
    @MyAnnotation(value = "scorpios")
    public class Person extends Creature<String> 
    					implements Comparable,MyInterface{ 
    	public String name;
    	private int age;
    	int id;
    	// 创建类时，尽量保留一个空参的构造器。
    	// 因为反射调用的newInstance()方法就是调用空参构造函数
    	public Person() { 
    		super();
    		System.out.println("今天天气很闷热");
    	}
    	public Person(String name) { 
    		super();
    		this.name = name;
    	}
    	private Person(String name, int age) { 
    		super();
    		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;
    	}
    
    	public int getId() { 
    		return id;
    	}
    	public void setId(int id) { 
    		this.id = id;
    	}
    	
    	// 方法
    	@MyAnnotation(value = "abc123")
    	public void show(){ 
    		System.out.println("我是一个人！");
    	}
    
    	private Integer display(String nation,Integer i) throws Exception{ 
    		System.out.println("我的国籍是：" + nation);
    		return i;
    	}
    	@Override
    	public String toString() { 
    		return "Person [name=" + name + ", age=" + age + "]";
    	}
    	
    	@Override
    	public int compareTo(Object o) { 
    		return 0;
    	}
    
    	public static void info(){ 
    		System.out.println("中国人！");
    	}
    
    	class Bird{ 
    
    	}
    }

###### 1、获取类的Class对象的方式 ######

（1）、调用Class的静态方法forName(String className)

Class clazz = Class.forName("com.scorpios.java.Person")

（2）、调用运行时类的.class属性

Class clazz = Person.class

（3）、通过运行时类的对象，调用其getClass()方法

Class clazz = new Person().getClass();

###### 2、有了Class实例以后，可以做什么？ ######

应用一：可以创建对应的运行时类的对象

@Test
    public void test1() throws Exception{ 
    	System.out.println("------------test1() begin------------");
    	String className = "com.scorpios.java.Person";
    	Class clazz = Class.forName(className);
    	// 创建对应的运行时类的对象。使用newInstance()，
    	// 实际上就是调用了运行时类的空参的构造器。
    	// 要想能够创建成功：
    	// ① 要求对应的运行时类要有空参的构造器。
    	// ② 构造器的权限修饰符的权限要足够。
    	Object obj = clazz.newInstance();
    	Person p = (Person)obj;
    	System.out.println(p);
    	System.out.println("------------test1() end------------");
    }

![在这里插入图片描述][20200727220451344.png_pic_left]

@Test
    public void test2() throws ClassNotFoundException{ 
    	System.out.println("------------test2() end------------");
    	String className = "com.scorpios.java.Person";
    	Class clazz = Class.forName(className);
    
    	// 获取所有的构造函数
    	Constructor[] cons = clazz.getDeclaredConstructors();
    	for(Constructor c : cons){ 
    		System.out.println(c);
    	}
    	System.out.println("------------test2() end------------");
    }

![在这里插入图片描述][20200727220511407.png]

//调用指定的构造器,创建运行时类的对象
    @Test
    public void test3() throws Exception{ 
    	System.out.println("------------test3() end------------");
    	String className = "com.scorpios.java.Person";
    	Class clazz = Class.forName(className);
    	// 获取两个参数的构造函数，该构造函数是private私有的
    	Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
    	cons.setAccessible(true);
    	Person p = (Person)cons.newInstance("罗伟",20);
    	System.out.println(p);
    	System.out.println("------------test3() end------------");
    }

![在这里插入图片描述][20200727220518493.png]  
应用二：获取对应的运行时类的完整的类的结构：属性

// 获取对应的运行时类的属性
    @Test
    public void test1(){ 
    	System.out.println("------------test1() start------------");
    	Class clazz = Person.class;
    	// getFields():只能获取到运行时类中及其父类中声明为public的属性
    	Field[] fields = clazz.getFields();
    	for(int i = 0;i < fields.length;i++){ 
    		System.out.println(fields[i]);
    	}
    	System.out.println();
    	// getDeclaredFields():获取运行时类本身声明的所有的属性
    	Field[] fields1 = clazz.getDeclaredFields();
    	for(Field f : fields1){ 
    		System.out.println(f.getName());
    	}
    	System.out.println("------------test1() end------------");
    }

getFields()：只能获取到运行时类中及其父类中声明为public的属性  
getDeclaredFields()：获取运行时类本身声明的所有的属性  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]

// 权限修饰符 变量类型 变量名
    // 获取属性的各个部分的内容
    @Test
    public void test2(){ 
    	System.out.println("------------test2() start------------");
    	Class clazz = Person.class;
    	Field[] fields1 = clazz.getDeclaredFields();
    	for(Field f : fields1){ 
    		// 1.获取每个属性的权限修饰符
    		int i = f.getModifiers();
    		String str1 = Modifier.toString(i);
    		System.out.print(str1 + " ");
    		// 2.获取属性的类型
    		Class type = f.getType();
    		System.out.print(type.getName() + " ");
    		// 3.获取属性名
    		System.out.print(f.getName());
    		System.out.println();
    	}
    	System.out.println("------------test2() end------------");
    }

![在这里插入图片描述][20200727221146667.png]

// 调用运行时类中指定的属性
    @Test
    public void test3() throws Exception{ 
    	System.out.println("------------test3() start------------");
    	Class clazz = Person.class;
    	// 1.获取指定的属性
    	//getField(String fieldName):获取运行时类中声明为public的指定属性名为fieldName的属性
    	Field name = clazz.getField("name");
    	// 2.创建运行时类的对象
    	Person p = (Person)clazz.newInstance();
    	System.out.println(p);
    	// 3.将运行时类的指定的属性赋值
    	name.set(p,"Jerry");
    	System.out.println(p);
    	System.out.println("%"+name.get(p));
    
    	System.out.println();
    	// getDeclaredField(String fieldName):获取运行时类中指定的名为fieldName的属性
    	Field age = clazz.getDeclaredField("age");
    	// 由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性可被操作。
    	age.setAccessible(true);
    	age.set(p,10);
    	System.out.println(p);
    	System.out.println("------------test3() end------------");
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 1]

应用三：调用对应的运行时类中指定的结构：方法

Method\[\] m1 = clazz.getMethods() :获取到对应的运行时类中声明的权限为public的方法（包含其父类中的声明的public）  
Method\[\] m2 = clazz.getDeclaredMethods()：获取到对应的运行时类中声明的所有的方法（①任何权限修饰符修饰的都能获取②不含父类中的）

// 1.获取运行时类的方法
    @Test
    public void test1(){ 
    	System.out.println("------------test1() start------------");
    	Class clazz = Person.class;
    	// 1.getMethods():获取运行时类及其父类中所有的声明为public的方法
    	Method[] m1 = clazz.getMethods();
    	for(Method m : m1){ 
    		System.out.println(m);
    	}
    	System.out.println();
    
    	// 2.getDeclaredMethods():获取运行时类本身声明的所有的方法
    	Method[] m2 = clazz.getDeclaredMethods();
    	for(Method m : m2){ 
    		System.out.println(m);
    	}
    	System.out.println("------------test1() end------------");
    }

Method\[\] m1 = clazz.getMethods()：获取到对应的运行时类中声明的权限为public的方法（包含其父类中的声明的public）  
Method\[\] m2 = clazz.getDeclaredMethods()：获取到对应的运行时类中声明的所有的方法（①任何权限修饰符修饰的都能获取②不含父类中的）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 2]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 3]

// 注解 权限修饰符 返回值类型 方法名 形参列表 异常
    @Test
    public void test2(){ 
    	System.out.println("------------test2() start------------");
    	Class clazz = Person.class;
    
    	Method[] m2 = clazz.getDeclaredMethods();
    	for(Method m : m2){ 
    		// 1.注解
    		Annotation[] ann = m.getAnnotations();
    		for(Annotation a : ann){ 
    			System.out.println(a);
    		}
    
    		// 2.权限修饰符
    		String str = Modifier.toString(m.getModifiers());
    		System.out.print(str + " ");
    		
    		// 3.返回值类型
    		Class returnType = m.getReturnType();
    		System.out.print(returnType.getName() + " ");
    		
    		// 4.方法名
    		System.out.print(m.getName() + " ");
    
    		// 5.形参列表
    		System.out.print("(");
    		Class[] params = m.getParameterTypes();
    		for(int i = 0;i < params.length;i++){ 
    			System.out.print(params[i].getName() + " args-" + i + " ");
    		}
    		System.out.print(")");
    
    		// 6.异常类型
    		Class[] exps = m.getExceptionTypes();
    		if(exps.length != 0){ 
    			System.out.print("throws ");
    		}
    		for(int i = 0;i < exps.length;i++){ 
    			System.out.print(exps[i].getName() + " ");
    		}
    		System.out.println();
    	}
    	System.out.println("------------test2() end------------");
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 4]

// 调用运行时类中指定的方法
    @Test
    public void test3() throws Exception{ 
    	System.out.println("------------test3() start------------");
    	Class clazz = Person.class;
    	// getMethod(String methodName,Class ... params):获取运行时类中声明为public的指定的方法
    	Method m1 = clazz.getMethod("show");
    	Person p = (Person)clazz.newInstance();
    	// 调用指定的方法：Object invoke(Object obj,Object ... obj)
    	Object returnVal = m1.invoke(p); //我是一个人
    	System.out.println(returnVal); //null
    
    	Method m2 = clazz.getMethod("toString");
    	Object returnVal1 = m2.invoke(p);
    	System.out.println(returnVal1); //Person [name=null, age=0]
    	// 对于运行时类中静态方法的调用
    	Method m3 = clazz.getMethod("info");
    	m3.invoke(Person.class);
    
    	//getDeclaredMethod(String methodName,Class ... params):获取运行时类中声明了的指定的方法
    	Method m4 = clazz.getDeclaredMethod("display",String.class,Integer.class);
    	m4.setAccessible(true);
    	Object value = m4.invoke(p,"CHN",10);//我的国籍是：CHN
    	System.out.println(value);//10
    	System.out.println("------------test3() end------------");
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 5]

// 1.获取运行时类的父类
    @Test
    public void test1(){ 
    	System.out.println("------------test1() start------------");
    	Class clazz = Person.class;
    	Class superClass = clazz.getSuperclass();
    	System.out.println(superClass);
    	System.out.println("------------test1() end------------");
    }

![在这里插入图片描述][20200727222318671.png]

// 2.获取带泛型的父类
    @Test
    public void test2(){ 
    	System.out.println("------------test2() start------------");
    	Class clazz = Person.class;
    	Type type1 = clazz.getGenericSuperclass();
    	System.out.println(type1);
    	System.out.println("------------test2() end------------");
    }

![在这里插入图片描述][20200727222356377.png]

// 3.获取父类的泛型
    @Test
    public void test3(){ 
    	System.out.println("------------test3() start------------");
    	Class clazz = Person.class;
    	Type type1 = clazz.getGenericSuperclass();
    
    	ParameterizedType param = (ParameterizedType)type1;
    	Type[] ars = param.getActualTypeArguments();
    
    	System.out.println(((Class)ars[0]).getName());
    	System.out.println("------------test3() end------------");
    }

![在这里插入图片描述][20200727222434611.png]

// 4.获取实现的接口
    @Test
    public void test4(){ 
    	System.out.println("------------test4() start------------");
    	Class clazz = Person.class;
    	Class[] interfaces = clazz.getInterfaces();
    	for(Class i : interfaces){ 
    		System.out.println(i);
    	}
    	System.out.println("------------test4() end------------");
    }

![在这里插入图片描述][20200727222510883.png]

// 5.获取所在的包
    @Test
    public void test5(){ 
    	System.out.println("------------test5() start------------");
    	Class clazz = Person.class;
    	Package pack = clazz.getPackage();
    	System.out.println(pack);
    	System.out.println("------------test5() end------------");
    }

![在这里插入图片描述][20200727222600208.png]

//6.获取注解
    @Test
    public void test6(){ 
    	System.out.println("------------test6() start------------");
    	Class clazz = Person.class;
    	Annotation[] anns = clazz.getAnnotations();
    	for(Annotation a : anns){ 
    		System.out.println(a);
    	}
    	System.out.println("------------test6() end------------");
    }

![在这里插入图片描述][20200727222632833.png]

[20200727220451344.png_pic_left]: /images/20230209/de64cbfabdb24adeb376b4fca714a65a.png
[20200727220511407.png]: /images/20230209/b98980bf9ba84e59b0e1ac77081ee959.png
[20200727220518493.png]: /images/20230209/8d3549715f6d46668b349ed4cc29234a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70]: /images/20230209/b05e7a2a02184b8ca7da7dfd448ca8fb.png
[20200727221146667.png]: /images/20230209/147cfd568ffd4fc2b39c910dcd26340d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 1]: /images/20230209/b786040dfcf84359be63019ed372dcde.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200727221748517.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 3]: /images/20230209/69633b77099e49debee4ad9dba23228e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 4]: /images/20230209/dd15b5a705b546b0b731b6a43d17563b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3p4ZDE0MzU1MTM3NzU_size_16_color_FFFFFF_t_70 5]: /images/20230209/07688d13f26f464bbbc9deca3153403b.png
[20200727222318671.png]: /images/20230209/317df0d1df494a2fa61aa3890e9628e8.png
[20200727222356377.png]: /images/20230209/5c52dcb57f944229a809fc8d6a6b1ec7.png
[20200727222434611.png]: /images/20230209/9299e438721a48cdbdedbfb3f4794087.png
[20200727222510883.png]: /images/20230209/db1c23fe9f064efeb35cda112609a661.png
[20200727222600208.png]: /images/20230209/cf52366894ca470e9847534b7977dd44.png
[20200727222632833.png]: /images/20230209/d5398cc47d924bf8a91965ea1163b1e9.png