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

模板⽅法设计模式

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

代码实现每天早上日常

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

}

/**
 * 周一
 * @author zhou
 */
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("坐地铁去上班");
    }
}

/**
 * 周末
 * @author zhou
 */
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中使用

/**
 * 业务层
 * 数据层同理
 * @author zhou
 */
public interface MyService {
    void test();
}

import org.springframework.stereotype.Service;

/**
 * @author zhou
 */
@Service
public class MyServiceImpl implements MyService {

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

子类

/**
 * 周一
 * @author zhou
 */
@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

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);
    }

    /**
     * 通过class获取Bean.
     *
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    /**
     * 通过name,以及Clazz返回指定的Bean
     *
     * @param name
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }

}

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

}