新闻代理模式的名词解释是

Posted 2023-04-25

【转载】代理模式：代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。 参考技术A 适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。wiki
代理模式：代理模式的定义：为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。wiki
2.困惑
设计模式总是通过增加层来进行解耦合，提高扩展性，但是如果我们没法从在这个抽象维度中看出，这个层真正的抽象含义，那么我们很难搞懂一个模式真正的内涵？我就有这个疑问，这两个东东都是增加了一层，但是这一层有什么区别？
3.理解
很明显，适配器模式是因为新旧接口不一致导致出现了客户端无法得到满足的问题，但是，由于旧的接口是不能被完全重构掉的，因为我们还想使用实现了这个接口的一些服务。那么为了使用以前实现旧接口的服务，我们就应该把新的接口转换成旧接口；实现这个转换的类就是抽象意义的转换器；
就比如在java中早期的枚举接口是Enumeration而后定义的枚举接口是Iterator;有很多旧的类实现了enumeration接口 暴露出了一些服务，但是这些服务我们现在想通过传入Iterator接口而不是Enumeration接口来调用，这时就需要一个适配器，那么client就能用这个服务了（服务端只想用Iterator或者只知道这个接口）；
相比于适配器的应用场景，代理就不一样了，虽然代理也同样是增加了一层，但是，代理提供的接口和原本的接口是一样的，代理模式的作用是不把实现直接暴露给client，而是通过代理这个层，代理能够做一些处理；
感悟：设计模式学习应该结合场景，脱离了场景就很难明白这些东西，这些层这么写都是在干什么；其实不管是面向对象还是设计模式，最重要的是抽象，理解了它在抽象一个什么场景你才能理解本质

编程经常使用设计模式具体解释--（中篇）（适配器装饰代理外观桥接组合享元）

摘自：http://blog.csdn.net/zhangerqing/article/details/8239539

我们接着讨论设计模式。上篇文章我讲完了5种创建型模式。这章開始，我将讲下7种结构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

当中对象的适配器模式是各种模式的起源，我们看以下的图：

6、适配器模式（Adapter）

适配器模式将某个类的接口转换成client期望的还有一个接口表示，目的是消除因为接口不匹配所造成的类的兼容性问题。主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。首先。我们来看看类的适配器模式，先看类图：

核心思想就是：有一个Source类，拥有一个方法，待适配，目标接口时Targetable，通过Adapter类，将Source的功能扩展到Targetable里，看代码：

[java] view plaincopyprint?

1. public class Source {
3. public void method1() {
4. System.out.println("this is original method!");
5. }
6. }

public class Source {

	public void method1() {
		System.out.println("this is original method!");
	}
}

[java] view plaincopyprint?

1. public interface Targetable {
3. /* 与原类中的方法同样 */
4. public void method1();
6. /* 新类的方法 */
7. public void method2();
8. }

public interface Targetable {

	/* 与原类中的方法同样 */
	public void method1();

	/* 新类的方法 */
	public void method2();
}

[java] view plaincopyprint?

1. public class Adapter extends Source implements Targetable {
3. @Override
4. public void method2() {
5. System.out.println("this is the targetable method!");
6. }
7. }

public class Adapter extends Source implements Targetable {

	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}
}

Adapter类继承Source类。实现Targetable接口，以下是測试类：

[java] view plaincopyprint?

1. public class AdapterTest {
3. public static void main(String[] args) {
4. Targetable target = new Adapter();
5. target.method1();
6. target.method2();
7. }
8. }

public class AdapterTest {

	public static void main(String[] args) {
		Targetable target = new Adapter();
		target.method1();
		target.method2();
	}
}

输出：

this is original method!
this is the targetable method!

这样Targetable接口的实现类就具有了Source类的功能。

对象的适配器模式

基本思路和类的适配器模式同样。仅仅是将Adapter类作改动，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。看图：

仅仅须要改动Adapter类的源代码就可以：

[java] view plaincopyprint?

1. public class Wrapper implements Targetable {
3. private Source source;
5. public Wrapper(Source source){
6. super();
7. this.source = source;
8. }
9. @Override
10. public void method2() {
11. System.out.println("this is the targetable method!");
12. }
14. @Override
15. public void method1() {
16. source.method1();
17. }
18. }

