java中的策略模式整合

weixin_44576239

已于 2024-05-10 14:01:13 修改

阅读量165

点赞数 2

文章标签： java 策略模式开发语言

于 2024-05-06 10:53:24 首次发布

本文链接：https://blog.csdn.net/weixin_44576239/article/details/138485434

版权

文章介绍了在SpringBoot项目中如何结合枚举和抽象工厂模式实现策略模式，分别展示了基于接口和具体实现类的示例，以及如何通过工厂方法动态创建并调用对应的行为服务。

摘要由CSDN通过智能技术生成

基于枚举的策略模式

public interface Eat {
    void eat(Food eatPre);
}

public class Food {
    public void prepareFood(){
        System.out.println("准备食物");
    }
}

public enum Animal implements Eat {
    /**
     * 猫
     */
    CAT(){
        @Override
        public void eat(Food food) {
            food.prepareFood();
            System.out.println("猫吃鱼");
        }
    },
    /**
     * 狗
     */
    DOG(){
        @Override
        public void eat(Food food) {
            food.prepareFood();
            System.out.println("狗吃肉");
        }
    },
    ;
}

public class AnimalTest {
    public static void main(String[] args) {
        Food food = new Food();
        Animal.DOG.eat(food);
    }
}

结合springboot基于简单工厂的策略模式

public enum AnimalEnum {
    /**
     * 人
     */
    PERSON(),
    /**
     * 猫
     */
    CAT(),
    /**
     * 狗
     */
    DOG(),
    ;
}

public interface AnimalService {
    /**
     * 动物类别
     * @return
     */
    AnimalEnum animalType();

    /**
     * 操作行为
     */
    void eat();
}

@Service
public class PersonServiceImpl implements AnimalService {
    @Override
    public AnimalEnum animalType() {
        return AnimalEnum.PERSON;
    }

    @Override
    public void eat() {
        System.out.println("人吃万物");
    }
}

@Service
public class DogServiceImpl implements AnimalService {
    @Override
    public AnimalEnum animalType() {
        return AnimalEnum.DOG;
    }

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

@Service
public class CatServiceImpl implements AnimalService {

    @Override
    public AnimalEnum animalType() {
        return AnimalEnum.CAT;
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

@Component
public class AnimalFactory implements ApplicationContextAware {
    private Map<AnimalEnum, AnimalService> map = new HashMap<>();
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, AnimalService> tempMap = applicationContext.getBeansOfType(AnimalService.class);
        tempMap.values().forEach(service -> map.put(service.animalType(), service));
    }

    public AnimalService buildAnimalService(AnimalEnum animalEnum){
        AnimalService animalService = map.get(animalEnum);
        if (animalService != null) {
            return animalService;
        }
        return map.get(AnimalEnum.PERSON);
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class AnimalTest {
    @Autowired
    private AnimalFactory animalFactory;
    public void testEat(){
        AnimalService animalService = animalFactory.buildAnimalService(AnimalEnum.CAT);
        animalService.eat();
    }
}

springboot基于抽象工厂实现的策略模式

基于三种策略（人、猫、狗），使用抽象工厂创建对应具体的工厂类型。再根据对应的行为，从而构建对应的行为策略。最后使用对应的工厂，生产出对应的行为service，使用对应的方法。

package com.test.mode.factory;

import org.springframework.context.ApplicationContextAware;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-6 10:24
 */
public interface AnimalFactory extends ApplicationContextAware {
    /**
     * 构建服务类
     * @param animalEnum 对应的服务类枚举
     * @return
     */
    IAnimalService buildAnimalService(AnimalEnum animalEnum);
}

package com.test.mode.factory;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-10 11:43
 */
public interface IAnimalService {
    /**
     * 服务类别
     * @return
     */
    AnimalEnum animalType();
}

package com.test.mode.factory;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-10 11:42
 */
public enum AnimalEnum {
    /**
     * 人
     */
    PERSON(),
    /**
     * 猫
     */
    CAT(),
    /**
     * 狗
     */
    DOG(),
    ;
}

package com.test.mode.factory.eat;

import com.test.mode.factory.AnimalEnum;
import com.test.mode.factory.AnimalFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.Map;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-10 11:47
 */
@Component
public class EatAnimalFactory implements AnimalFactory {
    private Map<AnimalEnum, EatAnimalService> businessImplMap = new HashMap<>();
    @Override
    public EatAnimalService buildAnimalService(AnimalEnum animalEnum) {
        return businessImplMap.get(animalEnum);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, EatAnimalService> tempMap = applicationContext.getBeansOfType(EatAnimalService.class);
        tempMap.values().forEach(service -> businessImplMap.put(service.animalType(), service));
    }
}

package com.test.mode.factory.eat;

import com.test.mode.factory.IAnimalService;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-10 11:48
 */
public interface EatAnimalService extends IAnimalService {
    /**
     * 吃什么
     */
    void eat();
}

package com.test.mode.factory.eat.impl;

import com.test.mode.factory.AnimalEnum;
import com.test.mode.factory.eat.EatAnimalService;
import org.springframework.stereotype.Service;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-10 11:53
 */
@Service
public class CatEatAnimalServiceImpl implements EatAnimalService {
    @Override
    public AnimalEnum animalType() {
        return AnimalEnum.CAT;
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

package com.test.mode.factory.eat.impl;

import com.test.mode.factory.AnimalEnum;
import com.test.mode.factory.eat.EatAnimalService;
import org.springframework.stereotype.Service;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-10 11:53
 */
@Service
public class DogEatAnimalServiceImpl implements EatAnimalService {
    @Override
    public AnimalEnum animalType() {
        return AnimalEnum.DOG;
    }

    @Override
    public void eat() {
        System.out.println("狗吃肉");
    }
}

package com.test.mode.factory.eat.impl;

import com.test.mode.factory.AnimalEnum;
import com.test.mode.factory.eat.EatAnimalService;
import org.springframework.stereotype.Service;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-10 11:50
 */
@Service
public class PersonEatAnimalServiceImpl implements EatAnimalService {
    @Override
    public AnimalEnum animalType() {
        return AnimalEnum.PERSON;
    }

    @Override
    public void eat() {
        System.out.println("人吃万物");
    }
}

方法调用

package com.test.service;

import com.test.mode.factory.AnimalEnum;
import com.test.mode.factory.eat.EatAnimalFactory;
import com.test.mode.factory.eat.EatAnimalService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @Author 
 * @Description
 * @Date create in 2024-5-10 12:04
 */
@SpringBootTest
@RunWith(SpringRunner.class)
public class AnimalServiceTest {
    @Autowired
    private EatAnimalFactory eatAnimalFactory;
    @Test
    public void testEet() {
        EatAnimalService animalService = eatAnimalFactory.buildAnimalService(AnimalEnum.PERSON);
        animalService.eat();
    }
}