Was sind FatJar und Jar in Springboot?
Einführung
Die Spring Boot-Anwendung kann mit spring-boot-maven-plugin
schnell gepackt werden, um ein spring-boot-maven-plugin
快速打包,构建一个可执行jar。Spring Boot内嵌容器,通过java -jar
命令便可以直接启动应用。
虽然是一个简单的启动命令,背后却藏着很多知识。今天带着大家探索FAT JAR启动的背后原理。本文主要包含以下几个部分:
JAR 是什么。首先需要了解jar是什么,才知道
java -jar
做了什么事情。FatJar 有什么不同。 Spring Boot提供的可执行jar与普通的jar有什么区别。
启动时的类加载原理。 启动过程中类加载器做了什么?Spring Boot又如何通过自定义类加载器解决内嵌包的加载问题。
启动的整个流程。最后整合前面三部分的内容,解析源码看如何完成启动。
JAR 是什么
JAR简介
JAR文件(Java归档,英语: Java ARchive)是一种软件包文件格式,通常用于将大量的Java类文件、相关的元数据和资源(文本、图片等)文件聚合到一个文件,以便分发Java平台应用软件或库。简单点理解其实就是一个压缩包,既然是压缩包那么为了提取JAR文件的内容,可以使用任何标准的unzip解压缩软件提取内容。或者使用Java虚拟机自带命令jar -xf foo.jar
来解压相应的jar文件。
JAR 可以简单分为两类:
非可执行JAR。打包时,不用指定
main-class
,也不可运行。普通jar包可以供其它项目进行依赖。可执行JAR。打jar包时,指定了
main-class
类,可以通过java -jar xxx.jar
命令,执行main-class
的main
方法,运行jar包。可运行jar包不可被其他项目进行依赖。
JAR结构
包结构
不管是非可行JAR还是可执行JAR解压后都包含两部分:META-INF
目录(元数据)和package
目录(编译后的class)。这种普通的jar不包含第三方依赖包,只包含应用自身的配置文件、class 等。
. ├── META-INF │ ├── MANIFEST.MF #定义 └── org # 包路径(存放编译后的class) └── springframework
描述文件MANIFEST.MF
JAR包的配置文件是META-INF
文件夹下的MANIFEST.MF
文件。主要配置信息如下:
Manifest-Version: 用来定义manifest文件的版本,例如:Manifest-Version: 1.0
Created-By: 声明该文件的生成者,一般该属性是由jar命令行工具生成的,例如:Created-By: Apache Ant 1.5.1
Signature-Version: 定义jar文件的签名版本
Class-Path: 应用程序或者类装载器使用该值来构建内部的类搜索路径,可执行jar包里需要设置这个。
上面是普通jar包的属性,可运行jar包的.MF文件中,还会有mian-class
或start-class
等属性。如果依赖了外部jar包,还会在MF文件中配置lib路径等信息。更多信息参见:maven为MANIFEST.MF文件添加内容的方法
至于可运行jar包和普通jar包的目录结构,没有什么特别固定的模式,总之,无论是什么结构,在.MF文件中,配置好jar包的信息,即可正常使用jar包了。
FatJar有什么不同
什么是FatJar?
普通的jar只包含当前 jar的信息,不含有第三方 jar。当内部依赖第三方jar时,直接运行则会报错,这时候需要将第三方jar内嵌到可执行jar里。将一个jar及其依赖的三方jar全部打到一个包中,这个包即为 FatJar。
SpringBoot FatJar解决方案
Spring Boot
为了解决内嵌jar问题,提供了一套FatJar解决方案,分别定义了jar目录结构和 MANIFEST.MF
。在编译生成可执行 jar 的基础上,使用spring-boot-maven-plugin
按Spring Boot 的可执行包标准repackage
ausführbares JAR zu erstellen. Spring Boot verfügt über einen eingebetteten Container und die Anwendung kann direkt über den Befehl java -jar
gestartet werden.
FAT JAR
zu erkunden. Dieser Artikel enthält hauptsächlich die folgenden Teile:- 🎜Was ist JAR🎜. Zuerst müssen Sie verstehen, was jar ist, bevor Sie wissen, was
java -jar
tut. 🎜 - 🎜🎜Was ist der Unterschied zu FatJar🎜. Was ist der Unterschied zwischen dem von Spring Boot bereitgestellten ausführbaren JAR und dem gewöhnlichen JAR? 🎜
- 🎜🎜Klassenladeprinzip beim Start🎜. Was macht der Klassenlader beim Start? Wie löst Spring Boot das Ladeproblem eingebetteter Pakete durch einen benutzerdefinierten Klassenlader? 🎜
- 🎜🎜Der gesamte Prozess🎜 wurde eingeleitet. Integrieren Sie abschließend den Inhalt der vorherigen drei Teile und analysieren Sie den Quellcode, um zu sehen, wie der Startvorgang abgeschlossen werden kann. Was ist JAR? Java-Klassendateien, zugehörige Metadaten und Ressourcendateien (Text, Bilder usw.) werden in einer Datei zusammengefasst, um Anwendungssoftware oder Bibliotheken für die Java-Plattform zu verteilen. Um es einfach zu verstehen: Da es sich um ein komprimiertes Paket handelt, können Sie zum Extrahieren des Inhalts der JAR-Datei eine beliebige Standard-Dekomprimierungssoftware zum Extrahieren verwenden. Oder verwenden Sie den Befehl
jar -xf foo.jar
, der mit der Java Virtual Machine geliefert wird, um die entsprechende JAR-Datei zu dekomprimieren. 🎜🎜🎜JARs können einfach in zwei Kategorien unterteilt werden: 🎜🎜- 🎜🎜Nicht ausführbare JARs🎜. Beim Packen müssen Sie
main-class
nicht angeben und es kann nicht ausgeführt werden. Gewöhnliche JAR-Pakete können von anderen Projekten als Abhängigkeit verwendet werden. 🎜 - 🎜🎜Ausführbares JAR🎜. Beim Erstellen eines JAR-Pakets wird die Klasse
main-class
angegeben. Sie können den Befehljava -jar xxx.jar
verwenden, um die Klassemain-class</ auszuführen. code> >main
-Methode, führt das JAR-Paket aus. Auf das ausführbare JAR-Paket 🎜 können sich andere Projekte nicht verlassen. 🎜 🎜 - 🎜Manifest-Version: wird verwendet, um die Version der Manifestdatei zu definieren, zum Beispiel: Manifest-Version: 1.0🎜
- 🎜Erstellt von: Deklarieren Sie den Generator der Datei. Im Allgemeinen wird dieses Attribut vom JAR-Befehlszeilentool generiert, zum Beispiel: Erstellt von: Apache Ant 1.5.1🎜 < li>🎜Signature-Version: Definition Signierte Version der JAR-Datei🎜
JAR-Struktur
🎜Paketstruktur🎜🎜Ob es sich um eine nicht lebensfähige JAR oder eine ausführbare JAR handelt, sie enthält nach der Dekomprimierung zwei Teile:META-INF
Verzeichnis (Metadaten) undpackage
Verzeichnis (kompilierte Klasse). Dieses gewöhnliche JAR enthält keine Abhängigkeitspakete von Drittanbietern, sondern nur die eigenen Konfigurationsdateien, Klassen usw. der Anwendung. 🎜🎜Beschreibungsdatei MANIFEST.MF🎜🎜Die Konfigurationsdatei des JAR-Pakets ist die Datei<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
Nach dem Login kopierenNach dem Login kopierenMANIFEST.MF
im OrdnerMETA-INF
. 🎜Die Hauptkonfigurationsinformationen🎜 lauten wie folgt: 🎜 - 🎜🎜Nicht ausführbare JARs🎜. Beim Packen müssen Sie
- 🎜Class-Path: Die Anwendung oder der Klassenlader verwendet diesen Wert, um den internen Klassensuchpfad zu erstellen. Dies muss im festgelegt werden ausführbares JAR-Paket. 🎜 🎜🎜Das Obige sind die Attribute des 🎜gewöhnlichen JAR-Pakets🎜. In der .MF-Datei des 🎜ausführbaren JAR-Pakets🎜 gibt es auch
其中
xxx.jar.original
是maven编译后的原始jar文件,即标准的java jar。该文件仅包含应用本地资源。 如果单纯使用这个jar,无法正常运行,因为缺少依赖的第三方资源。因此
spring-boot-maven-plugin
插件对这个xxx.jar.original
再做一层加工,引入第三方依赖的jar包等资源,将其"repackage"
为xxx.jar
。可执行Jar的文件结构如下图所示:META-INF: 存放元数据。MANIFEST.MF 是 jar 规范,Spring Boot 为了便于加载第三方 jar 对内容做了修改;
org: 存放Spring Boot 相关类,比如启动时所需的 Launcher 等;
BOOT-INF/class: 存放应用编译后的 class 文件;
BOOT-INF/lib: 存放应用依赖的 JAR 包。
Bootstrap CLassloder: 最顶层的加载类,主要加载核心类库
Extention ClassLoader: 扩展的类加载器,加载目录
%JRE_HOME%/lib/ext
目录下的jar包和class文件。 还可以加载-D java.ext.dirs选项指定的目录。AppClassLoader: 是应用加载器。
java -jar 启动,AppClassLoader 则会加载 MANIFEST.MF 配置的Main-Class, JarLauncher。
JarLauncher启动时,注册URL关联协议。
获取所有内嵌的存档(内嵌jar和class)
根据存档的URL[]构建类加载器。
然后用这个类加载器加载Start-Class。 保证这些类都在同一个ClassLoader中。
mian-class
oder start -class< /code> und andere Attribute. Wenn Sie auf ein externes JAR-Paket angewiesen sind, werden der lib-Pfad und andere Informationen auch in der MF-Datei konfiguriert. 🎜Weitere Informationen🎜Siehe: Wie Maven Inhalte zur MANIFEST.MF-Datei hinzufügt🎜🎜Was die Verzeichnisstruktur des 🎜ausführbaren JAR-Pakets🎜 und des 🎜gewöhnlichen JAR-Pakets🎜 betrifft, gibt es kein besonders festes Muster, nein Unabhängig von der Struktur konfigurieren Sie in der .MF-Datei die JAR-Paketinformationen, und Sie können das JAR-Paket normal verwenden. 🎜🎜Was ist der Unterschied zwischen FatJar🎜<h4 id="Was-ist-FatJar">Was ist FatJar? </h4>🎜Gewöhnliches Glas enthält nur Informationen über das aktuelle Glas und keine Gläser von Drittanbietern. Wenn Sie sich intern auf eine JAR-Datei eines Drittanbieters verlassen, wird bei direkter Ausführung ein Fehler gemeldet. In diesem Fall muss die JAR-Datei eines Drittanbieters in die ausführbare JAR-Datei eingebettet werden. 🎜Fügen Sie ein Glas und die davon abhängigen Gläser von Drittanbietern in ein Paket ein. Dieses Paket ist FatJar. 🎜🎜<h4 id="SpringBoot-FatJar-Lösung">SpringBoot FatJar-Lösung</h4>🎜<code>Spring Boot
bietet eine Reihe von FatJar-Lösungen zur Lösung des Problems eingebetteter Jars, die jeweils die 🎜jar-Verzeichnisstruktur🎜 und MANIFEST definieren .MF
. Basierend auf dem Kompilieren und Generieren einer ausführbaren JAR-Datei verwenden Sie spring-boot-maven-plugin
gemäß dem Standard für ausführbare Pakete von Spring Boot repackage
, um eine ausführbare Spring Boot-JAR-Datei zu erhalten. 🎜Je nach Art des ausführbaren Jars wird es in zwei Typen unterteilt: ausführbares Jar und ausführbarer Krieg. 🎜🎜🎜Spring-Boot-Maven-Plugin-Paketierungsprozess🎜🎜Weil es im neu erstellten leeren SpringBoot-Projekt nirgendwo eine explizite Einführung oder das Schreiben verwandter Klassen gibt. Tatsächlich können Sie für jedes neu erstellte SpringBoot-Projekt das folgende Plug-in in seiner pom.xml-Datei sehen: 🎜<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
这个是SpringBoot官方提供的用于打包FatJar的插件,org.springframework.boot.loader
下的类其实就是通过这个插件打进去的;
下面是此插件将 loader 相关类打入 FatJar 的一个执行流程:
org.springframework.boot.maven#execute-> org.springframework.boot.maven#repackage -> org.springframework.boot.loader.tools.Repackager#repackage-> org.springframework.boot.loader.tools.Repackager#writeLoaderClasses-> org.springframework.boot.loader.tools.JarWriter#writeLoaderClasses
最终的执行方法就是下面这个方法,通过注释可以看出,该方法的作用就是将 spring-boot-loader 的classes 写入到 FatJar 中。
/** * Write the required spring-boot-loader classes to the JAR. * @throws IOException if the classes cannot be written */ @Override public void writeLoaderClasses() throws IOException { writeLoaderClasses(NESTED_LOADER_JAR); }
打包结果
Spring Boot项目被编译以后,在targert
目录下存在两个jar文件:一个是xxx.jar
和xxx.jar.original
。
. ├── BOOT-INF │ ├── classes │ │ ├── application.properties # 用户-配置文件 │ │ └── com │ │ └── glmapper │ │ └── bridge │ │ └── boot │ │ └── BootStrap.class # 用户-启动类 │ └── lib │ ├── jakarta.annotation-api-1.3.5.jar │ ├── jul-to-slf4j-1.7.28.jar │ ├── log4j-xxx.jar # 表示 log4j 相关的依赖简写 ├── META-INF │ ├── MANIFEST.MF │ └── maven │ └── com.glmapper.bridge.boot │ └── guides-for-jarlaunch │ ├── pom.properties │ └── pom.xml └── org └── springframework └── boot └── loader ├── ExecutableArchiveLauncher.class ├── JarLauncher.class ├── LaunchedURLClassLoader$UseFastConnectionExceptionsEnumeration.class ├── LaunchedURLClassLoader.class ├── Launcher.class ├── MainMethodRunner.class ├── PropertiesLauncher$1.class ├── PropertiesLauncher$ArchiveEntryFilter.class ├── PropertiesLauncher$PrefixMatchingArchiveFilter.class ├── PropertiesLauncher.class ├── WarLauncher.class ├── archive │ ├── # 省略 ├── data │ ├── # 省略 ├── jar │ ├── # 省略 └── util └── SystemPropertyUtils.class
Spring Boot的MANIFEST.MF
和普通jar有些不同:
Spring-Boot-Version: 2.1.3.RELEASE Main-Class: org.springframework.boot.loader.JarLauncher Start-Class: com.rock.springbootlearn.SpringbootLearnApplication Spring-Boot-Classes: BOOT-INF/classes/ Spring-Boot-Lib: BOOT-INF/lib/ Build-Jdk: 1.8.0_131
Main-Class: 是java -jar
启动引导类,但这里不是项目中的类,而是Spring Boot内部的JarLauncher。
Start-Class: 这个才是正在要执行的应用内部主类
所以java -jar
启动的时候,加载运行的是JarLauncher。Spring Boot内部如何通过JarLauncher 加载Start-Class 执行呢?为了更清楚加载流程,我们先介绍下java -jar
是如何完成类加载逻辑的。
启动时的类加载原理
这里简单说下java -jar
启动时是如何完成记载类加载的。Java 采用了双亲委派机制,Java语言系统自带有三个类加载器:
默认情况下通过java -classpath
,java -cp
,java -jar
使用的类加载器都是AppClassLoader。 普通可执行jar通过java -jar
启动后,使用AppClassLoader加载Main-class
类。 如果第三方jar不在AppClassLoader里,会导致启动时候会报ClassNotFoundException。
例如在Spring Boot可执行jar的解压目录下,执行应用的主函数,就直接报该错误:
Exception in thread "main" java.lang.NoClassDefFoundError: org/springframework/boot/SpringApplication
at com.glmapper.bridge.boot.BootStrap.main(BootStrap.java:13)
Caused by: java.lang.ClassNotFoundException: org.springframework.boot.SpringApplication
at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:338)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
... 1 more
从异常堆栈来看,是因为找不到SpringApplication
这个类;这里其实还是比较好理解的,BootStrap
类中引入了SpringApplication
,但是这个类是在BOOT-INF/lib
下的,而java指令在启动时未指明classpath
,依赖的第三方jar无法被加载。
Spring Boot JarLauncher启动时,会将所有依赖的内嵌 jar (BOOT-INF/lib 目录下) 和class(BOOT-INF/classes 目录)都加入到自定义的类加载器LaunchedURLClassLoader中,并用这个ClassLoder去加载MANIFEST.MF配置Start-Class,则不会出现类找不到的错误。
LaunchedURLClassLoader是URLClassLoader的子类, URLClassLoader会通过URL[] 来搜索类所在的位置。Spring Boot 则将所需要的内嵌文档组装成URL[],最终构建LaunchedURLClassLoader类。
启动的整个流程
有了以上知识的铺垫,我们看下整个 FatJar 启动的过程会是怎样。为了以便查看源码和远程调试,可以在 pom.xml 引入下面的配置:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-loader</artifactId> </dependency>
简单概括起来可以分为几步:
Das obige ist der detaillierte Inhalt vonWas sind FatJar und Jar in Springboot?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Heiße KI -Werkzeuge

