模式的秘密---代理模式_技术笔记

ciicjsb 2020-02-20

实现静态代理的两种方式

截图
0赞 · 0采集
大鹏111 2019-07-29

聚合比继承更适合代理模式
案例描述：上节课程中，对Car类的move方法增加了时间处理的额外功能，现在想实现代理之间功能的叠加，也就是在move方法前后不仅做时间的处理，还做权限的管理和增加日志的管理。
通过继承实现上述功能：Car1的move方法里调用Car的move方法前后增加了时间处理的功能，现在要做代理类功能的叠加（先记录日志再记录汽车行驶的时间）。首先需要创建一个Car3，来继承Car1（Car1通过继承方式实现静态代理），或者继承Car，然后在move方法前后先实现日志，再实现汽车行驶时间的处理（这样会先输出日志再输出时间处理）。
如果先要记录汽车行驶的时间，再进行日志的处理，则需要创建一个Car4，先对时间处理，再对日志处理。
如果先要权限的判断、再进行日志的处理、然后再进行时间处理，则需要创建一个Car5。
如果先要权限的判断、再进行时间的处理、然后再进行日志的处理，则需要创建一个Car6.
结果得出如果使用继承的方式实现代理功能的叠加，代理类会无限的增多，也就是用一个代理则需要创建一个代理，所以继承的方式实现代理功能的叠加不是推荐的。
通过聚合实现上述功能：由于代理类和被代理类都实现了相同的接口，所以代理类的构造方法中也可以传入接口的对象（针对Car2代理类），代理类中声明的也是接口的对象。再创建一个CarLogProxy代理类（它实现了接口）用来做日志的功能。
如下是先记录日志再记录时间
如下是先记录时间再记录日志
结果通过聚合方式实现代理会比继承方式灵活很多，使用聚合方式代理之间是可以相互传递的，所以推荐使用聚合方式实现代理模式（这里通过聚合实现代理实现了不同功能的顺序）。

0赞 · 1采集
Jason_wang 2019-05-17

静态代理:代理和被代理对象在代理之前是确定的.他们都实现相同的接口或者继承相同的抽象类.
静态代理的两种实现方式:
1.继承方式
不建议使用,如果使用继承则会造成代理类无限叠加下去
2.聚合方式
代理之间可以相互传递,互相组合,提高代理的复用性

0赞 · 0采集
慕仰mooc 2019-05-06

@设计模式——代理模式——静态代理的实现 1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理

0赞 · 0采集
weixin_慕村030779 2018-11-25

4、聚合比继承更适合代理模式
如果使用继承的方式实现代理功能的叠加，代理类则会无限的膨胀。
使用聚合的方式实现代理功能的叠加和组合比较方便实用。

0赞 · 1采集
pinzaghi 2018-11-09

聚合方式比继承方式实现代理模式更好

截图
0赞 · 0采集
BirdOfV 2018-05-31

@设计模式---代理模式之聚合方式做代理模式
1.聚合代理优于继承代理。
在实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。
2.但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理

0赞 · 0采集
cherryljr 2018-05-06

截图
0赞 · 0采集
末水 2018-04-21

实现静态代理继承方法聚合方法 √

截图
0赞 · 0采集
690017359 2017-11-13

/* * 仔细理解一下，就是一层层嵌套叠加。。。 * 先调用ctp.move(); 输出 “汽车开始行驶...” * clp参数传到ctp.move()中的m.move方法；调用clp.move(),输出 “日志开始...” * car参数传到clp.move()中m.move方法；调用Car对象中的move方法。输出 “汽车行驶中....” * 然后调完clp.move()返回，输出 “日志结束...” * 调完返回ctp.move()返回，输出“汽车结束行驶... 汽车行驶时间：毫秒” * */

1赞 · 2采集
回不去小艾 2017-08-26

使用聚合的方式实现静态代理是合适的更好的方法，也就是代理类和被代理类同样实现同一个接口，然后代理类中存入一个被代理类的成员变量，真正调用的是这个成员变量的方法，这样可以实现多种功能的叠加，而且调整功能的顺序操作也会很简单，只需要客户端调整调用功能的顺序即可，如果采用继承的方式，就必须要实现多个功能顺序不同的代理类，这样代理类的数量会越来越多，不利于后面的维护工作。

0赞 · 3采集
范更 2017-08-17

通过继承方式和聚合方式哪种更适合实现代理模式：推荐使用聚合放入方式 -->注意：在使用聚合方法实现代理时每个类都实现了接口，而使用继承时只有父类实现了接口。（两个方法的利弊都出于此）。 1，我们可以将代理类的属性类类型定义为接口的类型，这样就更加方便，更加灵活，代理之间也可以相互传递的

0赞 · 1采集
qq_有姝_0 2017-07-24

功能叠加

截图
0赞 · 0采集
二月十三 2017-07-17

public CarTimeProxy(Moveable m) CarTimeProxy ctp = new CarTimeProxy(car(Moveable));

截图
0赞 · 0采集
夏Jue 2017-07-16

