• Java-反射调用类的完整结构,动态代理


    实例class类

    public class Person {
        public String name;
        int age;
    }
    ----------------------------------------------------------------------------------------------
    public class Test {
        public static void main(String[] args) {
            Person p = new Person();
            Class clazz = p.getClass();//clazz对象中就包含对象p所属的Person类的所有的信息
            
            
            Class c0 = Person.class;//通过类名.class创建指定类的Class实例
            
            Class c1 = p.getClass();//通过一个类的实例对象的getClass()方法,获取对应实例对象的类的Class实例
            
            try {
                //通过Class的静态方法forName(String className)来获取一个类的Class实例
                //forName(String className)方法中的参数是你要获取的Class实例的类的全路径(包名.类名)
                Class c2 = Class.forName("day14.Person");//这个是获取Class实例的常用方式
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            
        }
    }
    

    通过反射调用类的完整结构

    所用到的对象与接口

    public interface Move {
        void moveType();
    }
    ----------------------------------------------------------------------------------------------
    public interface Study {
        void studyInfo();
    }
    ----------------------------------------------------------------------------------------------    
    public class Student extends Person implements Move,Study{
        public Student(){
            System.out.println("调用的是public Student()");
        }
        
        public Student(String school){
            this.school = school;
            System.out.println("调用的是public Student(String school)");
        }
    
        private Student(String name,int age){
            this.name = name;
            this.age = age;
            System.out.println("调用的是private Student(String name,int age)");
        }
        public String school;
        private String privateField;
        
        public void showInfo(){
            System.out.println("学校是:" + this.school);
        }
        
        @Override
        public void studyInfo() {
            System.out.println("学习的中学的知识");
        }
    
        @Override
        public void moveType() {
            System.out.println("骑自行车上学");
        }
        
        private void test(String name){
            System.out.println("这是私有方法private void test(String name)");
        }
        
        public String getSchool(){
            return this.school;
        }
        
        public void setInfo(String name,String school){
            this.name = name;
            this.school = school;
            System.out.println("这个是setInfo(String name,String school)方法");
        }
        
        public void setInfo(int age){
            System.out.println("这个是public void setInfo(int age)方法");
        }
    }
    

    实现的全部接口

    public class Test1 {
        public static void main(String[] args) {
            try {
                Class clazz = Class.forName("day14.Student");//通过包名.类名的字符串,调用Class.forName方法获取指定类的Class实例
                
                 (以上部分省略)
                Class superClazz = clazz.getSuperclass();//获取父类
                System.out.println("父类:" + superClazz.getName());
                (以下部分省略)
                } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    

    所继承的父类

    public class Test1 {
        public static void main(String[] args) {
            try {
                Class clazz = Class.forName("day14.Student");//通过包名.类名的字符串,调用Class.forName方法获取指定类的Class实例
                 (以上部分省略)
                Class[] interfaces = clazz.getInterfaces();//获取当前类的所有接口
                for(Class c : interfaces){
                    System.out.println("接口:" + c.getName());
                }
                (以下部分省略)	
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
    

    全部的构造器

    Constructor[] cons = clazz.getConstructors();//获取到类的公有的构造方法
    
    for(Constructor c : cons){
        System.out.println("构造方法名称:" + c.getName());//取得方法名称
        //getModifiers取得方法的修饰符,返回数组1代表public
        System.out.println("构造方法:" + c.getName() + "的修饰符是:" + c.getModifiers());
        
        Class[] paramClazz = c.getParameterTypes();
        for(Class pc : paramClazz){
            System.out.println("构造方法:" + c.getName() + "的参数类型是:" + pc.getName());
        }
    }
    -------------------------------------------------------------------------------------
    Constructor[] cons1 = clazz.getDeclaredConstructors();//获取类的所有构造方法,包括公有和私有的
    for(Constructor c : cons1){
        
        System.out.println("-------------------------------------");
        
        System.out.println("构造方法名称:" + c.getName());//取得方法名称
        //getModifiers取得方法的修饰符,返回数组1代表public,返回数组2代表是private
        System.out.println("构造方法:" + c.getName() + "的修饰符是:" + c.getModifiers());//getModifiers取得方法的修饰符
        
        Class[] paramClazz = c.getParameterTypes();//获取构造方法的参数类型,有几个参数数组的元素就有几个
        for(Class pc : paramClazz){
            System.out.println("构造方法:" + c.getName() + "的参数类型是:" + pc.getName());
        }
        
        System.out.println("-------------------------------------");
    }
    

    利用反射构造方法创建对象

    Object obj = clazz.newInstance();//相当于调用Student类的无参公有的构造方法
    Student stu = (Student)obj;
    ------------------------------------------------------------
    Constructor c = clazz.getConstructor(String.class);//指定获取有一个参数并且为String类型的公有的构造方法
    Student stu1 = (Student)c.newInstance("第一中学");//newInstance实例化对象,相当于调用public Student(String school)
    System.out.println(stu1.school);
    ------------------------------------------------------------
    //通过反射机制,可以强制的调用私有的构造方法
    Constructor c = clazz.getDeclaredConstructor(String.class,int.class);//指定获取有两个参数(String,int)的构造方法
    c.setAccessible(true);//解除私有的封装,下面就可以对这个私有方法强制调用
    Student stu = (Student)c.newInstance("zhangsan",12);
    

    全部的方法

    <!-- Method[] ms = clazz.getMethods();//获取到类的所有公有的方法 -->
    Method[] ms = clazz.getDeclaredMethods();//获取类所有方法,包含公有和私有
    for(Method m : ms){
        System.out.println("方法名:" + m.getName());
        System.out.println("返回值类型:" + m.getReturnType());
        System.out.println("修饰符:" + m.getModifiers());
        
        Class[] pcs = m.getParameterTypes();//获取方法的参数类型,是一个数组,方法有几个参数,数据就有几个元素
        if(pcs != null && pcs.length > 0){
            for(Class pc : pcs){
                System.out.println("参数类型:" + pc.getName());
            }
        }
        
        System.out.println("==============================================");
    }
    

    全部的Field(即属性)

    <!-- Field[] fs = clazz.getFields();//获取类的公有的属性,包含父类的公有属性			 -->
    Field[] fs = clazz.getDeclaredFields();//获取本类的(不包括父类的属性)所有的属性,包括私有
    
    for(Field f : fs){
        System.out.println("修饰符:" + f.getModifiers());
        System.out.println("属性的类型:" + f.getType());
        System.out.println("属性的名称:" + f.getName());
    }
    

    类所在的包

    Package p = clazz.getPackage();//获取类所在的包
    System.out.println(p.getName());
    

    反射调用公有代码

    Constructor con = clazz.getConstructor();//获取无参构造
    Object obj = con.newInstance();//使用无参构造创建对象
    

    调用公有方法

    Method m = clazz.getMethod("setInfo", String.class,String.class);//得到名称叫setInfo,参数是String,String的方法
    m.invoke(obj, "zhangsan","第一中学");//参数1是需要实例化的对象,后面的参数是调用当前的方法实际参数
    

    调用私有方法

    //如果想要调用一个私有方法
    Method m1 = clazz.getDeclaredMethod("test", String.class);//获取方法名为test,参数为1个String类型的方法
    
    m1.setAccessible(true);//解除私有的封装,下面可以强制调用私有的方法
    
    m1.invoke(obj, "李四");
    

    反射调用重载方法

    Method m2 = clazz.getMethod("setInfo", int.class);//setInfo的重载方法
    m2.invoke(obj, 1);
    

    反射调用有返回值的方法

    //有返回值的方法
    Method m3 = clazz.getMethod("getSchool");//这是获取方法名为getSchool并且没有参数的方法
    String school = (String)m3.invoke(obj);//调用有返回值的但是没有参数的方法
    System.out.println(school);
    

    反射调用公有属性

    Field f = clazz.getField("school");//获取名称为school的属性
    f.set(stu, "第三中学");//对stu对象的school属性设置值"第三中学"
    String school = (String)f.get(stu);//获取stu对象的school属性的值
    System.out.println(school);
    

    反射调用私有属性

    Field f1 = clazz.getDeclaredField("privateField");
    f1.setAccessible(true);//解除私有的封装,下面就可以强制的调用这个属性
    f1.set(stu, "测试私有属性");
    System.out.println(f1.get(stu));
    

    动态代理

    理解:就是很多类绑在一起,同时改变,加入同一方法

    public class TestDemoImpl implements ITestDemo {
    
        @Override
        public void test1() {
            System.out.println("执行test1()方法");
        }
    
        @Override
        public void test2() {
            System.out.println("执行test2()方法");
        }
    }
    ------------------------动态代理类--------------------------------
    public class ProxyDemo implements InvocationHandler{
    
        Object obj;//被代理的对象
        
        public ProxyDemo(Object obj){
            this.obj = obj;
        }
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            
            System.out.println(method.getName() + " 方法开始执行");
            
            Object result = method.invoke(this.obj, args);//执行的是指定代理对象的指定的方法
            
            System.out.println(method.getName() + " 方法执行完毕");
            return result;
        }
    
    }
    -------------------------------------------------------------------
    public class Test2 {
        public static void main(String[] args) {
            ITestDemo test = new TestDemoImpl();
            /**
            * 注意:如果一个对象想要通过Proxy.newProxyInstance方法被代理,
            * 那么这个对象的类一定要有相应的接口
            * 就像本类中的ITestDemo接口和实现类TestDemoImpl
            */
            test.test1();
            test.test2();
            System.out.println("======================");
            /**
            * 需求:
            * 在执行test1和test2方法时需要加入一些东西
            * 在执行方法前打印test1或test2开始执行
            * 在执行方法后打印test1或test2执行完毕
            * 打印的方法名要和当时调用方法保存一致
            */
            
            InvocationHandler handler = new ProxyDemo(test);
            /**
            * Proxy.newProxyInstance(ClassLoader, interfaces, h)
            * 参数1是代理对象的类加载器
            * 参数2是被代理的对象的接口
            * 参数3是代理对象
            * 
            * 返回的值就成功被代理后对象,返回的是Object类型,需要根据当时的情况去转换类型
            */
            ITestDemo t = (ITestDemo)Proxy.newProxyInstance(handler.getClass().getClassLoader(), test.getClass().getInterfaces(), handler);
            
            t.test1();
            System.out.println("-----------------------");
            t.test2();
            
        }
    }
    -----------------------------执行结果------------------------------------
    执行test1()方法
    执行test2()方法
    ======================
    test1 方法开始执行
    执行test1()方法
    test1 方法执行完毕
    -----------------------
    test2 方法开始执行
    执行test2()方法
    test2 方法执行完毕
  • 相关阅读:
    Word Embedding理解
    几种简单的主题模型(生成模型)
    BTM学习小记
    LDA学习小记
    word2vec训练好的词向量
    java带字符编码编译
    web安全领域常见的攻击方式
    宝塔webhook布置gitee自动同步服务端
    unity3d学习路线
    缩略图含裁剪文件
  • 原文地址:https://www.cnblogs.com/dongxuelove/p/13031521.html
Copyright © 2020-2023  润新知