策略+工厂，策略+模板+工厂

g3230863

已于 2022-10-18 17:49:54 修改

阅读量85

点赞数

分类专栏： java 算法文章标签： java spring

于 2021-09-08 16:38:49 首次发布

本文链接：https://blog.csdn.net/g3230863/article/details/120182914

版权

java 同时被 2 个专栏收录

65 篇文章 0 订阅

订阅专栏

算法

14 篇文章 0 订阅

订阅专栏

1.策略代码

接口

public interface MapService {
    String saySomething();
    default String name(){
        return "default_name";
    }
}

实现

@Service(value = "MapServiceImpl1")
public class MapServiceImpl1 implements MapService {
    @Override
    public String saySomething() {
        return "MapServiceImpl----1";
    }
    @Override
    public String name() {
        return "testMap";
    }
}

根据Service名称装载到map中

@Service
public class MapServiceFactory {
    @Autowired
    Map<String, MapService> mapservice;

    public MapService getInstance(String name){
        MapService mapService = mapservice.get(name);
        if( mapService == null){
            System.out.println("没有此实现类");
            return null;
        }
        return mapService;
    }
}

通过applicationContext.getBeansOfType找到所有的实现，根据里面的变量在组件一个map

@Component
public class ServiceFactory {

    @Autowired
    ApplicationContext applicationContext;

   
    private static final Map<String, MapService> serviceMap = new ConcurrentHashMap<>(8);

    @PostConstruct
    private void initServiceMap () {
        Map<String, MapService> beans = applicationContext.getBeansOfType(MapService.class);
        beans.forEach((beanName, service) -> serviceMap.put(service.name(), service));
    }

    public MapService getInstance(String name) {
        if(serviceMap.containsKey(name)) {
            return serviceMap.get(name);
        }
        return serviceMap.get("default");
    }
}

2.策略+模板代码

定义接口

public interface MapService {
    String saySomething();
    
    default String name(){
        return "default_name";
    }

    String doSomething();
}

增加一个抽象类

public abstract class AbstractServiceImpl implements MapService {

    @Override
    public String saySomething() {

        String a = "hello";

        String s = this.doSomething();

        String b = "world";
        return a.concat(s).concat(b);
    }


}

让实现类去继承抽象类

@Service(value = "MapServiceImpl1")
public class MapServiceImpl1 extends AbstractServiceImpl {
    @Override
    public String saySomething() {

      return   super.saySomething();
    }

    @Override
    public String name() {
        return "testMap";
    }

    @Override
    public String doSomething() {
         return "do  --------1----------";
    }
}

策略工厂方法

@Component
public class ServiceFactory {

    @Autowired
    ApplicationContext applicationContext;

   
    private static final Map<String, MapService> serviceMap = new ConcurrentHashMap<>(8);

    @PostConstruct
    private void initServiceMap () {
        Map<String, MapService> beans = applicationContext.getBeansOfType(MapService.class);
        beans.forEach((beanName, service) -> serviceMap.put(service.name(), service));
    }

    public MapService getInstance(String name) {
        if(serviceMap.containsKey(name)) {
            return serviceMap.get(name);
        }
        return serviceMap.get("default");
    }
}

测试类，通过传入的值不同，会得到不同的实现类

  @Test
    public void test()
    {
        MapService testMap2 = ServiceFactory.getInstance("testMap");
        String s = testMap2.saySomething();
        System.out.println(s);
    }