Talk codemotion 2013 - La sostenibile leggerezza di Spring

Daniele La Nave
La sostenibile leggerezza di Spring!
Ovvero, come migliorare il nostro team e la nostra
produttività utilizzando Spring Framework.
dlanave@extrema-sistemas.com
Spring Certified Trainer & Specialist @ Extrema Sistemas

Capitolo 1
Daniele La Nave dlanave@extrema-sistemas.com - Extrema Sistemas

Come portare il nostro team,bendato e con i
tappi alle orecchie, alla piena
comprensione dell’ OOP utilizzando Spring

Come portare il nostro team, bendato e con i tappi alle orecchie,
alla piena comprensione dell’OOP utilizzando Spring

…..eh ?

Perché bendato e con i tappi alle orecchie ?


Risposte:

1. Capita, quando si realizza un software, di essere
concentrati a soddisfare i requisiti del cliente e meno
attenti alle linee guida ed i concetti legati ad una buona
progettazione dell’architettura


Risposte:

2. Un’ azienda deve, necessariamente, essere produttiva,
competitiva, ed in grado di far fronte alle eventuali
“turbe” dei clienti. Es:

“Vorrei un’ icona di color blu sul mio desktop…
…che, se cliccata, scateni il lancio di ordigno di
fine di mondo!!!”


Risposte:

3. “Lo voglio pronto per la prossima settimana! Anzi, lo
voglio pronto per domani!!”


Ironia a parte, quanto descritto fin ora può causare
dei pericolosi corto-circuiti tra reparti dell’azienda:

Settore Commerciale Vs. Settore Sviluppo
Oppure, in altri termini, una volta “rotto” il circuito

“Fighetti” Vs. “Autistici”


In realtà, tutti e due i reparti sono “vitali” per la
salute di un’ azienda perché:

• Inefficienza dei commerciali = Niente clienti
• Inefficienza degli sviluppatori = Niente prodotti

Bisogna quindi difendere l’operato di tutti i reparti!
(Siamo tutti sulla stessa barca, mai dimenticarlo!!)


...e quindi ?

Se i tempi sono corti ed i requisiti “complessi”,
come possiamo far contenti tutti ?


I principi fondamentali per l’OOP ci dicono che dovremmo
evitare 3 caratteristiche che denotano il “cattivo” design di
un’ applicazione:

1. Rigidità
(il cambiamento di un requisito richiede il cambiamento di molte parti del sistema)

2. Fragilità
(il cambiamento di un requisito interrompe il corretto funzionamento del sistema)

3. Immobilità
(impossibilità o difficoltà di riutilizzo delle stesse componenti su più di un’ applicazione)


Per evitare queste caratteristiche di “bad design” sono state
definite, nel corso degli anni, delle linee guida per aiutarci a
sviluppare software che non risentano di tali sintomi,
ovvero:

The Software Design Principles


Dependency Inversion Interface Segregation
Open Close Principle Principle Principle
Classi, moduli, funzioni I moduli a più alto livello non
dovrebbero essere “Aperte” per dovrebbero dipendere dai moduli
I Client non dovrebbero
l’estensione e “Chiuse” per la di livello più basso, entrambi essere forzati ad
modifica dovrebbero dipendere solo dalla implementare interfacce che
loro astrazione non utilizzano

Liskov’s Substitution
Single Responsibility
Principle
Principle
Le classi derivate devono
Una classe dovrebbe avere
poter sostituire
solo una singola ragione per
completamente quelle di
essere modificata
base


Sulla base di questi principi, è stata creata una serie di
modelli per la Programmazione Orientata agli Oggetti:

The Design Patterns (by GoF)
(Sono circa 25, divisi in 3 categorie)

Creazionali, Comportamentali, Strutturali


Però…

• Non tutti gli sviluppatori sanno come utilizzarli
• Un uso sbagliato può portare il progetto oltre “l’orizzonte
degli eventi!”
• Potrebbe risultare difficile far capire, ai “non addetti ai
lavori”, perché implementarli

Ma allora, come tenere sotto controllo il progetto ?


La soluzione esiste, ed è apprezzata da milioni di
sviluppatori: Spring Framework

Modularità Produttività Portabilità Testabilità


Principalmente, Spring ci chiede solo
di seguire alcune regole definite come
“fondamentali”:

• DRY Principle = “Don’t Repeat Yourself”

• SoC Principle = “Separation of Concern”

(segue)


E, per quel che riguarda il Design
della nostra applicazione, sviluppare:

1. Basandoci sulle interfacce
Astrazione dei componenti = loose coupling
2. Preferendo la composizione all’ereditarietà
Favorendo, di fatto, la modularità
3. Componendo l’architettura a layer
Service, Data Access & Infrastructure è un classico!


Quindi si!

…Bendati e con i tappi alle orecchie!
…Indaffarati nel soddisfare le richieste del cliente!

Contando, però, su di un Framework in grado di dare pieno
supporto infrastrutturale per il Design della nostra
architettura.

Capitolo 2

“Fatto! …Già fatto??”
Codice più efficiente e, soprattutto,
In minor quantità

Fatto! Già fatto?? Codice più efficiente e, soprattutto, in minor
quantità

Fitness Club Application

Requisiti cliente:
• Desktop App (Standalone)
• Gestione clienti del club
• Gestione delle sottoscrizioni alle attività

quantità

<<Java Class>> <<Java Class>> <<Java Class>>
Member Subscription Activity

<<Java Class>> <<Java Class>>
Customer Address

Domain Objects

quantità

<<Java Interface>> <<Java Interface>> <<Java Interface>>
MemberRepository SubscriptionRepository ActivityRepository

<<Java Interface>> <<Java Interface>>
CustomerRepository AddressRepository

Data Access Layer

quantità

CustomerManagerService FitnessClubService

Service Layer

quantità

<<Java Class>> <<Java Interface>>
JdbcActivityRepository ActivityRepository

<<Java Interface>>
DataSource

Data Access Layer
(implementazione)

quantità

HibernateActivityRepository ActivityRepository

<<Java Interface>>
SessionFactory

Data Access Layer
(implementazione)

quantità

<<Java Interface>>
MemberRepository <<Java Class>> <<Java Interface>>
FitnessClubServiceImpl FitnessClubService

<<Java Interface>>
SubscriptionRepository

CustomerManagerServiceImpl CustomerManagerService

CustomerRepository AddressRepository Service Layer
(implementazione)

quantità

I componenti della nostra applicazione sono pronti!

Passiamo ora alla configurazione di Spring

quantità

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/fitnessclubdb"/>
<property name="username" value="fitnessclubdbuser"/>
<property name="password" value="ItsASecret!"/>
</bean>

Oppure, se gestito da Java EE Container:

<jee:jndi-lookup id="dataSource" jndi-name="jdbc/fitnessclubdb"/>

db-config.xml

quantità

<jdbc:embedded-database id="dataSource">
<jdbc:script location="classpath:schema.sql"/>
<jdbc:script location="classpath:test-data.sql"/>
</jdbc:embedded-database>

test-db-config.xml

quantità

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="packagesToScan" value=“com.extremasistemas.fitnessclub.entities" />
<property name="hibernateProperties">
<value> …</value>
</property>
</bean>

hibernate-config.xml

quantità

…
<bean id="customerRepository"
class=" com.extremasistemas.examples.fitnessclub.repository.JdbcCustomerRepository ">
<constructor-arg ref="dataSource" />
</bean>

Oppure, utilizzando Hibernate:

<bean id="customerRepository"
class=" com.extremasistemas.examples.fitnessclub.repository.HibernateCustomerRepository ">
<constructor-arg ref="sessionFactory" />
</bean>
… data-access-config.xml

quantità

<bean id="customerManagerService"
class="com.extremasistemas.examples.fitnessclub.service.CustomerManagerServiceImpl">
<constructor-arg ref="customerRepository" />
<constructor-arg ref="addressRepository" />
</bean>

<bean id="fitenessClubService"
class="com.extremasistemas.examples.fitnessclub.service.FitnessClubServiceImpl">
<constructor-arg ref="customerManagerService " />
<constructor-arg ref="memberRepository " />
<constructor-arg ref="subscriptionRepository" />
</bean>
application-config.xml

quantità

Grafico delle dipendenze dei Bean

quantità

Ora che abbiamo definito la configurazione..
…”Miwa (Spring), lanciami i componenti!”

quantità

“Mmmhhhh.. ma scrivere meno XML, no eh ?”
(DI utilizzando le annotazioni ed il “component-scan”)

quantità

quantità

<context:component-scan base-package="com.extremasistemas.examples.fitnessclub" />


quantità

“Ma questa applicazione non usa le transazioni !!”
(Come applicare le proprietà ACID in 5 minuti)

quantità

<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

Oppure, utilizzando Hibernate:

<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
transaction-config.xml

quantità

Oppure, se gestito da Java EE Container:

<tx:jta-transaction-manager />

transaction-config.xml

quantità


<tx:annotation-driven />


quantità

