Limite de spring boot vs spring

**SEIYA.** · 29/09/2022, 12h44

Bonjour,

J'ai besoin de votre aide car ca va faire 10 ans que je fais du spring (mvc) et là je vais passer des entretiens pour des projets qui utilisent spring boot.

Mon problème c'est que j'ai du mal à comprendre ce que fait spring boot éxactement.

Pour moi spring boot permet juste de créer un nouveau projet plus facilement, une fois que le projet est créé on utilise le spring classique.

Est-ce que j'ai tord?

Merci d'avance pour votre aide.

**PhilippeGibault** · 29/09/2022, 14h18

Lorsque j'étais jeune (2012), j'ai eu aussi du mal à appréhender Spring dans sa globalité.

Pour répondre à ta question, il faut que je revienne sur les autres briques de Spring.

Le cœur du métier Spring, c'est Spring core. C'est le moteur d'injection de dépendance.

Autour de Spring gravite divers projets pour aider le développeur à faire son code. On a Spring MVC, Spring ORM, Spring data... pour les plus connus mais on peut aussi trouver du Spring LDAP...

Là, je pense que tu devais déjà connaître.

Spring Boot est une troisième brique qui permet de construire la configuration de son application.

Avant, ça se faisait par XML. Maintenant, ça se fait par classe Java.

