Java 代理模式

代理模式

什么是代理模式？（简单举例几个例子）

1、打王者段位一直打不上王者段位怎么办？请游戏代练。

2、过年回家自已抢不到高铁票怎么办？找黄牛帮我们抢票。

3、.......（生活中处处可见。）

由上可知，代理模式就是：

给某一个对象提供一个代理对象，并由代理对象控制对原对象的引用。

通俗滴讲就是我们常说的：中介。

有哪几种代理模式（它们的区别与优缺点）？

一般分为两种：

1、静态代理 (代理类与被代理类的关系在程序运行前就已经确定好了。)

2、动态代理 (代理类与被代理类的关系在程序运行时才确定。)

jdk动态代理

cglib动态代理

什么是静态代理？

在程序运行前就已经存在的代理类的字节码文件。

代理类和委托类的关系在运行前就确定了。

什么是动态代理？

在程序运行时，通过反射机制动态创建的。

静态代理与动态代理优缺点

优点

实现在不改变目标对象源码情况下，对目标对象进行功能扩展。

静态代理缺点

假设项目中有多个类，则需要编写多个代理类，工作量大，不好修改，不好维护，不能应对变化。

JDK动态代理缺点

被代理的类必须实现接口，未实现接口则没办法完成动态代理。

CGLIB动态代理缺点

被代理类必须不是 final 类。

代码实现代理

代码背景：某人(王五)吃苹果。

简单的代理（耦合性太强，采用继承的方式）不推荐使用

没有代理的情况下：

/**
 * 王五
 * @author oukele
 */
public class WangWu {

    /**
     * 吃苹果
     */
    public void eatApple(){
        System.out.println("王五吃苹果!");
    }

}

运行结果：

    public static void main(String[] args) {

        WangWu wangWu = new WangWu();
        wangWu.eatApple();

    }

王五吃苹果!

有代理的情况下：

(张三将削好的苹果递给王五，然后王五吃苹果！)

/**
 * 张三
 * @author oukele
 */
public class ZhangSan extends WangWu {

    @Override
    public void eatApple() {

        System.out.println("张三从众多苹果中挑了一个苹果。");
        System.out.println("1. 然后拿去洗了洗...。");
        System.out.println("2. 将苹果鲜红的外衣悄悄的脱掉...。");
        System.out.println("N. N步操作在这里省略...。");
        System.out.println("将处理好的苹果递给王五。");
        // 王五吃苹果
        super.eatApple();
    }
}

运行结果：

    public static void main(String[] args) {

        ZhangSan zhangSan = new ZhangSan();
        zhangSan.eatApple();

    }

张三从众多苹果中挑了一个苹果。

然后拿去洗了洗...。

将苹果鲜红的外衣悄悄的脱掉...。

N. N步操作在这里省略...。
将处理好的苹果递给王五。
王五吃苹果!

上面的这些例子就是一个简单的代理行为。这个简单代理，耦合性太强了。作为演示就好了。

1、静态代理

代码背景：还是上面的例子，某人(王五)吃苹果。

第一步：创建服务接口

/**
 * 吃的服务行为接口
 * @author oukele
 */
public interface Eat {
    
    /**
     * 吃的行为
     */
    void eat();
}

第二步：实现服务接口

/**
 * 王五（被代理类）
 * @author oukele
 */
public class WangWu implements Eat {
    
    @Override
    public void eat() {
        System.out.println("王五吃苹果!");
    }
}

第三步：创建代理类(让张三来帮忙削皮)

/**
 * 张三（代理类）
 *
 * @author oukele
 */
public class ZhangSan implements Eat {

    /**
     * 被代理类(王五)
     */
    private Eat eat = null;

    public ZhangSan(Eat eat){
        this.eat = eat;
    }

    @Override
    public void eat() {
        System.out.println("0.-----张三的操作-----");
        System.out.println("1.张三帮王五削好了苹果。");
        // 王五吃苹果
        eat.eat();
        System.out.println("3.王五吃完了,张三顺便帮忙收拾好。");
    }
}

