En el contenido de la Enciclopedia Baidu :
AOPes Aspect Oriented Programmingel acrónimo que significa: Programación Orientada a Aspectos, una técnica para mantener dinámicamente las funciones de un programa unificado implementado por la agencia durante el modo precompilado y de ejecución. AOPEs OOPuna continuación, es un punto caliente en el desarrollo de software, pero también Springun elemento importante en el marco es una programación funcional tipo Yansheng Fan. El uso AOPpuede aislar las diversas partes de la lógica empresarial, reduciendo así el acoplamiento entre las diversas partes de la lógica empresarial, mejorando la reutilización del programa y mejorando la eficiencia del desarrollo al mismo tiempo.
1. Proxy estático
En el proceso de desarrollo del proyecto, existe un pensamiento acordado: la expansión de funciones debe expandirse sin cambiar las funciones originales. Luego, debe presentar un agente de tercer problema . Este tipo de pensamiento Servicetiene una mejor realización en la capa anterior . Por ejemplo, si necesitamos ServiceImplexpandir una determinada clase, podemos escribir una clase adicional para implementar esta Serviceinterfaz y luego agregar el código que necesitamos agregar. Este tipo de proxy también es un proxy estático. Por ejemplo, el siguiente ejemplo:
public interface UserDao {
String getUserName();
}
public class UserDaoImpl implements UserDao{
public String getUserName() {
return "张三";
}
}
public interface UserService {
String getUserInfo();
}
public class UserServiceImpl implements UserService{
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public String getUserInfo() {
return userDao.getUserName();
}
}
Por ejemplo, probamos en este momento:
@Test
public void getUserInfoTest(){
UserServiceImpl userService = new UserServiceImpl();
userService.setUserDao(new UserDaoImpl());
System.out.println(userService.getUserInfo());
}
Cuando necesitamos getUserInfoconsultar información adicional cada vez que estamos allí, necesitamos usar una clase de proxy para lograrlo.
public class proxy implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public String getUserInfo() {
doSomething();
return userDao.getUserName();
}
private void doSomething() {
System.out.println("做一些事情");
}
}
@Test
public void getUserInfoTest(){
proxy userServiceProxy = new proxy();
userServiceProxy.setUserDao(new UserDaoImpl());
System.out.println(userServiceProxy.getUserInfo());
}
Esta idea, similar al modo adaptador, es principalmente adecuada para agregar algunas funciones sin cambiar el código original. Esto también se denomina modo proxy estático. La principal desventaja de este enfoque es que si A,, B... todo está personalizado, se agrega más clase de proxy, el resultado es obvio es escribir mucha duplicación de código. Así que aquí tenemos que introducir el modo de proxy dinámico.
2. Proxy dinámico
En este momento, esperamos que cuando agreguemos algunas funciones nuevas, no agreguemos muchas clases y agreguemos mucho código repetitivo. La técnica que debe usarse aquí es Javala reflexión en el medio.
Los agentes dinámicos se pueden dividir en dos categorías:
- Proxy dinámico JDK basado en interfaz;
- –Cglib basado en clases;
- implementación de código de bytes de Java;
Necesita usar InvocationHandlery Proxydos clases:
InvocationHandler: Llama al controlador y devuelve un resultado;Proxy: Proporciona métodos estáticos para crear instancias y clases de proxy dinámico, que se utilizan para generar esta instancia de proxy dinámico;
En este punto, eliminamos la clase de proxy proxyy luego escribimos una clase que implementa la InvocationHandlerinterfaz para implementar el proxy dinámico.
En primer lugar, aclare las necesidades de este momento o Serviceamplíe las funciones de la capa, lo que debe hacerse mediante el uso de un agente.
public class MyInvocationHandler implements InvocationHandler {
// 需要扩充的接口对象【或者，需要代理的接口对象】
UserService userService;
public void setUserService(UserService userService) {
this.userService = userService;
}
// 生成代理类对象，也就是需要扩充的接口对象UserService
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
userService.getClass().getInterfaces(), this);
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 新增功能调用
doSomethings();
// 传入需要动态代理的对象
return method.invoke(userService, args);
}
// 这里是扩充内容
private void doSomethings(){
System.out.println("做一些事情。");
}
}
Para realizar la prueba, también puede ServiceImplimprimir una oración en la sección anterior , como por ejemplo:
public class UserServiceImpl implements UserService{
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public String getUserInfo() {
System.out.println("以前的getUserInfo接口的扩充");
return userDao.getUserName();
}
}
prueba:
@Test
public void getUserInfoTest(){
UserServiceImpl userService = new UserServiceImpl();
userService.setUserDao(new UserDaoImpl());
MyInvocationHandler handler = new MyInvocationHandler();
handler.setUserService(userService);
// 新的UserService对象，实现了新增功能，但是我们这里并没有去真的用类来创建
UserService userService1 = (UserService) handler.getProxy();
System.out.println(userService1.getUserInfo());
}
En otras palabras, UserServiceImplesta vez no modificamos las clases en el proyecto original , y cuando el proyecto se estaba ejecutando, las getUserInfofunciones originales todavía se llamaban y se llamaban las nuevas funciones en nuestros requisitos.
- Una clase de proxy dinámico puede proxy de varias clases, siempre que se implemente la interfaz correspondiente;
- Clase de proxy dinámico, cuyo proxy es la interfaz, el proxy es un tipo de negocio;
Dirección de video: https://www.bilibili.com/video/BV1WE411d7Dv?p=19