转载

Java内存管理-掌握自定义类加载器的实现（七）

分享一位老师的人工智能教程。零基础！通俗易懂！风趣幽默！大家可以看看是否对自己有帮助， 点击这里查看【人工智能教程】 。接下来进入正文。

勿在流沙筑高台，出来混迟早要还的。

上一篇分析了ClassLoader的类加载相关的核心源码，也简单介绍了ClassLoader的设计思想， 读源码相对来说是比较枯燥的，还是这个是必须要走的过程，学习源码中的一些思想，一些精髓，看一下大神级人物是怎么写出那么牛逼的代码。我们能够从中学到一点点东西，那也是一种进步和成长了 。本文基于上一篇文章内容，手把手写一个自定义类加载器，并且通过一些简单的案例（场景）让我们更加细致和静距离的体验类加载器的神奇之处。

本文地图：

Java内存管理-掌握自定义类加载器的实现（七）

一、上文回顾扩展

上一篇介绍了ClassLoader中 loadClass() 内的一些源码，也介绍了一些核心的API，其中有一个 getParent() 是没有做说明的，这里简单说明一下，方便快速理解后续的内容。 

// 返回委托的父类加载器。 
ClassLoader getParent() 复制代码

这个方法是获取父类加载器，那么父类加载器是怎么初始化的。上一文也提到了，虽然类加载器的加载模式为双亲委派模型，但是真正在实现上并不是使用继承方式。

看下面源码， sun.misc.Launcher 类是java的入口，在启动java应用的时候会首先创建Launcher类，创建Launcher类的时候回准备应用程序运行中需要的类加载器。 

/**
*  删除了一些其他代码，方便阅读
**/
public class Launcher {
    // 可自行打印一下  bootClassPath ，看输入内容是什么？
    private static String bootClassPath = System.getProperty("sun.boot.class.path");// ①
    private static Launcher launcher = new Launcher(); // ②
    private ClassLoader loader;
    public Launcher() {
        Launcher.ExtClassLoader var1; 
        try {
            var1 = Launcher.ExtClassLoader.getExtClassLoader();
        } catch (IOException var10) {
            throw new InternalError("Could not create extension class loader", var10);
        }
        try {
            this.loader = Launcher.AppClassLoader.getAppClassLoader(var1);
        } catch (IOException var9) {
            throw new InternalError("Could not create application class loader", var9);
        }

        Thread.currentThread().setContextClassLoader(this.loader);// ③
           // 省略其他代码....
    }
}
复制代码

第一：Launcher作为JAVA应用的入口，根据我们之前所学的双亲委派模型，Laucher是由JVM创建的，它类加载器应该是 BootStrapClassLoader ， 这是一个C++编写的类加载器，是Java应用体系中最顶层的类加载器，负责加载JVM需要的一些类库，classpath配置 ( %JAVA_HOME%/jre/lib )。下面通过简单例子进行说明： 

public class TestClassLoader {
    public static void main(String[] args) {
        // 可以获取是哪个类加载器加载  Launcher 这个类
        ClassLoader classLoader = Launcher.class.getClassLoader();
        System.out.println("classLoader : " + classLoader);
        System.out.println("-------------------");
        String bootClassPath = System.getProperty("sun.boot.class.path");
        String[] split = bootClassPath.split(";");

        for (int i = 0; i < split.length; i++) {
            System.out.println(split[i]);
        }
}复制代码

输出的结果，我本地机器上路径：

classLoader : null 
-------------------
C:/Program Files/Java/jdk1.8.0_121/jre/lib/resources.jar
C:/Program Files/Java/jdk1.8.0_121/jre/lib/rt.jar
C:/Program Files/Java/jdk1.8.0_121/jre/lib/sunrsasign.jar
C:/Program Files/Java/jdk1.8.0_121/jre/lib/jsse.jar
C:/Program Files/Java/jdk1.8.0_121/jre/lib/jce.jar
C:/Program Files/Java/jdk1.8.0_121/jre/lib/charsets.jar
C:/Program Files/Java/jdk1.8.0_121/jre/lib/jfr.jar
C:/Program Files/Java/jdk1.8.0_121/jre/classes复制代码

第二：当初始化 Launcher 类的时候，遇到关键字new 进行初始化，调用构造方法。先获取到 ExtClassLoader 类加载器，然后在获取 AppClassLoader 类加载器器，然后设置 ExtClassLoader 做为它父类加载器。具体设置代码如下： 

public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
    //删掉其他代码...
    return new Launcher.AppClassLoader(var1x, var0);
}
AppClassLoader(URL[] var1, ClassLoader var2) {
    // 看 super的实现 ，var2 就是 ExtClassLoader
    super(var1, var2, Launcher.factory);
    this.ucp.initLookupCache(this);
}
/**
* 在AppClassLoader的父类中，java.net.URLClassLoader#URLClassLoader
*  super(parent); 设置父类加载器，最后可以通过 getParent() 获取父类加载器
*/
public URLClassLoader(URL[] urls, ClassLoader parent,
                      URLStreamHandlerFactory factory) {
    super(parent); // 这里就不在继续往上跟踪了，在往上代码相对简单，可自行查阅
    SecurityManager security = System.getSecurityManager();
    //删掉其他代码...
}
复制代码

