代理设计模式

最新推荐文章于 2024-07-27 18:05:15 发布

雨落GJS

最新推荐文章于 2024-07-27 18:05:15 发布

阅读量205

点赞数

分类专栏：设计模式文章标签：设计模式代理模式 java

本文链接：https://blog.csdn.net/GJS200010/article/details/126839451

版权

设计模式专栏收录该内容

22 篇文章 0 订阅

订阅专栏

代理模式

代理模式的基本介绍

1）代理模式：为一个对象提供一个替身，以控制对这个对象的访问。即通过代理对象访问目标对象，这样做的好处是：可以在目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能

2）被代理的对象可以是远程对象、创建开销大的对象或需要安全控制的对象

3）带模式有不同的形式，主要有三种静态代理、动态代理（JDK代理、接口代理）和CGlib代理（可以在内存动态的创建对象，而不需要实现接口，他是属于动态代理的范畴）

4）代理模式示意图

在这里插入图片描述

1、静态代理

静态代理在使用时，需要定义接口或者父类，被代理对象（即目标对象）与代理对象一起实现相同的接口或者时继承相同父类

应用实例

具体要求

1）定义一个接口:ITeacher

2）目标对象Teacher实现接口ITeacher

3）使用静态代理方式，就需要在代理对象TeacherProxy中也实现ITeacher接口

4）调用的时候通过调用代理对象的方法来调用目标对象

在这里插入图片描述

package designPatterns.proxy.staticproxy;

//接口
public interface ITeacher {
    void teach();//授课方法
}

package designPatterns.proxy.staticproxy;

//被代理类
public class Teacher implements ITeacher{
    @Override
    public void teach() {
        System.out.println("上课！同学们好！座！");
    }
}

package designPatterns.proxy.staticproxy;

//代理类（静态代理）
public class TeacherProxy implements ITeacher {

    private ITeacher teacher;

    public TeacherProxy(ITeacher teacher) {
        this.teacher = teacher;
    }

    @Override
    public void teach() {
        System.out.println("我是代理，同学们上课不要迟到哈，不然没饭吃");
        teacher.teach();
        System.out.println("同学们快点去吃饭");
    }
}

package designPatterns.proxy.staticproxy;

public class TestMain {
    public static void main(String[] args){
        Teacher teacher = new Teacher();
        TeacherProxy teacherProxy = new TeacherProxy(teacher);
        teacherProxy.teach();
    }
}

静态代理优缺点

1）优点：在不修改目标对象的功能前提下，能通过代理对象对目标功能扩展

2）缺点：因为代理对象需要与目标对象实现一样的接口，所以会有很多代理类

3）一旦接口增加方法，目标对象与代理对象都要维护

2、动态代理

动态代理模式的基本介绍

1）代理对象，不需要实现接口，但是目标对象要实现接口，否则不能用动态代理

2）代理对象的生成，是利用jdk的api，动态的在内存中构建代理对象那个

3）动态代理也叫做：jdk代理、接口代理

jdk中生成代理对象的api

1）代理类所在包：java.lang.reflect.Proxy

在这里插入图片描述

动态代理应用实例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jFGUDfTU-1663066780054)(C:\Users\gaojiashun\AppData\Roaming\Typora\typora-user-images\image-20220913184428456.png)]

package designPatterns.proxy.dynamicproxy;

//接口
public interface ITeacher {
    void teach();//教书
}

package designPatterns.proxy.dynamicproxy;

//老师类
public class Teacher implements ITeacher{
    @Override
    public void teach() {
        System.out.println("老师快点去上课...上课中...");
    }
}

package designPatterns.proxy.dynamicproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class ProxyFactory {

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        /**
         *     public static Object newProxyInstance(ClassLoader loader,
         *                                           Class<?>[] interfaces,
         *                                           InvocationHandler h)
         *  ClassLoader loader:指定当前目标对象使用的类加载器，获取加载器的方法固定
         *  Class<?>[] interfaces:目标对象实现的接口类型，使用泛型方法确认类型
         *  InvocationHandler h:事情处理，执行目标对象的方法时，会触发事情处理器方法，会把当前执行目标对象方法作为参数传入
         *
         */
        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("我是代理，你要干什么要经过我的同意");
                        //通过反射机制触发方法
                        Object value = method.invoke(target, args);
                        System.out.println("我是代理，你做了什么事情，我看的一清二楚");
                        return value;
                    }
                }
        );
    }

}

package designPatterns.proxy.dynamicproxy;

public class TestMain {
    public static void main(String[] args){
        Teacher teacher = new Teacher();
        ProxyFactory proxyFactory = new ProxyFactory(teacher);
        ITeacher proxy = (ITeacher) proxyFactory.getProxy();
        proxy.teach();
    }
}

3、Cglib代理

1）静态代理和jdk代理模式都要求目标对象实现是实现一个接口，但是有时候目标对象只是一个单独的对象，并没有实现如何接口，这个时候可使用目标对象子类来实现代理-这就是Cglib代理

2）Cglib代理也叫做子类代理，它是在内存中构建一个子类对象从而实现对目标对象功能扩展，有些书也将cglib代理归属到动态代理。

3）cglib是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口，它广泛的被许多aop的框架是使用，例如Spring Aop,实现方法拦截

4）在Aop编程中如何选择代理模式：

目标对象需要实现接口，用jdk代理
目标对象不需要实现接口，用cglib代理

5）cglib包的底层是通过使用子接口处理框架ASM来转换字节码并生成新的类

Cgli代理模式实现步骤

1）引入cglib的jar文件

创建maven工程，引入依赖

<!--cglib依赖-->
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.1</version>
</dependency>

2）在内存中动态构建子类，注意代理的类不能为final，否则报错

java.langIllegalArgumentException

3）目标对象的方法如果为final/static,那么就不会被拦截，即不会执行目标对象额外的业务方法

cglib代理模式应用实例

在这里插入图片描述

public class Teacher {

    public void teach(){
        System.out.println("老师正在上课中。。。");
    }

}

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

//实现MethodInterceptor
public class ProxyFactory implements MethodInterceptor {
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy() {
        //创建一个工具类
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(target.getClass());
        //设置回调函数
        enhancer.setCallback(this);
        //创建子类对象，即代理
        return enhancer.create();
    }

    //重写intercept方法，会调用目标对象方法
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("我是Cglib代理，你想要上课，那得先给我交学费");
        Object value = method.invoke(target, objects);
        System.out.println("回去好好复习老师教的功课啊");
        return value;
    }
}

public class TestMain {
    public static void main(String[] args){
        Teacher teacher = new Teacher();
        ProxyFactory proxyFactory = new ProxyFactory(teacher);
        Teacher proxy = (Teacher) proxyFactory.getProxy();
        //执行代理对象方法触发intercept方法，从而实现对目标对象的调用
        proxy.teach();

    }
}