java.lang.Class<T> -- 反射机制及动态代理

Interface ： Person

package java_.lang_.component.bean;

public interface Person {

    String area = "earth";
    
    public void userAxe();
    
    public void personLaught();
}

Class ： Teacher

package java_.lang_.component.bean.impl;

import java_.lang_.component.bean.Person;

public class Teacher {
    private String subject;
    private Person[] sudents;

    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        this.subject = subject;
    }

    public Person[] getSudents() {
        return sudents;
    }

    public void setSudents(Person[] sudents) {
        this.sudents = sudents;
    }
}

Class ： Chinese

package java_.lang_.component.bean.impl;

import java_.lang_.component.bean.Axe;
import java_.lang_.component.bean.Person;

public class Chinese extends Teacher implements Person {

    private String name;
    private Axe axe;
    public String commonPro;
    
    public Chinese(String name, Axe axe) {
        super();
        this.name = name;
        this.axe = axe;
    }

    public String getCommonPro() {
        return commonPro;
    }

    public void setCommonPro(String commonPro) {
        this.commonPro = commonPro;
    }

    public Chinese() {
        super();
        // TODO Auto-generated constructor stub
    }

    @Override
    public String toString() {
        return "Chinese [name=" + name + ", axe=" + axe + "]";
    }

    @Override
    public void userAxe() {
        System.out.println(name + " 说 ： " + axe.chop());
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Axe getAxe() {
        return axe;
    }

    public void setAxe(Axe axe) {
        this.axe = axe;
    }

    @Override
    public void personLaught() {
        System.out.println("laught");
    }

    public void exception() throws InterruptedException{
        Thread.sleep(1000);
    }

}

Interface ：Axe

package java_.lang_.component.bean;

public interface Axe {

    public String chop();
}

Class ： SteelAxe

package java_.lang_.component.bean.impl;

import java_.lang_.component.bean.Axe;

public class SteelAxe implements Axe {

    @Override
    public String chop() {
        return "用钢斧砍柴真快";
    }

}

Class ：Class_T

package java_.lang_;

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

import java_.lang_.component.bean.Axe;
import java_.lang_.component.bean.Person;
import java_.lang_.component.bean.impl.Chinese;
import java_.lang_.component.bean.impl.SteelAxe;
import java_.lang_.component.bean.impl.Teacher;

//T - 由此 Class 对象建模的类的类型。例如， String.class 的类型是 Class<String>。如果将被建模的类未知，则使用 Class<?>。
//Class 类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，
//所有具有相同元素类型和维数的数组都共享该 Class 对象。
//基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

//Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。
public class Class_T {

