View
584
Download
1
Category
Preview:
Citation preview
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...
Recommended