Exemple concret pris de mon projet ( https://bitbucket.org/philippegibaul...r40k/src/main/ ):
En ce qui me concerne, j'ai divisé mon projet en plusieurs modules.

Pour la BDD, les DAO, j'ai simplement:
Une configuration de base

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
 
package com.calculateur.warhammer.dao.configuration;
 
import javax.sql.DataSource;
 
import org.hibernate.dialect.H2Dialect;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
 
import com.calculateur.warhammer.base.server.IDatabaseConfiguration;
import com.calculateur.warhammer.base.server.IDatabaseServer;
import com.calculateur.warhammer.dao.h2.ConfigurationH2;
import com.calculateur.warhammer.dao.h2.ServerH2;
 
/**
 * Une classe abstraite pour la configuration avec la BDD H2
 * @author phili
 *
 */
@ComponentScan(basePackages = {"com.calculateur.warhammer.dao.dao","com.calculateur.warhammer.dao.dao.applicable"})
public abstract class AbstractConfigurationH2 {
 
	/**
         * 
         * @return Retourne la configuration de la BDD H2
         */
	@Bean(name = "configurationH2")
	protected abstract ConfigurationH2 getConfigurationH2();
 
	/**
         * 
         * @return Vrai si Hibernate show SQL
         */
	protected abstract boolean isShowSQL();
 
	/**
         * 
         * @return Vrai si le sclema doit être créé
         */
	protected abstract boolean isCreateSchema();
 
	@Bean(name = "serverH2")
	public IDatabaseServer getServerH2() {
		return new ServerH2(getConfigurationH2());
	}
 
	@Bean(name = "localContainerEntityManagerFactoryBean")
	public LocalContainerEntityManagerFactoryBean getLocalContainerEntityManagerFactoryBean() {
		LocalContainerEntityManagerFactoryBean bean = new LocalContainerEntityManagerFactoryBean();
		bean.setDataSource(getDataSource());
		bean.setPackagesToScan("com.calculateur.warhammer.entity.entity");
		bean.setJpaVendorAdapter(getJpaVendorAdapter());
		return bean;
	}
 
	@Bean(name = "jpaVendorAdapter")
	public JpaVendorAdapter getJpaVendorAdapter() {
		HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
		adapter.setShowSql(isShowSQL());
		adapter.setDatabasePlatform(H2Dialect.class.getName());
		adapter.setGenerateDdl(isCreateSchema());
		return adapter;
	}
 
	@Bean(name = "dataSource")
	public DataSource getDataSource() {
		IDatabaseConfiguration conf = getConfigurationH2();
		DataSourceBuilder<?> builder = DataSourceBuilder.create();
		builder.driverClassName(conf.getClassDriver());
		builder.url(conf.getJDBCUrl());
		builder.username(conf.getUser());
		builder.password(conf.getPassword());
 
		return builder.build();
	}
 
	@Bean(name = "transactionManager")
	public PlatformTransactionManager getTransactionManager() {
		JpaTransactionManager transactionManager
        = new JpaTransactionManager();
      transactionManager.setEntityManagerFactory(
        getLocalContainerEntityManagerFactoryBean().getObject() );
      return transactionManager;
	}
}

Et la configuration concrète de test:

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
 
package com.calculateur.warhammer.dao.configuration;
 
import java.io.File;
import org.springframework.context.annotation.Configuration;
 
import com.calculateur.warhammer.dao.h2.ConfigurationH2;
 
@Configuration
public class ConfigurationTestBDDH2 extends AbstractConfigurationH2{
 
	@Override
	protected ConfigurationH2 getConfigurationH2() {
		return new ConfigurationH2(getFolderDatabase(), getFolderCopy(), ConfigurationH2Test.PORT, ConfigurationH2Test.DATABASE_PATH,
				ConfigurationH2Test.DATABASE_SCHEMA);
	}
 
	@Override
	protected boolean isShowSQL() {
		return false;
	}
 
	@Override
	protected boolean isCreateSchema() {
		return false;
	}
 
	private File getFolderDatabase() {
		return new File(ConfigurationH2Test.PATH_FOLDER_BASE_DB);
	}
 
	private File getFolderCopy() {
		return new File(ConfigurationH2Test.PATH_FOLDER_COPY_DB);
	}
 
}

Côté service, on utilise la configuration de la DAO:

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.service.configuration;
 
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
 
import com.calculateur.warhammer.base.traduction.ILangues;
import com.calculateur.warhammer.base.traduction.LanguesImplementation;
import com.calculateur.warhammer.calcul.pouvoir.psy.CalculProbaPouvoirPsy;
import com.calculateur.warhammer.calcul.pouvoir.psy.ICalculProbaPouvoirPsy;
import com.calculateur.warhammer.data.regles.factory.factory.FactoryFactoryRegles;
import com.calculateur.warhammer.data.regles.factory.factory.IFactoryFactoryRegle;
 
/**
 * Configuration des services par Spring boot
 * @author phili
 *
 */
@ComponentScan(basePackages = {"com.calculateur.warhammer.service.service","com.calculateur.warhammer.service.mapping"})
public class ConfigurationService {
 
	@Bean(name = "langues")
	public ILangues getLangues() {
		Locale defaut = Locale.FRANCE;
		Map<String, Locale> map = new HashMap<>();
		map.put("fr", Locale.FRANCE);
		map.put("en", Locale.ENGLISH);
		return new LanguesImplementation(defaut, map);
	}
 
	//Fabrication de règle
	@Bean(name = "factoryFactoryRegle")
	public IFactoryFactoryRegle getFactoryFactoryRegle() {
		return new FactoryFactoryRegles();
	}
 
	//Calcul proba phase psychique
	@Bean("calculProbaPouvoirPsy")
	public ICalculProbaPouvoirPsy getCalculProbaPouvoirPsy() {
		return new CalculProbaPouvoirPsy();
	}
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
package com.calculateur.warhammer.service.configuration;
 
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
 
import com.calculateur.warhammer.dao.configuration.ConfigurationTestBDDH2;
 
@Configuration
@Import(value = {ConfigurationTestBDDH2.class})
@SuppressWarnings("all")
public class ConfigurationServiceTest extends ConfigurationService{
 
}

Enfin, côté REST:

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
 
package com.calculateur.warhammer.rest.configuration;
 
import org.springframework.context.annotation.ComponentScan;
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 RestConfiguration implements WebMvcConfigurer{
 
}

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
 
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.service.configuration.ConfigurationServiceTest;
 
@Configuration
@EnableWebMvc
@Import(value = {ConfigurationServiceTest.class})
@SuppressWarnings("all")
public class ConfigurationRestTest extends RestConfiguration{
 
}

Par ailleurs, avant, il fallait compiler un WAR et le déployer sur un serveur Tomcat.

Maintenant, avec Spring Boot, c'est terminé.

On peut fabriquer des programmes main qui vont lancer le serveur Tomcat et l'application dessus.

Soit:

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.server;
 
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.context.annotation.Import;
 
import com.calculateur.warhammer.rest.configuration.ConfigurationRestTest;
 
@SpringBootApplication
@Import(value = {ConfigurationRestTest.class})
@EnableAutoConfiguration
@SuppressWarnings("all")
public class ServerTest extends SpringBootServletInitializer{
 
	public static void main(String [] args) {
		SpringApplication.run(ServerTest.class, args);
	}
}

Il est en plus possible de lancer cette classe main dans un conteneur comme Docker.

**SEIYA.** · 29/09/2022, 15h29

Merci!!

Effectivement je comprend beaucoup mieux à quels niveaux agit spring boot.

Merci beaucoup pour ton aide @PhilippeGibault, ca me sera très utile

**PhilippeGibault** · 29/09/2022, 15h56

Merci, il n'y a pas de quoi.

Limite de spring boot vs spring

Spring Boot Java

Discussions similaires

Partager

Partager