Modèle de proxy (Proxy)----Modèle de conception Java
Le mode proxy, voir le sens du texte, consiste à proxy un objet d'une classe, et à vérifier et développer son comportement.
La culture provient de la vie, et l'agence est chargée de représenter les parties pour mener à bien certaines activités que les parties (ici se réfèrent à ) doivent faire.
Annuaire d'articles
Ce que c'est?
Qu'est-ce que le mode proxy ?
En termes simples, fournit un proxy pour les objets qui utilisent cet objet pour contrôler l'accès d'utilisation des extensions à cet objet. Le modèle proxy est utilisé lorsqu'un objet ne peut pas être directement remis ou n'est pas apte à être appelé directement par un autre objet.
Le modèle de proxy est largement utilisé en Java, et il en existe des traces partout.
Modèles et structures de proxy courants
Le mode proxy est très important dans la réflexion sur la programmation. Généralement, il existe les modes proxy suivants :
1. Proxy statique
Le proxy statique réalise principalement la même classe ou interface parent via l'objet proxy et l'objet proxy. En agrégeant l'objet proxy dans l'objet proxy, la même méthode de comportement est également définie dans l'objet proxy pour encapsuler et développer la méthode d'origine, et en appel de l'objet proxy La méthode dans implémente la méthode qui exécute l'objet d'origine.
2. Proxy dynamique
Le proxy dynamique réalise l'amélioration de la méthode statique, c'est-à-dire que l'objet proxy n'a pas besoin d'hériter de la classe ou de la méthode parente et utilise l'API JDK. La clé consiste à générer dynamiquement l'objet proxy pour le proxy via Proxy.newProxyInstance () méthode.
agent 3.cglib
Les proxys cglib implémentent des proxys pour des objets individuels, sans exiger que les objets implémentent une superclasse ou une interface. Cependant, ce type d'agent doit se référer au package cglib et implémenter l'agent via la couche inférieure de java. Cela ne sera pas expliqué en détail ici. Les amis intéressés peuvent consulter le modèle de conception Java de M. Han Shunping à la station b pour apprendre!
4. Plusieurs modes de proxy variantes
Il existe plusieurs modes d'agent variantes courants, et les amis intéressés peuvent en apprendre par eux-mêmes ~
Code source d'implémentation de proxy statique
ITeacherDao (classe mère)
package com.design_patterns.proxy.staticproxy;
public interface ITeacherDao {
//授课的方法
void teach();
}
TeacherDao (objet proxy)
package com.design_patterns.proxy.staticproxy;
public class TeacherDao implements ITeacherDao {
@Override
public void teach() {
System.out.println("老师正在授课中...");
}
}
TeacherDaoProxy (objet proxy)
package com.design_patterns.proxy.staticproxy;
//代理对象，静态代理
public class TeacherDaoProxy implements ITeacherDao {
private ITeacherDao iTeacherDao; //定义目标对象，通过接口来进行聚合
public TeacherDaoProxy(ITeacherDao iTeacherDao) {
this.iTeacherDao = iTeacherDao;
}
@Override
public void teach() {
System.out.println("代理开始, 完成某些操作......");
iTeacherDao.teach();
System.out.println("代理结束......");
}
}
Client
package com.design_patterns.proxy.staticproxy;
public class Client {
public static void main(String[] args) {
//创建目标对象
TeacherDao teacherDao = new TeacherDao();
//创建代理对象，同时将被代理对象传递给代理对象
TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao);
//通过代理对象，调用到被代理对象的方法
//即：执行的是代理对象的方法，代理对象再去调用目标对象的方法
teacherDaoProxy.teach();
}
}
Code source de mise en œuvre du proxy dynamique
ITeacherDao (classe mère)
package com.design_patterns.proxy.dynamicproxy;
//定义接口
public interface ITeacherDao {
//定义用于教授的方法
void teach();
}
TeacherDao (objet proxy)
package com.design_patterns.proxy.dynamicproxy;
public class TeacherDao implements ITeacherDao {
@Override
public void teach() {
System.out.println("老师正在授课中......");
}
}
ProxyFactory (usine de proxy)
package com.design_patterns.proxy.dynamicproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 代理对象生产工厂
*/
public class ProxyFactory {
//维护一个目标对象，Object
private Object target;
//定义构造方法，对 target 进行初始化
public ProxyFactory(Object target) {
this.target = target;
}
/**
* 1. ClassLoader loader:指定当前目标对象使用的类加载器，获取加载器的方法固定
* 2. Class<?>[] interfaces:目标对象实现的接口类型，使用泛型方法确认类型
* 3. InvocationHandler h: 事情处理，执行目标对象的方法时，会触发事情处理器方法，
* 会把当前执行的目标对象方法作为参数传入
* @return
*/
public Object getProxyInstance(){
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("JDK代理开始~~~~");
Object invoke = method.invoke(target, args);
System.out.println("JDK代理结束~~~~");
return invoke;
}
});
}
}
Client
package com.design_patterns.proxy.dynamicproxy;
//测试类
public class Client {
public static void main(String[] args) {
//创建目标对象
ITeacherDao iTeacherDao = new TeacherDao();
//给目标对象，创建代理对象
ITeacherDao proxyInstance = (ITeacherDao)new ProxyFactory(iTeacherDao).getProxyInstance();
proxyInstance.teach();
}
}
Résumer
Très bien ~ Terminé ! C'est le mode proxy. Ce que mon frère a dit est peut-être un peu approximatif, hehe, mais le principe est fondamentalement le même. Les amis doivent comprendre. S'il y a quelque chose que vous ne comprenez pas, veuillez laisser un message ci-dessous pour en discuter. Will répondez certainement!