[Spring] Spring3: dai Controller ai Repository [Parte1]

In questo articolo, riporto la configurazione di Spring per il supporto alle annotations (sia sui model, che sui servizi e DAO) e all’utilizzo di Spring MVC (controller). Ricordiamo che Spring è il framework open source per lo sviluppo di applicazioni su piattaforma Java attualmente più utilizzato e riconosciuto come valida alternativa agli Enterprise JavaBeans (EJB).

In un secondo tutorial (Parte 2), verranno riportati degli esempi di controller (interfaccia che riceve una richiesta HTTP – HttpServletRequest e HttpServletResponse – simile alla Action di Struts), di model o entity (modello dei dati o entità, ossia bean che rappresenta la tabella sulla basedati, con relative associazioni ad altre entità), di service (interfaccia con la logica di business della web application) e di repository (interfaccia DAO che esegue le operazioni CRUD sulla basedati), con relative annotations (@Controller, @Entity, @Service, @Repository).

Grazie all’utilizzo delle annotations, si riduce l’overhead per la scrittura di codice nei file XML, risparmiando tempo anche nel debug e manutenzione del codice (clean code). Il mapping dei bean di Spring, infatti, avviene tutto sul sorgente JAVA, mantenendo anche una netta separazione tra la configurazione del framework e le interfacce/classi della nostra applicazione.

Gli step da seguire per la configurazione di Spring+Hibernate nella nostra web application sono i seguenti:

  1. Installazione delle librerie di Spring e Hibernate con l’ausilio di MAVEN
  2. Integrazione di Spring nella web application (dispatcher, filters, listeners, servlets nel file web.xml)
  3. Logging di Spring e Hibernate
  4. Configurazione del context-application di Spring (configurazione core)
  5. Configurazione dell’ORM Hibernate in Spring
  6. Sicurezza in Spring
  7. Configurazione di Spring MVC

I file di configurazione di Spring sono stati divisi a seconda del modulo/componente che si intende utilizzare nella nostra web application (Spring ORM, Spring Security, Spring MVC, Spring Core), per avere una maggiore leggibilità e flessibilità nella scelta delle componenti da installare. I nomi dei file riportati di seguito (spring-application.xml, spring-servlet.xml, spring-orm.xml, spring-security.xml) non sono imposti dalla specifica di Spring, come neanche la suddivisione adottata.

1. Installazione delle librerie di Spring3 + Hibernate4 con MAVEN2:

Per l’installazione delle librerie di Spring e di Hibernate, con relative dipendenze, è comodo utilizzare il tool MAVEN, disponibile anche come plugin di Eclipse (Maven Integration – m2e). Nel file pom.xml, si possono inserire le seguenti librerie di Hibernate 4 e Spring3:

		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-validator</artifactId>
			<version>4.2.0.Beta2</version>
		</dependency>
		<dependency>
			<groupId>net.sf.ehcache</groupId>
			<artifactId>ehcache</artifactId>
			<version>1.2.3</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<optional>false</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<optional>false</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<optional>false</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<optional>false</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<optional>false</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<optional>false</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>3.0.5.RELEASE</version>
			<type>jar</type>
			<optional>false</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>3.0.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-core</artifactId>
			<version>3.0.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-web</artifactId>
			<version>3.0.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.security</groupId>
			<artifactId>spring-security-config</artifactId>
			<version>3.0.5.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>joda-time</groupId>
			<artifactId>joda-time</artifactId>
			<version>1.6.2</version>
		</dependency>

 

2. Integrazione di Spring nella web application: dispatcher, listeners, filters e servlets nel file web.xml

Per poter integrare Spring nella nostra web application, occorre configurare il dispatcher e i listeners, filters e servlets nel file web.xml (sotto WEB-INF) della nostra WebContent root.

In particolare, nel context-param occorre elencare i file di configurazione dei moduli di Spring (core, ORM, security e MVC) e occorre indirizzare tutte le richieste alle URL che terminano per estensione .do (o quello che vi pare) allo strato di controller di Spring.

 <!-- Configurazione di Spring -->
 <context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>
        /WEB-INF/spring/spring-application.xml
	  	/WEB-INF/spring/spring-orm.xml
	  	/WEB-INF/spring/spring-security.xml
	  	/WEB-INF/spring/spring-servlet.xml</param-value>
 </context-param>

 <!-- Configurazione LOG4J -->
 <context-param>
  <param-name>log4jConfigLocation</param-name>
  <param-value>/WEB-INF/classes/log4j.properties</param-value>
 </context-param>

 <!-- SPRING SECURITY FILTERS -->
 <filter>
  <filter-name>springSecurityFilterChain</filter-name>
  <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
 </filter>
 <filter-mapping>
  <filter-name>springSecurityFilterChain</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>

 <!-- LISTENERS -->
 <listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 </listener>
 <listener>
  <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
 </listener>
 <listener>
  <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>
 </listener>
 <listener>
  <listener-class>org.springframework.security.web.session.HttpSessionEventPublisher</listener-class>
 </listener>

 <!-- Spring MVC Dispatcher -->
 <servlet>
  <servlet-name>yourProjectName</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
   <param-name>namespace</param-name>
   <param-value>spring/yourProjectName-servlet</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
 </servlet>
 <servlet-mapping>
  <servlet-name>yourProjectName</servlet-name>
  <url-pattern>*.do</url-pattern>
 </servlet-mapping>

 

3.Configurazione dei log di Spring e Hibernate: LOG4J.properties

Per poter loggare Spring e Hibernate sui file di log, con LOG4J, occorre inserire nel file log4j.properties le seguenti righe di codice:

#-------------------------------------------------------------------------------
# Define loggers
#-------------------------------------------------------------------------------
log4j.logger.com.yourDomain.yourProjectName=DEBUG, stdout, yourProjectNameLog, yourProjectNameAllLog

#-------------------------------------------------------------------------------
# Define Spring-Hibernate loggers
#-------------------------------------------------------------------------------
log4j.logger.org.springframework=DEBUG,yourProjectNameAllLog
log4j.logger.org.springframework.orm=DEBUG,yourProjectNameAllLog
log4j.logger.org.springframework.transaction=DEBUG,yourProjectNameAllLog
log4j.logger.org.hibernate=DEBUG,yourProjectNameAllLog
log4j.logger.controller==DEBUG,stdout,yourProjectNameLog,yourProjectNameAllLog

 

4. La configurazione del context-application di Spring: spring-application.xml

Questa è la vera e propria configurazione del core di Spring di quello che si definisce “context-application“.

In particolare, nel file spring-application.xml, possiamo notare:

  • default-autowire=”byName” : l’autowiring è il processo di injection e di discovery dei bean e delle varie componenti della nostra applicazione, che viene fatta in automatico con le annotazioni. Vedere questo link.
  • mvc:annotation-driven: con questo tag abilitiamo il supporto a Spring MVC. Il sistema “scopre” e registra, in fase di startup della web application, tutte le classi annotate con @Controller
  • context:component-scan base-package: con questo tag diciamo a Spring che tutte le classi presenti nel package esplicitato devono essere scannerizzate (processo di discovery o autowiring) per poter essere registrate (se annotate)
  • sezione “resource bundles: si possono elencare dei file properties utili per poter mappare parametri, messaggi statici, codici e quant’altro (coppia chiave-valore) – nel nostro esempio, due sono i file di properties: yourProjectName-message.properties e yourProjectName-config.properties
  • sezione “mail configuration”: è possibile specificare un servizio per la spedizione della posta (server SMTP di default) o per l’invio di notifiche (alert)
  • sezione “scheduling”: Spring permette anche di configurare dei servizi di scheduling per l’esecuzione programmata di determinate operazioni (annotate con l’annotation @Scheduled)
  • eventuale sezione di dichiarazione dei bean: non è più necessaria, poichè i bean si dichiarano direttamente sulle classi con l’utilizzo delle relative annotazioni
<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:security="http://www.springframework.org/schema/security"
       xmlns:context="http://www.springframework.org/schema/context"
	   xmlns:mvc="http://www.springframework.org/schema/mvc"
	   xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	   http://www.springframework.org/schema/context
	   http://www.springframework.org/schema/context/spring-context-3.0.xsd
	   http://www.springframework.org/schema/mvc
	   http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
       http://www.springframework.org/schema/task
       http://www.springframework.org/schema/task/spring-task-3.0.xsd
       "
       default-autowire="byName">  

 	<!-- SPRING MVC Annotation configuration -->
	<context:annotation-config />
	<context:component-scan base-package="com.yourDomain.yourProjectName" />

	<!-- Configures the annotation-driven Spring MVC Controller programming model.
	Note that, with Spring 3.0, this tag works in Servlet MVC only!  -->
	<mvc:annotation-driven conversion-service="conversionService"/>

	<bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean" />

 	<!-- RESOURCE BUNDLES -->
   	<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
		<!-- <property name="basename"><value>yourProjectName-message</value></property> -->
		<property name="basenames">
            <list>
                <value>yourProjectName-message</value>
                <value>yourProjectName-config</value>
            </list>
        </property>
	</bean>

	<context:property-placeholder location="classpath:yourProjectName-config.properties" />

	<!-- MAIL CONFIGURATION -->
	 <bean id="mailSender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
			<property name="host" value="${smtp.host}"/>
			<property name="port" value="25"/>
        	<!--  <property name="username" value="${smtp.username}"/>
        	<property name="password" value="${smtp.password}"/> -->
	        <property name="javaMailProperties">
	            <props>
                <!-- Use SMTP transport protocol -->
                    <prop key="mail.transport.protocol">${smtp.mail.transport.protocol}</prop>
	            <!-- Use SMTP-AUTH to authenticate to SMTP server -->
	                <prop key="mail.smtp.auth">${smtp.mail.smtp.auth}</prop>
                <!-- Use TLS to encrypt communication with SMTP server -->
	                <prop key="mail.smtp.starttls.enable">${smtp.mail.smtp.starttls.enable}</prop>
              		<prop key="mail.debug">${smtp.mail.debug}</prop>
           		</props>
	        </property>
	    </bean>

	<bean id="alertMailMessage" class="org.springframework.mail.SimpleMailMessage">
			<property name="from">
				<value>${smtp.mail.alert.from}</value>
			</property>
			<property name="to">
				<value>${smtp.mail.alert.to}</value>
			</property>
			<property name="subject" value="${smtp.mail.alert.subject}"/>
	</bean>

    <!-- CONFIGURAZIONE SCHEDULING -->
    <task:scheduler id="taskScheduler"/>
    <task:executor id="taskExecutor" pool-size="1"/>
    <task:annotation-driven executor="taskExecutor" scheduler="taskScheduler"/>

    <!-- BEANS DECLARATION -->  

	<!-- Configure the multipart resolver -->
	<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<!-- 1048576 x 10 = 10 MB (Tiene conto anche dei video)-->
		<property name="maxUploadSize" value="10485760" />
	</bean>

</beans>

 

5. La configurazione di Hibernate su Spring: spring-orm.xml

In questo file di configurazione, spring-orm.xml, viene riportata la configurazione di Hibernate sullo “scheletro” di Spring e vengono inizializzate le componenti di base: sessionFactory, hibernateTemplate e transactionManager. Qui occorre anche inserire parametri/proprietà di Hibernate, il datasource (in questo caso si fa una lookup con JNDI) e l’elenco dei modelli che occorre far gestire ad Hibernate (lista delle annotatedClasses, ovvero classi che sono state preventivamente annotate con @Entity). Le transazioni, come vedremo, possono essere gestite e configurate direttamente su classi di servizio o DAO, con l’annotation @Transaction.

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:security="http://www.springframework.org/schema/security"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"> 

    <!--  DATASOURCE CONFIGURATION -->
    <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
        <property name="jndiName" value="java:yourJNDIdatasource"/>
        <property name="lookupOnStartup" value="false"/>
		<property name="cache" value="true"/>
		<property name="proxyInterface" value="javax.sql.DataSource"/>
    </bean>   

    <!-- AUDIT LOGGING INTERCEPTOR -->
	<bean id="auditLog" class="com.yourDomain.model.interceptors.AuditLogInterceptor"/>

    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--  HIBERNATE CONFIGURATION -->
 	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />

		<property name="schemaUpdate"><value>true</value></property>
		<property name="annotatedClasses">
			<list>
				<value>com.yourDomain.model.Model1</value>
				<value>com.yourDomain.model.Model2</value>
				....

			</list>
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.validator.apply_to_ddl">false</prop>
				<prop key="hibernate.validator.autoregister_listeners">false</prop>
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
	            <prop key="hibernate.cache.use_query_cache">true</prop>
	            <prop key="hibernate.cache.use_second_level_cache">true</prop>
				<prop key="hibernate.cache.provider_class">net.sf.ehcache.hibernate.EhCacheProvider</prop>
	            <prop key="hibernate.show_sql">false</prop>
	            <prop key="hibernate.format_sql">true</prop>
	            <prop key="hibernate.use_sql_comments">false</prop>
	            <prop key="hibernate.hbm2ddl.auto">update</prop>
	            <prop key="hibernate.max_fetch_depth">5</prop>
				<prop key="hibernate.default_batch_fetch_size">16</prop>
				<prop key="hibernate.jdbc.batch_size">25</prop>
				<prop key="hibernate.jdbc.fetch_size">8</prop> 

				<prop key="hibernate.connection.release_mode">after_statement</prop>
				<prop key="hibernate.connection.autoReconnect">true</prop>
				<prop key="hibernate.generate_statistics">false</prop>
        		<prop key="hibernate.cglib.use_reflection_optimizer">false</prop>
				<prop key="c3p0.acquire_increment">1</prop>
				<prop key="c3p0.idle_test_period">0</prop>
				<prop key="c3p0.idleConnectionTestPeriod">60</prop>
				<prop key="c3p0.max_size">200</prop>
				<prop key="c3p0.max_statements">0</prop>
				<prop key="c3p0.min_size">20</prop>
				<prop key="c3p0.timeout">1800</prop>
        	 	<prop key="hibernate.use_outer_join">true</prop>
        		<prop key="hibernate.jdbc.use_scrollable_resultset">true</prop>

	      	</props>
		</property>
	</bean>

    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>   

	<!-- TRANSACTION MANAGER -->
	<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
		<property name="entityInterceptor" ref="auditLog"/>
	</bean>

	<tx:annotation-driven transaction-manager="transactionManager"/>

	<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
      <tx:method name="delete*" propagation="REQUIRED" />
      <tx:method name="save*"   propagation="REQUIRED" />
      <tx:method name="modify*" propagation="REQUIRED" />
      <tx:method name="update*" propagation="REQUIRED" />
      <tx:method name="find*"   read-only="true"/>
      <tx:method name="get*"    read-only="true"/>
      <tx:method name="export*" read-only="true"/>
     </tx:attributes>
    </tx:advice>
</beans>

 

6. Gestione della sicurezza in Spring: Spring Security (spring-security.xml)

Nel file spring-security.xml viene riportata la configurazione della sicurezza sui metodi. In questo esempio, occorre che un utente loggato abbia un determinato ruolo (ROLE_USER), per poter eseguire i metodi (di classi presenti in determinati package della nostra web application). E’ possibile anche customizzare l’authentication manager (CustomAuthenticationManager) per poter gestire, ad esempio, una autenticazione con un web services esterno oppure un LDAP. A seconda poi degli stati di autenticazione (autenticazione con successo, autenticazione fallita, sessione scaduta, logout, ecc.) è possibile fare in modo che Spring effettui delle redirect a determinate pagine, gestendo opportunamente la sessione utente.

<?xml version="1.0" encoding="UTF-8"?>