Undresser.AI Undress
KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover
Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool
Ausziehbilder kostenlos

Clothoff.io
KI-Kleiderentferner

AI Hentai Generator
Erstellen Sie kostenlos Ai Hentai.

Heißer Artikel

Heiße Werkzeuge

Notepad++7.3.1
Einfach zu bedienender und kostenloser Code-Editor

SublimeText3 chinesische Version
Chinesische Version, sehr einfach zu bedienen

Senden Sie Studio 13.0.1
Leistungsstarke integrierte PHP-Entwicklungsumgebung

Dreamweaver CS6
Visuelle Webentwicklungstools

SublimeText3 Mac-Version
Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

Heiße Themen



Voraussetzungen für die Ausführung von JAR-Dateien Die Ausführung von JAR-Dateien auf einem Linux-System erfordert die Installation der Java Runtime Environment (JRE), der Grundkomponente, die zum Ausführen von Java-Anwendungen erforderlich ist, einschließlich der Java Virtual Machine (JVM), Kernklassenbibliotheken usw. Viele gängige Linux-Distributionen wie Ubuntu, Debian, Fedora, openSUSE usw. bieten Softwarebibliotheken mit JRE-Paketen, um die Benutzerinstallation zu erleichtern. Im folgenden Artikel werden die Schritte zur Installation von JRE auf gängigen Distributionen detailliert beschrieben. Nach dem Einrichten der JRE können Sie je nach Ihren persönlichen Vorlieben das Befehlszeilenterminal oder die grafische Benutzeroberfläche zum Starten der JAR-Datei verwenden. Ihre Wahl hängt möglicherweise von Ihrer Vertrautheit mit Linux-Shells und Ihren persönlichen Vorlieben ab

