Java实现代理模式

最新推荐文章于 2024-03-13 00:17:43 发布
最新推荐文章于 2024-03-13 00:17:43 发布
阅读量406 收藏 1
点赞数 1
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a464700300/article/details/79879839
版权

7.2 没有代理的代码（静态代理）

追求者中间没有代理人，代理人可以代替追求者给女孩送花等。
现在没有代理人的代码
这里写图片描述

//追求者类
class Pursuit {
    SchoolGirl mm;

    public Pursuit(SchoolGirl mm){
        this.mm = mm;
    }

    public void giveDolls(){
        printf("送洋娃娃");
    }

    public void giveFlowers(){
        printf("送花");
    }

    public void giveChocolate(){
        printf("送巧克力");
    }
}

//被追求者类
class SchoolGirl {
    private String name;

    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return name;
    }
}

//客户端
public class Main{
    public static void main(String[] args){
        SchoolGirl girl = new SchoolGirl();
        girl.setName("娇娇");
    }

    //现在追求者赵直接把礼物送给娇娇，但是娇娇并不认识追求者，
    //这样写说明娇娇认识追求者赵，有逻辑错误
    Pursuit zhao = new Pursuit(girl);

    zhao.giveDolls();
    zhao.giveFlowers();
    zhao.giveChocolate();
}

事实上，追求者(Pursuit)通过代理人(Proxy)送给被追求者(SchoolGirl)

追求者和代理都有相同送礼物的三个方法。有相同的方法就可以有共同的接口。

7.4 符合实际代码

这里写图片描述

//代理接口
public interface GiveGift {
    void giveDolls();
    void giveFlowers();
    void giveChocolate();
}

//追求者类
class Pursuit implements GiveGift {
    SchoolGirl mm;

    public Pursuit(SchoolGirl mm){
        this.mm = mm;
    }

    public void giveDolls(){
        printf("送洋娃娃");
    }

    public void giveFlowers(){
        printf("送花");
    }

    public void giveChocolate(){
        printf("送巧克力");
    }
}

//代理类
class Proxy implements GiveGift {
    Pursuit gg;

    public Proxy(SchoolGirl mm){
        gg = new Pursuit(mm);
    }

    //实现方法中调用“追求者”类的方法
    public void giveDolls(){
        gg.giveDolls();
    }

    public void giveFlowers(){
        gg.giveFlowers();
    }

    public void giveChocolate(){
        gg.giveChocolate();
    }
}

//客户端
public class Main {
    public static void main(String[] args){
        SchoolGirl girl = new SchoolGirl();
        girl.setName("娇娇");

        Proxy p = new Proxy(girl);

        p.giveDolls();
        p.giveFlowers();
        p.giveChocolate();
    }
}

7.5 静态代理模式

为其他对象提供一种代理以控制这个对象的访问。

这里写图片描述
Subject类定义了RealSubject和Proxy的共用接口，在任何使用RealSubject，都可以用Proxy 

public interface Subject {
    public void request();
}

RealSubject类，定义Proxy所代表的真实实体。

public class RealSubject implements Subject {
    @Override
    public void request(){
        println("真实请求");
    }
}

Proxy类，保存一个引用使用代理可以访问实体，实现Subject接口，代理就可以用来代替实体。

public class Proxy implements Subject {
    RealSubject real;

    @Override
    public void request(){
        if(real == null){
            real = new RealSubject();
        }
        real.request();
    }
}

客户端

public class Main {
    public static void main(String[] args){
        Proxy proxy = new Proxy();
        proxy.request();
    }
}

缺点：
每一个代理类都必须实现一遍委托类（也就是realsubject）的接口，如果接口增加方法，则代理类也必须跟着修改。其次，代理类每一个接口对象对应一个委托对象，如果委托对象非常多，则静态代理类就非常臃肿，难以胜任。

7.6 动态代理

是根据代理的对象，动态创建代理类
可以避免静态代理中代理类的方法过多的问题
动态代理是实现方式，是通过反射来实现的，借助Java自带的++java.lang.reflect.Proxy++，通过固定规则生成。

