java - Per cosa è esattamente il Framework di primavera?


Ho sentito parlare molto di Spring , la gente dice in tutto il web che Spring è un buon framework per lo sviluppo web. Per cosa è esattamente il Framework di primavera? Come posso usarlo per lo sviluppo di applicazioni Web-Java? qualche esempio?




Answers


Fondamentalmente Spring è una struttura per l' iniezione di dipendenza che è un modello che consente di costruire sistemi molto disaccoppiati.

Il problema

Ad esempio, supponiamo di dover elencare gli utenti del sistema e quindi dichiarare un'interfaccia chiamata UserLister :

public interface UserLister {
    List<User> getUsers();
}

E forse un'implementazione che accede a un database per ottenere tutti gli utenti:

public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

Nella tua vista dovrai accedere a un'istanza (solo un esempio, ricorda):

public class SomeView {
    private UserLister userLister;

    public void render() {
        List<User> users = userLister.getUsers();
        view.render(users);
    }
}

Si noti che il codice sopra non ha inizializzato la variabile userLister . Cosa dovremmo fare? Se istanzio esplicitamente l'oggetto in questo modo:

UserLister userLister = new UserListerDB();

... Vorrei accoppiare la vista con la mia implementazione della classe che accede al DB. Cosa succede se voglio passare dall'implementazione del DB a un altro che ottiene l'elenco degli utenti da un file separato da virgole (ricordate, è un esempio)? In tal caso, andrei di nuovo al mio codice e cambierò l'ultima riga con:

UserLister userLister = new UserListerCommaSeparatedFile();

Questo non ha alcun problema con un programma piccolo come questo ma ... Cosa succede in un programma che ha centinaia di visualizzazioni e un numero simile di classi di business. La manutenzione diventa un incubo!

Approccio Spring (Dependency Injection)

Quello che Spring fa è collegare le classi usando un file XML, in questo modo tutti gli oggetti sono istanziati e inizializzati da Spring e iniettati nei punti giusti (Servlet, Web Framework, Business Class, DAO, ecc. Ecc. Ecc. .).

Tornando all'esempio di Spring, abbiamo solo bisogno di avere un setter per il campo userLister e avere un XML come questo:

<bean id="userLister" class="UserListerDB" />

<bean class="SomeView">
    <property name="userLister" ref="userLister" />
</bean>

In questo modo, quando viene creata la vista, magicamente avrà un UserLister pronto a funzionare.

List<User> users = userLister.getUsers();  // This will actually work
                                           // without adding any line of code

È grande! Non è vero?

  • Cosa succede se si desidera utilizzare un'altra implementazione dell'interfaccia UserLister ? Basta modificare l'XML
  • Cosa succede se non si dispone di un'implementazione UserLister pronta? Programmare un'implementazione UserLister di UserLister e facilitare lo sviluppo della vista
  • Cosa succede se non voglio più usare Spring? Basta non usarlo! La tua applicazione non è accoppiata ad essa. Inversione degli stati di controllo : "L'applicazione controlla il framework, non il framework controlla l'applicazione".

Ci sono alcune altre opzioni per Dependency Injection in giro, cosa che secondo me ha reso la Spring così famosa oltre alla sua semplicità, eleganza e stabilità è che i ragazzi di SpringSource hanno programmato molti POJO che aiutano a integrare Spring con molti altri framework comuni senza essere invadente nella tua applicazione. Anche Spring ha diversi sottoprogetti validi come Spring MVC, Spring WebFlow, Spring Security e di nuovo una lista mooolto di eccetera.

Spero che questo ti aiuti. Ad ogni modo, ti incoraggio a leggere l'articolo di Martin Fowler su Dependency Injection e Inversion of Control perché lo fa meglio di me. Dopo aver compreso le basi date un'occhiata alla documentazione di primavera , a mio parere è stato usato per essere il miglior libro di primavera di sempre.




La primavera contiene ( come ha giustamente sottolineato Skaffman ) una struttura MVC. Per spiegare in breve ecco i miei input. Spring supporta la segregazione del livello di servizio, del livello Web e del livello aziendale, ma ciò che realmente fa meglio è "l'iniezione" di oggetti. Quindi per spiegare che con un esempio si consideri l'esempio di seguito:

public interface FourWheel
{
   public void drive();
}

public class Sedan implements FourWheel
{
   public void drive()
   {
      //drive gracefully
   }
}

public class SUV implements FourWheel
{
   public void drive()
   {
      //Rule the rough terrain
   }
}

Ora nel tuo codice hai una classe chiamata RoadTrip come segue