Einführung in Jasypt Jasypt ist eine Java-Bibliothek, die es einem Entwickler ermöglicht, seinem Projekt mit minimalem Aufwand grundlegende Verschlüsselungsfunktionen hinzuzufügen und kein tiefes Verständnis der Funktionsweise der Verschlüsselung erfordert. standardbasierte Verschlüsselungstechnologie. Passwörter, Text, Zahlen, Binärdateien verschlüsseln ... Geeignet für die Integration in Spring-basierte Anwendungen, offene API, zur Verwendung mit jedem JCE-Anbieter ... Fügen Sie die folgende Abhängigkeit hinzu: com.github.ulisesbocchiojasypt-spring-boot-starter2 Die Vorteile von Jasypt schützen unsere Systemsicherheit. Selbst wenn der Code durchgesickert ist, kann die Datenquelle garantiert werden.

Nutzungsszenario 1. Die Bestellung wurde erfolgreich aufgegeben, die Zahlung erfolgte jedoch nicht innerhalb von 30 Minuten. Die Zahlung ist abgelaufen und die Bestellung wurde automatisch storniert. 2. Die Bestellung wurde unterzeichnet und es wurde 7 Tage lang keine Bewertung durchgeführt. Wenn die Bestellung abläuft und nicht ausgewertet wird, wird die Bestellung standardmäßig positiv bewertet. Wenn der Händler die Bestellung innerhalb von 5 Minuten nicht erhält, wird die Bestellung abgebrochen Es wird eine SMS-Erinnerung gesendet ... Für Szenarien mit langen Verzögerungen und geringer Echtzeitleistung können wir die Aufgabenplanung verwenden, um eine regelmäßige Abfrageverarbeitung durchzuführen. Zum Beispiel: xxl-job Heute werden wir auswählen

