Quels types de serveurs proxy connaissez-vous?

En Java, il existe les types de proxies suivants :

• Proxy Statique (Static Proxy) : Il est implémenté en créant une classe enveloppe séparée qui contient une référence à l'objet réel et délègue ses appels de méthodes, en ajoutant sa propre logique (par exemple, journalisation, autorisation).

  // Interface
  interface Service {
      void doSomething();
  }
  
  // Objet réel
  class RealService implements Service {
      @Override
      public void doSomething() {
          System.out.println("Action réelle");
      }
  }
  
  // Proxy statique
  class StaticServiceProxy implements Service {
      private final Service realService;
  
      public StaticServiceProxy(Service realService) {
          this.realService = realService;
      }
  
      @Override
      public void doSomething() {
          System.out.println("Avant l'appel de la méthode réelle");
          realService.doSomething();
          System.out.println("Après l'appel de la méthode réelle");
      }
  }
  

• Proxy Dynamique (Dynamic Proxy) : Créé au moment de l'exécution en utilisant Reflection API et nécessite que l'objet proxy implémente au moins une interface. Permet de générer des proxies pour plusieurs classes implémentant une même interface, sans créer une classe séparée pour chacune.

  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  
  // Gestionnaire d'appels pour proxy dynamique
  class DynamicServiceInvocationHandler implements InvocationHandler {
      private final Object target; // Objet cible
  
      public DynamicServiceInvocationHandler(Object target) {
          this.target = target;
      }
  
      @Override
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          System.out.println("Avant l'appel de la méthode " + method.getName());
          Object result = method.invoke(target, args); // Appel de la méthode de l'objet cible
          System.out.println("Après l'appel de la méthode " + method.getName());
          return result;
      }
  }
  
  // Exemple d'utilisation (pour l'interface Service du proxy statique)
  // Service realService = new RealService();
  // Service proxy = (Service) Proxy.newProxyInstance(
  //     realService.getClass().getClassLoader(),
  //     realService.getClass().getInterfaces(),
  //     new DynamicServiceInvocationHandler(realService));
  // proxy.doSomething();
  

• Proxy CGLIB : Basé sur la génération de bytecode et ne nécessite pas l'implémentation d'une interface. Peut proxyer des classes concrètes (si elles ne sont pas finales et que leurs méthodes ne sont pas finales). Plus performant que le proxy dynamique standard dans certains scénarios.

  // Exemple d'utilisation de CGLIB (nécessite une bibliothèque tierce)
  // public class RealService {
  //     public void doSomething() {
  //         System.out.println("Action réelle");
  //     }
  // }
  
  // import net.sf.cglib.proxy.MethodInterceptor;
  // import net.sf.cglib.proxy.MethodProxy;
  // import net.sf.cglib.proxy.Enhancer;
  
  // class CglibServiceInterceptor implements MethodInterceptor {
  //     @Override
  //     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
  //         System.out.println("Avant l'appel de la méthode " + method.getName());
  //         Object result = proxy.invokeSuper(obj, args); // Appel de la méthode de la superclasse (objet original)
  //         System.out.println("Après l'appel de la méthode " + method.getName());
  //         return result;
  //     }
  // }
  
  // // Exemple d'utilisation :
  // // Enhancer enhancer = new Enhancer();
  // // enhancer.setSuperclass(RealService.class);
  // // enhancer.setCallback(new CglibServiceInterceptor());
  // // RealService proxy = (RealService) enhancer.create();
  // // proxy.doSomething();
  

Principales différences :

Type de Proxy	Nécessite une Interface	Génération	Flexibilité	Performance	Application
Statique	Oui	Manuel	Faible (pour chaque classe)	Élevée	Cas simples, structure connue
Dynamique	Oui	En temps d'exécution	Élevée (pour interfaces)	Moyenne	Logique commune pour interfaces, AOP
CGLIB	Non	En temps d'exécution	Élevée (pour classes)	Élevée	AOP, proxy de classes sans interfaces