public class Wrapper implements Targetable {

	private Source source;
	
	public Wrapper(Source source){
		super();
		this.source = source;
	}
	@Override
	public void method2() {
		System.out.println("this is the targetable method!");
	}

	@Override
	public void method1() {
		source.method1();
	}
}

測试类：

[java] view plaincopyprint?

1. public class AdapterTest {
3. public static void main(String[] args) {
4. Source source = new Source();
5. Targetable target = new Wrapper(source);
6. target.method1();
7. target.method2();
8. }
9. }

public class AdapterTest {

	public static void main(String[] args) {
		Source source = new Source();
		Targetable target = new Wrapper(source);
		target.method1();
		target.method2();
	}
}

输出与第一种一样，仅仅是适配的方法不同而已。

第三种适配器模式是接口的适配器模式，接口的适配器是这种：有时我们写的一个接口中有多个抽象方法，当我们写该接口的实现类时。必须实现该接口的全部方法，这明显有时比較浪费，由于并非全部的方法都是我们须要的。有时仅仅须要某一些，此处为了解决问题，我们引入了接口的适配器模式。借助于一个抽象类，该抽象类实现了该接口，实现了全部的方法。而我们不和原始的接口打交道，仅仅和该抽象类取得联系。所以我们写一个类，继承该抽象类，重写我们须要的方法即可。

看一下类图：

这个非常好理解，在实际开发中。我们也常会遇到这样的接口中定义了太多的方法。以致于有时我们在一些实现类中并非都须要。看代码：

[java] view plaincopyprint?

1. public interface Sourceable {
3. public void method1();
4. public void method2();
5. }

public interface Sourceable {
	
	public void method1();
	public void method2();
}

抽象类Wrapper2：

[java] view plaincopyprint?

1. public abstract class Wrapper2 implements Sourceable{
3. public void method1(){}
4. public void method2(){}
5. }

public abstract class Wrapper2 implements Sourceable{
	
	public void method1(){}
	public void method2(){}
}

[java] view plaincopyprint?

1. public class SourceSub1 extends Wrapper2 {
2. public void method1(){
3. System.out.println("the sourceable interface‘s first Sub1!");
4. }
5. }

public class SourceSub1 extends Wrapper2 {
	public void method1(){
		System.out.println("the sourceable interface's first Sub1!");
	}
}

[java] view plaincopyprint?

1. public class SourceSub2 extends Wrapper2 {
2. public void method2(){
3. System.out.println("the sourceable interface‘s second Sub2!");
4. }
5. }

public class SourceSub2 extends Wrapper2 {
	public void method2(){
		System.out.println("the sourceable interface's second Sub2!");
	}
}

[java] view plaincopyprint?

1. public class WrapperTest {
3. public static void main(String[] args) {
4. Sourceable source1 = new SourceSub1();
5. Sourceable source2 = new SourceSub2();
7. source1.method1();
8. source1.method2();
9. source2.method1();
10. source2.method2();
11. }
12. }

public class WrapperTest {

	public static void main(String[] args) {
		Sourceable source1 = new SourceSub1();
		Sourceable source2 = new SourceSub2();
		
		source1.method1();
		source1.method2();
		source2.method1();
		source2.method2();
	}
}

測试输出：

the sourceable interface‘s first Sub1!
the sourceable interface‘s second Sub2!

达到了我们的效果！

讲了这么多，总结一下三种适配器模式的应用场景：

类的适配器模式：当希望将一个类转换成满足还有一个新接口的类时，能够使用类的适配器模式，创建一个新类，继承原有的类，实现新的接口就可以。

对象的适配器模式：当希望将一个对象转换成满足还有一个新接口的对象时，能够创建一个Wrapper类。持有原类的一个实例，在Wrapper类的方法中。调用实例的方法即可。

接口的适配器模式：当不希望实现一个接口中全部的方法时，能够创建一个抽象类Wrapper。实现全部方法，我们写别的类的时候，继承抽象类就可以。

7、装饰模式（Decorator）

