Reflection(反射)

动态语言的关键

• 允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法
• 提供的功能:
  在运行时判断任意一个对象所属类
  在运行时构造任意一个类的对象
  在运行时判断任意一个类所具有的成员变量和方法
  在运行时调用任意一个对象的成员变量和方法
  生成动态代理
  

例：
Person类

@MyAnnotation(value = "atguigu")
public class Person extends Creature<String> implements Comparable,MyInsterface{   
	public String name;
	private int age;
	//创建类时，尽量保留一个空参的构造器
	public Person() {
		super();
		System.out.print("空参");
	}
	public Person(String name) {
		super();
		this.name = name;
	}
	public 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;
	}
	@MyAnnotation(value = "boos")
	public void show() {
		System.out.println("I am Person");
	}
	public void display(String nation)throws Exception {
		System.out.println("我的国籍是= " + nation);
	}
	private Integer displays(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 arg0) {
		// TODO Auto-generated method stub
		return 0;
	}
	public static void info() {
		System.out.println("Chianese");
	}
	class A {
		
	}
}

• 没有反射之前，创建对象，调用方法，属性

@Test
public void test1() throws Exception {
	Person p = new Person();
	p.setName("HaoJie");
	p.setAge(22);
	System.out.println(p);                             
	p.show();
	p.display("中国");
}

• 有反射之后，创建对象，调用方法，属性

@Test
public void test2() throws Exception{
	Class c = Person.class;//c直接指向Person实体(反射的源头java.lang.Class类)
	//1.创建c对应的运行时类Person类的对象
	Person p = (Person)c.newInstance();
	//2-1.通过反射获取实体的公有属性
	Field f1 = c.getField("name");
	f1.set(p,"LiYunHai");
	System.out.println(p);       
	//2-2.通过反射获取实体的私有属性
	Field f2 = c.getDeclaredField("age");
	f2.setAccessible(true);
	f2.set(p,26);
	System.out.println(p);  
	
	//通过反射调用运行时实体（类）的指定的方法
	Method m1 = c.getMethod("show");
	m1.invoke(p);
	
	Method m2 = c.getMethod("display",String.class);
	m2.invoke(p,"China");		
}

1.理解Class类并实例化Class类对象

• 类的具体实现：
  

  创建类，通过编译（javac.exe）,生产字节码文件，之后通过java.exe加载（JVM的类加载器完成的）字节码文件，字节码文件加载到内存中，就是一个运行时类，存在缓冲区中。这个运行时类本身就是一个Class的实例
  

• 每一个运行时类只加载一次

• 有Class的实例，就可以进行如下操作：

   //*创建对应的运行时类的对象
   //获取对应的运行时类的完整结构（属性，方法，构造器，内部类。。。）
   //*调用对应运行时类的指定的结构（属性，方法，构造器）
   //反射的应用：动态代理
  

获取Class的实例（掌握3种）

@Test
public void test4() throws ClassNotFoundException {
	//1.调用运行时类本身的.class属性
	Class clazz = Person.class;
	System.out.println(clazz.getName());                
	
	Class clazz1 = String.class;
	System.out.println(clazz1.getName());
	System.out.println();
	
	//2.通过运行时类的对象获取
	Person p = new Person();
	Class clazz2  = p.getClass();
	System.out.println(clazz2.getName());
	
	//3.通过Class的静态方法获取
	String classname = "java.lang.String";
	Class clazz3 = Class.forName(classname);
	System.out.println(clazz3.getName());
	
	//4.(了解)通过类的加载器
	ClassLoader classLoader = this.getClass().getClassLoader();
	Class clazz4 = classLoader.loadClass(classname);
	System.out.println(clazz4.getName());
	
	System.out.println(clazz1 == clazz3);//true
	System.out.println(clazz1 == clazz2);//false
	System.out.println(clazz1 == clazz4);//true
}

例：

