Analyse détaillée du mode proxy Java (image et texte)

Cet article présente principalement les informations pertinentes sur JavaMode proxy en détail. Il a une certaine valeur de référence. Les amis intéressés peuvent se référer à

Le mode proxy est notre l'un des plus couramment utilisés. modèles de conception. La nouvelle idée est d'insérer un objet proxy entre l'objet réel et l'appelant afin de fournir un traitement supplémentaire ou des opérations différentes. Ces opérations supplémentaires nécessitent généralement une communication avec l'objet réel. Les rôles généralement impliqués dans le modèle proxy sont :

Rôle abstrait : déclare l'interface commune de l'objet réel et de l'objet proxy ; 🎜>
Rôle proxy : le rôle d'objet proxy contient une référence à l'objet réel en interne, afin que l'objet réel puisse être manipulé. En même temps, l'objet proxy fournit la même interface que l'objet réel afin qu'il puisse. Remplacez l'objet réel à tout moment. Dans le même temps, l'objet proxy peut ajouter d'autres opérations lors de l'exécution d'opérations sur l'objet réel, ce qui équivaut à encapsuler l'objet réel.

Rôle réel : L'objet réel représenté par le rôle proxy est l'objet que nous voulons finalement référencer.

Ce qui suit prend

l'envoi d'un message

comme exemple pour illustrer la mise en œuvre de base d'un mode proxy simple :
Clarifiez d'abord le but : il est un message qui doit être envoyé. Pour envoyer ce message, définissez l'interface MessageHandler correspondante en fonction de cet objectif. Opérations supplémentaires requises : Supposons que nous devions vérifier que la longueur du message ne peut pas dépasser la longueur spécifiée et ne peut pas être vide, et que nous devons compter le nombre de fois où les informations pertinentes sont envoyées. Si elles dépassent le nombre de fois spécifié, nous en avons besoin. pour émettre une alerte. Nous implémentons cette opération supplémentaire via le modèle proxy. Voici le diagramme de classes correspondant et l’exemple de code.

Dans l'exemple, nous pouvons facilement ajouter diverses méthodes de traitement supplémentaires requises pendant le processus d'envoi du message, et peut également remplacer facilement la façon dont les messages sont traités, par exemple en remplaçant l'envoi de messages par e-mail par l'envoi de messages par SMS, sans que l'appelant s'en rende compte ! Les proxys sont très utiles chaque fois que vous souhaitez séparer certaines opérations supplémentaires de l'objet spécifique, surtout si vous souhaitez pouvoir apporter des modifications facilement, ou si vous souhaitez insérer des opérations supplémentaires avant que la méthode de l'objet spécifique ne soit exécutée !

//接口定义  
public interface MessageHandler {  
public void sendMessage(String msg);  
}  
//通过Email方式发送消息的实现类  
public class EmailMessage implements MessageHandler {  
@Override  
public void sendMessage(String msg) {  
// TODO Auto-generated method stub  
System.out.println(msg+" send!!");  
}  
}  
//消息处理的代理类  
public class MessageProxy implements MessageHandler {  
private static int count;  
private MessageHandler emailMsg;  
@Override  
public void sendMessage(String msg) {  
// TODO Auto-generated method stub  
if(checkMessage(msg))  
{  
if(emailMsg==null) emailMsg=new EmailMessage();  
count++;  
emailMsg.sendMessage(msg);  
System.out.println("Message sent:"+count);  
}  
}  
private boolean checkMessage(String msg) {  
return msg != null && msg.length() > 10;  
}  
}  
//调用类  
public class MainClass {  
private static void runProxy(MessageHandler handler)  
{  
handler.sendMessage("message for test");  
}  
/** 
 * @param args 
 */  
public static void main(String[] args) {  
// TODO Auto-generated method stub  
runProxy(new EmailMessage());  
System.out.println("++++++++++++++++Pjroxy++++++++++++++++++");  
runProxy(new MessageProxy());  
}  
}  
//输出  
message for test send!!  
++++++++++++++++Pjroxy++++++++++++++++++  
message for test send!!  
Message sent:1

Procuration dynamique

L'introduction du mécanisme de proxy dynamique en Java a rendu l'idée du modèle de proxy plus complète et progressive. Il permet la création dynamique de proxys et prend en charge l'invocation dynamique de méthodes proxy. La classe proxy dynamique Java se trouve sous le package Java.

lang

.reflect, qui implique généralement les deux classes suivantes :
(1) Interface InvocationHandler : Cette interface définit uniquement. Une méthode

Object

 : Invoquer(Object obj,Method method, Object[] args). En utilisation réelle, le premier paramètre obj fait généralement référence à la classe proxy, method est la méthode proxy, comme request() dans l'exemple ci-dessus, et args est le tableau de paramètres de la méthode. Cette méthode abstraite est implémentée dynamiquement dans la classe proxy.
(2).Proxy : Cette classe est une classe proxy dynamique, sa fonction est similaire au ProxySubject dans l'exemple ci-dessus, qui comprend principalement le contenu suivant :

