JAVA反射Reflection知识汇总

// aClass实例相当于Consumer实例
Class aClass = Class.forName("com.Test.Consumer");
Object o =aClass.newInstance();

Field field = c4.getDeclaredField("name");
String name = field.get(o);

Class[] p = {String.class};
constructors = c4.getDeclaredConstructor(p)

Class[] p4 = {String.class};
Method method = c4.getDeclaredMethod("welcome",p4);

Class c1 = Class.forName("com.test.bean.Xxx");
Object o = c1.newInstance();
Field field2 = c1.getField("sex");
field2.set(o, 1);

Class c2 = Class.forName("com.test.bean.Xxx");
Class[] p = {String.class, Integer.class, Integer.class, String.class};
Constructor constructor1 = c2.getConstructor(p);
Object o1 = constructor1.newInstance("码云", 1, 57, "资本家");

Class c2 = Class.forName("com.test.bean.Xxx");
Method method1 = c2.getMethod("sout");
method.invoke(o1);

method1.setAccessible(true);

 public class MyClass {
  protected List<String> stringList = ...;
  public List<String> getStringList(){
    return this.stringList;
  }
}

Method method = MyClass.class.getMethod("getStringList", null);
// 返回方法返回对象类型
Type returnType = method.getGenericReturnType();
// 比较是否为参数化类型
if(returnType instanceof ParameterizedType){
    ParameterizedType type = (ParameterizedType) returnType;
    Type[] typeArguments = type.getActualTypeArguments();
    for(Type typeArgument : typeArguments){
        Class typeArgClass = (Class) typeArgument;
        System.out.println("typeArgClass = " + typeArgClass);
        // 打印结果:"typeArgClass = java.lang.String"
    }
}

public void setStringList(List<String> list){
    this.stringList = list;
}

method = Myclass.class.getMethod("setStringList", List.class);
// 返回方法参数类型
Type[] genericParameterTypes = method.getGenericParameterTypes();

for(Type genericParameterType : genericParameterTypes){
    if(genericParameterType instanceof ParameterizedType){
        ParameterizedType aType = (ParameterizedType) genericParameterType;
        Type[] parameterArgTypes = aType.getActualTypeArguments();
        for(Type parameterArgType : parameterArgTypes){
            Class parameterArgClass = (Class) parameterArgType;
            System.out.println("parameterArgClass = " + parameterArgClass);
        }
    }
}

public class MyClass {
  public List<String> stringList = ...;
}

Field field = MyClass.class.getField("stringList");

Type genericFieldType = field.getGenericType();

if(genericFieldType instanceof ParameterizedType){
    ParameterizedType aType = (ParameterizedType) genericFieldType;
    Type[] fieldArgTypes = aType.getActualTypeArguments();
    for(Type fieldArgType : fieldArgTypes){
        Class fieldArgClass = (Class) fieldArgType;
        System.out.println("fieldArgClass = " + fieldArgClass);
    }
}

@MyAnnotation(name="someName",  value = "Hello World")
public class TheClass {
}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)

public @interface MyAnnotation {
  public String name();
  public String value();
}

Class aClass = TheClass.class;
Annotation[] annotations = aClass.getAnnotations();

for(Annotation annotation : annotations){
    if(annotation instanceof MyAnnotation){
        MyAnnotation myAnnotation = (MyAnnotation) annotation;
        System.out.println("name: " + myAnnotation.name());
        System.out.println("value: " + myAnnotation.value());
    }
}

public class TheClass {
  public static void doSomethingElse(
        @MyAnnotation(name="aName", value="aValue") String parameter){
  }
}

Method method = ... //获取方法对象
Annotation[][] parameterAnnotations = method.getParameterAnnotations();
Class[] parameterTypes = method.getParameterTypes();

int i=0;
for(Annotation[] annotations : parameterAnnotations){
  Class parameterType = parameterTypes[i++];

  for(Annotation annotation : annotations){
    if(annotation instanceof MyAnnotation){
        MyAnnotation myAnnotation = (MyAnnotation) annotation;
        System.out.println("param: " + parameterType.getName());
        System.out.println("name : " + myAnnotation.name());
        System.out.println("value: " + myAnnotation.value());
    }
  }
}

int``[] intArray = (``int``[]) Array.newInstance(``int``.``class``, ``3``);

Array.set(intArray, 0, 123);
Array.set(intArray, 1, 456);
Array.set(intArray, 2, 789);

System.out.println("intArray[0] = " + Array.get(intArray, 0));
System.out.println("intArray[1] = " + Array.get(intArray, 1));
System.out.println("intArray[2] = " + Array.get(intArray, 2));

Class intArray = Class.forName(``"[I"``);

Class stringArrayClass = Class.forName(``"[Ljava.lang.String;"``);

// 直接获取的化，这样都会抛出ClassNotFoundException
Class intClass1 = Class.forName("I");
Class intClass2 = Class.forName("int");

Class stringArrayClass = String[].``class``;

public Class getClass(String className){
  if("int" .equals(className)) return int .class;
  if("long".equals(className)) return long.class;
  ...
  return Class.forName(className);
}
...
Class theClass = getClass(theClassName);

public class MainClass {
  public static void main(String[] args){
    ClassLoader classLoader = MainClass.class.getClassLoader();
    try {
        Class aClass = classLoader.loadClass("com.jenkov.MyClass");
        System.out.println("aClass.getName() = " + aClass.getName());
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
}

public class MyObject extends MyObjectSuperClass implements AnInterface2{
    //... body of class ... override superclass methods
    //    or implement interface methods
}

public class MyClassLoader extends ClassLoader{

    public MyClassLoader(ClassLoader parent) {
        super(parent);
    }

    public Class loadClass(String name) throws ClassNotFoundException {
        if(!"reflection.MyObject".equals(name))
                return super.loadClass(name);

        try {
            String url = "file:C:/data/projects/tutorials/web/WEB-INF/" +
                            "classes/reflection/MyObject.class";
            URL myUrl = new URL(url);
            URLConnection connection = myUrl.openConnection();
            InputStream input = connection.getInputStream();
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            int data = input.read();
            while(data != -1){
                buffer.write(data);
                data = input.read();
            }
            input.close();
            byte[] classData = buffer.toByteArray();
            return defineClass("reflection.MyObject",
                    classData, 0, classData.length);
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

public static void main(String[] args) throws
    ClassNotFoundException,
    IllegalAccessException,
    InstantiationException {

    ClassLoader parentClassLoader = MyClassLoader.class.getClassLoader();
    MyClassLoader classLoader = new MyClassLoader(parentClassLoader);
    Class myObjectClass = classLoader.loadClass("reflection.MyObject");

    AnInterface2       object1 =
            (AnInterface2) myObjectClass.newInstance();

    MyObjectSuperClass object2 =
            (MyObjectSuperClass) myObjectClass.newInstance();

    //重载类需要创建一个新的类加载器
    classLoader = new MyClassLoader(parentClassLoader);
    myObjectClass = classLoader.loadClass("reflection.MyObject");
        
    object1 = (AnInterface2)       myObjectClass.newInstance();
    object2 = (MyObjectSuperClass) myObjectClass.newInstance();
}

interface Worker {
    // 售票;
    void sell();
}
/**
** 线上
*/class online implements Worker {
    @Override
    public void sell() {
        System.out.println("需支付300元票费");
    }
}
/**
** 线下
*/class Offline implements Worker {

    // 私有一个被代理类的父类引用,这样做是为了适应所有的被代理类对象,只要实现了接口就好;
    private Worker online;

    // 传入被代理类对象,这里的作用是初始化"代理类"中的"被代理类"对象;
    public Offline(Worker online) {
        this.online = online;
    }

    /**
     * 增强服务和功能;
     */    @Override
    public void sell() {
        // 代理实现线上服务;
        online.sell();
        // 额外服务;
        noQueue();
    }

    // 代理类本身自带功能;
    public void noQueue() {
        System.out.println("需支付40元线下税");
    }
}

public Object invoke(Object proxy, Method method, Object[] args)
    throws Throwable;

public class WorkHandler implements InvocationHandler{
    // 需要代理的类
    private Object obj;
    public WorkHandler() {
        // TODO Auto-generated constructor stub
    }
    // 构造函数
    public WorkHandler(Object obj) {
        this.obj = obj;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //在真实的对象执行之前我们可以添加自己的操作
        System.out.println("代理处理开始。。。");
        Object invoke = method.invoke(obj, args);
        //在真实的对象执行之后我们可以添加自己的操作
        System.out.println("方法代理完毕!");
        System.out.println("代理处理结束。。。");
        return invoke;
    }
}

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

public interface Subject {
    public String SayHello(String name);
}

public class RealSubject implements Subject{
    @Override
    public String SayHello(String name) {
        return "hello " + name;
    }

    @Override
    public String toString() {
        return "RealSubject{}";
    }
}

public class ProxyMain {
    public static void main(String[] args) throws Exception {
        Subject real =new RealSubject();
        ClassLoader loader = ProxyMain.class.getClassLoader();

        // 创建一个InvocationHandler实例，用作处理代理逻辑
        InvocationHandler handler = new WorkHandler(real);
        // 创建代理
        Subject realSubjectProxy = (Subject)Proxy.newProxyInstance(loader, new Class[]{Subject.class}, handler);
    }
}

System.out.println(realSubjectProxy.SayHello("我是一个代理类"));

代理处理开始。。。
方法代理完毕!
代理处理结束。。。
hello 我是一个代理类

System.out.println(realSubjectProxy.getClass().getName());

com.sun.proxy.$Proxy0

/**
 * @description: TODO
 */public class WorkHandler implements InvocationHandler {
    // 需要代理的类
    private Object object;

    /**
     * 生成绑定后的动态代理类
     *
     * @param object 需要代理的类
     * @return Object 动态代理类
     */    public Object bind(Object object) {
        this.object = object;
        return Proxy.newProxyInstance(this.object.getClass().getClassLoader(),
                this.object.getClass().getInterfaces(), this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object returnObject = null;
        ...
        returnObject = method.invoke(object, args);
        ...
        return returnObject;
    }
}