Costruire un progetto di guerra

Differenze tra file war e jar

In effetti , una libreria jar è solo un archivio zip, che deriva direttamente dal suo nome: Java Archive . Molto spesso contiene solo quattro cose:

• classi compilate;
• risorse: file di proprietà e simili;
• manifest MANIFEST.MF;
• altre librerie jar (raro).

La struttura tipica di un tale archivio è la seguente:

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

Ora diamo un'occhiata a un tipico file di guerra. A proposito, la guerra non deriva dalla parola guerra, ma da W eb Archive . La struttura di un war file è generalmente più complessa. Molto spesso si compone di due parti:

• parte Java
  • classi compilate
  • risorse per le classi java: file delle proprietà e simili
  • altre librerie jar (spesso)
  • manifest MANIFEST.MF
• parte web
  • web-xml - descrittore di distribuzione del servizio Web
  • servlet jsp
  • risorse web statiche: file HTML, CSS, JS

Un esempio di un tipico file di guerra:

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

Importante! jar può essere eseguito solo da una macchina java, ma per eseguire un file war, deve essere caricato su un server web. Non si avvia da solo.

war file plugin con maven-war-plugin

Immaginiamo di avere un semplice progetto web. Lascia che il progetto riceva una tale struttura di file, come lo assembliamo?

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

Per prima cosa, dobbiamo dire a Maven di costruire tutto questo come un file war , c'è un tag <package> per this , ad esempio:

	<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>

In secondo luogo, dobbiamo includere il plug-in maven-war-plugin . Esempio:

  <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>

Qui definiamo semplicemente un plugin che può essere configurato in futuro. Inoltre, utilizzando il tag webappDirectory , ridefiniamo la directory in cui verrà distribuito il progetto. Ora ti dirò di più su ciò di cui sto parlando.

Il plug-in può essere impostato su due modalità di compilazione (due tipi di obiettivo):

• guerra: guerra
• guerra: esplosa

Nel primo caso, il file war risultante viene semplicemente inserito nella cartella di destinazione e denominato <artifactId>-<version>.war .

Ma puoi "chiedere" al plugin in modo che il contenuto del file war venga inserito nella cartella finale nello stato in cui verrà decompresso dal server web all'interno. Per questo, viene utilizzato goal war:exploded .

Il secondo approccio viene spesso utilizzato se si esegue o si esegue il debug di un progetto direttamente da Intellij IDEA.

A proposito, il tag webappDirectory nell'esempio sopra ti consente di ridefinire la directory in cui il tuo file war verrà decompresso durante la compilazione in modalità war:exploded.

Puoi conoscere altre impostazioni del plugin dalla sua pagina ufficiale .

Creazione di un'applicazione Web basata su SpringBoot

Bene, vorrei smontare qualche vero esempio di assemblaggio. Non facciamo sciocchezze e consideriamolo utilizzando un'applicazione di esempio basata su SpringBoot.

Primo passo. Crea un progetto web Maven vuoto con IDEA.

Passo due. Aggiungi le dipendenze Spring al suo 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>

Fase tre. Crea una classe com.codegym.spring.MainController . Deve essere inserito nella cartella src/main/java :

@Controller
public class MainController {

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

Ci sono 3 cose descritte qui. Innanzitutto, l'annotazione @Controller indica al framework SpringBoot che questa classe verrà utilizzata per servire le richieste Web in arrivo.

In secondo luogo, l'annotazione @GetMapping indica che il nostro metodo verrà chiamato per servire una richiesta GET sull'URI root - /

Terzo, il metodo restituisce la stringa "index" . Questo dice al framework SpringBoot di restituire il contenuto del file index.html come risposta .

Fase quattro. Devi aggiungere un file index.html al progetto con il seguente contenuto:

<!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>

Non è solo html. Prima che il suo contenuto venga fornito al client, verrà modificato sul server dal framework Thymeleaf . Tag speciali sono incorporati in questo file, che consentono alla libreria Thymeleaf di elaborare e modificare il contenuto della pagina.

I tag in rosso sono i tag che verranno elaborati dalla libreria Thymeleaf, quelli verdi sono gli stili della libreria CSS di Bootstrap.

Passaggio cinque. Imposta il plugin in pom.xml:

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

Ho sopravvalutato un po' la mia forza. Ci vuole molto tempo per analizzare completamente un semplice esempio. Ma puoi scaricare il codice completo del progetto da GitHub e provare a capirlo da solo. A proposito, l'80% del tuo orario di lavoro lo farai :)

È possibile scaricare il codice completo dal collegamento in GitHub .