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 .