Spring MVC: differenza tra i tag e ?

Alcuni giorni fa ho iniziato a studiare questo tutorial Spring Hello World: http://viralpatel.net/blogs/spring-3-mvc-create-hello-world-application-spring-3-mvc/

In questo tutorial Spring DispatcherServlet è configurato utilizzando il file spring-servlet.xml , questo:

        

In questo file sto usando il contesto: tag component-scan per dire che Spring deve eseguire la scansione del mio file cercando l’annotazione, così per esempio, quando la class controller scopre che un metodo è annotato da @RequestMapping (“/ hello”) annotazione sa che questo metodo gestisce la richiesta HTTP verso l’URL che termina con “/ hello”. Questo è semplice …

Ora il mio dubbio è legato al progetto di template Spring MVC che ho potuto creare automaticamente in STS \ Eclipse.

Quando creo un nuovo progetto Spring MVC in STS, ho il mio DispatcherServlet configurato da un file denominato servlet-context.xml che contiene alcune configurazioni simili al precedente file di esempio.

In questo file, ho ancora il tag di scansione del componente:

  

ma ho anche un altro tag (che sembra avere un’attività simile), questo:

  

Qual è la differenza tra questi due tag?
Un’altra cosa “strana” è che l’esempio precedente (che non usa il tag basato sull’annotazione) è molto simile al progetto creato da STS usando il progetto Spring MVC Template, ma se elimino il tag guidato dall’annotazione dalla sua configurazione file il progetto non viene eseguito e mi dà il seguente errore: HTTP Status 404 –

E nello stacktrace ho:

WARN: org.springframework.web.servlet.PageNotFound – Nessun mapping trovato per richiesta HTTP con URI [/ maventestwebapp /] in DispatcherServlet con nome ‘appServlet’

Ma perché? L’esempio precedente funziona bene senza tag con annotazioni e questa class di controller è molto simile. Infatti, esiste un solo metodo che gestisce la richiesta HTTP verso il percorso “/”

Questo è il codice della mia class controller:

 package com.mycompany.maventestwebapp; import java.text.DateFormat; import java.util.Date; import java.util.Locale; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; /** * Handles requests for the application home page. */ @Controller public class HomeController { private static final Logger logger = LoggerFactory.getLogger(HomeController.class); /** * Simply selects the home view to render by returning its name. */ @RequestMapping(value = "/", method = RequestMethod.GET) public String home(Locale locale, Model model) { logger.info("Welcome home! The client locale is {}.", locale); Date date = new Date(); DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale); String formattedDate = dateFormat.format(date); model.addAttribute("serverTime", formattedDate ); return "home"; } 

Qualcuno può aiutarmi a capire questa cosa?

Grazie mille!

significa che è ansible definire le dipendenze dei bean di spring senza dover effettivamente specificare un gruppo di elementi in XML o implementare un’interfaccia o estendere una class base. Ad esempio, @Repository per dire alla spring che una class è un Dao senza dover estendere JpaDaoSupport o qualche altra sottoclass di DaoSupport. Allo stesso modo @Controller dice a molla che la class specificata contiene metodi che gestiranno le richieste HTTP senza dover implementare l’interfaccia Controller o estendere una sottoclass che implementa il controller.

All’avvio di Spring legge il suo file di configurazione XML e cerca gli elementi all'interno se vede qualcosa come e Foo è stato contrassegnato con @Controller sa che la class è un controller e lo tratta come tale. Per impostazione predefinita, Spring presuppone che tutte le classi che deve gestire siano definite esplicitamente nel file beans.XML.

La scansione dei componenti con indica che dovrebbe cercare il classpath per tutte le classi in com.mycompany.maventestweapp e controllare ogni class per vedere se ha un @Controller , o @Repository , o @Service , o @Component e se lo fa, Spring registrerà la class con il bean factory come se avessi digitato nella configurazione XML File.

In una tipica app MVC primaverile troverete che ci sono due file di configurazione primaverili, un file che configura il contesto dell'applicazione solitamente avviato con il listener del contesto Spring.

  org.springframework.web.context.ContextLoaderListener  

E un file di configurazione di Spring MVC in genere è stato avviato con il servlet di Spring dispatcher. Per esempio.

  main org.springframework.web.servlet.DispatcherServlet 1   main /  

Spring supporta le factory bean gerarchiche, quindi nel caso di Spring MVC, il contesto del servlet del dispatcher è figlio del contesto dell'applicazione principale. Se è stato chiesto al contesto servlet un bean chiamato "abc", esso cercherà prima nel contesto servlet, se non lo trova lì verrà cercato nel contesto padre, che è il contesto dell'applicazione.

I bean comuni come le origini dati, la configurazione JPA, i servizi aziendali sono definiti nel contesto dell'applicazione mentre la configurazione specifica MVC non è il file di configurazione associato al servlet.

Spero che questo ti aiuti.

  

dice a Spring di analizzare quei pacchetti per le annotazioni.

  

registra un RequestMappingHanderMapping, un RequestMappingHandlerAdapter e un ExceptionHandlerExceptionResolver per supportare i metodi del controller annotato come @RequestMapping, @ExceptionHandler, ecc. che vengono forniti con MVC.

Ciò abilita anche un ConversionService che supporta la formattazione degli output basata su Annotation e la convalida basata su Annotation per gli input. Abilita anche il supporto per @ResponseBody che è ansible utilizzare per restituire i dati JSON.

Puoi realizzare le stesse cose usando la configurazione basata su Java usando @ComponentScan (basePackages = {“…”, “…”} e @EnableWebMvc in una class @Configuration.

Controlla la documentazione 3.1 per saperne di più.

http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/mvc.html#mvc-config

Il comando di annotazione indica a Spring che deve eseguire la scansione dei bean annotati e non fare affidamento solo sulla configurazione del bean XML. Scansione componente indica dove cercare quei fagioli.

Ecco alcuni documenti: http://static.springsource.org/spring/docs/current/spring-framework-reference/html/mvc.html#mvc-config-enable