La classe de proxy dynamique Java est située dans le package java.lang.reflect, et implique généralement principalement les deux classes suivantes:
(1) InvocationHandler: une seule méthode est définie dans cette interface
Invoque d'objet public (objet obj, méthode de la méthode, objet [] args)
Dans une utilisation réelle, le premier paramètre OBJ fait généralement référence à la classe proxy, la méthode est la méthode proxy, telle que request () dans l'exemple ci-dessus, les args sont 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 de proxy dynamique, et sa fonction est similaire au proxysubject dans l'exemple ci-dessus, qui contient principalement le contenu suivant protégée (invocationHandler h): un constructeur, utilisé pour attribuer des valeurs aux valeurs aux valeurs interne h.
classe statique getProxyclass (chargeur classloader, classe [] interfaces)
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 (Classloader Loader, Class [] Interfaces, InvocationHandler H)
Renvoie une instance de la classe proxy.
Le soi-disant proxy dynamique est une classe: c'est une classe générée à l'exécution. Bien sûr, vous pouvez utiliser l'instance de la classe comme n'importe laquelle de ces interfaces. Bien sûr, ce proxy dynamique est en fait un proxy, qui ne fera pas de travail substantiel pour vous.
Lorsque vous utilisez des classes de proxy dynamiques, nous devons implémenter l'interface invocationHandler:
Voir le programme Subject.java
Voir le programme realSubject.java
Voir le programme Dynamicsubject.java
Voir le programme client.java
La copie de code est la suivante:
Package com.langsin.damicproxy;
// Rôle abstrait (auparavant c'était une classe abstraite, elle doit être changée en une interface ici):
Sujet de l'interface publique
{
Résumé Public Void Request ();
}
La copie de code est la suivante:
Package com.langsin.damicproxy;
// Rôle spécifique
classe publique RealSubject implémente le sujet
{
public realSubject ()
{
}
Public void request ()
{
System.out.println ("From Real Sujet.");
}
}
La copie de code est la suivante:
Package com.langsin.damicproxy;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
// Processeur proxy
/ **
* Les propriétés internes de la classe proxy sont la classe d'objets.
* De plus, la méthode invoquée est également mise en œuvre dans cette classe, Method.invoke (sub, args);
* En fait, il s'agit d'appeler la méthode à exécuter par l'objet proxy.
* Args est le paramètre requis pour effectuer le fonctionnement correspondant de l'objet proxy.
* Grâce à des classes de proxy dynamiques, nous pouvons effectuer des opérations connexes avant ou après l'appel
* /
Classe publique DynamicsUbject implémente InvocationHandler
{
objet privé sub;
public dynamicsubject ()
{
}
Public Dynamicsubject (objet obj)
{
sub = obj;
}
invoque d'objet public (proxy d'objet, méthode de la méthode, objet [] args) lance le jetable
{
System.out.println ("avant d'appeler" + méthode);
Method.invoke (sub, args);
System.out.println ("après appel" + méthode);
retourner null;
}
}
La copie de code est la suivante:
Package com.langsin.damicproxy;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.proxy;
//Client
Client de classe publique
{
STATIC PUBLIC VOID MAIN (String [] args) lance le jetable
{
RealSubject rs = new realSubject ();
InvocationHandler ds = new dynamicsubject (rs);
Classe <?> CLS = Rs.GetClass ();
// Ce qui suit est un agent de génération unique
Sujet sujet = (sujet) proxy.newproxyinstance (
Cls.getClassloadher (), Cls.getInterfaces (), DS);
sujet.request ();
}
}
Exemple 2:
La copie de code est la suivante:
Package com.langsin.damicproxy;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
import java.lang.reflect.proxy;
Importer java.util.list;
Importer java.util.vector;
classe publique VectorProxy implémente InvocationHandler
{
objet privé ProxyObj;
public vectorproxy (objet obj) {
proxyobj = obj;
}
usine d'objet statique publique (objet obj) {
Classe <?> CLS = obj.getClass ();
return proxy.newProxyInstance (cls.getClassloader (), cls.getInterfaces (), new VectorProxy (obj));
}
invoque d'objet public (proxy d'objet, méthode de la méthode, objet [] args) lance throwable {
System.out.println ("avant d'appeler" + méthode);
if (args! = null) {
pour (int i = 0; i <args.length; i ++) {
System.out.println (args [i] + "");
}
}
Objet objet = méthode.invoke (proxyoBj, args);
System.out.println ("après appel" + méthode);
retour objet;
}
@SuppressWarnings ("non contrôlé")
public static void main (String [] args) {
List <string> v = (list <string>) factory (new vector <string> (10));
v.add ("nouveau");
v.add ("York");
System.out.println (v);
V.Remove (0);
System.out.println (v);
}
}
Exemple 3.
La copie de code est la suivante:
Package com.langsin.damicproxy;
interface publique foo {
vide doaction ();
}
Package com.langsin.damicproxy;
classe publique fooimpl implémente foo {
public fooimpl () {
}
public void doaction () {
System.out.println ("dans fooImp1.doaction ()");
}
}
Package com.langsin.damicproxy;
classe publique fooimpl2 implémente foo {
public fooimpl2 () {
}
public void doaction () {
System.out.println ("dans fooImp2.doaction ()");
}
}
Package com.langsin.damicproxy;
import java.lang.reflect.invocationhandler;
import java.lang.reflect.method;
classe publique CommonInvocationHandler implémente invocationhandler {
// Exécution dynamique des objets, objets qui nécessitent des rappels
cible d'objet privé;
// soutient l'injection du constructeur
public CommonInvocationHandler () {
}
// soutient l'injection du constructeur
public CommonInvocationHandler (cible d'objet) {
Settarget (cible);
}
/ **
*
* Utilisez la méthode du secteur pour injecter
*
* Target @param
*
* /
public void Settarget (cible d'objet) {
this.target = cible;
}
/ **
*
* Appelez la méthode spécifiée dans proxy et transmettez dans la liste des paramètres args
*
* Proxy @param
* Le type de classe proxy, tel que la définition de l'interface proxy correspondant à la méthode
*
* Méthode @param
* Méthode d'être proxy
*
* @param args
* Paramètres qui appellent la méthode proxy
*
* @retour
*
* @throws java.lang.throwable
*
* /
invoque d'objet public (proxy d'objet, méthode de la méthode, objet [] args) lance throwable {
Retour Method.Invoke (Target, Args);
}
}
Package com.langsin.damicproxy;
import java.lang.reflect.proxy;
Demo de classe publique {
public static void main (String [] args) {
// 1. Implémentation générale de proxy dynamique
CommonInvocationHandler Handler = new CommonInvocationHandler ();
Foo f;
// 2. Implémentation d'interface 1
handler.setTarget (new fooImpl ());
// Méthode Paramètre Description: Classe proxy, liste d'implémentation de classe proxy, processeur de classe proxy
// associer la classe proxy, les méthodes d'interface et les processeurs dans la classe proxy.
// Si la classe proxy n'implémente pas la liste d'interface spécifiée, une exception de paramètre illégal sera jetée
f = (foo) proxy.newproxyinstance (foo.class.getClassloader (),
Nouvelle classe [] {foo.class},
gestionnaire);
f.doaction ();
// 3. Implémentation d'interface 2
handler.setTtarget (new fooimpl2 ());
f = (foo) proxy.newproxyinstance (foo.class.getClassloader (),
Nouvelle classe [] {foo.class},
gestionnaire);
f.doaction ();
}
}
Parce que j'ai un talent littéraire limité, la plupart du contenu est le code.