public class RoadTrip
{
    private FourWheel myCarForTrip;
}

Ora ogni volta che vuoi un'istanza di Trip; a volte potresti volere un SUV per inizializzare FourWheel o qualche volta potresti voler berlina. Dipende molto da ciò che vuoi in base alla situazione specifica.

Per risolvere questo problema, si vorrebbe avere un modello di fabbrica come modello creativo. Dove una fabbrica restituisce l'istanza giusta. Quindi alla fine ti ritroverai con un sacco di codice di colla solo per istanziare correttamente gli oggetti. Spring fa il lavoro del codice colla migliore senza quel codice colla. Si dichiarano i mapping in XML e vengono inizializzati automaticamente gli oggetti. Fa anche molto usando l'architettura singleton per le istanze e questo aiuta nell'ottimizzazione dell'uso della memoria.

Questo è anche chiamato Inversion Of Control. Altri framework per fare questo sono Google guice, Pico container ecc.

Oltre a questo, Spring ha framework di validazione, ampio supporto per layer DAO in collaborazione con JDBC, iBatis e Hibernate (e molti altri). Fornisce un eccellente controllo transazionale sulle transazioni del database.

C'è molto di più in Primavera che può essere letto in buoni libri come "Pro Spring".

Anche gli URL seguenti potrebbero essere di aiuto.
http://static.springframework.org/docs/Spring-MVC-step-by-step/
http://en.wikipedia.org/wiki/Spring_Framework
http://www.theserverside.com/tt/articles/article.tss?l=SpringFramework




A cosa serve la primavera? Risponderò a breve a questa domanda, ma prima, diamo un'altra occhiata all'esempio di Victor Hugo. Non è un grande esempio perché non giustifica la necessità di un nuovo framework.

public class BaseView {
  protected UserLister userLister;

  public BaseView() {
    userLister = new UserListerDB(); // only line of code that needs changing
  }
}

public class SomeView extends BaseView {
  public SomeView() {
    super();
  }

  public void render() {
    List<User> users = userLister.getUsers();
    view.render(users);
  }
}

Fatto! Quindi ora anche se hai centinaia o migliaia di visualizzazioni, devi solo cambiare la riga di codice, come nell'approccio XML di Spring. Ma cambiare una riga di codice richiede ancora la ricompilazione piuttosto che la modifica di XML che dici? Bene, amico mio, usa Ant e script!

