Java反射工作机制

76、感情将我们由陌生变成熟悉，又由熟悉变成陌生。感情将两个人由陌生变成熟悉，又由熟悉变成陌生。19、感情将两个人由陌生变成熟悉，又由熟悉变成陌生。

结论在前：

1：Class对象包含类的所有信息，可以通过该对象获取到构造方法，成员变量，成员方法和接口等信息，这些信息在JVM中同样以类的形式存在

2：Class对象有三种获取方法，字面量XXX.class，Object.getClass()，Class.forName()

共享对象池：redis内部维护[0-9999]的整数对象池，对于0-9999的内部整数类型的元素、整数值对象都会直接引用整数对象池中的对象，因此尽量使用整数对象可节省内存。cloudfront首先在本地缓存节点查找blob对象，如果不存在，将请求源站获取s3中存储的blob对象，这一步操作称为回源。lrucache是一个泛型类, 它内部采用了一个linkedhashmap以强引用的方式存储外界的缓存对象, 其提供了get和put方法来完成缓存的获取和添加的操作. 当缓存满了时, lrucache会移除较早使用的缓存对象, 然后在添加新的缓存对象. 普及一下各种引用的区别:。

4：调用Method的invoke方法底层借助了一个叫做MethodAccessor的工具，这个工具又两种形态，一种是native，一种是字节码生成加载后的Magic形态，前者初始化快执行慢，后者初始化慢执行快，JVM权衡之后决定前15次用前者，超过15次用后者（inflation机制）。

5：Class对象中的缓存创建使用了CAS+Volatile+死循环这种无锁形式

Class对象可以说是反射的源泉，但是Class对象存放在哪，什么时候存放，存放了哪些信息你真的了解吗？下面我们就来揭开Class对象的神秘面纱。

这个比较简单，栈、堆、方法区、其他，栈存放引用，堆存放对象，方法区存放类信息和静态变量以及字面量，实际上Class对象就存放在方法区中。

加载，连接（验证，准备，解析），初始化，使用，卸载；解析阶段与初始化阶段顺序不一定。

以下几种情况虚拟机必须对类进行初始化（加载，验证，准备自然必须在此之前）

加载阶段需要完成的3件事情

让我们好好想想类有哪些信息组成，继承/实现的接口、全路径名、类名称、类访问限制、构造方法、成员变量、成员方法、静态变量等等。Class对象包含了所有获取这些信息的方法。这些信息中，反射最常用的是类的构造方法、成员变量、成员方法、成员方法参数这几个重要的属性，而且每个属性都有对应的类实现。

类继承体系@2x.png

对于相关用到的类，直接写一个空的类（能用接口 的尽量用接口，你的目的只是通过编译而不是能运行起来），让程序可以通过编译就可以了。 420 反馈控制 是把组织系统运行结果返送到组织系统的输入端， 与组织预定计划标准进行比较， 然后找出实际与计划之间的差异， 并采取措施纠正差异的一种控制方法。2.全数字音频功放：它的输入信号是来自数字音源的数字化的音频信号,在整个功率放大过程没有进行任何模拟信号处理,完全是数字化的端到端的解决方法.数字音频处理单元将来自数字音源的数字化的音频信号变成pwm直接送入d类音频功放的输出级,所以称这样工作原理的放大器为：“全数字音频功放”.尽管它的体积越来越小,但从功能的完善性来看,特别是dsp技术的引用,应称之为数字音频处理系统.上面所谈到的“d类音频功放”（这里实际上,就是功率输出级,不包括模拟信号转换为pwm的过程）在这个系统里才真正得到了近乎完美的发挥.应该讲,这是音响领域发展的一个里程碑,它标志着音频数码时代的真正到来.因这部分的原理较复杂,涉及到数字信号处理、编码、解码等技术.通常我们使用cd机、dvd机做音源时,较常用的是模拟信号音频输出端,也就是说：从光盘上解读的数字信号经过了一个d/a变换过程,即便你使用了“d类音频功放”则实际上又进行了一次a/d变换的过程,在这两个过程中失去许多有用的信息,而“全数字音频功放”的音频处理系统里则没有这两个环节.没丢什么.。

有了Class对象就可以为所欲为吗？抱歉，有Class对象真的可以为所欲为！