第三：设置上下文类加载器的思考？

在Java中为什么需要上下文类加载器呢，这个就是一个非常有意思的问题。 Java中有两种方式获取类加载器：

第一种：一个类被加载的时候使用哪个类加载器来加载，也就是 类.class.getClassLoader() 或者 对象.getClass().getClassLoader() 。 

String str = new String();
ClassLoader classLoader1 = String.class.getClassLoader();
ClassLoader classLoader2 = str.getClass().getClassLoader();
System.out.println("String loader1 : " + classLoader1);
System.out.println("String loader2 : " + classLoader2);
-----输出为null，启动类加载器进行加载--------
String loader1 : null
String loader2 : null复制代码

第二种：通过Thread的上限文获取类加载器。为什么要通过上下文加载呢？

虽然我们都知道Java类加载的双亲委派模型，在加载一个类的时候，会优先委派给父类加载器，这样保证不会出现类被重复加载，也保证了Java一些基础类(如String类)可以稳定的存在，不会被用户自定义类顶替掉。

但是双亲委派模型并不是完美的，在一些场景下会出现一些比较难解决的问题，举个例子，在使用SPI的时候， java.util.ServiceLoader 是通过 BootStrapClassLoader 类加载器加载的，在执行到加载用户编写的扩展类的时候，如果使用当前类的类加载器，是肯定无法加载到用户编写的类的，这个时候就无法继续执行了，所以这个时候就需要使用Thread的上下文类加载器，查看源码的时候我们就发现，在用户不主动传递 ClassLoader 的时候，会获取当前上下文类加载器，这样应用程序才能正常的执行。 

public static <S> ServiceLoader<S> load(Class<S> var0) {
    ClassLoader var1 = Thread.currentThread().getContextClassLoader();
    return load(var0, var1);
}复制代码

小总结：

上面的内容是在上一篇的基础上继续的扩展，如果对还没有看过上一篇内容，请先阅读上一篇内容后，在来看这段内容。整个ClassLoader源码的的部分就分析这么多了，后面在自定义类加载器中有遇到需要分析源码的地方，还是会继续进行说明和讲解。

二、实现自定义类加载器

前面的两篇文章一直在为自定义加载器做铺垫，本文终于来引来这个神秘的嘉宾了，下面就我们用"热恋"的掌声欢迎它的出场(活跃一下气氛，因为刚才看源码太安静了)！

首先看一下JDK API中如何教我们实现从现从网络加载类的类加载器的简单示例。看下面代码：

例如，应用程序可以创建一个网络类加载器，从服务器中下载类文件。示例代码如下所示： 

ClassLoader loader = new NetworkClassLoader(host, port);
Object main = loader.loadClass("Main", true).newInstance();
. . .
网络类加载器子类必须定义方法 findClass 和 loadClassData，以实现从网络加载类。下载组成该类的字节后，它应该使用方法 defineClass 来创建类实例。示例实现如下： 

class NetworkClassLoader extends ClassLoader {
    String host;
    int port;

    public Class findClass(String name) {
    byte[] b = loadClassData(name);
    return defineClass(name, b, 0, b.length);
    }

    private byte[] loadClassData(String name) {
    // load the class data from the connection
    . . .
    }
}
复制代码

下面就“手把手”一步步教你如何实现一个自定义类加载器！

第一步： 新建一个 MyClassLoader 继承 ClassLoader 

public class MyClassLoader extends ClassLoader {}复制代码

第二步：添加自定义的类加载器属性和 构造函数 

public class MyClassLoader extends ClassLoader {
    /**
     * 类加载器名称
     */
    private String name;

    /**
     * 自定义加载路径
     */
    private String path;
    /**
     * 自定义加载文件后缀类型
     */
    private final String fileType = ".class";
    
    public MyClassLoader(String name,String path){
        //让系统类加载器(AppClassLoader)成为该类加载器的父类加载器
        super();
        this.name = name;
        this.path = path;
    }
    public MyClassLoader(ClassLoader parent,String name,String path){
        //显示指定该类的父类加载器
        super(parent);
        this.name = name;
        this.path = path;
    }
    
    @Override
    public String toString() {
        return this.name;
    }
}复制代码

第三步：重写 findClass 方法，自定义我们自己的查询类的方式，然后通过 defineClass 方法将一个 byte 数组转换为 Class 类的实例。 

/**
* 加载我们自己定义的类，通过我们自己定义的类加载器
* @param name 二进制的文件名称 
* @return Class实例对象
* @throws ClassNotFoundException
*/
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
    //获取class文件的字节数组
    byte[] resultData = this.loadByteClassData(name);

    return super.defineClass(name, resultData, 0, resultData.length);
}
/**
* 加载指定路径下面的class文件的字节数组
* @param name 二进制文件名称 ，例如：com.learn.classloader.Demo
* @return 二进制字节数组
*/
private byte[] loadByteClassData(String name) {
    byte[] classData = null;
    InputStream in = null;
    ByteArrayOutputStream os = null;
    try {
        // 比如 有包名 二进制文件名：com.learn.classloader.Demo
        // 转换为本地路径 com/learnclassloader/Demo.class
        name = this.path + name.replaceAll("//.", "/") + fileType;
        File file = new File(name);
        os = new ByteArrayOutputStream();
        in = new FileInputStream(file);

        int tmp = 0;
        while ((tmp = in.read()) != -1){
            os.write(tmp);
        }
        // 文件流转为二进制字节流
        classData = os.toByteArray();
    }catch (Exception e){
        e.printStackTrace();
    }finally {
        try {
            // 关闭流
            if(in != null){
                in.close();
            }
            if(os != null){
                os.close();
            }
        }catch (Exception e){
            e.printStackTrace();
        }

    }
    return classData;
}
复制代码

上面三步整合在一起，就实现了一个简单的类加载！ 查看自定义类加载器的全部代码。

/**
 * 自定义类加载器
 *
 * @author:dufyun
 * @version:1.0.0
 * @date 2019/3/28
 */
public class MyClassLoader extends ClassLoader {
    /**
     * 类加载器名称
     */
    private String name;

    /**
     * 自定义加载路径
     */
    private String path;
    /**
     * 自定义加载文件后缀类型
     */
    private final String fileType = ".class";

    public MyClassLoader(String name,String path){
        //让系统类加载器(AppClassLoader)成为该类加载器的父类加载器
        super();
        this.name = name;
        this.path = path;
    }
    public MyClassLoader(ClassLoader parent,String name,String path){
        //显示指定该类的父类加载器
        super(parent);
        this.name = name;
        this.path = path;
    }

    /**
     * 加载我们自己定义的类，通过我们自己定义的类加载器
     * @param name 二进制的文件名称
     * @return Class实例对象
     * @throws ClassNotFoundException
     */
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        //获取class文件的字节数组
        byte[] resultData = this.loadByteClassData(name);

        return super.defineClass(name, resultData, 0, resultData.length);
    }
    /**
     * 加载指定路径下面的class文件的字节数组
     * @param name 二进制文件名称 ，例如：com.learn.classloader.Demo
     * @return 二进制字节数组
     */
    private byte[] loadByteClassData(String name) {
        byte[] classData = null;
        InputStream in = null;
        ByteArrayOutputStream os = null;
        try {
            // 比如 有包名 二进制文件名：com.learn.classloader.Demo
            // 转换为本地路径 com/learn/classloader/Demo.class
            name = this.path + name.replaceAll("//.", "/") + fileType;
            File file = new File(name);
            os = new ByteArrayOutputStream();
            in = new FileInputStream(file);

            int tmp = 0;
            while ((tmp = in.read()) != -1){
                os.write(tmp);
            }
            // 文件流转为二进制字节流
            classData = os.toByteArray();
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                // 关闭流
                if(in != null){
                    in.close();
                }
                if(os != null){
                    os.close();
                }
            }catch (Exception e){
                e.printStackTrace();
            }

        }
        return classData;
    }

    @Override
    public String toString() {
        return this.name;
    }
}复制代码

