Modo proxy (Proxy)----modo de diseño

Patrón de proxy (Proxy)----Patrón de diseño de Java

El modo proxy, ver el significado del texto, es representar un objeto de una clase y verificar y expandir su comportamiento.

La cultura se origina en la vida, y la agencia se encarga de representar a las partes para llevar a cabo algunas actividades que las partes (aquí se refiere a ) deben hacer.

¿Lo que es?

¿Qué es el modo proxy?

En términos simples, proporciona un proxy para objetos que usan este objeto para controlar el acceso de uso de extensiones a este objeto. El patrón proxy se utiliza cuando un objeto no se puede entregar directamente o no es adecuado para que otro objeto lo llame directamente.

El patrón de proxy se usa ampliamente en Java y hay rastros de él en todas partes.

Estructuras y patrones de proxy comunes

El modo proxy es muy importante en el pensamiento de programación. Generalmente, existen los siguientes modos proxy:

1. Proxy estático

El proxy estático realiza principalmente la misma clase principal o interfaz a través del objeto proxy y el objeto proxy. Al agregar el objeto proxy en el objeto proxy, el mismo método de comportamiento también se define en el objeto proxy para encapsular y expandir el método original, y al llamando al objeto proxy El método en implementa el método que ejecuta el objeto original.

2. Proxy dinámico

El proxy dinámico se da cuenta de la mejora del método estático, es decir, el objeto proxy no necesita heredar la clase o el método principal, y utiliza la API de JDK. La clave es generar dinámicamente el objeto proxy para el proxy a través de Proxy.newProxyInstance () método.

agente 3.cglib

Los proxies cglib implementan proxies para objetos individuales, sin requerir que los objetos implementen una superclase o interfaz. Sin embargo, este tipo de agente debe hacer referencia al paquete cglib e implementar el agente a través de la capa inferior de java. No se explicará en detalle aquí. Los amigos interesados ​​pueden ir al patrón de diseño de Java del Sr. Han Shunping en la estación b para ¡aprender!

4. Varios modos de proxy variantes

Hay varios modos de agente de variantes comunes, y los amigos interesados ​​​​pueden aprender sobre ellos por sí mismos ~

Código fuente de implementación de proxy estático

ITeacherDao (clase principal)

package com.design_patterns.proxy.staticproxy;

public interface ITeacherDao {
    
    
    //授课的方法
    void teach();
}

TeacherDao (objeto proxy)

package com.design_patterns.proxy.staticproxy;

public class TeacherDao implements ITeacherDao {
    
    

    @Override
    public void teach() {
    
    
        System.out.println("老师正在授课中...");
    }
}

TeacherDaoProxy (objeto 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("代理结束......");
    }
}

Cliente

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();
    }
}

Código fuente de implementación de proxy dinámico

ITeacherDao (clase principal)

package com.design_patterns.proxy.dynamicproxy;

//定义接口
public interface ITeacherDao {
    
    
    //定义用于教授的方法
    void teach();
}

TeacherDao (objeto proxy)

package com.design_patterns.proxy.dynamicproxy;

public class TeacherDao implements ITeacherDao {
    
    

    @Override
    public void teach() {
    
    
        System.out.println("老师正在授课中......");
    }
}

ProxyFactory (fábrica 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;
                    }
                });
    }
}

Cliente

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();
    }
}

Resumir

Muy bien ~ ¡Listo! Este es el modo proxy. Lo que dijo mi hermano puede ser un poco rudo, jeje, pero el principio es básicamente el mismo. Los amigos deben entender. Si hay algo que no entiende, deje un mensaje a continuación para discutirlo. Will definitivamente responde!