1. Mode agent
Un agent est une personne ou une institution agissant au nom d’une autre personne ou institution. Dans certains cas, un client ne veut pas ou ne peut pas référencer directement un objet, et un objet proxy peut servir d'intermédiaire entre le client et l'objet cible.
Le modèle de proxy fournit un objet proxy pour un objet, et l'objet proxy contrôle la référence à l'objet d'origine.
Exemple concret : vous êtes occupé à faire des heures supplémentaires pendant le Nouvel An et n'avez pas le temps d'acheter des billets de train. À ce moment-là, vous pouvez appeler la billetterie la plus proche et leur demander de vous acheter un billet de train pour rentrer chez vous. ajouter des frais de main-d'œuvre supplémentaires. Mais il doit être clair que la billetterie elle-même ne vend pas de billets. Seule la gare vend réellement des billets. Les billets que la billetterie vous vend sont réellement vendus par l'intermédiaire de la gare. C'est très important !
Dans l'exemple ci-dessus, vous êtes le « client », la billetterie est le « rôle d'agent », la gare est le « rôle réel » et la vente de billets est appelée le « rôle abstrait » !
Exemple de code JAVA en mode agent :
Rôle abstrait : classe ou interface abstraite
Copiez le code comme suit :
interfaceBusiness
{
void doAction();
}
Rôle réel : implémente véritablement l'interface de logique métier
Rôle d'agent : il n'implémente pas l'interface de logique métier, mais appelle le rôle réel pour l'implémenter.
Copiez le code comme suit :
la classe BusinessImplProxy implémente Business
{
privé BusinessImpl bi;
public void doAction()
{
si (bi==nul)
{
bi = new BusinessImpl();
}
faireAvant();
bi.doAction();
faireAprès();
}
public void doBefore()
{
System.out.println("Prétraitement!");
}
public void doAfter()
{
System.out.println("Post-traitement !");
}
}
//classe de test
Test de classe
{
public static void main (String[] arguments)
{
//Les variables de référence sont définies comme types de rôles abstraits
Business bi = new BusinessImplProxy();
bi.doAction();
}
}
Copiez le code comme suit :
<span></span>
Par conséquent, avec la prise en charge de JVM, les classes proxy (« rôles d'agent ») peuvent être générées dynamiquement au moment de l'exécution, et nous pouvons résoudre le problème de l'expansion du code dans le mode proxy ci-dessus. Après avoir utilisé le proxy dynamique, les « rôles d'agent » ne seront plus nécessaires. à générer manuellement, qui est généré dynamiquement par la JVM au moment de l'exécution en spécifiant trois paramètres : le chargeur de classe, le tableau d'interface et le gestionnaire d'appel.
Exemple de code JAVA en mode proxy dynamique :
Copiez le code comme suit :
importer java.lang.reflect.InvocationHandler ;
importer java.lang.reflect.Proxy ;
importer java.lang.reflect.Method ;
//Rôle abstrait : l'implémentation du proxy dynamique Java ne prend actuellement en charge que les interfaces et ne prend pas en charge les classes abstraites
interface BusinessFoo
{
vide foo();
}
interfaceBusinessBar
{
Barre de chaîne (message de chaîne) ;
}
//Rôle réel : mettre réellement en œuvre des méthodes de logique métier
la classe BusinessFooImpl implémente BusinessFoo
{
public vide foo()
{
System.out.println("BusinessFooImpl.foo()");
}
}
la classe BusinessBarImpl implémente BusinessBar
{
barre de chaîne publique (message de chaîne)
{
System.out.println("BusinessBarImpl.bar()");
message de retour ;
}
}
//Rôle dynamique : générer dynamiquement une classe proxy
la classe BusinessImplProxy implémente InvocationHandler
{
objetprivé obj ;
BusinessImplProxy() {
}
BusinessImplProxy (Objet obj) {
ceci.obj = obj;
}
public Object Invoke (Object Proxy, Method Method, Object [] args) lance Throwable
{
Résultat de l'objet = null ;
faireAvant();
résultat = méthode.invoke(obj,args);
faireAprès();
renvoyer le résultat ;
}
public void doBefore(){
System.out.println("faire quelque chose avant Business Logic");
}
public void doAfter(){
System.out.println("faire quelque chose après la logique métier");
}
Fabrique d'objets statique publique (Objet obj)
{
Classe cls = obj.getClass();
return Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),new BusinessImplProxy(obj));
}
}
//classe de test
classe publique DynamicProxy
{
public static void main (String[] args) lance Throwable
{
BusinessFooImpl bfoo = new BusinessFooImpl();
BusinessFoo bf = (BusinessFoo)BusinessImplProxy.factory(bfoo);
bf.foo();
System.out.println();
BusinessBarImpl bbar = new BusinessBarImpl();
BusinessBar bb = (BusinessBar)BusinessImplProxy.factory(bbar);
Chaîne message = bb.bar("Bonjour, le monde");
System.out.println(message);
}
}
Description du déroulement du programme :
new BusinessFooImpl(); crée un "rôle réel", le transmet à la méthode d'usine BusinessImplProxy.factory(), puis initialise le "processeur d'invocation" - la classe qui implémente InvocationHandler. Et renvoie une instance de classe proxy créée dynamiquement. Étant donné que le « rôle d'agent » doit également implémenter les méthodes de logique métier fournies par le « rôle abstrait », il peut être transformé en BusinessBar et affecté à la référence bb pointant vers le type BusinessBar.
La méthode newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) permet aux programmeurs de spécifier des paramètres et de renvoyer dynamiquement la classe proxy requise, tandis que la méthode Invocation(Object proxy, Method method, Object[] args) est utilisée par la JVM appelée dynamiquement au moment de l'exécution. Lors de l'exécution de la méthode "bb.bar("Hello,World");" la JVM attribue dynamiquement un "gestionnaire d'invocation", transmet les paramètres à l'invocation externe et appelle method.invoke(obj, args) pour l'exécuter !
La méthode statique BusinessImplProxy.Factory est utilisée pour générer dynamiquement des classes proxy (« rôles d'agent »). Les rôles proxy sont générés dynamiquement au moment de l'exécution en fonction de différentes interfaces de logique métier BusinessFoo et BusinessBar. Le « rôle abstrait », le « rôle d'agent » et le gestionnaire d'invocation (classe qui implémente l'interface InvocationHandler) peuvent tous être modifiés, le proxy dynamique de JAVA est donc très puissant.