1.什么是反射？
Reflection(反射)是被视为动态语言的关键，反射机制允许程序做执行期间借助于ReflectionAPI取得任何类的内部信息，并能直接操作任意对象内部属性及方法
2.反射相关的主要API
java.lang.Class:代表一个类
java.lang.reflect.Method:代表类的方法
java.lang.reflect.Field:代表类的成员变量
java.lang.reflect.Constructor:代表类的构造方法
3.简单入门示例代码
package day01.code; import java.lang.reflect.Field;
import java.lang.reflect.Method; import org.junit.Test; public class TestReflection { // 有了反射，可以通过反射创建一个类的对象，并调用其中的结构
@Test
public void test2() throws Exception{
Class clazz=Person.class;
// 1.创建clazz对应的运行时类Person类的对象
Person person= (Person)clazz.newInstance();
System.out.println(person);
// 2.通过反射调用运行时类的指定的属性
// 2.1 调用public的属性
Field f1=clazz.getField("name");
f1.set(person, "lisi");
System.out.println(person);
// 2.2 调用非public的属性
Field f2= clazz.getDeclaredField("age");
f2.setAccessible(true);
f2.set(person, 20);
System.out.println(person);
// 3.通过反射调用运行时类的指定的方法
// 3.1 调用无参方法
Method m1=clazz.getMethod("show");
m1.invoke(person);
// 3.2 调用有参方法
Method m2=clazz.getMethod("display",String.class);
m2.invoke(person, "CHN");
} // 在有反射以前，如何创建一个类的对象，并调用其中的方法，属性
@Test
public void test1(){
Person person=new Person();
person.setAge(10);
person.setName("zhangsan");
System.out.println(person);
person.show();
person.display("CN");
}
}
4.反射的源头Class
4.1 getClass()详解，此方法中Object类中被定义，会被所有的子类继承，调用此方法返回值的类型是一个Class类，此类的反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，即：可以通过对象反射出类的名称
@Test
public void test3(){
Person person=new Person();
Class calzz= person.getClass(); // 通过运行时类的对象，调用其getClass()，返回其运行时类
System.out.println(calzz);
}
4.2 反射原理解析
我们创建了一个类，通过编译(javac.exe)，生成对应的.class文件，之后我们使用java.exe加载(JVM的类加载器完成的)此.class文件，此.class文件加载到内存以后，就是一个运行时类，存放在缓存区。那么这个运行时类本身就是一个Class的实例！
4.2.1 每一个运行时类只加载一次
4.2.2 有了Class的实例以后，我们才可以进行如下操作
1）创建对应的运行时类的对象
2）获取对应的运行时类的完整结构（属性，方法，构造器，内部类，父类，所在的包，异常，注解........）
3) 调用对应的运行时类的指定的结构（属性，方法，构造器）
4）反射的应用，动态代理
正常方式：引入需要的“包类”名称->通过new实例化->取得实例化对象
反射方式：实例化对象->getClass()方法->得到完整的“包类”名称
4.3 获取Class的实例
4.3.1 调用运行时类本身的.class属性
@Test
public void test4(){
// 1.调用运行时类本身的.class属性
Class clazz=Person.class;
System.out.println(clazz.getName());
}
4.3.2 通过运行时类的对象获取
@Test
public void test5(){
// 通过运行时类的对象获取
Person person=new Person();
Class clazz= person.getClass();
System.out.println(clazz.getName());
}
4.3.3 通过Class的静态方法获取
@Test
public void Test6() throws Exception{
// 通过Class的静态方法获取
String className="day01.code.Person";
Class clazz= Class.forName(className);
System.out.println(clazz.getName());
}
4.3.4 通过类的加载器
@Test
public void test7() throws Exception{
// 通过类的加载器
String className="day01.code.Person";
ClassLoader classLoader=this.getClass().getClassLoader();
Class clazz= classLoader.loadClass(className);
System.out.println(clazz.getName());
}
4.4 什么是类的加载器？(ClassLoader)
解释：类加载器是用来把类(class)装载进内存的。JVM 规范定义了两种类型的类加载器：启动类加载器(bootstrap)和用户自定义加载器(user-defined class loader)
4.4.1 Bootstap Classloader 引导类加载器：用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来加载核心类库，该加载器无法直接获取
4.4.2 Extension Classloader 扩展类加载器：负责jre/lib/ext目录下的jar包或 –D java.ext.dirs 指定目录下的jar包装入工作库 .
4.4.3 System Classloader 系统类加载器：负责java –classpath 或 –D java.class.path所指的目录下的类与jar包装入工作 ，是最常用的加载器
4.5 有了Class对象，能做什么？
4.5.1 newInstance() 作用： 创建对应的运行时类的对象，实际上就是调用类运行时类的空参的构造器。注：要想创建成功，1.要求对应的运行时类要有空参的构造器 2.构造器的权限修饰符的权限要足够(经验证同一个包下大于 private 即可)
@Test
public void test1() throws Exception{
String className="day01.code.Person";
Class clazz= Class.forName(className);
// 创建运行时对象
Object obj=clazz.newInstance();
Person person=(Person)obj;
System.out.println(person);
}
4.5.2 通过反射调用类的完整结构(实现的全部接口，所继承的父类，全部的构造器，全部的方法，全部的Field)
4.5.2.1 Field
// 获取对应的运行时类的属性
@Test
public void test1(){
Class clazz= Person.class;
// 1.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 field : fields1) {
System.out.println(field.getName());
}
} // 权限修饰符 变量类型 变量名，获取属性的各个部分的内容
@Test
public void test2(){
Class clazz= Person.class;
Field[] fields1=clazz.getDeclaredFields();
for (Field field : fields1) {
// 1.获取每个属性的权限修饰符
int i= field.getModifiers();
String modifier= Modifier.toString(i);
System.out.print(modifier+" ");
// 2.获取属性的变量类型
Class type=field.getType();
System.out.print(type.getName()+" ");
// 3.获取属性名
System.out.println(field.getName());
}
}
4.5.2.2 Method
// 1.获取运行时类的方法
@Test
public void test1(){
Class clazz=Person.class;
// 1.getMethods():获取运行时类及其父类中所有声明为public的方法
Method[]m1=clazz.getMethods();
for (Method method : m1) {
System.out.println(method);
}
System.out.println();
// 2.getDeclaredMethods():获取运行时类本身声明的所有的方法
Method[]m2=clazz.getDeclaredMethods();
for (Method method : m2) {
System.out.println(method);
}
} // 注解 权限修饰符 返回值类型 方法名 形参列表 异常
@Test
public void test2(){
Class clazz=Person.class;
Method[]m2=clazz.getDeclaredMethods();
for (Method method : m2) {
// 1.注解
Annotation[] ann= method.getAnnotations();
for (Annotation annotation : ann) {
System.out.print(annotation+" ");
}
// 2.权限修饰符
String str= Modifier.toString(method.getModifiers());
System.out.print(str+" ");
// 3.返回值类型
Class returnType=method.getReturnType();
System.out.print(returnType.getName()+" ");
// 4.方法名
System.out.print(method.getName()+" ");
// 5.形参列表
System.out.print("(");
Class[]params=method.getParameterTypes();
for (Class p : params) {
System.out.print(p.getName());
}
System.out.print(")");
// 6.异常类型
Class[]exps= method.getExceptionTypes();
for (Class exp : exps) {
System.out.print(exp.getName()+" ");
}
System.out.println();
}
}
4.5.2.3 构造器
// 获取运行时类的构造器
@Test
public void test2()throws Exception{
String className="day01.code.Person";
Class clazz= Class.forName(className);
Constructor[]cons=clazz.getDeclaredConstructors();
for (Constructor constructor : cons) {
System.out.println(constructor);
}
}
4.5.2.4 其他结构
// 6.获取注解
@Test
public void test6(){
Class clazz=Person.class;
Annotation[]anns=clazz.getAnnotations();
for (Annotation annotation : anns) {
System.out.println(annotation);
}
} // 5.获取所在的包
@Test
public void test5(){
Class clazz=Person.class;
Package package1=clazz.getPackage();
System.out.println(package1);
} // 4.获取实现的接口
@Test
public void test4(){
Class clazz=Person.class;
Class[] interfaces=clazz.getInterfaces();
for (Class class1 : interfaces) {
System.out.println(class1);
}
} // 3.获取父类的泛型
@Test
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());
} // 2.获取带泛型的父类
@Test
public void test2(){
Class clazz=Person.class;
Type type=clazz.getGenericSuperclass();
System.out.println(type);
} // 1.获取运行时类的父类
@Test
public void test1(){
Class clazz= Person.class;
Class superClass=clazz.getSuperclass();
System.out.println(superClass);
}
4.5.3 反射的各种操作
4.5.3.1 调用运行时类指定的属性
// 调用运行时类中指定的属性
@Test
public void test3() throws Exception{
Class clazz=Person.class;
// 1.获取指定的属性，属性权限是public的
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();
Field age= clazz.getDeclaredField("age");
// 由于属性权限修饰符的限制，为了保证可以给属性赋值，需要在操作前使得此属性值可以被操作
age.setAccessible(true);
age.set(p, 10);
System.out.println(p);
}
4.5.3.2 调用运行时类指定的方法
// 调用运行时类中指定的方法
@Test
public void test3() throws Exception{
Class clazz=Person.class;
// getMethod(String methodName,Class...params):获取运行时类中声明为public的方法
Method m1=clazz.getMethod("show");
Person person=(Person)clazz.newInstance();
// 可以获取返回值
Object returnVal=m1.invoke(person);
System.out.println(returnVal); Method m2=clazz.getMethod("toString");
Object returnVal2=m2.invoke(person);
System.out.println(returnVal2); // 获取运行时类的静态方法
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(person,"中国",10);
System.out.println(value);
}
4.5.3.3 调用指定的构造器
// 调用指定的构造器,创建运行时类的对象
@Test
public void test() throws Exception{
String className="day01.code.Person";
Class clazz= Class.forName(className);
Constructor cons= clazz.getDeclaredConstructor(String.class,int.class);
cons.setAccessible(true);
Person person=(Person)cons.newInstance("陆虎",10);
System.out.println(person);
}
4.5.4 动态代理vs静态代理
4.5.4.1 静态代理
package day01.code1; // 静态代理
// 接口
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("代理类开始执行。。。");
this.cf.productCloth();
} } public class TestClothProduct { public static void main(String[]args){
NikeClothFactory nikeClothFactory=new NikeClothFactory();
ProxyFactory proxyFactory=new ProxyFactory(nikeClothFactory);
proxyFactory.productCloth();
}
}
4.5.4.2 动态代理
package day01.code1; import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy; interface Subject{
void action();
}
// 被代理类
class RealSubject implements Subject{ @Override
public void action() {
System.out.println("被代理类方法开始执行");
} }
class MyInvocationHandler implements InvocationHandler{ Object obj;// 实现了接口的被代理类的对象的声明 // 1.给被代理的对象实例化 2.返回一个代理类的对象
public Object blind(Object obj){
this.obj=obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(), this);
}
// 当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// method方法的返回值是returnVal
Object returnVal=method.invoke(obj, args);
return returnVal;
} } public class TestProxy { public static void main(String[]args){
// 1.被代理类的对象
RealSubject real=new RealSubject();
// 2.创建一个实现了InvacationHandler接口的类的对象
MyInvocationHandler handler=new MyInvocationHandler();
// 3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象
Object object=handler.blind(real);
// 4.此时subject就是代理类的对象
Subject subject=(Subject)object;
// 5.转到对InvocationHandler接口对实现类对invoke()方法的调用
subject.action(); // 再举一例
NikeClothFactory nikeClothFactory=new NikeClothFactory();
// proxyCloth即为代理类的对象
ClothFactory proxyCloth=(ClothFactory)handler.blind(nikeClothFactory);
proxyCloth.productCloth(); }
}