Mois : août 2014

Birt 4.2 et la gestion des images

    Birt 4.2 ne veut que du 96 ?

birt 4.2 72dpi photoshopEn passant à Birt 4.2 pour l’édition de documents nous nous sommes rendu compte que la gestion des images était sensiblement différente d’avec les versions précédentes.

Birt 4.2 contrairement à ses prédécesseurs prend exactement la taille de l’image spécifiée en cm/pouces. Autrement dit pour la taille d’un logo standard de 450px de large, on se retrouve avec un logo imprimé avec une taille de 3,81cm pour une haute résolution de 300dpi (pixels par pouce), mais le même logo de 450px en résolution 72dpi (le standard du web) aura une largeur de 15,88cm une fois imprimé, là où avant Birt se servait de la taille en pixel en imprimant toujours avec la même résolution.

Lire plus

Texte défilant en css avec CSS3

Comment faire un Texte défilant en css ?

Texte défilant en css et l’utilisation de l’attribut data-text pour fournir un roulement continu

Le plus simple pour faire un texte qui défile, c’est d’utiliser la balise <marquee> pour encadrer la partie à faire défiler. C’est simple certes, mais marquee étant une balise propriétaire de Microsoft, elle n’est pas valide w3c (bien qu’elle soit correctement interprétée par tous les navigateurs) et quand on se soucie d’avoir un site valide elle est donc exclue.

Une autre solution, un peu plus complexe mais cependant accessible est d’utiliser javascript pour simuler le défilement. C’est d’ailleurs la solution qui est le plus proposée par les internautes. Mais comment faire si, pour une raison ou une autre on ne veut pas ou ne peut pas utiliser javascript ?

Lire plus

Introduction au framework Grails

Grails_logo

 

L’objectif de cet article et de ceux à venir est de vous présenter les avantages que peut vous apporter le framework Grails. Pourquoi, quand et comment l’utiliser ? Nous verrons cela par la suite.

 

 

Présentation de GRAILS

 

Grails est un framework web open source, de développement rapide, basé sur le langage Groovy, lui-même basé sur le langage Java.

Il utilise plusieurs principes qui permettent une haute productivité :

– Don’t Repeat Yourself (DRY) : le framework est basé sur le modèle MVC.

– Convention plutôt que configuration (Convention over configuration ou coding by convention) : Grails propose de nombreux comportements par défaut, vous n’aurez presque rien à configurer lors du développement de votre application. Par exemple, une classe dont le nom termine par « Controller » sera automatiquement considérée comme un contrôleur web.

– Architecture orientée modèle : pour réaliser une application basique, vous aurez uniquement à vous préoccuper de vos modèles. Les vues, les contrôleurs et les tests seront générés.

– Prototypage : Grails vous permet de générer vos vues, contrôleurs et tests à partir de vos modèles grâce à des méthodes de scaffolding. Vous pouvez ainsi obtenir une application de CRUD très rapidement. Vous pouvez également créer vos propres templates pour ajouter des fonctionnalités à la génération, ou simplement modifier l’apparence de votre application.

– Plugins : de nombreux plugins sont disponibles pour Grails. Ils vous permettront d’implémenter rapidement des fonctionnalités, telles que l’authentification avec le plugin Spring Security Core.

 

Historique

 

Le développement de Grails a été débuté en juillet 2005 par Graeme Rocher. Le framework était alors connu sous le nom de “Groovy on Rails”, car inspiré de “Ruby on Rails”. La première version (0.1) a été publiée le 29 mars 2006. Le même mois, il est renommé en “Grails” sous la demande du créateur de Ruby on Rails, David Heinemeier Hansson. Les principales versions suivantes sont:

 

[table id=1 /]

 

Peu après la sortie de la version 1.0, la société G2One (The Groovy Grails Company) est rachetée en novembre 2008 par SpringSource, elle-même rachetée en août 2009 par VMware.

 

Architecture

 

Grails utilise de nombreuses technologies existantes. Les principales sont :
– Le langage Groovy
– Hibernate
– Spring
– Sitemesh pour gérer la mise en page
– Le célèbre système de logging Log4J
– JUnit pour les tests unitaires

Celles-ci sont organisées comme montré ci-dessous :

architecture_grails

 

Toute application Grails est organisée en quatre parties : les domaines (les modèles), les services, les contrôleurs et les vues. Nous verrons plus en détail cette organisation par la suite avec un exemple d’application.

Les vues sont gérées par le framework SiteMesh, permettant notamment de créer des layouts, tandis que le cœur de Grails est géré par le framework Spring. La persistance des données est facilitée par GORM (Grails Object Relational Mapping). Celui-ci est basé sur Hibernate et utilise par défaut sa base de données intégrée HSQLDB, il permet de faire la relation entre les domaines et la base de données. Nous le verrons plus en détail dans un article suivant. Gant quant à lui est basé sur Ant, il sera utilisé notamment lorsque nous exécuterons une commande pour gérer Grails telle que « grails run-app ».

Pour terminer, tout objet de votre application pourra être développé soit en Java soit en Groovy. Dans les deux cas, votre objet sera compilé en bytecode et exécuté par la JVM.

 

Installation

 

Nous allons maintenant voir comment mettre en place un environnement de développement pour utiliser Grails.

Avant de commencer, il faut bien évidemment avoir installé un JDK (en version 1.6 ou supérieure), avoir configuré la variable d’environnement JAVA_HOME, pointant vers le dossier d’installation de votre JDK, et avoir ajouté le dossier bin/ du JDK à votre variable PATH.

Il existe plusieurs solutions pour utiliser le framework Grails. La première, la plus simple, consiste à télécharger l’IDE Groovy/Grails Tool Suite (GGTS). Il s’agit d’un environnement de développement basé sur Eclipse, tout comme Spring Tool Suite (STS). Il vous suffit ensuite d’extraire l’archive téléchargée, et de lancer GGTS.

Si vous possédez déjà STS, vous pouvez facilement installer le plugin Grails en suivant ces directives.

Si vous souhaitez utiliser Grails avec un autre IDE comme IntelliJ IDEANetBeans ou TextMate, nous vous laissons consulter la documentation officielle à ce propos.

 

Conclusion

 

Après cette présentation, vous pouvez déjà apercevoir les avantages que peut fournir Grails. Il utilise le langage moderne Groovy, le réputé framework Spring, de nombreux plugins, le principe de « coding by convention », le prototypage… Il s’agit d’un framework bien adapté au développement très rapide d’applications basiques, vous laissant en même temps la possibilité de réaliser des fonctionnalités bien plus avancées que du simple CRUD.

Dans les prochains articles, nous verrons plus en détail le fonctionnement du framework par un exemple d’application.

 

Sources

http://grails.org/

http://en.wikipedia.org/wiki/Grails_(framework)

http://www-igm.univ-mlv.fr/~dr/XPOSE2009/Groovy_and_Grails/grails_architecture.php

JAVA EE 7 et JSON

Nous sommes de plus en plus souvent amenés à échanger des données en JSON en remplacement de XML.

JSON est né avec AJAX et les Web Services REST dans le but d’obtenir un format d’échange simple et peu verbeux (à l’inverse du XML).

Pour plus de détails sur JSON voir l’article de Wikipedia ou pour les plus techniques le site json.org.

Mais Java ne permettait pas, jusqu’à peu, de traiter nativement des messages JSON.

La version 7.0 de Java EE intègre le support de la JSR 353 qui est l’API Java pour le JSON Processing (JSON-P) et définit l’API pour analyser, générer, transformer et requêter du JSON.

L’avantage de cette spécification est de standardiser le traitement des flux JSON en Java. Mais nous allons voir dans cet article si elle apporte suffisamment en comparaison de frameworks Java de traitement JSON tels que Gson, même pour des traitements très simples.

Nous créons un objet People qui nous permet de tester les différents cas (tableau, composition, …) :

public class People {
	
	private String name;
	private String firstName;
	private Date birthDate;
	private Address address;
	private List<PhoneNumber> phones;
	...

public class Address {
	
	private String addressStreet1;
	private String addressStreet2;
	private int addressNumber;
	private String zipcode;
	private String town;
	...

public class PhoneNumber {
	
	private String type;
	private String number;
	...

Création d’un jeu de tests :

		people = new People();
		Address address = new Address();
		address.setAddressNumber(12);
		...
		PhoneNumber mobilePhone = new PhoneNumber();
		...
		PhoneNumber workPhone = new PhoneNumber();
		...		
		people.setFirstName("Paul");
		people.setName("Dubois");
		...
		ArrayList<PhoneNumber> phones = new ArrayList<PhoneNumber>();
		phones.add(mobilePhone);
		phones.add(workPhone);
		people.setPhones(phones);
Données de test

JSON-P

JSON-P propose deux modèles de développement :

  • Le modèle objet crée un arbre qui représente les données JSON en mémoire (équivalent au DOM en XML).
  • Le modèle Streaming permet de parcourir un document JSON à partir d’évènements (début ou fin d’un objet ou d’un tableau, lecture d’une clé ou d’une valeur, …) (équivalent StAX en XML).

Les classes principale de l’API sont :

  • JsonObjectBuilder & JsonArrayBuiler : pour créer des objets ou tableaux JSON
  • JsonReader & JsonWriter : pour lire et écrire des objets JSON
  • JsonObject, … : réprésentation des types de données JSON
		JsonObjectBuilder jsonBuilder = Json.createObjectBuilder()
				.add("firstName", people.getFirstName())
				.add("name", people.getName())
				.add("birthDate", people.getBirthDate().toString())
				.add("address", Json.createObjectBuilder()
						.add("addressNumber", people.getAddress().getAddressNumber())
						.add("addressStreet1", people.getAddress().getAddressStreet1())
						.add("addressStreet2", people.getAddress().getAddressStreet2())
						.add("addressZipCode", people.getAddress().getZipcode())
						.add("town", people.getAddress().getTown())
						.build()
						);
		JsonArrayBuilder arrayBuilder = Json.createArrayBuilder();
		for (PhoneNumber phoneNumber : people.getPhones()) {
			arrayBuilder.add(Json.createObjectBuilder()
					.add("type", phoneNumber.getType())
					.add("number", phoneNumber.getNumber()));
		}
		
		jsonBuilder.add("phones", arrayBuilder);
		
		JsonObject jsonObject = jsonBuilder.build();
		
		StringWriter stWriter = new StringWriter();
		JsonWriter jsonWriter = Json.createWriter(stWriter);
		jsonWriter.writeObject(jsonObject);
		jsonWriter.close();
		
		String jsonData = stWriter.toString();
JSON-P

1 & 2 – Création du JsonObjectBuilder et ajout des propriétés simples.

5 – Ajout d’un objet Address à l’objet People

13 – Création d’un tableau pour représenter la liste de téléphone

22 – Création du JsonObject représentant notre People

25 & 29 – utilisation d’un JsonWriter pour représenter notre People sous forme de String

 

{
  "firstName": "Paul",
  "name": "Dubois",
  "birthDate": "Mon Jun 12 08:06:24 CEST 1978",
  "address": {
    "addressNumber": 12,
    "addressStreet1": "Rue de la République",
    "addressStreet2": "Immeuble des tests",
    "addressZipCode": "13001",
    "town": "Marseille"
  },
  "phones": [
    {
      "type": "mobile",
      "number": "0612345678"
    },
    {
      "type": "work",
      "number": "0412345678"
    }
  ]
}
Résultat JSON-P

 GsON

Gson est une librairie Java développée par Google pour transformer des objets Java vers leur représentation JSON et vice-versa.

Les objectifs principaux de Gson sont :

  • Fournir un mécanisme simple pour convertir un objet Java en JSON et vice-versa
  • Permettre de convertir des objets existants et non modifiables
  • Permettre d’obtenir une représentation personnalisée des objets

 

La classe principale de Gson est Gson. Elle permet de convertir très rapidement un objet Java en JSON :

		Gson gson = new Gson();
		gson.toJson(people);
Gson

Le code parle de lui-même…

{
  "name": "Dubois",
  "firstName": "Paul",
  "birthDate": "Jun 12, 1978 8:06:24 AM",
  "address": {
    "addressStreet1": "Rue de la République",
    "addressStreet2": "Immeuble des tests",
    "addressNumber": 12,
    "zipcode": "13001",
    "town": "Marseille"
  },
  "phones": [
    {
      "type": "mobile",
      "number": "0612345678"
    },
    {
      "type": "work",
      "number": "0412345678"
    }
  ]
}
Résultat Gson

Le résultat est sensiblement le même que pour JSON-P si ce n’est le formatage des dates différent.

Gson propose un mécanisme de Serializer et Deserializer personnalisé qui nous permet d’appliquer un formatage particulier à un type donné (Date par exemple) ou plus généralement une représentation particulière pour un objet.

L’exemple suivant montre la création d’un Serializer personnalisé :

public class PeopleSerialiser implements JsonSerializer<People> {
	public JsonElement serialize(People people, Type arg1,
			JsonSerializationContext arg2) {
		final JsonObject jsonObject = new JsonObject();
		jsonObject.addProperty("firstName", people.getFirstName());
		jsonObject.addProperty("name", people.getName());
		jsonObject.addProperty("birthDate", people.getBirthDate().toString());
		jsonObject.addProperty("addressNumber", people.getAddress().getAddressNumber());
		jsonObject.addProperty("addressStreet1", people.getAddress().getAddressStreet1());
		jsonObject.addProperty("addressStreet2", people.getAddress().getAddressStreet2());
		jsonObject.addProperty("addressZipCode", people.getAddress().getZipcode());
		jsonObject.addProperty("town", people.getAddress().getTown());

		final JsonArray jsonAuthorsArray = new JsonArray();
        for (final PhoneNumber phoneNumber : people.getPhones()) {
        	final JsonObject number = new JsonObject();
        	number.addProperty("type", phoneNumber.getType());
			number.addProperty("number", phoneNumber.getNumber());
            jsonAuthorsArray.add(number);
        }
        jsonObject.add("phones", jsonAuthorsArray);
		return jsonObject;
	}
}

1 & 2 : Notre Serializer implémente l’interface JsonSerializer et définit la méthode serialize qui prend notamment en paramètre un objet People pour renvoyer un JsonElement.

4 : La suite ressemble un peu à JSON-P avec la création d’un JsonObject qui est la représentation de l’objet en JSON (JsonArray pour les tableaux).

Dans cet exemple on construit une représentation de notre objet People en publiant une adresse « à plat » et non comme objet au sein de People.

		final GsonBuilder gsonBuilder = new GsonBuilder();
	    gsonBuilder.registerTypeAdapter(People.class, new PeopleSerialiser());
	    gsonBuilder.setPrettyPrinting();
	    final Gson gson = gsonBuilder.create();
	    gson.toJson(people);

Afin d’utiliser notre serializer on crée un GsonBuilder (1) auquel on passe notre serializer (2).

L’option setPrettyPrinting permet d’obtenir une représentation JSON formatée et indentée.

Puis cette fois on crée notre objet Gson grâce à la méthode create du GsonBuilder (4).

On obtient un résultat conforme à nos attentes :

{
  "firstName": "Paul",
  "name": "Dubois",
  "birthDate": "Mon Jun 12 08:06:24 CEST 1978",
  "addressNumber": 12,
  "addressStreet1": "Rue de la République",
  "addressStreet2": "Immeuble des tests",
  "addressZipCode": "13001",
  "town": "Marseille",
  "phones": [
    {
      "type": "mobile",
      "number": "0612345678"
    },
    {
      "type": "work",
      "number": "0412345678"
    }
  ]
}
Résultat Gson serializer

Conclusion

L’api JSON-P au sein de JEE7 est une vrai avancée car elle permet de traiter nativement du JSON. Mais le manque principal actuel est le binding natif d’un objet Java vers JSON.

On voit que dans le cas où on construit une API basée sur des échanges JSON et des objets métiers, l’utilisation de JSON-P sera bien trop verbeuse et on privilégiera l’utilisation de Gson (ou d’autres framework comme celui-ci) dont le coût de construction sera quasiment nul.

Dans le cas où l’on doit intégrer des messages JSON existants, la question se pose. Soit nos objets métiers n’existent pas et on va avoir tendance à utiliser Gson et le binding, soit nos objets métiers existent et la question se pose car la verbosité des deux API sera quasiment identique.

Il faudrait ensuite approfondir l’étude des deux sur des aspects tels que les performances pour faire son choix. Gson donne quelques indications à ce sujet (ici) mais un comparatif sur un même jeu de données serait intéressant.

Ce manque de binding a clairement été identifié par Oracle, notamment lors d’un sondage sur les nouveautés à apporter à JEE8. Une nouvelle JSR va être soumise d’ici peu pour intégrer une API Java JSON Binding à JEE8.

Prochains tests lors de la sortie de JEE8…

Loading...
X