Discussion :

[Thiami]

Bonjour/Bonsoir,
ça fait trois semaines que j'ai commencer la création des API avec Spring Boot. Et là maintenant j'aimerais créer un API qui importe une liste (fichier cvs) et afficher son contenu aléatoirement et je sais pas vraiment par où commencer . Votre aide me sera utile.
Merci d'avance .

[PhilippeGibault]

On n'a pas besoin de Spring ou Spring Boot pour faire ça.

Spring est un moteur d'injection de dépendance.

C'est à dire qu'il va définir la façon dont les objets (dit bean en langage Spring) vont être instancié, et surtout, on va injecter les dépendances entre les beans.

Par exemple, les DAO vont dépendre de la BDD, on va donc injecter les dépendances liées à la BDD dans les beans de DAO.

Spring Boot, c'est encore autre chose.

Avant, Spring demandait des fichiers XML pour fabriquer la configuration. Spring Boot permet de faire la configuration à partir de classe Java, ce qui remplace les fichiers XML.

D'abord, il faut architecturer ton application. Ceci impose de découper les différentes briques, et en particulier de définir l'interface qui traite les CSV et de faire l'implémentation (ou les implémentation).

Ensuite, tu construits ta configuration avec Spring Boot, et ta classe Main pour lancer ton application.

Pour exemple, pour fabriquer ma BDD H2 de test, j'ai:

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")
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;
	}
}

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
 
package com.calculateur.warhammer.dao.configuration;
 
import java.io.File;
import java.io.IOException;
 
import org.apache.commons.io.FileUtils;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
import com.calculateur.warhammer.base.bdd.IExecuteSQL;
import com.calculateur.warhammer.dao.h2.ConfigurationH2;
import com.calculateur.warhammer.dao.sql.ExecuteFichiersSQL;
 
@Configuration
public class ConfigurationCreationBDDH2 extends AbstractConfigurationH2 {
 
	@Bean(name = "executeSQL")
	public IExecuteSQL getExecutionSQL() {
		return new ExecuteFichiersSQL(getFolderSQL(), getConfigurationH2());
	}
 
	@Override
	protected ConfigurationH2 getConfigurationH2() {
		return new ConfigurationH2(getFolderDatabase(), null, ConfigurationH2Test.PORT, ConfigurationH2Test.DATABASE_PATH,
				ConfigurationH2Test.DATABASE_SCHEMA);
	}
 
	@Override
	protected boolean isShowSQL() {
		return true;
	}
 
	@Override
	protected boolean isCreateSchema() {
		return true;
	}
 
	private File getFolderDatabase() {
		try {
			File folderH2 = new File(ConfigurationH2Test.PATH_FOLDER_BASE_DB);
			if(folderH2.listFiles() != null) {
				for(File file:folderH2.listFiles()) {
					FileUtils.deleteDirectory(file);
				}
			}
			return folderH2;
		}catch (IOException e) {
			throw new IllegalArgumentException(e);
		}
	}
 
	private File getFolderSQL() {
		return new File(ConfigurationH2Test.PATH_FOLDER_BASE_SQL);
	}
}

Avec le Main suivant:

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
 
package com.calculateur.warhammer.dao.generation;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Import;
 
import com.calculateur.warhammer.base.bdd.IExecuteSQL;
import com.calculateur.warhammer.base.server.IDatabaseServer;
import com.calculateur.warhammer.dao.configuration.ConfigurationCreationBDDH2;
 
@SpringBootApplication
@Import(ConfigurationCreationBDDH2.class)
public class GenereDatabaseH2 implements CommandLineRunner{
 
	@Autowired
    private ApplicationContext applicationContext;
 
	public static void main(String[] args) {
		SpringApplication.run(GenereDatabaseH2.class, args).stop();		
	}
 
	@Override
	public void run(String... args) throws Exception {
		IExecuteSQL executeSQL = (IExecuteSQL)applicationContext.getBean("executeSQL");
		executeSQL.executeSQL();
 
		IDatabaseServer server = (IDatabaseServer) applicationContext.getBean("serverH2");
		server.stopServer();
	}
 
}

Notez que j'ai utilisé le Design Pattern Template Methode pour pouvoir répéter ma configuration (pour des TU, par exemple).

L'avantage de Spring Boot est aussi de pouvoir démarer, dans le cadre de service REST, un Tomcat avec les services REST.
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
 
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{
 
}

Et:

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

Notez que j'ai importé des configuration (celle des services) qui importe la configuration des DAO.

Dans ce cas, on lance le serveur de la façon suivante:

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);
	}
}

Au final, Spring et Spring Boot sont de super outils/librairies, qui permettent de faire de l'injection de dépendance, de gérer l'injection de dépendances au sein d'une application Java.

C'est aussi un outil (relativement simple) et qui possède un système aux alentours pour faciliter le développement (BDD, LDAP, service REST...).

Dans une application complexe, Spring et Spring Boot deviennent vite indispensable.

Mais c'est un investissement et une complexité à payer (même si au final, c'est pour simplifier l'architecture).

Si le projet est de juste lire un CSV, dans ce cas, on risque d'être dans l'anti-pattern le Marteau doré.

C'est à dire d'utiliser un outil inadapté.

A-t-on besoin d'un marteau-piqueur pour clouer un simple clou?

[Thiami]

Merci énormément pour les explications, et c'est à travers ceux-ci que j'ai pu approfondir mes recherche (sur le fonctionnement de Spring/Spring Boot) et finir mon projet .
Merci énormément.

[PhilippeGibault]

Il n'y a pas de quoi.