第五：简单的测试自定义类加载器！ 

MyClassLoader myClassLoaderA = new MyClassLoader("aflyun", "F://tmp//");
System.out.println("myClassLoaderA :" + myClassLoaderA.getParent().getClass().getName());

// 设置父类加载器 为null ，启动类加载器
MyClassLoader myClassLoaderB = new MyClassLoader(null, "aflyun", "F://tmp//");
System.out.println("myClassLoaderB :" + myClassLoaderB.getParent());

------------
myClassLoaderA :sun.misc.Launcher$AppClassLoader
myClassLoaderB :null复制代码

看到这里，你如果对本篇第一小节理解的话，这里肯定会好奇， MyClassLoader 是怎么设置 AppClassLoader 为父类加载器的，在代码中只写了一个 super(); 系统类加载器(AppClassLoader)成为该类加载器的父类加载器。还是看源码 ,使用 super(); 在初始化的时候调用 CLassLoader 的构造函数，在此构造函数中有一个 getSystemClassLoader() 获取的就是 AppClassLoader 。 

protected ClassLoader() {
    this(checkCreateClassLoader(), getSystemClassLoader());
}复制代码

我们在看一下 getSystemClassLoader() 的实现，其中有一个 initSystemClassLoader() 方法获取到 Launcher 初始化加载的 ClassLoader ，然后将此 ClassLoader 赋值给 ClassLoader 类 中的 scl ！具体源码如下： 

// The class loader for the system
private static ClassLoader scl;
public static ClassLoader getSystemClassLoader() {
    initSystemClassLoader(); // 获取系统初始化的ClassLoader
    if (scl == null) {
        return null;
    }
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkClassLoaderPermission(scl, Reflection.getCallerClass());
    }
    return scl;
}
private static synchronized void initSystemClassLoader() {
    if (!sclSet) {
        // 省略其他代码.....
        sun.misc.Launcher l = sun.misc.Launcher.getLauncher();
        if (l != null) {
            Throwable oops = null;
            //从Launcher 中获取ClassLoader也就是 AppClassLoader
            scl = l.getClassLoader();
          // 省略其他代码.....
        }
        sclSet = true;
    }
}复制代码

最后 this(checkCreateClassLoader(), getSystemClassLoader()); 调用了 ClassLoader 的另一个构造函数，具体看下面源码，比较简单，就不做太多说明了。 

// 这段代码上一篇文章就介绍过
private ClassLoader(Void unused, ClassLoader parent) {
    this.parent = parent; // 将获取的系统类加载器作为父类加载器，通过getParent()获取！
    if (ParallelLoaders.isRegistered(this.getClass())) {
        parallelLockMap = new ConcurrentHashMap<>();
        // 省略其他代码.....
    } else {
        // no finer-grained lock; lock on the classloader instance
        parallelLockMap = null;
       // 省略其他代码.....
    }
}
/**
* 获取父类加载器
*/
public final ClassLoader getParent() {
    if (parent == null)
        return null;
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        checkClassLoaderPermission(parent, Reflection.getCallerClass());
    }
    return parent;
}复制代码

一张图在此说明：当前的类加载器就是自定义类加载器 MyClassLoader ! 

MyClassLoader myClassLoaderA = new MyClassLoader("aflyun", "F://tmp//");复制代码

Java内存管理-掌握自定义类加载器的实现（七）

tips1 ：自定义类加载说明

在实现自定义类加载器过程中可以重写 findClass 也可以重写 loadClass ，但一般建议重写 findClass ！

tips2 ：自定义类加载器设置了加载路径path，其实之前介绍过的类加载器也有对应的加载路径。

// BootStrapClassLoader
String bootClassPath = System.getProperty("sun.boot.class.path");
// ExtClassLoader
String var0 = System.getProperty("java.ext.dirs");
// AppClassLoader
String var1 = System.getProperty("java.class.path");复制代码

三、多案例分析

1、相同两个类文件，名称一样，一个在磁盘`F:tmp`下（无包名）一个工程中（有包名）

F:盘中代码

Java内存管理-掌握自定义类加载器的实现（七） 

public class HelloWorld {
    public HelloWorld() {
        System.out.println("--F: --HelloWorld--" + this.getClass().getClassLoader());
    }
}复制代码

工程中代码 : 

package com.learn.classloader;

public class HelloWorld {
    public HelloWorld() {
        System.out.println("--IDEA --HelloWorld--" + this.getClass().getClassLoader());
    }
}复制代码

执行类加载代码 ： 

MyClassLoader myClassLoader = new MyClassLoader("myClassLoader","F:/tmp/");
Class<?> cls = null;
try {
    //加载类文件
    cls = myClassLoader.loadClass("HelloWorld");
    cls.newInstance();//实例化类。调用构造方法
} catch (Exception e) {
    e.printStackTrace();
}复制代码

思考一下打印的结果是什么呢？

答案： --F: --HelloWorld--myClassLoader

原因分析： HelloWorld 类的class文件只有在 F:/tmp/ 下存在，所以就加载的是F盘下的 HelloWorld 类文件!

2、相同两个类文件，名称和包名一样，一个在磁盘`F:tmp`，一个在工程中

F:盘中代码

Java内存管理-掌握自定义类加载器的实现（七） 

package com.learn.classloader;
public class HelloWorld {
    public HelloWorld() {
        System.out.println("--F:com.learn.classloader --HelloWorld--" + this.getClass().getClassLoader());
    }
}复制代码

工程中的代码 : 

package com.learn.classloader;

public class HelloWorld {
    public HelloWorld() {
        System.out.println("--IDEA --HelloWorld--" + this.getClass().getClassLoader());
    }
}复制代码

执行类加载代码 ： 

MyClassLoader myClassLoader = new MyClassLoader("myClassLoader","F:/tmp/");
Class<?> cls = null;
try {
    cls = myClassLoader.loadClass("com.learn.classloader.HelloWorld");
    cls.newInstance();
} catch (Exception e) {
    e.printStackTrace();
}复制代码

思考一下打印的结果是什么呢？

答案： --IDEA --HelloWorld--sun.misc.Launcher$AppClassLoader@18b4aac2

原因分析：F盘中 HelloWorld 和工程中的 HelloWorld 具有一样的包名，并且 MyClassLoader 没有设置父类加载器，那么默认的父类加载类就是 AppClassLoader ,根据之前所学的双亲委派模型， HelloWorld 类文件会首先被父类加载器加载，也就是被 AppClassLoader 加载，只要父类加载器加载成功，子类加载器就不会在进行加载！

3、新增一个myClassLoaderB的实例设置父类加载器myClassLoader，加载MyHelloWorld

F: 盘 MyHelloWorld

Java内存管理-掌握自定义类加载器的实现（七） 

package com.learn.classloader;
public class MyHelloWorld {
    public MyHelloWorld() {
        System.out.println("--F:com.learn.classloader --MyHelloWorld--" + this.getClass().getClassLoader());
    }
}复制代码

D：盘 MyHelloWorld

Java内存管理-掌握自定义类加载器的实现（七） 

package com.learn.classloader;
public class MyHelloWorld {
    public MyHelloWorld() {
        System.out.println("--D:com.learn.classloader --MyHelloWorld--" + this.getClass().getClassLoader());
    }
}
复制代码

此时新增一个myClassLoaderB，加载 MyHelloWorld !

加载的代码如下：

MyClassLoader myClassLoader = new MyClassLoader("myClassLoader","F:/tmp/");
MyClassLoader myClassLoaderB = new MyClassLoader(myClassLoader,"myClassLoader","D:/tmp/");
Class<?> cls = null;
try {
    cls = myClassLoaderB.loadClass("com.learn.classloader.MyHelloWorld");
    cls.newInstance();
} catch (Exception e) {
    e.printStackTrace();
}复制代码

思考一下打印的结果是什么呢？

答案： --F:com.learn.classloader --MyHelloWorld--myClassLoader

原因分析： myClassLoaderB 父类加载器是 myClassLoader ,此时在加载 MyHelloWorld ,首先会被父类加载器 myClassLoader 加载！

4、新增myClassLoaderC设置父类加载器为null（启动类加载器），加载MyHelloWorld！

代码示例和示例3一样！只是修改类加载器！代码如下：

MyClassLoader myClassLoaderC = new MyClassLoader(null,"myClassLoaderC","D:/tmp/");
Class<?> cls = null;
try {
    cls = myClassLoaderC.loadClass("com.learn.classloader.MyHelloWorld");
    cls.newInstance();
} catch (Exception e) {
    e.printStackTrace();
}复制代码

