Diferenças entre arquivos war e jar

Na verdade , uma biblioteca jar é apenas um arquivo zip, que segue diretamente de seu nome: Java Archive . Na maioria das vezes, contém apenas quatro coisas:

  • classes compiladas;
  • recursos: arquivos de propriedades e similares;
  • manifesto MANIFEST.MF;
  • outras bibliotecas jar (raras).

A estrutura típica de tal arquivo se parece com isso:

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

Agora vamos ver um arquivo de guerra típico. A propósito, war não vem da palavra war, mas de W eb Archive . A estrutura de um arquivo war é geralmente mais complexa. Na maioria das vezes, consiste em duas partes:

  • parte Java
    • classes compiladas
    • recursos para classes java: arquivos de propriedades e similares
    • outras bibliotecas jar (frequentemente)
    • manifesto MANIFEST.MF
  • parte da web
    • web-xml - descritor de implantação de serviço da web
    • servlets jsp
    • recursos estáticos da web: HTML, CSS, arquivos JS

Um exemplo de arquivo de guerra típico:

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

Importante! jar pode ser executado apenas por uma máquina java, mas para executar um arquivo war, ele deve ser carregado em um servidor web. Ele não inicia sozinho.

Java university

plugin de arquivo war com maven-war-plugin

Vamos imaginar que temos um projeto web simples. Deixe o projeto receber essa estrutura de arquivo, como o montamos?

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

Primeiro, precisamos dizer ao Maven para construir tudo isso como um arquivo war , existe uma tag <package> para isso , por exemplo:

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

Em segundo lugar, precisamos incluir o plugin maven-war-plugin . Exemplo:

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

Aqui simplesmente definimos um plugin que pode ser configurado no futuro. Além disso, usando a tag webappDirectory , redefinimos o diretório no qual o projeto será implantado. Agora vou contar mais sobre o que estou falando.

O plug-in pode ser configurado para dois modos de construção (dois tipos de objetivo):

  • guerra:guerra
  • guerra: explodiu

No primeiro caso, o arquivo war resultante é simplesmente colocado na pasta de destino e denominado <artifactId>-<version>.war .

Mas você pode “pedir” ao plugin para que o conteúdo do arquivo war seja colocado na pasta final no estado em que será descompactado pelo servidor web interno. Para isso, goal war:exploded é usado .

A segunda abordagem geralmente é usada se você estiver executando ou depurando um projeto diretamente do Intellij IDEA.

A propósito, a tag webappDirectory no exemplo acima permite que você redefina o diretório onde seu arquivo war será descompactado ao compilar no modo war:exploded.

Você pode aprender sobre outras configurações de plug-in em sua página oficial .

Construindo uma aplicação web baseada em SpringBoot

Bem, eu gostaria de desmontar alguns exemplos reais de montagem. Não sejamos insignificantes e consideremos isso usando um aplicativo de exemplo baseado no SpringBoot.

Passo um. Crie um projeto da web Maven vazio com o IDEA.

Passo dois. Adicione as dependências do Spring a seu 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>

Passo três. Crie uma classe com.codegym.spring.MainController . Ele precisa ser colocado na pasta src/main/java :

@Controller
public class MainController {

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

Existem 3 coisas descritas aqui. Primeiro, a anotação @Controller informa à estrutura do SpringBoot que essa classe será usada para atender às solicitações da Web recebidas.

Em segundo lugar, a anotação @GetMapping , indica que nosso método será chamado para atender a uma solicitação GET no URI raiz - /

Em terceiro lugar, o método retorna a string "index" . Isso diz ao framework SpringBoot para retornar o conteúdo do arquivo index.html como uma resposta .

Etapa quatro. Você precisa adicionar um arquivo index.html ao projeto com o seguinte conteúdo:

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

Não é apenas html. Antes de seu conteúdo ser entregue ao cliente, ele será modificado no servidor pelo framework Thymeleaf . Tags especiais são incorporadas a este arquivo, o que permite que a biblioteca Thymeleaf processe e modifique o conteúdo da página.

As tags em vermelho são as tags que serão processadas pela biblioteca Thymeleaf, as verdes são os estilos da biblioteca Bootstrap CSS.

Quinto passo. Defina o plug-in em pom.xml:

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

Superestimei um pouco minha força. Leva muito tempo para analisar completamente um exemplo simples. Mas você pode baixar o código completo do projeto no GitHub e tentar entender você mesmo. A propósito, 80% do seu tempo de trabalho você fará exatamente isso :)

Você pode baixar o código completo no link do GitHub .