顾名思义，装饰模式就是给一个对象添加一些新的功能，并且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。关系图例如以下：

Source类是被装饰类，Decorator类是一个装饰类，能够为Source类动态的加入一些功能，代码例如以下：

[java] view plaincopyprint?

1. public interface Sourceable {
2. public void method();
3. }

public interface Sourceable {
	public void method();
}

[java] view plaincopyprint?

1. public class Source implements Sourceable {
3. @Override
4. public void method() {
5. System.out.println("the original method!");
6. }
7. }

public class Source implements Sourceable {

	@Override
	public void method() {
		System.out.println("the original method!");
	}
}

[java] view plaincopyprint?

1. public class Decorator implements Sourceable {
3. private Sourceable source;
5. public Decorator(Sourceable source){
6. super();
7. this.source = source;
8. }
9. @Override
10. public void method() {
11. System.out.println("before decorator!");
12. source.method();
13. System.out.println("after decorator!");
14. }
15. }

public class Decorator implements Sourceable {

	private Sourceable source;
	
	public Decorator(Sourceable source){
		super();
		this.source = source;
	}
	@Override
	public void method() {
		System.out.println("before decorator!");
		source.method();
		System.out.println("after decorator!");
	}
}

測试类：

[java] view plaincopyprint?

1. public class DecoratorTest {
3. public static void main(String[] args) {
4. Sourceable source = new Source();
5. Sourceable obj = new Decorator(source);
6. obj.method();
7. }
8. }

public class DecoratorTest {

	public static void main(String[] args) {
		Sourceable source = new Source();
		Sourceable obj = new Decorator(source);
		obj.method();
	}
}

输出：

before decorator!
the original method!
after decorator!

装饰器模式的应用场景：

1、须要扩展一个类的功能。

2、动态的为一个对象添加功能。并且还能动态撤销。（继承不能做到这一点，继承的功能是静态的。不能动态增删。

）

缺点：产生过多相似的对象，不易排错！

8、代理模式（Proxy）

事实上每一个模式名称就表明了该模式的作用。代理模式就是多一个代理类出来，替原对象进行一些操作，比方我们在租房子的时候回去找中介。为什么呢？由于你对该地区房屋的信息掌握的不够全面，希望找一个更熟悉的人去帮你做，此处的代理就是这个意思。再如我们有的时候打官司。我们须要请律师，由于律师在法律方面有专长，能够替我们进行操作。表达我们的想法。

先来看看关系图：

依据上文的阐述，代理模式就比較easy的理解了。我们看下代码：

[java] view plaincopyprint?

1. public interface Sourceable {
2. public void method();
3. }

public interface Sourceable {
	public void method();
}

[java] view plaincopyprint?

1. public class Source implements Sourceable {
3. @Override
4. public void method() {
5. System.out.println("the original method!");
6. }
7. }

public class Source implements Sourceable {

	@Override
	public void method() {
		System.out.println("the original method!");
	}
}

[java] view plaincopyprint?

1. public class Proxy implements Sourceable {
3. private Source source;
4. public Proxy(){
5. super();
6. this.source = new Source();
7. }
8. @Override
9. public void method() {
10. before();
11. source.method();
12. atfer();
13. }
14. private void atfer() {
15. System.out.println("after proxy!");
16. }
17. private void before() {
18. System.out.println("before proxy!");
19. }
20. }

public class Proxy implements Sourceable {

	private Source source;
	public Proxy(){
		super();
		this.source = new Source();
	}
	@Override
	public void method() {
		before();
		source.method();
		atfer();
	}
	private void atfer() {
		System.out.println("after proxy!");
	}
	private void before() {
		System.out.println("before proxy!");
	}
}

測试类：

[java] view plaincopyprint?

1. public class ProxyTest {
3. public static void main(String[] args) {
4. Sourceable source = new Proxy();
5. source.method();
6. }
8. }

public class ProxyTest {

	public static void main(String[] args) {
		Sourceable source = new Proxy();
		source.method();
	}

}

输出：

before proxy!
the original method!
after proxy!

代理模式的应用场景：

假设已有的方法在使用的时候须要对原有的方法进行改进。此时有两种办法：

