Limite de spring boot vs spring

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:

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:

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:

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:

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:

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:

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:

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.