Commentaires sur : Les dynamic finders du pauvre

Par : Blog Excilys » Classes proxy en PHP : l’AOP des pauvres

Blog Excilys » Classes proxy en PHP : l’AOP des pauvres — Thu, 06 May 2010 13:07:41 +0000

[...] une expression régulière , par exemple « findAll.* [...]

Par : Bastien JANSEN

Bastien JANSEN — Wed, 10 Feb 2010 13:51:39 +0000

A noter également que Doctrine, l’ORM PHP utilisé notamment dans symfony, propose les Magic Finders qui permettent de retrouver des objets en fonction de la valeur d’une ou plusieurs colonnes, combinées avec des And ou des Or.

On pourra par exemple avoir un

1	Doctrine_Core::getTable('User')->findOneByUsernameAndPassword('bastien', 'monSuperPassword');

Par : Nicolas Delsaux

Nicolas Delsaux — Tue, 09 Feb 2010 14:54:19 +0000

C’est vraiment dans l’air du temps, cette idée !
J’ai implémenté exactement la même chose dans gaedo (http://gaedo.origo.ethz.ch/blog/%5Buser-raw%5D/dynamic_finders_the_reference). La différence, à mon sens, c’est que je peux utiliser à peu près n’importe quel back-end, que ce soit Google App Engine datastore, une base de donnée relationnelle, …

Par : Eric BOTTARD

Eric BOTTARD — Fri, 29 Jan 2010 13:34:10 +0000

Le framework Hades (que je découvre à l’instant) dont parle Nicolas (merci!) est très intéressant (avec une doc soignée, en tout cas) : http://redmine.synyx.org/wiki/hades

Comme quoi, ce post qui relevait plus du POC et du mini tutorial sur Proxy/InvocationHandler, peut déboucher sur de belles découvertes !

J’insiste en revanche sur le fait qu’un DAO qui n’est pas clair sur ce qu’il fetche est un problème de perfs à la clef…

Sinon, Fonzie, c’est coooooool

Par : nicolas De loof

nicolas De loof — Fri, 29 Jan 2010 13:09:57 +0000

La solution proposée est relativement identique à ce que Fait Hades (cf la session correspondante lors du dernier Devoxx).

Pour ceux qui cherchent une autre piste, vous pouvez aussi tenter l’aventure avec un dev perso qui se rapproche plutôt de Spring ROO : Fonzie (http://code.google.com/p/loof/wiki/Fonzie)

NB : ce n’est pas un clone, je l’ai sorti 2 jours avant l’annonce officielle de Roo !

Par : Pierre-Yves RICAU

Pierre-Yves RICAU — Fri, 29 Jan 2010 11:17:31 +0000

@Eric BOTTARD
C’est vrai que c’est plus beau avec des annotations, mais dès lors l’affirmation “tout ce dont nous avons besoin se trouve déjà dans le JDK” ne tient plus . Ceci dit, utiliser cglib c’est pas la mort

Par : Maxime Picque

Maxime Picque — Fri, 29 Jan 2010 10:50:17 +0000

Pour le cas des méthodes à la mano, je pense que nous pouvons imaginer un comportement du genre :

1	dao.delete[All][ByProp]([params])

Il est donc tout à fait possible d’ajouter le delete à notre dynamic finder (mais ça complexifie d’autant plus le InvocationHandler) :

1
2
3
4
5
6
7
8

public class FinderDescriptor {
public final boolean delete;

public final boolean returnsAll; // findAll ou find unique ?
public final BooleanCombinator comb; // And ou Or
public final List props;
...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
FinderDescriptor descriptor = descriptors.get(method);

if (descriptor.delete) {
StringBuilder hqlQuery = new StringBuilder("delete from ");
builder.append(entityClassToUse(method).getName());
if (descriptor.props != null && !descriptor.props.isEmpty()) {
builder.append(" where ");
argIndex = 0;
for (PropertyAndComparator pac : descriptor.props) {
// ajout des différents paramètres
builder.append(buildHQLRestrictionForProperty(pac, argIndex));
argIndex += pac.comparator.nbArguments;
}
}

Query query = obtainSession().createQuery(hqlQuery.toString());
argIndex = 0;
for (PropertyAndComparator pac : descriptor.props) {
// ajout des paramètres de sélection
setHQLRestriction(query, pac, args, argIndex);
argIndex += pac.comparator.nbArguments;
}
} else {
// finder
}
}

avec pour la méthode buildHQLRestrictionForProperty et setHQLRestriction :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

private String buildHQLRestrictionForProperty(PropertyAndComparator pac, int argOffset) {
switch (pac.comparator) {
case Between:
return pac.property + " between :arg" + argOffset + " and :arg" + (angOffser + 1);
case Equals:
return pac.property + " = :arg" + argOffset;
[...]
}
}

private void setHQLRestriction(Query query, PropertyAndComparator pac, Object[] args, int argOffset) {
switch (pac.comparator) {
case Between:
query.setParameter("arg" + argIndex, args[argIndex]);
query.setParameter("arg" + (argIndex + 1), args[argIndex + 1]);
break;
case Equals:
query.setParameter("arg" + argIndex, args[argIndex]);
break;
[...]
}
}

PS : j’ai fait ce code à la va vite, il pourrait y avoir des erreurs.

Par : Eric BOTTARD

Eric BOTTARD — Fri, 29 Jan 2010 10:40:23 +0000

Comme le mentionne PY, le code actuel sur le trunk a été enrichi pour permettre les stubs (même si je ne suis pas satisfait du couplage induit sur l’interface, il serait plus pertinent d’annoter la classe stub. On y travaille). Jetez un oeil au test nommé annotationOnItfWithSpecifiedStub

Concernant la ruse avec deux interfaces, je pense qu’un tel framework se doit d’être le moins intrusif possible (Le but est de gagner du temps, on le rappelle). S’il faut introduire une deuxième interface juste pour faire une pirouette technique, on n’a finalement rien gagné

Par : Pierre-Yves RICAU

Pierre-Yves RICAU — Fri, 29 Jan 2010 09:55:27 +0000

Le framework disponible sur le repository est bien plus complet que ce qui est présenté dans l’article, je vous invite à y faire un tour c’est très instructif.

Citation de l’article : Il serait donc bon de pouvoir combiner des méthodes réellement écrites à la main (dans un « stub » de DAO, abstrait donc) et les méthodes générées automagiquement par notre librairie. [...] cela requiert l’utilisation d’une librairie telle que cglib.

On pourrait aussi y parvenir d’une manière sioux en utilisant uniquement les proxy JDK : en définissant une interface mère comportant la définition des méthodes à la mano, et un stub qui implémenterait uniquement cette interface.

Exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

public interface IStubUserDAO {
Stroumph myCustomMethod();
}

[...]

@DataAccessObject(entityType=User.class)
public interface IUserDAO extends IStubUserDAO {
User findByFirstname(String firstname);
}

[...]

public class StubUserDAO implements IStubUserDAO {
public Stroumph myCustomMethod() {
return new GrandStroumph();
}
}

[...]

ClassLoader cl = IUserDAO.class.getClassLoader();
InvocationHandler h = new MyInvocationHandler(IUserDAO.class, new StubUserDAO());
IUserDAO dao = (IUserDAO) Proxy.newProxyInstance(cl, new Class[] {IUserDAO.class}, h);

dao.findByFirstname("");
dao.myCustomMethod();
[...]