[Java知识库]设计模式 接口隔离原则

接口隔离原则

要求程序员尽量将臃肿庞大的接口, 拆分为更小和更加具体的接口.
让接口中只包含客户感兴趣的方法.
用更小的接口 更具体的接口处理业务.

问题越小, 越容易被处理, 达到高内聚, 低耦合.

接口隔离原则代码实战

英雄联盟中, 每个英雄都有各自的一些技能
定义一个技能接口, 这个接口中有所有的技能, 不同的英雄, 去实现各自的技能.

public interface ISkill {

    void doArchery();

    void doInvisible();

    void doSilent();

    void doVertigo();
}

英雄后裔实现其拥有的技能, 没有的技能不进行实现编写.

public class HeroHouYi implements ISkill {
    public void doArchery() {
        System.out.println("后裔的灼日之矢");
    }

    public void doInvisible() {
        System.out.println("后裔的隐身技能");
    }

    public void doSilent() {
        System.out.println("后裔的沉默技能");
    }

    public void doVertigo() {
        // 无此技能的实现
    }
}

英雄廉颇也一样实现技能接口类

public class HeroLianPo implements ISkill {

    public void doArchery() {
        // 无此技能的实现

    }

    public void doInvisible() {
        System.out.println("廉颇的隐身技能");

    }

    public void doSilent() {
        System.out.println("廉颇的沉默技能");
    }

    public void doVertigo() {
        System.out.println("廉颇的眩晕技能");
    }
}

测试类

public class ApiTest {

    @Test
    public void test_ISKill() {
        // 后裔
        HeroHouYi heroHouYi = new HeroHouYi();
        heroHouYi.doArchery();

        // 廉颇
        HeroLianPo heroLianPo = new HeroLianPo();
        heroLianPo.doInvisible();
    }

}

运行结果如下 :

后裔的灼日之矢
廉颇的隐身技能

上面这么写的缺点是ISkill 接口定义了所有的技能, 太大了, 所有英雄实现此接口后, 类中会有所有的技能方法. 用接口隔离原则进行优化, 将其拆分为更小和更加具体的接口.

接口隔离原则的优化

把技能进行归类. 每一个技能, 定义一个接口.

public interface ISkillArchery {

    // 射箭
    void doArchery();

}

public interface ISkillInvisible {

    // 隐袭
    void doInvisible();
}

public interface ISkillSilent {
    // 沉默
    void doSilent();

}
public interface ISkillVertigo {
    // 眩晕
    void doVertigo();
}

后裔类去实现其拥有的技能的接口

public class HeroHouYi implements ISkillArchery, ISkillInvisible, ISkillSilent {

    public void doArchery() {
        System.out.println("后裔的灼日之矢");
    }

    public void doInvisible() {
        System.out.println("后裔的隐身技能");
    }

    public void doSilent() {
        System.out.println("后裔的沉默技能");
    }
}

廉颇类也仅仅实现其拥有的技能接口

public class HeroLianPo implements ISkillInvisible, ISkillSilent, ISkillVertigo {

    @Override
    public void doInvisible() {
        System.out.println("廉颇的隐身技能");
    }

    public void doSilent() {
        System.out.println("廉颇的沉默技能");
    }

    public void doVertigo() {
        System.out.println("廉颇的眩晕技能");
    }
}

测试类和打印结果与上面的一致.

接口隔离原则在开源框架中的应用

接口隔离原则在开源框架中的应用还是很广泛的. 经常能看到某个类, 实现了一系列的接口.
这些接口也只定义了一个方法.

例如Spring的spring-orm模块中, 有一个类AbstractEntityManagerFactoryBean
其实现的接口如下

public abstract class AbstractEntityManagerFactoryBean implements
		FactoryBean<EntityManagerFactory>, BeanClassLoaderAware, BeanFactoryAware, BeanNameAware,
		InitializingBean, DisposableBean, EntityManagerFactoryInfo, PersistenceExceptionTranslator, Serializable

其中下面这几个接口的特点都是只有一个方法, 达到了接口的隔离原则.

BeanClassLoaderAware, BeanFactoryAware, BeanNameAware,
InitializingBean, DisposableBean, PersistenceExceptionTranslator

public interface BeanClassLoaderAware extends Aware {
	void setBeanClassLoader(ClassLoader classLoader);
}
public interface BeanFactoryAware extends Aware {
	void setBeanFactory(BeanFactory beanFactory) throws BeansException;
}
public interface BeanNameAware extends Aware {
	void setBeanName(String name);
}
public interface InitializingBean {
	void afterPropertiesSet() throws Exception;
}
public interface DisposableBean {
	void destroy() throws Exception;
}
public interface PersistenceExceptionTranslator {
	DataAccessException translateExceptionIfPossible(RuntimeException ex);
}