Allora, a cosa serve la primavera? È per:

  1. Sviluppatori ciechi che seguono la mandria
  2. I datori di lavoro che non vogliono mai assumere programmatori laureati perché non insegnano tali quadri a Uni
  3. Progetti che hanno avuto un cattivo design e hanno bisogno di patchwork (come dimostra l'esempio di Victor Hugo)

Ulteriori letture: http://discuss.joelonsoftware.com/?joel.3.219431.12




I vecchi tempi, la primavera era un lavoro a iniezione dipendente come ( Guice , PicoContainer , ...), ma ora un giorno è una soluzione totale per costruire un'applicazione Enterprise .

L'iniezione di dipendenza primaverile, che è ovviamente il cuore della primavera, è ancora lì (e puoi rivedere altre buone risposte qui), ma ce ne sono di più dalla primavera ....

Spring ha ora molti progetti, ognuno con alcuni sottoprogetti ( http://spring.io/projects ). Quando qualcuno parla della primavera, devi scoprire quale progetto di primavera sta parlando, è solo il nucleo primaverile, che è noto come quadro di primavera , oppure sono altri progetti di primavera.

Alcuni progetti di primavera che vale la pena menzionare sono:

Se hai bisogno di qualche funzione specifica per la tua applicazione, potresti trovarla anche lì:

  • struttura batch batch di primavera progettata per consentire lo sviluppo di
    applicazione batch
  • primavera HATEOAS facile creazione della base di api REST sul principale di HATEOAS
  • molla mobile e molla per lo sviluppo di applicazioni mobili
  • spring shell costruisce un'applicazione shell (anche nota da riga di comando) completa
  • flusso di dati cloud di primavera e nuvole primaverili per applicazioni cloud

Ci sono anche alcuni piccoli progetti per esempio spring-social-facebook ( http://projects.spring.io/spring-social-facebook/ )

È possibile utilizzare Spring per lo sviluppo Web in quanto ha il modulo Spring MVC che fa parte del progetto del framework di primavera . Oppure puoi usare la molla con un altro fotogramma web, come i puntoni2 .




Molto breve riassunta, dirò che la primavera è la "colla" nella vostra applicazione. È usato per integrare diversi framework e il tuo codice.




La primavera è tre cose.

  1. Le maniglie di primavera Dipendenza da iniezione e vi consiglio di leggere l'eccellente introduzione di Martin Fowler sull'iniezione di dipendenza.
  2. La seconda cosa che Spring fa è racchiudere eccellenti librerie Java in un modo molto elegante da usare nelle tue applicazioni. Per un buon esempio, vedere come Spring esegue il wrapping dei Task Executors e del Quartz Scheduler.
  3. In terzo luogo, Spring fornisce una serie di implementazioni di elementi web come REST, un framework Web MVC e altro ancora. Capiscono dal momento che stai usando Spring per i primi due, forse puoi semplicemente usarlo per tutto ciò di cui la tua app web ha bisogno.

Il problema è che Spring DI è davvero ben congegnata, i wrapper attorno ad altre cose sono davvero ben pensati in quanto le altre cose hanno pensato a tutto e Spring lo avvolge piacevolmente. Le implementazioni Spring di MVC e REST e tutte le altre cose non sono altrettanto ben fatte (YMMV, IMHO) ma ci sono delle eccezioni (Spring Security è da bomba). Quindi tendo a usare Spring per DI, e i suoi involucri freddi ma preferisco altre cose per il Web (mi piace molto Tapestry), REST (Jersey è davvero robusto), ecc.




Cosa vorresti probabilmente in un'applicazione web con Spring -

  • Spring MVC, che con 2.5+ consente di utilizzare POJO come classi Controller, il che significa che non è necessario estendersi da alcun framework particolare (come in Struts o Spring pre-2.5). Le classi di controller sono anche semplici da testare grazie in parte all'iniezione di dipendenza
  • Integrazione Spring con Hibernate, che fa un buon lavoro di semplificazione del lavoro con quella soluzione ORM (per la maggior parte dei casi)
  • L'utilizzo di Spring per un'app Web ti consente di utilizzare gli oggetti del dominio a tutti i livelli dell'applicazione: le stesse classi mappate utilizzando Hibernate sono le classi che utilizzi come "bean dei moduli". Per sua natura, ciò porterà a un modello di dominio più robusto, in parte perché ridurrà il numero di classi.
  • I tag dei moduli Spring semplificano la creazione di moduli senza troppi problemi.

Inoltre, Spring è ENORME - quindi ci sono molte altre cose che potresti essere interessato ad usare in un'applicazione web come Spring AOP o Spring Security. Ma le quattro cose sopra elencate descrivono le componenti comuni di Spring utilizzate in un'app Web.




Vedo due parti per questo:

  1. "Che cosa è esattamente Spring per" -> vedere la risposta accettata da Victor Hugo.
  2. "[...] La primavera è [un] buon framework per lo sviluppo del web" -> persone che dicono che stanno parlando di Spring MVC. Spring MVC è una delle tante parti di Spring, ed è un framework web che sfrutta le caratteristiche generali di Spring, come l'iniezione di dipendenza. È un framework piuttosto generico in quanto è molto configurabile: puoi usare diversi livelli db (Hibernate, iBatis, plain JDBC), diversi livelli di visualizzazione (JSP, Velocity, Freemarker ...)

Si noti che è possibile utilizzare perfettamente Spring in un'applicazione Web senza utilizzare Spring MVC. Direi che la maggior parte delle applicazioni web Java fa questo, mentre usa altri framework web come Wicket, Struts, Seam, ...




La primavera è grande per incollare istanze di classi insieme. Sai che le tue classi di Hibernate avranno sempre bisogno di un'origine dati, Spring le unisce insieme (e ha anche un'implementazione dell'origine dati).

I tuoi oggetti di accesso ai dati avranno sempre bisogno dell'accesso Hibernate, Spring collega le classi di Hibernate ai tuoi DAO per te.

Inoltre, Spring offre fondamentalmente configurazioni solide di un sacco di librerie e, in questo, fornisce una guida su quali librerie utilizzare.

La primavera è davvero un ottimo strumento. (Non stavo parlando di Spring MVC, solo il framework di base).




Spring è una buona alternativa alla tecnologia EJB (Enterprise JavaBeans) . Ha anche componenti del framework web e dei servizi web.




Il vantaggio è Dipendenza Iniezione (DI) . Significa esternalizzare il compito di creazione dell'oggetto. Mi spiego con un esempio.

public interface Lunch
{
   public void eat();
}

public class Buffet implements Lunch
{
   public void eat()
   {
      // Eat as much as you can 
   }
}

public class Plated implements Lunch
{
   public void eat()
   {
      // Eat a limited portion
   }
}

Ora nel mio codice ho una classe LunchDecide come segue:

public class LunchDecide {
    private Lunch todaysLunch;
    public LunchDecide(){
        this.todaysLunch = new Buffet(); // choose Buffet -> eat as much as you want
        //this.todaysLunch = new Plated(); // choose Plated -> eat a limited portion 
    }
}

Nella classe sopra, a seconda del nostro umore, selezioniamo Buffet () o Placcato (). Tuttavia questo sistema è strettamente accoppiato. Ogni volta che abbiamo bisogno di un diverso tipo di oggetto, dobbiamo cambiare il codice. In questo caso, commentando una riga! Immagina che ci siano 50 diverse classi usate da 50 persone diverse. Sarebbe un gran casino. In questo caso, abbiamo bisogno di disaccoppiare il sistema. Riscriviamo la classe LunchDecide.

public class LunchDecide {
    private Lunch todaysLunch;
    public LunchDecide(Lunch todaysLunch){
        this.todaysLunch = todaysLunch
        }
    }

Si noti che invece di creare un oggetto usando una nuova parola chiave abbiamo passato il riferimento a un oggetto di tipo Pranzo come parametro al nostro costruttore. Qui, la creazione dell'oggetto è esternalizzata. Questo codice può essere cablato utilizzando il file di configurazione Xml (legacy) o Java Annotations (moderno). In entrambi i casi, la decisione su quale tipo di oggetto verrebbe creata verrà eseguita lì durante il runtime. Un oggetto sarebbe iniettato da Xml nel nostro codice - Il nostro codice dipende da Xml per quel lavoro. Quindi, Dipendenza iniezione (DI). DI non solo aiuta a rendere il nostro sistema liberamente accoppiato, ma semplifica la scrittura dei test di Unità poiché consente alle dipendenze di essere derisi. Ultimo ma non meno importante, DI semplifica la programmazione orientata agli aspetti (AOP) che porta a un ulteriore disaccoppiamento e aumento della modularità. Si noti inoltre che sopra DI è Costruttore Iniezione. DI può essere fatto anche con Setter Injection - lo stesso semplice metodo setter da incapsulamento.




La risposta accettata non implica l'utilizzo delle annotazioni poiché Spring ha introdotto il supporto per varie annotazioni per la configurazione.

Approccio Spring (Dependency Injection)

C'è un altro modo per legare le classi insieme usando un file XML: le annotazioni. Usiamo l'esempio dalla risposta accettata e registriamo il bean direttamente nella classe usando l'unica annotazione @Bean :

@Bean
public class UserListerDB implements UserLister {
    public List<User> getUsers() {
        // DB access code here
    }
}

In questo modo, quando viene creata la vista, magicamente avrà un UserLister pronto a funzionare.

La dichiarazione di cui sopra è valida con un piccolo bonus che non richiede l'utilizzo di file XML e il cablaggio con un'altra annotazione @Autowired che trova un'implementazione rilevante e la inietta.

@Autowired
private UserLister userLister;



La primavera è iniziata come un sistema di iniezione di dipendenze piuttosto semplice. Ora è enorme e ha tutto in esso (tranne che per il proverbiale lavandino della cucina).

Ma non temere, è abbastanza modulare, quindi puoi usare solo i pezzi che desideri.

Per vedere dove è iniziato tutto, prova:

http://www.amazon.com/Expert-One-Design-Development-Programmer/dp/0764543857/ref=sr_1_1?ie=UTF8&s=books&qid=1246374863&sr=1-1

Potrebbe essere vecchio ma è un libro eccellente.

Per un altro buon libro questa volta dedicato esclusivamente alla Primavera, vedi:

http://www.amazon.com/Professional-Java-Development-Spring-Framework/dp/0764574833/ref=sr_1_2?ie=UTF8&s=books&qid=1246374863&sr=1-2

Si riferisce anche alle versioni precedenti di Spring, ma vale sicuramente la pena guardare.




La primavera è stata un'iniezione di dipendenza all'inizio, quindi aggiungere re di wrapper per quasi tutto (wrapper su implementazioni JPA, ecc.).

Lunga storia ... gran parte delle soluzioni XML di Spring preffer (motore di scripting XML ... brrrr), quindi per DI uso Guice

Una buona libreria, ma con la crescente depnedenciec, ad esempio Sprong JDBC (forse una soluzione jdbc Java con parametri di nomi reali) prende da Maven 4-5 in seguito.

Usando Spring MVC (parte di "big spring") per lo sviluppo web ... è un framework "request based", c'è una guerra santa "request vs component" ... fino a te