Comment deployer sur Tomcat une app (back:Springboot, front:Angular 4) ?

Version imprimable

22/01/2018, 03h37
lenas_tshaleb

Comment deployer sur Tomcat une app (back:Springboot, front:Angular 4) ?

Bonjour à tous,

j'ai une application qui en backend utilise Java Spring Boot et en frontend utilise Angular 4.

En local (Spring Boot lancé avec Eclipse, Angular lancé avec WebStorm) => ça marche super : les service, les routes, tous quoi....

Là j'ai un serveur Tomcat (pas de serveur d'application) sur raspberry et je souhaite déployer le tous sur ce serveur.

Comment Faire ??

pour la partie front il suffit d'un build avec AngularCLI et on obtient les fichiers prêts au déploiement.
Pour jee classique (jsp, servlet, ...) exporter sur un fichier war et c'est bon.

Mais là avec spring boot je ne sais pas comment faire, donc merci d'avance pour votre aide :D
22/01/2018, 09h38
Pill_S

En produisant un war non?

Tu mets packaging war dans le pom, mvn clean install, ça produit un war que tu colles dans $TOMCAT_HOME/webapps

Ensuite tu monitores les logs (catalina.out) et tu espères que la mayonnaise prenne :)

Pour le front, il y a un plugin maven qui peut permettre de faire les opérations nécessaire (mais d'expérience c'est le plus chiant à mettre en place): https://github.com/eirslett/frontend-maven-plugin

Citation:

En produisant un war non?

Oui mais en plus de packager en war, il faut aussi modifier le code qui configurer le démarrage de l'application par le conteneur Tomcat.
Pour cela il faut juste faire hériter la classe principale de SpringBootServletInitializer et implémenter la méthode configure.
Dans le cas le plus basique :
Code:

1 2 3 4 5 6 7 8 9 10 @SpringBootApplication public class Application extends SpringBootServletInitializer { @Override protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { return application.sources(Application.class); } public static void main(String[] args) throws Exception { SpringApplication.run(Application.class, args); } }
Enfin dernière chose il faut mettre la dépendance spring-boot-starter-tomcat en provided dans ton pom.

22/01/2018, 13h08
Pill_S

En même temps on n'a aucun code, on va attendre de voir à quel stade il est avant de proposer des solutions...

D'ailleurs lenas... un peu de code ça pourrait aider non ?

Pill_S excuse moi, je mets tous mon code maintenant :D

mon but c'est d'avoir dans une base de données une table utilisateurs où je stockerai des infos genre nom, prenom, mail, ...

donc j'ai une seule classe métier "utilisateur" que voici :

Code:

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
 
package org.sid.entities;
 
import java.io.Serializable;
import java.util.Date;
 
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
 
@Entity
public class Utilisateur implements Serializable {
 
	@Id @GeneratedValue
	private Long id;
	private String nom;
	private String prenom;
	private String mail;
 
	public Utilisateur(String nom, String prenom, String mail, String mdp, String telephone, int niveau) {
		super();
		this.nom = nom;
		this.prenom = prenom;
		this.mail = mail;
		this.mdp = mdp;
		this.telephone = telephone;
		this.niveau = niveau;
	}
 
	public Utilisateur() {
		super();
		// TODO Auto-generated constructor stub
	}
 
//getters & setters ne sont pas affichés ici
}

Pour l'accès à la base de données je passe par spring data comme ceci (corrigez moi si je me trompe car je débute...)

Code:

1
2
3
4
5
6
7
8
9
10
 
package org.sid.dao;
 
import org.sid.entities.Utilisateur;
import org.springframework.data.jpa.repository.JpaRepository;
 
public interface UtilisateurRepository extends JpaRepository<Utilisateur, Long> {
	//rien pour l'instant, car les méthodes que j'utilise pour l'instant sont implémentées dans la classe mère JpaRepository
 
}

Je met en place des services qui me permettrons de récupérer les infos depuis la base de données
c'est a dire une requête http depuis le client (front) que je traduis en back puis je renvois la réponse comme ceci :

Code:

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
 
package org.sid.web;
 
import java.util.List;
 
import org.sid.dao.UtilisateurRepository;
import org.sid.entities.Utilisateur;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
 
@RestController // Il permet de faire la conversion JSON -> Objet et inversement automatiquement grace à Spring 4
@CrossOrigin("*") // Pour autoriser les navigateur à acceder ici via une URL (Rqête http)
public class UtilisateurRestService {
 