1、改动原有的方法来适应。这样违反了“对扩展开放，对改动关闭”的原则。

2、就是採用一个代理类调用原有的方法，且对产生的结果进行控制。这样的方法就是代理模式。

使用代理模式，能够将功能划分的更加清晰。有助于后期维护！

9、外观模式（Facade）

外观模式是为了解决类与类之家的依赖关系的。像spring一样，能够将类和类之间的关系配置到配置文件里。而外观模式就是将他们的关系放在一个Facade类中，减少了类类之间的耦合度。该模式中没有涉及到接口。看下类图：（我们以一个计算机的启动过程为例）

我们先看下实现类：

[java] view plaincopyprint?

1. public class CPU {
3. public void startup(){
4. System.out.println("cpu startup!");
5. }
7. public void shutdown(){
8. System.out.println("cpu shutdown!");
9. }
10. }

public class CPU {
	
	public void startup(){
		System.out.println("cpu startup!");
	}
	
	public void shutdown(){
		System.out.println("cpu shutdown!");
	}
}

[java] view plaincopyprint?

1. public class Memory {
3. public void startup(){
4. System.out.println("memory startup!");
5. }
7. public void shutdown(){
8. System.out.println("memory shutdown!");
9. }
10. }

public class Memory {
	
	public void startup(){
		System.out.println("memory startup!");
	}
	
	public void shutdown(){
		System.out.println("memory shutdown!");
	}
}

[java] view plaincopyprint?

1. public class Disk {
3. public void startup(){
4. System.out.println("disk startup!");
5. }
7. public void shutdown(){
8. System.out.println("disk shutdown!");
9. }
10. }

public class Disk {
	
	public void startup(){
		System.out.println("disk startup!");
	}
	
	public void shutdown(){
		System.out.println("disk shutdown!");
	}
}

[java] view plaincopyprint?

1. public class Computer {
2. private CPU cpu;
3. private Memory memory;
4. private Disk disk;
6. public Computer(){
7. cpu = new CPU();
8. memory = new Memory();
9. disk = new Disk();
10. }
12. public void startup(){
13. System.out.println("start the computer!");
14. cpu.startup();
15. memory.startup();
16. disk.startup();
17. System.out.println("start computer finished!");
18. }
20. public void shutdown(){
21. System.out.println("begin to close the computer!");
22. cpu.shutdown();
23. memory.shutdown();
24. disk.shutdown();
25. System.out.println("computer closed!");
26. }
27. }

public class Computer {
	private CPU cpu;
	private Memory memory;
	private Disk disk;
	
	public Computer(){
		cpu = new CPU();
		memory = new Memory();
		disk = new Disk();
	}
	
	public void startup(){
		System.out.println("start the computer!");
		cpu.startup();
		memory.startup();
		disk.startup();
		System.out.println("start computer finished!");
	}
	
	public void shutdown(){
		System.out.println("begin to close the computer!");
		cpu.shutdown();
		memory.shutdown();
		disk.shutdown();
		System.out.println("computer closed!");
	}
}

User类例如以下：

[java] view plaincopyprint?

1. public class User {
3. public static void main(String[] args) {
4. Computer computer = new Computer();
5. computer.startup();
6. computer.shutdown();
7. }
8. }

public class User {

	public static void main(String[] args) {
		Computer computer = new Computer();
		computer.startup();
		computer.shutdown();
	}
}

输出：

start the computer!
cpu startup!
memory startup!
disk startup!
start computer finished!
begin to close the computer!
cpu shutdown!
memory shutdown!
disk shutdown!
computer closed!

假设我们没有Computer类。那么，CPU、Memory、Disk他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，改动一个类，可能会带来其它类的改动，这不是我们想要看到的。有了Computer类。他们之间的关系被放在了Computer类里，这样就起到了解耦的作用。这，就是外观模式。

10、桥接模式（Bridge）

