Le Tutoriel de Spring pour des débutants

View more categories:

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:
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.
  1. 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.
  2. DAO, ORM, AOP, WEB: Le module est disponible outil ou le cadre est intégré au Spring.

2.1- 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%20-->
        <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%20-->
        <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:

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

Vous pouvez télécharger  Spring à l'adresse ci-dessous:
Décompressez le fichier zip téléchargé sur un dossier de disque dur:

View more categories: