springboot中使用模板⽅法设计模式-设计模块(六)

人生之路坎坎坷坷,跌跌撞撞在所难免。但是,不论跌了多少次,你都必须坚强勇敢地站起来。任何时候,无论你面临着生命的何等困惑抑或经受着多少挫折,无论道路多艰难,希望变得如何渺茫,请你不要绝望,再试一次,坚持到底,成功终将属于勇不言败的你。

导读:本篇文章讲解 springboot中使用模板⽅法设计模式-设计模块(六),希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com,来源:原文

模板⽅法设计模式

  • 抽象模板(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();
    }

}

使用模板方法实现一个省 市 区 乡镇 不同级别的统计

待续~

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由极客之音整理,本文链接:https://www.bmabk.com/index.php/post/133907.html

(0)
飞熊的头像飞熊bm

相关推荐

发表回复

登录后才能评论
极客之音——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!