DarkVenoM

Generation de classes de méta-model

2010-05-30T02:38:00.000-07:00

L'un des apports les plus intéressants de JEE6 est sans aucun doute JPA 2, en effet cette version apporte une multitude de nouvelle fonctionnalité par rapport a JPA 1 afin d'accroitre la productivité des développeurs. Certes la plupart des nouveautés de JPA 2 sont des fonctionnalités qui existaient déjà dans Hibernate 3.3. Mais JPA2 a le mérite de standardiser la gestion de la persistance des objets Java et donc de faciliter la migration entres ORM. Une fonctionnalité qui m'a tout particulièrement plu dans JPA2 est l'utilisation de méta modèle, elle permet de ne plus référencer les champs des objets a persister dans les requêtes de types criteria avec des chaines de caractères, mais avec des classes un peu particulières appelées méta modèles. Je vous engage à lire la documentation d' Hibernate 3,5, d' EclipseLink et d' OpenJPA 2 pour plus d'information sur le sujet. Bien évidement ces classes doivent êtres crées a partir des classes des objets a persister. Bien évidement, il existe des outils pour générer automatiquement ces classes « méta modèles ». Bien évidement Hibernate 3.5, EclipseLink et OpenJPA 2 fournissent des outils pour générer ces classes.

N'étant pas un fan de JEE, j'ai pris l'habitude d'utiliser Spring, néanmoins je souhaite gérer ma persistance avec JPA2, j'ai donc tenté d'utiliser EclipseLink qui est censé être compatible. C'est probablement le cas mais j'ai été confronté a une anomalie (l'absence de génération automatique du schéma au démarrage du serveur ) lorsque j'ai voulu l'intégrer avec Spring, et je pense qu'il va falloir alourdir la configuration de l' ORM à cause du weaving ce qui ne m'enchante guère. Bref j'ai essayé d'intégrer Spring et Hibernate 3.5 , mais là j'ai été confronté a des anomalies assez étranges, morceau choisi : un ClassCastException, il n'arrivait pas à caster la classe PostgreSQLDialect en Dialect, c'est bête, la classe Dialect est la classe mère de PostgreSQLDialect, je soupçonne Hibernate 3.5 d'être incompatible avec Spring 3.0.2 . Par contre OpenJPA 2 a marché du premier coup, sans anomalie. Je ne vous le cache pas, jusqu'à présent je n'était pas un fan d' OpenJPA, a l'époque de JPA 1 cet ORM se contentait d'implémenter la norme et n'offrait pas toute les fonctionnalités d' Hibernate 3.3 et n'offrait pas non plus les performances de TopLink essentials et d' Hibernate. Je rajouterais que OpenJPA bien qu'il soit soutenu par la prestigieuse fondation Apache manque sérieusement de « street credibility » par rapport à ses concurrents, en effet, Hibernate a pour lui le fait d'avoir influencé JPA, on sait que sans Hibernate, JPA ne serait pas ce qu'il est aujourd'hui. Hibernate est de surcroit l' ORM Java le plus utilisé, je soupçonne en outre NHibernate d'être l' ORM .NET le plus utilisé. Faut-il le rappeler Hibernate est soutenu par Red Hat proclamé leader du middleware open source. EclipseLink a pour lui le fait qu'il soit soutenu par la fondation Eclipse (et donc probablement par IBM), qu'il est le cœur de TopLink (l' ORM d' Oracle), qu'il est donc soutenu par Oracle, il est de surcroit l'implémentation de référence de JPA 2. Voilà de quoi justifier la crédibilité d' Hibernate et d' EclipseLink. Cela dit, OpenJPA étant la seule implémentation de JPA que j'arrive a faire fonctionner simplement avec Spring 3 c'est dorénavant celle ci que je privilégierais.

OpenJPA 2 propose de générer ces classes de méta-modèle. L'inconvénient du générateur de classe d' OpenJPA 2 est qu'il génère les classes de méta-modèle dans le même package que les classes des objets a persister, en soit ce n'est pas dramatique, mais ça m'embête un peu. Les classes de méta-modèle font pour ma partie intégrante de la couche de persistance, on a besoin de ces classes uniquement pour faire des requêtes, ces classes ne devraient pas êtres accessibles en dehors des packages relatifs à la persistance. Vous l'avez compris je souhaite que le générateur d' OpenJPA 2 puisse générer les classes dans un autre package. Cet ORM étant libre j'ai donc téléchargé le code source et je l'ai modifié afin qu'il puisse prendre en compte cette fonctionnalité. Cela se fait en rajoutant a la commande de génération le paramètre -Aopenjpa.destpackage=nom.du.package.

Vous pouvez télécharger ce générateur sur ce lien : (n'hésitez pas à me contacter si le lien ne marche plus)

http://www.megaupload.com/?d=J479TUTT

Cette jeune demoiselle...

2010-03-13T03:20:00.001-08:00

Cette jeune demoiselle que je ramasse chaque trimestre à la petite cuillère, je ne peux m'en défaire. Je me fait un plaisir de sécher ses larmes, de lui redonner confiance en elle, de lui faire comprendre qu'elle vaut plus que c'est qu'elle croit valoir. Je l'aide dans ses conquêtes et sans trop le vouloir, je fini par en faire parti, je deviens alors le calineur, puis l'officiel. Je la connais par cœur, je lis dans ses yeux comme dans un livre, je me méfie d'elle parce qu'elle me connait bien elle aussi, mais pas autant que je ne la connais. Elle me considère comme l'homme parfait, on se connait depuis quelques années, je ne sais pas si c'est moi qui a évolué jusqu'à correspondre a ses critères, ou si c'est elle qui a modifié les siens pour que j'y corresponde. Peut-être que j'y ai toujours correspondu dans le fond. Elle voit en moi des qualités que nulle autre n'a pu voir jusqu'à présent. On semble faut l'un pour l'autre et pourtant, je me suis échappé. Je l'ai laissé seule, je me suis arrangé a ce qu'elle ne souffre pas trop. Je ne voulais pas ou plus être dépendant d'elle, je voulais pouvoir me convaincre que je pouvais vivre sans elle, je me suis en quelque sorte désintoxiqué d'elle. Durant l'année qui a suivi je ne suis sorti qu'avec des femmes qui lui ressemblait, comme celle ci qui est grande avec un teint halé, celle là qui a la même coupe de cheveux, l'autre qui à la même voix qu'elle, ou encore celle ci qui avait les même passion qu'elle. Tout se ramenait à elle. Inconsciemment je la recherchait à travers toute mes conquêtes, et je ne trouvais que des parties d'elle. Inconsciemment je comparais toute les femmes que je rencontrais à elle, elle était pour moi la femme parfaite, aucune autre ne m'a enivré autant qu'elle. En totale contradiction, je recherchais l'addiction, celle la même que j'ai fuit un an plus tôt.

La femme lapin

2010-03-13T02:07:00.001-08:00

Elle est plutôt jolie, assez timide, elle garde ses distance. Elle se méfie de presque tout le monde. Regardez-la mais ne la touchez pas, ne lui parlez pas, d'ailleurs ne la regardez pas trop, ça la met mal à l'aise. Elle parle très peu, ne s'éloigne jamais de ceux qu'elle connait. Elle est plutôt sobre et elle fait tellement d'effort pour être discrète qu'elle finit malgré elle par se faire remarquer.

Bloody Mary

2010-02-27T04:42:00.001-08:00

Cela fait bien longtemps que je raffole de violence musicale, de colère sonore, d’ondes mécaniques aussi rageuses que progressives, peut être depuis Nirvana. Friand de gourmandises métalliques ou hardcore, je me suis orienté vers la musique du groupe Cursed. Encore une sommité musicale que je n'ai pu connaître avant son split. Je commence donc par le titre « Bloody Mary », lors de son audition, je ressens une légère sensation d’oppression. J'ai l'impression de basculer 5 6 ans en arrière. La colère du chanteur est assez banale pour un groupe affilié au punk au hardcore et au metal, mais ça voix a un petit quelque chose qui fait la différence. Il y a comme une densité musicale, le son a une ténébreuse texture. Puis la rythmique ralentit. Les riffs semblent plus plombant. I KNOW IT'S WROOOOONG ! Rythmique punk puis crust, les riffs semblent s'éclaircir tout en étant pachydermiques, les hurlements deviennent plus aigu, plus furieux. Je me sens vibrer, je me sens habité, je suis off, je sens le désespoir et la démence du vocaliste. C'est pour ces sensations là que j'écoute des musiques extrêmes. Rares sont les chansons qui ont un tel effet sur moi.

Ce matin un gamin a buté un prof

2010-02-20T02:57:00.000-08:00

Ce matin un gamin a buté un prof. La victime était excédée de subir les humiliations répétées de ses enseignants, qui étaient bien souvent suivi des brimades de ses camarades. La victime semblait douter de la faculté de ses enseignants à pouvoir les faire ingurgiter la totalité du programme au cours de l'année scolaire, et ne semblait pas comprendre pourquoi ils s'évertuaient à perdre un temps précieux sur des remontrances d'une demi heure ou sur des activités ni ludiques ni instructives. Le coupable était quadragénaire, semblait faire son travail comme il se doit, des témoignages d'anciens élèves relatent qu'il avait une appétence particulière pour les remontrances, il jouissait de sa supériorité, ils projetaient les craies sur la figures des bavard, tirait les cheveux des rebelles et giflait les rebelles qui avaient le malheur d'avoir des fibres capillaires trop courtes. Il faisait passer au tableau ceux qui étaient incapable de faire les exercices correctement, et plutôt que de faire son travail, d'être pédagogue, il prenait un plaisir sadique à humilier sa victime, le supplice morale pouvait durer une heure, une heure durant laquelle la victime subit, une heure durant laquelle le reste de la classe à défaut de s'instruire regarde le spectacle. Le coupable aimait particulièrement faire passer après « les branleurs » comme ils les appelaient un « bon » qui allaient « torcher » l'exercice avec célérité, cela lui permettait de conclure son humiliation par une comparaison qui allait enfoncer un peu plus la victime (le « branleur »), et peut importe si cette façon de faire poussaient les élèves à se haïr les uns les autres. Lorsque la victime récite son cours, le coupable appelle ça du baratin, lorsque la victime tente de se justifier, de s'expliquer, le coupable appelle ça de l'insubordination, chose qui se finit assez souvent dans le bureau de la principale ou du proviseur. Le coupable se plaisait à insulter la victime, sachant pertinemment que la victime ne pouvait pas répliquer, a moins bien sur de vouloir une nouvelle fois rendre visite au proviseur... La victime loin d'être exempt de tout défaut se soulageait en dégradant le véhicule de son bourreau. Le coupable dans les conseils de classe accablait sa victime (bien qu'elle soit absente), préconisait des voies de garages pour elle, en dépit de l'avis de ses collègues. Il ne faut pas croire que le coupable haïssait tous les mauvais élèves et seulement les mauvais élèves (du moins ceux qu'ils considéraient comme tel), il aimait beaucoup certaines personnes, et savait être pédagogues avec elles, il n'hésitait pas à les défendre dans les conseils de classes, à appuyer leurs candidatures pour des filières prestigieuses. Et comme on le sait tous l'affection et l'aversion peuvent être inconditionnelles, et si il lui arrivait de prendre pour des « branleurs » des élèves moyens, il lui arrivait aussi de soutenir des mauvais élevés en dépit de la motivation de ces derniers. Ce matin la victime s'est juré de pourfendre le coupable, ce matin le « branleur » a voulu mettre un point final à ses humiliations, ce matin le gamin a voulu rivaliser, se défaire de son complexe d'infériorité. Ce matin un coupable est mort, lacéré par des coups de couteaux. On dit que la victime s'est acharnée pendant un quart d'heure sur le coupable, ce sont les professeurs des salles d' a cotés et les pions qui ont arrêté le massacre, trop tard... La victime semblait incontrôlable, ils n'étaient pas trop de trois pour empêcher la victime d'exercer son action macabre. On entendit la victime hurler tout comme le coupable, des insultes ont figés dans les deux sens, des pleurs aussi, le coupable a malgré tout supplié la victime de l'épargner... Sans succès. La victime avait le regard lumineux, de son regard jaillissait une haine sans limite, c'est à se demander si elle prenait plaisir a voir le coupable se noyer dans son propre sang. La victime sera considéré comme folle, passera les trente prochaines années de sa vie en prison, le coupable sera incinéré, sa dépouille étant trop dégradée pour être mise dans un cercueil.

Tenebris

2010-02-20T02:09:00.000-08:00

J'étais encore lycéen, j'aimais beaucoup le quartet americano-armenien de la cité des anges, mais je recherchais plus, plus de violence, plus de rapidité, de brutalité. Je voulais savoir si j'étais capable d'écouter de la musique encore plus bourrine. J'avais déjà tenté d'écouter des morceaux de l'hydre à 9 têtes d' Iowa, je n'avais pu entendre que du bruit, je pensais que ce groupe représentait la limite de l'audible que mes oreilles ne sauraient franchir. J'avais malgré tout pu me rendre compte chez un ami, que le vocaliste de la formation de Des Moines était capable de chanter avec une voix claire, ce qui rendait la musique du groupe nettement moins bruitiste. Un soir je me senti prêt à subir l'épreuve du groupe au nœud coulant, je tentât l'expérience seul dans ma chambre, il faisait nuit, les premiers sons que j'entendis fut des hurlements bizarres, presque inquiétant, des sonorités étranges, puis du bruit, je n'étais pas vraiment surpris de percevoir ainsi la musique du groupe d' Iowa, mais j'étais surpris de ne plus être brutalisé, de pouvoir écouter ce son sans souffrance, j'étais passé du stade de l'asphyxie musicale au stade de l'apnée musicale. Plus surprenant encore, je percevais une colère incontrôlée car tout simplement incontrôlable, une rage presque inexplicable, une haine absolue, un véritable chaos , une noirceur que les chants clairs parvenait difficilement à éclaircir. J'avais gouté à l'obscurité, je ne pourrais désormais plus m'en passer.

GWT et Spring

2009-11-28T09:46:00.000-08:00

Je n'ai jamais pu utiliser GWT dans un cadre professionnel, mais le peu de fois que j'ai pu le tester à titre personnel, j'en ai été pleinement satisfait. Je dois vous l'avouer, je n'aime pas flash et Silverlight, et ce, en tant qu'utilisateur. Les sites en Flash sont souvent lourds, lents, et gourmands en mémoire et en CPU. Alors certes sans ces plugins, la vidéo et la musique sur le net n'aurait pas l'essor que l'on connait. Mais j'avoue avoir une nette préférence pour les sites utilisant ces plugins avec parcimonie. Quoiqu'en dise les benchmarks, l'ajax donne une impression de légèreté que je peine a retrouver avec le flash et silverlight. Malgré tout je dois reconnaître que programmer en Javascript est vraiment chiant, je trouve ça nocif pour la productivité. Il faut jouer avec le respects des standards et les performances des différents navigateurs. Alors certes, il y a pleins de librairies permettant de faire de jolis sites en ajax et qui sont compatibles avec la plupart des navigateurs (même Internet Explorer 6!!), mais pour les utiliser il faut quand même coder en Javascript pour les utiliser. Je ne sais pas comment vous (chers lecteurs) faites vos sites web, mais moi je n'utilise le Javascript uniquement pour la vu, le reste est fait en Java ou en .Net. Du coup ça m'oblige a écrire du code Javascript dans une String Java ou au sein d'une page JSP... Il faut aussi formater les données pour les envoyer du serveur au clients, et si vous avez quelques notions d' ajax vous savez que ça se fait en XML. Il faut donc depuis le code Java générer du XML, ça implique de passer du temps pour bien former son code XML (qui est bien souvent présent dans le code Java sous forme de String...) afin que la partie cliente en Javascript puisse correctement l'interpréter. Le typage faible de Javascript n'arrange en rien les choses. J'ai pu travailler sur des sites utilisant, Javascript, Silverlight et Flex. Et si l'internaute que je suis n'est pas fada de Flash et Silverlight, le programmeur que je suis les préfèrent largement au Javascript. Ne serait-ce que pour s'épargner le formatage des données nécessaires à la communication du serveur vers le client. Dans le cas de Flex c'est entre autre BlazeDS qui nous facilite les communications, il nous permet d'appeler des méthodes Java depuis du code Flex comme si il s'agissait que code ActionScript. Problème, lorsque le passe des objets en paramètres a ces méthodes ou que l'on veut récupérer les objets renvoyés par la méthode, on doit les déclarer en ActionScript presque comme s'il il s'agissait d'objets ActionScript à part entière. Certes ce n'est ni trop long ni trop compliqué, mais on se passerait bien de le faire. De plus, je n'ai pas retrouvé d'environnement de développement intégré offrant les même fonctionnalités aux développeurs ActionScript (et Flex de manière générale) qu' Eclipse pour les développeurs Java. Non, FlexBuilder ne m'a pas convaincu.

Je dois avouer GWT a quelques avantages qui font défauts aux outils précédemment cités. Tout d'abord le code généré est en Xhtml et Javascript, donc on s'épargne la lourdeur relative de Flash et Silverlight. D'un autre coté, lorsqu'on utilise GWT on code en Java, cela permet donc d'utiliser son EDI Java habituel (au moins Eclipse et Netbeans) et de jouir de la productivité qui en découle.

S'agirait-il du cadriciel parfait pour l' IHM ? Pas tout a fait, pour chaque service, 2 deux interfaces et une classe doivent êtres implémentés, le service doit en plus être référencé dans le fichier « web.xml ». Alors certes, si vous utilisez Eclipse, l'interface asynchrone est généré à partir de l'autre interface, mais ils vous devez quand même référencer votre service dans le « web.xml » qui va vite devenir volumineux. De plus si GWT résout pas mal de problème au niveau de l' IHM il ne fait rien pour la persistance de données, rien pour implémenter le motif MVC, et il me semble qui ne fait pas grand chose non plus pour gérer les transactions. Bref, une application web écrite en Java ne peut se contenter de GWT elle devra en plus disposer d'un ORM comme EclipseLink ou Hibernate et d'un cadriciel comme Spring. Si la documentation de Seam nous montre qu'il peut interagir avec GWT, il n'en est rien pour Spring, il va donc falloir faire du bidouillage pour faire fonctionner les deux de concert. Certaines personnes l'ont déjà fait, et ça fonctionne pas trop mal :

http://docs.google.com/Doc?docid=dw2zgx2_25492p5qxfq&hl=en

http://technophiliac.wordpress.com/2008/08/24/giving-gwt-a-spring-in-its-step/

L'inconvénient de ces deux approches (très similaires...) et qu'elles s'appuient sur une configuration des services dans les fichiers XML de Spring. Alors certes nos classes qui implémentent les services ne sont plus obligées d'hériter de la classe RemoteServlet, on peut donc câbler GWT a du code existant, mais bon, le fait de passer par des fichiers XML nuit à la productivité et risque de provoquer des conflits au sein des gestionnaires de configuration (en effet, un fichier est édité par plusieurs personnes a de grande chance de causer des conflits). C' est d'autant plus dommage de passer par des fichiers XML pour configurer les dépendances entre les différents beans qu'il existe une alternative crédible : les annotations.

La solution que je vous propose repose sur le même principe que les deux précédentes, Spring va intercepter toutes les requêtes du client vers le serveur. Ceci va nous éviter de déclarer chaque service dans le " web.xml ". Notre fichier " spring-servlet.context.xml " qui contient toute notre configuration Spring. Il est très bref, il contient la déclaration de deux beans du cadriciel Spring, une balise lui disant que nous allons utiliser les annotations, et une autre lui disant dans quel package il va trouver les classes annotées. En utilisant Spring ainsi, le fichier " spring-servlet.context.xml " ne devrait pas changer au cours d'un projet, ou alors très rarement.

Nous allons nous aussi utiliser la pièce maitresse des deux méthodes d'intégration avec Spring précédemment citées : la classe "GwtRpcController". Cette classe change un peu, elle devient abstraite et utilise un accesseur abstrait pour accéder au " RemoteService ". Il n'y a pas d'accesseur pour accéder a la classe de RemoteService, parce que c'est tout simplement inutile, un simple "getClass() " fait la même chose. Cette classe ne pouvant être instancié elle n'est jamais utilisée directement par Spring. Pour chaque service nous allons créer des contrôleurs Spring héritant de la classe "GwtRpcController ". Le but des contrôleurs dans notre application est d'associer une URL à une classe service (implémentant l'interface " RemoteService "). Chaque contrôleur utilisera donc l'annotation "@ RequestMapping " pour s'associer à une URL et se fera injecter une instance de la classe de service par l'annotation " @Ressource ", c'est cette même instance qui sera retournée par l'accesseur " getRemoteService ()". Vous devinez déjà les obligations auxquelles doivent se soumettre nos classes de services, elle doivent bien évidement implémenter l'interface RemoteService (ce qui n'est pas vraiment une contrainte) et elle doit être annotée afin d'être un bean Spring.Je crois que cette dernière obligation est de loin la plus restrictive... Dans cette solution j'ai voulu faire en sorte à ce que l'on ai besoin d'écrire le moins de code XML possible, mais j'admets que ce que l'on écrit pas en XML au final, on l'écrit en Java. Finalement l'intégration de Gwt avec Spring est tellement simple que l'on se demande à quoi servent les cadriciels qui prétendent le faire à notre place.

QuoteService.java :

package com.example.integration.client;

import com.google.gwt.user.client.rpc.RemoteService;

import com.google.gwt.user.client.rpc.RemoteServiceRelativePath;

@RemoteServiceRelativePath("quote.rpc")

public interface QuoteService extends RemoteService {

public String getQuote();

}

QuoteServiceAsync.java :

package com.example.integration.client;

import com.google.gwt.user.client.rpc.AsyncCallback;

public interface QuoteServiceAsync {

void getQuote(AsyncCallback callback);

}

Integration.java :

package com.example.integration.client;

import com.google.gwt.core.client.EntryPoint;

import com.google.gwt.core.client.GWT;

import com.google.gwt.user.client.Timer;

import com.google.gwt.user.client.rpc.AsyncCallback;

import com.google.gwt.user.client.ui.Label;

import com.google.gwt.user.client.ui.RootPanel;

public class Integration implements EntryPoint {

private static final String SERVER_ERROR = "An error occurred while "

+ "attempting to contact the server. Please check your network "

+ "connection and try again.";

private final GreetingServiceAsync greetingService = GWT

.create(GreetingService.class);

public void onModuleLoad() {

final Label quoteText = new Label();

Timer timer = new Timer() {

public void run() {

// create an async callback to handle the result:

AsyncCallback callback = new AsyncCallback() {

public void onFailure(Throwable t) {

// display error text if we can't get the quote:

quoteText.setText("Failed to get a quote");

}

public void onSuccess(String result) {

// display the retrieved quote in the label:

quoteText.setText(result);

}

};

QuoteServiceAsync service = (QuoteServiceAsync) GWT.create(QuoteService.class);

service.getQuote(callback);

}

};

timer.scheduleRepeating(3000);

RootPanel.get().add(quoteText);

}

Integration.gwt.xml :

<>DOCTYPE module PUBLIC "-//Google Inc.//DTD Google Web Toolkit 1.7.1//EN" "http://google-web-toolkit.googlecode.com/svn/tags/1.7.1/distro-source/core/src/gwt-module.dtd">

<entry-point class='com.example.integration.client.Integration'/>

</module>

GwtRpcController.java :

package com.example.integration.server;

import javax.servlet.ServletContext;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.context.ServletContextAware;

import org.springframework.web.servlet.ModelAndView;

import org.springframework.web.servlet.mvc.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import com.google.gwt.user.client.rpc.IncompatibleRemoteServiceException;

import com.google.gwt.user.client.rpc.RemoteService;

import com.google.gwt.user.client.rpc.SerializationException;

import com.google.gwt.user.server.rpc.RPC;

import com.google.gwt.user.server.rpc.RPCRequest;

import com.google.gwt.user.server.rpc.RemoteServiceServlet;

public abstract class GwtRpcController extends RemoteServiceServlet implements

Controller, ServletContextAware {

private ServletContext servletContext;

@RequestMapping(method = RequestMethod.POST)

public ModelAndView handleRequest(HttpServletRequest request,

HttpServletResponse response) throws Exception {

super.doPost(request, response);

return null;

}

@Override

public String processCall(String payload) throws SerializationException {

try {

RPCRequest rpcRequest = RPC.decodeRequest(payload,

getRemoteService().getClass());

// delegate work to the spring injected service

return RPC.invokeAndEncodeResponse(getRemoteService(), rpcRequest

.getMethod(), rpcRequest.getParameters());

} catch (IncompatibleRemoteServiceException ex) {

getServletContext()

.log(

"An IncompatibleRemoteServiceException was thrown while processing this call.",

ex);

return RPC.encodeResponseForFailure(null, ex);

}

@Override

public ServletContext getServletContext() {

return servletContext;

}

public void setServletContext(ServletContext servletContext) {

this.servletContext = servletContext;

}

public abstract RemoteService getRemoteService();

}

QuoteController.java :

package com.example.integration.server;

import javax.annotation.Resource;

import org.springframework.stereotype.Controller;

import org.springframework.web.bind.annotation.RequestMapping;

import com.google.gwt.user.client.rpc.RemoteService;

@Controller

@RequestMapping("/integration/quote.rpc")

public class QuoteController extends GwtRpcController {

@Resource

private RemoteService quoteService;

@Override

public RemoteService getRemoteService() {

return quoteService;

}

QuoteServiceImpl.java :

package com.example.integration.server;

import java.util.ArrayList;

import java.util.List;

import java.util.Random;

import org.springframework.stereotype.Service;

import com.example.integration.client.QuoteService;

@Service("quoteService")

public class QuoteServiceImpl implements QuoteService {

private Random randomizer = new Random();

private static List quotes = new ArrayList();

static {

quotes.add("No great thing is created suddenly - Epictetus");

quotes.add("Well done is better than well said - Ben Franklin");

quotes.add("No wind favors he who has no destined port - Montaigne");

quotes.add("Sometimes even to live is an act of courage - Seneca");

quotes.add("Know thyself - Socrates");

}

public String getQuote() {

return quotes.get(randomizer.nextInt(quotes.size()));

}

Web.xml:

<>DOCTYPE web-app

PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"

"http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>

<servlet-name>springservlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>

<load-on-startup>1load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>springservlet-name>

<url-pattern>*.rpcurl-pattern>

</servlet-mapping>

<welcome-file-list>

<welcome-file>Integration.htmlwelcome-file>

</welcome-file-list>

</web-app>

spring-servlet.xml:

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:p="http://www.springframework.org/schema/p"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-2.5.xsd">

<context:component-scan base-package="com"/>

<context:annotation-config/>

</beans>

pom.xml:

<modelVersion>4.0.0modelVersion>

<groupId>IntegrationgroupId>

<artifactId>IntegrationartifactId>

<packaging>warpackaging>

<version>0.0.1-SNAPSHOTversion>

<groupId>org.springframeworkgroupId>

<artifactId>spring-webmvcartifactId>

<version>2.5.6.SEC01version>

Integration.html :

<>DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<head>

<title>Web Application Starter Projecttitle>

<head>

<body>

<h1>Web Application Starter Projecth1>

<tr>

<td colspan="2" style="font-weight:bold;">Please enter your name:td>

<tr>

<tr>

< table>

<body>

<html>

Scolaire

2009-11-21T15:00:00.000-08:00

L'autre jour, je discutais persistance avec mes collègues, je leur recommandais l'utilisation d' Hibernate avec les annotations en lieu et place des fichiers de mapping XML pour plusieurs raisons :

- Lorsque l'on rajoute ou qu'on enlève un champ dans une classe dont les instances sont censé à être persistées, on a moins de chance d'enlever ou de rajouter les annotations nécessaires. En effet, lorsque l'on supprime un champ d'une classe on peut difficilement oublier de supprimer l'annotation juste au dessus (si elle existe). Lorsque l'on rajoute un champ, on se rend rapidement compte que les autres sont annotés, donc on pense à annoter le nouveau champ. De plus dans des cas simples le nouveau champ est automatiquement pris en compte dans la persistance. Les manques de synchronisations entre les classes et les fichiers de mapping correspondant arrivent régulièrement. Donc moins d'erreurs.

- Les fichiers de mapping sont assez chiants à remplir, et honnêtement je pense qu'il est plus facile et plus rapide de rendre une classe persistable avec des annotations qu'avec les balises XML. De plus dans les cas relativement simples (on ne cherche pas a nommer les champs, ni à borner les chaines de caractères etc.) on n'utilise que deux annotations, une pour la classe et une autre pour l'identifiant. Donc plus de productivité.

- Les annotations sont utilisées dans JPA ce qui signifie qu'en utilisant des annotations on peut passer plus ou moins facilement à un autre ORM si c'est nécessaire. Donc plus d'indépendance.

Mes collègues, eux n'étaient pas convaincu et pour deux raisons :

- Persistance ignorance.

- Les annotations c'est moche. Cela nuit à la lisibilité du code.

Ok...

Effectivement les annotations lorsqu'elles sont nombreuses ne sont pas sexy mais bon, nous sommes des informaticiens pas des artistes (tous mes collègues n'en sont pas convaincus...), plus un fichier de mapping n'a absolument rien de beau. Sur le fait que ça nuit à la lisibilité du code, certes ça rajoute des lignes de code à la classe persistée mais pas tant que ça, et puis pour avoir utilisé (contrairement à eux) les annotations dans le cadre d'un projet JEE5 (avec un vrai client et tout !!) j'avoue n'avoir jamais été gêné par ça, pareil pour les gens avec qui je travaillais. D'ailleurs je vois mal comment les annotations JPA pourraient me ralentir dans la compréhension des classes persistées ainsi que dans la maintenance de celles-ci.

Pour ce qui est de la persistance ignorance, j'ai halluciné, cet argument qui n'en est pas vraiment un, brandi tel un bouclier face à quelque chose que mes collègues ne connaissent pas : les annotations.

Tout d'abord, c'est quoi la persistance ignorance ? C'est le fait de dire qu'une classe qui doit être persistée ne doit pas embarquer d'information permettant de savoir si et comment elle est persistée. Quel sont les buts de la persistance ignorance ? De faire en sorte a ce que les changements de la couche de persistance n'impactent pas les classes censées êtres persistées (qui sont souvent dans le domaine). De faire en sorte à ce que la compréhension du domaine n'implique pas de maitriser le fonctionnement de la couche de persistance. Je précise que ce n'est pas eux qui m'ont expliqué ce qu'était la persistance ignorance.

En quoi la persistance ignorance est débile ? Il y a un gros couplage entre les classes (du domaine) qui vont être persistées et la manière dont elles vont l'être. Si vous rajoutez un champ à une classe il y a des chances que ce champ doit être persisté. Si vous supprimer un champ, ce champ ne doit plus être persisté. Toute modification des champs d'une classe implique une modification dans la couche de persistance. Donc oui je trouve très débile (pour ne pas dire con...) de cacher au développeur ce couplage. Au final c'est un peu comme du code dupliqué une modification à un endroit implique souvent une modification à un autre endroit, sauf que cet endroit on ne sait pas toujours où il est. L'approche souvent employé pour lutter contre la duplication de code est de factoriser le code, afin que lorsque l'on effectue une modification à un endroit on n'ait pas besoin de la faire ailleurs. Je pense au contraire qu'en dépit de certains principes scolaires et théorique d'architecture il faut être franc avec le développeur : « Hey, cette classe est persistée n'oublie pas de mettre à jour les informations concernant la persistance !! » plutôt que : « Non, qu'est-ce que tu me racontes là ? Cette classe n'est pas persistée ! (10 minutes plus tard le développeur se rend compte d'une erreur à l'exécution) Hein ? Quoi ? Hibernate t'as lancé une erreur ? Ah ben désolé... ».

J'ai tenté de leur expliquer qu'en utilisant les annotations, une modification de la couche de persistance impliquerait dans le pire des cas une modification des annotations elles même, mais pas de la classe, puisque les champs et les méthodes ne dépendent pas de la couche de persistance. Et que donc, une modification de la couche de persistance n'aurait aucun impacte sur nos vues, nos contrôleurs, nos services etc... Ils n'ont rien voulu savoir. Je pense que leur problème c'est d'être trop scolaire, c'est paradoxal car la plupart ont quittés les bancs de la fac et des écoles d'ingénieurs il y a bien longtemps (plus que moi en tout cas). En fait ils appliquent de « grands » (?!!) principes théoriques sans les comprendre et sans vraiment savoir les appliquer. C'est un peu comme « Jacadi à dit » sauf que là Jacadi est un professeur d'architecture logicielle.

Cocu

2009-10-17T08:42:00.000-07:00

"Le célèbre rapport Hite3 indique qu'aux États-Unis, 70 % des femmes ayant plus de cinq ans de mariage déclarent avoir été infidèles au moins une fois, et 72 % des hommes."

Ne quitte jamais la personne que tu aimes pour la personne qui te plais car celui qui te plais te quittera pour la personne qu'elle aime. Trompe plutôt la personne que tu aimes avec celle qui te plait, parce que la personne que tu aimes te trompera avec celle qui lui plait.

...

2009-10-09T14:40:00.000-07:00

Parfois j'ai du mal à comprendre mes semblables, quand je vois le nombre de personnes qui ont pleurés la mort de la personne qui prétendait être le roi de la pop... Les soupçons de pédophilie dont il a été victime n'a pas l'air d'avoir surpris grand monde, alors certes il n'y a pas de preuve formelles et encore moins de jugement qui a été rendu, et pour cause, il a payé les « victimes » (qui n'en sont pas puisque le jugement n'a pas vraiment été rendu) pour qu'elles arrentent leur poursuites... L'interview vidéo que j'ai vu où il se défend de ces accusations ne m'a pas convaincu, sa manière de tenir la main de certains garçons pendant l'interview encore moins. Mais bon, tout le monde s'en bas les couilles, c'est le chanteur de «thriller», il fait de la bonne musique (je me méfie de la sincérité des propos des gens qui écoutent sa musique en boucle depuis qu'il est mort), il fait du moonwalk et tout.

La encore un réalisateur de films a cavalé pendant près de trente ans pour fuir à la justice américaine, ce réalisateur est soupçonné (enfin très fortement soupçonné) de pédophilie, il a récemment été arrête. On se dit que s'il est innocent il pourra enfin le prouver (il avait 30 ans pour le faire quand même...), et que s'il est coupable il sera enfin jugé. Quoiqu'il en soit il a été soutenu par des ministres (le ministre de la culture entre autres) et différentes personnalités du monde du cinéma. Je dois avouer qu'en lisant la liste des gens qui le soutiennent, certains réalisateurs, acteurs et producteurs ont sérieusement baissé dans mon estime, mais cela n'a pas d'importance. Encore une fois peut importe ce qu'il ait fait par le passé, il a réalisé des putains de films, c'est tout ce qui compte.

Ce ministre de la culture qui a soutenue le réalisateur est au cœur d'un scandale a base de soupçon de tourisme sexuel et de pédophilie a Bangkok (donc en Thaïlande). Que le ministre aille se soulager avec des péripatéticiens, c'est drôle, surprenant, mais pas franchement choquant. Cela aurait été au bois de Boulogne ou en hollande, ça aurait été juste cocasse. Le fait que ce soit a Bangkok, fait naitre des soupçons de pédophilie. En effet, pourquoi aller a l'autre bout du monde pour faire l'amour avec des « personnes consentantes de son âge (a cinq ans près)» alors qu'il en existe dans notre beau pays et dans les pays voisins ? Peut-être pour aller chercher de l'exclusivité, pour trouver quelque chose qui ne se fait pas sur place... Voyez-vous, je me méfie autant des gens qui vont faire du tourisme en Thaïlande que de ceux qui vont en faire Hollande. Honnêtement je n'ai jamais mis les pieds dans aucun de ces deux pays, il y a certainement pleins de choses intéressantes a découvrir. Je ne doute pas que des gens aillent en Hollande uniquement pour apprendre la langue du pays, manger du fromage et découvrir une autre culture. Je ne doute pas que des gens aillent en Thaïlande pour découvrir une végétation luxuriante, une nouvelle culture, s'initier ou se perfectionner au muay thaï. Mais j'ai toujours des doutes. Alors oui, j'imagine que la passe d'un prostitué thaïlandais est moins chère que celle de son confrère français, mais je ne pense pas que notre cher ministre de la culture soit à ça près. Il possède une excellente répartie, et se réjouit d'être la cible d'un célèbre partie d'extrême droite français. Alors certes, recevoir le crachat de ces dernier peut être un honneur dans bien des cas, mais pas lorsqu'on est suspecté de pédophilie... Je ne doute pas que les partis politiques qui hurlent au scandale ne le fassent pas que par morale et éthique mais aussi pour assouvir des fins bassement politiques. Dans tous les cas, je ne suis pas convaincu par sa défense, comment pourrais-je l'être ? Et je comprends mieux pourquoi il a pris la défense du réalisateur donc j'ai parlé plus haut.

Je ne comprends pas que l'on puisse défendre ces personnes, certes, dans tous les cas il n'y a aucune preuve formelle de culpabilité. Aucune preuve formelle d'innocence ou d'alibi en béton. Je pense que dans ces cas, on n'a ni a faire a des innocents, ni des coupables, mais a des douteux, et je suis désagréablement surpris que des gens accordent autant de crédit à ces douteux. Qu'ils attendent dans le cas du réalisateur, qu'un procès le déclare innocent. J'ai l'impression que lorsque certaines personnes ont atteints de hauts postes ou un certain niveau de notoriété, l'image qu'ils sont aux yeux des gens devient intouchable, invulnérable, comme si les gens pouvaient tout leur pardonner.

Grand prix

2009-09-27T04:07:00.000-07:00

C'est comme un grand prix, beaucoup iront faire un tour sur la piste de danse, mais très peu monteront sur le podium. Régulièrement, ils s'arrêteront au bar faire leur ravitaillement, certains repartent plus chargés que d'autres, tout dépend de leur stratégie pour la soirée. Chaque passage au bar est dangereux, ça joue des coudes, divers substances liquides se sont répandus sur le sol qui est devenu glissant, la barmaid s'énerve, elle arrive difficilement à satisfaire la demande des ces personnes qui trépignent d'impatience. Certains s'accrocheront dangereusement, et se feront éjecter de la boite pour finir dehors sur le gravier. D'autres auront des pannes et finiront dans les toilettes vomir leur carburant.

Absentéisme

2009-04-12T11:33:00.000-07:00

« Shetan : tu savais qu'il y avait une fac pour les + de 50 ans qui était ouverte depuis des années en France ?
Saki : nan mais c'est bon à savoir
Shetan : ouais, ils sont 500, yen a jamais plus de 150, ya 2-3 intellos qui écoutent, le reste dort, joue aux cartes, fout le bordel... comme les jeunes quoi
Saki : mdr excellent
Shetan : C'est l'Assemblée Nationale »
Bashfr.

Vous savez probablement que la loi Hadopi a été rejeté par l'assemblée nationale (pour combien de temps ?). Ce qui me fâche ce n'est pas loi Hadopi, ce n'est pas non plus le fait qu'elle n'ait pas été adopté, c'est le manque de député. Notre président Nicolas Sarkozy, est semble t'il fâché que la loi n'ait pas pu être voté. Les députés UMP sont surpris de s'être fait avoir, et reprochent à leurs adversaires du PS d'êtres arrivés à la dernière minute pour le vote. Je dirais « hate the game, not the player » la manœuvre a beau être vicieuse elle n'a rien d'illégale. Comment se fait-il qu'il y avait si peu de député à l'assemblée à ce moment là (et aux autres...) ? J'ai cru comprendre que cette loi été controversé même au sein de l'UMP comment se fait il que les députés UMP qui étaient contre l'adoption de cette loi, ne soient pas venu voter contre ? D'ailleurs, s'il y avait assez de députés socialiste pour que la loi ne soit pas adopté, dans l'absolu il n'y en avait pas beaucoup. Il est admissible que des gens payés par l'état (déficitaire, faut-il le rappeler ?) ne fassent pas acte de présence dans l'hémicycle. Et si les absents étaient occupés à exercer des fonctions conférés par d'autres mandats, on peut se demander quel l'intérêt pour l'état d'avoir des hommes politiques qui cumulent des mandats sans qu'ils puissent exercer chacun d'entre eux comme il se doit. Dans un monde idéal, les députés devraient rendre des comptes à chaque fois qu'ils ne sont pas présents, comme le fait un collégien lorsqu'il n'a pas assisté à tel ou tel cours. Je comprends parfaitement que les députés sont des grandes personnes qui savent ce qu'elles ont à faire, mais lorsqu'on a dans le portefeuille l'argent du contribuable il convient de faire ce pour quoi on est payé correctement, surtout que leurs salaires est supérieurs à celui de la plupart des français. Dans un monde idéal, un député qui sèche un peu trop souvent les bancs de l'hémicycle (disons deux trois fois sans justification valable) seraient démis de leurs fonctions de députés et seraient exposés à de sévères amendes proportionnelles à la durée de leurs absences.

Le doute

2009-04-12T06:14:00.000-07:00

Jusque là je pensais qu'en formule 1, pour gagner il fallait avoir la meilleure bagnole et le meilleur pilote et peut-être même aussi la meilleure équipe. Et là, j'ai un doute, certes il n'y a eu que deux courses, mais bon, aucun des « champions » de la saison précédente n'a fait de podium... Que ce soit le champion du monde en titre Lewis Hamilton, les anciens champions du monde Kimi Raikkonen et Fernando Alonso, le vice champion du monde Felipe Massa, ou les très prometteurs Robert Kubica et Sebastian Vettel. Les premiers d'hier ne sont plus ceux d'aujourd'hui. Parallèlement d'autres pilotes qui avaient fait des saisons sans vraiment marquer les esprits s'imposent, Rubens Barrichello et surtout Jenson Button. Qui aurait parié sur eux l'an dernier ? On pourrait se dire « ouais mais bon il y a eu des faits de courses... » certes mais ils sont signé des pôles positions, a deux reprise pour Jenson. Je pourrais dire que les résultats de l'équipe Toyota sont assez surprenant aussi dans une moindre mesure. On peut se dire que la monoplace Ferrari n’est peut-être pas aussi compétitive que celle de l'an dernier. On peut se dire la même chose pour la monoplace McLaren, même si c'est étrange que les deux leaders de la saison précédente s’effondrent la même année, c'est d'autant plus étrange que cette chute ne se fait pas au profit de Renault ou de BMW. Si la victoire des pilote BrawnGP est surprenante celle de leur monoplace l'est encore plus, qui aurait parié sur une monoplace construite par l'ex écurie Honda ? Le seul élément dont on pouvait se méfier c'est la présence de Ross Brawn, il s'agit d'un ancien de chez Ferrari et si les écrits de Wikipédia sont avérés il s'agit de quelqu'un de compétent. On le sait, il ne suffit pas d'être un bon pilote pour gagner, il n'y a qu'à voir Vettel et Kubica pour s'en convaincre, la monoplace a une importance capitale. Mais il ne suffit pas non plus d'avoir une bonne monoplace, il n'y a qu'a voir les résultats d' Heikki Kovalainen qui sont nettement en dessous de son coéquipier (Hamilton). Je ne pense pas que Barrichello et Button soient des pilotes exceptionnels, j'admets qu'ils ne sont pas mauvais, mais s'ils étaient bon on s'en serait rendu compte pendant les saisons précédentes, je pense par contre que leur monoplace est clairement plus compétitive que celles de leurs concurrents. Je pense que l'équipe est bonne, car si elle prenait des mauvaises stratégies, BrawnGP ne serait probablement pas première au classement mondial. Et si il n'était guère utile d'être un virtuose du volant pour gagner, et s'il suffisait juste d'avoir un niveau correcte, et si la compétitivité des monoplaces et les compétences de l'équipe étaient les éléments clés de la réussite ? Et si les champions des saisons précédentes n'étaient en fait pas des si bons pilotes que ça, mais juste des pilotes chanceux de disposer des meilleurs monoplaces ?

Tutoriel developper des EJB3 remix

2009-02-08T05:53:00.000-08:00

Parti en expédition sur les terres du JEE, j'ai trouvé refuge dans le comté d'EJB3, comté certes séduisant en apparence, mais la simplicité faisant défaut a ses habitants j'ai décidé de faire un tutoriel largement inspiré de celui existant sur éclipse totale (http://www.eclipsetotale.com/articles/Introduction_EJB3_avec_Eclipse.html). Étant rebelle, je n'utiliserais pas Eclipse mais Netbeans, et j'utiliserais Glassfish en lieu et place de JBoss.
Pourquoi ces choix ? Tout d'abord pourquoi Glassfish ? Parce que ce serveur d'application JEE est léger il prend moins de 100 MO à vide contrairement à JBoss qui prend plus de 300 MO à vide, Parce que Glassfish est certifié JEE 5 et pas JBoss. Glassfish est certes peu connu (contrairement à JBoss) mais il est quand même conçu par Sun ce qui lui apporte une certaine crédibilité, il aurait d'ailleurs déposé Weblogic et Websphere dans le benchmark SPECjAppServer. Pourquoi Netbeans ? Là je dois avouer que c'est plus subjectif, les deux environnement se valent, Eclipse est plus réactif (grâce à SWT ?) et dispose de bien plus de plugins, il a de plus résolu ses problèmes de stabilité, Netbeans lui n'a pas beaucoup évolué et n'as pas vraiment comblé ses lacunes par rapport à Eclipse, mais son plugin pour Glassfish semble mieux fonctionner que celui d' Eclipse. J'ai eu l'occasion d'essayer JDevelopper d' Oracle, c'est de loin l' EDI le plus réussi esthétiquement parlant, mais la stabilité du logiciel est déplorable, elle est digne d'une version alpha. Bref, trêve de tergiversations, passons au tutoriel. La version de Netbeans utilisée ici est la 6.5, la version de Glassfish est la version 2.1 et la versions du JDK utilisé est la 6 update 11.

Créez un nouveau projet Java EE de type EJB Module dans Netbeans, ce projet est intitulé IntroEJB3, la version de JEE utilisé sera la 5 et le serveur utilisé sera bien évidement Glassfish V2.
Créez un package «com.et».Dans l'onglet « projects » faites un clic droit sur « Entreprise beans » cliquez sur « Session Bean » vous appellerez ce bean « PremierEJB3 » ce bean est de type « stateless » son interface est de type « remote » (décochez la case « Local »), ce bean sera dans le package «com.et». Deux fichier sont créés : « PremierEJB3Remote.java» et « PremierEJB3Bean.java», le premier correspond a l'interface « remote » du bean le second correspond à la classe d'implémentation du bean. Ouvrez le fichier « PremierEJB3Bean.java » faites un clic droit à l'interieur, cliquez sur « insert code » puis sur « add business method », appelez cette méthode « ditBonjour » donnez lui le type String comme « return type », ajoutez lui un paramètre de type String nommé « aQui ». Le contenu de cette méthode sera le suivant « return "Bonjour " + aQui + " !!!"; » . Il ne vous aura pas échappé que le prototype de la méthode a été rajouté dans l'interface « PremierEJB3Remote ». Vous pouvez tester votre travail en lancant le serveur, pour ce faire faites un clic droit sur le projet « IntroEJB3 » et en cliquant sur « Run », après quelques secondes un message doit vous afficher que le serveur est bien lancé et que le projet IntroEJB3 a été chargé par Glassfish, en cas de soucis n'hésitez pas à augmenter le timeout (surtout si votre machine est peu véloce) du lancement du serveur.

Passons au client, créez un projet Java de type « Java Application », appelez le « ClientEJB3 », créez un package « com.et ». Créez dans ce package une classe « ClientPremierEJB3 » qui contient le code suivant :

package com.et;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;

public class ClientPremierEJB3 {
public static void main(String[] args) {
try {
Hashtable hashtableEnvironment = new Hashtable();
hashtableEnvironment.put("java.naming.factory.initial",
"com.sun.enterprise.naming.SerialInitContextFactory");
hashtableEnvironment.put("java.naming.factory.url.pkgs",
"com.sun.enterprise.naming");
hashtableEnvironment.put("java.naming.factory.state",
"com.sun.corba.ee.impl.presentation.rmi.JNDIStateFactoryImpl");
hashtableEnvironment.put("org.omg.CORBA.ORBInitialHost",
"localhost");
hashtableEnvironment.put("org.omg.CORBA.ORBInitialPort",
"3700");
Context context = new InitialContext(hashtableEnvironment);
PremierEJB3Remote beanRemote = (PremierEJB3Remote)
context.lookup("com.et.PremierEJB3Remote");
System.out.println(beanRemote.ditBonjour("ClientPremierEJB3"));
} catch (NamingException e) {
e.printStackTrace();
}
}
}

Vous notez ici quelques différence avec le tutoriel d'eclipse totale, d'une part j'ai renseigné les paramètres JNDI dans une hashtable et non pas dans un fichier « jndi.properties » et d'autre par la chaine de caractère passé en paramètre à la méthode « lookup » de l'objet « context », n'est pas la même.
Je n'ai pas utilisé de fichier « jndi.properties » pour des raisons de simplicité. La chaine passé en paramètre à la méthode « lookup » est différente parce que celle présente sur le tutoriel d'éclipse totale ne permet pas de retrouver le bean « PremierEJB3Bean ». De plus, quel est l'intérêt de créer une interface si le client cherche un bean à partir du nom de sa classe d'implémentation ? Si l'on utilise l'interface « remote » du bean « PremierEJB3Bean » dans la méthode « lookup » quel est l'intérêt de rajouter « /remote » à la fin de la chaine de caractère ? Afin de vous évitez quelques déconvenue je vous recommande l'ajout des jar suivantes : « appserv-rt.jar » et « javaee.jar ». La jar « appserv-rt.jar » vous évitera l'exception « classnotfoundexception » en effet vous avez besoin de la classe « com.sun.enterprise.naming.SerialInitContextFactory » qui se trouve justement dans ce jar. Il en est de même pour la jar « javaee.jar » qui vous permettra d'éviter le « classnotfoundexception » avec la classe « javax.security.jacc.PolicyException », ces jar doivent bien évidement êtres accessible lors de l'exécution du programme. N'oubliez pas de référencez le projet « IntroEJB3 » dans les librairies de « ClientEJB3 » pour la compilation et l'exécution du programme.

Utilisez la chaine "PremierEJB3Bean/remote" en paramètre de la méthode « lookup » et vous obtiendrez une magnifique « javax.naming.NameNotFoundException ». Si vous décidez d'utiliser la chaine "PremierEJB3Remote/remote" en paramètre a cette même méthode vous obtiendrez une autre « javax.naming.NameNotFoundException ». En utilisant "com.et.PremierEJB3Remote/remote" vous obtiendrez une curieuse « javax.naming.NameAlreadyBoundException: com.et.PremierEJB3Remote », curieuse dans la mesure où nous n'essayons pas de refaire un binding, nous aurions utilisé la fonction «bind » pour cela. La chaine "com.et.PremierEJB3Remote", elle permettra à votre client de s'exécuter convenablement. Cela me semble logique dans la mesure ou en utilisant l'interface de type « remote » il est évident que l'on souhaite accéder à un bean distant, le suffixe « /remote » deviens donc inutile. Préfixer le nom de l'interface par son package me parait là aussi logique.

Politique

2009-01-25T12:20:00.000-08:00

Des fois je me demande pourquoi, je me lève tôt cinq matins sur sept pour aller travailler 35 heures par semaines. Je me dis que j’aurais mieux fait de faire de la politique, j’ai une grande gueule, de la répartie, je sais baratiner, mes qualités oratoires sont reconnues. J’aurais du intégrer un grand parti politique, l’UMP ou le PS, les autres n’étant pas assez fortunés à mon gout, j’aurais fait partie de l’élite, de ces gens qui n’en ont rien à branler de la hausse du prix de l’essence, j’aurais fait partie de ces gens qui ont la chance de pouvoir faire leurs courses sans compter, d’avoir une carrière tracée, de pouvoir me préparer une retraite confortable. Peu importe mes opinions, peu importe mes idées, l’important ce n’est pas que je sois en accord avec mon parti politique, mais que je donne l’impression de l’être. L’important n’est pas de savoir de quoi l’on parle mais de donner l’impression que l’on sait de quoi l’on parle. Tout n’est qu’apparence.

Une base de données orientée objet : Db4o

2009-01-25T08:28:00.000-08:00

Entre deux morceaux de death metal scandinaves votre dévoué serviteur se plaît à expérimenter de nouveaux outils informatiques. C’est ainsi que j’ai testé une base de données orienté objets. Pourquoi une base de données orientée objet ? Cela ne vous aura pas échappé que dans beaucoup de logiciels nécessitant la présence d’une base de données (afin de persister des données) des ORMs (object-relational mapping) sont utilisés (Hibernate, TopLink, Ibatis pour ne citer qu’eux). En utilisant des ORM on est confrontés (entre autres) a deux problèmes, soit des problèmes de performances (qui sont les prix à payer pour se détacher du SQL afin gagner en productivité), soit des problèmes de productivité (qui sont les prix à payer pour avoir un niveau de performance acceptable lorsque l’on manipule de gros volume de données). Alors certes, dans la réalité la situation n’est pas aussi binaire que mes propos le laisseraient supposer, en effet il est possible d’optimiser un ORM lent et d’utiliser des outils qui permettent de gagner en productivité lorsque l’on utilise des ORMs ne facilitant pas à la base la productivité. Dans le premier cas, il faut connaître sur le bout des doigts l’ORM ce qui en soit n’est pas trivial, cela demande aussi une bonne connaissance de l’optimisation de l’utilisation des bases de données (schémas, requêtes etc.). Dans le cas des ORM ne facilitant pas la productivité, les outils dont j’ai parlé plus tôt ne sont pas toujours disponibles, et lorsqu’ils permettent d’avoir un niveau de productivité correcte, c’est parfois au dépend de l’architecture du logiciel. Le compromis entre performances et productivité est possible, mais difficile à obtenir. Et si le problème était (entre autre) le manque d’adéquation entre le modèle objet et le modèle relationnel ? Et si un bon modèle objet était rarement transposable en un bon modèle relationnel et inversement ? Et si la solution était que la base de données nous libère du SQL ? Et si la base de données était capable de persister des objets sans avoir à définir de mapping que ce soit par des annotations ou des fichiers XML ? Ces interrogations pourront vous paraitre naïve voir utopistes, mais sachez qu’il existe des bases de données orientées objets qui sont capable de persister des objets Java .NET etc. Et ce sans la moindre information de mapping.

J’ai eu l’occasion d’essayer Db4o une base de données orientées objet libre, la facilité d’utilisation de cet outil est assez troublante. En l’utilisant on se demande vraiment pourquoi autant de gens s’embêtent avec des ORMs. Toutefois la prudence est de mise, si je pense que cette solution est adapté pour des petits projets, je n’ai pas pu faire de tests de performances avec cette base de données, je n’ai pas non plus essayé de persister des objets complexes. Le gain en productivité avec cette base de données est plus important selon moi qu’avec un ORM comme hibernate. Je trouve que ce type de base gagnerait à être connu dans la mesure où elles tentent de répondre à la demande actuelle, à savoir persister facilement et si possible rapidement des objets. J’ai décelé quelques points noirs, tout d’abord la documentation, le « Formula One Tutorial » bien qu’amusant à faire il est un peu négligé, d’une part il propose d’utiliser des méthodes dépréciés (problème de mise à jour de la documentation ?) d’autre part le « full source » est incomplet. Autre point noir, la licence, cette sympathique base de données est sous licence GPL, donc tout logiciel utilisant cette base de données bascule sous licence GPL…. Néanmoins ce type de base données trace une nouvelle voie : Plutôt que faire rentrer un model objet dans une base de données relationnelles ou un modèle relationnel dans un modèle objet à l’aide d’ORMs, autant utiliser une base de données capable de comprendre nativement un model objet.

Quelques bouts de codse pour montrer ce que l’on peut faire avec :

MyClass.java :

package com.db4o.f1.chapter1;

import java.io.File;

import com.db4o.Db4o;
import com.db4o.ObjectContainer;
import com.db4o.ObjectSet;

public class MyClass {
public static void main(String[] args) {
new File("c:/database").delete();
accessDb4o();
new File("c:/database").delete();
ObjectContainer db = Db4o.openFile("c:/database");
try {
storeFirstPilot(db);
storeSecondPilot(db);
retrieveAllPilots(db);
retrievePilotByName(db);
retrievePilotByExactPoints(db);
updatePilot(db);
deleteFirstPilotByName(db);
deleteSecondPilotByName(db);
} finally {
db.close();
}
}

public static void accessDb4o() {
ObjectContainer db = Db4o.openFile("c:/database");
try {
// do something with db4o
} finally {
db.close();
}
}

public static void storeFirstPilot(ObjectContainer db) {
Pilot pilot1 = new Pilot("Michael Schumacher", 100);
db.set(pilot1);
System.out.println("Stored " + pilot1);
}

public static void storeSecondPilot(ObjectContainer db) {
Pilot pilot2 = new Pilot("Rubens Barrichello", 99);
db.set(pilot2);
System.out.println("Stored " + pilot2);
}

public static void retrieveAllPilotQBE(ObjectContainer db) {
Pilot proto = new Pilot(null, 0);
ObjectSet result = db.get(proto);
listResult(result);
}

public static void listResult(ObjectSet result) {
System.out.println(result.size());
while (result.hasNext()) {
System.out.println(result.next());
}
}

public static void retrieveAllPilots(ObjectContainer db) {
ObjectSet result = db.get(Pilot.class);
listResult(result);
}

public static void retrievePilotByName(ObjectContainer db) {
Pilot proto = new Pilot("Michael Schumacher", 0);
ObjectSet result = db.get(proto);
listResult(result);
}

public static void retrievePilotByExactPoints(ObjectContainer db) {
Pilot proto = new Pilot(null, 100);
ObjectSet result = db.get(proto);
listResult(result);
}

public static void updatePilot(ObjectContainer db) {
ObjectSet result = db.get(new Pilot("Michael Schumacher", 0));
Pilot found = (Pilot) result.next();
found.addPoints(11);
db.set(found);
System.out.println("Added 11 points for " + found);
retrieveAllPilots(db);
}

public static void deleteFirstPilotByName(ObjectContainer db) {
ObjectSet result = db.get(new Pilot("Michael Schumacher", 0));
Pilot found = (Pilot) result.next();
db.delete(found);
System.out.println("Deleted " + found);
retrieveAllPilots(db);
}

public static void deleteSecondPilotByName(ObjectContainer db) {
ObjectSet result = db.get(new Pilot("Rubens Barrichello", 0));
Pilot found = (Pilot) result.next();
db.delete(found);
System.out.println("Deleted " + found);
retrieveAllPilots(db);
}
}

Pilot.java :

package com.db4o.f1.chapter1;

public class Pilot {
private String name;
private int points;

public Pilot(String name,int points) {
this.name=name;
this.points=points;
}

public int getPoints() {
return points;
}

public void addPoints(int points) {
this.points+=points;
}

public String getName() {
return name;
}

public String toString() {
return name+"/"+points;
}
}

Le C orienté objet, 3ème partie

2009-01-25T04:27:00.000-08:00

Voici un troisième exemple de « classe » écrite en langage C, cette version de distingue de ses précédentes par la présence d’une certaine forme d’encapsulation. Les développeurs qui manipuleront une instance de la classe « ClasseEncapsule » n’auront pas un accès direct aux champs de cette instance, ils devront passer par des accesseurs et des mutateurs. On peut trouver ces derniers inutiles dans la mesure où la plupart du temps ils se contentent de faire de simples affectations, mais ils permettent de masquer l’implémentation et ainsi de minimiser l’impact des modifications de la classe « ClasseEncapsule ».

ClasseEncapsule.h :

#ifndef CLASSEENCAPSULE_H_INCLUDED
#define CLASSEENCAPSULE_H_INCLUDED

typedef struct ClasseEncapsule *ClasseEncapsule;

extern void ClasseEncapsule_supprimer(ClasseEncapsule
maClasse);
extern double
ClasseEncapsule_methode1(ClasseEncapsule maClasse,double unDouble);

extern char *
ClasseEncapsule_methode2(ClasseEncapsule maClasse,int unInt, char * unCharEtoile);

extern ClasseEncapsule
ClasseEncapsule_creer(int champ1, double champ2, char * champ3);
extern int ClasseEncapsule_acceder_champ1(ClasseEncapsule maClasse);
extern double ClasseEncapsule_acceder_champ2(ClasseEncapsule maClasse);
extern char * ClasseEncapsule_acceder_champ3(ClasseEncapsule maClasse);
extern void ClasseEncapsule_muter_champ1(ClasseEncapsule maClasse, int valeur);
extern void ClasseEncapsule_muter_champ2(ClasseEncapsule maClasse,double valeur);
extern void ClasseEncapsule_muter_champ3(ClasseEncapsule maClasse,char * valeur);

#define ClasseEncapsuleUpCast(instance,instanceSousClasse, NOM_CLASSE_FILLE) \
ClasseEncapsule_muter_champ1(instance,NOM_CLASSE_FILLE##_acceder_champ1(instanceSousClasse)); \
ClasseEncapsule_muter_champ2(instance,NOM_CLASSE_FILLE##_acceder_champ2(instanceSousClasse)); \
ClasseEncapsule_muter_champ3(instance,NOM_CLASSE_FILLE##_acceder_champ3(instanceSousClasse));

#define ClasseEncapsuleDownCast(instance,instanceSousClasse, NOM_CLASSE_FILLE) \
NOM_CLASSE_FILLE##_muter_champ1(instanceSousClasse,ClasseEncapsule_acceder_champ1(instance)); \
NOM_CLASSE_FILLE##_muter_champ2(instanceSousClasse,ClasseEncapsule_acceder_champ2(instance)); \
NOM_CLASSE_FILLE##_muter_champ3(instanceSousClasse,ClasseEncapsule_acceder_champ3(instance));
#endif // CLASSEENCAPSULE_H_INCLUDED

ClasseEncapsuleImpl.h :

#ifndef CLASSEENCAPSULEIMPL_H_INCLUDED
#define CLASSEENCAPSULEIMPL_H_INCLUDED

#define ClasseEncapsule_methode1_IMPL(instanceClasseMere, unDouble) \
return instanceClasseMere->monChamp2 + (unDouble);

#define ClasseEncapsule_methode2_IMPL( instanceClasseMere, unInt,unCharEtoile) \
if(strlen(unCharEtoile) > (unInt)){\
return unCharEtoile;\
}\
return instanceClasseMere->monChamp3;

#define ClasseEncapsule_supprimer_IMPL(instanceClasseMere) \
if(instanceClasseMere!=NULL){\
free(instanceClasseMere);\
}

#define ClasseEncapsule_acceder_champ1_IMPL(instanceClasseMere) \
return instanceClasseMere->monChamp1;

#define ClasseEncapsule_acceder_champ2_IMPL(instanceClasseMere) \
return instanceClasseMere->monChamp2;

#define ClasseEncapsule_acceder_champ3_IMPL(instanceClasseMere) \
return instanceClasseMere->monChamp3;

#define ClasseEncapsule_muter_champ1_IMPL(instanceClasseMere,valeur) \
instanceClasseMere->monChamp1=valeur;

#define ClasseEncapsule_muter_champ2_IMPL(instanceClasseMere,valeur) \
instanceClasseMere->monChamp2=valeur;

#define ClasseEncapsule_muter_champ3_IMPL(instanceClasseMere,valeur) \
instanceClasseMere->monChamp3=valeur;

#endif // CLASSEENCAPSULEIMPL_H_INCLUDED

ClasseEncapsule.c :

#include
#include
#include
#include "classeencapsule.h"
#include "classeencapsuleimpl.h"

struct ClasseEncapsule
{
int monChamp1;
double monChamp2;
char* monChamp3;
};

int ClasseEncapsule_acceder_champ1(ClasseEncapsule maClasse){
ClasseEncapsule_acceder_champ1_IMPL(maClasse);
}
double ClasseEncapsule_acceder_champ2(ClasseEncapsule maClasse){
ClasseEncapsule_acceder_champ2_IMPL(maClasse);
}
char * ClasseEncapsule_acceder_champ3(ClasseEncapsule maClasse){
ClasseEncapsule_acceder_champ3_IMPL(maClasse);
}

void ClasseEncapsule_muter_champ1(ClasseEncapsule maClasse, int valeur){
ClasseEncapsule_muter_champ1_IMPL(maClasse,valeur);
}
void ClasseEncapsule_muter_champ2(ClasseEncapsule maClasse,double valeur){
ClasseEncapsule_muter_champ2_IMPL(maClasse,valeur);
}

void ClasseEncapsule_muter_champ3(ClasseEncapsule maClasse,char * valeur){
ClasseEncapsule_muter_champ3_IMPL(maClasse,valeur);
}

void ClasseEncapsule_supprimer(ClasseEncapsule maClasse){
ClasseEncapsule_supprimer_IMPL(maClasse);
}

double
ClasseEncapsule_methode1(ClasseEncapsule maClasse,double unDouble){

ClasseEncapsule_methode1_IMPL(maClasse,unDouble);
}

char *
ClasseEncapsule_methode2(ClasseEncapsule maClasse,int unInt, char * unCharEtoile){
ClasseEncapsule_methode2_IMPL(maClasse,unInt,unCharEtoile);

}

ClasseEncapsule
ClasseEncapsule_creer(int champ1, double champ2, char * champ3)
{
ClasseEncapsule monInstance=malloc(sizeof(struct ClasseEncapsule));

monInstance->monChamp1=champ1;
monInstance->monChamp2=champ2;
monInstance->monChamp3=champ3;
return monInstance;

}

Le C orienté objet, 2ème partie

2008-12-14T08:07:00.000-08:00

Un des concepts fondamentaux de la programmation orienté objet est l’héritage, comment l’implémenter en langage C ? Prenons deux classes, une classe mère « ClasseMère » et une classe fille « ClasseFille » qui hérite de la première. La classe mère içi sera une pale copie de la classe MonAutreClasse présentée dans la première partie. Les fonctions concernant le descripteur de classe et le constructeur n’ont pas beaucoup changés. Pour les autres méthodes vous noterez l’usage de macro-fonctions dans lesquelles nous avons réécris les méthodes. Pour des raisons évidentes d’encapsulation, ces macros n’ont pas été mises dans le fichier d’en-tête « classemere.h », elles n’ont pas non plus été mises dans le fichier « classemere.c » (afin d’éviter d’encombrer inutilement ce fichier). Ces macros ont été définies dans un fichier nommé « classemereimpl.h » qui contrairement à ce que son extension pourrait laisser supposer n’est pas un fichier d’en-tête voué à être utilisé comme une interface, il s’agit içi d’un fichier d’implémentation au même titre que le fichier « classemere.c ». Pourquoi écrire le corps de certaines méthodes dans des macros fonctions ? Cette astuce permet de factoriser du code entre les classes mères et les classes filles. En effet, lorsque nous implémentons les méthodes de la classe filles celles de la classe mère ne peuvent pas être directement réutilisées. Le premier argument des méthodes de la classe mère (argument de type « ClasseMere ») n’est pas le même que le premier argument que les méthodes des classes filles (« ClasseFille »). Cela dit, à par le type du premier argument, rien ne change, en factorisant le corps des méthodes dans des macro-fonctions, on s’affranchit du type du premier argument. Par contre, nous gardons toute la force (ou la faiblesse, à votre convenance…) du typage du langage C, une fois que le préprocesseur aura effectué son travail, le compilateur se chargera d’effectuer toutes les vérifications de type. Néanmoins, cette astuce nous oblige à redéfinir chaque méthode dans le fichier d’implémentation de la classe fille, afin de préciser que le type du premier argument (correspondant à l’instance de la classe sur laquelle s’applique la méthode) à changé.

Lorsque nous avons une instance de la classe « ClasseFille » comment la passer en paramètre à une méthode qui prend en paramètre une instance de la classe « ClasseMere » ? Grace aux deux autres macros-fonctions « ClasseMereUpCast » et « ClasseMereDownCast » qui permettent respectivement le transtypage de la classe fille vers la classe mère et inversement. Ce transtypage comme vous pourrez le constater à la lecture des sources est artificiel, de plus, il nécessite la présence d’une instance de la classe « ClasseMere ». En effet, la macro-fonction « ClasseMereUpCast » se contente d’affecter à chaque les donnée membre de l’instance de la classe « ClasseMere » la valeur de son équivalent dans la classe fille. La macro fonction « ClasseMereDownCast », fait le même type d’affectations mais dans le sens inverse (de l’instance de la classe mère vers l’instance de la classe fille). Ces transtypages, aussi artificiels soient ils, n’empêcheront pas, à priori, le compilateur de détecter les éventuels problèmes de type.

On peut bien évidement utiliser des macros-fonctions pour factoriser du code dans quasiment toutes les fonctions présentes dans les fichiers d’implémentation (pour alléger le code du constructeur par exemple).

Classemere.h :

#ifndef CLASSEMERE_H_INCLUDED

#define CLASSEMERE_H_INCLUDED

typedef struct ClasseMere *ClasseMere;

typedef struct DescripteurClasseMere DescripteurClasseMere;

struct DescripteurClasseMere

{

void (*supprimer)(ClasseMere);

double (*methode1)(ClasseMere a, double);

char*(*methode2)(ClasseMere a,int b, char *c);

};

struct ClasseMere

{

int monChamp1;

double monChamp2;

char* monChamp3;

DescripteurClasseMere* classe;

};

extern ClasseMere

ClasseMere_creer(int champ1, double champ2, char * champ3);

#define ClasseMereUpCast(instance,instanceSousClasse) \

instance->monChamp1=instanceSousClasse->monChamp1; \

instance->monChamp2=instanceSousClasse->monChamp2; \

instance->monChamp3=instanceSousClasse->monChamp3;

#define ClasseMereDownCast(instance,instanceSousClasse) \

instanceSousClasse->monChamp1=instance->monChamp1; \

instanceSousClasse->monChamp2=instance->monChamp2; \

instanceSousClasse->monChamp3=instance->monChamp3;

#endif // CLASSEMERE_H_INCLUDED

classemereimpl.h :

#ifndef CLASSEMEREIMPL_H_INCLUDED

#define CLASSEMEREIMPL_H_INCLUDED

#define ClasseMere_methode1_IMPL(instanceClasseMere, unDouble) \

return instanceClasseMere->monChamp2 + (unDouble);

#define ClasseMere_methode2_IMPL( instanceClasseMere, unInt,unCharEtoile) \

if(strlen(unCharEtoile) > (unInt)){\

return unCharEtoile;\

return instanceClasseMere->monChamp3;

#define ClasseMere_supprimer_IMPL(instanceClasseMere) \

if(instanceClasseMere!=NULL){\

free(instanceClasseMere);\

}

#endif // CLASSEMEREIMPL_H_INCLUDED

classemere.c :

#include

#include "classemere.h"

#include "classemereimpl.h"

static void ClasseMere_supprimer(ClasseMere maClasse){

ClasseMere_supprimer_IMPL(maClasse);

}

static double

ClasseMere_methode1(ClasseMere maClasse,double unDouble){

ClasseMere_methode1_IMPL(maClasse,unDouble);

}

static char *

ClasseMere_methode2(ClasseMere maClasse,int unInt, char * unCharEtoile){

ClasseMere_methode2_IMPL(maClasse,unInt,unCharEtoile);

}

static DescripteurClasseMere*

ClasseMere_obtenir_descripteur(){

static int descripteurDejaInitalise=0; // superieur a 0 si le descripteur est deja initalise

static DescripteurClasseMere descripteur;

if(descripteurDejaInitalise==0){

descripteur.supprimer=ClasseMere_supprimer;

descripteur.methode1=ClasseMere_methode1;

descripteur.methode2=ClasseMere_methode2;

descripteurDejaInitalise++;

}

return &descripteur;

}

ClasseMere

ClasseMere_creer(int champ1, double champ2, char * champ3)

{

ClasseMere monInstance=malloc(sizeof(struct ClasseMere));

monInstance->monChamp1=champ1;

monInstance->monChamp2=champ2;

monInstance->monChamp3=champ3;

monInstance->classe=ClasseMere_obtenir_descripteur();

return monInstance;

}

classefille.h:

#ifndef CLASSEFILLE_H_INCLUDED

#define CLASSEFILLE_H_INCLUDED

typedef struct ClasseFille *ClasseFille;

typedef struct DescripteurClasseFille DescripteurClasseFille;

struct DescripteurClasseFille

{

void (*supprimer)(ClasseFille);

double (*methode1)(ClasseFille a, double);

char*(*methode2)(ClasseFille a,int b, char *c);

int (*methode3)(ClasseFille a,int b);

double (*methode4)(ClasseFille a,int b, double c);

};

struct ClasseFille

{

int monChamp1;

double monChamp2;

char* monChamp3;

int monChamp4;

double monChamp5;

DescripteurClasseFille* classe;

};

extern ClasseFille

ClasseFille_creer(int champ1, double champ2, char * champ3,int champ4,double champ5);

#define ClasseFilleUpCast(instance,instanceSousClasse) \

instance->monChamp1=instanceSousClasse->monChamp1; \

instance->monChamp2=instanceSousClasse->monChamp2; \

instance->monChamp3=instanceSousClasse->monChamp3; \

instance->monChamp4=instanceSousClasse->monChamp4; \

instance->monChamp5=instanceSousClasse->monChamp5;

#define ClasseFilleDownCast(instance,instanceSousClasse) \

instanceSousClasse->monChamp1=instance->monChamp1; \

instanceSousClasse->monChamp2=instance->monChamp2; \

instanceSousClasse->monChamp3=instance->monChamp3; \

instanceSousClasse->monChamp4=instance->monChamp4; \

instanceSousClasse->monChamp5=instance->monChamp5;

#endif // CLASSEFILLE_H_INCLUDED

classefilleimpl.h :

#ifndef CLASSEFILLEIMPL_H_INCLUDED

#define CLASSEFILLEIMPL_H_INCLUDED

#include "classemereimpl.h"

#define ClasseFille_methode3_IMPL(instanceClasseFille,b) \

return a->monChamp4 + (b);

#define ClasseFille_methode4_IMPL(instanceClasseFille,b,c) \

return a->monChamp5 + (c) + ((double) b);

#endif // CLASSEFILLEIMPL_H_INCLUDED

classefille.c :

#include

#include "classefille.h"

#include "classefilleimpl.h"

static void ClasseFille_supprimer(ClasseFille maClasse){

ClasseMere_supprimer_IMPL(maClasse);

}

static double

ClasseFille_methode1(ClasseFille maClasse,double unDouble){

ClasseMere_methode1_IMPL(maClasse,unDouble);

}

static char *

ClasseFille_methode2(ClasseFille maClasse,int unInt, char * unCharEtoile){

ClasseMere_methode2_IMPL(maClasse,unInt,unCharEtoile);

}

static int

ClasseFille_methode3(ClasseFille a,int b){

ClasseFille_methode3_IMPL(a,b);

}

static double

ClasseFille_methode4(ClasseFille a,int b, double c){

ClasseFille_methode4_IMPL(a,b,c);

}

static DescripteurClasseFille*

ClasseFille_obtenir_descripteur(){

static int descripteurDejaInitalise=0; // superieur a 0 si le descripteur est deja initalise

static DescripteurClasseFille descripteur;

if(descripteurDejaInitalise==0){

descripteur.supprimer=ClasseFille_supprimer;

descripteur.methode1=ClasseFille_methode1;

descripteur.methode2=ClasseFille_methode2;

descripteur.methode3=ClasseFille_methode3;

descripteur.methode4=ClasseFille_methode4;

descripteurDejaInitalise++;

}

return &descripteur;

}

ClasseFille

ClasseFille_creer(int champ1, double champ2, char * champ3,int champ4,double champ5)

{

ClasseFille monInstance=malloc(sizeof(struct ClasseFille));

monInstance->monChamp1=champ1;

monInstance->monChamp2=champ2;

monInstance->monChamp3=champ3;

monInstance->monChamp4=champ4;

monInstance->monChamp5=champ5;

monInstance->classe=ClasseFille_obtenir_descripteur();

return monInstance;

}

Le C orienté objet, 1ère partie

2008-12-07T04:51:00.000-08:00

Le langage de monsieur Stroustrup n’a pas pu enterrer le langage C, ce dernier est encore très utilisé nonobstant son retard par rapport aux langages « modernes » (C++, C#, F# etc.). Aujourd’hui encore, de volumineux logiciels sont faits en langage C, comme les noyaux de la plupart des systèmes d’exploitation modernes (Linux, NetBSD etc.). On peut imaginer qu’a certains moments, dans de gros logiciels écrit en C, le besoin d’utiliser quelques principes de programmation orienté objet se fassent sentir. Comment implémenter des objets en langage C ? C’est justement la question a la quelle cet article essai de répondre.

Définition d’une classe :

Pour cette partie je m’inspirerais des travaux de M. Braquelaire.

Les classes n’existant pas en langage C, nous utiliserons des structures, ces structures contiendront des données membres et des pointeurs de fonctions, qui pointent vers les méthodes de notre classe. Les méthodes de cette « classe » auront toutes au moins un paramètre : l’instance de la classe à laquelle elle s’applique. J’en conviens, il est assez ennuyeux de toujours passer ce paramètre mais n’oubliez pas que nous n’avons pas de « this » en C. Autre point à préciser, il sera nécessaire d’initialiser les pointeurs de fonctions de notre instance dans notre « constructeur ».

Example avec la « classe » « MaClasse » ;

Le fichier d’en-tête :

#ifndef MACLASSE_H_INCLUDED

#define MACLASSE_H_INCLUDED

typedef struct MaClasse *MaClasse;

struct MaClasse

{

int monChamp1;

double monChamp2;

char* monChamp3;

void (*supprimer)(MaClasse);

double (*methode1)(MaClasse, double);

char*(*methode2)(MaClasse,int b, char *c);

};

extern MaClasse

MaClasse_creer(int champ1, double champ2, char * champ3);

#endif // MACLASSE_H_INCLUDED

Le fichier d’implémentation :

#include "maclasse.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

static void MaClasse_supprimer(MaClasse maClasse){

if(maClasse!=NULL){

free(maClasse);

}

static double

MaClasse_methode1(MaClasse maClasse,double unDouble){

return maClasse->monChamp2 + unDouble;

}

static char *

MaClasse_methode2(MaClasse maClasse,int unInt, char * unCharEtoile){

if(strlen(unCharEtoile) > unInt){

return unCharEtoile;

}

return maClasse->monChamp3;

}

MaClasse

MaClasse_creer(int champ1, double champ2, char * champ3)

{

MaClasse monInstance=malloc(sizeof(struct MaClasse));

monInstance->monChamp1=champ1;

monInstance->monChamp2=champ2;

monInstance->monChamp3=champ3;

monInstance->supprimer=MaClasse_supprimer;

monInstance->methode1=MaClasse_methode1;

monInstance->methode2=MaClasse_methode2;

return monInstance;

}

Comme vous avez pu le constater, la programmation style « objet » en C est un tantinet plus pénible que dans un vrai langage orienté objet. Aussi, il ne vous aura pas échappé que chaque objet embarque trois pointeurs de fonctions en plus des trois données membres. Etant donnée que les trois méthodes sont communes à toutes les instances de la classe « MaClasse » ont peut réduire la taille (en mémoire) des instances en mettant ces pointeurs de fonctions dans un descripteur de classe. Qu’est-ce qu’un descripteur de classe ? Et bien, il s’agit d’une structure qui contient que des pointeurs de fonctions, ces pointeurs de fonctions pointent vers les méthodes qui seront utilisées par toutes les instances de la classe. Cette petite optimisation à l’inconvénient de rallonger l’écriture de l’appel d’une méthode.

Example avec la « classe » « MonAutreClasse » ;

Le fichier d’en-tête :

#ifndef MONAUTRECLASSE_H_INCLUDED

#define MONAUTRECLASSE_H_INCLUDED

typedef struct MonAutreClasse *MonAutreClasse;

typedef struct DescripteurMonAutreClasse DescripteurMonAutreClasse;

struct DescripteurMonAutreClasse

{

void (*supprimer)(MonAutreClasse);

double (*methode1)(MonAutreClasse a, double);

char*(*methode2)(MonAutreClasse a,int b, char *c);

};

struct MonAutreClasse

{

int monChamp1;

double monChamp2;

char* monChamp3;

DescripteurMonAutreClasse* classe;

};

extern MonAutreClasse

MonAutreClasse_creer(int champ1, double champ2, char * champ3);

#endif // MONAUTRECLASSE_H_INCLUDED

Le fichier d’implémentation :

#include "monautreclasse.h"

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

static void MonAutreClasse_supprimer(MonAutreClasse maClasse){

if(maClasse!=NULL){

free(maClasse);

}

static double

MonAutreClasse_methode1(MonAutreClasse maClasse,double unDouble){

return maClasse->monChamp2 + unDouble;

}

static char *

MonAutreClasse_methode2(MonAutreClasse maClasse,int unInt, char * unCharEtoile){

if(strlen(unCharEtoile) > unInt){

return unCharEtoile;

}

return maClasse->monChamp3;

}

static DescripteurMonAutreClasse*

MonAutreClasse_obtenir_descripteur(){

static int descripteurDejaInitalise=0; // superieur a 0 si le descripteur est deja initalise

static DescripteurMonAutreClasse descripteur;

if(descripteurDejaInitalise==0){

descripteur.supprimer=MonAutreClasse_supprimer;

descripteur.methode1=MonAutreClasse_methode1;

descripteur.methode2=MonAutreClasse_methode2;

descripteurDejaInitalise++;

}

return &descripteur;

}

MonAutreClasse

MonAutreClasse_creer(int champ1, double champ2, char * champ3)

{

MonAutreClasse monInstance=malloc(sizeof(struct MonAutreClasse));

monInstance->monChamp1=champ1;

monInstance->monChamp2=champ2;

monInstance->monChamp3=champ3;

monInstance->classe=MonAutreClasse_obtenir_descripteur();

return monInstance;

}

Vous vous demandez probablement pourquoi je défini les structures dans les interfaces (les fichiers d’en-tête), car vous avez peut-être entendu je ne sais quel programmeur C vous dire qu’en agissant de la sorte vous exposiez l’implémentation aux autres programmeurs. Sachez toutefois que de manière générale, en C++ les classes sont définies dans les fichiers d’en-tête, certes, cette habitude n’est probablement pas bonne, en effet, les données privées sont elles aussi exposées (l’idéal aurait été qu’il soit possible de définir une classe sur deux fichiers comme en C#, une définition publique contenant tout ce dont les autres développeurs ont besoins, et une autre privé, contenant uniquement les données membres et les fonctions privées), mais comment les développeurs peuvent connaitre les méthodes de nos « classes » si les structures ne sont pas définies dans les interfaces ? Certes nous exposons les données membres, mais ne pouvant gérer la visibilité des variables (les champs des structures (les variables d’instances) sont tous publics) il me semble difficile de faire autrement. Nous pouvons en déduire que les accesseurs sont içi inutiles.

Là encore, nous nous trouvons confronté aux faiblesses du langage C.