springboot中使用模板⽅法设计模式-设计模块（六）

springboot中使用模板⽅法设计模式-设计模块（六） 模板⽅法设计模式

• 抽象模板(Abstract Template): 定义⼀个模板⽅法，这个模板⽅法⼀般是⼀个具体⽅法，给出⼀个顶级算法⻣架，
• ⽽逻辑⻣架的组成步骤在相应的抽象 *** 作中，推迟到⼦类实现
• 模板⽅法：定义了算法的⻣架，按某种顺序调⽤其包含的基本⽅法
• 基本⽅法：是整个算法中的⼀个步骤，包括抽象⽅法和具体⽅法
• 抽象⽅法：在抽象类中申明，由具体⼦类实现。
• 具体⽅法：在抽象类中已经实现，在具体⼦类中 可以继承或重写它

代码实现 每天早上日常

public abstract class AbstractTemplate {

    
    public void dailyRoutineTemplateMethod(){
        getUp();
        wash();
        changeClothesAbstractMethod();
        haveMealAbstractMethod();
        commuteAbstractMethod();
    }

    
    public void getUp() {
        System.out.println("6点起床");
    }

    
    public void wash() {
        System.out.println("洗漱");
    }

    
    public abstract void changeClothesAbstractMethod();

    
    public abstract void haveMealAbstractMethod();

    
    public abstract void commuteAbstractMethod();

}

public class Monday extends AbstractTemplate{

    @Override
    public void changeClothesAbstractMethod() {
        System.out.println("今天很热啊 穿短袖吧");
    }

    @Override
    public void haveMealAbstractMethod() {
        System.out.println("早饭吃麦当劳");
    }

    @Override
    public void commuteAbstractMethod() {
        System.out.println("坐地铁去上班");
    }
}

public class Weekend extends AbstractTemplate{

    @Override
    public void getUp() {
        System.out.println("今天12点起床");
    }

    @Override
    public void changeClothesAbstractMethod() {
        System.out.println("不换了");
    }

    @Override
    public void haveMealAbstractMethod() {
        System.out.println("叫外卖");
    }

    @Override
    public void commuteAbstractMethod() {
        System.out.println("下午继续睡,不同勤了");
    }
}

public class Test {

    public static void main(String[] args) {
        // 周一
        Monday monday = new Monday();
        monday.dailyRoutineTemplateMethod();
        System.out.println("==============================");
        // 周末
        Weekend weekend = new Weekend();
        weekend.dailyRoutineTemplateMethod();
    }

}

如何在spring中使用 abstract类中可使用ApplicationContext 来获取Bean

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringContextHolder implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Autowired
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringContextHolder.applicationContext = applicationContext;
    }


    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }


    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }

    
    public static  T getBean(Class clazz) {
        return getApplicationContext().getBean(clazz);
    }

    
    public static  T getBean(String name, Class clazz) {
        return getApplicationContext().getBean(name, clazz);
    }

}

public interface MyService {
    void test();
}

import org.springframework.stereotype.Service;


@Service
public class MyServiceImpl implements MyService {

    @Override
    public void test() {
        System.out.println("业务");
    }
}

子类使用DependsOn注解

• 因为baseService中构造器需要使用applicationContextUtil这个bean，所以需要加@DependsOn这个注解。
• 注解作用：
• 1、保证applicationContextUtil总是在MyService之前实例化
• 2、保证applicationContextUtil总是在MyService销毁之后销毁

@DependsOn("springContextHolder")
@Component
public class Monday extends AbstractTemplate{

    @Override
    public void changeClothesAbstractMethod() {
        System.out.println("今天很热啊 穿短袖吧");
    }

    @Override
    public void haveMealAbstractMethod() {
        System.out.println("早饭吃麦当劳");
    }

    @Override
    public void commuteAbstractMethod() {
        System.out.println("坐地铁去上班");
    }
}

父类使用构造方法和ApplicationContext 来注入Bean

public abstract class AbstractTemplate {

    private MyService myService;

    public AbstractTemplate() {
        this.myService = SpringContextHolder.getBean(MyService.class);
    }

    
    public void dailyRoutineTemplateMethod(){
        myService.test();
        getUp();
        wash();
        changeClothesAbstractMethod();
        haveMealAbstractMethod();
        commuteAbstractMethod();
    }

    
    public void getUp() {
        System.out.println("6点起床");
    }

    
    public void wash() {
        System.out.println("洗漱");
    }

    
    public abstract void changeClothesAbstractMethod();

    
    public abstract void haveMealAbstractMethod();

    
    public abstract void commuteAbstractMethod();

}

import com.zm.demo4.Monday;
import com.zm.demo4.Weekend;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class Demo01ApplicationTests {

   // 这里可以结合实际场景将策略和工厂模式应用
    @Autowired
    Monday monday;
    @Autowired
    Weekend weekend;

    @Test
    void contextLoads() {
        monday.dailyRoutineTemplateMethod();
        weekend.dailyRoutineTemplateMethod();
    }

}