JVM核心知识体系

ClassFile {    u4             magic;    u2             minor_version;    u2             major_version;    u2             constant_pool_count;    cp_info        constant_pool[constant_pool_count-1];    u2             access_flags;    u2             this_class;    u2             super_class;    u2             interfaces_count;    u2             interfaces[interfaces_count];    u2             fields_count;    field_info     fields[fields_count];    u2             methods_count;    method_info    methods[methods_count];    u2             attributes_count;    attribute_info attributes[attributes_count];}

#include 
int main() {   /* my first program in C */   printf("Hello, World! \n");   return 0;}

$ gcc hello.c$ ./a.outHello, World!

package com.zooncool.example.theory.jvm;/** * Created with IntelliJ IDEA. User: linzhenhua Date: 2019/1/3 Time: 11:56 PM * @author linzhenhua */public class HelloWorld {    public static void main(String[] args) {        System.out.println("my classLoader is " + HelloWorld.class.getClassLoader());    }}

$ javac src/main/java/com/zooncool/example/theory/jvm/HelloWorld.java $ java -cp src/main/java/ com.zooncool.example.theory.jvm.HelloWorldmy classLoader is sun.misc.Launcher$AppClassLoader@2a139a55

$ javac src/main/java/com/zooncool/example/theory/jvm/HelloWorld.java $ java -cp src/main/java/ com.zooncool.example.theory.jvm.HelloWorld错误: main 方法不是类 com.zooncool.example.theory.jvm.HelloWorld 中的static, 请将 main 方法定义为: public static void main(String[] args)

$ javac src/main/java/com/zooncool/example/theory/jvm/HelloWorld.java $ java -cp src/main/java/ com.zooncool.example.theory.jvm.HelloWorld错误: main 方法必须返回类 com.zooncool.example.theory.jvm.HelloWorld 中的空类型值, 请将 main 方法定义为: public static void main(String[] args)

$ javac src/main/java/com/zooncool/example/theory/jvm/HelloWorld.java $ java -cp src/main/java/ com.zooncool.example.theory.jvm.HelloWorld错误: 在类 com.zooncool.example.theory.jvm.HelloWorld 中找不到 main 方法, 请将 main 方法定义为: public static void main(String[] args)否则 JavaFX 应用程序类必须扩展javafx.application.Application

/** Get the application's main class.*/if (jarfile != 0) {mainClassName = GetMainClassName(env, jarfile);... ...
mainClass = LoadClass(env, classname);if(mainClass == NULL) { /* exception occured */... ...
/* Get the application's main method */mainID = (*env)->GetStaticMethodID(env, mainClass, "main", "([Ljava/lang/String;)V");... ...
{/* Make sure the main method is public */jint mods;jmethodID mid;jobject obj = (*env)->ToReflectedMethod(env, mainClass, mainID, JNI_TRUE);... ...
/* Build argument array */mainArgs = NewPlatformStringArray(env, argv, argc);if (mainArgs == NULL) {ReportExceptionDescription(env);goto leave;}
/* Invoke main method. */(*env)->CallStaticVoidMethod(env, mainClass, mainID, mainArgs);

char *fgets( char *buf, int n, FILE *fp );

InputStream f = new FileInputStream("theory/jvm/HelloWorld.class");

URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/resources.jar/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/rt.jar/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/sunrsasig.jar/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jsse.jar/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jce.jar/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/charsets.jar/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/lib/jfr.jar/Library/Java/JavaVirtualMachines/jdk1.8.0_181.jdk/Contents/Home/jre/classes

//构造方法返回扩展类加载器public Launcher() {  //定义扩展类加载器  Launcher.ExtClassLoader var1;  try {      //1、获取扩展类加载器      var1 = Launcher.ExtClassLoader.getExtClassLoader();  } catch (IOException var10) {      throw new InternalError("Could not create extension class loader", var10);  }  ...}
//扩展类加载器static class ExtClassLoader extends URLClassLoader {   private static volatile Launcher.ExtClassLoader instance;   //2、获取扩展类加载器实现   public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {         if (instance == null) {              Class var0 = Launcher.ExtClassLoader.class;              synchronized(Launcher.ExtClassLoader.class) {                  if (instance == null) {                      //3、构造扩展类加载器                      instance = createExtClassLoader();                  }              }          }
          return instance;   }   //4、构造扩展类加载器具体实现  private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {      try {          return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction() {              public Launcher.ExtClassLoader run() throws IOException {                  //5、获取扩展类加载器加载目标类的目录                  File[] var1 = Launcher.ExtClassLoader.getExtDirs();                  int var2 = var1.length;
                  for(int var3 = 0; var3 < var2; ++var3) {                      MetaIndex.registerDirectory(var1[var3]);                  }                  //7、构造扩展类加载器                  return new Launcher.ExtClassLoader(var1);              }          });      } catch (PrivilegedActionException var1) {          throw (IOException)var1.getException();      }  }
  //6、扩展类加载器目录路径  private static File[] getExtDirs() {      String var0 = System.getProperty("java.ext.dirs");      File[] var1;      if (var0 != null) {          StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);          int var3 = var2.countTokens();          var1 = new File[var3];
          for(int var4 = 0; var4 < var3; ++var4) {              var1[var4] = new File(var2.nextToken());          }      } else {          var1 = new File[0];      }
      return var1;  }  //8、扩展类加载器构造方法  public ExtClassLoader(File[] var1) throws IOException {      super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);      SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);  }}

