IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Spring Boot Java Discussion :

Affichage d'une Liste aléatoire avec Spring boot


Sujet :

Spring Boot Java

  1. #1
    Candidat au Club
    Femme Profil pro
    Étudiant
    Inscrit en
    Août 2022
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 23
    Localisation : Mali

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Août 2022
    Messages : 2
    Par défaut Affichage d'une Liste aléatoire avec Spring boot
    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 .

  2. #2
    Membre très actif

    Profil pro
    Inscrit en
    Janvier 2009
    Messages
    486
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2009
    Messages : 486
    Billets dans le blog
    5
    Par défaut
    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?

  3. #3
    Candidat au Club
    Femme Profil pro
    Étudiant
    Inscrit en
    Août 2022
    Messages
    2
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 23
    Localisation : Mali

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Août 2022
    Messages : 2
    Par défaut
    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.

  4. #4
    Membre très actif

    Profil pro
    Inscrit en
    Janvier 2009
    Messages
    486
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2009
    Messages : 486
    Billets dans le blog
    5
    Par défaut
    Il n'y a pas de quoi.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Creation d une api rest avec spring boot
    Par ofilwende530 dans le forum Spring
    Réponses: 1
    Dernier message: 07/01/2022, 03h45
  2. [XL-2019] Trier une liste aléatoirement avec conditions
    Par Killian.B dans le forum Excel
    Réponses: 3
    Dernier message: 09/11/2021, 10h48
  3. Réponses: 0
    Dernier message: 26/05/2008, 16h41
  4. [MySQL] affichage d'une liste avec une boucle while
    Par Invité dans le forum PHP & Base de données
    Réponses: 3
    Dernier message: 29/01/2007, 20h19
  5. Réponses: 7
    Dernier message: 06/03/2006, 15h38

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo