一。类加载器及双亲委派机制

1.类加载器承袭结构

2.类加载器的外围方法

3.Launcher类源码解析

publicclassLauncher{

privatestaticURLStreamHandlerFactoryfactory=newFactory();

privatestaticLauncherlauncher=newLauncher();

//进行类加载器加载门路

privatestaticStringbootClassPath=

System.getProperty("sun.boot.class.path");

publicstaticLaunchergetLauncher(){

returnlauncher;

privateClassLoaderloader;

publicLauncher(){

//Createtheextensionclassloader

ClassLoaderextcl;

//失掉裁减类加载器

extcl=ExtClassLoader.getExtClassLoader();

}catch(IOExceptione){

thrownewInternalError(

"Couldnotcreateextensionclassloader",e);

//Nowcreatetheclassloadertousetolaunchthelication

//失掉运行类加载器

loader=AppClassLoader.getAppClassLoader(extcl);

}catch(IOExceptione){

thrownewInternalError(

"Couldnotcreateapplicationclassloader",e);

//Alsosetthecontextclassloaderfortheprimordialthread.

//设置线程高低文类加载器为运行类加载器

Thread.currentThread().setContextClassLoader(loader);

*Theclassloaderusedforloadinginstalledextensions.

staticclassExtClassLoaderextendsURLClassLoader{

privatestaticvolatileExtClassLoaderinstance=null;

*createanExtClassLoader.TheExtClassLoaderiscreated

*withinacontextthatlimitswhichfilesitcanread

publicstaticExtClassLoadergetExtClassLoader()throwsIOException

if(instance==null){

synchronized(ExtClassLoader.class){

if(instance==null){

instance=createExtClassLoader();

returninstance;

*失掉加载门路

privatestaticFile[]getExtDirs(){

//裁减类加载器加载门路

Strings=System.getProperty(".ext.dirs");

*Theclassloaderusedforloadingfromjava.class.path.

*runsinarestrictedsecuritycontext.

staticclassAppClassLoaderextendsURLClassLoader{

publicstaticClassLoadergetAppClassLoader(finalClassLoaderextcl)

throwsIOException

//运行类加载器加载门路

finalStrings=System.getProperty("java.class.path");

finalFile[]path=(s==null)?newFile[0]:getClassPath(s);

returnAccessController.doPrivileged(

newPrivilegedAction<AppClassLoader>(){

publicAppClassLoaderrun(){

URL[]urls=

(s==null)?newURL[0]:pathToURLs(path);

returnnewAppClassLoader(urls,extcl);

4.ClassLoader类源码解析

publicabstractclassClassLoader{

protectedClass<?>loadClass(Stringname,booleanresolve)

throwsClassNotFoundException

synchronized(getClassLoadingLock(name)){

//First,checkiftheclasshasalreadybeenloaded

//从系统缓存中失掉

Class<?>c=findLoadedClass(name);

if(c==null){

longt0=System.nanoTime();

//委托父加载器加载

if(parent!=null){

c=parent.loadClass(name,false);

c=findBootstrapClassOrNull(name);

}catch(ClassNotFoundExceptione){

//ClassNotFoundExceptionthrownifclassnotfound

//fromthenon-nullparentclassloader

if(c==null){

//Ifstillnotfound,theninvokefindClassinorder

//tofindtheclass.

longt1=System.nanoTime();

//自己加载，从指定门路

c=findClass(name);

//thisisthedefiningclassloader;recordthestats

sun.misc.PerfCounter.getParentDelegationTime().addTime(t1-t0);

sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

sun.misc.PerfCounter.getFindClasses().increment();

if(resolve){

resolveClass(c);

//自定义类加载器须要重写该方法

protectedClass<?>findClass(Stringname)throwsClassNotFoundException{

thrownewClassNotFoundException(name);

5.双亲委派机制优缺陷

好处：

1、保障安保性，层级相关代表优先级，也就是一切类的加载，优先给进行类加载器，这样就保障了外围类库类

2、防止类的重复加载，假设父类加载器加载过了，子类加载器就没有必要再去加载了，确保一个类的全局惟一性

缺陷：

审核类能否加载的委派环节是单向的，这个形式虽然从结构上说比拟明晰，使各个ClassLoader的职责十清楚白，然而同时会带来一个疑问，即顶层的ClassLoader不可访问底层的ClassLoader所加载的类

通常状况下，进行类加载器中的类为系统外围类，包括一些关键的系统接口，而在运行类加载器中，为运行类。依照这种形式，运行类访问系统类人造是没有疑问，然而系统类访问运行类就会产生疑问。

二.spi接口及线程高低文类加载器

1.spi接口定义及线程高低文加载的作用

Java提供了很多外围接口的定义，这些接口被称为SPI接口。 （ServiceProviderInterface，SPI），准许第三方为这些接口提供成功。经常出现的SPI有JDBC、JCE、JNDI、JAXP和JBI等。

这些SPI的接口由Java外围库来提供，而这些SPI的实现代码则是作为Java运行所依赖的jar包被蕴含进类门路（CLASSPATH）里。SPI接口中的代码经常须要加载详细的成功类。那么疑问来了，SPI的接口是Java外围库的一局部，是由进行类加载器(BootstrapClassloader)来加载的；SPI的成功类是由系统类加载器(SystemClassLoader)来加载的。 疏导类加载器是不可找到SPI的成功类的，由于依照双亲委派模型，BootstrapClassloader不可委派AppClassLoader来加载类。而线程高低文类加载器破坏了双亲委派模型，可以在口头线程中放弃双亲委派加载链形式，使程序可以逆向经常使用类加载器。

类加载传导规定：JVM会选用以后类的类加载器来加载一切该类的援用的类。例如咱们定义了TestA和TestB两个类，TestA会援用TestB，只需咱们经常使用自定义的类加载器加载TestA，那么在运转时，当TestA调用到TestB的时刻，

TestB也会被JVM经常使用TestA的类加载器加载。依此类推，只需是TestA及其援用类关联的一切jar包的类都会被自定义类加载器加载。经过这种形式，咱们只需让模块的mn方法类经常使用不同的类加载器加载，那么每个模块的都会经常使用main

方法类的类加载器加载的，这样就能让多个模块区分经常使用不同类加载器。这也是OSGi和SofaArk能够成功类隔离的外围原理。

2.spi加载原理

当第三方成功者提供了服务接口的一种成功之后，在jar包的META-INF/services/目录里同时创立一个以服务接口命名的文件，该文件就是成功该服务接口的成功类。而当外部程序装配这个模块的时刻，就能经过该jar包META-INF/services/里的性能文件找到详细的成功类名，并装载实例化，成功模块的注入。

JDK官网提供了一个查找服务虚现者的工具类：java.util.ServiceLoader

publicfinalclassServiceLoader<S>

implementsIterable<S>

//加载spi接口成功类性能文件固定门路

*Createsanewserviceloaderforthegivenservicetype,usingthe

*currentthread's{@linkplainjava.lang.Thread#getContextClassLoader

*contextclassloader}.

*<p>Aninvocationofthisconveniencemethodoftheform

*ServiceLoader.load(<i>service</i>)</pre></blockquote>

*isequivalentto

*ServiceLoader.load(<i>service</i>,

*Thread.currentThread().getContextClassLoader())</pre></blockquote>

*@param<S>theclassoftheservicetype

*@paramservice

*Theinterfaceorabstractclassrepresentingtheservice

*@returnAnewserviceloader

publicstatic<S>ServiceLoader<S>load(Class<S>service){

//线程高低文类加载器

ClassLoadercl=Thread.currentThread().getContextClassLoader();

returnServiceLoader.load(service,cl);

3.示列代码

代码：

publicinterfaceIShout{

voidshout();

publicclassDogimplementsIShout{

publicvoidshout(){

System.out.println("wangwang");

publicclassCatimplementsIShout{

publicvoidshout(){

System.out.println("miaomiao");

publicclassMain{

publicstaticvoidmain(String[]args){

ServiceLoader<IShout>shouts=ServiceLoader.load(IShout.class);

for(IShouts:shouts){

s.shout();

性能：

4.驱动类加载

//加载Class到AppClassLoader（系统类加载器），而后注册驱动类

//Class.forName("com.mysql.jdbc.Driver").newInstance();

//经过java库失掉数据库衔接

Connectionconn=java.sql.DriverManager.getConnection(url,"name","pass");

publicclassDriverManager{

loadInitialDrivers();

println("JDBCDriverManagerinitialized");

privatestaticvoidloadInitialDrivers(){

AccessController.doPrivileged(newPrivilegedAction<Void>(){

publicVoidrun(){

ServiceLoader<Driver>loadedDrivers=ServiceLoader.load(Driver.class);

Iterator<Driver>driversIterator=loadedDrivers.iterator();

/*Loadthesedrivers,sothattheycanbeinstantiated.

*Itmaybethecasethatthedriverclassmaynotbethere

*i.e.theremaybeapackageddriverwiththeserviceclass

*asimplementationofjava.sql.Driverbuttheactualclass

*maybemissing.Inthatcaseajava.util.ServiceConfigurati

*willbethrownatruntimebytheVMtryingtolocate

*andloadtheservice.

*Addingatrycatchblocktocatchthoseruntimeerrors

*ifdrivernotavailableinclasspathbutit's

*packagedasserviceandthatserviceisthereinclasspath.

while(driversIterator.hasNext()){

driversIterator.next();

}catch(Throwablet){

//Donothing

returnnull;

println("DriverManager.initialize:jdbc.drivers="+drivers);

if(drivers==null||drivers.equals("")){

String[]driversList=drivers.split(":");

println("numberofDrivers:"+driversList.length);

for(StringaDriver:driversList){

println("DriverManager.Initialize:loading"+aDriver);

Class.forName(aDriver,true,

ClassLoader.getSystemClassLoader());

}catch(Exceptionex){

println("DriverManager.Initialize:loadfailed:"+ex);

三。自定义灵活类加载器

1.示例代码

publicclassDynamicClassLoadextendsClassLoader{

publicstaticvoidmain(String[]args){

Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(newRunnable(){

publicvoidrun(){

DynamicClassLoadmyClassLoad=newDynamicClassLoad();

Classclazz=myClassLoad.findClass("/Users/wangzhaoqing1/Desktop/MyTest.class");

Objectobj=clazz.newInstance();

MethodsayHello=clazz.getDeclaredMethod("sayHello");

sayHello.invoke(obj,null);

}catch(Throwablee){

e.printStackTrace();

},1,2,TimeUnit.SECONDS);

protectedClass<?>findClass(Stringname)throwsClassNotFoundException{

Filefile=newFile(name);

byte[]bytes=FileUtils.readFileToByteArray(file);

Class<?>c=this.defineClass(null,bytes,0,bytes.length);

}catch(Exceptione){

e.printStackTrace();

returnsuper.findClass(name);

//DynamicClassLoad进行后，修副本类从新编译

publicclassMyTest{

publicvoidsayHello(){

System.out.println("hellowzq6666666666");

---

java中反射实例类装载的步骤及简要阐述

java反射和类装载反射机制：Person p=new Person();这是什么?当然是实例化一个对象了.可是这种实例化对象的方法存在一个问题,那就是必须要知道类名才可以实例化它的对象,这样我们在应用方面就会受到限制.那么有没有这样一种方式,让我们不知道这个类的类名就可以实例化它的对象呢?Thank Goodness!幸亏我们用的是java, java就提供了这样的机制.1)程序在运行时可以获得任何一个类的字节码信息,包括类的修饰符(public,static等),基类(超类,父类),实现的接口,字段和方法等信息.2)程序在运行时可以根据字节码信息来创建该类的实例对象,改变对象的字段内容和调用对象方法.这样的机制就叫反射技术.可以想象光学中的反射,就像我们照镜子,镜子中又出现一个自己(比喻可能不太恰当,但是足以表达清楚意思了).反射技术提供了一种通用的动态连接程序组件的方法,不必要把程序所需要的目标类硬编码到源程序中,从而使得我们可以创建灵活的程序.反射的实现步骤（ 不问不需要答) ，1、获取类的常用方式有三种： a) (包名.类名)，最常用、推荐；b) 包名.类 最简捷；c) 对象 的方式获得。 2、对象的实例化,上面已经获取了类，只需要调用类的实例化方法,类()便可。 3、获取属性和构造等，可以参考 JavaApi 的调用，类. getDeclaredFields,类. getConstructor(..)等。 Java的反射机制是通过反射API来实现的,它允许程序在运行过程中取得任何一个已知名称的类的内部信息.反射API位于包中.主要包括以下几类:1)类:用来描述一个类的构造方法2)类:用来描述一个类的成员变量3)类:用来描述一个类的方法.4)类:用来描述类内各元素的修饰符5):用来对数组进行操作,Field,Method这三个类都是JVM(虚拟机)在程序运行时创建的,用来表示加载类中相应的成员.这三个类都实现了接口,Member接口定义了获取类成员或构造方法等信息的方法.要使用这些反射API,必须先得到要操作的对象或类的Class类的实例.通过调用Class类的newInstance方法(只能调用类的默认构造方法)可以创建类的实例.这样有局限性,我们可以先冲类的Class实例获取类需要的构造方法,然后在利用反射来创建类的一个实例.类加载机制：类的加载机制可以分为加载-链接-初始化三个阶段，链接又可以分为验证、准备、解析三个过程。 加载：通过类的加载器查找并加载二进制字节流的过程，在堆内存中的方法区生成一个代表这个类的 对象，作为这个类的数据请求入口。 （这里可以把上面类加载器加载文件的过程描述一下（参考版本一，不作重复））。 验证：主要是对一些词法、语法进行规范性校验，避免对 JVM 本身安全造成危害； 比如对文件格式，字节码验证，无数据验证等。 但验证阶段是非必须的，可以通过参数设置来进行关闭，以提高加载的时效。 准备：对类变量分配内存，并且对类变量预初始化，初始化成数据类型的原始值， 比如 static int a=11,会被初始化成成 a=0;如果是 static double a =11,则会被初始化成 a=0.0； 而成员变量只会成实例化后的堆中初始化。 解析：把常量池中的符号引用转换为直接引用的过程。 初始化：对类的静态变量和静态块中的变量进行初始化。 （上面的准备阶段可以作为预初始化，初始到变量类型的原值，但如果被 final 修饰会进行真正初始化）上面加载、链接、初始化的各个阶段并不是彼此独立，而是交叉进行，这点很重要 。 ***和 classloader的区别 和 ClassLoader 都是用来装载类的，对于类的装载一般为分三个阶段加载、链接、编译，它们装载类的方式是有区别。 首先看一下 （..），forName（..）方法有一个重载方法 forName(className,boolean,ClassLoader)，它有三个参数，第一个参数是类的包路径，第二个参数是boolean类型，为 true 地表示 Loading 时会进行初始化，第三个就是指定一个加载器；当你调用(..)时，默认调用的是有三个参数的重载方法，第二个参数默认传入true,第三个参数默认使用的是当前类加载时用的加载器。 ()也有一个重载方法，从源码中可以看出它默认调的是它的重载方法 loadClass(name, false)，当第二参数为 false 时，说明类加载时不会被链接。 这也是两者之间最大区别，前者在加载的时候已经初始化，后者在加载的时候还没有链接。 如果你需要在加载时初始化一些东西，就要用 了，比如我们常用的驱动加载， 实际上它的注册动作就是在加载时的一个静态块中完成的。 所以它不能被 ClassLoader 加载代替。

java工作原理

Java工作原理由四方面组成：（1）Java编程语言（2）Java类文件格式（3）Java虚拟机（4）Java应用程序接口 当编辑并运行一个Java程序时，需要同时涉及到这四种方面。 使用文字编辑软件（例如记事本、写字板、UltraEdit等）或集成开发环境（Eclipse、MyEclipse等）在Java源文件中定义不同的类 ，通过调用类（这些类实现了Java API）中的方法来访问资源系统，把源文件编译生成一种二进制中间码，存储在class文件中，然后再通过运行与操作系统平台环境相对应的Java虚拟机来运行class文件，执行编译产生的字节码，调用class文件中实现的方法来满足程序的Java API调用 。