    public static void main(String[] args) throws Exception{
        Chinese chinese = new Chinese();
        System.out.println(chinese.getClass().getName());
        System.out.println(chinese.getClass());
        System.out.println("----------------------Class类的常用方法--------------");
//        传入完整的“包.类”名称实例化Class对象
        Class<?> clazzChinese = Class.forName("java_.lang_.component.bean.impl.Chinese");
//        得到一个类中的全部构造方法,按类中构造方法的顺序排列：无参、有参：0、1
        System.out.println("得到一个类中的全部构造方法");
        Constructor[] constructorsChinese = clazzChinese.getConstructors();
        for(Constructor<?> constructor : constructorsChinese){
            System.out.println(constructor);
        }
//        得到本类中单独定义的全部属性
        System.out.println("得到本类中单独定义的全部属性");
        Field[] fieldDeclaredsChinese = clazzChinese.getDeclaredFields();
        for(Field fieldDeclared : fieldDeclaredsChinese){
            System.out.println(fieldDeclared);
        }
//        取得本类继承而来的全部属性
        System.out.println("取得本类继承而来的全部属性");
        Field[] fields = clazzChinese.getFields();
        for(Field field : fields){
            System.out.println(field);
        }
//        得到一个类中的全部方法
        System.out.println("得到一个类中的全部方法");
        Method[] methods = clazzChinese.getMethods();
        for(Method method : methods){
            System.out.println(method);
        }
//        返回一个Method对象，并设置一个方法中的所有参数类型
        System.out.println("返回一个Method对象，并设置一个方法中的所有参数类型");
        Method method = clazzChinese.getMethod("setName", String.class);
        Chinese lime = (Chinese) clazzChinese.newInstance();
        method.invoke(lime, "lime");
        System.out.println(lime.getName());
//        得到一个类中所有实现的全部接口
        System.out.println("得到一个类中所有实现的全部接口");
        Class[] interfaces = clazzChinese.getInterfaces();
        for(Class<?> interfaceClass : interfaces){
            System.out.println(interfaceClass);
        }
//        得到一个类完整的“包.类”名称
        System.out.println("得到一个类完整的“包.类”名称");
        System.out.println(clazzChinese.getName());
//        得到一个类的包
        System.out.println("得到一个类的包");
        System.out.println(clazzChinese.getPackage());
//        得到一个类的父类
        System.out.println("得到一个类的父类");
        System.out.println(clazzChinese.getSuperclass());
//        根据Class定义的类实例化对象
        System.out.println("根据Class定义的类实例化对象");
        Teacher teacher = (Teacher) clazzChinese.newInstance();
        System.out.println(teacher);
//        返回表示数组类型的Class
        System.out.println("返回表示数组类型的Class");
        Class<? extends Person[]> clazzArray = new Person[]{}.getClass();
        System.out.println(clazzArray);
//        判断此Class 是否是一个数组
        System.out.println("判断此Class 是否是一个数组");
        if(clazzArray.isArray()){
            System.out.println("isArray");
        }else{
            System.out.println("not isArray");
        }
        System.out.println("budong");
//        通过无参构造实例化对象
        System.out.println("通过无参构造实例化对象");
        Chinese china = (Chinese) clazzChinese.newInstance();
        System.out.println(china);
//        调用有参构造实例化对象
        System.out.println("调用有参构造实例化对象");
        Constructor[] constructorsChina = clazzChinese.getConstructors();
        Person person = (Person) constructorsChina[0].newInstance("lime",new SteelAxe());
        person.userAxe();
        System.out.println("-------------Constructor常用方法--------------------");
//        得到构造方法的修饰符
        System.out.println("得到构造方法的修饰符");
        int modifier = constructorsChina[0].getModifiers();
        System.out.println(modifier);
        System.out.println(Modifier.toString(modifier));
//        得到构造方法的名称
        System.out.println("得到构造方法的名称");
        System.out.println(constructorsChina[0].getName());
//        得到构造方法中参数的类型
        System.out.println("得到构造方法中参数的类型");
        Class[] parameterTypes = constructorsChina[0].getParameterTypes();
        for(Class<?> parameterType : parameterTypes){
            System.out.println(parameterType);
        }
//        返回此构造的信息
        System.out.println("返回此构造的信息");
        for(Constructor<?> constructor : constructorsChina){
            System.out.println(constructor.toString());
        }
//        向构造方法中传递参数，实例化对象
        System.out.println("向构造方法中传递参数，实例化对象");
        Chinese per = (Chinese) constructorsChina[0].newInstance("lime",new SteelAxe());
        System.out.println(per.toString());
        
        System.out.println("----------------------反射的应用------取得类的结构-----------------");
        
        System.out.println("-----------------------取得全部方法--------------------");
        System.out.println("---------------------Method类中的常用方法---------------");
//        取得本方法的访问修饰符
        System.out.println("取得本方法的访问修饰符");
        Method meth = clazzChinese.getDeclaredMethod("setName",String.class);
        System.out.println(meth.getModifiers());
        System.out.println(Modifier.toString(meth.getModifiers()));
//        获取方法的名称
        System.out.println("获取方法的名称");
        Method[] meths = clazzChinese.getDeclaredMethods();
        for(Method metho : meths){
            System.out.println(metho.getName());
        }
//        得到方法的全部参数类型
        System.out.println("得到方法的全部参数类型");
        for(Method metho : meths){
            System.out.println(metho.getName());
            Class[] params = metho.getParameterTypes();
            for(Class<?> param : params){
                System.out.println(param);
            }
        }
//        得到方法的返回值类型
        System.out.println("得到方法的返回值类型");
        for(Method metho : meths){
            System.out.print(Modifier.toString(metho.getModifiers()) + " ");
            System.out.println(metho.getReturnType());
        }
//        得到一个方法的全部抛出异常
        System.out.println("得到一个方法的全部抛出异常");
        Method methodException = clazzChinese.getMethod("exception");
        System.out.print(Modifier.toString(methodException.getModifiers()) + " ");
        System.out.print(methodException.getReturnType() + " ");
        System.out.print(methodException.getName() + "(");
        Class[] paramMethods = methodException.getParameterTypes();
        if(paramMethods.length > 0){
            for(int i = 0;i < paramMethods.length - 1;i++){
                System.out.print(paramMethods[i].getName().substring(paramMethods[i].getName().lastIndexOf(".")) + ",");
            }
            System.out.print(paramMethods[paramMethods.length-1]);
        }
        System.out.print(") throws ");
        Class[] exceptionClasses = methodException.getExceptionTypes();
        if(exceptionClasses.length > 0){
            for(int i = 0;i < exceptionClasses.length - 1;i++){
                System.out.print(exceptionClasses[i].getName().substring(exceptionClasses[i].getName().lastIndexOf(".")) + ", ");
            }
            System.out.println(exceptionClasses[exceptionClasses.length-1].getName());
        }
        for(Class<?> exce : exceptionClasses){
            System.out.println(exce);
        }
        
        System.out.println("---------------------------------------------");
        System.out.println("--------------------获取全部属性-----------------");
        System.out.println("----------------Field类的常用方法----------------");
//        得到一个对象中属性的具体内容
        System.out.println("得到一个对象中属性的具体内容");
        Chinese ch = (Chinese) clazzChinese.newInstance();
        Field commonPro = clazzChinese.getDeclaredField("commonPro");
        System.out.println(commonPro.getName() + " isAccessible " + commonPro.isAccessible());
        commonPro.set(ch, "lime");
        commonPro.get(ch);
        System.out.println(ch.getCommonPro());
        Field name = clazzChinese.getDeclaredField("name");
        System.out.println(name.getName() + " isAccessible " + name.isAccessible());
        if(name.isAccessible()){
        }else{
            name.setAccessible(true);
            name.set(ch, "Oracle");
            name.get(ch);
            System.out.println(ch.getName());

        }
//        设置指定对象中属性的具体内容
        System.out.println("设置指定对象中属性的具体内容");
//        得到属性的修饰符
        System.out.println("得到属性的修饰符");
        System.out.println(commonPro.getModifiers());
        System.out.println(Modifier.toString(commonPro.getModifiers()));
//        返回此属性的名称
        System.out.println("返回此属性的名称");
        System.out.println(commonPro.getName());
//        判断此属性是否可被外部访问
        System.out.println("判断此属性是否可被外部访问");
        System.out.print(Modifier.toString(commonPro.getModifiers()) + " ");
        if(commonPro.isAccessible()){
            System.out.println("isAccessible");
        }else{
            System.out.println("not isAccessible");
        }
        System.out.print(Modifier.toString(clazzChinese.getDeclaredField("name").getModifiers()) + " ");
        if(clazzChinese.getDeclaredField("name").isAccessible()){
            System.out.println("isAccessible");
        }else{
            System.out.println("not isAccessible");
        }
//        设置一个属性是否可被外部访问
        System.out.println("设置一个属性是否可被外部访问");
        commonPro.setAccessible(true);
        if(commonPro.isAccessible()){
            System.out.println("isAccessible");
        }else{
            System.out.println("not isAccessible");
        }
//        设置一组属性是否可被外部访问
        System.out.println("设置一组属性是否可被外部访问");
        Field[] fieldsAll = clazzChinese.getDeclaredFields(); 
        System.out.println("设置前");
        for(Field field : fieldsAll){
            System.out.println(field.getName() + " isAccessible:" + field.isAccessible());
        }
        for(Field field : fieldsAll){
            field.setAccessible(true);
        }
        System.out.println("全部设置为true");
        for(Field field : fieldsAll){
            System.out.println(field.getName() + " isAccessible:" + field.isAccessible());
        }
//        获取属性的类型
        System.out.println("获取属性的类型");
        for(Field field : fieldsAll){
            System.out.println(field.getName() + " " + field.getType());
        }
//        获取继承父类的全部属性
        System.out.println("获取继承父类的全部属性");
        Field[] fieldsDeclared = clazzChinese.getFields();
        for(Field field : fieldsDeclared){
            System.out.println(field.getName());
        }
        System.out.println("----------------------------------------------");
        System.out.println("-------------------Java反射机制的深入应用-------------");
        System.out.println("-------------通过反射调用类中的方法-------------------");
//        通过反射调用类中的方法
        System.out.println("通过反射调用类中的方法");
        {
            Method methodSetAxe = clazzChinese.getDeclaredMethod("setAxe", Axe.class);
            Chinese chin = (Chinese) clazzChinese.newInstance();
            methodSetAxe.invoke(chin, new SteelAxe());
            System.out.println(chin.getAxe());
        }
//        调用setter和getter方法
        System.out.println("模拟setter和getter方法");
        System.out.println("懒得写");
//        通过反射操作属性
        System.out.println("通过反射操作属性");
//        得到一个对象中属性的具体内容
        System.out.println("得到一个对象中属性的具体内容");
        Chinese ch1 = (Chinese) clazzChinese.newInstance();
        Field commonPro1 = clazzChinese.getDeclaredField("commonPro");
//        commonPro1.setAccessible(true);
        commonPro1.set(ch1, "lime");
        commonPro1.get(ch1);
        System.out.println(ch1.getCommonPro());
        System.out.println("-----------通过反射操作数组--------------");
        System.out.println("-----------Array类的常用方法------------");
//        根据下标取得数组内容
        System.out.println("根据下标取得数组内容");
        int[] temp = {1,2,3};
        Class<?> c = temp.getClass().getComponentType();
        System.out.println("类型：" + c.getName());
        System.out.println("长度：" + Array.getLength(temp));
        System.out.println("第一个内容：" + Array.get(temp,0));
//        修改指定位置的内容
        System.out.println("修改指定位置的内容");
        Array.set(temp, 0, 6);
        System.out.println("第一个内容：" + Array.get(temp,0));
//        根据已有的数组类型开辟新的数组对象
        System.out.println("根据已有的数组类型开辟新的数组对象");
        int[] newTemp = (int[]) Array.newInstance(temp.getClass().getComponentType(), Array.getLength(temp)*2);
        System.arraycopy(temp, 0, newTemp, 0, temp.length);
        for(int array : newTemp){
            System.err.print(array);
        }
        System.out.println();
        System.out.println(Array.getLength(newTemp));
        for(int i = 0;i < Array.getLength(newTemp);i++){
            System.out.print(Array.get(newTemp, i));
        }
        System.out.println("--------------------------------");
    }
}