@Test	
	public void test5() throws IOException {
		ClassLoader loader1 = ClassLoader.getSystemClassLoader();          
		System.out.println(loader1);//获取ClassLoader类的加载类AppClassLoader
		
		ClassLoader loader2 = loader1.getParent();
		System.out.println(loader2);//ExtClassLoader
		
		ClassLoader loader3 = loader2.getParent();
		System.out.println(loader3);//null（核心类库及引导类无法获取）
		
		
		Class clazz1 = Person.class;
		ClassLoader loader4 = clazz1.getClassLoader();
		System.out.println(loader4);//AppClassLoader
	}

	//掌握如下：查找包下的文件中的部分内容
		ClassLoader loader5 = this.getClass().getClassLoader();                  
		InputStream is = loader5.getResourceAsStream("hello.txt");
		//查找工程下的文件中的部分内容
	//FileInputStream is = new FileInputStream(new File("hello.txt"));
		Properties txt = new Properties();
		txt.load(is);
		String name = txt.getProperty("user");
		System.out.println(name);
		String password = txt.getProperty("password");
		System.out.println(password);

2.在运行时创建类对象并获取类的完整结构

例：

@Test
	public void test1() throws Exception {
		String className = "Person";                       
		Class clazz = Class.forName(className);  
		//创建对应的运行类的对象
		//要求：1.对应的运行时类要有空参的构造器；2.构造器的权限应在缺省（及以上）
		Object obj = clazz.newInstance();
		Person p = (Person)obj;
		System.out.print(p);  
	}
	
	@Test
	//构造器
	public void test2() throws ClassNotFoundException {
		String className = "Person";  
		Class clazz = Class.forName(className);  
		//getDeclaredConstructors()：获取本身类所有的构造器
		Constructor[] cons = clazz.getDeclaredConstructors();
		for(Constructor c : cons) {  
			System.out.println(c);  
	}
		}
	

获取运行时类的方法

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

获取对应的运行时类的属性

@Test
	public void test1() {
		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();
		
		//2.getDeclaredFields()：获取运行时类本身声明的所有属性
		Field[] fields1 = clazz.getDeclaredFields();
		for(Field f : fields1) {
			System.out.println(f.getName());
		}
	}

获取属性各个部分的内容（权限修饰符 变量类型 变量名）

@Test
    public void test2() {
		Class clazz = Person.class;
		Field[] fields = clazz.getDeclaredFields();
		for(Field f : fields) {
			//1.获取属性的权限修饰符
			int i = f.getModifiers();
			String str = Modifier.toString(i);
			System.out.print(str + " ");      
			//2.获取属性的类型
			Class type = f.getType();
			System.out.print(type.getName() + " ");
			//3.获取属性名
			System.out.print(f.getName());
			System.out.println();
		}
	}

注解 权限修饰符 返回值类型 方法名 形参列表 异常

@Test
	public void test2() {
		Class clazz = Person.class;
		
		Method[] m1 = clazz.getDeclaredMethods();
		for(Method m : m1) {   
			//1.注解
			Annotation[] ann = m.getAnnotations();
			for(Annotation an : ann) {
				System.out.println(an);
			}
			//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();
		}
	}

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();
}

带泛型的类

public class Creature<T> {
	public double weight; 
	public void breath() {
		System.out.println("呼吸");
	}
}

接口

import java.io.Serializable;

public interface MyInsterface extends Serializable{
	
}

继承，实现接口等

@MyAnnotation(value = "atguigu")
public class Person extends Creature<String> implements Comparable,MyInsterface{  
	public String name;
	private int age;
	//创建类时，尽量保留一个空参的构造器
	public Person() {
		super();
		System.out.print("空参");
	}
	public Person(String name) {
		super();
		this.name = name;
	}
	public 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;
	}
	@MyAnnotation(value = "boos")
	public void show() {
		System.out.println("I am Person");
	}
	public void display(String nation)throws Exception {
		System.out.println("我的国籍是= " + nation);
	}
	private Integer displays(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 arg0) {
		// TODO Auto-generated method stub
		return 0;
	}
	public static void info() {
		System.out.println("Chianese");
	}
	class A {
		
	}
}

