这杯咖啡有毒( ? ) -- Java 的反射机制

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

@MyAnnotation(value = "oktfolio")
public class Person extends Creature<String> implements Comparable, MyInterface {
public String name;
private int age;

public Person() {
}

private Person(String name, int age) {
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 = "adc")
public void show() {
System.out.println("I'm a human.");
}

private Integer display(String nation, Integer i) throws Exception {
System.out.println("I'm from " + nation);
return i;
}

@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}

@Override
public int compareTo(Object o) {
return 0;
}

class Bird {
}

public static void info() {
System.out.println("Chinese");
}

}

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
String value();
}

import java.io.Serializable;

public interface MyInterface extends Serializable {
}

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

interface Human {
void info();

void fly();
}

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

//被代理类
class SuperMan implements Human {

@Override
public void info() {
System.out.println("I'm superman");
}

@Override
public void fly() {
System.out.println("I can fly!");
}
}

class MyInvocationHandler1 implements InvocationHandler {
Object object;

public void setObject(Object object) {
this.object = object;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
HumanUtil humanUtil = new HumanUtil();
humanUtil.method1();
Object returnVal = method.invoke(object, args);
humanUtil.method2();
return returnVal;
}
}

class HumanUtil {
public void method1() {
System.out.println("===方法一===");
}

public void method2() {
System.out.println("===方法二===");
}
}

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

//静态代理模式

//接口
interface ClothFactory {
void productCloth();
}

//被代理类
class NikeClothFactory implements ClothFactory {

@Override
public void productCloth() {
System.out.println("被代理类开始执行...");
}
}

//代理类
class ProxyFactory implements ClothFactory {
ClothFactory cf;

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

@Override
public void productCloth() {
System.out.println("代理类开始执行...");
cf.productCloth();
}
}

public class TestClothProduct {
public static void main(String[] args) {
NikeClothFactory nikeClothFactory = new NikeClothFactory();//创建被代理类的对象
ProxyFactory proxyFactory = new ProxyFactory(nikeClothFactory);//创建代理类的对象
proxyFactory.productCloth();
}
}

import org.junit.Test;

import java.lang.reflect.Constructor;

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

@Test
public void test2() throws ClassNotFoundException {
String className = "Person";
Class clazz = Class.forName(className);
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}
}
}

import org.junit.Test;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class TestField {
//获取对应的运行时类的属性
@Test
public void test1() {
Class clazz = Person.class;
//getFields():只能获取到运行时类及其父类中声明为 public 的属性
Field[] fields = clazz.getFields();
for (Field field : fields) {
System.out.println(field);
}
//getDeclaredFields();获取运行时类本身声明的所有的属性。
Field[] fields1 = clazz.getDeclaredFields();
for (Field field : fields1) {
System.out.println(field);
}
}

//权限修饰符 Modifiers 变量类型 Type 变量名 Name
@Test
public void test2() {
Class clazz = Person.class;
Field[] fields = clazz.getFields();
for (Field field : fields) {
//1.获取每个属性的权限修饰符
System.out.print(Modifier.toString(field.getModifiers()) + " ");
//2.获取属性的变量类型
System.out.print(field.getType() + " ");
//3.获取属性名
System.out.println(field.getName());
}
}

//调用运行时类中指定的属性
@Test
public void test3() throws NoSuchFieldException, IllegalAccessException, InstantiationException {
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();
//getDeclaredField(String fieldName):获取运行时类中的指定属性名为 fieldName 的属性
Field age = clazz.getDeclaredField("age");
age.setAccessible(true);//私有方法需要setAccessible(true)才能操作私有属性
age.set(p, 10);
System.out.println(p);
}
}

import com.sun.xml.internal.ws.api.model.ExceptionType;
import org.junit.Test;