“Missione compiuta! Transazioni implementate!!”

quantità

Riunione con il Cliente…

Requisiti:
• Ho due nuovi impiegati, vorrei che anch’essi utilizzassero
l’applicazione.
• Deve rimanere un’ applicazione desktop
• Vorrei che la business logic fosse spostata su un server
• Ma, non voglio un server web!

quantità

Remote Method Invocation
“Senza toccare una riga di codice Java”

quantità

Come ?

1. Spostando il back-end dell’applicazione su una macchina
dedicata
2. Lasciando il solo front-end sui terminali degli operatori
3. Modificando le istruzioni di configurazione di Spring
per il back-end ed il front-end.

quantità



<bean class="org.springframework.remoting.rmi.RmiServiceExporter">
<property name="serviceName" value="FitnessClubService" />
<property name="serviceInterface"
value="com.extremasistemas.examples.fitnessclub.service.FitnessClubService" />
<property name="service" ref="fitnessClubService" />
</bean>

application-config.xml (server)

quantità

<bean id=“fitnessClubService" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">
<property name="serviceUrl" value="rmi://HOST:1099/FitnessClubService" />
<property name="serviceInterface"
value=" com.extremasistemas.examples.fitnessclub.service.FitnessClubService " />
</bean>

application-config.xml (client)

quantità

Fatto!
“E non abbiamo toccato una sola riga di codice Java!!”

quantità

Riunione con il Cliente…

Requisiti:
• Ho vinto al Superenalotto! Apro 10 club sul territorio!!
• Ora voglio che la mia applicazione sia utilizzata via web!
• Voglio comunque mantenere la stessa logica di business

quantità

E come ?

Con Spring MVC!

quantità

E come ?

1. Mantenendo intatta la configurazione applicativa
2. Configurando l’applicazione web via web.xml
3. Configurando Spring MVC
4. Definendo in nostri Controller
5. Creando i nostri Form

quantità

<web-app>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/META-INF/spring/application-config.xml</param-value>
</context-param>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</servlet-name>
</listener>
…

web.xml

quantità

…
<servlet>
<servlet-name>fitnessClubApplication</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:/META-INF/spring/web/mvc-config.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
…
</web-app>
web.xml

quantità

<mvc:annotation-driven />
<mvc:default-servlet-handler />

<mvc:view-controller path="/login" view-name="login" />

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/" />
<property name="suffix" value=".jsp" />
</bean>

<context:component-scan base-package="com.extremasistemas.examples.fitnessclubweb" />

mvc-config.xml

quantità

FitnessClubsController.java

quantità

<a href="http://www.server.com/fitnessclubs/members" >Lista Iscritti</a>

…la lista degli iscritti sarà quindi recuperabile come attributo della request:

${members}

quantità

<forms:form action="${myurl} " method="POST" modelAttribute="customer">
…
<forms:input path="firstName" />
<forms:errors path="firstName" />
…
</forms:form>

memberForm.jsp

quantità

E per la sicurezza, come si fa ?

1. Si aggiunge un filtro sul web.xml
2. Si aggiunge la configurazione per la sicurezza
3. Eventualmente, si utilizza la taglib specifica di Spring
per personalizzare le JSP

quantità

<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>

web.xml

quantità

<security:http pattern="/css/**" security="none"/>
<security:http pattern="/login.jsp*" security="none"/>

<security:http auto-config="true" use-expressions="true">
<security:intercept-url pattern="/**" access="hasRole(' ROLE_USER')" />
<security:form-login login-page="/login"
authentication-failure-url="/login?login_error=1" />
<scecurity:logout logout-url="/logout" logout-success-url="/" invalidate-session="true" />
</security:http>

<security:authentication-manager>
<security:authentication-provider>
<security:jdbc-user-service data-source-ref="dataSource"/>
</security:authentication-provider>
security-config.xml
</security:authentication-manager>

quantità

<security:authorize access="hasRole('ROLE_USER')" >
…lo legge solo chi ha questa determinata authority!!
</security:authorize>

Oppure, per visualizzare i dati relativi al contesto di sicurezza:

Benvenuto: <security:authentication property="principal.username" />

example.jsp

quantità

“E la sicurezza è servita!”

quantità

“Vorrei una mail per ogni errore
sul Data Access Layer”

quantità

Come possiamo farlo?

1. Modifichiamo tutte le repository (molto male!!!)
– Violazione del DRY Principle (Code Scattering)
– Violazione del SoC Principle (Code Tangling)

2. Aggiungiamo un componente per svolgere l’attività (Ok!)
– No Tangling
– No Scattering

quantità

