spring Tutorial
Iniziare con la primavera

Osservazioni

Versioni

Setup (configurazione XML)

Passi per creare Hello Spring:

0. Indaga su Spring Boot per vedere se ciò sarebbe più adatto alle tue esigenze.
1. Avere un progetto impostato con le dipendenze corrette. Si consiglia di utilizzare Maven o Gradle .
2. creare una classe POJO, ad es. Employee.java
3. creare un file XML in cui è possibile definire la classe e le variabili. ad esempio beans.xml
4. crea la tua classe principale, ad es. Customer.java
5. Includere i fagioli primaverili (e le sue dipendenze transitive!) Come dipendenza.

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();
   }
}

Mostrando le caratteristiche primaverili primarie con l'esempio

Descrizione

Questo è un esempio in esecuzione autonomo che include / showcasing: dipendenze minime necessarie, configurazione Java, dichiarazione Bean per annotazione e configurazione Java, Iniezione delle dipendenze per Costruttore e per Proprietà e Ganci Pre / Post .

dipendenze

Queste dipendenze sono necessarie nel classpath:

1. spring-core
2. spring-contesto
3. spring-fagioli
4. spring-AOP
5. spring-espressione
6. commons-logging

Classe principale

A partire dalla fine, questa è la nostra classe Main che funge da segnaposto per il metodo main() che inizializza il contesto dell'applicazione puntando alla classe Configuration e carica tutti i vari bean necessari per mostrare funzionalità particolari.

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();
    }
}

File di configurazione dell'applicazione

La classe di configurazione è annotata da @Configuration e viene utilizzata come parametro nel contesto dell'applicazione inizializzato. L'annotazione @ComponentScan a livello di classe della classe di configurazione punta a un pacchetto da scansionare per i bean e le dipendenze registrate usando le annotazioni. Infine l'annotazione @Bean funge da definizione bean nella classe di configurazione.

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();
    }
}

Dichiarazione di fagioli per annotazione

L'annotazione @Component serve a demarcare il POJO come bean Spring disponibile per la registrazione durante la scansione dei componenti.

@Component
public class BeanDeclaredByAnnotation {

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

Dichiarazione Bean in base alla configurazione dell'applicazione

Si noti che non è necessario annotare o contrassegnare in altro modo il nostro POJO poiché la dichiarazione / definizione del bean sta avvenendo nel file di classe Application Configuration.

public class BeanDeclaredInAppConfig {

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

Costruttore di iniezione

Si noti che l'annotazione @Autowired è impostata a livello di costruttore. Si noti inoltre che, a meno che non venga definito esplicitamente per nome, il processo di creazione automatica predefinito si verifica in base al tipo di bean (in questo caso 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();
    }
}

Proprietà dell'iniezione

Si noti che l'annotazione @Autowired demarcates il metodo setter il cui nome segue lo 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 !");
    }
}

Ganci PostConstruct / PreDestroy

Possiamo intercettare l'inizializzazione e la distruzione di un bean con gli @PostConstruct e @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");
    }
}

Cos'è il Framework di primavera, perché dovremmo farlo?

Spring è un framework, che fornisce un mucchio di classi, usando questo non abbiamo bisogno di scrivere la logica della piastra di cottura nel nostro codice, quindi Spring fornisce un layer astratto su J2ee.

Ad esempio, per il semplice programmatore dell'applicazione JDBC è responsabile

1. Caricamento della classe del driver
2. Creare la connessione
3. Creazione di un oggetto statement
4. Gestire le eccezioni
5. Creazione di query
6. Esecuzione della query
7. Chiusura della connessione

Che viene trattato come codice standard, poiché ogni programmatore scrive lo stesso codice. Quindi per semplicità il framework si occupa della logica del boilerplate e il programmatore deve scrivere solo la logica di business. Quindi, utilizzando il framework Spring, possiamo sviluppare rapidamente progetti con linee di codice minime, senza alcun bug, riducendo anche i costi e il tempo di sviluppo.

Quindi, perché scegliere Spring come struts è lì

Il puntone è una struttura che fornisce una soluzione solo agli aspetti del web e gli struts sono di natura invasiva. La primavera ha molte caratteristiche rispetto ai montanti quindi dobbiamo scegliere Spring.

1. La primavera è di natura non invasiva : ciò significa che non è necessario estendere alcuna classe o implementare alcuna interfaccia alla classe.
2. La primavera è versatile : significa che può essere integrata con qualsiasi tecnologia esistente nel tuo progetto.
3. Spring offre uno sviluppo end to end del progetto: ciò significa che possiamo sviluppare tutti i moduli come il livello aziendale, il livello di persistenza.
4. La primavera è leggera : ciò significa che se vuoi lavorare su un particolare modulo, non hai bisogno di imparare la primavera completa, ma impara solo quel particolare modulo (ad esempio Spring Jdbc, Spring DAO)
5. La molla supporta l' iniezione di dipendenza .
6. Spring supporta lo sviluppo di più progetti, ad esempio: Core Java Application, Web Application, Distributed Application, Enterprise Application.
7. Spring supporta la programmazione orientata all'aspetto per problemi trasversali.

Quindi finalmente possiamo dire che Spring è un'alternativa a Struts. Ma Spring non sostituisce l'API J2EE, poiché le classi fornite da Spring utilizzano internamente le classi API J2EE. La primavera è un quadro vasto, quindi si è diviso in diversi moduli. Nessun modulo dipende da un altro, ad eccezione di Spring Core. Alcuni moduli importanti sono

1. Spring Core
2. Spring JDBC
3. Spring AOP
4. Transazione di primavera
5. Primavera ORM
6. Spring MVC