1. Redis implementiert das Prinzip der verteilten Sperren und warum verteilte Sperren erforderlich sind. Bevor über verteilte Sperren gesprochen wird, muss erläutert werden, warum verteilte Sperren erforderlich sind. Das Gegenteil von verteilten Sperren sind eigenständige Sperren. Wenn wir Multithread-Programme schreiben, vermeiden wir Datenprobleme, die durch den gleichzeitigen Betrieb einer gemeinsam genutzten Variablen verursacht werden. Normalerweise verwenden wir eine Sperre, um die Richtigkeit der gemeinsam genutzten Variablen sicherzustellen Die gemeinsam genutzten Variablen liegen im gleichen Prozess. Wenn es mehrere Prozesse gibt, die gleichzeitig eine gemeinsam genutzte Ressource betreiben müssen, wie können sie sich dann gegenseitig ausschließen? Heutige Geschäftsanwendungen sind in der Regel Microservice-Architekturen, was auch bedeutet, dass eine Anwendung mehrere Prozesse bereitstellen muss. Wenn mehrere Prozesse dieselbe Datensatzzeile in MySQL ändern müssen, ist eine Verteilung erforderlich, um fehlerhafte Daten zu vermeiden wird zu diesem Zeitpunkt eingeführt. Der Stil ist gesperrt. Punkte erreichen wollen

