Creazione di un'applicazione Hello World Spring
Il processo di creazione di questa applicazione primaverile consiste in questi seguenti passaggi:
- Crea un progetto Maven
- Aggiungi dipendenze primaverili
- Crea una classe di fagioli di primavera
- Crea un file XML del contenitore Spring
- Crea una classe principale di primavera
Crea un progetto Maven
Innanzitutto, creeremo un progetto Maven per sviluppare l'applicazione Spring. Abbiamo già trattato questo argomento nel nostro articolo sulla creazione di Maven Project. Puoi fare riferimento a questo per avere un'idea approfondita della creazione di Maven Project se non sei già familiare in: .
Cominciamo con l'apertura dell'eclissi e facendo clic sul menu del file. Quindi, seleziona il progetto Maven come questo: File-> Nuovo-> Progetto Maven
Dopo aver selezionato, chiederà alcuni dettagli come nome del progetto, nome dell'app, versione, tipo di imballaggio e ecc. L'imballaggio specifica il tipo di pacchetto di build finale del progetto. Se l'applicazione è app Web, dovrebbe essere War (Web Archive).
Abbiamo selezionato JAR qui perché non stiamo creando un'applicazione Web piuttosto una semplice applicazione "Hello World".
Colpire il fine pulsante e ci vorranno un paio di secondi per creare un progetto. A prima vista il progetto appena creato sembra questo:
Aggiungi dipendenze primaverili
Inizialmente, tutte le cartelle sono vuote. Nessun file di origine è presente. IL pom.XML Il file è il principale file Maven che contiene tutte le configurazioni e le dipendenze del progetto. Useremo questo file per aggiungere dipendenze a molla.
Dipendenze primaverili:
Qui, ne stiamo aggiungendo solo due Core di molla E contesto di primavera per creare una semplice applicazione. Aggiungeremo più dipendenze solo se abbiamo bisogno di aumentare l'applicazione, altrimenti solo questi due sono sufficienti.
org.Springframework primavera $ primavera.versione org.Springframework a primavera $ primavera.versione
Dopo aver aggiunto dipendenze primaverili, il POM.Il file XML assomiglia a questo:
// pom.XML
4.0.0 com.Linuxhint Springapp 0.0.1-snapshot Springapp Una semplice app di primavera org.Springframework primavera $ primavera.versione org.Springframework a primavera $ primavera.versione 5.2.8.PUBBLICAZIONE
Vmaven scaricherà automaticamente tutti i file richiesti al progetto.
Dopo aver aggiunto queste dipendenze, puoi notare che il dipendenza da maven La cartella ora contiene tutti i file jar.
Avviso: La cartella delle dipendenze Maven non era presente nel progetto realizzato iniziale, prima di aggiungere le dipendenze. È stato aggiunto dal Maven per raccogliere tutte le dipendenze in una singola cartella per una migliore gestione. Vedi la struttura del progetto seguente.
Crea la classe di fagioli primaverili
Ora, creiamo una classe di fagioli che è una classe Java con proprietà private e getter, metodi setter.
In primavera, Bean è un oggetto Java creato dal contenitore a molla.
Per creare una classe, fare clic sul menu File, quindi selezionare la classe in questo modo:
File-> Nuovo-> Classe
Fornire il nome del pacchetto come com.Linuxhint.fagioli Come vogliamo posizionarlo in un pacchetto di fagioli separati.
Fai clic sul pulsante Fine e quindi aggiungi un po 'di codice sorgente. Abbiamo creato un msg variabile stringa e il suo getter, metodi setter.
// Ciao mondo.Giava
pacchetto com.Linuxhint.fagioli;
Classe pubblica HelloWorld
stringa privata msg;
public String getMsg ()
restituire msg;
public void setMSG (string msg)
Questo.msg = msg;
Crea la classe principale
Allo stesso modo, crea una primavera.classe Java in com.Linuxhint pacchetto.
Fai clic sul pulsante Fine e aggiungi il codice sorgente ad esso.
Questa è la classe principale in cui la primavera inizia l'esecuzione. Qui, abbiamo letto per la prima volta il ApplicationContext.XML File utilizzando il costruttore ClassPathXMlapplicationContext e quindi chiamare il suo metodo getBean () per ottenere il fagiolo "Helloworld".
Abbiamo configurato il bean in ApplicationContext.XML File con un valore mondiale di Hello. Quindi, per leggere questo abbiamo usato il metodo getmsg () della classe Helloworld.
Non ti preoccupi di questo strano codice. Ne discuteremo in dettaglio più avanti nei nostri articoli. Per ora, usa solo questo pezzo di codice nella classe.
// Springapp.Giava
pacchetto com.Linuxhint;
Org di importazione.Springframework.contesto.ApplicationContext;
Org di importazione.Springframework.contesto.supporto.ClassPathXMlapplicationContext;
Importa com.Linuxhint.fagioli.Ciao mondo;
Classe pubblica Springapp
public static void main (string [] args)
ApplicationContext AC = new ClassPathXMLapplicationContext ("ApplicationContext.XML ");
HelloWorld Hello = (HelloWorld) AC.getbean ("ciao");
String msg = ciao.getMsg ();
Sistema.fuori.println ("---"+msg+"---");
Creazione del contenitore di fagioli
Il contenitore di fagioli è un file XML che contiene del codice XML per configurare i fagioli.
L'abbiamo chiamato ApplicationContext.XML che contiene la configurazione dei fagioli che è Helloworld nel nostro caso. Il tag bean richiede ID e nome di classe. Quindi, abbiamo superato l'ID di fagioli e il nome della nostra classe di fagioli Helloworld con il nome completo del pacchetto.
// ApplicationContext.XML
xmlns: xsi = "http: // www.W3.org/2001/xmlschema-istance "
XSI: schemalocation = "http: // www.Springframework.org/schema/fagioli
http: // www.Springframework.Org/Schema/Beans/Spring-Beans-3.0.XSD ">
Dopo aver aggiunto tutti i file, il layout del progetto finale sembra questo:
Esegui l'applicazione Spring
Ora possiamo eseguire l'applicazione per testare e vedere l'output desiderato Hello World.
Per eseguire l'applicazione, fare clic con il pulsante destro del mouse sul progetto e selezionare l'applicazione run-> Java.
Puoi vedere l'output nella scheda Console.
Produzione:
Vedi tutto funzionare bene.
Fino a qui, abbiamo imparato con successo per creare un progetto Hello World Spring. Nei prossimi articoli, impareremo a creare questa applicazione utilizzando STS (Spring Tool Suite).