spring Tutoriel
Commencer avec le printemps

Remarques

Versions

Configuration (configuration XML)

Étapes pour créer Hello Spring:

0. Examinez Spring Boot pour voir si cela répondrait mieux à vos besoins.
1. Avoir un projet configuré avec les dépendances correctes. Il est recommandé d'utiliser Maven ou Gradle .
2. créer une classe POJO, par exemple Employee.java
3. créer un fichier XML dans lequel vous pouvez définir votre classe et vos variables. par exemple beans.xml
4. Créez votre classe principale, par exemple Customer.java
5. Inclure les Spring-Beans (et ses dépendances transitives!) En tant que dépendance.

Employee.java :

package com.test;

public class Employee {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void displayName() {
        System.out.println(name);
    }
}

beans.xml :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
        
    <bean id="employee" class="com.test.Employee">
        <property name="name" value="test spring"></property>
    </bean>

</beans>

Customer.java :

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Customer {
   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

      Employee obj = (Employee) context.getBean("employee");
      obj.displayName();
   }
}

Présentation des fonctionnalités de base du ressort par exemple

La description

Voici un exemple d'exécution autonome incluant / showcasing: dépendances minimales requises, configuration Java, déclaration Bean par annotation et configuration Java, injection de dépendance par constructeur et par propriété, et hooks Pre / Post .

Les dépendances

Ces dépendances sont nécessaires dans le classpath:

1. noyau de printemps
2. contexte de printemps
3. haricots de printemps
4. printemps-aop
5. expression de printemps
6. commons-journalisation

Classe principale

À partir de la fin, il s'agit de notre classe principale qui sert d'espace réservé pour la méthode main() qui initialise le contexte d'application en pointant sur la classe Configuration et charge tous les différents beans nécessaires pour présenter des fonctionnalités particulières.

package com.stackoverflow.documentation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {

    public static void main(String[] args) {

        //initializing the Application Context once per application.
        ApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);

        //bean registered by annotation
        BeanDeclaredByAnnotation beanDeclaredByAnnotation = 
                applicationContext.getBean(BeanDeclaredByAnnotation.class);
        beanDeclaredByAnnotation.sayHello();

        //bean registered by Java configuration file
        BeanDeclaredInAppConfig beanDeclaredInAppConfig = 
                applicationContext.getBean(BeanDeclaredInAppConfig.class);
        beanDeclaredInAppConfig.sayHello();

        //showcasing constructor injection
        BeanConstructorInjection beanConstructorInjection = 
                applicationContext.getBean(BeanConstructorInjection.class);
        beanConstructorInjection.sayHello();

        //showcasing property injection
        BeanPropertyInjection beanPropertyInjection = 
                applicationContext.getBean(BeanPropertyInjection.class);
        beanPropertyInjection.sayHello();

        //showcasing PreConstruct / PostDestroy hooks
        BeanPostConstructPreDestroy beanPostConstructPreDestroy = 
                applicationContext.getBean(BeanPostConstructPreDestroy.class);
        beanPostConstructPreDestroy.sayHello();
    }
}

Fichier de configuration de l'application

La classe de configuration est annotée par @Configuration et est utilisée comme paramètre dans le contexte d'application initialisé. L'annotation @ComponentScan au niveau de la classe de la classe de configuration pointe vers un package à analyser pour les beans et les dépendances enregistrés à l'aide d'annotations. Enfin, l'annotation @Bean sert de définition de bean dans la classe de configuration.

package com.stackoverflow.documentation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.stackoverflow.documentation")
public class AppConfig {

    @Bean
    public BeanDeclaredInAppConfig beanDeclaredInAppConfig() {
        return new BeanDeclaredInAppConfig();
    }
}

Déclaration de haricot par annotation

L'annotation @Component sert à délimiter le POJO en tant que bean Spring disponible pour l'enregistrement lors de l'analyse des composants.

@Component
public class BeanDeclaredByAnnotation {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredByAnnotation !");
    }
}

Déclaration de bean par configuration d'application

Notez que nous n'avons pas besoin d'annoter ou de marquer notre POJO, car la déclaration / définition du bean se produit dans le fichier de classe Configuration de l'application.

public class BeanDeclaredInAppConfig {

    public void sayHello() {
        System.out.println("Hello, World from BeanDeclaredInAppConfig !");
    }
}

Constructeur Injection

