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

时间：2022-09-27 17:38:38

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

啦啦啦

啦啦啦

相关文章