策略模式-xml配置实现

前言

工作中经常要写一些业务代码，但如何写好却是一件不那么容易的事情，特别是需要灵活运用设计模式去代码进行重构，本篇文章只通过利用spring的配置去实现策略模型，相信会对大家有所帮忙。

方法介绍

1、首先需要定义接口，描述策略的关键方法
2、定义接口的实现类，也就是策略的具体实现
3、将每个策略的具体实现类加载spring容器中
4、利用ApplicationContextAware的作用是可以方便获取Spring容器ApplicationContext，从而可以获取容器内的Bean，即方便获取每个策略的具体实现类。
备注：
ApplicationContextAware 通过它Spring容器会自动把上下文环境对象调用ApplicationContextAware接口中的setApplicationContext方法。这样我们在ApplicationContextAware的实现类中，就可以通过这个上下文环境对象得到Spring容器中的Bean。
ApplicationContextAware的作用是可以方便获取Spring容器ApplicationContext，从而可以获取容器内的Bean。

public interface ApplicationContextAware extends Aware {
    void setApplicationContext(ApplicationContext var1) throws BeansException;
}

ApplicationContextAware接口只有一个方法，如果实现了这个方法，那么Spring创建这个实现类的时候就会自动执行这个方法，把ApplicationContext注入到这个类中，也就是说，spring 在启动的时候就需要实例化这个 class（如果是懒加载就是你需要用到的时候实例化），在实例化这个 class 的时候，发现它包含这个 ApplicationContextAware 接口的话，sping 就会调用这个对象的 setApplicationContext 方法，把 applicationContext Set 进去了。

代码实现

定义策略接口

public interface BackHome {
    public void goToHome();
}

定义策略接口的实现类

public class BackHomeByCar implements BackHome {
    @Override
    public void goToHome() {
        System.out.println("back home by car");
    }
}

public class BackHomeByBike implements BackHome {
    @Override
    public void goToHome() {
        System.out.println("back home by bike!!!");
    }
}

策略枚举

public enum BackHomeTools {

    BY_BIKE(1,"ByBike"),
    By_CAR(2,"ByCar"),
    ;

    private Integer code;
    private String description;

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    BackHomeTools(int i, String s) {
        this.code=i;
        this.description=s;
    }

    /**
     * 判断code是否在枚举中存在
     * @param code
     * @return
     */
    public static Boolean containsCode(Integer code){
        if (Objects.isNull(code)){
            return false;
        }
        for (BackHomeTools backHomeTool : values()){
            if (code.equals(backHomeTool.code)){
                return true;
            }
        }
        return false;
    }

    /**
     * find backHomeTools by code
     * @param code
     * @return
     */
    public static BackHomeTools valueOf(Integer code){
        return Arrays.stream(BackHomeTools.values())
                .filter(backHomeTools -> backHomeTools.getCode().equals(code))
                .findAny()
                .orElse(null);
    }
}

spring的xml文件进行配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans.xsd
 http://www.springframework.org/schema/aop
 http://www.springframework.org/schema/aop/spring-aop.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util.xsd" default-autowire="byName">

    <bean id="backHomeListener" class="com.coder.listener.BackHomeListener"> </bean>

    <bean id="backHomeContext" class="com.coder.context.BackHomeContext"></bean>

    <bean id="backHomeByBike" class="com.coder.service.impl.BackHomeByBike"> </bean>
    <bean id="backHomeByCar" class="com.coder.service.impl.BackHomeByCar"> </bean>

</beans>

ApplicationContextAware的作用是可以方便获取Spring容器ApplicationContext，从而可以获取容器内的Bean。

public class BackHomeContext implements ApplicationContextAware {
    private ApplicationContext applicationContext;

    public void backHome(Integer code){
        if (BackHomeTools.containsCode(code)){
            BackHome backHome = applicationContext.getBean("backHome"+ BackHomeTools.valueOf(code).getDescription(),BackHome.class);
            backHome.goToHome();
        }
    }

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

通过继承ApplicationListener接口去实现监听器，当项目一启动的时候就会执行其重写的onApplicationEvent()方法。

public class BackHomeListener implements ApplicationListener {

    private BackHomeContext backHomeContext;

    @Override
    public void onApplicationEvent(ApplicationEvent applicationEvent) {
        backHomeContext.backHome(1);
    }

    public void setBackHomeContext(BackHomeContext backHomeContext) {
        this.backHomeContext = backHomeContext;
    }
}

总结

上面通过监听器简单看了下策略模式的具体使用，实际使用过程中大家要结合具体业务进行使用。