Notez que l'annotation @Autowired est définie au niveau du constructeur. Notez également que, sauf définition explicite par nom, le démarrage automatique par défaut se produit en fonction du type du bean (dans cet exemple, BeanToBeInjected ).

package com.stackoverflow.documentation;

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

@Component
public class BeanConstructorInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public BeanConstructorInjection(BeanToBeInjected dependency) {
        this.dependency = dependency;
    }

    public void sayHello() {
        System.out.print("Hello, World from BeanConstructorInjection with dependency: ");
        dependency.sayHello();
    }
}

Injection de propriété

Notez que l'annotation @Autowired délimite la méthode setter dont le nom suit le standard JavaBeans.

package com.stackoverflow.documentation;


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

@Component
public class BeanPropertyInjection {

    private BeanToBeInjected dependency;

    @Autowired
    public void setBeanToBeInjected(BeanToBeInjected beanToBeInjected) {
        this.dependency = beanToBeInjected;
    }

    public void sayHello() {
        System.out.println("Hello, World from BeanPropertyInjection !");
    }
}

Crochets PostConstruct / PreDestroy

Nous pouvons intercepter l’initialisation et la destruction d’un bean par les @PostConstruct et @PreDestroy .

package com.stackoverflow.documentation;

import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Component
public class BeanPostConstructPreDestroy {

    @PostConstruct
    public void pre() {
        System.out.println("BeanPostConstructPreDestroy - PostConstruct");
    }

    public void sayHello() {
        System.out.println(" Hello World, BeanPostConstructPreDestroy !");
    }

    @PreDestroy
    public void post() {
        System.out.println("BeanPostConstructPreDestroy - PreDestroy");
    }
}

Qu'est-ce que Spring Framework, pourquoi devrions-nous y aller?

Spring est un framework qui fournit un tas de classes. En utilisant ceci, nous n'avons pas besoin d'écrire la logique de la plaque chauffante dans notre code, donc Spring fournit une couche abstraite sur J2ee.

Par exemple, dans Simple JDBC Application, le programmeur est responsable de

1. Chargement de la classe de pilote
2. Créer la connexion
3. Création d'un objet d'instruction
4. Traitement des exceptions
5. Créer une requête
6. Exécution d'une requête
7. Fermer la connexion

Ce qui est traité comme un code standard comme chaque programmeur écrit le même code. Donc, pour simplifier, le cadre prend en charge la logique standard et le programmeur doit écrire uniquement la logique métier. Ainsi, en utilisant le framework Spring, nous pouvons développer rapidement des projets avec un minimum de lignes de code, sans aucun bogue, le coût de développement et le temps également réduit.

Alors, pourquoi choisir le printemps comme struts est là

Strut est un cadre qui fournit une solution aux aspects Web uniquement et les structures sont invasives dans la nature. Le printemps a de nombreuses fonctionnalités par rapport aux jambes de force, nous devons donc choisir le printemps.

1. Spring est de nature non invasive : cela signifie que vous n'avez pas besoin d'étendre de classes ou d'implémenter des interfaces dans votre classe.
2. Le printemps est polyvalent : cela signifie qu'il peut être intégré à toute technologie existante dans votre projet.
3. Spring fournit un développement de projet de bout en bout : cela signifie que nous pouvons développer tous les modules tels que la couche métier, la couche de persistance.
4. Le printemps est léger : cela signifie que si vous souhaitez travailler sur un module particulier, vous n'avez pas besoin d'apprendre le printemps complet, mais seulement d'apprendre ce module particulier (par exemple, Spring Jdbc, Spring DAO)
5. Spring prend en charge l'injection de dépendance .
6. Spring prend en charge le développement de plusieurs projets, par exemple: Application Core java, application Web, application distribuée, application d'entreprise.
7. Spring soutient la programmation orientée aspect pour des problèmes transversaux.

On peut donc enfin dire que Spring est une alternative aux Struts. Mais Spring ne remplace pas l'API J2EE, car les classes fournies par Spring utilisent en interne des classes d'API J2EE. Le printemps est un vaste cadre qui a été divisé en plusieurs modules. Aucun module n'est dépendant d'un autre, à l'exception de Spring Core. Certains modules importants sont

1. Base de printemps
2. JDBC de printemps
3. AOP de printemps
4. Transaction de printemps
5. ORM de printemps
6. MVC de printemps