桥接模式就是把事物和其详细实现分开，使他们能够各自独立的变化。桥接的用意是：将抽象化与实现化解耦。使得二者能够独立变化，像我们经常使用的JDBC桥DriverManager一样，JDBC进行连接数据库的时候，在各个数据库之间进行切换。基本不须要动太多的代码，甚至丝毫不用动。原因就是JDBC提供统一接口，每一个数据库提供各自的实现，用一个叫做数据库驱动的程序来桥接即可了。我们来看看关系图：

实现代码：

先定义接口：

[java] view plaincopyprint?

1. public interface Sourceable {
2. public void method();
3. }

public interface Sourceable {
	public void method();
}

分别定义两个实现类：

[java] view plaincopyprint?

1. public class SourceSub1 implements Sourceable {
3. @Override
4. public void method() {
5. System.out.println("this is the first sub!");
6. }
7. }

public class SourceSub1 implements Sourceable {

	@Override
	public void method() {
		System.out.println("this is the first sub!");
	}
}

[java] view plaincopyprint?

1. public class SourceSub2 implements Sourceable {
3. @Override
4. public void method() {
5. System.out.println("this is the second sub!");
6. }
7. }

public class SourceSub2 implements Sourceable {

	@Override
	public void method() {
		System.out.println("this is the second sub!");
	}
}

定义一个桥，持有Sourceable的一个实例：

[java] view plaincopyprint?

1. public abstract class Bridge {
2. private Sourceable source;
4. public void method(){
5. source.method();
6. }
8. public Sourceable getSource() {
9. return source;
10. }
12. public void setSource(Sourceable source) {
13. this.source = source;
14. }
15. }

public abstract class Bridge {
	private Sourceable source;

	public void method(){
		source.method();
	}
	
	public Sourceable getSource() {
		return source;
	}

	public void setSource(Sourceable source) {
		this.source = source;
	}
}

[java] view plaincopyprint?

1. public class MyBridge extends Bridge {
2. public void method(){
3. getSource().method();
4. }
5. }

public class MyBridge extends Bridge {
	public void method(){
		getSource().method();
	}
}

測试类：

[java] view plaincopyprint?

1. public class BridgeTest {
3. public static void main(String[] args) {
5. Bridge bridge = new MyBridge();
7. /*调用第一个对象*/
8. Sourceable source1 = new SourceSub1();
9. bridge.setSource(source1);
10. bridge.method();
12. /*调用第二个对象*/
13. Sourceable source2 = new SourceSub2();
14. bridge.setSource(source2);
15. bridge.method();
16. }
17. }

public class BridgeTest {
	
	public static void main(String[] args) {
		
		Bridge bridge = new MyBridge();
		
		/*调用第一个对象*/
		Sourceable source1 = new SourceSub1();
		bridge.setSource(source1);
		bridge.method();
		
		/*调用第二个对象*/
		Sourceable source2 = new SourceSub2();
		bridge.setSource(source2);
		bridge.method();
	}
}

output：

this is the first sub!
this is the second sub!

这样，就通过对Bridge类的调用，实现了对接口Sourceable的实现类SourceSub1和SourceSub2的调用。接下来我再画个图，大家就应该明确了，由于这个图是我们JDBC连接的原理。有数据库学习基础的，一结合就都懂了。

11、组合模式（Composite）

组合模式有时又叫部分-总体模式在处理类似树形结构的问题时比較方便，看看关系图：

直接来看代码：

[java] view plaincopyprint?

1. public class TreeNode {
3. private String name;
4. private TreeNode parent;
5. private Vector<TreeNode> children = new Vector<TreeNode>();
7. public TreeNode(String name){
8. this.name = name;
9. }
11. public String getName() {
12. return name;
13. }
15. public void setName(String name) {
16. this.name = name;
17. }
19. public TreeNode getParent() {
20. return parent;
21. }
23. public void setParent(TreeNode parent) {
24. this.parent = parent;
25. }
27. //加入孩子节点
28. public void add(TreeNode node){
29. children.add(node);
30. }
32. //删除孩子节点
33. public void remove(TreeNode node){
34. children.remove(node);
35. }
37. //取得孩子节点
38. public Enumeration<TreeNode> getChildren(){
39. return children.elements();
40. }
41. }

public class TreeNode {
	
	private String name;
	private TreeNode parent;
	private Vector<TreeNode> children = new Vector<