Springboot liest die Datei, kann aber nach dem Packen in ein JAR-Paket nicht auf die neueste Entwicklung zugreifen. Es gibt eine Situation, in der Springboot die Datei nach dem Packen in ein JAR-Paket nicht lesen kann ist ungültig und kann nur über den Stream gelesen werden. Die Datei befindet sich unter resources publicvoidtest(){Listnames=newArrayList();InputStreamReaderread=null;try{ClassPathResourceresource=newClassPathResource("name.txt");Input

Wenn Springboot + Mybatis-plus keine SQL-Anweisungen zum Hinzufügen mehrerer Tabellen verwendet, werden die Probleme, auf die ich gestoßen bin, durch die Simulation des Denkens in der Testumgebung zerlegt: Erstellen Sie ein BrandDTO-Objekt mit Parametern, um die Übergabe von Parametern an den Hintergrund zu simulieren dass es äußerst schwierig ist, Multi-Table-Operationen in Mybatis-plus durchzuführen. Wenn Sie keine Tools wie Mybatis-plus-join verwenden, können Sie nur die entsprechende Mapper.xml-Datei konfigurieren und die stinkende und lange ResultMap konfigurieren Schreiben Sie die entsprechende SQL-Anweisung. Obwohl diese Methode umständlich erscheint, ist sie äußerst flexibel und ermöglicht es uns

SpringBoot und SpringMVC sind beide häufig verwendete Frameworks in der Java-Entwicklung, es gibt jedoch einige offensichtliche Unterschiede zwischen ihnen. In diesem Artikel werden die Funktionen und Verwendungsmöglichkeiten dieser beiden Frameworks untersucht und ihre Unterschiede verglichen. Lassen Sie uns zunächst etwas über SpringBoot lernen. SpringBoot wurde vom Pivotal-Team entwickelt, um die Erstellung und Bereitstellung von Anwendungen auf Basis des Spring-Frameworks zu vereinfachen. Es bietet eine schnelle und einfache Möglichkeit, eigenständige, ausführbare Dateien zu erstellen

1. Passen Sie den RedisTemplate1.1-Standard-Serialisierungsmechanismus an. Die API-basierte Redis-Cache-Implementierung verwendet die RedisTemplate-Vorlage für Daten-Caching-Vorgänge. Öffnen Sie hier die RedisTemplate-Klasse und zeigen Sie die Quellcodeinformationen der Klasse publicclassRedisTemplateextendsRedisAccessorimplementsRedisOperations an. Schlüssel deklarieren, verschiedene Serialisierungsmethoden des Werts, der Anfangswert ist leer @NullableprivateRedisSe
