Discussion :

[Emplyst]

Bon lundi!
Comme a chaque lundi j'ai ma petite question hehe.

Tout d'abord je ne parle pas de la technologie utilise en reseautique

Comme le titre l'indique je me questionne actuellement sur le fonctionnement du concept des proxy en java, je pige pas trop l'utilite et le fonctionnement. A ce que j'ai compris ce permetterais d'adopter une interface dynamiquement, mais disons que j'ai pas trop compris l'interet et sans pus le fonctionnement.

Enfin bref, voici une classe test fournit avec le chapitre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
/**
   @version 1.00 2000-04-13
   @author Cay Horstmann
*/
 
import java.lang.reflect.*;
import java.util.*;
 
public class ProxyTest
{  
   public static void main(String[] args)
   {  
      Object[] elements = new Object[1000];
 
      // fill elements with proxies for the integers 1 ... 1000
      for (int i = 0; i < elements.length; i++)
      {
         Integer value = i + 1;
         Class[] interfaces = value.getClass().getInterfaces();
         InvocationHandler handler = new TraceHandler(value);
         Object proxy = Proxy.newProxyInstance(null,
            interfaces, handler);
         elements[i] = proxy;
      }
 
      // construct a random integer
      Integer key = new Random().nextInt(elements.length) + 1;
 
      // search for the key
      int result = Arrays.binarySearch(elements, key);
 
      // print match if found
      if (result >= 0) System.out.println(elements[result]);
   }
}
 
/**
   An invocation handler that prints out the method name
   and parameters, then invokes the original method
*/
class TraceHandler implements InvocationHandler
{ 
   /**
      Constructs a TraceHandler
      @param t the implicit parameter of the method call
   */
   public TraceHandler(Object t)
   {  
      target = t;
   }
 
   public Object invoke(Object proxy, Method m, Object[] args) throws Throwable
   {  
      // print implicit argument
      System.out.print(target);
      // print method name
      System.out.print("." + m.getName() + "(");
      // print explicit arguments
      if (args != null)
      {
         for (int i = 0; i < args.length; i++)
         {  
            System.out.print(args[i]);
            if (i < args.length - 1)
               System.out.print(", ");
         }
      }
      System.out.println(")");
 
      // invoke actual method
      return m.invoke(target, args);
   }
 
   private Object target;
}

Ah j'oubliais ma question, en fait elle est plutot simple, si vous pourriez m'expliquer grossierement c'est quoi l'idee de ce truc et son interet sans trop vous casser la tete ca serait bien .

[adiGuba]

Salut,


Un Proxy permet de créer un objet implémentant une ou plusieurs interfaces de manière dynamique.

Cela permet entre autres :

• De proposer une implémentation complêtement dynamique, par rapport à des fichiers de configuration ou des annotations, comme ce sera le cas dans JDBC 4.0 (Lire : Mustang, JDBC 4.0 et les Annotations, même si les choses ont quelques peu évolué depuis cette article).
• D'effectuer des traitements avant et/ou après l'exécution d'un méthode. Ainsi dans ton exemple, lorsqu'une des méthodes des interfaces de Integer (soit Comparable) est appellé, c'est la méthode invoke() de ton Handler qui est appellé en réalité. Et ce dernier peut affiche le nom de la méthode et ses paramètres avant de l'appeller réellement...
• Tu peux carrément faire des Proxy qui se contente de logger les appels de méthodes, pratique pour débugger les evénéments de composants Swing (Par exemple : InvocationHandler)

Bref l'idée c'est de rediriger les appels de méthodes vers la méthodes invoke(), afin d'y effectuer un traitement quelconque...

a++

[Emplyst]

Okay, donc c'est plutot rare qu'on a besoin de ce genre de technique de programmation.

Enfin bref un gros merci adiGuba!