如何在Spring中使用责任链设计模式

九年义务教育漏网之鱼
7,060 阅读6分钟

如何在Spring中使用责任链设计模式

笔者文笔功力尚浅，如有不妥，请慷慨指出，必定感激不尽

本片文章不是讲Spring源码中使用责任链的设计实例，而是会讲在Spring中如何设计自己的责任链并且如何调用。

责任链设计模式作为我们常用的设计模式之一，用途非常的广，例如在一些流程化的执行中、或者是一些动态拦截中我们都可以使用责任链设计模式进行设计需求，从而使我们的项目无论是可用性还是可扩展性都会非常的好。

大家对于责任链还有不了解的可以看我之前的博文设计模式——责任链模式

如何定义链条

在Java开发中我们如果想要自己定义一个链条，其实非常简单，也就定义一个抽象类，然后定义几个实现方法，然后设置其next属性即可，但是在Spring中如何将框架与我们的链条结合起来呢？其实这里用到了三个注解@Component、@Order、@PostConstruct。

  • @Component：将我们的子类交给Spring管理
  • @Order：定义我们链条的顺序
  • @PostConstruct：程序启动时将我们链条组合起来

接下来我们直接看代码，首先来看抽象类，其实责任链的抽象类基本上都一样的。

 1public abstract class PrintChainPattern {
 2
 3    private PrintChainPattern next;
 4
 5    public final void print() {
 6        String message = getMessage();
 7
 8        log.info("{} : {}",message,message);
 9        if (getNext()!=null){
10            getNext().print();
11        }
12    }
13    public abstract String getMessage();
14}

然后我们看实现类，后面有四个实现类，依次返回是two、three、four。@Order注解中数字依次递增。这里只演示第一个实现类的代码。

1@Order(1)
2@Component
3public class OnePrintChainPattern extends PrintChainPattern{
4    @Override
5    public String getMessage() {
6        return "one";
7    }
8}

接下来就到了如何利用Spring来组装我们的链条了

 1@Configuration
 2public class InitPrintChainPattern {
 3
 4    @Autowired
 5    private List<PrintChainPattern> printChainPatterns;
 6
 7    @PostConstruct
 8    private void initPrintChainPattern(){
 9        Collections.sort(printChainPatterns, AnnotationAwareOrderComparator.INSTANCE);
10
11        int size = printChainPatterns.size();
12        for (int i = 0; i < size; i++) {
13            if (i == size-1){
14                printChainPatterns.get(i).setNext(null);
15            }else {
16                printChainPatterns.get(i).setNext(printChainPatterns.get(i+1));
17            }
18        }
19    }
20
21    public void print(int index){
22        printChainPatterns.get(index-1).print();
23    }
24}

这里我们可以看到在@PostConstruct方法中我们做了两件事

  1. 将List中按照@Order注解的数字进行排序
  2. 依次设置每个节点的next值

这样我们就已经将这个链条组合了起来。接下来我们就可以随意的对这个链条进行操作，例如我下面的print()方法中，就是根据传进来的值的不同会从不同的节点进行执行。

如何在抽象类中使用@Autowired

在上面我们已经将我们链条组合了起来，但是如果我们的所有子类都公有一些类的话，那么这个类就要放在抽象类中。那么如果这个类我们想要从Spring的容器中取得呢？

比如我们有如下的类交给了Spring管理，我们所有子类都要使用这个类。

1@Bean
2public User setUser(){
3    return User.builder().name("张三").age(14).build();
4}

只需要在抽象类中定义一次即可，只需要在set方法上加@Autowired注解就能够将Spring容器中的类给注入进来。

1private User user;
2
3@Autowired
4public void setUser(User user){
5    this.user = user;
6}

然后在子类中直接调用getUser()方法就行

1@Override
2public String getMessage() {
3    log.info("name:{},age:{}",getUser().getName(),getUser().getAge());
4    return "one";
5}

如何在枚举类中使用@Autowired

为什么要在枚举类中使用@Autowired，是因为我在做需求时将责任链设计模式和策略模式结合起来做了，关于策略模式不明白的话可以看我之前的文章设计模式——策略模式。我们可以使用枚举类使我们的代码更加清晰可见。

我们定义一个简单的枚举策略模式的枚举类。例如我们在这里面要使用Spring容器中得了类的话，我们该如何写呢？例如还是User类。

 1public enum  HumanEnum {
 2
 3    MAN("man"){
 4        @Override
 5        public void invoke() {
 6            log.info("i am man");
 7        }
 8    },
 9    WOMAN("woman"){
10        @Override
11        public void invoke() {
12            log.info("i am woman");
13        }
14    };
15
16    String value;
17
18    HumanEnum(String value){
19        this.value = value;
20    }
21
22    public abstract void invoke();
23}

只需要在枚举类中定义一个内部类，然后将注入进来的类赋值给枚举类即可。

 1User user;
 2
 3public void setUse(User user){
 4    this.user = user;
 5}
 6
 7@Component
 8public static class HumanEnumInjector{
 9
10    @Autowired
11    private  User user;
12
13    @PostConstruct
14    public void setValue(){
15        for (HumanEnum humanEnum : EnumSet.allOf(HumanEnum.class)){
16            humanEnum.setUse(user);
17        }
18    }
19}

本文代码地址

总结

面向对象的三大特性：封装、继承、多态

  1. 大部分的设计模式都是围绕着面向对象的三大特性进行演化的
  2. @Autowired也可以定义在方法上，之前只是习惯将其定义在字段上
  3. 注重基础，复杂的设计肯定也是通过一个一个简单的设计将其拼合的
avatar
文章
阅读
粉丝