Problème de dèmarrage d une aplication spring boot

**sonia5** · 28/09/2023, 12h17

Bonjour,

J’ai créé une application API backend avec spring boot et maven, mais je veux dèmarrer application.war au niveau de Websphere IBM j’ai l’erreur suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
webapp        E com.ibm.ws.webcontainer.webapp.WebApp notifyServletContextDestroyed SRVE0285E: Exception caught while destroying context: {0}
                                 java.lang.NullPointerException
 
com.ibm.ws.webcontainer.exception.WebAppNotLoadedException: Failed to load webapp: Failed to load webapp: null
 
bapp        E com.ibm.ws.webcontainer.webapp.WebGroupImpl WebGroup SRVE0015E: Failure to initialize Web application application.war

Sachant qu au niveau de mon pom j’ai fait exclusion de Tomcat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.14</version>
		<relativePath/>
	</parent>
............
<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
			<exclusions>
			<exclusion>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			</exclusion>
			</exclusions>
		</dependency>
	<dependency> <!-- A voir si je laisserai ça -->
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-validation</artifactId>
		<exclusions>
			<exclusion>
			<artifactId>tomcat-embed-el</artifactId>
			<groupId>org.apache.tomcat.embed</groupId>
			</exclusion>
		</exclusions>
	</dependency>
 
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
		<exclusions>
			<exclusion>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-starter-tomcat</artifactId>
			</exclusion>
			<exclusion>
				<groupId>org.apache.tomcat.embed</groupId>
				<artifactId>tomcat-embed-websocket</artifactId>
			</exclusion>
		</exclusions>
	</dependency>
 
<dependency>
    <groupId>javax.el</groupId>
    <artifactId>javax.el-api</artifactId>
    <version>3.0.0</version>
    <scope>provided</scope>
</dependency>
</dependencies>

Mais est ce que je dois ajouter des exclusions au niveau de :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
			<plugin>
            <groupId>io.openliberty.tools</groupId>
            <artifactId>liberty-maven-plugin</artifactId>
            <version>3.4</version>
        </plugin>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-war-plugin</artifactId>
            <version>3.3.2</version>
            <configuration>
                <failOnMissingWebXml>false</failOnMissingWebXml>
            </configuration>
        </plugin>

SVP, avez-vous une idée sur cet erreur, sachant que mon application est une application web service rest (backend) ?

J'attends vous retours et merci d'avance.

**PhilippeGibault** · 28/09/2023, 16h04

Effectivement, packager un WAR avec Spring Boot nécessite quelques étapes.

J'ai eu le problème au travail:
https://www.developpez.net/forums/d2...spring-2023-a/

Pour mémoire, il faut que dans la classe de configuration, on ait @EnableAutoConfiguration.

De fait, une classe de conf ressemble à:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
package com.spring.tomcat.war.test.configuration;
 
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
@EnableAutoConfiguration
@Configuration
@ComponentScan(basePackages = {"com.spring.tomcat.war.test.controller","com.spring.tomcat.war.test.service"})
public class TestConfiguration extends SpringBootServletInitializer implements WebMvcConfigurer{
 
	@Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(TestConfiguration.class);
    }
}

**sonia5** · 28/09/2023, 16h40

Merci pour votre retour, mais je pense pas qu'on a même prb car pour mon cas j'ai développé une API Rest backend Spring boot et Maven, je n'ai pas la partie Front mais j'ai généré un WAR car qd je déploie un *.jar via le serveur WebSphere, j'avais des erreurs que l'application n'est pas connue c'est pour cela j ètais obligèe de gènèrer un WAR.
Mais malgrè les exclusions de Librairie de Tomcat, il essaye de chercher le Webapp et web.xml ...

**PhilippeGibault** · 28/09/2023, 16h50

Dans ce cas là, avec un .jar, on n'a pas besoin d'un Tomcat/websphère...

Exemple dans mon projet perso:
https://bitbucket.org/philippegibaul...r40k/src/main/

Je vais effectivement ici compilé dans un JAR et non plus un WAR.

Avec comme classe de configuration:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
package com.calculateur.warhammer.rest.configuration;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
 
import com.calculateur.warhammer.rest.configuration.general.AbstractRestConfiguration;
import com.calculateur.warhammer.service.configuration.ConfigurationService;
 
/**
 * Configuration REST pour la PROD
 * @author phili
 *
 */
@Configuration
@EnableWebMvc
@Import(value = {ConfigurationService.class})
public class RestConfiguration extends AbstractRestConfiguration{
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
package com.calculateur.warhammer.rest.configuration.general;
 
import java.util.Arrays;
 
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.web.cors.CorsConfiguration;
import org.springframework.web.cors.CorsConfigurationSource;
import org.springframework.web.cors.UrlBasedCorsConfigurationSource;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
 
/**
 * Configuration pour les service REST pour Spring Boot
 * @author phili
 *
 */
@ComponentScan(basePackages = {"com.calculateur.warhammer.rest.controller"})
public class AbstractRestConfiguration implements WebMvcConfigurer{
 