第四步：进行测试

    public static void main(String[] args) {

        System.out.println("-------------------没有代理----------------------");
        // 被代理类
        WangWu wangWu = new WangWu();
        wangWu.eat();
        System.out.println("-------------------没有代理----------------------");
        System.out.println();
        System.out.println("-------------------有代理----------------------");
        // 代理类
        ZhangSan zhangSan = new ZhangSan(wangWu);
        zhangSan.eat();
        System.out.println("-------------------有代理----------------------");
    }

运行结果：

-------------------没有代理----------------------
王五吃苹果!
-------------------没有代理----------------------

-------------------有代理----------------------
0.-----张三的操作-----
1.张三帮王五削好了苹果。
王五吃苹果!
3.王五吃完了,张三顺便帮忙收拾好。
-------------------有代理----------------------

2、JDK动态代理

代码背景：还是上面的例子，某人(王五)吃苹果。

第一步：创建服务接口

/**
 * 吃的服务行为接口
 * @author oukele
 */
public interface Eat {
    
    /**
     * 吃的行为
     */
    void eat();
}

第二步：实现服务接口

/**
 * 王五（被代理类）
 * @author oukele
 */
public class WangWu implements Eat {
    
    @Override
    public void eat() {
        System.out.println("王五吃苹果!");
    }
}

第三步：创建代理类并实现 InvocationHandler 接口，这次就不叫张三来帮忙了

/**
 * 使用JDK内置的Proxy实现动态代理（代理类）
 * @author oukele
 */
public class JdkProxy implements InvocationHandler {

    /**
     * 被代理类
     */
    private Object object = null;

    private JdkProxy(){};

    public JdkProxy(Object object){
        this.object = object;
    }

    /**
     * 用户调用代理对象的什么方法，都是在调用处理器的invoke方法。【被拦截】
     * @param proxy 被代理后的对象
     * @param method 将要被执行的方法
     * @param args 调用方法时需要的参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("某某人....帮王五削好苹果。");
        Object invoke = null;
        try {
            invoke = method.invoke(object, args);
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("出现异常：" +  e.getMessage());
        }
        System.out.println("某某人....帮忙收拾好现场。");
        return invoke;
    }

}

第四步：进行测试

    public static void main(String[] args) {

        Eat eat = (Eat) Proxy.newProxyInstance(
                WangWu.class.getClassLoader(),
                WangWu.class.getInterfaces(),
                new JdkProxy(new WangWu())
                );
        eat.eat();

    }

注意 Proxy.newProxyInstance() 方法接受三个参数
    1. ClassLoader loader: 指定当前目标对象使用的类加载器,获取加载器的方法是固定的。A
    2. Class<?>[] interfaces: 指定目标对象实现的接口类型。 B
    3. InvocationHandler: 指定动态处理器,执行目标对象的方法时，触发事件处理器的方法。C
大白话：
    A: 生成代理对象使用哪个类装载器【一般我们使用的是被代理类的装载器】
    B: 生成哪个对象的代理对象，通过接口指定【指定要被代理类的接口】
    C: 生成的代理对象的方法里干什么事【实现InvocationHandler接口，我们想怎么增强原有对象的功能就随意怎么增强。】

运行结果：

某某人....帮王五削好苹果。
王五吃苹果!
某某人....帮忙收拾好现场。

3、CGLIB动态代理

其原理：通过字节码技术为一个类创建子类。

代码背景：还是上面的例子，某人(王五)吃苹果。

注意：需要 cglib 的依赖；

此处使用的版本为

        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.3.0</version>
        </dependency>

1、第一步：创建一个王五类

/**
 * 王五
 * @author oukele
 */
public class WangWu {

    /**
     * 吃苹果
     */
    public void eatApple(){
        System.out.println("王五吃苹果!");
    }

}

2、第二步：创建 CGLIB 代理类并实现 MethodInterceptor 接口

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

/**
 * Cglib 动态代理类
 * @author oukele
 */
public class CglibProxy  implements MethodInterceptor {