静态代理： 1.继承、继承父类实现想要的功能。 2.聚合、传入参数，实现想要的功能。推荐使用聚合

0赞 · 0采集
多瑞秘法搜啦系多 2017-04-29

代理模式与装饰器模式的区别：区分模式，要首先知道什么叫模式。模式是在某种特定条件下，为了某个目的而提出的一种通用解决方案。这个定义就包括三个东西，限制条件、目的、还有具体实现。装饰器模式虽然与代理模式在实现上相似，但两者目的不一样，代理重在控制，并且对被代理对象在功能上的“增强”对于被代理对象那些“增强”的功能是“透明”的，被代理对象无须关注“增强”的功能具体干了什么。

0赞 · 0采集
多瑞秘法搜啦系多 2017-04-29

不推荐使用继承的方式

截图
0赞 · 0采集
orangewangjie3473319 2017-04-18

聚合方式实现代理

截图
0赞 · 0采集
orangewangjie3473319 2017-04-18

不推荐继承方式实现代理

截图
0赞 · 0采集
蛛丝与马迹 2017-03-15

在静态代理中使用继承的方式不够灵活，会出现改变需求的时候就要重新的改变。使用聚合的方式可以将单个不同的需求放在类中，在使用的时候重新聚合，这样比较方便，而且耦合性很低。

0赞 · 0采集
激流勇进__ 2017-03-05

聚合：一个类中使用另一个类的对象。 1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理静态代理的两种实现方式对比（继承方式和聚合方式）案例--代理类功能的叠加 1. 继承的方式:如果使用继承的方式来实现我们代理功能的叠加，我们的代理类会无限的膨胀下去。 2. 聚合的方式：由于代理类和被代理类都实现了相同的接口，那么代理类的构造参数就可以传入该相同的接口，这样在后面功能叠加的时候就可以传入其他功能的代理类，因为他们都实现了相同的父接口。从而达到功能叠加的作用。 eg:汽车类，先记录日志再记录时间 Car car = new Car(); CarTimeProxy ctp = new CarTimeProxy(car); CarLogProxy clp = new CarLogProxy(ctp); clp.move(); 先记录时间再记录日志 Car car = new Car(); CarLogProxy clp = new CarLogProxy(car); CarTimeProxy ctp = new CarTimeProxy(clp); ctp.move(); 聚合的方式比继承的方式灵活很多，通过聚合的方式，代理之间也是可以相互传递的，相互组合。

0赞 · 3采集
Lgin 2017-03-04

1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理静态代理的两种实现方式对比（继承方式和聚合方式）案例--代理类功能的叠加 1. 继承的方式:如果使用继承的方式来实现我们代理功能的叠加，我们的代理类会无限的膨胀下去。 2. 聚合的方式：由于代理类和被代理类都实现了相同的接口，那么代理类的构造参数就可以传入该相同的接口，这样在后面功能叠加的时候就可以传入其他功能的代理类，因为他们都实现了相同的父接口。从而达到功能叠加的作用。 eg:汽车类，先记录日志再记录时间 Car car = new Car(); CarTimeProxy ctp = new CarTimeProxy(car); CarLogProxy clp = new CarLogProxy(ctp); clp.move(); 先记录时间再记录日志 Car car = new Car(); CarLogProxy clp = new CarLogProxy(car); CarTimeProxy ctp = new CarTimeProxy(clp); ctp.move(); 聚合的方式比继承的方式灵活很多，通过聚合的方式，代理之间也是可以相互传递的，相互组合。

截图
0赞 · 0采集
Jathy 2017-01-12

@设计模式——代理模式——静态代理的实现 1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理静态代理的两种实现方式对比（继承方式和聚合方式）案例--代理类功能的叠加 1. 继承的方式:如果使用继承的方式来实现我们代理功能的叠加，我们的代理类会无限的膨胀下去。 2. 聚合的方式：由于代理类和被代理类都实现了相同的接口，那么代理类的构造参数就可以传入该相同的接口，这样在后面功能叠加的时候就可以传入其他功能的代理类，因为他们都实现了相同的父接口。从而达到功能叠加的作用。 eg: 先记录日志再记录时间 Car car = new Car(); CarTimeProxy ctp = new CarTimeProxy(car); CarLogProxy clp = new CarLogProxy(ctp); clp.move(); 先记录时间再记录日志 Car car = new Car(); CarLogProxy clp = new CarLogProxy(car); CarTimeProxy ctp = new CarTimeProxy(clp); ctp.move(); 聚合的方式比继承的方式灵活很多，通过聚合的方式，代理之间也是可以相互传递的，相互组合

0赞 · 3采集
夜还没黑 2016-12-21

