Inhaltsverzeichnis
Einführung
JAR 是什么
JAR简介
JAR结构
包结构
描述文件MANIFEST.MF
FatJar有什么不同
什么是FatJar?
SpringBoot FatJar解决方案
FAT JAR
JAR-Struktur
Was ist FatJar?
SpringBoot FatJar-Lösung
打包结果
启动时的类加载原理
启动的整个流程
Heim Java javaLernprogramm Was sind FatJar und Jar in Springboot?

Was sind FatJar und Jar in Springboot?

May 11, 2023 am 09:58 AM
jar springboot fatjar

    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-classmain方法,运行jar包。可运行jar包不可被其他项目进行依赖。

    JAR结构

    包结构

    不管是非可行JAR还是可执行JAR解压后都包含两部分:META-INF目录(元数据)和package目录(编译后的class)。这种普通的jar不包含第三方依赖包,只包含应用自身的配置文件、class 等。

    .
    ├── META-INF
    │   ├── MANIFEST.MF  #定义
    └── org  # 包路径(存放编译后的class)
        └── springframework
    Nach dem Login kopieren
    描述文件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-classstart-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 的可执行包标准repackageausführbares JAR zu erstellen. Spring Boot verfügt über einen eingebetteten Container und die Anwendung kann direkt über den Befehl java -jar gestartet werden.

    Obwohl es sich um einen einfachen Startbefehl handelt, verbirgt sich dahinter eine Menge Wissen. Heute werde ich Sie mitnehmen, um die Prinzipien hinter dem Startup von
    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 Befehl java -jar xxx.jar verwenden, um die Klasse main-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. 🎜
      • 🎜

        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) und package Verzeichnis (kompilierte Klasse). Dieses gewöhnliche JAR enthält keine Abhängigkeitspakete von Drittanbietern, sondern nur die eigenen Konfigurationsdateien, Klassen usw. der Anwendung. 🎜
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
        Nach dem Login kopieren
        Nach dem Login kopieren
        🎜Beschreibungsdatei MANIFEST.MF🎜🎜Die Konfigurationsdatei des JAR-Pakets ist die Datei MANIFEST.MF im Ordner META-INF. 🎜Die Hauptkonfigurationsinformationen🎜 lauten wie folgt: 🎜
        • 🎜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🎜
        • 🎜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 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>
          Nach dem Login kopieren
          Nach dem Login kopieren

          这个是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
          Nach dem Login kopieren

          最终的执行方法就是下面这个方法,通过注释可以看出,该方法的作用就是将 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);
          }
          Nach dem Login kopieren
          打包结果

          Spring Boot项目被编译以后,在targert目录下存在两个jar文件:一个是xxx.jarxxx.jar.original

          • 其中xxx.jar.original是maven编译后的原始jar文件,即标准的java jar。该文件仅包含应用本地资源。 如果单纯使用这个jar,无法正常运行,因为缺少依赖的第三方资源。

          • 因此spring-boot-maven-plugin插件对这个xxx.jar.original再做一层加工,引入第三方依赖的jar包等资源,将其 "repackage"xxx.jar。可执行Jar的文件结构如下图所示:

          .
          ├── 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
          Nach dem Login kopieren
          • META-INF: 存放元数据。MANIFEST.MF 是 jar 规范,Spring Boot 为了便于加载第三方 jar 对内容做了修改;

          • org: 存放Spring Boot 相关类,比如启动时所需的 Launcher 等;

          • BOOT-INF/class: 存放应用编译后的 class 文件;

          • BOOT-INF/lib: 存放应用依赖的 JAR 包。

          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
          Nach dem Login kopieren

          Main-Class:java -jar启动引导类,但这里不是项目中的类,而是Spring Boot内部的JarLauncher
          Start-Class: 这个才是正在要执行的应用内部主类

          所以java -jar启动的时候,加载运行的是JarLauncher。Spring Boot内部如何通过JarLauncher 加载Start-Class 执行呢?为了更清楚加载流程,我们先介绍下java -jar是如何完成类加载逻辑的。

          启动时的类加载原理

          这里简单说下java -jar启动时是如何完成记载类加载的。Java 采用了双亲委派机制,Java语言系统自带有三个类加载器:

          • Bootstrap CLassloder: 最顶层的加载类,主要加载核心类库

          • Extention ClassLoader: 扩展的类加载器,加载目录%JRE_HOME%/lib/ext目录下的jar包和class文件。 还可以加载-D java.ext.dirs选项指定的目录。

          • AppClassLoader: 是应用加载器。

          默认情况下通过java -classpathjava -cpjava -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>
          Nach dem Login kopieren

          简单概括起来可以分为几步:

          • java -jar 启动,AppClassLoader 则会加载 MANIFEST.MF 配置的Main-Class, JarLauncher。

          • JarLauncher启动时,注册URL关联协议。

          • 获取所有内嵌的存档(内嵌jar和class)

          • 根据存档的URL[]构建类加载器。

          • 然后用这个类加载器加载Start-Class。 保证这些类都在同一个ClassLoader中。

          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!

    Erklärung dieser Website
    Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn

    Heiße KI -Werkzeuge

    Undresser.AI Undress

    Undresser.AI Undress

    KI-gestützte App zum Erstellen realistischer Aktfotos

    AI Clothes Remover

    AI Clothes Remover

    Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

    Undress AI Tool

    Undress AI Tool

    Ausziehbilder kostenlos

    Clothoff.io

    Clothoff.io

    KI-Kleiderentferner

    AI Hentai Generator

    AI Hentai Generator

    Erstellen Sie kostenlos Ai Hentai.

    Heißer Artikel

    R.E.P.O. Energiekristalle erklärten und was sie tun (gelber Kristall)
    3 Wochen vor By 尊渡假赌尊渡假赌尊渡假赌
    R.E.P.O. Beste grafische Einstellungen
    3 Wochen vor By 尊渡假赌尊渡假赌尊渡假赌
    R.E.P.O. So reparieren Sie Audio, wenn Sie niemanden hören können
    3 Wochen vor By 尊渡假赌尊渡假赌尊渡假赌
    WWE 2K25: Wie man alles in Myrise freischaltet
    3 Wochen vor By 尊渡假赌尊渡假赌尊渡假赌

    Heiße Werkzeuge

    Notepad++7.3.1

    Notepad++7.3.1

    Einfach zu bedienender und kostenloser Code-Editor

    SublimeText3 chinesische Version

    SublimeText3 chinesische Version

    Chinesische Version, sehr einfach zu bedienen

    Senden Sie Studio 13.0.1

    Senden Sie Studio 13.0.1

    Leistungsstarke integrierte PHP-Entwicklungsumgebung

    Dreamweaver CS6

    Dreamweaver CS6

    Visuelle Webentwicklungstools

    SublimeText3 Mac-Version

    SublimeText3 Mac-Version

    Codebearbeitungssoftware auf Gottesniveau (SublimeText3)

    So führen Sie JAR-Dateien unter Linux aus So führen Sie JAR-Dateien unter Linux aus Feb 20, 2024 am 10:40 AM

    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

    Wie Springboot Jasypt integriert, um die Verschlüsselung von Konfigurationsdateien zu implementieren Wie Springboot Jasypt integriert, um die Verschlüsselung von Konfigurationsdateien zu implementieren Jun 01, 2023 am 08:55 AM

    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.

    Wie SpringBoot Redisson integriert, um eine Verzögerungswarteschlange zu implementieren Wie SpringBoot Redisson integriert, um eine Verzögerungswarteschlange zu implementieren May 30, 2023 pm 02:40 PM

    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

    So implementieren Sie verteilte Sperren mit Redis in SpringBoot So implementieren Sie verteilte Sperren mit Redis in SpringBoot Jun 03, 2023 am 08:16 AM

    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

    So lösen Sie das Problem, dass Springboot nach dem Einlesen in ein JAR-Paket nicht auf die Datei zugreifen kann So lösen Sie das Problem, dass Springboot nach dem Einlesen in ein JAR-Paket nicht auf die Datei zugreifen kann Jun 03, 2023 pm 04:38 PM

    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

    So implementieren Sie Springboot+Mybatis-plus, ohne SQL-Anweisungen zum Hinzufügen mehrerer Tabellen zu verwenden So implementieren Sie Springboot+Mybatis-plus, ohne SQL-Anweisungen zum Hinzufügen mehrerer Tabellen zu verwenden Jun 02, 2023 am 11:07 AM

    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

    Vergleich und Differenzanalyse zwischen SpringBoot und SpringMVC Vergleich und Differenzanalyse zwischen SpringBoot und SpringMVC Dec 29, 2023 am 11:02 AM

    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

    Wie SpringBoot Redis anpasst, um die Cache-Serialisierung zu implementieren Wie SpringBoot Redis anpasst, um die Cache-Serialisierung zu implementieren Jun 03, 2023 am 11:32 AM

    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

    See all articles