    /**
     *
     * @param o 由CGLib动态生成的代理类实例
     * @param method 上文中实体类所调用的被代理的方法引用
     * @param objects 参数值列表
     * @param methodProxy 生成的代理类对方法的代理引用
     * @return 代理实例的方法调用返回的值
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("某某人....帮王五削好苹果。");
        Object invoke = null;
        try {
            invoke = method.invoke(o, objects);
        }catch (Exception e){
            e.printStackTrace();
            throw new RuntimeException("出现异常：" + e.getMessage());
        }
        System.out.println("某某人....帮忙收拾好现场。");
        return invoke;
    }
}

3、第三步：进行测试

    public static void main(String[] args) {

        // 增强器，动态代码生成器
        Enhancer enhancer = new Enhancer();
        // 设置 被代理类
        enhancer.setSuperclass(WangWu.class);
        // 放置 代理类
        enhancer.setCallback(new CglibProxy());
        // 动态生成字节码并返回代理对象
        WangWu wangWu = (WangWu) enhancer.create();
        wangWu.eat();
        
        // 简写
        WangWu wangWu1 = (WangWu)Enhancer.create(
                WangWu.class,
                new CglibProxy()
        );
        wangWu1.eat(); 
        
    }

运行结果：

某某人....帮王五削好苹果。
王五吃苹果!
某某人....帮忙收拾好现场。

小结：

JDK 动态代理和 CGLIB 字节码生成的区别?

JDK动态代理

只能对实现了接口的类生成代理

CGLIB动态代理

针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法，
并覆盖其中方法实现增强，但是因为采用的是继承，所以该类或方法最好不要声明成final.

JDK 代理与 CGLIB 代理中如何选择？

目标对象是否实现了接口

是

采用JDK的动态代理

否

采用CGLIB动态代理

posted @ 2020-08-10 01:25 追梦滴小蜗牛阅读(163) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

阅读排行：
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 地球OL攻略 —— 某应届生求职总结
· 提示词工程——AI应用必不可少的技术
· Open-Sora 2.0 重磅开源！
· 周边上新：园子的第一款马克杯温暖上架

公告

昵称：追梦滴小蜗牛
园龄： 6年7个月
粉丝： 54
关注： 9

+加关注

2025年3月

日

一

二

三

四

五

六

追梦者丶

Java 代理模式

代理模式

什么是代理模式？（简单举例几个例子）

有哪几种代理模式（它们的区别与优缺点）？

代码实现代理

简单的代理（耦合性太强，采用继承的方式）不推荐使用

1、静态代理

第一步：创建服务接口

第二步：实现服务接口

第三步：创建代理类(让张三来帮忙削皮)

第四步：进行测试

2、JDK动态代理

第一步：创建服务接口

第二步：实现服务接口

第三步：创建代理类并实现 InvocationHandler 接口，这次就不叫张三来帮忙了

第四步：进行测试

3、CGLIB动态代理

1、第一步：创建一个王五类

2、第二步：创建 CGLIB 代理类并实现 MethodInterceptor 接口

3、第三步：进行测试

小结：

公告

搜索

常用链接

我的标签

积分与排名

随笔分类 (299)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

追梦者丶

Java 代理模式

代理模式

什么是代理模式？（简单举例几个例子）

有哪几种代理模式（它们的区别与优缺点）？

代码实现代理

简单的代理（耦合性太强，采用继承的方式）不推荐使用

1、静态代理

第一步：创建 服务接口

第二步：实现服务接口

第三步：创建代理类(让张三来帮忙削皮)

第四步：进行测试

2、JDK动态代理

第一步：创建 服务接口

第二步：实现服务接口

第三步：创建代理类并实现 InvocationHandler 接口，这次就不叫 张三来帮忙了

第四步：进行测试

3、CGLIB动态代理

1、第一步：创建一个 王五 类

2、第二步：创建 CGLIB 代理类 并实现 MethodInterceptor 接口

3、第三步：进行测试

小结：

公告

搜索

常用链接

我的标签

积分与排名

随笔分类 (299)

阅读排行榜

评论排行榜

推荐排行榜

最新评论

第一步：创建服务接口

第一步：创建服务接口

第三步：创建代理类并实现 InvocationHandler 接口，这次就不叫张三来帮忙了

1、第一步：创建一个王五类

2、第二步：创建 CGLIB 代理类并实现 MethodInterceptor 接口