Un’introduzione al Framework di primavera

Spring è un framework Java che utilizza un contenitore per creare e gestire i diversi componenti di un’applicazione. Il contenitore (spesso chiamato contesto dell’applicazione Spring) collega i diversi componenti in un’applicazione utilizzando il modello di progettazione DI (Dependency Injection). DI consente di utilizzare un oggetto in una classe dipendente, senza crearne una nuova istanza all’interno della classe dipendente.

Quindi, invece di consentire a ciascun componente di creare nuove istanze di quelle su cui si basano, il contenitore di Spring crea e mantiene un’istanza di ciascuno dei componenti che ospita. Questo contenitore quindi inietta un’istanza di un componente in tutti gli altri componenti che ne hanno bisogno.

Esplorando le caratteristiche principali di Spring

Il framework Spring ha circa 20 moduli ben organizzati che svolgono un ruolo fondamentale nella sua capacità di creare e gestire applicazioni. In base alle caratteristiche principali di questi moduli, puoi raggrupparli in cinque categorie:

• Contenitore principale
• Accesso/integrazione dei dati
• ragnatela
• Programmazione e strumentazione orientate agli aspetti
• Test

Contenitore a molla

Spring utilizza un contenitore per creare e gestire diversi componenti (che chiama bean) di un’applicazione. Il contenitore è accessibile tramite l’interfaccia ApplicationContext di Spring, che consente di istanziare, configurare e assemblare oggetti (o bean). Il contenitore di Spring può svolgere la sua funzione grazie all’ausilio dei metadati di configurazione.

Questi metadati di configurazione possono avere diverse forme, ma la sua forma tipica è XML. Oltre ai bean, il contenitore di Spring è costituito anche da un core, un contesto e un modulo di espressione.

Accesso/integrazione dei dati di Spring

L’aspetto di accesso/integrazione dei dati del framework Spring è costituito da diversi sottomoduli: JDBC, ORM, OXM, JMS e transazione. Questi moduli lavorano insieme per gestire tutti i dati utilizzati dall’applicazione.

Rete primaverile

La funzionalità web dell’applicazione Spring fornisce l’integrazione orientata al web per la tua applicazione. Oltre all’integrazione orientata al web, Spring fornisce un modulo servlet web. Il modulo web servlet è responsabile dell’implementazione MVC (model-view-controller) di Spring.

Programmazione orientata agli aspetti primaverili (AOP)

Il framework AOP di Spring è un altro dei suoi componenti chiave. Sebbene il framework AOP non sia cruciale per la funzione del contenitore di Spring, integra il contenitore essendo una soluzione middleware capace. Una delle caratteristiche principali del framework AOP è che fornisce servizi aziendali dichiarativi per la tua applicazione, ovvero la gestione delle transazioni di dichiarazione.

La gestione dichiarativa delle transazioni è un approccio auspicabile allo sviluppo del software perché ha un impatto minimo sul codice dell’applicazione.

Prova di primavera

Spring attribuisce un’importanza significativa ai test delle applicazioni. Il suo modulo di test supporta test di integrazione e unit test utilizzando JUnit o TestNG.

Creazione di un’applicazione Spring

Esistono diversi modi per creare il boilerplate per una nuova applicazione Spring. I vari approcci includono:

• Dall’applicazione web (o Spring Initializr) sul sito ufficiale di Spring.
• Creazione manuale di una struttura di directory del progetto e specifiche di compilazione.
• Con la Spring Tool Suite.
• Dalla riga di comando con l’interfaccia della riga di comando di Spring Boot.
• Con l’IDE Eclipse.
• Con IntelliJ IDEA IDE.

L’approccio più popolare è Spring Initializr:

Come puoi vedere dall’immagine sopra, dovrai prendere diverse decisioni. Il primo è il tipo di progetto che vuoi inizializzare. Spring offre tre opzioni: Gradle per Groovy, Gradle per Kotlin o Maven. Questa applicazione di esempio utilizzerà un progetto Maven.

Le altre opzioni che devi selezionare sono la lingua (Java), la versione di Spring Boot che desideri utilizzare e i metadati del progetto. Spring ha già alcuni dati fittizi nei suoi cinque campi che ti aiuteranno a creare un’applicazione di esempio. Tuttavia, dovrai aggiornare questi campi con dati specifici del progetto, poiché questi metadati descriveranno la tua applicazione Spring, inclusi i bean Spring e i relativi metodi.

Successivamente, dovrai selezionare la confezione in cui desideri i tuoi file (jar o war). Quindi puoi selezionare la versione di Java che hai sul tuo dispositivo. La decisione finale che dovrai prendere è il tipo di dipendenze che desideri per la tua applicazione.

