Framework web

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)

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

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

Framework WebBut

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'

Framework WebServices

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

Framework WebA Full ecosystem

Ready on PAAS

SocialSécurity

Sql

NoSQL

JPACaching

Big Data SOAP

JMS

AMQPWS

Voldemort

Highly DistributedWeb 2.0 Complient Data Oriented

IOCSCALABLE

TESTABLERELIABLE

Framework Web2012 Review - Framework popularity

Copyright : zeroturnaround / Developer productivity report 2012

Framework WebOr Lightweight Framework

Handmade Framework based on lightweight components

Framework Webl'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

Framework WebLightweigth 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 popularityWarning when the framework became hasbeen

Depends on the popularity

Framework WebConclusion

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

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

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 MVCInversion of Control container

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 scopesingleton (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 MVCInversion of Control container

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 MVCInversion of Control container

Pour utiliser un bean il suffit de l'injecter :

● Avec l'anotation Autowired○ Quand l'interface n'a qu'une seule implémentation

@Autowiredprivate BeerStore beerBusiness;

○ Avec un Qualifier@Autowired@Qualifier(value="enibbar")private BeerStore beerBusiness;

● Avec l'anotation Resource @Resourse(name="enibBeerStore")private BeerStore beerBusiness;

Spring MVCInversion of Control container

Le controleur est une Servlet, il en a strictement le même rôleLa 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 MVCLe controleur

fichier mvc-disatcher-servlet.xmlnom de la JSP pour le forwardConfiguration de la localisation : - mvc-dispatcher-servlet.xml

Spring MVCLe 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 theJSPreturn "signup/createAccountForm";

}

Ce controleur reçoit des HTTP POST sur l'urlhttp://mydomain:8080/context/signupUniquement pour des requetes POST

L'objet message disponible dans la JSP

Nom de la JSP pour le forward

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 @ResponseBodyAddBeerStatus create(@RequestBody Beer beer, HttpServletResponse response) {

Beer newBeer = beerBusiness.addBeer(beer);

return AddBeerStatus.created(newBeer );}

Object de retour à sérialiser en JSO

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

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 MVCLe controleur - Mapping Object - JSON

Spring MVCLe 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 @ResponseBodyAddBeerStatus validateField(@PathVariable String field, @RequestBody Beer beer, HttpServletResponse response) {

... do the business call

return AddBeerStatus.notCreated(null);}

Variabilisation de l'URL

Spring MVCDatabase / 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

This afternoonHand in code...