步骤：

  1. 编写一个委托类的接口，即静态代理的（Subject接口）
  2. 实现一个真正的委托类，即静态代理的（RealSubject类）
  3. 创建一个动态代理类，实现 ++InvocationHandler++ 接口，并重写该 ++invoke++ 方法
  4. 在测试类中，生成动态代理的对象。

第3步的代码：

public class DynamicProxy implements InvocationHandler {
    private Object object;
    public DynamicProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object result = method.invoke(object, args);
        return result;
    }
}

第4步代码： 

public static void main(String[] args){
    Subject realSubject = new RealSubject();
    DynamicProxy proxy = new DynamicProxy(realSubject);
    ClassLoader classLoader = realSubject.getClass().getClassLoader();
    Subject subject = (Subject) Proxy.newProxyInstance(classLoader, new  Class[]{Subject.class}, proxy);
    subject.visit();    
}

创建动态代理对象，需要 ++Proxy.newProxyInstance++
该方法三个参数：

  • ClassLoader loader表示当前使用到的appClassloader。
  • Class
/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{

    //维护一个目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }

   //给目标对象生成代理对象
    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("开始事务2");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务2");
                        return returnValue;
                    }
                }
        );
    }
}

测试类

public class App {
    public static void main(String[] args) {
        // 目标对象
        IUserDao target = new UserDao();
        // 【原始的类型 class cn.itcast.b_dynamic.UserDao】
        System.out.println(target.getClass());

        // 给目标对象，创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());

        // 执行方法   【代理对象】
        proxy.save();
    }
}

总结：
代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

7.7 CGLib代理

上面的Java动态代理和静态代理都要求目标对象要实现一个接口，但有时候一个类没有实现接口，只要这个类自己，如果代理该类就要用CGLib代理。

介绍：也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.

Cglib子类代理实现方法:

  1. 需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入 ++pring-core-3.2.5.jar++ 即可
  2. 引入功能包后,就可以在内存中动态构建子类
  3. 代理的类不能为final,否则报错
  4. 目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

目标对象类:UserDao.java 

public class UserDao {
    public void save() {
        System.out.println("----已经保存数据!----");
    }
}

Cglib代理工厂:ProxyFactory.java 

/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
public class ProxyFactory implements MethodInterceptor {
    //维护目标对象
    private Object target;

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

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

        System.out.println("提交事务...");

        return returnValue;
    }
}

测试类 

public class App {

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();

        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法
        proxy.save();
    }
}

在Spring的AOP编程中:
如果加入容器的目标对象有实现接口,用JDK代理
如果目标对象没有实现接口,用Cglib代理

