java设计模式5，接口隔离原则

一、接口隔离原则

客户端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上。

接口隔离原则要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。

接口隔离是为了高内聚、低耦合。在实际的业务开发中，通常会先定义好需要开发的接口，并由各个实现类实现。但如果没有经过考虑和设计，就很可能造成一个接口中包含众多的接口方法，而这些接口并不一定在每一个类中都需要实现。这样的接口很难维护，也不易于扩展，每一次修改验证都有潜在的风险。

1. 将臃肿庞大的接口分解为多个粒度小的接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。
2. 接口隔离提高了系统的内聚性，减少了对外交互，降低了系统的耦合性。
3. 使用多个专门的接口还能够体现对象的层次，因为可以通过接口的继承，实现对总接口的定义。
4. 能减少项目工程中的代码冗余。过大的大接口里面通常放置许多不用的方法，当实现这个接口的时候，被迫设计冗余的代码。

二、模拟场景

通过模拟开发部经理、项目经理、员工之间的关系的例子来说明迪米特法则。

1. 项目经理负责项目的设计、开发；
2. 后端工程师负责项目的开发、测试、运维；
3. 测试工程师负责项目的测试；

三、违背原则方案

我相信你一定写过类似的代码，看似设计感满满，面向接口编程，扩展性良好，结果一地鸡毛。

1、程序员的职责接口

package com.guor.beanutil.principle.isolation;

/**
 * 程序员的职责
 */
public interface Responsibility {

    // 设计
    void design();

    // 开发
    void develop();

    // 测试
    void test();

    // 运维
    void maintain();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2、项目经理

package com.guor.beanutil.principle.isolation;

/**
 * 项目经理
 */
public class ProjectManager implements Responsibility{
    @Override
    public void design() {
        System.out.println("设计");
    }

    @Override
    public void develop() {
        System.out.println("开发");
    }

    @Override
    public void test() {
		// 无此职责的实现
    }

    @Override
    public void maintain() {
		// 无此职责的实现
    }
}

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

3、开发人员

package com.guor.beanutil.principle.isolation;

/**
 * 开发人员
 */
public class Programmer implements Responsibility{
    @Override
    public void design() {
		// 无此职责的实现
    }

    @Override
    public void develop() {
        System.out.println("开发");
    }

    @Override
    public void test() {
        System.out.println("测试");
    }

    @Override
    public void maintain() {
        System.out.println("运维");
    }
}

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

4、测试人员

package com.guor.beanutil.principle.isolation;

/**
 * 测试人员
 */
public class TestPerson implements Responsibility{
    @Override
    public void design() {
		// 无此职责的实现
    }

    @Override
    public void develop() {
		// 无此职责的实现
    }

    @Override
    public void test() {
        System.out.println("我只负责测试, so easy");
    }

    @Override
    public void maintain() {
		// 无此职责的实现
    }
}

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

四、接口隔离原则概述代码

接口隔离原则要求程序员尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。

1、设计接口

package com.guor.beanutil.principle.isolation;

/**
 * 设计
 */
public interface DesignService {

    void design();
}

1
2
3
4
5
6
7
8
9
10

2、开发接口

package com.guor.beanutil.principle.isolation;

/**
 * 开发
 */
public interface DevelopService {

    // 开发
    void develop();
}

1
2
3
4
5
6
7
8
9
10
11

3、测试接口

package com.guor.beanutil.principle.isolation;

/**
 * 测试
 */
public interface TestService {

    // 测试
    void test();
}

1
2
3
4
5
6
7
8
9
10
11

4、运维接口

package com.guor.beanutil.principle.isolation;

/**
 * 运维
 */
public interface MaintainService {

    // 运维
    void maintain();
}

1
2
3
4
5
6
7
8
9
10
11

5、项目经理

package com.guor.beanutil.principle.isolation;

/**
 * 项目经理
 */
public class ProjectManager implements DesignService,DevelopService {

    @Override
    public void design() {
        System.out.println("设计");
    }

    @Override
    public void develop() {
        System.out.println("开发");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

6、开发人员

package com.guor.beanutil.principle.isolation;

import com.guor.beanutil.principle.isolation2.Responsibility;

/**
 * 开发人员
 */
public class Programmer implements DevelopService,TestService,MaintainService{

    @Override
    public void develop() {
        System.out.println("开发");
    }

    @Override
    public void test() {
        System.out.println("测试");
    }

    @Override
    public void maintain() {
        System.out.println("运维");
    }
}

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

7、测试人员

package com.guor.beanutil.principle.isolation;

/**
 * 测试人员
 */
public class TestPerson implements TestService {

    @Override
    public void test() {
        System.out.println("我只负责测试, so easy");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13

4个类秒变7个类，这设计靠谱吗？

现在看来管理人员、开发人员、测试人员都按需实现了各职责接口。不用再实现不必要的职责方法了，提高了代码的可靠性，降低开发成本和维护成本。

接口隔离原则虽然看似简单，但如果想在实际项目开发中，将各模块、功能规划的井井有条，运用的炉火纯青、恰到好处，真的很难。反复阅读，仔细体会。

设计模式系列文章：

java设计模式1，单一职责原则

java设计模式2，开闭原则

java设计模式3，里氏替换原则

java设计模式4，不要和陌生人说话