//构造方法返回系统类加载器public Launcher() {  try {      //获取系统类加载器      this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);  } catch (IOException var9) {      throw new InternalError("Could not create application class loader", var9);  }}
static class AppClassLoader extends URLClassLoader {  final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);  //系统类加载器实现逻辑  public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {      //类比扩展类加载器，相似的逻辑      final String var1 = System.getProperty("java.class.path");      final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);      return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction() {          public Launcher.AppClassLoader run() {              URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);              return new Launcher.AppClassLoader(var1x, var0);          }      });  }  //系统类加载器构造方法  AppClassLoader(URL[] var1, ClassLoader var2) {      super(var1, var2, Launcher.factory);      this.ucp.initLookupCache(this);  }}

protected Class> loadClass(String name, boolean resolve)    throws ClassNotFoundException{    synchronized (getClassLoadingLock(name)) {        // First, check if the class has already been loaded，看缓存有没有没有才去找        Class> c = findLoadedClass(name);        if (c == null) {            long t0 = System.nanoTime();            try {                //先看是不是最顶层，如果不是则parent为空，然后获取父类                if (parent != null) {                    c = parent.loadClass(name, false);                } else {                    //如果为空则说明应用启动类加载器，让它去加载                    c = findBootstrapClassOrNull(name);                }            } catch (ClassNotFoundException e) {                // ClassNotFoundException thrown if class not found                // from the non-null parent class loader            }
            if (c == null) {                // If still not found, then invoke findClass in order                // to find the class.                //如果还是没有就调用自己的方法，确保调用自己方法前都使用了父类方法，如此递归三次到顶                long t1 = System.nanoTime();                c = findClass(name);
                // this is the defining class loader; record the stats                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);                sun.misc.PerfCounter.getFindClasses().increment();            }        }        if (resolve) {            resolveClass(c);        }        return c;    }}
protected Class> findClass(String name) throws ClassNotFoundException {    throw new ClassNotFoundException(name);}

package com.zooncool.example.theory.jvm;import java.io.FileInputStream;import static java.lang.System.out;
public class ClassIsolationPrinciple {    public static void main(String[] args) {        try {            String className = "com.zooncool.example.theory.jvm.ClassIsolationPrinciple$Demo"; //定义要加载类的全限定名            Class> class1 = Demo.class;  //第一个类又系统默认类加载器加载            //第二个类MyClassLoader为自定义类加载器，自定义的目的是覆盖加载类的逻辑            Class> class2 = new MyClassLoader("target/classes").loadClass(className);            out.println("-----------------class name-----------------");            out.println(class1.getName());            out.println(class2.getName());            out.println("-----------------classLoader name-----------------");            out.println(class1.getClassLoader());            out.println(class2.getClassLoader());            Demo.example = 1;//这里修改的系统类加载器加载的那个类的对象，而自定义加载器加载进去的类的对象保持不变，也即是同时存在内存，但没有修改example的值。            out.println("-----------------field value-----------------");            out.println(class1.getDeclaredField("example").get(null));            out.println(class2.getDeclaredField("example").get(null));        }  catch (ClassNotFoundException e) {            e.printStackTrace();        } catch (NoSuchFieldException e) {            e.printStackTrace();        } catch (IllegalAccessException e) {            e.printStackTrace();        }    }
    public static class Demo {        public static int example = 0;    }
    public static class MyClassLoader extends ClassLoader{        private String classPath;        public MyClassLoader(String classPath) {            this.classPath = classPath;        }        //自定义类加载器继承了ClassLoader，称为一个可以加载类的加载器，同时覆盖了loadClass方法，实现自己的逻辑        @Override        public Class> loadClass(String name) throws ClassNotFoundException {            if(!name.contains("java.lang")){//排除掉加载系统默认需要加载的内心类，因为些类只能又默认类加载器去加载，第三方加载会抛异常，具体原因下文解释                byte[] data = new byte[0];                try {                    data = loadByte(name);                } catch (Exception e) {                    e.printStackTrace();                }                return defineClass(name,data,0,data.length);            }else{                return super.loadClass(name);            }        }        //把影片的二进制类文件读入内存字节流        private byte[] loadByte(String name) throws Exception {            name = name.replaceAll("\\.", "/");            String dir = classPath + "/" + name + ".class";            FileInputStream fis = new FileInputStream(dir);            int len = fis.available();            byte[] data = new byte[len];            fis.read(data);            fis.close();            return data;        }    }}

-----------------class name-----------------com.zooncool.example.theory.jvm.ClassIsolationPrinciple2$Democom.zooncool.example.theory.jvm.ClassIsolationPrinciple2$Demo-----------------classLoader name-----------------sun.misc.Launcher$AppClassLoader@18b4aac2com.zooncool.example.theory.jvm.ClassIsolationPrinciple2$MyClassLoader@511d50c0-----------------field value-----------------10

/** Defines a Class using the class bytes obtained from the specified* Resource. The resulting Class must be resolved before it can be* used.*/private Class> defineClass(String name, Resource res) throws IOException {  //加载资源  long t0 = System.nanoTime();  int i = name.lastIndexOf('.');  URL url = res.getCodeSourceURL();  if (i != -1) {      String pkgname = name.substring(0, i);      // Check if package already loaded.      Manifest man = res.getManifest();      definePackageInternal(pkgname, man, url);  }  // Now read the class bytes and define the class  java.nio.ByteBuffer bb = res.getByteBuffer();  if (bb != null) {      // Use (direct) ByteBuffer:      CodeSigner[] signers = res.getCodeSigners();      CodeSource cs = new CodeSource(url, signers);      sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);      //字节码转为内存类格式规范      return defineClass(name, bb, cs);  } else {      byte[] b = res.getBytes();      // must read certificates AFTER reading bytes.      CodeSigner[] signers = res.getCodeSigners();      CodeSource cs = new CodeSource(url, signers);      sun.misc.PerfCounter.getReadClassBytesTime().addElapsedTimeFrom(t0);      //字节码转为内存类格式规范      return defineClass(name, b, 0, b.length, cs);  }}//调用类定义方法protected final Class> defineClass(String name,                                   byte[] b, int off, int len,                                   CodeSource cs){  return defineClass(name, b, off, len, getProtectionDomain(cs));}//调用类定义方法protected final Class> defineClass(String name, byte[] b, int off, int len,                                   ProtectionDomain protectionDomain)  throws ClassFormatError{  protectionDomain = preDefineClass(name, protectionDomain);  String source = defineClassSourceLocation(protectionDomain);  //本地方法，定义类  Class> c = defineClass1(name, b, off, len, protectionDomain, source);  postDefineClass(c, protectionDomain);  return c;}
//本地方法，将加载的字节码定义为规范的class对象private native Class> defineClass1(String name, byte[] b, int off, int len,                                       ProtectionDomain pd, String source);

package com.zooncool.example.theory.jvm;import java.io.FileInputStream;import java.lang.reflect.InvocationTargetException;
public class ClassReloading {    public static void main(String[] args)        throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InstantiationException,        InvocationTargetException, InterruptedException {        for (;;){//用死循环让线程持续运行未中断状态            //通过反射调用目标类的入口方法            String className = "com.zooncool.example.theory.jvm.ClassReloading$User";            Class> target = new MyClassLoader("target/classes").loadClass(className);            //加载进来的类，通过反射调用execute方法            target.getDeclaredMethod("execute").invoke(targetClass.newInstance());            //HelloWorld.class.getDeclaredMethod("execute").invoke(HelloWorld.class.newInstance());            //如果换成系统默认类加载器的话，因为双亲委派原则，默认使用应用类加载器，而且能加载一次            //休眠是为了在删除旧类编译新类的这段时间内不执行加载动作            //不然会找不到类文件            Thread.sleep(10000);        }    }        //自定义类加载器加载的目标类    public static class User {        public void execute() throws InterruptedException {            //say();            ask();        }        public void ask(){            System.out.println("what is your name");        }        public void say(){            System.out.println("my name is lucy");        }    }
    //下面是自定义类加载器，跟第一个例子一样，可略过    public static class MyClassLoader extends ClassLoader{        private String classPath;        public MyClassLoader(String classPath) {            this.classPath = classPath;        }        @Override        public Class> loadClass(String name) throws ClassNotFoundException {            if(!name.contains("java")){                byte[] data = new byte[0];                try {                    data = loadByte(name);                } catch (Exception e) {                    e.printStackTrace();                }                return defineClass(name,data,0,data.length);            }else{                return super.loadClass(name);            }        }        private byte[] loadByte(String name) throws Exception {            name = name.replaceAll("\\.", "/");            String dir = classPath + "/" + name + ".class";            FileInputStream fis = new FileInputStream(dir);            int len = fis.available();            byte[] data = new byte[len];            fis.read(data);            fis.close();            return data;        }    }}

what is your namewhat is your namewhat is your name//修改代码，编译新类my name is lucymy name is lucywhat is your name//修改代码，编译新类

package com.zooncool.example.theory.jvm;




    

import java.io.FileInputStream;import java.lang.reflect.InvocationTargetException;
/** * 应用上下文热加载 * Created with IntelliJ IDEA. User: linzhenhua Date: 2019/2/24 Time: 10:25 PM * @author linzhenhua */public class ContextReloading {    public static void main(String[] args)        throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InstantiationException,        InvocationTargetException, InterruptedException {        for (;;){            Object context = newContext();//创建应用上下文            invokeContext(context);//通过上下文对象context调用业务方法            Thread.sleep(5000);        }    }
    //创建应用的上下文，context是整个应用的GC roots，创建完返回对象之前调用init()初始化对象    public static Object newContext()        throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException,        InvocationTargetException {        String className = "com.zooncool.example.theory.jvm.ContextReloading$Context";        //通过自定义类加载器加载Context类        Class> contextClass = new MyClassLoader("target/classes").loadClass(className);        Object context = contextClass.newInstance();//通过反射创建对象        contextClass.getDeclaredMethod("init").invoke(context);//通过反射调用初始化方法init()        return context;    }    //业务方法，调用context的业务方法showUser()    public static void invokeContext(Object context)        throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {        context.getClass().getDeclaredMethod("showUser").invoke(context);    }

    public static class Context{        private UserService userService = new UserService();        public String showUser(){            return userService.getUserMessage();        }        //初始化对象        public void init(){            UserDao userDao = new UserDao();            userDao.setUser(new User());            userService.setUserDao(userDao);        }    }

    public static class UserService{        private UserDao userDao;        public String getUserMessage(){            return userDao.getUserName();        }        public void setUserDao(UserDao userDao) {            this.userDao = userDao;        }    }

    public static class UserDao{        private User user;        public String getUserName(){            //关键操作，运行main方法后切换下面方法，编译后下一次调用生效            return user.getName();            //return user.getFullName();        }        public void setUser(User user) {            this.user = user;        }    }
    public static class User{        private String name = "lucy";        private String fullName = "hank.lucy";
        public String getName() {            System.out.println("my name is " + name);            return name;        }        public String getFullName() {            System.out.println("my full name is " + fullName);            return name;        }    }        //跟之前的类加载器一模一样，可以略过    public static class MyClassLoader extends ClassLoader{        private String classPath;        public MyClassLoader(String classPath) {            this.classPath = classPath;        }        @Override        public Class> loadClass(String name) throws ClassNotFoundException {            if(!name.contains("java")){                byte[] data = new byte[0];                try {                    data = loadByte(name);                } catch (Exception e) {                    e.printStackTrace();                }                return defineClass(name,data,0,data.length);            }else{                return super.loadClass(name);            }        }        private byte[] loadByte(String name) throws Exception {            name = name.replaceAll("\\.", "/");            String dir = classPath + "/" + name + ".class";            FileInputStream fis = new FileInputStream(dir);            int len = fis.available();            byte[] data = new byte[len];            fis.read(data);            fis.close();            return data;        }    }}

package com.zooncool.example.theory.jvm;
import java.io.FileInputStream;import java.lang.reflect.InvocationTargetException;/** * 应用上下文热加载，增加缓存用户态 * Created with IntelliJ IDEA. User: linzhenhua Date: 2019/2/24 Time: 10:25 PM * @author linzhenhua */public class ContextStaticReloading {    public static void main(String[] args)        throws NoSuchMethodException, ClassNotFoundException, IllegalAccessException, InstantiationException,        InvocationTargetException, InterruptedException, NoSuchFieldException {        Cache cache = new Cache();//根据GCRoots可达原则，Cache会被系统类加载器加载，而且不会被GC回收        cache.setName("Jack");        for (;;){            Object context = newContext(cache);//把cache赋给context，注意context是由自定义类加载器的，所以每次循环都会被新版本的context替换，而cache不会被GC所以一直保持用户态。            invokeContext(context);            Thread.sleep(5000);        }    }    public static Object newContext(Cache cache)        throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException,        InvocationTargetException, NoSuchFieldException {        String className = "com.zooncool.example.theory.jvm.ContextStaticReloading$Context";        Class> contextClass = new MyClassLoader("target/classes").loadClass(className);        Object context = contextClass.newInstance();        contextClass.getDeclaredField("cache").set(context,cache);//初始化之前显把context对象里面的cache进行赋值，这里要特别注意的是，我们传入的cache对象是由系统类加载器加载的。而Context类里面的Cache类却是由自定义类加载器MyClassLoader加载，这样赋值会造成类型和值不一致，导致抛出IllegalArgumentException异常。解决思路很简单，让他们保持一致就行，但是由于我们Cache必须又系统默认类加载器加载，那么只能让Context里面的Cache显性的指定系统类加载器来加载(因为不指定的话，根据类加载器依赖传导原则，依赖类复用被依赖的类的加载器)。本例子很简单，就是在复写loadClass方法的时候，增加条件!name.contains("Cache")，让MyClassLoader加载Cache时抛给系统类加载器。        contextClass.getDeclaredMethod("init").invoke(context);        return context;    }    public static void invokeContext(Object context)        throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {        context.getClass().getDeclaredMethod("showUser").invoke(context);    }    public static class Context{        public Cache cache;        private UserService userService = new UserService();        public void init(){            User user = new User();            user.setName("Rose");            UserDao userDao = new UserDao();            userDao.setUser(user);            userService.setUserDao(userDao);        }        public void showUser(){            System.out.println("from context name is " + userService.getUserMessage());            System.out.println("from  cache  name is " + cache.getName());            System.out.println();        }    }    public static class UserService{        private UserDao userDao;        public String getUserMessage(){            return userDao.getUserName();        }




    
        public void setUserDao(UserDao userDao) {            this.userDao = userDao;        }    }    public static class UserDao{        private User user;        public String getUserName(){            return user.getName();        }        public void setUser(User user) {            this.user = user;        }    }    public static class User{        private String name;        public String getName() {            return name;        }        public void setName(String name) {            this.name = name;        }    }    public static class Cache{        private String name;        public String getName() {            return name;        }        public void setName(String name) {            this.name = name;        }    }    public static class MyClassLoader extends ClassLoader{        private String classPath;        public MyClassLoader(String classPath) {            this.classPath = classPath;        }        @Override        public Class> loadClass(String name) throws ClassNotFoundException {            if(!name.contains("java") && !name.contains("Cache") ){//就是这里加条件过滤Cache                byte[] data = new byte[0];                try {                    data = loadByte(name);                } catch (Exception e) {                    e.printStackTrace();                }                return defineClass(name,data,0,data.length);            }else{                return super.loadClass(name);            }        }        private byte[] loadByte(String name) throws Exception {            name = name.replaceAll("\\.", "/");            String dir = classPath + "/" + name + ".class";            FileInputStream fis = new FileInputStream(dir);            int len = fis.available();            byte[] data = new byte[len];            fis.read(data);            fis.close();            return data;        }    }}

cache.setName("Jack");user.setName("Rose");

from context name is Rosefrom  cache  name is Jack
from context name is Lucyfrom  cache  name is Jack
from context name is hanmeifrom  cache  name is Jack

Class groovyClass = classLoader.parseClass(new GroovyCodeSource(sourceFile));GroovyObject instance = (GroovyObject)groovyClass.newInstance();//proxy  

public static void main(String[] args) {   Class> userClass1 = User.class;   Class> userClass2 = new DynamicClassLoader("target/classes")         .load("qj.blog.classreloading.example1.StaticInt$User");
   out.println("Seems to be the same class:");   out.println(userClass1.getName());   out.println(userClass2.getName());   out.println();
   out.println("But why there are 2 different class loaders:");   out.println(userClass1.getClassLoader());   out.println(userClass2.getClassLoader());   out.println();
   User.age = 11;   out.println("And different age values:");   out.println((int) ReflectUtil.getStaticFieldValue("age", userClass1));   out.println((int) ReflectUtil.getStaticFieldValue("age", userClass2));}
public static class User {   public static int age = 10;}

public static void main(String args[]) {




    

    if (daemon == null) {        // Don't set daemon until init() has completed        Bootstrap bootstrap = new Bootstrap();        try {            //1、初始化守护进程            bootstrap.init();        } catch (Throwable t) {            handleThrowable(t);            t.printStackTrace();            return;        }        daemon = bootstrap;    } else {        // When running as a service the call to stop will be on a new        // thread so make sure the correct class loader is used to prevent        // a range of class not found exceptions.        Thread.currentThread().setContextClassLoader(daemon.catalinaLoader);    }
    //下面的逻辑是执行startup.sh脚本里面执行的exec "$PRGDIR"/"$EXECUTABLE" start "$@"    //篇幅限制，省略}

ClassLoader commonLoader = null;//公共类加载器ClassLoader catalinaLoader = null;//ClassLoader sharedLoader = null;//

/** * Initialize daemon. * @throws Exception Fatal initialization error */public void init() throws Exception {    //2、初始化类加载器    initClassLoaders();
    Thread.currentThread().setContextClassLoader(catalinaLoader);
    SecurityClassLoad.securityClassLoad(catalinaLoader);
    // Load our startup class and call its process() method    if (log.isDebugEnabled())        log.debug("Loading startup class");    //6、通过类加载器catalinaLoader加载Catalina，并通过反射创建对象startupInstance    Class> startupClass = catalinaLoader.loadClass("org.apache.catalina.startup.Catalina");    Object startupInstance = startupClass.getConstructor().newInstance();
    // Set the shared extensions class loader    if (log.isDebugEnabled())        log.debug("Setting startup class properties");    String methodName = "setParentClassLoader";    Class> paramTypes[] = new Class[1];    paramTypes[0] = Class.forName("java.lang.ClassLoader");    Object paramValues[] = new Object[1];    paramValues[0] = sharedLoader;    //7、startupInstance实例调用setParentClassLoader方法设置父类加载器为sharedLoader    Method method =        startupInstance.getClass().getMethod(methodName, paramTypes);    method.invoke(startupInstance, paramValues);
    catalinaDaemon = startupInstance;
}

private void initClassLoaders() {    try {        //3.1、创建通用类加载器        commonLoader = createClassLoader("common", null);        if( commonLoader == null ) {            // no config file, default to this loader - we might be in a 'single' env.            commonLoader=this.getClass().getClassLoader();        }        //3.2、创建系统类加载器        catalinaLoader = createClassLoader("server", commonLoader);        //3.3、创建共享类加载器        sharedLoader = createClassLoader("shared", commonLoader);    } catch (Throwable t) {        handleThrowable(t);        log.error("Class loader creation threw exception", t);        System.exit(1);    }}

//不同功能类加载器通过配置文件加载不同路径的类库，父加载器显式指定parent//通过parent传参方式，我们知道commonLoader的父类加载器是系统类加载器//而catalinaLoader和sharedLoader的父类加载器则是commonLoaderprivate ClassLoader createClassLoader(String name, ClassLoader parent)    throws Exception {    //省略从catalina.properties读取common.loader，server.loader，shared.loader加载类库逻辑    //common.loader="${catalina.base}/lib","${catalina.base}/lib/*.jar"...    //server.loader=    //shared.loader=        //4、工厂类ClassLoaderFactory创建类加载器    return ClassLoaderFactory.createClassLoader(repositories, parent);}

//创建类加载器public static ClassLoader createClassLoader(List repositories,                                            final ClassLoader parent)    throws Exception {
    // Construct the "class path" for this class loader    Set set = new LinkedHashSet<>();
    //省略从repositories循环迭代出Repository然后装配URL的逻辑，最终就是指定类加载器所要加载类的路径
    //5、创建URLClassLoader类加载器    return AccessController.doPrivileged(            new PrivilegedAction() {                @Override                public URLClassLoader run() {                    if (parent == null)                        return new URLClassLoader(array);                    else                        return new URLClassLoader(array, parent);                }            });}