1. Framework web

2. Introduction
Le Web est fait de HTTP, HTML, CSS, REST avec des architectures sans
états.
<Guillaume Bort / Play Framework>
Le framework web est le socle d'une application Web fonctionnant sur un éco-
système (java, Ruby, PHP, Python, Groovy)

3. Introduction
Historique - Java Jungle
2000
● API Servlet
○ Une url = une vue, une page HTTP
○ Session HTTP
● Tomcat
○ Conteneur "léger" (servlets et JSP, pas d'EJB)
● Struts
○ Modèle MVC
○ Configuration XML
2003
● Spring
○ Inversion de contrôle
○ Programmation orientée aspect
○ Couche d’abstraction.
2005
○ Ajax - les pages web dynamiques naissent

4. Introduction
Historique - Java Jungle
2006
● Seam le concept de conservation introduit par Seam (reference à mettre).
Natif dans les framework modernes (Grails / Play)
● Apparition des compilateur JS et framework "poid mouche" (GWT)
2007
● Nouveau paradigme : retour à l'Esprit du Web : Play! Framework

5. Framework Web
But
DON'T REINVENT THE WHEEL !!!
● se concentrer sur le code métier
● améliorer :
○ la testabilité
○ maintenabilité
● ouvert
○ intégration de modules "prêts à plugger"
○ communautaire
● Réduire le 'time to market'

6. Framework Web
Services
- web template système : produire le code html / css / js
- cache / asynchronisme : limiter la charge server
- sécurité : garantir l'authenticité du client sur le web
- intéropabilité : savoir dialoguer avec des applications tiers (back end)
- URL mapping : associer le code à une URL
- AJAX : réliser des applications intéractives
- web services : exposer des API
- architecture : structurer l'application (MVC, IOC)

7. Framework Web
A Full ecosystem
Ready on PAAS
Social
Sécurity
Sql
NoSQL
JPA
Caching
Big
Data SOAP
JMS
AMQP
WS
Voldemort
Highly DistributedWeb 2.0 Complient Data Oriented
IOC
SCALABLE
TESTABLE
RELIABLE

8. Framework Web
2012 Review - Framework popularity
Copyright : zeroturnaround / Developer productivity report 2012

9. Framework Web
Or Lightweight Framework
Handmade Framework based on lightweight components

10. Framework Web
l'heure du choix !
Framework
● fondations de l'application Web
● très couteux à changer
● doit résister aux changements (vision du produit)
● framework obsolète ou inadapté = risque

11. Framework Web
Lightweigth vs Heavyweight
Framework Lightweight Framework
plateform set up Rapid slow for a full web scope
custom more difficult possible handmade
Evolution all the framework possible part by part
plateform depedends sometimes (Web Profile
developpement)
only a servlet container
integrate new
compenents
A functionality or technology
not supported by the
framework can be hard to
integrate
You can make you own
patchwork easier
Community and updates Depends on the popularity
Warning when the framework
became hasbeen
Depends on the popularity

12. Framework Web
Conclusion
Il n'y a pas de bon choix, uniquement un choix adapté à votre besoin
Avant de choisir testez vos choix pour le confirmer
Confrontez vos choix avec d'autres architectes (qui développent encore...), de
préférence d'autres sociétés pour avoir un avis objectif sur votre système
N'oubliez un choix, c'est pour le meilleur, ou le pire de votre application

13. Spring est un framework libre pour construire et définir l'infrastructure d'une
application java, dont il facilite le développement et les tests.
En 2004, Rod Johnson a écrit le livre Expert One-on-One J2EE Design and
Development qui explique les raisons de la création de Spring, basé sur les
concepts suivants :
● Inversion de Contrôle
● Data access (JBDC)
● Transaction management
● Model-view-controller
● Remote Access framework: RPC-style and HTTP-based protocols
● Authentication and authorization
● Remote Management (via JMX)
● Messaging (JMS)
● Testing
Framework Web
Spring MVC

14. La pière angulaire de String est l'inversion de contrôle qui permet de configurer
et gérer des objets via reflexion.
Le framework est responsable du cycle de vie des objets :
○ les instancier et les initialiser
○ les configurer
○ injecter les dependances
Spring MVC
Inversion of Control container

15. La pière angulaire de String est l'inversion de contrôle qui permet de configurer et
gérer des objets via reflexion.
Le framework est responsable du cycle de vie des objets :
○ les instancier et les initialiser
○ les configurer
○ injecter les dependances
Chaque object injectable (bean) a un scope
singleton (default).
prototype any number of object instances.
request to an HTTP request. Only valid in the Spring ApplicationContext.
session to an HTTP session. Only valid in the Spring ApplicationContext.
global-session to a global HTTP session. Only valid in the Spring
ApplicationContext.
Spring MVC
Inversion of Control container

16. Un bean injectable est une classe Java
<bean id="beerStore" class="fr.enib. ... .business.impl.BeerStoreImpl" >
</bean>
Qui peut se faite injecter :
● des paramètres
<bean id="beerStore" class="fr.enib. ... .business.impl.BeerStoreImpl" >
<property name="size" value="10" />
</bean>
<bean id="enibBeerStore" class="fr.enib. ... .business.impl.EnibarImpl" >
<property name="size" value="10" />
<qualifier "enibar"></qualifier>
</bean>
● des dependances (d'autres beans)
<bean id="beerStore" class="fr.enib. ... .business.impl.BeerStoreImpl" >
<property name="dataSource" ref="jndi-datasource" />
<property name="size" value="10" />
</bean>
● des listes et maps et plus encore...
http://static.springsource.org/spring/docs/1.2.9/reference/beans.html
Spring MVC
Inversion of Control container

17. Pour utiliser un bean il suffit de l'injecter :
● Avec l'anotation Autowired
○ Quand l'interface n'a qu'une seule implémentation
@Autowired
private BeerStore beerBusiness;
○ Avec un Qualifier
@Autowired
@Qualifier(value="enibbar")
private BeerStore beerBusiness;
● Avec l'anotation Resource
@Resourse(name="enibBeerStore")
private BeerStore beerBusiness;
Spring MVC
Inversion of Control container

18. Le controleur est une Servlet, il en a strictement le même rôle
La configuration est réalisée avec des annotations Java
http://mydomain.com:8080/context/helloString?name=toto
@Controller
@RequestMapping("/helloSpring")
public class HelloSpringMVC {
/**
* Handler de la méthode Get pour l'URL /helloSpringMVC.html.
*
* @param name le nom que l'on doit afficher dans la vue.
* @param model une map de toutes les données qui seront utilisables dans la vue
* @return le nom de la vue qu'il faudra utiliser.
*/
@RequestMapping(method = RequestMethod.GET)
public String sayHelloWithSpringMVC( @RequestParam(value="name",required=false) String name, Model model) {
model.addAttribute("name",name);
return "hello";
}
}
<!-- Resolves view names to protected .jsp resources within the /WEB-INF/jsp directory -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
Spring MVC
Le controleur
fichier mvc-disatcher-servlet.xml
nom de la JSP pour le forward
Configuration de la localisation :
- mvc-dispatcher-servlet.xml

19. Spring MVC
Le controleur - POST / Retour HTTP
Utilisé par exemple lors d'un submit d'un formulaire
@Controller
@RequestMapping(value = "/signup")
public class SignupControler {
....
@RequestMapping(method = RequestMethod.POST)
public
String create( Account account, ModelMap model ) {
// do Something
// The Form parameter are in the Account Object
...
// call the business
...
// add ojects to the model
model.addAttribute("message", "I Will survive");
// Forward to theJSP
return "signup/createAccountForm";
}
Ce controleur reçoit des HTTP POST sur l'url
http://mydomain:8080/context/signup
Uniquement pour des requetes POST
L'objet message disponible dans la JSP
Nom de la JSP pour le forward

20. Utilisé par exemple lors d'un post HTTP / AJAX / JSON
La sérialisation / désérialisation est réalisée par le framework en fonction des
dépendances ajoutée à ce dernier.
@RequestMapping(value = "/private/beer/add", method = RequestMethod.POST)
public @ResponseBody
AddBeerStatus create(@RequestBody Beer beer, HttpServletResponse response) {
Beer newBeer = beerBusiness.addBeer(beer);
return AddBeerStatus.created(newBeer );
}
Object de retour à sérialiser en JSO
Spring MVC
Le controleur - POST HTTP / AJAX - JSON
L'anotation RequestBody ResponseBody
indique que la requête et réponse est
dans le body et non les paramètres
Object issu de la desérialisation JSON
modélisant la requête

21. Modèle Object :
public class Beer {
private String name;
private String brewery;
private String country;
private double alcohol;
private int id;
public Beer() {
super();
}
... getters et setters publiques
}
Json produit
{"name":"1664","brewery":"kronenbourg","country":"France","alcohol":"5,5"}
Spring MVC
Le controleur - Mapping Object - JSON

22. Spring MVC
Le controleur - REST Web Service
Utilisation de :
○ la serialisation / deserialisation JSON
○ des request body
○ de la variabilisation des URLS
@RequestMapping(value = "/private/beer/validate/{field}", method = RequestMethod.POST)
public @ResponseBody
AddBeerStatus validateField(@PathVariable String field, @RequestBody Beer beer, HttpServletResponse response) {
... do the business call
return AddBeerStatus.notCreated(null);
}
Variabilisation de l'URL

23. Spring MVC
Database / Exemple
public class MyJdbcDaoImpl implements MyJdbcDao {
private final String sql = "select id, last_name from T_ACTOR where specialty = ? and age = ?";
private JdbcTemplate jdbcTemplate;
public void setDataSource(DataSource dataSource) {
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public Actor findActor(String specialty, int age) {
RowMapper<Actor> mapper = new RowMapper<Actor>() {
public Actor mapRow(ResultSet rs, int rowNum) throws SQLException {
Actor actor = new Actor();
actor.setId(rs.getLong("id"));
actor.setLastName(rs.getString("last_name"));
return actor;
}
};
// notice the wrapping up of the argumenta in an array
return (Actor) jdbcTemplate.queryForObject(sql, new Object[] {specialty, age}, mapper);
}
}
Injection de la datasource
Requête SQL
Row Mapper pour la
construction de l'objet de
retour
Execution de la requête

24. This afternoon
Hand in code...