概念

　　将一个jar及其依赖的三方jar全部打到一个包中，这个包即为FatJar。

作用

　　作用：　Jar包隔离，避免Jar冲突。

打包方式

1. maven-shade-plugin插件；
2. spring-boot-maven-plugin插件（Spring Boot打包插件）；

嵌套Jar资源加载方案

　　思路：扩展Jar URL协议+定制ClassLoader;

扩展Jar URL协议

　　问题： JDK内置的Jar URL协议只支持一个’!/’，需要扩展此协议使其支持多个’!/’，以便能够加载jar in jar的资源，如下所示：

 jar:file:/data/spring-boot-theory/BOOT-INF/lib/spring-aop-5.0.4.RELEASE.jar!/org/springframework/aop/SpringProxy.class

jar:file:/data/spring-boot-theory.jar!/BOOT-INF/lib/spring-aop-5.0.4.RELEASE.jar!/org/springframework/aop/SpringProxy.class

　　解决方案：定制协议处理器Handler，定制规则查看另一篇，SpringBoot实现如下图所示：

定制ClassLoader

　　加载class：重载loadclass，添加对应的包路径；

　　加载其它资源：使用URLClassLoader原有逻辑即可；

SpringBoot提供了LaunchedURLClassLoader ，实现如下所示：

/*

 * Copyright 2012-2017 the original author or authors.

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package org.springframework.boot.loader;

import java.io.IOException;

import java.net.JarURLConnection;

import java.net.URL;

import java.net.URLClassLoader;

import java.net.URLConnection;

import java.security.AccessController;

import java.security.PrivilegedExceptionAction;

import java.util.Enumeration;

import java.util.jar.JarFile;

import org.springframework.boot.loader.jar.Handler;

/**

 * {@link ClassLoader} used by the {@link Launcher}.

 *

 * @author Phillip Webb

 * @author Dave Syer

 * @author Andy Wilkinson

 */

public class LaunchedURLClassLoader extends URLClassLoader {

    static {

        ClassLoader.registerAsParallelCapable();

    }

    /**

     * Create a new {@link LaunchedURLClassLoader} instance.

     * @param urls the URLs from which to load classes and resources

     * @param parent the parent class loader for delegation

     */

    public LaunchedURLClassLoader(URL[] urls, ClassLoader parent) {

        super(urls, parent);

    }

    @Override

    public URL findResource(String name) {

        Handler.setUseFastConnectionExceptions(true);

        try {

            return super.findResource(name);

        }

        finally {

            Handler.setUseFastConnectionExceptions(false);

        }

    }

    @Override

    public Enumeration<URL> findResources(String name) throws IOException {

        Handler.setUseFastConnectionExceptions(true);

        try {

            return new UseFastConnectionExceptionsEnumeration(super.findResources(name));

        }

        finally {

            Handler.setUseFastConnectionExceptions(false);

        }

    }

    @Override

    protected Class<?> loadClass(String name, boolean resolve)

            throws ClassNotFoundException {

        Handler.setUseFastConnectionExceptions(true);

        try {

            try {

                definePackageIfNecessary(name);

            }

            catch (IllegalArgumentException ex) {

                // Tolerate race condition due to being parallel capable

                if (getPackage(name) == null) {

                    // This should never happen as the IllegalArgumentException indicates

                    // that the package has already been defined and, therefore,

                    // getPackage(name) should not return null.

                    throw new AssertionError("Package " + name + " has already been "

                            + "defined but it could not be found");

                }

            }

            return super.loadClass(name, resolve);

        }

        finally {

            Handler.setUseFastConnectionExceptions(false);

        }

    }

    /**

     * Define a package before a {@code findClass} call is made. This is necessary to

     * ensure that the appropriate manifest for nested JARs is associated with the

     * package.

     * @param className the class name being found

     */

    private void definePackageIfNecessary(String className) {

        int lastDot = className.lastIndexOf('.');

        if (lastDot >= 0) {

            String packageName = className.substring(0, lastDot);

            if (getPackage(packageName) == null) {

                try {

                    definePackage(className, packageName);

                }

                catch (IllegalArgumentException ex) {

                    // Tolerate race condition due to being parallel capable

                    if (getPackage(packageName) == null) {

                        // This should never happen as the IllegalArgumentException

                        // indicates that the package has already been defined and,

                        // therefore, getPackage(name) should not have returned null.

                        throw new AssertionError(

                                "Package " + packageName + " has already been defined "

                                        + "but it could not be found");

                    }

                }

            }

        }

    }

    private void definePackage(String className, String packageName) {

        try {

            AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {

                String packageEntryName = packageName.replace('.', '/') + "/";

                String classEntryName = className.replace('.', '/') + ".class";

                for (URL url : getURLs()) {

                    try {

                        URLConnection connection = url.openConnection();

                        if (connection instanceof JarURLConnection) {

                            JarFile jarFile = ((JarURLConnection) connection)

                                    .getJarFile();

                            if (jarFile.getEntry(classEntryName) != null

                                    && jarFile.getEntry(packageEntryName) != null

                                    && jarFile.getManifest() != null) {

                                definePackage(packageName, jarFile.getManifest(), url);

                                return null;

                            }

                        }

                    }

                    catch (IOException ex) {

                        // Ignore

                    }

                }

                return null;

            }, AccessController.getContext());

        }

        catch (java.security.PrivilegedActionException ex) {

            // Ignore

        }

    }

    /**

     * Clear URL caches.

     */

    public void clearCache() {

        for (URL url : getURLs()) {

            try {

                URLConnection connection = url.openConnection();

                if (connection instanceof JarURLConnection) {

                    clearCache(connection);

                }

            }

            catch (IOException ex) {

                // Ignore

            }

        }

    }

    private void clearCache(URLConnection connection) throws IOException {

        Object jarFile = ((JarURLConnection) connection).getJarFile();

        if (jarFile instanceof org.springframework.boot.loader.jar.JarFile) {

            ((org.springframework.boot.loader.jar.JarFile) jarFile).clearCache();

        }

    }

    private static class UseFastConnectionExceptionsEnumeration

            implements Enumeration<URL> {

        private final Enumeration<URL> delegate;

        UseFastConnectionExceptionsEnumeration(Enumeration<URL> delegate) {

            this.delegate = delegate;

        }

        @Override

        public boolean hasMoreElements() {

            Handler.setUseFastConnectionExceptions(true);

            try {

                return this.delegate.hasMoreElements();

            }

            finally {

                Handler.setUseFastConnectionExceptions(false);

            }

        }

        @Override

        public URL nextElement() {

            Handler.setUseFastConnectionExceptions(true);

            try {

                return this.delegate.nextElement();

            }

            finally {

                Handler.setUseFastConnectionExceptions(false);

            }

        }

    }

}

加载步骤

1. 注册定制Handler;
2. 获取当前Jar包及其嵌套Jar包URL;
3. 创建ClassLoader，进行资源加载；

使用示例代码，如下所示：

import java.net.URL;

import java.util.List;

import com.cainiao.iots.client.utils.loader.ExecutableArchiveLauncher;

import com.cainiao.iots.client.utils.loader.archive.Archive;

import com.cainiao.iots.client.utils.loader.jar.JarFile;

public class IotClientLauncher extends ExecutableArchiveLauncher {

    static final String BOOT_INF_LIB = "sar/jars/";

    private ClassLoader classLoader;

    @Override

    protected boolean isNestedArchive(Archive.Entry entry) {

        return entry.getName().startsWith(BOOT_INF_LIB);

    }

    @Override

    protected void launch(String[] args) throws Exception {

        //step1:注册handler

        JarFile.registerUrlProtocolHandler();

        //step2:获取当前Jar包及其嵌套Jar包URL

        List<Archive> archives = getClassPathArchives();

        for(int i = 0; i < archives.size(); i++){

            System.out.println("Archive url: " + archives.get(i).getUrl());

        }

        //step3:创建ClassLoader

        this.classLoader = createClassLoader(archives);

    }

    public ClassLoader getClassLoader() {

        return classLoader;

    }

    public static void main(String[] args) throws Exception {

        //1. 创建ClassLoader

        IotClientLauncher launcher = new IotClientLauncher();

        launcher.launch(args);

        ClassLoader loader = launcher.getClassLoader();

        //2. 加载jar in jar的资源

        URL url = loader.getResource("1.jpg");

        Class<?> clazz = loader.loadClass("*.*.*");

    }

}

参考：

1. https://segmentfault.com/a/1190000013532009；