@设计模式——代理模式——静态代理的实现 1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理静态代理的两种实现方式对比（继承方式和聚合方式）案例--代理类功能的叠加 1. 继承的方式:如果使用继承的方式来实现我们代理功能的叠加，我们的代理类会无限的膨胀下去。 2. 聚合的方式：由于代理类和被代理类都实现了相同的接口，那么代理类的构造参数就可以传入该相同的接口，这样在后面功能叠加的时候就可以传入其他功能的代理类，因为他们都实现了相同的父接口。从而达到功能叠加的作用。 eg: 先记录日志再记录时间 Car car = new Car(); CarTimeProxy ctp = new CarTimeProxy(car); CarLogProxy clp = new CarLogProxy(ctp); clp.move(); 先记录时间再记录日志 Car car = new Car(); CarLogProxy clp = new CarLogProxy(car); CarTimeProxy ctp = new CarTimeProxy(clp); ctp.move(); 聚合的方式比继承的方式灵活很多，通过聚合的方式，代理之间也是可以相互传递的，相互组合。

0赞 · 0采集
你庄哥哥 2016-12-05

@设计模式——代理模式——静态代理的实现 1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理静态代理的两种实现方式对比（继承方式和聚合方式）案例--代理类功能的叠加 1. 继承的方式:如果使用继承的方式来实现我们代理功能的叠加，我们的代理类会无限的膨胀下去。 2. 聚合的方式：由于代理类和被代理类都实现了相同的接口，那么代理类的构造参数就可以传入该相同的接口，这样在后面功能叠加的时候就可以传入其他功能的代理类，因为他们都实现了相同的父接口。从而达到功能叠加的作用。 eg:汽车类，先记录日志再记录时间 Car car = new Car(); CarTimeProxy ctp = new CarTimeProxy(car); CarLogProxy clp = new CarLogProxy(ctp); clp.move(); 先记录时间再记录日志 Car car = new Car(); CarLogProxy clp = new CarLogProxy(car); CarTimeProxy ctp = new CarTimeProxy(clp); ctp.move(); 聚合的方式比继承的方式灵活很多，通过聚合的方式，代理之间也是可以相互传递的，相互组合。

0赞 · 0采集
慕粉2216198324 2016-11-10

@设计模式——代理模式——静态代理的实现 1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理静态代理的两种实现方式对比（继承方式和聚合方式）案例--代理类功能的叠加 1. 继承的方式:如果使用继承的方式来实现我们代理功能的叠加，我们的代理类会无限的膨胀下去。 2. 聚合的方式：由于代理类和被代理类都实现了相同的接口，那么代理类的构造参数就可以传入该相同的接口，这样在后面功能叠加的时候就可以传入其他功能的代理类，因为他们都实现了相同的父接口。从而达到功能叠加的作用。 eg:汽车类，先记录日志再记录时间 Car car = new Car(); CarTimeProxy ctp = new CarTimeProxy(car); CarLogProxy clp = new CarLogProxy(ctp); clp.move(); 先记录时间再记录日志 Car car = new Car(); CarLogProxy clp = new CarLogProxy(car); CarTimeProxy ctp = new CarTimeProxy(clp); ctp.move(); 聚合的方式比继承的方式灵活很多，通过聚合的方式，代理之间也是可以相互传递的，相互组合。

截图
0赞 · 1采集
慕粉3392781 2016-11-03

功能叠加

截图
0赞 · 1采集
qq_啤酒泡泡_1 2016-10-22

@设计模式——代理模式——静态代理的实现 1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理静态代理的两种实现方式对比（继承方式和聚合方式）案例--代理类功能的叠加 1. 继承的方式:如果使用继承的方式来实现我们代理功能的叠加，我们的代理类会无限的膨胀下去。 2. 聚合的方式：由于代理类和被代理类都实现了相同的接口，那么代理类的构造参数就可以传入该相同的接口，这样在后面功能叠加的时候就可以传入其他功能的代理类，因为他们都实现了相同的父接口。从而达到功能叠加的作用。 eg:汽车类，先记录日志再记录时间 Car car = new Car(); CarTimeProxy ctp = new CarTimeProxy(car); CarLogProxy clp = new CarLogProxy(ctp); clp.move(); 先记录时间再记录日志 Car car = new Car(); CarLogProxy clp = new CarLogProxy(car); CarTimeProxy ctp = new CarTimeProxy(clp); ctp.move(); 聚合的方式比继承的方式灵活很多，通过聚合的方式，代理之间也是可以相互传递的，相互组合。

0赞 · 0采集
尐笨笨 2016-10-14

@设计模式——代理模式——静态代理的实现 1、聚合代理优于继承代理。因为实现功能叠加的情况下，聚合代理通过相互代理可以实现功能重用，而继承代理必须写多个类来实现多功能叠加。 2、但静态代理只能代理一种类型的被代理类，换个类型的就不行了，这需要动态代理

0赞 · 0采集
yrf 2016-08-23

引入问题以上的CarLogProxy和CarTimeProxy只是对Car的日志和时间的代理，假如现在来了一辆货车也需要实现日志和时间的代理，那还需要再写两个代理类，同理如果来了自行车。。。日志代理和时间代理实现的是相同的功能，那我们不同的类需要实现这些代理，所以，我们能不能统一组合成一个代理。通过TimeProxy来实现对货车汽车自行车的一个代理。

0赞 · 0采集

数据加载中...