Spring MVC: różnica między tagami? [duplikat]

To pytanie ma już odpowiedź tutaj:

Kilka dni temu zacząłem studiować tej wiosny Hello World Tutorial: http://viralpatel.net/blogs/spring-3-mvc-create-hello-world-application-spring-3-mvc/

W tym tutorialu Spring DispatcherServlet jest skonfigurowany przy użyciu spring-servlet.plik xml, ten:

<?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="
    http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context.xsd">

<context:component-scan base-package="net.viralpatel.spring3.controller" />

<bean id="viewResolver"
    class="org.springframework.web.servlet.view.UrlBasedViewResolver">
    <property name="viewClass"
        value="org.springframework.web.servlet.view.JstlView" />
    <property name="prefix" value="/WEB-INF/jsp/" />
    <property name="suffix" value=".jsp" />
</bean>

W tym pliku używam znacznika context: component-scan , aby powiedzieć, że Spring musi przeskanować mój plik przeszukując adnotację, więc na przykład, gdy Klasa kontrolera stwierdzi, że metoda jest adnotowana przez @ RequestMapping ("/hello") adnotacja wie, że ta metoda obsługuje żądanie HTTP w kierunku adresu URL kończącego się "/ hello". To proste...

Teraz moje wątpliwości związane są z projektem Spring MVC template, który mógłbym automatycznie zbudować w STS \ Eclipse.

Kiedy tworzę nowy projekt Spring MVC w STS mam, że mój DispatcherServlet jest skonfigurowany przez plik o nazwie Servlet-context.xml , który zawiera jakąś konfigurację podobną do poprzedniej przykładowy plik.

W tym pliku mam jeszcze znacznik scan komponentu:

<context:component-scan base-package="com.mycompany.maventestwebapp" />

Ale mam jeszcze inny tag (który wygląda jakby miał podobne zadanie), Ten:

<annotation-driven />

Jaka jest różnica między tymi dwoma znacznikami?
Inną "dziwną" rzeczą jest to, że poprzedni przykład (który nie używa znacznika adnotacji) jest bardzo podobny do projektu stworzonego przez STS przy użyciu szablonu Spring MVC, ale jeśli usunę znacznik adnotacji z jego pliku konfiguracyjnego, project don ' t run and give me the following error: HTTP Status 404 -

A w stacktrace Mam:

WARN: org.springframework.www.servlet.PageNotFound - nie znaleziono mapowania dla żądania HTTP z URI [/maventestwebapp/] w DispatcherServlet o nazwie 'appServlet'

Ale dlaczego? Poprzedni przykład działa dobrze bez znacznika opartego na adnotacji, a ta klasa kontrolera jest bardzo podobna. W rzeczywistości jest tylko jedna metoda, która obsługuje żądanie HTTP w kierunku "/"Ścieżka

To jest kod mojej klasy kontrolerów:

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";
}
Czy ktoś może mi pomóc to zrozumieć?

Dziękuję bardzo!

Author: xyz, 2012-12-01

3 answers

<mvc:annotation-driven /> oznacza to, że możesz definiować zależności spring beans bez konieczności określania kilku elementów w XML lub implementowania interfejsu lub rozszerzania klasy bazowej. Na przykład @Repository aby powiedzieć spring ' owi, że klasa jest Dao bez konieczności rozszerzania JpaDaoSupport lub innej podklasy Dao. Podobnie @Controller mówi spring, że podana klasa zawiera metody, które będą obsługiwać żądania Http bez konieczności implementowania interfejsu kontrolera lub rozszerzania podklasy, która implementuje kontroler.

Kiedy spring uruchomi się, odczytuje swój plik konfiguracyjny XML i szuka <bean elementów w nim, jeśli zobaczy coś w rodzaju <bean class="com.example.Foo" /> i Foo zostało oznaczone @Controller wie, że klasa jest kontrolerem i traktuje ją jako taki. Domyślnie Spring zakłada, że wszystkie klasy, którymi powinien zarządzać, są wyraźnie zdefiniowane w beans.Plik XML.

Skanowanie komponentów za pomocą <context:component-scan base-package="com.mycompany.maventestwebapp" /> mówi spring ' owi, że powinien przeszukać classpath dla wszystkich klas pod com.mycompany.maventestweapp i spójrz na każdą klasę, aby zobaczyć, czy ma @Controller, lub @Repository, lub @Service, lub @Component, a jeśli tak, to Spring zarejestruje klasę w fabryce bean tak, jakbyś wpisał <bean class="..." /> w plikach konfiguracyjnych XML.

W typowej aplikacji spring MVC znajdziesz dwa pliki konfiguracyjne spring, plik, który konfiguruje kontekst aplikacji Zwykle rozpoczynany od słuchacza kontekstu Spring.

<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

I plik konfiguracyjny Spring MVC Zwykle zaczynał się od Spring dispatcher servlet. Na przykład.

<servlet>
        <servlet-name>main</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>main</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

Spring ma wsparcie dla hierarchicznych fabryk fasoli, więc w przypadku Spring MVC, kontekst serwletów dyspozytorskich jest potomkiem głównego kontekstu aplikacji. Jeśli kontekst servleta został poproszony o fasolę o nazwie "abc", najpierw będzie wyglądał w kontekście servleta, jeśli go tam nie znajdzie, będzie wyglądał w kontekście nadrzędnym, który jest kontekstem aplikacji.

Wspólne ziarna, takie jak źródła danych, JPA Konfiguracja, usługi biznesowe są definiowane w kontekście aplikacji, podczas gdy konfiguracja specyficzna dla MVC nie idzie do pliku konfiguracyjnego skojarzonego z serwletem.

Mam nadzieję, że to pomoże.
 80
Author: ams,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2017-07-07 22:21:04
<context:component-scan base-package="" /> 

Każe Spring ' owi przeskanować te pakiety w poszukiwaniu adnotacji.

<mvc:annotation-driven> 

Rejestruje RequestMappingHanderMapping, RequestMappingHandlerAdapter i ExceptionHandlerExceptionResolver, aby obsługiwać adnotowane metody kontrolera, takie jak @RequestMapping, @ExceptionHandler, itp. to pochodzi z MVC.

Umożliwia to również obsługę konwersji, która obsługuje formatowanie danych wyjściowych oparte na adnotacji, a także walidację danych wejściowych opartą na adnotacji. Umożliwia również wsparcie dla @ResponseBody, którego możesz użyć do zwrócenia danych JSON.

Możesz wykonać te same czynności używając konfiguracji opartej na Javie przy użyciu @ComponentScan (basePackages={"...", "..."} i @EnableWebMvc w klasie @ Configuration.

Sprawdź dokumentację 3.1, aby dowiedzieć się więcej.

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

 25
Author: Dennis S,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2012-12-02 20:44:48

Adnotacja-driven wskazuje Springowi, że powinien skanować w poszukiwaniu annotowanych fasoli, a nie polegać tylko na konfiguracji XML bean. Skanowanie komponentów wskazuje, gdzie szukać tych fasolek.

Oto kilka doc: http://static.springsource.org/spring/docs/current/spring-framework-reference/html/mvc.html#mvc-config-enable

 11
Author: atrain,
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2012-12-02 16:22:09