	@Value("${clientWeb}")
	private String clientWeb;
 
	@Bean("securityFilterChain")
	public SecurityFilterChain getFilterChain(HttpSecurity http) throws Exception {
			return http
				.cors().configurationSource(getCorsConfigurationSource())
					.and()
				.csrf().disable()	
				.build();
	}
 
	@Bean("corsConfigurationSource")
	public CorsConfigurationSource getCorsConfigurationSource() {
		CorsConfiguration configuration = new CorsConfiguration();
		configuration.setAllowedMethods(Arrays.asList("GET","POST"));
		configuration.applyPermitDefaultValues();
		configuration.addAllowedOrigin(clientWeb);
		UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
		source.registerCorsConfiguration("/**", configuration);
		return source;
	}	
}

Comme j'ai un JAR, il faut cette fois-ci une classe Main pour lancer l'application:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
package com.calculateur.warhammer.rest.server;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Import;
 
import com.calculateur.warhammer.rest.configuration.RestConfiguration;
 
/**
 * Serveur Web pour la PROD
 * @author phili
 *
 */
@Import(value = {RestConfiguration.class})
@EnableAutoConfiguration
public class ServerWeb extends SpringBootServletInitializer{
 
	public static void main(String [] args) {
		SpringApplication.run(ServerWeb.class, args);
	}
}

De fait, je lance le programme comme un vulgaire exécutable.

Pour continuer, dans la vraie vie, c'est via un conteneur (comme Docker) que l'on déploie l'application, et un DockerFile:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
FROM eclipse-temurin:17-jdk-alpine
VOLUME /tmp
ARG ARGS_BACK
ENV ARGS_BACK=${ARGS_BACK}
COPY target/com.calculateur.40K.rest*.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

En résumé:
Si (comme c'est le cas dans mon travail), on déploie sur un serveur (TOMCAT, WEBSPHERE...), on doit déposer un WAR. Le projet Maven doit compiler dans un WAR.

Par contre, dans "La vraie vie", on déploie à partir de conteneur (comme Docker). On compile donc dans un JAR exécutable (avec une classe Main exécutable à définir), et on construit une image Docker pour lancer çaa viaa un Docker.

**PhilippeGibault** · 28/09/2023, 16h53

Après, on peut faire un war sans fichier index.html, qui est une application qui ne donne que des services REST. Le principe reste le même que mon premier message. Au travail, j'ai aussi la contrainte d'un client écrit en vue.js (à intégrer au WAR).

Sur mon projet perso, j'ai un JAR qui ne donne que des services REST. Le client est en Angular et tourne aussi grâce à sa propre image Docker basée sur nginx.

**PhilippeGibault** · 28/09/2023, 16h55

Je compile un WAR et grâce à Spring, je n'ai plus besoin d'un fichier web.xml, et grâce à Spring Boot, je n'ai pas besoin d'un fichier XML de configuration Spring.

**sonia5** · 28/09/2023, 17h29

Mon cas aussi c'est obligé d'utiliser le serveur Websphere pour le travail.
Donc je dois trouver une solution pr cet erreur.

Peut être qu'il y a de souci de version et voici mon pom.xml si vous avez des suggestions

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.14</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.application</groupId>
	<artifactId>MyApplication</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<name>MyApplication</name>
	<description>MyApplication API</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
			<exclusions>
			<exclusion>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			</exclusion>
			</exclusions>
		</dependency>
	<!--<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-validation</artifactId>
		<exclusions>
			<exclusion>
			<artifactId>tomcat-embed-el</artifactId>
			<groupId>org.apache.tomcat.embed</groupId>
			</exclusion>
		</exclusions>
	</dependency>-->
 
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<exclusions>
				<exclusion>
					<groupId>org.springframework.boot</groupId>
					<artifactId>spring-boot-starter-tomcat</artifactId>
				</exclusion>
				<exclusion>
					<groupId>org.apache.tomcat.embed</groupId>
					<artifactId>tomcat-embed-websocket</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
 
			<!--<dependency>
	    		<groupId>org.springframework.boot</groupId>
	    		<artifactId>spring-boot-starter-log4j2</artifactId>
			</dependency>-->
 
    	<!-- Dépendance pour le pilote Oracle JDBC -->
	    <dependency>
	        <groupId>com.oracle.database.jdbc</groupId>
	        <artifactId>ojdbc8</artifactId>
	        <version>19.3.0.0</version>
	    </dependency> 
	    <dependency>
	        <groupId>com.oracle.ojdbc</groupId>
	        <artifactId>ojdbc8</artifactId>
	        <version>19.3.0.0</version>
	    </dependency>
	    <dependency>
	        <groupId>com.oracle.ojdbc</groupId>
	        <artifactId>orai18n</artifactId>
	        <version>19.3.0.0</version>
	    </dependency>
 
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
			<exclusions>
			<exclusion>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
			</exclusion>
			</exclusions>
		</dependency>
		<!--<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-test</artifactId>
			<scope>test</scope>
		</dependency>-->
		<dependency>
		    <groupId>org.junit.jupiter</groupId>
		    <artifactId>junit-jupiter-api</artifactId>
		    <version>5.9.0</version>
		    <scope>test</scope>
		</dependency>
 
		<dependency>
			<groupId>com.ibm.disthub2</groupId>
			<artifactId>dhbcore</artifactId>
			<version>7.0.1.8</version>
		</dependency>                
		<dependency>
			<groupId>com.ibm.mq</groupId>
			<artifactId>com.ibm.mq.allclient</artifactId>
			<version>9.2.2.0</version>            
		</dependency>
		<dependency>
		    <groupId>org.springframework</groupId>
		    <artifactId>spring-jms</artifactId>
		    <version>5.3.14</version>
		</dependency>
 
		<dependency>
		    <groupId>com.ibm.mq</groupId>
		    <artifactId>com.ibm.mq.allclient</artifactId>
		    <version>9.1.5.0</version> 
		</dependency>
	    <dependency>
	        <groupId>javax.jms</groupId>
	        <artifactId>javax.jms-api</artifactId>
	        <version>2.0.1</version> 
	    </dependency>		    
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-api</artifactId>
			<version>2.17.1</version>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-core</artifactId>
			<version>2.17.1</version>
		</dependency>
 
		<dependency>
		    <groupId>javax.el</groupId>
		    <artifactId>javax.el-api</artifactId>
		    <version>3.0.0</version>
		    <scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<scope>provided</scope>
		</dependency>
</dependencies>
<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
			<configuration>
  				<excludeGroupIds>org.apache.tomcat.embed</excludeGroupIds>
			</configuration>
		</plugin>
 
		<plugin>
        <groupId>io.openliberty.tools</groupId>
        <artifactId>liberty-maven-plugin</artifactId>
        <version>3.4</version>
    </plugin>
    <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.3.2</version>
        <configuration>
            <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
    </plugin>
	</plugins>
 
	<pluginManagement>
		<plugins>
			<plugin>
				<groupId>org.eclipse.m2e</groupId>
				<artifactId>lifecycle-mapping</artifactId>
				<version>1.0.0</version>
				<configuration>
					<lifecycleMappingMetadata>
						<pluginExecutions>
							<pluginExecution>
								<pluginExecutionFilter>
									<groupId>
										org.apache.maven.plugins
									</groupId>
									<artifactId>
										maven-compiler-plugin
									</artifactId>
									<versionRange>
										[3.7.0,)
									</versionRange>
									<goals>
										<goal>testCompile</goal>
									</goals>
								</pluginExecutionFilter>
								<action>
									<ignore></ignore>
								</action>
							</pluginExecution>
						</pluginExecutions>
					</lifecycleMappingMetadata>
				</configuration>
			</plugin>
		</plugins>
	</pluginManagement>	
</build>
	<repositories>
		<repository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</repository>
		<repository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<releases>
				<enabled>false</enabled>
			</releases>
		</repository>
		    <repository>
      <releases>
        <enabled>false</enabled>
        <updatePolicy>always</updatePolicy>
        <checksumPolicy>warn</checksumPolicy>
      </releases>
      <snapshots>
        <enabled>true</enabled>
        <updatePolicy>never</updatePolicy>
        <checksumPolicy>fail</checksumPolicy>
      </snapshots>
      <name>Nexus Snapshots</name>
      <id>snapshots-repo</id>
      <url>https://oss.sonatype.org/content/repositories/snapshots</url>
      <layout>default</layout>
    </repository>
        <repository>
        <id>central</id>
        <url>https://repo.maven.apache.org/maven2</url>
    </repository>
	</repositories>
	<pluginRepositories>
		<pluginRepository>
			<id>spring-milestones</id>
			<name>Spring Milestones</name>
			<url>https://repo.spring.io/milestone</url>
			<snapshots>
				<enabled>false</enabled>
			</snapshots>
		</pluginRepository>
		<pluginRepository>
			<id>spring-snapshots</id>
			<name>Spring Snapshots</name>
			<url>https://repo.spring.io/snapshot</url>
			<releases>
				<enabled>false</enabled>
			</releases>
		</pluginRepository>
	</pluginRepositories>

**PhilippeGibault** · 28/09/2023, 21h14

Pour commencer, quelle est la version de Websphère?

Avant, la servlet (et le reste de JEE), les packages (pour les servlet) étaient javax.servlet.

Or, JEE est passé à la fondation Eclipse et est devenue Jakarta.

Histoire de faire chier tous le monde, Oracle a expressément interdit à la fondation Eclipse et donc à Jakarta d'avoir des package nommés en javax.

Du coup, maintenant, la servlet, c'est en jakarta.servlet.

https://javadoc.io/doc/jakarta.servl...e-summary.html

Ta version de Spring est en javax.servlet (car je vois Spring Boot version < 3). Si ton serveur EJB (Websphère) est en jakarta.servlet, ça va poser des problèmes.

Problème de dèmarrage d une aplication spring boot

Spring Java

Vue hybride

Discussions similaires

Partager

Partager