import javax.sound.midi.Soundbank;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class TestMethod {
//1.获取运行时类的方法

@Test
public void test1() {
Class clazz = Person.class;
//getMethods():只能获取到运行时类及其父类中声明为 public 的方法
Method[] methods = clazz.getMethods();
for (Method method : methods) {
System.out.println(method);
}
//getDeclaredMethods():获取运行时类本身声明的所有的方法
Method[] methods1 = clazz.getDeclaredMethods();
for (Method method : methods1) {
System.out.println(method);
}
}

//注解 Annotation 权限修饰符 Modifiers 返回值类型 ReturnType 参数列表 异常
@Test
public void test2() {
Class clazz = Person.class;
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {
//1.注解
Annotation[] annotations = method.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
//2.权限修饰符
System.out.print(Modifier.toString(method.getModifiers()) + " ");

//3.返回值类型
System.out.print(method.getReturnType() + " ");

//4.方法名
System.out.print(method.getName());

//5.参数列表
System.out.print("(");
Class[] classes = method.getParameterTypes();
for (int i = 0; i < classes.length; i++) {
System.out.print(classes[i].getName() + " args-" + i + "");
}
System.out.print(")");

//6.异常
Class<?>[] exceptionTypes = method.getExceptionTypes();
if (exceptionTypes.length != 0) {
System.out.print("throws ");
}
for (int i = 0; i < exceptionTypes.length; i++) {
System.out.print(exceptionTypes[i].getName());
}
System.out.println();
}
}

//调用运行时类中指定的方法
@Test
public void test3() throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
Class clazz = Person.class;
//getMethod(String methodName,Class..params):获取运行时类中声明为 public 的方法。
Method method = clazz.getMethod("show");
Person p = (Person) clazz.newInstance();

//调用指定的方法：invoke(Object obj,Object ...obj)
Object returnVal = method.invoke(p);

Method method1 = clazz.getMethod("toString
1050c
");
Object returnVal1 = method1.invoke(p);
System.out.println(returnVal1);

//对于运行时类中的 static 方法调用
Method method2 = clazz.getMethod("info");
method2.invoke(Person.class);

//getDeclaredMethod(String methodName,Class ...params):获取运行时类中的
Method method3 = clazz.getDeclaredMethod("display", String.class, Integer.class);
method3.setAccessible(true);
Object returnVal2 = method3.invoke(p, "China", 10);
System.out.println(returnVal2);
}

//调用指定的构造器
@Test
public void test4() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
String className = "Person";
Class clazz = Class.forName(className);
Constructor constructor = clazz.getDeclaredConstructor(String.class, int.class);
constructor.setAccessible(true);
Person p = (Person) constructor.newInstance("Tom",16);
System.out.println(p);
}
}

import org.junit.Test;

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

public class TestOthers {

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

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

//3.获取父类的泛型
@Test
public void test3() {
Class clazz = Person.class;
Type type = clazz.getGenericSuperclass();
ParameterizedType parameterizedType = (ParameterizedType) type;
Type[] types = parameterizedType.getActualTypeArguments();
for (Type type1 : types) {
System.out.println(((Class)type1).getName());
}
}

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

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

//6.获取注解
@Test
public void test6(){
Class clazz = Person.class;
Annotation[] annotations = clazz.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
}

}

//动态代理的使用

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 object;//实现了接口的被代理类的对象的声明

//①给被代理的对象实例化 ②返回一个代理类的对象
public Object bind(Object object) {
this.object = object;
return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
}

//当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的 invoke 方法的调用
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//method 方法的返回值是 returnVal
Object returnVal = method.invoke(object, args);
return returnVal;
}
}

public class TestProxy {
public static void main(String[] args) {
//1.被代理类的对象
RealSubject realSubject = new RealSubject();
//2.创建一个实现了 InvocationHandler 接口的对象
MyInvocationHandler handler = new MyInvocationHandler();
//3.调用 bind() 方法，动态的返回一个同样实现了 real 所在类实现的接口 Subject 的代理类的对象
Object object = handler.bind(realSubject);
Subject subject = (Subject) object;//此时的 subject 就是代理类的对象
/*Object returnVal = */
subject.action();//转到 InvocationHandler 接口的实现类的 invoke() 方法调用
/* System.out.println(returnVal);*/

//再举一个例子

NikeClothFactory nikeClothFactory = new NikeClothFactory();

MyInvocationHandler handler1 = new MyInvocationHandler();

ClothFactory clothFactory = (ClothFactory) handler1.bind(nikeClothFactory);

clothFactory.productCloth();

}
}