残念怪蜀黍
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java实现代理模式
04-14
用java实现代理模式，使用房屋中介的现实例子进行代理模式的说明
Java简单实现动态代理模式过程解析
08-18
主要介绍了Java动态代理模式简单案例代码,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java 静态代理、Java动态代理、CGLIB动态代理
qiang_zi_的专栏
05-14 533
转载 作者：树修 原文：https://www.jianshu.com/p/1682ed0d0c16 Java 的代理就是客户类不再直接和委托类打交道, 而是通过一个中间层来访问, 这个中间层就是代理。为啥要这样呢, 是因为使用代理有 2 个优势： 可以隐藏委托类的实现 可以实现客户与委托类之间的解耦, 在不修改委托类代码的情况下能够做一些额外的处理 我们举个...
java设计模式-代理模式
热门推荐
长草颜团子
04-10 21万+
代码参考(更详细,这里为了博客简洁,代码去了一些注释)https://github.com/zhang-xiaoxiang/proxy 1静态代理(接口代理) 需求(干什么):对明星唱歌的业务流程进行代理,而明星唱歌还是交由明星自己唱歌,这个流程把唱歌分成2部分了,1:歌手尽管唱歌,2:代理公司负责打杂(面谈,签合同,订票,收钱),对被代理的歌手来说,他解放了,相当于增强了,不用自己面谈......
java中的代理模式
最新发布
weixin_39038328的博客
03-13 857
java代理模式的学习：静态代理、JDK动态代理、CGLIB动态代理
java 代理（静态代理、动态代理的不同实现）详解及示例
alanchanchn的专栏
06-13 2万+
代理模式上，基本上有Subject角色，RealSubject角色，Proxy角色。Subject角色负责定义RealSubject和Proxy角色应该实现的接口；RealSubject角色用来真正完成业务服务功能；Proxy角色负责将自身的Request请求，调用realsubject 对应的request功能来实现业务功能，自己不真正做业务。代理对象和被代理对象一般实现相同的接口，调用者与代理对象进行交互。代理的存在对于调用者来说是透明的，调用者看到的只是接口。
Java 代理模式的基本概念、使用场景、应用示例和实现方法
网络技术联盟站
06-06 2520
代理模式是一种结构型设计模式，它允许我们通过添加一个代理对象来控制对另一个对象的访问。代理对象和实际对象具有相同的接口，使得客户端在不知情的情况下可以使用代理对象进行操作。代理对象在与客户端进行交互时，可以控制对实际对象的访问，以实现一些额外的功能，例如访问计数、延迟加载、权限控制等。在 Java 中，代理模式主要有两种实现方式：静态代理和动态代理。静态代理需要手动编写代理类，通常需要针对每个实际对象编写一个代理类，在系统中管理多个代理类比较麻烦。
Java代理模式
Gamble6
05-21 1073
代理模式指为其他对象提供一种代理，以控制对这个对象的访问。在某些情况下，一个对象若不能直接引用另一个对象，而代理对象可以在客户端与目标对象之间起到中介的作用。
代理模式简介和java代码实现
07-05
介绍代理模式的概念、特点、优缺点、适用场景和java代码简单实现
Java 代理 代理模式 静态代理与动态代理 常见的动态代理实现 .md
08-11
- 代理模式 - 静态代理与动态代理 - 常见的动态代理实现 - JDK Proxy - CGLIB - JDK Proxy 和 CGLIB 的对比 - 动态代理的实际应用 - Spring AOP 说在前面：今天我们来聊一聊 Java 中的代理，先来聊聊故事...
java代理模式示例源码
06-05
通过房产中介的例子介绍了java代理的实现
java代理模式
03-31
该文件包含代理模式的ppt，已经它在eclipse中的实现代码，它形象生动的描述了java24中模式中的代理模式！
用Java实现的代理模式之动态代理
03-06
带视频讲解的代理模式之动态代理，有源代码和课件，很有帮助
Java 代理模式
10-10
Java 代理模式 简单实现，这是用Java实现的Java代理模式，包括动态代理， 可以运行
设计模式-代理模式-java
05-02
自己写的Java的代理模式的实现，有兴趣的可以下载看看
Java设计模式及应用场景之《代理模式》
12-21
文章目录一、代理模式定义二、代理模式的结构和说明三、代理模式的分类四、代理模式示例五、动态代理1、JDK动态代理JDK动态代理...实现原理CGLIB动态代理注意事项六、三种代理方式的对比七、代理模式的应用场景及案例...
java 代理模式
luoj_616的专栏
06-11 179
简介 代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能. 这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法 1.1.静态代理 静态代理在使用时,需要定义接口或者父类,被代理对象与代理对象一起实现相同...
Java 代理模式详解
xuejun_1996的博客
02-14 604
java代理模式
java 代理模式详解
徐公，微信公众号同名
08-03 1万+
简介 代理是什么？ 代理也称“委托”，分为静态代理和动态代理，代理模式也是常用的设计模式之一，具有方法增强、高扩展性的设计优势。 代理的设计理念是限制对象的直接访问，即不能通过 new 的方式得到想要的对象，而是访问该对象的代理类。 这样的话，我们就保护了内部对象，如果有一天内部对象因为某个原因换了个名或者换了个方法字段等等，那对访问者来说一点不影响，因为他拿到的只是代理类而已，从而使该访...
java实现代理者模式
06-01
在 Java 中，代理者模式可以通过接口实现或者继承实现来实现。下面我将分别介绍这两种实现方式。 1. 接口实现 定义一个抽象主题角色的接口 Subject，真实主题角色 RealSubject 和代理角色 ProxySubject 都实现该...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值