 　　　　动态代理

　　　　　　通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。

　　　　　　在Java中想实现动态代理机制，则需要java.lang.reflect.InvocationHandler接口和java.lang.reflect.Proxy类的支持。

　　　　　　InvocationHandler接口的定义如下：

/*
     * proxy : （此处有误吧？被代理的对象）应该是指最终生成的代理对象，打印出来是class $proxy0
     * method : 要调用的方法
     * args[] : 方法调用时所需要的参数。
     */
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable;

　　　　　　Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类。

　　　　　　Proxy类提供了如下的操作方法：

//    通过newProxyInstance()方法可以动态地生成实现类
    /*
     * loader : 类加载器。Proxy.class.getClassLoader().getClass().getName();
     * interfaces : 得到全部的接口。
     * hander : 得到Invocationhandler接口的子类实例。
     */
    public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler handler) throws lllegalArgumentException{
        
    }

　　　　　　Class ： MyInvocationHandler

package edu.pri.lime._7_8_3.demo.bean;

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

public class MyInvocationHandler implements InvocationHandler{

//    真实主题
    private Object obj;
//    绑定真实操作主题
    public Object bind(Object obj){
        this.obj = obj;
//        Proxy类是专门完成代理的操作类，可以通过此类为一个或多个接口动态地生成实现类。
//        通过Proxy.newProxyInstance()可以动态地生成实现类
//        取得代理对象
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
    }
    
//    动态调用方法
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
//        调用方法，传入真实主题和参数
        args[0] = "Oracle";
        Object temp = method.invoke(this.obj, args);
//        返回方法的返回信息
        return temp;
    }

}