public class SingletonTest {
    // 私有构造方法
    private SingletonTest(){    
        System.out.println("无参数---构造----");  
    }
    // 私有构造方法
    private SingletonTest(String a){      
        System.out.println("有参数---构造----参数值：" + a);  
    }
    //定义私有类型的变量
    private static volatile  SingletonTest instance;
    //定义一个静态共有方法
    public static SingletonTest getInstance(){
        if(instance == null){
            synchronized(SingletonTest.class){
                if(instance == null){
                    return new SingletonTest();
                }
            }
        }
        return instance;
    }
    public static void main(String[] args) throws Exception{
        Class clazz = SingletonTest.class;
        /*以下调用无参的、私有构造函数*/   
        Constructor c0=  clazz.getDeclaredConstructor();   
        c0.setAccessible(true); 
        SingletonTest po=(SingletonTest)c0.newInstance();   
        System.out.println("无参构造函数\t"+po); 
        /*以下调用带参的、私有构造函数*/   
        Constructor c1=clazz.getDeclaredConstructor(new Class[]{String.class});   
        c1.setAccessible(true);   
        SingletonTest p1=(SingletonTest)c1.newInstance(new Object[]{"我是参数值"});   
        System.out.println("有参的构造函数\t"+p1);  
    }
}

执行结果：

无参数---构造----
无参构造函数  com.huo.demos.test.SingletonTest@15db9742
有参数---构造----参数值：我是参数值
有参的构造函数 com.huo.demos.test.SingletonTest@6d06d69c

具体的API这里就不一一调用了，自己去参考Java的API吧，上面很详细。这里要说的是反射技术可以拿到类的所有信息，并通过这些信息做你想做的事情，无论信息声明是私有的还是公有的。

随着线程数量逐渐增加，性能下降，因为线程之间会互相争夺cpu资源，造成频繁切换线程执行上下文环境，而这些切换只会浪费cpu资源。虽然可以让sta线程直接调用对象（而不用像前述的挂起等待另一个线程来调用对象），但这是必须的，因为可能会有回调问题，比如这个mta线程又反过来回调外界线程中的组件对象（假设客户本身也是一个组件对象，这正是连接点技术），如果异步回调将可能发生错误。单进程的线程可以使用临界资源对象来解决同步互斥问题,该对象不能保证哪个个线程能够获得到临界资源对象,因而该系统能公平的对待每一个线程。

首先，我们自己新建一个用于发射的类，反射获取该类的成员变量，构造方法，成员方法，如下

public class ReflectionMechanism {
    public static void main(String[] args) throws Exception {
        ClassNeedReflect target = new ClassNeedReflect();
        Class<ClassNeedReflect> clazz  = ClassNeedReflect.class;
        Field field = clazz.getDeclaredField("fieldReflected");
        Constructor<ClassNeedReflect> constructor = clazz.getDeclaredConstructor();
        Method method = clazz.getDeclaredMethod("methodReflected");
        method.invoke(target);
    }
    static class ClassNeedReflect {
        private String fieldReflected;
        private ClassNeedReflect(){
            System.out.println("构造方法");
        }
        public void methodReflected() {
            System.out.println("反射的方法");
        }
    }
}

4. base 关键字：子类中可以用（base.父类中的成员 ）来调用父类中的成员，base()调用父类构造，base.xxx()调用父类成员方法。velocity通过astreference类来表示一个变量和变量的方法调用，astreference类如果有子节点，就表示这个变量有方法调用，方法调用同样是通过“.”来区分的，每一个点后面会对应一个方法调用。但是存在一个疑问：对于生成的class1,class2，class3这些这么有规则的类，应该是.netreflector生成的，且在生成的项目代码内部也是通过调用class1,class2、、、的方式(newclass1()).方法，(newclass2()).方法，(newclass3()).方法调用，这样导致这些类不能够"见名知意",也不知道这个类是什么作用。

 ReflectionData<T> rd = reflectionData();

然后，rd是个缓存对象，缓存的内容实际上是反射需要获取的成员变量、成员方法、构造方法、类接口等可以由每个线程获取到的变量。为什么要这么做呢？缓存嘛，肯定是可以提高效率啊，多线程同时读取的时候就不用每次都去底层拿这些变量了，具体缓存内容如下。

private static class ReflectionData<T> {
        volatile Field[] declaredFields;
        volatile Field[] publicFields;
        volatile Method[] declaredMethods;
        volatile Method[] publicMethods;
        volatile Constructor<T>[] declaredConstructors;
        volatile Constructor<T>[] publicConstructors;
        // Intermediate results for getFields and getMethods
        volatile Field[] declaredPublicFields;
        volatile Method[] declaredPublicMethods;
        volatile Class<?>[] interfaces;
        final int redefinedCount;
        ReflectionData(int redefinedCount) {
            this.redefinedCount = redefinedCount;
        }
    }

本文来自电脑杂谈，转载请注明本文网址：
http://www.pc-fly.com/a/jisuanjixue/article-111385-1.html