测试

import java.lang.annotation.Annotation;             
import java.lang.reflect.ParameterizedType; 
import java.lang.reflect.Type; 

import org.junit.Test;

public class TestOther {
	
	@Test
	//1.获取运行时类的父类
	public void test1() {
		Class clazz = Person.class;
		Class superClass = clazz.getSuperclass();
		System.out.println(superClass);//class Creature 
	}
	
	@Test
	//2.获取带泛型的父类
	public void test2() {
		Class clazz = Person.class;
		Type type = clazz.getGenericSuperclass();
		System.out.println(type);//Creature<java.lang.String> 
	}
	
	@Test
	//3.获取父类的泛型
	public void test3() {
	Class clazz = Person.class;
	Type type = clazz.getGenericSuperclass();
	
	ParameterizedType param = (ParameterizedType)type; 
	Type[] ars = param.getActualTypeArguments(); 
	
	System.out.println(((Class)ars[0]).getName()); 
	
	}
	
	@Test
	//获取实现的接口
	public void test4() {
		Class clazz = Person.class;
		Class[] interfaces = clazz.getInterfaces(); 
		for(Class i : interfaces) { 
			System.out.println(i); 
		}
		
	}
	@Test
	//获取所在的包
	public void test5() {
		Class clazz = Person.class;
		Package pack = clazz.getPackage();
		System.out.println(pack); 
	}
	
	@Test
	//获取注解
	public void test6() {
		Class clazz = Person.class;
		Annotation[] anns = clazz.getAnnotations();
		for(Annotation a : anns) {
			System.out.println(a); 
		}
	}
}

3.通过反射调用类的指定方法，指定属性

调用指定构造器,创建对象

@Test
	//
	public void test3() throws Exception {
		String className = "Person";    
		Class clazz = Class.forName(className);
		
		Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
		cons.setAccessible(true);
		Person p = (Person)cons.newInstance("李福根",56);
		System.out.println(p);
	}

调用运行时类中指定的属性

@Test
	public void test3() throws Exception {
		Class clazz = Person.class;
		//1.获取指定的属性
		//getField(String fielName)：获取运行时类中声明为public类型的指定属性名为fielName的属性
		Field name = clazz.getField("name");
		//2.创建运行时类的对象
		Person p = (Person)clazz.newInstance();
		System.out.println(p);        
		//3.将运行时指定的属性赋值
		name.set(p, "Jame");
		System.out.println(p);
		
		System.out.println();
		//getDeclaredField(String fielName)：获取运行时类中指定属性名为fielName的属性
		Field age = clazz.getDeclaredField("age");//私有属性不能直接用getField来调
		//由于权限修饰符的限制，为保证可以给属性赋值，需要在操作前使此属性可被操作（缺省状态下，可不用）
		age.setAccessible(true);
		age.set(p, 25);
		System.out.println(p);
	}

调用运行时类的指定方法

@Test
	public void test3() throws Exception {
		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);//方法本身无返回值，就显示为null
		System.out.println(returnVal);
		
		Method m2 = clazz.getMethod("toString");
		Object returnVal1 = m2.invoke(p);
		System.out.println(returnVal1);//方法本身有返回值,就显示为方法的返回值
		
		//调用静态的方法
		Method m3 = clazz.getMethod("info");
		m3.invoke(Person.class);//不需要对象
		
		
		//getDeclaredMethod(String methodName,Class .. params)：获取运行时类中声明的指定方法
		Method m4 = clazz.getDeclaredMethod("displays",String.class,Integer.class);
		m4.setAccessible(true);
		Object returnVal2 = m4.invoke(p,"CNN",10);//调用方法
		System.out.println(returnVal2);//返回值
		
	}