<beans:beans xmlns="http://www.springframework.org/schema/security"
  xmlns:beans="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/security
          http://www.springframework.org/schema/security/spring-security-3.0.3.xsd">

  <!-- Gestione della sicurezza sui metodi -->
  <global-method-security>
   	   <protect-pointcut access="ROLE_USER"  expression="execution(* com.yourDomain.dao.*.*(..))"/>
       <protect-pointcut access="ROLE_USER"  expression="execution(* com.yourDomain.dao.impl.*.*(..))"/>
       <protect-pointcut access="ROLE_USER"  expression="execution(* com.yourDomain.service.*.*(..))"/>
       <protect-pointcut access="ROLE_USER"  expression="execution(* com.yourDomain.service.impl.*.*(..))"/>
   </global-method-security> 	

  <http auto-config="false" use-expressions="true" access-denied-page="/login.jsp?error=1"
   entry-point-ref="authenticationEntryPoint" >

	    <intercept-url pattern="/css/**" access="permitAll"/>
	    <intercept-url pattern="/js/**" access="permitAll"/>
	    <intercept-url pattern="/img/**" access="permitAll"/>
	    <intercept-url pattern="/include/**" access="permitAll"/>
	   	<intercept-url pattern="/xslt/**" access="hasRole('ROLE_USER')"/>
	    <intercept-url pattern="/anagrafica1/**" access="hasRole('ROLE_USER')"/>
	    <intercept-url pattern="/anagrafica2/**" access="hasRole('ROLE_USER')"/>
	    <intercept-url pattern="/anagrafica3/**" access="hasRole('ROLE_USER')"/>
	    <intercept-url pattern="/main/**" access="permitAll"/>
	    <intercept-url pattern="/login.jsp*" access="permitAll"/>
	    <intercept-url pattern="/ie-css3.htc*" access="permitAll"/>
	    <intercept-url pattern="/**" access="hasRole('ROLE_USER')" />

	    <logout
	    invalidate-session="true"
	    logout-success-url="/login.jsp"
	    logout-url="/auth/logout.do"/>

	   <!-- <session-management invalid-session-url="/login.jsp?error=4">
	  		<concurrency-control max-sessions="1" />
	  	</session-management> -->

	  	<session-management invalid-session-url="/login.jsp">
	  	</session-management>

	   <custom-filter ref="authenticationFilter" position="FORM_LOGIN_FILTER"/>
   </http>

   <beans:bean id="authenticationFilter" class="org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter"
    p:authenticationManager-ref="customAuthenticationManager"
    p:authenticationFailureHandler-ref="customAuthenticationFailureHandler"
    p:authenticationSuccessHandler-ref="customAuthenticationSuccessHandler" />

   <beans:bean id="customAuthenticationManager" class="com.yourDomain.authenticator.CustomAuthenticationManager"/>

   <beans:bean id="customAuthenticationFailureHandler" class="org.springframework.security.web.authentication.SimpleUrlAuthenticationFailureHandler"
   p:defaultFailureUrl="/login.jsp?error=2" />

   <beans:bean id="customAuthenticationSuccessHandler" class="org.springframework.security.web.authentication.SimpleUrlAuthenticationSuccessHandler"
   p:defaultTargetUrl="/main/home.do" />

   <beans:bean id="authenticationEntryPoint"  class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint"
   p:loginFormUrl="/login.jsp"/>

  <authentication-manager/>

</beans:beans>

 

7. Configurazione di Spring MVC: spring-servlet.xml

Nel file spring-servlet.xml viene riportata la configurazione (minimale) per l’installazione del modulo Spring MVC, che fa da strato di interfaccia tra business e presentation layer.

Tutte le classi che sono state annotate con @Controller vengono “scannerizzate” in automatico (come già descritto nella configurazione core al passo 4), e ora occorre che venga definita l’estensione delle pagine che conterranno le view della nostra applicazione (nel nostro caso, sono pagine .JSP). Qui si possono definire anche gli interceptors, ovvero classi di controller molto utili, che vengono attivate quando viene fatta una data richiesta (eseguito un determinato controller) e che effettuano delle elaborazioni “in background” (asincrone).

<?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:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	   		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	   		http://www.springframework.org/schema/context
	   		http://www.springframework.org/schema/context/spring-context-3.0.xsd
			http://www.springframework.org/schema/mvc
			http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">

	<bean id="viewResolver"
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix">
			<value>/</value>
		</property>
		<property name="suffix">
			<value>.jsp</value>
		</property>
	</bean>	

	<bean id="annotationMapper"
		class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
		<property name="interceptors">
			<list>
				<ref bean="menuDispatcher" />
			</list>
		</property>
	</bean>

	<mvc:interceptors>
		<mvc:interceptor>
			<mvc:mapping path="/**/**.do"/>
			<bean class="com.yourDomain.layout.MenuDispatcher" />
		</mvc:interceptor>
	</mvc:interceptors> 	

	<bean id="menuDispatcher" class="com.yourDomain.layout.MenuDispatcher"/>

	<!-- MAPPING DEI CONTROLLER -->
	<!-- <bean class="com.yourDomain.controller.TestController">
		<property name="service">
			<ref bean="testService"/>
		</property>
	</bean> -->
</beans>

 

Conclusioni

Nella Parte 2 di questo tutorial, vedremo degli esempi sulle classi/interfacce di Spring con relative annotazioni, mostrando un esempio utile per capire come il framework ci viene in aiuto dal presentation layer (grazie a Spring MVC) al persistent layer (Spring ORM).

Vi allego il codice sorgente dei file descritti in questo articolo.

Spring3_Configuration
Titolo: Spring3_Configuration (0 click)
Etichetta:
Filename: spring3_configuration.zip
Dimensione: 9 kB

Un pensiero su “[Spring] Spring3: dai Controller ai Repository [Parte1]

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *


quattro + = 11