	@Autowired // Injecter la dependance UtilisateurRepository
			   // RAPPEL : UtilisateurRepository permet d'intéragir avec la BDD automatiquement
			   // grace à JpaRepository, du moins pour les accès simple (save, find, delete, ...)
	private UtilisateurRepository utilisateurRepository;
 
 
	@RequestMapping(value="/utilisateurs",method=RequestMethod.GET)
	public List<Utilisateur> getUtilisateur(){
		return utilisateurRepository.findAll();
	}
 
 
	@RequestMapping(value="/utilisateur/{id}",method=RequestMethod.GET)
	public Utilisateur getContact(@PathVariable Long id){
		return utilisateurRepository.findOne(id);
	}
 
 
	@RequestMapping(value="/utilisateur",method=RequestMethod.POST)
	public String save(@RequestBody Utilisateur u){
		utilisateurRepository.save(u);
		return "Utilisateur enregistré avec succès : \n"+u;
	}
 
 
	@RequestMapping(value="/contacts/{id}",method=RequestMethod.PUT)
	public void save(@PathVariable Long id, @RequestBody Utilisateur u){
		u.setId(id);
		utilisateurRepository.save(u);
	}
 
 
	@RequestMapping(value="/contacts/{id}",method=RequestMethod.DELETE)
	public void delete(@PathVariable Long id){
		utilisateurRepository.delete(id);
	}
 
}

pour finir la classe principale :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
package org.sid;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class InfonetApplication {
 
	public static void main(String[] args) {
		SpringApplication.run(InfonetApplication.class, args);
	}
}

il y a une autre classe générée automatiquement au moment de la création du projet spring starter je ne sais pas ce qu'elle fait la voici :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
package org.sid;
 
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;
 
public class ServletInitializer extends SpringBootServletInitializer {
 
	@Override
	protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
		return application.sources(InfonetApplication.class);
	}
 
}

Tous le code Front est placé dans un dossier Deployed Resources/webapp.

la tout marche : j'envois une requête depuis le front en POST sur /utilisateur avec les bonne données en JSON et la back les enregistre sur la base de données et me revois le code 200 avec la réponse générée dans la méthode correspondant dans UtilisateurRestService

MAIS que fait ServletInitializer ?

Une autre question qui m'intrigue : quand je teste sur Eclipse, je dois d'abord lancer la classe principale InfonetApplication.java en tant javaapplication pour que les service marchent (ici c l'envois depuis le front de la reqête de sauvegarde d'un utilisateur comme expliqué en haut...) MAIS une fois l'appli déployé sur le serveur alors PAS BESOIN DE LANCER QUOI QUE CE SOIT, JUSTE ENVOYER LA REQUETE ! POURQUOI ?

J'aimerais avoir vos remarques sur comment j'ai procédé, s'il y a des améliorations ou autres s'il vous plaît, et merci.

25/01/2018, 09h40
Pill_S

Spring Boot permet de générer soit des jar, avec une classe principale qui s'occupera de lancer un Tomcat (embarqué avec l'appli), soit de produire des war normaux, qui peuvent être déployés dans le serveur d'appli de ton choix.

"InfonetApplication" semble être la version exécutable (lancée lorsque l'application est exportée sous forme de jar), puisque lorsque tu l'exécute comme application java, tu peux accéder à tes services. Perso je trouve que c'est une mauvaise manière de faire, si tu veux updater Tomcat (à cause de patch de sécurité par exemple), tu dois recompiler l'appli (mouais...). C'est un couplage que j'aime pas trop...

Quand tu package en war, il n'y a pas de classe principale (qui contient un main(String[] arg)), c'est le serveur d'application qui déploie le code, expose les servlets, démarre les composants, etc, en fonction des instructions qu'il trouve dans le web.xml (ou en fonction d'autres choses dès la spéc servlet 3.0).

Avant de te lancer trop loin, je pense qu'il faudrait passer un peu par la case théorique...
26/01/2018, 01h04
lenas_tshaleb

Merci pour ces infos Pill_S

peux-tu m'orienter vers cette case théorique ?

Citation:

expose les servlets,

j'ai pas mi de servlet ici moi ! hors la classe ServletInitializer que je ne sais ce quelle fait, elle a été générée automatiquement.

Aussi, donc tu me conseil de passer par des war normaux que par des jar, c'est bien ça ?
26/01/2018, 09h38
Pill_S

Oui, en spring-boot, les servlets sont cachées. Tu déclares des controller (@RestController) et une servlet interne de spring s'occupe de les exposer sur l'url adéquate.

La ServletInitializer que tu as, qui étend SpringBootServletInitializer, est le mécanisme de spring-boot pour configurer les différents paramètres de ton application. Elle est documentée comme suit:

Citation:

* An opinionated {@link WebApplicationInitializer} to run a {@link SpringApplication}
* from a traditional WAR deployment. Binds {@link Servlet}, {@link Filter} and
* {@link ServletContextInitializer} beans from the application context to the servlet
* container.

Et oui, je conseille de travailler en mode war uniquement, ça permet de découpler son application du container qui l'exécute (tu peux changer de version de tomcat sans tout recompiler, et en entreprise, c'est important)

Commence par lire ceci, https://spring.io/guides/gs/spring-boot/ et si tu as des questions spécifiques, reviens nous voir