java类加载机制、反射方式

类加载机制
1.java的源代码是java格式的，需要compiler先将源代码编译为class文件（这个class文件是java文件的byte code文件，即所谓的字节码文件），然后再由jvm运行
但电脑还不能读得懂，需要由jvm中的jit compiler将class文件再编译为native machine code（二进制语言），系统才能去执行

即：.java文件–.class文件—-machine code

2.对于不同的平台，需要有不同的虚拟机，但是虚拟机屏蔽了底层运行系统的差别，因此可以实现“一次编译，随处运行”

3.类加载器（ClassLoader），顾名思义，即加载类的东西。在我们使用一个类之前，JVM需要先将该类的字节码文件（.class文件）从磁盘、网络或其他来源加载到内存中，并对字节码进行解析生成对应的Class对象，这就是类加载器的功能。

4.类的加载采用双亲委派机制加载

每个类加载器都有一个父加载器，在类加载器递归自己之前都会先让父加载器去尝试加载， 在jvm中有个启动类加载器（bootstrap classloader），他没有父加载器，但可以作为其他加载器的父类

5.三种加载器分别加载不同的内容

程序在启动的时候，并不会一次性加载程序所要用的所有class文件，而是根据程序的需要，通过Java的类加载机制（ClassLoader）来动态加载某个class文件到内存当中的，从而只有class文件被载入到了内存之后，才能被其它class所引用。所以ClassLoader就是用来动态加载class文件到内存当中用的

• Bootstrap ClassLoader：称为启动类加载器，是Java类加载层次中最顶层的类加载器，负责加载JDK中的核心类库， JAVA_HOME/jre/lib ，如：rt.jar、resources.jar、charsets.jar等
• Extension ClassLoader：称为扩展类加载器，负责加载Java的扩展类库，默认加载JAVA_HOME/jre/lib/ext/目下的所有jar。
• App ClassLoader：称为系统类加载器，负责加载应用程序classpath目录下的所有jar和class文件。

用户还可以根据需要定义自已的ClassLoader，而这些自定义的ClassLoader都必须继承自java.lang.ClassLoader类，也包括Java提供的另外二个ClassLoader（Extension ClassLoader和App ClassLoader）在内

Bootstrap ClassLoader不继承自ClassLoader，因为它不是一个普通的Java类，底层由C++编写，已嵌入到了JVM内核当中，当JVM启动后，Bootstrap ClassLoader也随着启动，负责加载完核心类库后，并构造Extension ClassLoader和App ClassLoader类加载器。

6.classLoader搜索机制
ClassLoader使用的是双亲委托模型来搜索类的，虚拟机内置的类加载器（Bootstrap ClassLoader）用作其它ClassLoader实例的的父类加载器。当一个ClassLoader实例需要加载某个类时，它会试图亲自搜索某个类之前，先把这个任务委托给它的父类加载器，这个过程是由上至下依次检查的，首先由最顶层的类加载器Bootstrap ClassLoader试图加载，如果没加载到，则把任务转交给Extension ClassLoader试图加载，如果也没加载到，则转交给App ClassLoader 进行加载，如果它也没有加载得到的话，则返回给委托的发起者，由它到指定的文件系统或网络等URL中加载该类。如果它们都没有加载到这个类时，则抛出ClassNotFoundException异常。

JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。只有两者同时满足的情况下，JVM才认为这两个class是相同的。

所以在自定义类中，要是有出现继承父类的，要先加载父类

有一个java面试题的例子：http://www.cnblogs.com/paddix/p/5268559.html

一般来说，用户自定义的类使用 AppClassLoader 加载，AppClassLoader 的父加载器为 ExtClassLoader，但是 ExtClassLoader 的父加载器却显示为空，这是什么原因呢？究其缘由，启动类加载器属于 JVM 的一部分，它不是由 Java 语言实现的，在 Java 中无法直接引用，所以才返回空

双亲委派机制则保证了基类都由相同的类加载器加载，这样就避免了同一个字节码文件被多次加载生成不同的 Class 对象的问题。但双亲委派机制仅仅是Java 规范所推荐的一种实现方式，它并不是强制性的要求。近年来，很多热部署的技术都已不遵循这一规则，如 OSGi 技术就采用了一种网状的结构，而非双亲委派机制。

反射
1. JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
2.反射的作用
反射是Java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以再运行时装配，无需在组件之间进行源代码链接。但是反射使用不当会成本很高！
Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

• 可以通过一个对象去获取他完整的类名和包名

package Reflect;
/**
 * 通过一个对象获得完整的包名和类名
 * */
class Demo{
    //other codes...
}

class hello{
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.getClass().getName());
    }
}

- 可以实例化class类对象

package Reflect;
class Demo{
    //other codes...
}

class hello{
    public static void main(String[] args) {
        Class<?> demo1=null;
        Class<?> demo2=null;
        Class<?> demo3=null;
        try{
            //一般尽量采用这种形式
            demo1=Class.forName("Reflect.Demo");
        }catch(Exception e){
            e.printStackTrace();
        }
        demo2=new Demo().getClass();
        demo3=Demo.class;


        System.out.println("类名称   "+demo1.getName());
        System.out.println("类名称   "+demo2.getName());
        System.out.println("类名称   "+demo3.getName());


    }
}

区别：class.forName()返回的是一个class对象，而new Object（）返回的则是Object对象；如果要从类对象进一步去获得Object对象，则需要class.forName().newInstance();
与 demo1=Class.forName(“Reflect.Demo”) 等效的还有
demo2=new Demo().getClass();和 demo3=Demo.class;

注意：如果要用newInstance（）方法实例化对象，则需要在对象中创建无参的构造函数，如果有有残的构造函数则必须重新声明一个

• 可以返回接口

class.forName().getInterface()

• 可以获得其他类继承的父类

class.forName().getSuperClass()

• 可以获得全部的构造方法

class.forName().getConstructors()

• 可以获得本类属性

class.forName().getDeclaredFeild()

• 判断是不是该类的实例化对向

object.isInstance(class.name);

• 动态代理

invoke（）：在代理实例上处理方法调用并返回结果。在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

之前写的一个数据库连接关闭的动态代理程序，一个项目需求，创建连接池，然后服务需要时再去获取连接，而当连接不需要了，则返还连接。而我们习惯的操作是conn.close(),这里通过动态代理的方式，修改close的实际操作内容，将关闭连接的操作改为返还连接到连接池的操作

public Connection getConnection() throws SQLException {
//获取连接时就已经改写了方法
Connection proxy=null;
if(pool.size()>0){
     //从连接池中取出的连接对象
     Connection conn=pool.remove(0);
     //创建连接代理对象，将取出的连接对象交于代理连接对象，当对象访问到close的方法时，将由代理对象执行修改后的方法
     proxy=(Connection)Proxy.newProxyInstance(conn.getClass().getClassLoader(),new Class []{Connection.class},new InvocationHandler() {

         @Override
         public Object invoke(Object proxy, Method method, Object[] args)
              throws Throwable {
                   if(method.getName().equals("close")){
                        returnConnection(conn);
                   }else{
                        method.invoke(conn, args);
                   }
                        return null;
                   }
              });
         System.out.println("获取一个连接，"+"连接池还剩："+pool.size());
     }
              return proxy;
}