import org.junit.Test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Properties;

public class TestReflection {

//关于类的加载器 ClassLoader
@Test
public void Test5() throws ClassNotFoundException, IOException {
ClassLoader classLoader = ClassLoader.getSystemClassLoader();
System.out.println(classLoader);

ClassLoader classLoader1 = classLoader.getParent();
System.out.println(classLoader1);

ClassLoader classLoader2 = classLoader1.getParent();
System.out.println(classLoader2);

Class clazz = Person.class;
ClassLoader classLoader3 = clazz.getClassLoader();
System.out.println(classLoader3);

String className = "java.lang.Object";
Class clazz1 = Class.forName(className);
ClassLoader classLoader4 = clazz1.getClassLoader();
System.out.println(classLoader4);

//掌握
//法一：
ClassLoader classLoader5 = this.getClass().getClassLoader();
InputStream is = classLoader5.getResourceAsStream("jdbc.properties");
//法二：
FileInputStream fis = new FileInputStream(new File("jdbc.properties"));

Properties properties = new Properties();
properties.load(is);
String username = properties.getProperty("username");
System.out.println(username);
String password = properties.getProperty("password");
System.out.println(password);
}

//如何获取 Class 的实例
@Test
public void test4() throws ClassNotFoundException {
//1.调用运行时类本身的 .class 属性。
Class<Person> clazz = Person.class;
System.out.println(clazz.getName());
Class clazz1 = String.class;
System.out.println(clazz1.getName());

//2.通过运行时类的对象获取
Person p = new Person();
Class clazz2 = p.getClass();
System.out.println(clazz2.getName());

//3.通过 Class 的静态方法获取。体现反射的动态性。
String className = "Person";
Class clazz3 = Class.forName(className);
System.out.println(clazz3.getName());

//4.通过类的加载器ClassLoader
ClassLoader classLoader = this.getClass().getClassLoader();
Class clazz4 = classLoader.loadClass(className);
System.out.println(clazz4.getName());
}

/*
* java.lang.Class: 是放射的源头。
*
* 我们创建了一个类，通过编译 ( javac.exe ) ，生成对应的 .class 文件。
* 之后我们用 java.exe 加载 ( JVM 的类加载器 ) 此 .class文件。
* 此 .class 文件加载到内存以后，就是一个运行时类，存在缓存区。
* 那么这个运行时类本身就是一个 Class 的示例。
*
* 1.每一个运行时类只加载一次！
* 2.有了 Class 的实例以后，我们才可以进行如下的操作。
*  1)*创建对应的运行时类的对象
*  2)获取对应的运行时类的完整结构（属性、方法、构造器、内部类、父类、所在的包、异常、注解、...）
*  3)*调用对应的运行时类指定的结构（属性、方法、构造器）
*  4)反射的应用：动态代理
* */
@Test
public void test3() {
Person p = new Person();
Class clazz = p.getClass();//通过运行时类的对象，调用其 getClass() 方法返回其运行时类
System.out.println(clazz);
}

//有了反射，可以通过反射创建一个类的对象， 并调用其中的结构
@Test
public void test2() throws IllegalAccessException, InstantiationException, NoSuchFieldException, NoSuchMethodException, InvocationTargetException {
Class<Person> clazz = Person.class;

//1.创建 clazz 对应的运行时类 Person 类的对象。
Person p = clazz.newInstance();
System.out.println(p);

//2.通过反射调用运行时类指定的属性
//2.1 public
Field f1 = clazz.getField("name");
f1.set(p, "Tony");
System.out.println(p);

//2.2 private
Field f2 = clazz.getDeclaredField("age");
f2.setAccessible(true);
f2.set(p, 15);
System.out.println(p);

Method m1 = clazz.getMethod("show");
m1.invoke(p);

Method m2 = clazz.getMethod("display", String.class);
m2.invoke(p, "Zhongguo");
}

// 在有反射以前，如何创建一个类的对象，并调用其中的方法、属性。
@Test
public void test1() throws Exception {
Person p = new Person();
p.setAge(18);
p.setName("Jack");
p.show();
//p.display("China");
System.out.println(p);
}
}