　　　　　　Interface ： Subject

package edu.pri.lime._7_8_3.demo.bean;

//定义Subject接口
public interface Subject {
//    定义抽象方法say
    public String say(String name,int age);
}

　　　　　　Class ： RealSubject

package edu.pri.lime._7_8_3.demo.bean.impl;

import edu.pri.lime._7_8_3.demo.bean.Subject;

//定义真实主题实现类
//在操作时直接将真实主题类的对象传入到MyInvocationHandler类的bind()方法中即可
public class RealSubject implements Subject {

    public String say(String name, int age) {
        return "姓名:" + name + ", 年龄:" + age;
    }

}

　　　　　　Class ： DynaProxyDemo

package edu.pri.lime._7_8_3.demo.main;

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

import edu.pri.lime._7_8_3.demo.bean.MyInvocationHandler;
import edu.pri.lime._7_8_3.demo.bean.Subject;
import edu.pri.lime._7_8_3.demo.bean.impl.RealSubject;

public class DynaProxyDemo {

    public static void main(String[] args) {
        {
            // 实例化代理操作类
            MyInvocationHandler handler = new MyInvocationHandler();
            // 绑定对象
            Subject sub = (Subject) handler.bind(new RealSubject());
            // 通过动态代理调用方法
            String info = sub.say("lime", 20);
            System.out.println(info);
        }
    }
}

　　　　　　Console ：

姓名:Oracle, 年龄:20

啦啦啦

啦啦啦