Spring : Le guide du démarrage

Spring est un framework d'application reconnu pour le développement d'applications d'entreprise. Sa capacité à permettre aux développeurs de mettre en œuvre des systèmes de presque toutes les tailles, y compris les services bancaires, ERP, e-commerce, POS (Terminal de point de vente), et autres, est remarquable. Spring est construit en utilisant le langage Java. La dernière version du framework, Spring 5, supporte désormais les applications web réactives. De plus, les applications réactives sont des applications qui adhèrent au Manifeste Réactif. Être réactif signifie qu'un système est résilient, réactif, élastique et axé sur des message-driven. Dans cet article, nous allons découvrir le concept fondamental de Spring.

Spring IOC

Au premier rang de toute application Spring est le conteneur Spring, où tous les beans gérés par Spring sont stockés et récupérés pour l'instanciation. Les principaux avantages du conteneur sont de découpler le code de la logique métier réelle. Le code inclut de l'instanciation d'objet, la configuration de base de données, la configuration de mise en file d'attente dans le cas de systèmes de messagerie ... et la liste continue. En outre, la logique métier comprend toute la logique d'application spécifiée par les exigences / spécifications métier.

The Bean Factory

Le conteneur Spring est implémenté via le composant de l'infrastructure BeanFactory . Une BeanFactory est une implémentation du modèle de conception SimpleFactory tel que décrit par le Gang of Four.

Le contexte de l'application

Le contexte d'application est une extension du composant BeanFactory, ce qui signifie que le contexte de l'application est une version plus riche en fonctionnalités de BeanFactory.

Annotations

Spring propose une grande variété d'annotations puissantes telles que @Qualifier, @Repository, @Service, @Controller, @RestController, @Configuration et @Component.

@Composant

Cette annotation est utilisée pour enregistrer simplement un POJO ou un bean dans le conteneur Spring (c'est-à-dire pour faire prendre conscience à un Spring de l'existence du POJO).

Exemple:

// The configuration class

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

@Configuration

@ComponentScan

public class AppConfig {

    @Bean(name = "Greeting")

    public Greeting getGreetingBean() {

        return new Greeting();

    }

}

// the bean class

import org.springframework.stereotype.Component;

@Component

public class Greeting {

   public void greet() {

     system.out.println("Hello World!")

   }

}

// Client application

import org.springframework.context.ApplicationContext;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

  public static void main (String args[]) {

    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

    Greeting greetingObject = (Greeting) applicationContext.getBean("Greeting");

System.out.println(greetingObject.greet());

  }

}

@Repository

L'annotation @Repository est une version plus spécialisée de l'annotation @Compoment et est principalement utilisée pour annoter les classes de couches de persistance. L'avantage supplémentaire de l'utilisation de cette annotation spécialisée dans la couche de persistance consiste à ajouter une traduction d'exception.

Exemple:

// The configuration class

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

@Configuration

@ComponentScan

public class AppConfig {

    @Bean(name = "ProductRepository")

    public ProductRepository getProductRepositoryBean() {

        return new ProductRepository();

    }

}

// the bean class

import org.springframework.stereotype.Component;

@Repository

public class ProductRepository {

   public void save() {

     system.out.println("Product Saved.")

   }

}

// Client application

import org.springframework.context.ApplicationContext;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

  public static void main (String args[]) {

    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

    ProductRepository productRepository = (ProductRepository) applicationContext.getBean("ProductRepository");

    System.out.println(productRepository.save());

  }

}

@Service

L'annotation @Service est une version plus spécialisée de l'annotation @Compoment et est principalement utilisée pour annoter les classes de la couche de service.

Exemple:

// The configuration class

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

@Configuration

@ComponentScan

public class AppConfig {

    @Bean(name = "ProductService")

    public ProductService getProductServiceBean() {

        return new ProductService();

    }

}

// the bean class

import org.springframework.stereotype.Component;

@Service

public class ProductService {

   public void isProductOutOfStock() {

     system.out.println(true)

   }

}

// Client application

import org.springframework.context.ApplicationContext;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Application {

  public static void main (String args[]) {

    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(AppConfig.class);

    ProductService productService = (ProductService) applicationContext.getBean("ProductService");

System.out.println(productService.isProductOutOfStock());

  }

}

@Controller

L'annotation @Controller est une version plus spécialisée de l'annotation @Compoment et est principalement utilisée pour annoter les classes de couche de présentation (spring-mvc).

Exemple:

// The configuration class

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.ComponentScan;

import org.springframework.context.annotation.Configuration;

@Configuration

@ComponentScan

public class AppConfig {

    @Bean(name = "ProductService")

    public ProductService getProductServiceBean() {

        return new ProductService();

    }

}

// the bean class

import org.springframework.stereotype.Component;

@Controller

public class ProductController {

   @Autowire

   private ProductService productService;

   @RequestMapping(value = "/product", method = RequestMethod.POST, produces = MediaType.APPLICATION_JSON_VALUE)

   public void create(@RequestBody Product product) {

     productService.save(product)

     return ResponseEntity.ok().build();

   }

}

Afin de tester entièrement ce point, un serveur tel que Tomcat sera nécessaire. 

@Configuration

L'annotation @Configuration est une version plus spécialisée de l'annotation @Compoment et est principalement utilisée pour annoter les classes de configuration (c'est-à-dire les classes qui contiendront le code "plomberie").

@Qualificatif

Cette annotation est utilisée pour enregistrer deux beans ayant la même interface mais des implémentations différentes. L'annotation Qualifier permet à l'application cliente de spécifier quelle implémentation doit être instanciée.

Exemple:

// Service interface

public interface SalesService {

public void registerSale(Sale sale);

} 

// cash sale implementation

@Qualifier('CashSale')

@Service

public class CashSale implements SaleService {

  public void registerSale(Sale sale){

    System.out.println("registering cash sale.")

  }

}

@Qualifier('CardSale')

@Service

public class CardSale implements SaleService {

  public void registerSale(Sale sale){

     System.out.println("registering card sale.")

  }

}

// client application

public class Application {

@Autowire

  @Qualifier('CardSale')

  private CardSale cardSale;

  @Autowire

  @Qualifier('CashSale')

  private CashSale cashSale;

  //a Dummy method just to demonstrate how the different implementations could be used.

  public void performSale(Sale sale) {

      if (sale.getSaleType == "Cash") {

      cashSale.registerSale(sale)

      } else if (sale.getSaleType == "Card") {

      cardSale.registerSale(sale)

      }

    }

@Autowire

L'annotation @Autowire est utilisée pour instancier les objets qui sont enregistrés avec Spring.

Mettre tous ensemble

Dans cet article, nous avons découvert quelques-uns des principaux concepts du framework Spring. Spring est devenu un framework d'application très vaste et modulaire. Il a maintenant des modules qui servent également d'abstractions pour presque tous les systèmes populaires tels que Facebook, Twitter, etc. Certaines de ces abstractions, selon le site Web de Spring, sont Spring Social Facebook, Spring Social LinkedIn, et Spring Social Twitter. D'autres abstractions incluent le projet de données Spring Data, utile pour la couche de persistance.