Frameworks Maverick - JiBX
Sommaire
Framework Maverick
Logo de Maverick

Présentation

Maverick est un framework MVC utilisé pour les publications web utilisant Java et JEE. C'est un framework assez léger et simple qui permet de générer des présentations en utilisant des technologies avec modèles et transformations. Il qui est dit plus léger que Struts.

Les avantages de maverick sont :

Les inconvénients de maverick sont :

L'idée à retenir sur Maverick est qu'il est simple à utiliser et très orienté web. Par contre, il n'est pas simple à installer.



Fonctionnement

Maverick fonctionne avec un objet central : le Dispatcher. C'est lui qui reçoit les commandes, execute le controller lié à cette commande et affiche la vue souhaitée par le controller. C'est pour cette raison que dans le fichier web.xml, une seule servlet est définie, le Dispatcher.

Fichier web.xml :

	<servlet>
		<display-name>Maverick Dispatcher</display-name>
		<servlet-name>dispatcher</servlet-name>
		<servlet-class>org.infohazard.maverick.Dispatcher</servlet-class>
		<init-param>
			<param-name>reloadCommand</param-name>
			<param-value>reload</param-value>
		</init-param>
		<load-on-startup>2</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>dispatcher</servlet-name>
		<url-pattern>*.m</url-pattern>
	</servlet-mapping>
		

Pour lier les vues avec les controllers et les commandes, c'est un deuxième fichier xml, maverick.xml qui est utilisé. Il est dans le répertoire WEB-INF avec le fichier web.xml. A propos des commandes, il est à noter que, comme défini dans le fichier web.xml, les commandes sont suffixées de .m. Ainsi pour appeler la commande nommée commande1 dans le fichier maverick.xml, il faut utiliser commande1.m. Les commandes sont définies entre les balises <commands> et </commands> et les vues entre <views> et </views>. Il n'est pas obligatoire de définir les vues. Cela permet simplement dans la partie commandes de faire appel à elles sans avoir besoin de préciser leur path mais en utilisant l'attribut ref qui renvoie au nom de la vue défini dans la partie vues.

Fichier maverick.xml :

	<maverick version="2.0" default-view-type="document" default-transform-type="document">

	<views>
		<view id="test" path="test.jsp" />
		<view id="test2" path="test2.jsp" />
	</views>  

	<commands>
		<command name="commande1">
 			<controller class="controller.ViewController"/>
 
 			<view ref="test2"/>
 
 			<view name="success" path="test2.jsp">
				<transform path="test.jsp" />
			</view>
 		</command>
	</commands>

	</maverick>
		

Placez les fichiers maverick.jar, commons-logging-1.0.3.jar, jdom.jar dans le répertoire lib du projet dans WEB-INF. Il est à noter que les fichiers commons-beanutils.jar et commons-collections.jar peuvent être nécessaires selon l'utilisation de maverick. Les controllers utilisables avec Maverick sont disponible ici dans le package ctl. Ces classes ne sont pas des servlets, elles ne contiennent donc pas les méthodes doGet et doPost.
Alors comment récupérer les données de la requête? Ainsi :

	ControllerContext contexte = getCtx();
	HttpServletRequest requete = contexte.getRequest();
		
Et ainsi on récupère l'objet HttpServletRequest. Les controllers doivent décider quelles vues seront affichées, on utilise donc la méthode go() des controllers qui renvoit une chaine de caractères qui correspond au nom de la vue à afficher dans le fichier maverick.xml.
Maverick est un framework de transformation. Il permet aussi de transformer les jsp. Dans maverick.xml, on utilise les lignes suivantes :
	<command name="commande1">
		<controller class="controller.ViewController"/>

		<view ref="test2"/>

		<view name="success" path="test2.jsp">
			<transform path="test.jsp" />
		</view>
	</command>
		
Le fichier test.jsp contient le code suivant :
	<%@ taglib uri="http://java.sun.com/jstl/core" prefix="c" %>
	<a href="commande1.m">test</a>
	test
	<c:out value="${wrapped}" escapeXml="false" />
		
L'objet Dispatcher affichera test.jsp et remplacera la dernière ligne par le contenu de test2.jsp suite à la reception de la commande1. Toutefois lors de cette utilisation, vous risque d'obtenir une erreur de tld. Pour la résoudre il faut modifier la version de web-app dans le fichier web.xml et utiliser la valeur 2.3.


Bibliographie

Voici une liste de liens qui pourraient vous être utiles :


Framework JiBX

Présentation

JiBX est un Framework puissant permettant d’attacher de l’XML à du code Java et vice-versa. Il est très flexible et offre des performances exceptionnelles.

Les qualités de JiBX sont :
Il utilise des fichiers pour définir la façon d’attacher l’XML (respectivement le Java) au Java (respectivement au XML). Cela limite la production de classes intermédiaires et aide donc à la lisibilité du code et à la vitesse d’attachement.
Pour utiliser ce Framework il suffit de le télécharger et de le mettre dans le dossier adéquate . La configuration de fichier de description de l’attachement peut se faire manuellement ou on peut laisser le générateur le faire. JiBX est donc simple d’utilisation !
Contrairement aux autres Framework d’attachement XML JiBX n’est pas basé sur le parser (de type push parser) SAX2 mais sur un autre parser qui lui est de type pull parser. Cela rend possible a JiBX d’utiliser du code simple la ou les autres génèrent un code relativement compliqué.
Grace à l’utilisation d’un parser différent JiBX génère un code allégé autant au niveau du nombre de classes qu’au niveau de la taille des fichiers générés. Le diagramme ci-dessous, comparant plusieurs frameworks, le montre bien :
Comparaison de frameworks

Les défauts de JiBX sont :
JiBX est un peu compliqué à mettre en place. Il existe un plugin Eclipse mais nous n'avons pas compris où déposer les fichiers nécessaires au fonctionnement du framework. Autre problème, palié par l'utilisation du plugin Eclipse qui le fait automatiquement, toute modification du code d'une classe nécessite un nouveau binding.

Fonctionnement

L'utilisation de JiBX comporte principalement 2 étapes :

Le binding :
Pour toutes les commandes qui suivent, il sera nécessaire de récupérer jibx-1.2.1 et d'avoir accès au répertoire lib qui contient tous les .jar nécessaires.
Pour réaliser l'opération de binding, on peut créer son propre fichier de binding ou utiliser un schéma xml et à partir de celui-ci utiliser la commande : java -cp jibx-tools.jar org.jibx.schema.codegen.CodeGen fichier.xsd qui crée les classes Java et le fichier binding.xml liés au fichier schéma.
Dans le cas où on dispose déjà des classes Java et du fichier de binding binding.xml, on passe directement à cette étape. On compile ensuite les fichiers java : javac *.java.
On utilise ensuite la commande java -jar jib-bind.jar binding.xml qui crée les .class nécessaire au fonctionnement de JiBX en Runtime. Sans le plugin Eclipse, on utilise tous les .class qui ont été générés et on les copie dans le répertoire build/classes. Ensuite toute modification des fichiers java nécessitera de reprendre toutes les opérations.
Exemple :

	public class Customer {
		public Person person;
		public String street;
		public String city;
		public String state;
		public Integer zip;
		public String phone;
	}
	
	public class Person {
		public int customerNumber;
		public String firstName;
		public String lastName;
	}
		
Le fichier de binding :
	<?xml version="1.0" encoding="UTF-8"?>
	<binding>
	  <mapping name="customer" class="Customer">
		<structure name="person" field="person">
		  <value name="cust-num" field="customerNumber"/>
		  <value name="first-name" field="firstName" />
		  <value name="last-name" field="lastName" />
		</structure>
		<value name="street" field="street" />
		<value name="city" field="city" />
		<value name="state" field="state" />
		<value name="zip" field="zip" />
		<value name="phone" field="phone" />
	  </mapping>
	</binding>
		
Un fichier xml qui pourrait être utilisé pour le runtime serait alors :
	<?xml version="1.0" encoding="UTF-8"?>
	<customer>
	  <person>
		<cust-num>123456789</cust-num>
		<first-name>John</first-name>
		<last-name>Smith</last-name>
	  </person>
	  <street>12345 Happy Lane</street>
	  <city>Plunk</city>
	  <state>WA</state>
	  <zip>98059</zip>
	  <phone>888.555.1234</phone>
	</customer>
		

Le runtime :
Pour instancier les classes java depuis un fichier xml on utilise le code suivant :

		IBindingFactory bfact = BindingDirectory.getFactory(Carnet.class);
		IUnmarshallingContext uctx = bfact.createUnmarshallingContext();  
		Object obj = uctx.unmarshalDocument(new FileInputStream("carnet.xml"), null);
		Carnet carnet = (Carnet)obj;
	
Suite à cette opération, les cast peuvent être capricieux. Pour résoudre ces problèmes, on récupère dans un premier temps les données à caster dans un objet de type Object puis on caste cet Object, exemple :
		List<Utilisateur> listeUtilisateurs = new ArrayList<Utilisateur>();
		carnet = (Carnet)obj;
		obj = carnet.getUtilisateurs(); 
		listeUtilisateurs = (ArrayList<Utilisateur>)obj;
	
Pour créer le fichier xml depuis un objet Java, on utilise le code suivant :
		IBindingFactory bfact = BindingDirectory.getFactory(Carnet.class);
		IMarshallingContext mctx = bfact.createMarshallingContext();
		mctx.setIndent(4);
		mctx.marshalDocument(obj, "UTF-8", null, new FileOutputStream("carnetSave.xml"));
	

Bibliographie

Voici une liste de liens qui pourraient vous être utiles :

Présentation

Voici le lien pour la présentation :
ici

Exemple

Voici le lien pour un exemple d'utilisation des frameworks dans le cadre d'un module de gestion de contacts :
ici
Pour pouvoir l'utiliser, il faudra mettre le fichier xml dans le répertoire du serveur. Pour le connaitre exécutez :

		System.out.println(System.getProperty("wtp.deploy")+requete.getContextPath());