Protected Proxy(InvocationHandler h ) :

Constructeur
, estimé pour être utilisé pour attribuer une valeur au h interne. Classe statique getProxyClass (chargeur ClassLoader, interfaces Class[]) : obtenez une classe proxy, où le chargeur est le chargeur de classe et les interfaces sont un tableau de toutes les interfaces appartenant à la classe réelle.

Objet statique newProxyInstance (Chargeur ClassLoader, interfaces Class[], InvocationHandler h) : Renvoie une instance de la classe proxy. La classe proxy renvoyée peut être utilisée comme classe proxy (la classe proxy peut être. méthode utilisée déclarée dans l'interface Sujet).

Le soi-disant Dynamic Proxy est une classe : c'est une classe générée au moment de l'exécution, vous devez lui fournir un ensemble d'interfaces, puis la classe déclare qu'elle les implémente. interfaces . Vous pouvez bien sûr utiliser des instances de cette classe comme n’importe laquelle de ces interfaces. Bien entendu, ce proxy dynamique est en fait un proxy. Il ne fera pas de travail substantiel à votre place. Lors de la génération de son instance, vous devez fournir un gestionnaire qui prendra en charge le travail réel. Réimplémentons l'exemple ci-dessus d'envoi d'informations via un proxy dynamique !

Sur la base de l'exemple ci-dessus, nous ajoutons d'abord une classe de traitement pour l'envoi de messages par SMS :

public class SmsMessage implements MessageHandler {  
@Override  
public void sendMessage(String msg) {  
// TODO Auto-generated method stub  
System.out.println("SMS Message :" + msg+" sent !");  
}  
}  
//动态代理类  
import java.lang.reflect.InvocationHandler;  
import java.lang.reflect.Method;  
public class DynamicMessageProxy implements InvocationHandler {  
private static int count;  
private MessageHandler msgHandler;  
public DynamicMessageProxy(MessageHandler handler) {  
msgHandler = handler;  
}  
@Override  
public Object invoke(Object proxy, Method method, Object[] args)  
throws Throwable {  
// TODO Auto-generated method stub  
System.out.println("++++++++=============+++++++++");  
System.out.println("proxy:" + proxy.getClass());  
System.out.println("method:" + method);  
System.out.println("++++++++=============+++++++++");  
if (args != null && args.length == 1 && checkMessage((String) args[0])) {  
count++;  
System.out.println("Message sent:" + count);  
return method.invoke(msgHandler, args);  
}  
return null;  
}  
private boolean checkMessage(String msg) {  
return msg != null && msg.length() > 10;  
}  
}  
//下面是调用  
import java.lang.reflect.Proxy;  
public class MainClass {  
private static void runProxy(MessageHandler handler) {  
handler.sendMessage("message for test");  
}  
/** 
 * @param args 
 */  
public static void main(String[] args) {  
// TODO Auto-generated method stub  
// runProxy(new EmailMessage());  
// System.out.println("++++++++++++++++Proxy++++++++++++++++++");  
// runProxy(new MessageProxy());  
MessageHandler handler = new EmailMessage();  
runProxy(handler);  
MessageHandler proxy = (MessageHandler) Proxy.newProxyInstance(  
MessageHandler.class.getClassLoader(),  
new Class[] { MessageHandler.class }, new DynamicMessageProxy(  
handler));  
runProxy(proxy);  
System.out.println("++++++++++++++++++++++++++++++++++");  
// 短信方式  
handler = new SmsMessage();  
runProxy(handler);  
proxy = (MessageHandler) Proxy.newProxyInstance(MessageHandler.class  
.getClassLoader(), new Class[] { MessageHandler.class },  
new DynamicMessageProxy(handler));  
runProxy(proxy);  
}  
}  
//下面为以上方法的输出：  
message for test send!!  
++++++++=============+++++++++  
proxy:class $Proxy0  
method:public abstract void MessageHandler.sendMessage(java.lang.String)  
++++++++=============+++++++++  
Message sent:1  
message for test send!!  
++++++++++++++++++++++++++++++++++  
SMS Message :message for test sent !  
++++++++=============+++++++++  
proxy:class $Proxy0  
method:public abstract void MessageHandler.sendMessage(java.lang.String)  
++++++++=============+++++++++  
Message sent:2  
SMS Message :message for test sent !

 以上例子中，通过调用Proxy.newProxyInstance方法创建动态代理对象，该方法需要传入一个 类加载器、一组希望代理实现的接口列表、InvocationHandler 接口的一个具体实现。动态代理可以将所有调用重定向到调用处理器，通常我们会向该处理器传递一个时间对象的引用。invoke()方法中传递进来了代理对象，当你需要区分请求来源时这是非常有用的，例如你可以通过判断传入的方法名屏蔽掉某些方法的执行！动态代理机制并不是会很频繁使用的方法，它通常用来解决一些特定情况下的问题，因此不要盲目的为了使用而使用，要根据自己的实际需求来决定！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!