Spring Aspect Oriented Programming
(…al volo!)

quantità

DataAccessLayerMonitor.java

quantità

<aop:aspectj-autoproxy >
<aop:include name="dataAccessMonitor" />
</ aop:aspectj-autoproxy >

<bean id="dataAccessMonitor“
class=" com.extremasistemas.examples.fitnessclub.aspects.DataAccessLayerMonitor ">
<constructor-arg ref="mailService" />
</bean>

aspects-config.xml

quantità

<import resource="aspects-config.xml" />




quantità

“Fatto!!”

Capitolo 3

Facciamo tutti parte di un disegno più
grande. Il team, Spring ed i concetti legati
ai Design Patterns

Facciamo tutti parte di un disegno più grande.
Il team, Spring ed concetti legati ai Design Patterns

La piattaforma Java propone una vasta gamma di
funzionalità per lo sviluppo delle nostre applicazioni.

Non ci fornisce, però, i mezzi per poterne organizzare gli
elementi fondamentali in un insieme che sia coerente con i
principi legati ai Design Patterns.

Sicuramente, possiamo usare i Design Patterns per la
composizione delle varie classi ed istanze di oggetti…


…Ma, dobbiamo implementarli nella nostra
applicazione!


Spring ApplicationContext = Inversion of Control Pattern


Spring MVC = Front Controller Pattern


Spring AOP = Proxy Pattern


Spring JdbcTemplate = Template Method Pattern


Spring Integration = EAI Patterns


“La forza scorre potente in Spring!!”
Ma…

Capitolo 4

“La potenza è nulla senza controllo!”
Perché i test di unità devono essere un MUST

La potenza è nulla senza controllo!

Lo Unit Testing è fondamentale perché:

• Prima troviamo un Bug, meno tempo impieghiamo nel
risolverlo

• Tenere in considerazione i test, come parte integrante del
progetto (TDD), consente:
• Maggiore agilità
• L’utilizzo di meccanismi di verifica automatica (es. JUnit)


Inoltre, cosa non da poco:

• L’implementazione dei test ci da la possibilità di
controllare la “flessibilità” e la “modularità” del nostro
sistema

Se non siamo in grado di implementare facilmente gli Stubs, oppure
i Mocks, per la simulazione delle dipendenze di un componente, vuol
dire che il design della nostra applicazione è da “rivedere”!


Spring ci offre inoltre pieno supporto
agli Integration Test:

• Permettendoci l’utilizzo dei bean nei test (tramite DI)
• Permettendoci l’uso delle transazioni per i test
• Fornendoci componenti di supporto all’esecuzione di test
“out-of-container” (es. per le web application)


CustomerServiceTest.java

Capitolo 5

“L’importante è vincere, non partecipare!”
Il valore aggiunto dato da Spring Framework

L’ importante è vincere, non partecipare!

ff


Spring Features Overview:

• Modern Web
• Data Access
• Integration
• Mobile
• Social
• Security
• Cloud Ready


Spring Projects Overview:

Spring AMQP Spring Mobile
Spring for Android Spring.NET
Spring Batch Spring Roo
Spring Data Spring Security
Spring Framework Spring Social
Spring Gemfire Spring Web Flow
Spring Integration Spring Web Services


SpringSource ToolSuite

Features:
• Wizards per Spring Projects, configurazione bean con xml
files
• Supporto per Spring 3.1
• Funzionalità avanzate per il completamento del codice,
“content-assist”, validazione e supporto al “quick-fix” di
applicazioni Spring
• Supporto al refactoring per la configurazione XML e @Configuration
• Editor grafico per la configurazione di Spring
• Tools visuali di sviluppo per Spring Web Flow, Spring Batch e Spring Integration
• Spring Roo project wizard con shell integrata



Deployment Target flessibile:

• Supporto per tutti i più comuni Java EE Application
Servers
• Supporto avanzato per VMware vFabric tc Server
• Piena integrazione dell’IDE per Cloud Foundry, con
inclusione del debug diretto nel cloud



Pronto per l’uso:

• Distribuzione basata su Eclipse
• Componenti comuni già pre-installati
• Contiene le ultime versioni per i runtime di tc Server
Developer Edition e Spring Roo


tc Server Developer & Spring Insight

Q&A

Q&A

Talk codemotion 2013 - La sostenibile leggerezza di Spring

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Talk codemotion 2013 - La sostenibile leggerezza di Spring

Semelhante a Talk codemotion 2013 - La sostenibile leggerezza di Spring (20)

Talk codemotion 2013 - La sostenibile leggerezza di Spring