Le Tutoriel de Spring pour débutant

Introduction
Spring Framework
Créer le projet Maven
La déclaration des bibliothèque de base de Spring
Code Project
Spring @Configuration & IoC
Spring ApplicationContext
Des principes de travail de Spring
La programmation de l'application web utilisant Spring Boot
Annexe: Télécharger la bibliothèque Spring

1. Introduction

Ce document est basé sur:

Spring Framework 4.x
Eclipse 4.6 NEON (ok for Eclipse 4.5 MARS)

Dans ce document, j'utilise Maven pour déclarer que la bibliothèque Spring utilisera, au lieu de télécharger la bibliothèque Spring et de déclarer de manière normale.

Maven est un outil qui vous aide à gérer votre bibliothèque de manière automatique et efficace, et il est devenu habitué que tous les programmeurs Java doivent connaître. Si vous ne connaissez pas Maven, vous pouvez passer 10 minutes pour savoir comment l'utiliser ici:

Le Tutoriel de Maven pour débutant

Dans le cas où vous souhaitez télécharger Spring et déclarer la bibliothèque de la manière traditionnelle, vous pouvez voir l'annexe à la fin du document.

2. Spring Framework

L'illustration ci-dessous montre la structure de Spring Framework.

IoC Container: C'est la base la plus importante et également la base, le fondement du Spring. C'est le rôle de la configuration et de la gestion du cycle de vie des objets Java. Dans le poste d' aujourd'hui, nous allons connaître cette partie.
DAO, ORM, AOP, WEB: Le module est disponible outil ou le cadre est intégré au Spring.

Le concecpt d'Inversion de Control & Dependency Injection

Pour comprendre ce problème, nous prenons quelques classes ci-dessous:

// Interface HelloWorld
public interface HelloWorld {
    public void sayHello();
}

// Class implements HelloWorld
public class SpringHelloWorld implements HelloWorld {
   public void sayHello()  {
           System.out.println("Spring say Hello!");
   }
}

// Other class implements HelloWorld
public class StrutsHelloWorld implements HelloWorld {
   public void sayHello()  {
           System.out.println("Struts say Hello!");
   }
}


// And Service class
public class HelloWorldService {
   
     // Field type HelloWorld
     private HelloWorld helloWorld;
   
     // Constructor HelloWorldService
     // It initializes the values for the field 'helloWorld'
     public HelloWorldService()  {
           this.helloWorld = new StrutsHelloWorld();
     }

}

Il est évident que la classe HelloWorldService gère la création d'objets HelloWorld.

- Dans la situation ci-dessus, lorsqu'un objet HelloWorldService est créé à partir de son constructeur (constructor), l'objet HelloWorld est également créé. Il est créé à partir de StrutsHelloWorld.

La question est que vous souhaitez créer un objet HelloWorldService et que l'objet HelloWorld est créé simultanément, mais il doit être SpringHelloWorld.
Ainsi, HelloWorldService contrôle la "object creation" de HelloWorld. Pourquoi ne transférez-nous pas la création de HelloWorld à un tiers, au lieu de le faire dans HelloWorldService? Nous avons la définition de"inversion of control" qui signifie "inversion de contrôle" (IoC).

Et IoC Container agira en tant que gestionnaire et créera HelloWorldService et HelloWorld.

IoC = Inversion of Control

IoC Container crée l'objet HelloWorldService et l'objet HelloWorld ensuite passez l'objet HelloWorld au HelloWorldService via le passeur. Ce que IoC Container fait est d "injection de dépendance" (Dependency Injection) dans HelloWorldService . La dépendance ici signifie que la dépendance entre les objets: HelloWorldService et HelloWorld.

À ce stade, nous avons identifié clairement ce que IoC & DI. Prenons un exemple de HelloWorld pour mieux comprendre.

3. Créer le projet Maven

File/New/Other...

Saisissez:

Group Id: org.o7planning
Artifact Id: HelloSpringAnnotation
package: org.o7planning.spring

Le projet a été créé:

Assurez- vous que votre projet est build sur Java 7 ou sur la version plus récente. Cliquez sur le bouton droit du projet et sélectionnez Properties.

4. La déclaration des bibliothèque de base de Spring

C'est l'exemple de HelloWorld Spring, donc nous n'utilisons que la bibliothèque Spring de base (Core). Ouvrez le fichier pom.xml et déclarez la bibliothèque qui va utiliser:

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
  http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>org.o7planning</groupId>
  <artifactId>HelloSpringAnnotation</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>HelloSpringAnnotation</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

    <dependencies>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <!-- Spring Core -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-core -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

        <!-- Spring Context -->
        <!-- http://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>4.1.4.RELEASE</version>
        </dependency>

    </dependencies>
 
</project>

5. Code Project

Voici une illustration de la structure du projet:

Language.java

package org.o7planning.spring.lang;

// A Language
public interface Language {

    // Get a greeting
    public String getGreeting();

    // Get a bye
    public String getBye();

}

English.java

package org.o7planning.spring.lang.impl;

import org.o7planning.spring.lang.Language;

// English
public class English  implements Language {

 @Override
 public String getGreeting() {
     return "Hello";
 }

 @Override
 public String getBye() {
     return "Bye bye";
 }


}

Vietnamese.java

package org.o7planning.spring.lang.impl;

import org.o7planning.spring.lang.Language;

// Vietnamese
public class Vietnamese implements Language {