思考一下打印的结果是什么呢？

答案： --D:com.learn.classloader --MyHelloWorld--myClassLoaderC

原因分析： myClassLoaderC 父类加载器是 启动类加载器 ,在 启动类加载器 中找不到 MyHelloWorld ,转一圈回来还是需要 myClassLoaderC 自己去加载！

四、本文总结

本文实现了一个自定义的类加载器，并且通过简单的案例进行讲解和说明，让我们更加深入的了解类加载器的双亲委派模式和实现原理。

对类加载器有了比较深入的学习和思考之后，会对我们以后写Java代码会有一定帮助，并且在遇到一些Java的异常如 ClassNotFoundException 能够快速知道原因。 其实类加载的知识还有很多，在这里先抛出两个问题：

问题1、Java热部署如何实现 ?修改一个Java文件后，不需要启动服务，就可以动态生效！ （目前的主流开发工具都支持，如IDEA 在windows下 Ctrl+Shirt+F9，动态编译，动态加载！或者 SpringBoot通过配置devtools实现热部署的原理是什么？）

本质上是更新clas文件内容！ 不需要重新启动服务！

问题2、之前一直提的类加载模式： 双亲模式模式！但是在Tomcat中你知道 WebappClassLoader 的加载机制吗？

说明：WebappClassLoader 会先加载自己的Class ，找不到在委托给parent，破坏双亲委派模式！

后续有时间会去整理，如果你对这两个问题感兴趣，也欢迎在文末留言，一起探讨！

五、参考资料

《JDK API 文档》

《深入理解Java虚拟机》

备注： 由于本人能力有限,文中若有错误之处,欢迎指正。

谢谢你的阅读，如果您觉得这篇博文对你有帮助，请点赞或者喜欢，让更多的人看到！祝你每天开心愉快！

Java编程技术乐园 ：一个分享编程知识的公众号。跟着老司机一起学习干货技术知识，每天进步一点点，让小的积累，带来大的改变！
扫描关注，后台回复 【资源】 ，获取珍藏干货！ 99.9% 的伙伴都很喜欢

Java内存管理-掌握自定义类加载器的实现（七）

© 每天都在变得更好的阿飞云
原文  https://juejin.im/post/5d555faef265da03b31bc849
正文到此结束
所属分类： 编程技术 Java

热门推荐

相关文章

阿里云首购8折
说给你听

本文目录
随机标签
书籍教程
springboot-demo Java入门教程 bootstrap3 CSS Apache基础教程 php ionic 教程 Python mysql教程 eclipse Ubuntu VPS系统配置 AngularJS 教程 MongoDB教程 Struts2教程 Redis教程 Spring教程 Git教程 Jenkins进阶系列 openfire参考指南 Java设计模式 HBase教程 Maven教程 hibernate教程 Docker 教程 memcached教程 Quartz指南 Hive教程 Ant教程 ANTLR教程 SpringCloud java实例教程 springcloud-demo XStream教程 Hazelcast教程 Elastic-Job-Lite 深入浅出MyBatis SVN教程 ibaties教程 rabittmq教程 solr教程 Hadoop教程 WebService CXF学习 JPA教程 ActiveMQ中文指南 java-demo Java内存模型 dubbo教程 python3-demo Linux入门视频教程
近期评论
  1. 1 Spring Cloud Consul实现选举机制
  2. 2 Spring Boot集成ShedLock实现分布式定时任务
  3. 3 利用oss进行数据库和网站图片备份
  4. 4 Spring Cloud Stream实现数据流处理
  5. 5 Python3访问MySQL数据库快速入门Demo
  6. 6 Github开源项目作者可以免费申请 JetBrains 全家桶
  7. 7 Spring Cloud Vault快速入门Demo
  8. 8 Spring Cloud Gateway快速入门Demo
  9. 9 Spring Cloud Contract快速入门Demo
  10. 10 Spring Cloud Consul快速入门Demo
网站信息
  • 文章总数：82,714 篇
  • 文件总数：284,287 个
  • 标签总数：2,393 个
  • 分类总数：85 个
  • 留言数量：2,560 条
  • 在线人数：615 人
  • 运行天数：4,408天
  • 最后更新：2024年11月21日23点
Loading...

其他链接

关于本站

本站定位：个人技术类博客

本站作用：写博客、记日志、闲聊扯淡鼓捣技术。

问题交流

[HBLOG]公众号 HBLOG HBLOG