Verschillen tussen oorlogs- en jar-bestanden

In feite is een jar-bibliotheek slechts een zip-archief, wat direct volgt uit de naam : Java Archive . Meestal bevat het slechts vier dingen:

  • samengestelde klassen;
  • bronnen: eigenschappenbestanden en dergelijke;
  • manifesteren MANIFEST.MF;
  • andere jar-bibliotheken (zeldzaam).

De typische structuur van zo'n archief ziet er als volgt uit:

  META-INF/
  	MANIFEST.MF
  com/
  	codegym/
	      MyApplication.class
  application.properties

Laten we nu eens kijken naar een typisch oorlogsbestand. Oorlog komt trouwens niet van het woord oorlog, maar van W eb Ar chive . De structuur van een oorlogsdossier is meestal complexer. Meestal bestaat het uit twee delen:

  • Java-gedeelte
    • samengestelde lessen
    • bronnen voor java-klassen: eigenschappenbestanden en dergelijke
    • andere jar-bibliotheken (vaak)
    • manifesteren MANIFEST.MF
  • webonderdeel
    • web-xml - descriptor voor implementatie van webservices
    • jsp-servlets
    • statische webbronnen: HTML, CSS, JS-bestanden

Een voorbeeld van een typisch oorlogsbestand:

META-INF/
    MANIFEST.MF
WEB-INF/
    web.xml
    jsp/
    	helloWorld.jsp
    classes/
    	static/
    	templates/
    	application.properties
    lib/
    	// *.jar files as libs

Belangrijk! jar-bestand kan alleen door een java-machine worden uitgevoerd, maar om een ​​war-bestand uit te voeren, moet het naar een webserver worden geüpload. Het start niet vanzelf.

Java university

war-bestandsplugin met maven-war-plugin

Laten we ons voorstellen dat we een eenvoudig webproject hebben. Laat het project zo'n dossierstructuur krijgen, hoe zetten we het dan in elkaar?

|-- pom.xml
 `-- src
 	`-- main
     	|-- java
     	|   `-- com
     	|   	`-- example
     	|       	`-- projects
     	|           	`-- SampleAction.java
     	|-- resources
     	|   `-- images
     	|   	`-- sampleimage.jpg
     	`-- webapp
         	|-- WEB-INF
         	|   `-- web.xml
         	|-- index.jsp
         	`-- jsp
             	`-- websource.jsp

Eerst moeten we Maven vertellen om dit allemaal als een oorlogsbestand te bouwen, er is een <package> tag hiervoor , bijvoorbeeld:

	<project>
  	...
      <groupId>com.example.projects</groupId>
      <artifactId>simple-war</artifactId>
  	<packaging>war</packaging>
      <version>1.0-SNAPSHOT</version>
  	<name>Simple War Project</name>
      <url>http://codegym.cc</url>
  	...
    </project>

Ten tweede moeten we de plug-in maven-war-plug- in toevoegen . Voorbeeld:

  <build>
	<plugins>
  	<plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
    	<version>3.3.2</version>
    	<configuration>
          <webappDirectory>/sample/servlet/container/deploy/directory</webappDirectory>
    	</configuration>
      </plugin>
    </plugins>
  </build>

Hier definiëren we eenvoudig een plug-in die in de toekomst kan worden geconfigureerd. Met behulp van de webappDirectory- tag herdefiniëren we ook de map waarin het project zal worden geïmplementeerd. Nu zal ik je meer vertellen over waar ik het over heb.

De plug-in kan worden ingesteld op twee bouwmodi (twee soorten doelen):

  • oorlog: oorlog
  • oorlog: ontploft

In het eerste geval wordt het resulterende war-bestand gewoon in de doelmap geplaatst en krijgt het de naam <artifactId>-<version>.war .

Maar je kunt de plug-in "vragen" zodat de inhoud van het war-bestand in de uiteindelijke map wordt geplaatst in de staat waarin het door de webserver binnenin zal worden uitgepakt. Hiervoor wordt goal war:exploded gebruikt .

De tweede benadering wordt vaak gebruikt als u een project rechtstreeks vanuit Intellij IDEA uitvoert of debugt.

Trouwens, met de webappDirectory- tag in het bovenstaande voorbeeld kun je de map herdefiniëren waar je war-bestand zal worden uitgepakt bij het bouwen in war:exploded-modus.

U kunt meer te weten komen over andere plug-ininstellingen op de officiële pagina .

Het bouwen van een webapplicatie op basis van SpringBoot

Nou, ik zou graag een echt montagevoorbeeld willen demonteren. Laten we geen kleinigheden zijn en dit overwegen aan de hand van een voorbeeldtoepassing op basis van SpringBoot.

Stap een. Maak een leeg Maven-webproject met IDEA.

Stap twee. Voeg Spring-afhankelijkheden toe aan pom.xml.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-tomcat</artifactId>
    <scope>provided</scope>
</dependency>

Stap drie. Maak een klasse com.codegym.spring.MainController . Het moet in de map src/main/java worden geplaatst :

@Controller
public class MainController {

	@GetMapping("/")
    public String viewIndexPage(Model model) {
        model.addAttribute("header", "Maven Generate War");
    	return "index";
	}
}

Er worden hier 3 dingen beschreven. Ten eerste vertelt de @Controller-annotatie het SpringBoot-framework dat deze klasse zal worden gebruikt om inkomende webverzoeken te verwerken.

Ten tweede geeft de @GetMapping-annotatie aan dat onze methode wordt aangeroepen om een ​​GET-verzoek op de root-URI te verwerken - /

Ten derde retourneert de methode de tekenreeks "index" . Dit vertelt het SpringBoot-framework om de inhoud van het bestand index.html als antwoord te retourneren .

Stap vier. U moet een index.html-bestand aan het project toevoegen met de volgende inhoud:

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Index</title>
    <!-- Bootstrap core CSS -->
    <link th:href="@{/css/bootstrap.min.css}" rel="stylesheet">
</head>
<body>
    <nav class="navbar navbar-light bg-light">
    	<div class="container-fluid">
        	<a class="navbar-brand" href="#">
            	CodeGym Tutorial
        	</a>
    	</div>
    </nav>
    <div class="container">
    	<h1>[[${header}]]</h1>
    </div>
</body>
</html>

Het is niet alleen html. Voordat de inhoud aan de client wordt gegeven, wordt deze op de server gewijzigd door het Thymeleaf- framework . In dit bestand zijn speciale tags ingesloten, waarmee de Thymeleaf-bibliotheek de inhoud van de pagina kan verwerken en wijzigen.

De rode tags zijn de tags die door de Thymeleaf-bibliotheek worden verwerkt, de groene zijn de stijlen van de Bootstrap CSS-bibliotheek.

Stap vijf. Stel de plug-in in pom.xml in:

<plugin>
    <artifactId>maven-war-plugin</artifactId>
    <version>3.3.1</version>
</plugin>

Ik overschatte mijn kracht een beetje. Het kost veel tijd om een ​​eenvoudig voorbeeld volledig te ontleden. Maar je kunt de volledige code van het project downloaden van GitHub en het zelf proberen te begrijpen. Trouwens, 80% van je werktijd doe je precies dat :)

Je kunt de volledige code downloaden via de link in GitHub .