Spring fornisce diverse dipendenze che puoi utilizzare per aggiungere proprietà alla tua applicazione. Per aggiungere una nuova dipendenza alla tua applicazione, fai semplicemente clic sul pulsante Aggiungi dipendenze a destra di Spring Initializr. Questa azione genererà il seguente overlay sullo schermo:

Per questa applicazione di esempio, l’unica dipendenza di cui avrai bisogno è Spring Web. Questa dipendenza consente di creare applicazioni Web utilizzando l’architettura MVC. Dopo aver selezionato tutte le dipendenze che desideri utilizzare nella tua applicazione, fai clic su Genera. Questo scaricherà il boilerplate del progetto per te.

Ora hai un progetto Spring Boot (che è una delle librerie di Spring). Il passaggio finale consiste nell’importare il progetto nel tuo IDE preferito. Il tuo progetto Spring avrà la seguente struttura di progetto:

Questa è una normale struttura del progetto Maven e ci sono diversi file importanti con cui devi familiarizzare.

• Pom.xml: contiene i dati di configurazione dell’applicazione Spring.
• OnlineShopaholicsApplication.java: questa è la classe principale di Spring Boot, che esegue l’applicazione.
• OnlineShopaholicsApplicationTest.java: questa è una classe di test JUnit che assicura che il contesto dell’applicazione Spring (o contenitore) venga caricato correttamente.

Esecuzione di un’applicazione Spring

La classe bootstrap di Spring, che in questo caso è la classe OnlineShopaholicsApplication, ha il seguente codice iniziale:

package com.onlineshopaholics;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class OnlineShopaholicsApplication {
  public static void main(String[] args) {
    SpringApplication.run(OnlineShopaholicsApplication.class, args);
  }
}

Uno degli aspetti più importanti del codice di cui sopra è l’ annotazione @SpringBootApplication , che è un’annotazione composita che consente all’applicazione di accedere alle funzionalità di altre tre annotazioni:

• @EnableAutoconfiguration: questa annotazione abilita la configurazione automatica di Spring Boot. Ciò significa che indica a Spring Boot di configurare qualsiasi componente che ritiene necessario per funzionare con l’applicazione.
• @ComponentScan: questa annotazione consente di abilitare la scansione dei componenti. Questa funzionalità è importante, consente a Spring di rilevare e registrare automaticamente altri componenti annotati per l’utilizzo da parte del contesto dell’applicazione Spring (o contenitore).
• @SpringBootConfiguration: questa è una forma specializzata dell’annotazione @Configureation, che consente di registrare bean (o oggetti) nel contesto dell’applicazione Spring.

L’altro aspetto importante del codice sopra è il metodo main() , esegue la tua applicazione. Quando l’applicazione viene eseguita ora, avvia semplicemente il server. Quindi, se vuoi aggiungere più funzionalità all’applicazione, dovrai aggiornare il codice:

package com.onlineshopaholics;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

  @GetMapping("/customer")
  public String Welcome(@RequestParam(value = "name", defaultValue = "Customer") String name) {
    return String.format("Welcome %s!", name);
  }
}

L’applicazione Spring Boot ha ora tre nuove annotazioni:

• @RestController: questa annotazione contrassegna la classe come controller, quindi ogni metodo nella classe precedente (a parte main()) restituirà un oggetto di dominio anziché una vista.
• @GetMapping: questa annotazione mappa le richieste HTTP GET su metodi di intestazione specifici. Quindi, ogni volta che crei una richiesta per “/customer” nel browser, il metodo Welcome() gestirà la richiesta restituendo un valore stringa.
• @RequestParam: questa annotazione indica che un parametro di metodo deve essere associato a un parametro di richiesta Web.

Con il codice aggiornato la tua Spring Online ShopaholicsApplication ora ha una pagina cliente che puoi visualizzare nel tuo browser. L’esecuzione dell’applicazione avvierà il server e produrrà l’output nella console.

Ci sono molte informazioni importanti nell’output. Ti dice che il server è in esecuzione, ti dice quanto tempo ha impiegato il processo di inizializzazione e ti dice su quale porta è in esecuzione l’applicazione (8080, per impostazione predefinita). Pertanto, se navighi su http://localhost:8080/customer vedrai il seguente output nel tuo browser:

Ora puoi progettare la tua visualizzazione dell’applicazione

Un altro file importante nella struttura del progetto che potresti notare è la cartella dei modelli . Idealmente, la classe OnlineShopaholicsApplication dovrebbe fungere da controller, che gestisce le richieste di visualizzazioni diverse. Pertanto, in un’applicazione completa, la classe controller non dovrebbe contenere il testo che verrà visualizzato nella visualizzazione della sua richiesta.

Invece, dovrai creare file modello utilizzando HTML e inserirli nella cartella dei modelli della tua applicazione Spring.