Acerca del proxy estático y el proxy dinámico JDK
que es un apoderado
En términos sencillos, un agente es hacer algo en nombre de alguien. Por ejemplo, si un maestro está enfermo y no puede venir a clase hoy, ¿es posible contratar a un maestro interino para ayudar con la clase? En un sentido práctico, el dos maestros Las cosas terminadas son las mismas, son todas para que los estudiantes prediquen y aprendan, pero el maestro interino puede expandir más "funciones" sobre la base de la clase original , por ejemplo, antes de que el maestro interino vaya a la clase, primero va a la siguiente clase para ver. ¿La maestra que me gusta vino de un vistazo, y después de la clase, fui a comer mis fideos de caracol favoritos ~ Al ver aquí, ¿sientes que parece una cosa, entonces el principio de La transformación orientada a aspectos de SpringAOP es así, por supuesto. El aspecto de implementación real es más complicado.
Los agentes se dividen en tres roles.
- interfaz
- clase delegada
- clase de apoderado
proxy estático
Primero hablemos sobre el proxy estático y usemos el ejemplo que dimos anteriormente para cargar directamente el código.
interfaz:
package com.staticproxy;
//我和代理老师都是老师，共同实现了老师接口
public interface Teacher {
void teach();
}
Clase delegante:
package com.staticproxy;
//这个就是生病的老师
public class MathTeacher implements Teacher {
@Override
public void teach() {
System.out.println("传道受业解惑40分钟");
}
}
clase de apoderado:
package com.staticproxy;
//这个是代理老师
public class ProxyTeacher implements Teacher {
//通过构造器注入被代理对象(注入一个生病老师的对象)
private Teacher targetTeacher;
public ProxyTeacher(Teacher teacher){
this.targetTeacher=teacher;
}
//代理老师实现了接口也有teach方法
@Override
public void teach() {
System.out.println("上课之前先去隔壁班看美女老师");
//调用生病老师的teach方法
targetTeacher.teach();
System.out.println("上完课了，去吃个螺蛳粉压压惊!");
}
}
Método principal del cliente:
package com.staticproxy;
public class Client {
public static void main(String[] args) {
Teacher teacher=new MathTeacher();
Teacher proxyteacher=new ProxyTeacher(teacher);
proxyteacher.teach();
}
}
Resultado:
el proxy estático debe eliminarse rápidamente, muy simple.
Continuemos con el proxy dinámico, que requiere el mecanismo de reflexión.
Proxy dinámico JDK
interfaz:
package com.jdkproxy;
public interface Teacher {
void teach();
}
Nada que decir sobre la misma interfaz que antes.
Clase delegante:
package com.jdkproxy;
public class MathTeacher implements Teacher {
@Override
public void teach() {
System.out.println("传道受业解惑40分钟");
}
}
Aquí viene el punto
package com.jdkproxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 注意动态代理这里不需要再实现教师接口了
* 这样才能体现动态的概念，往往在实际应用之中
* 我们是不会提前知道我们需要代理什么对象的
*/
public class ProxyTeacher {
private Object targetteacher;
public ProxyTeacher(Teacher teacher){
this.targetteacher=teacher;
}
/**
* 这里调用了Proxy的newProxyInstance方法获得代理对象
* 参数1表示被代理对象的类加载器
* 参数2是被代理对象实现的接口，可以是数组(表示实现多个接口)
* 参数3是用匿名内部类实例化一个实现了InvocationHandler接口的对象
*/
public Object getProxyInstance(){
return Proxy.newProxyInstance(targetteacher.getClass().getClassLoader(), targetteacher.getClass().getInterfaces(),
new InvocationHandler() {
/**
* @param proxy 调用这个方法的代理实例
* @param method 要调用的方法
* @param args 方法调用时所需要的参数
* @return 方法调用的结果
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("上课之前先去隔壁班看美女老师");
method.invoke(targetteacher,args);
System.out.println("上完课了，去吃个螺蛳粉压压惊");
return null;
}
});
}
}
Cliente:
package com.jdkproxy;
public class Client {
public static void main(String[] args) {
Teacher teacher=new MathTeacher();
Teacher proxyTeacher=(Teacher)new ProxyTeacher(teacher).getProxyInstance();
proxyTeacher.teach();
}
}
Resultado:
Resumen:
Por supuesto, el proxy dinámico utilizado por SpringAop es más complicado, y otras tecnologías como el proxy dinámico cglib no se extienden aquí. Solo necesitamos saber que el proxy dinámico puede continuar ampliándose e integrándose sobre la base de completar las funciones realizadas por el objeto original. La expansión, que también es una idea importante de la programación orientada a aspectos de SpringAop, se usa ampliamente en funciones como el registro, el manejo de excepciones, el monitoreo y la gestión de transacciones. Este es el principio general de orientación a aspectos. Puedes pensarlo de esta manera. Las clases son un proceso obligatorio para los maestros. En este proceso, las dos funciones de mirar bellezas y comer se cortan horizontalmente, sin afectar la realización de las funciones en absoluto.