(转)Java经典设计模式（2）：七大结构型模式（附实例和详解）

时间：2021-03-28 05:43:02

原文出处： 小宝鸽

总体来说设计模式分为三大类：创建型模式、结构型模式和行为型模式。

博主的上一篇文章已经提到过创建型模式，此外该文章还有设计模式概况和设计模式的六大原则。设计模式的六大原则是设计模式的核心思想，详情请看博主的另外一篇文章：Java经典设计模式之五大创建模式（附实例和详解）。

接下来我们看看结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中适配器模式主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。其中的对象的适配器模式是各种结构型模式的起源。

一、适配器模式

适配器模式主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

适配器模式将某个类的接口转换成客户端期望的另一个接口表示，目的是消除由于接口不匹配所造成的类的兼容性问题。有点抽象，我们来看看详细的内容。

1.1、类的适配器模式

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

1
2
3
4
5
6
7
package com.model.structure;
 
public class Source {
    public void method1() { 
        System.out.println("this is original method!"); 
    } 
}
1
2
3
4
5
6
7
8
9
package com.model.structure;
 
public interface Targetable {
    /* 与原类中的方法相同 */
    public void method1();
 
    /* 新类的方法 */
    public void method2();
}
1
2
3
4
5
6
7
package com.model.structure;
 
public class Adapter extends Source implements Targetable {
    public void method2() {
        System.out.println("this is the targetable method!");
    }
}
1
2
3
4
5
6
7
8
9
package com.model.structure;
 
public class AdapterTest {
    public static void main(String[] args) {
        Targetable target = new Adapter();
        target.method1();
        target.method2();
    }
}

AdapterTest的运行结果：

(转)Java经典设计模式（2）：七大结构型模式（附实例和详解）

1.2、对象的适配器模式

对象的适配器模式的基本思路和类的适配器模式相同，只是将Adapter类作修改成Wrapper，这次不继承Source类，而是持有Source类的实例，以达到解决兼容性的问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com.model.structure;
 
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();
    }
}
1
2
3
4
5
6
7
8
9
10
package com.model.structure;
 
public class AdapterTest {
    public static void main(String[] args) {
        Source source = new Source();
        Targetable target = new Wrapper(source);
        target.method1();
        target.method2();
    }
}

运行结果跟类的适配器模式例子的一样。

1.3、接口的适配器模式

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

这里看文字描述已经试够清楚的了，因此就不贴代码实例了。

二、装饰模式

装饰模式：在不必改变原类文件和使用继承的情况下，动态地扩展一个对象的功能。它是通过创建一个包装对象，也就是装饰来包裹真实的对象。

装饰模式的特点：

（1） 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
（2） 装饰对象包含一个真实对象的引用（reference）
（3） 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。
（4） 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。继承不能做到这一点，继承的功能是静态的，不能动态增删。

具体看看代码实例

1
2
3
4
5
package com.model.structure;
 
public interface Sourceable {
    public void method();
}
1
2
3
4
5
6
7
8
9
package com.model.structure;
 
public class Source implements Sourceable {
 
    @Override
    public void method() {
        System.out.println("the original method!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.model.structure;
 
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!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.model.structure;
 
public class DecoratorTest {
 
    public static void main(String[] args) {
        //（1） 装饰对象和真实对象有相同的接口。这样客户端对象就能以和真实对象相同的方式和装饰对象交互。
        //（2） 装饰对象包含一个真实对象的引用（reference）
        //（3） 装饰对象接受所有来自客户端的请求。它把这些请求转发给真实的对象。
        //（4） 装饰对象可以在转发这些请求以前或以后增加一些附加功能。这样就确保了在运行时，不用修改给定对象的结构就可以在外部增加附加的功能。
        //    在面向对象的设计中，通常是通过继承来实现对给定类的功能扩展。
        //    继承不能做到这一点，继承的功能是静态的，不能动态增删。
        Sourceable source = new Source();
        Sourceable obj = new Decorator(source);
        obj.method();
    }
}

运行结果：

1
2
3
before decorator!
the original method!
after decorator!

三、代理模式

代理模式就是多一个代理类出来，替原对象进行一些操作。代理类就像中介，它比我们掌握着更多的信息。

具体看看代码实例。

1
2
3
4
5
package com.model.structure;
 
public interface Sourceable {
    public void method();
}
1
2
3
4
5
6
7
8
9
package com.model.structure;
 
public class Source implements Sourceable {
 
    @Override
    public void method() {
        System.out.println("the original method!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package com.model.structure;
 
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!");
    }
}
1
2
3
4
5
6
7
8
9
package com.model.structure;
 
public class ProxyTest {
 
    public static void main(String[] args) {
        Sourceable source = new Proxy();
        source.method();
    }
}

运行结果：

1
2
3
before proxy!
the original method!
after proxy!

四、外观模式

外观模式是为了解决类与类之间的依赖关系的，像spring一样，可以将类和类之间的关系配置到配置文件中，而外观模式就是将他们的关系放在一个Facade类中，降低了类类之间的耦合度，该模式中没有涉及到接口。

我们以一个计算机的启动过程为例，看看如下的代码：

1
2
3
4
5
6
7
8
9
10
11
12
package com.model.structure;
 
public class CPU {
 
    public void startup() {
        System.out.println("cpu startup!");
    }
 
    public void shutdown() {
        System.out.println("cpu shutdown!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
package com.model.structure;
 
public class Disk {
 
    public void startup() {
        System.out.println("disk startup!");
    }
 
    public void shutdown() {
        System.out.println("disk shutdown!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
package com.model.structure;
 
public class Memory {
 
    public void startup() {
        System.out.println("memory startup!");
    }
 
    public void shutdown() {
        System.out.println("memory shutdown!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.model.structure;
 
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!");
    }
}
1
2
3
4
5
6
7
8
9
10
package com.model.structure;
 
public class User {
 
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.startup();
        computer.shutdown();
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
10
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!

五、桥接模式

在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。

在提出桥梁模式的时候指出，桥梁模式的用意是”将抽象化(Abstraction)与实现化(Implementation)脱耦，使得二者可以独立地变化”。这句话有三个关键词，也就是抽象化、实现化和脱耦。

抽象化：存在于多个实体中的共同的概念性联系，就是抽象化。作为一个过程，抽象化就是忽略一些信息，从而把不同的实体当做同样的实体对待。
实现化：抽象化给出的具体实现，就是实现化。
脱耦：所谓耦合，就是两个实体的行为的某种强关联。而将它们的强关联去掉，就是耦合的解脱，或称脱耦。在这里，脱耦是指将抽象化和实现化之间的耦合解脱开，或者说是将它们之间的强关联改换成弱关联。

下面我们来看看代码实例：

1
2
3
4
5
package com.model.structure;
 
public interface Driver { 
    public void connect(); 
}
1
2
3
4
5
6
7
8
9
package com.model.structure;
 
public class MysqlDriver implements Driver {
 
    @Override
    public void connect() {
        System.out.println("connect mysql done!");
    }
}
1
2
3
4
5
6
7
8
9
package com.model.structure;
 
public class DB2Driver implements Driver {
 
    @Override
    public void connect() {
        System.out.println("connect db2 done!");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.model.structure;
 
public abstract class DriverManager {
 
    private Driver driver;
 
    public void connect() {
        driver.connect();
    }
 
    public Driver getDriver() {
        return driver;
    }
 
    public void setDriver(Driver driver) {
        this.driver = driver;
    }
 
}
1
2
3
4
5
6
7
8
9
package com.model.structure;
 
public class MyDriverManager extends DriverManager {
 
    public void connect() {
        super.connect();
    }
 
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.model.structure;
 
public class Client {
 
    public static void main(String[] args) {
 
        DriverManager driverManager = new MyDriverManager();
        Driver driver1 = new MysqlDriver();
        driverManager.setDriver(driver1);
        driverManager.connect();
 
        Driver driver2 = new DB2Driver();
        driverManager.setDriver(driver2);
        driverManager.connect();
 
    }
}

执行结果：

1
2
connect mysql done!
connect db2 done!

如果看完代码实例还不是很理解，我们想想如下两个维度扩展：（1）假设我想加一个OracleDriver，这是一个维度，很好理解，不多解释。（2）假设我们想在连接前后固定输出点什么，我们只需要加一个MyDriverManager2，代码如下：

1
2
3
4
5
6
7
8
9
10
11
package com.model.structure;
 
public class MyDriverManager2 extends DriverManager {
 
    public void connect() {
        System.out.println("before connect");
        super.connect();
        System.out.println("after connect");
    }
 
}

再将Client代码中的MyDriverManager 改成 MyDriverManager2 ，执行结果如下：

1
2
3
4
5
6
before connect
connect mysql done!
after connect
before connect
connect db2 done!
after connect

六、组合模式

组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。掌握组合模式的重点是要理解清楚 “部分/整体” 还有 ”单个对象“ 与 “组合对象” 的含义。

组合模式让你可以优化处理递归或分级数据结构。

《设计模式》：将对象组合成树形结构以表示“部分整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

涉及角色：

Component：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。

Leaf：在组合中表示叶子结点对象，叶子结点没有子结点。

Composite：定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除(remove)等。

比如现实中公司内各部门的层级关系，请看代码：

Component：是组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.model.structure;
 
public abstract class Company {
 
    private String name;
 
    public Company() {
    }
 
    public Company(String name) {
        super();
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    protected abstract void add(Company company);
 
    protected abstract void romove(Company company);
 
    protected abstract void display(int depth);
 
}

Composite：定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除(remove)等。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package com.model.structure;
 
import java.util.ArrayList;
import java.util.List;
 
public class ConcreteCompany extends Company {
 
    private List<Company> cList;
 
    public ConcreteCompany() {
        cList = new ArrayList();
    }
 
    public ConcreteCompany(String name) {
        super(name);
        cList = new ArrayList();
    }
 
    @Override
    protected void add(Company company) {
        cList.add(company);
    }
 
    @Override
    protected void display(int depth) {
 
        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(new String(sb) + this.getName());
        for (Company c : cList) {
            c.display(depth + 2);
        }
    }
 
    @Override
    protected void romove(Company company) {
        cList.remove(company);
    }
}

Leaf：在组合中表示叶子结点对象，叶子结点没有子结点。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.model.structure;
 
public class HRDepartment extends Company {
    public HRDepartment(String name) {
        super(name);
    }
 
    @Override
    protected void add(Company company) {
    }
 
    @Override
    protected void display(int depth) {
        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(new String(sb) + this.getName());
    }
 
    @Override
    protected void romove(Company company) {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.model.structure;
 
public class FinanceDepartment extends Company {
    public FinanceDepartment(String name) {
        super(name);
    }
 
    @Override
    protected void add(Company company) {
    }
 
    @Override
    protected void display(int depth) {
        StringBuilder sb = new StringBuilder("");
        for (int i = 0; i < depth; i++) {
            sb.append("-");
        }
        System.out.println(new String(sb) + this.getName());
    }
 
    @Override
    protected void romove(Company company) {
    }
}

Client：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package com.model.structure;
 
public class Client {
    public static void main(String[] args) {
        Company root = new ConcreteCompany();
        root.setName("北京总公司");
        root.add(new HRDepartment("总公司人力资源部"));
        root.add(new FinanceDepartment("总公司财务部"));
        Company shandongCom = new ConcreteCompany("山东分公司");
        shandongCom.add(new HRDepartment("山东分公司人力资源部"));
        shandongCom.add(new FinanceDepartment("山东分公司账务部"));
        Company zaozhuangCom = new ConcreteCompany("枣庄办事处");
        zaozhuangCom.add(new FinanceDepartment("枣庄办事处财务部"));
        zaozhuangCom.add(new HRDepartment("枣庄办事处人力资源部"));
        Company jinanCom = new ConcreteCompany("济南办事处");
        jinanCom.add(new FinanceDepartment("济南办事处财务部"));
        jinanCom.add(new HRDepartment("济南办事处人力资源部"));
        shandongCom.add(jinanCom);
        shandongCom.add(zaozhuangCom);
        Company huadongCom = new ConcreteCompany("上海华东分公司");
        huadongCom.add(new HRDepartment("上海华东分公司人力资源部"));
        huadongCom.add(new FinanceDepartment("上海华东分公司账务部"));
        Company hangzhouCom = new ConcreteCompany("杭州办事处");
        hangzhouCom.add(new FinanceDepartment("杭州办事处财务部"));
        hangzhouCom.add(new HRDepartment("杭州办事处人力资源部"));
        Company nanjingCom = new ConcreteCompany("南京办事处");
        nanjingCom.add(new FinanceDepartment("南京办事处财务部"));
        nanjingCom.add(new HRDepartment("南京办事处人力资源部"));
        huadongCom.add(hangzhouCom);
        huadongCom.add(nanjingCom);
        root.add(shandongCom);
        root.add(huadongCom);
        root.display(0);
    }
}

运行结果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
北京总公司
--总公司人力资源部
--总公司财务部
--山东分公司
----山东分公司人力资源部
----山东分公司账务部
----济南办事处
------济南办事处财务部
------济南办事处人力资源部
----枣庄办事处
------枣庄办事处财务部
------枣庄办事处人力资源部
--上海华东分公司
----上海华东分公司人力资源部
----上海华东分公司账务部
----杭州办事处
------杭州办事处财务部
------杭州办事处人力资源部
----南京办事处
------南京办事处财务部
------南京办事处人力资源部

七、享元模式

享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，通常与工厂模式一起使用。

一提到共享池，我们很容易联想到Java里面的JDBC连接池，想想每个连接的特点，我们不难总结出：适用于作共享的一些个对象，他们有一些共有的属性，就拿数据库连接池来说，url、driverClassName、username、password及dbname，这些属性对于每个连接来说都是一样的，所以就适合用享元模式来处理，建一个工厂类，将上述类似属性作为内部数据，其它的作为外部数据，在方法调用时，当做参数传进来，这样就节省了空间，减少了实例的数量。

看下数据库连接池的代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com.model.structure;
 
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Vector;
 
public class ConnectionPool {
 
    private Vector<Connection> pool;
 
    /* 公有属性 */
    private String url = "jdbc:mysql://localhost:3306/test";
    private String username = "root";
    private String password = "root";
    private String driverClassName = "com.mysql.jdbc.Driver";
 
    private int poolSize = 100;
    private static ConnectionPool instance = null;
    Connection conn = null;
 
    /* 构造方法，做一些初始化工作 */
    private ConnectionPool() {
        pool = new Vector<Connection>(poolSize);
 
        for (int i = 0; i < poolSize; i++) {
            try {
                Class.forName(driverClassName);
                conn = DriverManager.getConnection(url, username, password);
                pool.add(conn);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
 
    /* 返回连接到连接池 */
    public synchronized void release() {
        pool.add(conn);
    }
 
    /* 返回连接池中的一个数据库连接 */
    public synchronized Connection getConnection() {
        if (pool.size() > 0) {
            Connection conn = pool.get(0);
            pool.remove(conn);
            return conn;
        } else {
            return null;
        }
    }
}

通过连接池的管理，实现了数据库连接的共享，不需要每一次都重新创建连接，节省了数据库重新创建的开销，提升了系统的性能！

注，本文参考了另外一位博主的文章，某些地方有结合自己的一些理解加以修改：
http://blog.csdn.net/zhangerqing/article/details/8194653

相关文章