   @Override
   public String getGreeting() {
       return "Xin Chao";
   }

   @Override
   public String getBye() {
       return "Tam Biet";
   }

}

@Service est une annotation qui sert à annoter sur une classe pour informer Spring que la classe est un Spring BEAN.

@Autowired est annoté sur un champ (field) pour informer Spring qui injecte (inject) de la valeur dans le champ. Notez que la signification du terme "injecter" est similaire à attribuer une valeur à ce champ.

GreetingService.java

package org.o7planning.spring.bean;

import org.o7planning.spring.lang.Language;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class GreetingService {

   @Autowired
   private Language language;

   public GreetingService() {

   }

   public void sayGreeting() {
       
       String greeting = language.getGreeting();

       System.out.println("Greeting: " + greeting);
   }

}

@Repository est une annotation qui sert à annoter sur une classe pour informer Spring que la classe est un Spring BEAN.

MyRepository.java

package org.o7planning.spring.bean;

import java.util.Date;

import org.springframework.stereotype.Repository;

@Repository
public class MyRepository {

    public String getAppName() {
        return "Hello Spring App";
    }

    public Date getSystemDateTime() {
        return new Date();
    }
    
    
}

@Component est une annotation qui sert à annoter sur une classe pour informer Spring que la classe est un Spring BEAN.

@Autowired est annoté sur un champ (field) pour informer Spring qui injecte (inject) de la valeur dans le champ. Note: La signification du terme "injecter" est similaire à attribuer une valeur à ce champ.

MyComponent

package org.o7planning.spring.bean;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyComponent {
   
    @Autowired
    private MyRepository repository;

    public void showAppInfo() {
        System.out.println("Now is: "+ repository.getSystemDateTime());
        System.out.println("App Name: "+ repository.getAppName());
    }

}

Il n'y a pas de différence entre l'utilisation de @Service, @Component et @Repository, vous pouvez les utiliser pour annoter sur votre classe qui convient à la signification et au contexte de l'application.

6. Spring @Configuration & IoC

@Configuration est une annotation qui est annotée dans une classe définissant Spring BEAN.

@ComponentScan - fournit un rapport à Spring sur les package pour rechercher des autres Spring BEAN, Spring scannera (scan) les packages à rechercher.

AppConfiguration.java

package org.o7planning.spring.config;

import org.o7planning.spring.lang.Language;
import org.o7planning.spring.lang.impl.Vietnamese;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan({"org.o7planning.spring.bean"})
public class AppConfiguration {

    @Bean(name ="language")
    public Language getLanguage() {

        return new Vietnamese();
    }
     
}

Les Spring BEAN qui sont créées sera gérées dans Spring IoC Container (Le conteneur Spring IoC).

7. Spring ApplicationContext

MainProgram.java

package org.o7planning.spring;

import org.o7planning.spring.bean.GreetingService;
import org.o7planning.spring.bean.MyComponent;
import org.o7planning.spring.config.AppConfiguration;
import org.o7planning.spring.lang.Language;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainProgram {

   public static void main(String[] args) {

       // Creating a Context Application object by reading
       // the configuration of the 'AppConfiguration' class.
       ApplicationContext context = new AnnotationConfigApplicationContext(AppConfiguration.class);

       System.out.println("----------");
       Language language = (Language) context.getBean("language");
     
       System.out.println("Bean Language: "+ language);
       System.out.println("Call language.sayBye(): "+ language.getBye());
     
       System.out.println("----------");
     
       GreetingService service = (GreetingService) context.getBean("greetingService");
 

       service.sayGreeting();
 
       System.out.println("----------");
     
       MyComponent myComponent = (MyComponent) context.getBean("myComponent");
     
       myComponent.showAppInfo();
     
   }
 
}

Exécutez la classe MainProgram

Results:

8. Des principes de travail de Spring

Vous créez un objet ApplicationContext en lisant des configuration dans la classe AppConfiguration. Par exemple, voyez le code ci-dessous.

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfiguration.class);

Spring va créer des Spring BEAN, suites aux définitions dans la classe AppConfiguration, (Remarque: La classe AppConfiguration doit être annotée par @Configuration).

Ensuite, Spring va chercher dans le package "org.o7planning.spring.bean" pour créer des autres Spring BEAN, (Créer des objets provenant les classes annotées par @Service, @Component ou @Repository).

Maintenant Spring BEAN est créée, et est compris dans Spring IoC. Les champs de Spring BEAN sont annotées par @Autowired qui aura des valeurs injectées. Voyez l'illustration ci-dessous:

Donc, qu'est ce qui IoC?.
Dans le cas où un objet est créé à partir d'une classe traditionnellement, ses champs (field) ont une valeur assignée dans la classe. À l'inverse, pour Spring, ses objets et champs ont une valeur injectée de l'extérieur par un objet appelé IoC.

IoC signifie "Inversion of Control"

IoC Container est un conteneur contenant tous les Spring BEAN utilisés dans l'application.

9. La programmation de l'application web utilisant Spring Boot

Ensuite, vous pouvez apprendre à programmer des applications web avec Spring Boot:

Le Tutoriel de Spring Boot pour débutant

10. Annexe: Télécharger la bibliothèque Spring

Vous pouvez télécharger Spring à l'adresse ci-dessous:

https://maven.springframework.org/release/org/springframework/spring/

Décompressez le fichier zip téléchargé sur un dossier de disque dur: