Java 反射

//-- 练习使用反射技术获取带有@Controller 标注的方法，并执行它。

import java.lang.reflect.*;
/**
 * 设计模式+反射+注解（xml） Spring Hibernate MyBatis
 * 反射机制
 * ：Java语言提供的一种可以窥探class类里的属性和方法技术。
 * 原理：
 */
public class Demo03 {
    public static void main(String[] args) throws Exception {
        //--  1.拿到Student类的类对象，也就是那个Class类型的对象
        //--  2. 获取的方式：方式一：
        Class c1 = Class.forName("day02.Student");//包+类名
        //--                方式二：
        Class c2 = Student.class;
        //System.out.println(c1 == c2);
        //-- 问题一： Student类什么时候获取的：类加载
        //-- 问题二： 什么时候类会被加载：
        //Student stu;不会加载Student（可以利用静态代码块模拟看）
        //--  3. 使用 Class 对象获取类的属性
        Field[] fs = c1.getDeclaredFields();
        
        //-- 4. 遍历所有的属性，进行输出
        for (Field field : fs) {
            System.out.println(field.getType() + " " + field.getName());
        }
        
        //-- 5. 使用 Class 对象获取类的方法
        Method[] methods = c1.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method.getReturnType() + " " +method.getName());
        }
    }
}
//-- 每个类里面有一个Class类型的属性，这个类类型的对象可以窥探本类的一切。
//-- 而且该类类型的对象对于某个类来说，有且仅有一个。
class Student{
    //-- 属性
    //默认带有 Student this; Object super; static Class c(通过这个属性进行反射);    
    String name;
    //-- 方法
    public void study() {
        System.out.println("we love study");
    }
    static{
        System.out.println("Student 被加载。。。");
    }
}

/**
 * 反射工具类
 *
 */
public class ReflectUtil {
    /**
     * 获取某个类的某个方法
     */
    public static Method getMethod(String className, String methodName) {
        Class c;
        try {
            c = Class.forName(className);
        } catch (ClassNotFoundException e) {
            return null;
        }
        Method[] ms = c.getDeclaredMethods();
        for (Method method : ms) {
            if (method.equals(methodName)) {
                return method; 
            }
        }
        return null;
    } 
    
    /**
     * @param className
     * @param annotationName
     * @return Object
     *  使用反射技术获取带有@Controller 标注的方法。框架的原理。
     */
    
    public static Object excuteMethodWithAnnotation(String className,String annotationName) throws Exception {
        //-- 1. 获取类类型对象
        Class c = null;
        Object o = null;
        try {
            c = Class.forName(className);
            //-- 2 . 创建一个类对象对应得类得对象
            o = c.newInstance(); //多态
        } catch (Exception e) {
            e.printStackTrace();
        }
        
        //-- 3. 获取该类的所有的方法
        Method[] ms = c.getDeclaredMethods();
        //-- 4. 遍历方法
        for (Method method : ms) {
            //-- 5. 判断某方法是否被我们给定的标注所标注，若有则执行
            Annotation[] ans = method.getDeclaredAnnotations();
            for (Annotation an : ans) {
                //-- 6.判断哪个标注是我们给定的标注
                if (an.annotationType().getSimpleName().equals(annotationName)){
                    //-- 7. 执行该方法
                    Object result = method.invoke(o, null);//-- o 代表实列对象，args代表调用的方法的参数。
                    return result;
                }
            }
        }
        return null;
    }
    
}

写个标注@calculator，再利用反射写一个方法，
 这个方法用于计算某个加有@calculator标注的类的方法的运行时间（耗时）

package day02.util;

import java.lang.annotation.*;
import java.lang.reflect.*;

public class 作业 {
    public static void main(String[] args) throws Exception {
        
        String calculatorMethod = ReflectUtil2.calculatorMethod("day02.util.Test00000", "calculator");
        System.out.println(calculatorMethod);
        
    }
}

@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface calculator{
    String value() default "计算方法时间";
}

class ReflectUtil2{
    public static String calculatorMethod(String className, String annotationName) throws Exception {
        Class c = Class.forName(className);
        Object obj = c.newInstance();
        
        Method[] methods = c.getDeclaredMethods();
        for (Method method : methods) {
            Annotation[] annotations = method.getDeclaredAnnotations();
            for (Annotation annotation : annotations) {
                if(annotation.annotationType().getSimpleName().equals(annotationName)) {
                    //long startTimeMillis = System.currentTimeMillis();
                    long startTimeMillis = System.nanoTime();
                    method.invoke(obj, null);
                    //long endTimeMillis = System.currentTimeMillis()-startTimeMillis;
                    long endTimeMillis = System.nanoTime()-startTimeMillis;
                    return endTimeMillis+"ns";
                }
            }
        }
        
        return null;
    }
}
class Test00000 {
    
    @calculator
    public void test() {
        for(int i = 0; i <= 1000; i++) {
            //System.out.print(i);
            if(i%100 == 0) {
                //System.out.println();
            }
        }
    }
}