4.动态代理与AOP

静态代理

例：

package Proxy;     
//接口
interface ClothFactory{
	void productCloth();
}
//被代理类
class NikeClothFactory implements ClothFactory{

	@Override
	public void productCloth() {
		System.out.println("Nike工厂开工了！");	
	}
}

//代理类
class ProxyFactory implements ClothFactory{
	ClothFactory cf;
	//创建代理类的对象时，实际传入一个被代理类的对象
	public ProxyFactory(ClothFactory cf) {
		this.cf = cf;
	}

	@Override
	public void productCloth() {
		System.out.println("代理开始，收专利费了！");
		cf.productCloth();
	}
	
}
public class TestCiothProduct {
	public static void main(String[] args) {	
	NikeClothFactory nike = new NikeClothFactory();//被代理类
	ProxyFactory proxy = new ProxyFactory(nike);//代理类
	proxy.productCloth();
}
}

动态代理

例：

package Proxy;  

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//动态代理
interface Subject{
	void action();
}
//被代理类
class ReaSubject implements Subject{
	public void action() {
		System.out.println("我是被代理类，好囧ing");
	}
}

class MyInvocationHandler implements InvocationHandler{
	Object obj;//实现接口的被代理类对象的声明
	
	//给被代理的对象实例化；返回一个代理类的对象声明
	public Object blind(Object obj) {
		this.obj = obj;
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),this);
	}
	@Override
	//当通过代理类的对象发起被重写的方法的调用时，都会转换为对如下invoke方法的调用
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//method方法的返回值是returnVal
		System.out.println("代理------");
		Object returnVal = method.invoke(obj, args);
		return returnVal;
	}
}
public class dongProxy {
	public static void main(String[] args) {
		//1.被代理类的对象
		ReaSubject real = new ReaSubject();
		//2.创建实现InvocationHandler接口的类对象
		MyInvocationHandler handler = new MyInvocationHandler();
		//3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象
		Object obj = handler.blind(real);
		Subject sub = (Subject)obj;//此时的sub就是代理类的对象
		
		sub.action();//跳转到InvocationHandler接口的实现类的invoke()方法的调用
		
		//例
		NikeClothFactory nike = new NikeClothFactory();//被代理类
		ClothFactory proxyCloth = (ClothFactory)handler.blind(nike);//proxyCloth即为代理类的对象
		proxyCloth.productCloth();
	}
}

动态代理与AOP

例：

package com.al.java;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Human{
	void info();
	void fly();   
}
//被代理类
class SuperMan implements Human{
	public void info() {
		System.out.println("我是超人");
	}
	public void fly() {
		System.out.println("I believe I can fly!");
	}
}
class HumanUtil{
	public void method1() {
		System.out.println("========方法一======");
	}
	public void method2() {
		System.out.println("========方法二======");
	}
}

class MyInvocationHandler implements InvocationHandler{
	Object obj;
	public void setObject(Object obj) {
		this.obj = obj;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		HumanUtil h = new HumanUtil();
		h.method1();
		Object returnval = method.invoke(obj, args);
		h.method2();
		return returnval;
	}
	
	
}

class MyProxy{
	//动态的创建一个代理类对象
	public static Object getProxyInstance(Object obj) {
		MyInvocationHandler handler = new MyInvocationHandler();
		handler.setObject(obj);
		
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
	}
}

public class TestAOP {
	public static void main(String[] args) {	
	SuperMan man = new SuperMan();//创建被代理类对象
	Object obj = MyProxy.getProxyInstance(man);//返回代理类对象
	Human hu = (Human)obj;
	hu.info();//通过代理类的对象调用重写的抽象方法
	System.out.println();
	hu.fly();
	}
}

运行示例

感谢大家的支持，关注，评论，点赞！
参考资料：
尚硅谷宋红康20天搞定Java基础下部