Spring 结合策略模式，如何优雅的实践（普通注入，Map注入，自定义注解注入）
Spring 结合策略模式，如何优雅的实践（普通注入，Map注入，自定义注解注入）
一，认识
掌握注解@Autowired 和 @Resource 基本原理
使用方法
@Autowired和@Resource注解都是作为bean对象注入的时候使用的。两者都可以声明在字段和setter方法上
public class test{
/**字段注入**/
@Autowired
private XXXService service;
/**字段注入**/
@Resource
private XXXService service;
/**构造注入**/
@Autowired
public test(XXXService service){
this.service = service;
}
/**Setter注入**/
@Autowired
public void setService(XXXService service) {
this.service = service;
}
}
以上三种使用方式 字段注入，构造注入，setter注入。
区别：
@Autowired注解是Spring提供的，而@Resource注解是J2EE本身提供的
@Autowird注解默认通过byType方式注入，而@Resource注解默认通过byName方式注入
@Autowired注解注入的对象需要在IOC容器中存在，否则需要加上属性required=false，表示忽略当前要注入的bean，如果有直接注入，没有跳过，不会报错
其他源码不再撰述，可以自行查看网上相关资料。
掌握策略模式
不了解原理的，可以看我之前写的设计模式，策略博客：地址轻点跳转:https://blog.csdn.net/Crazy_Cw/article/details/106818217
二，实现策略模式
简单通过手动注入bean实现策略模式
定义一个父类接口
public interface Fruits{
void show();
}
实现接口1
//实现1
@Service
public class Apple implements Fruits {
@Override
public void show() {
System.out.println("我是苹果");
}
}
实现接口2
//实现2
@Service
public class Banana implements Fruits {
@Override
public void show() {
System.out.println("我是香蕉");
}
}
创建一个工厂，来实现不同水果
public class IndexMapDataFactory {
/**使用map，来封装**/
private static final Map<Integer, Fruits> MAP_DATA = Maps.newHashMap();
/**获得不同的实例对象**/
private static final Apple service1 = SpringUtil.getBean(Apple.class);
/**获得不同的实例对象**/
private static final Banana service2 = SpringUtil.getBean(Banana.class);
static {
MAP_DATA.put(0, service1);
MAP_DATA.put(1, service2);
}
/**获得不同的实例对象**/
public static Fruits getServiceByType(int type) {
return MAP_DATA.get(type);
}
}
我们这里看到工厂类IndexMapDataFactory 里面的不同的实现 通过手动注入， 实在不够优雅。接下来我们来升级
使用注解
这里我们来把工厂类改造一下升级一下，变得更加的优雅
/**记为Spring容器中的一个Bean**/
@Slf4j
@Component
public class StrategyFactory {
/**Spring会将实现注入到该map 里面， key:注入的name,默认类名小写， value：为该实例 **/
@Resource
private Map<String, Fruits> interFaceMap;
public Fruits getServiceByType(Integer code) {
String implementName = FruitsTypeEnum.getImplementByCode(code);
Fruits bean = interFaceMap.get(implementName);
if(bean == null){
log.error("策略工厂bean异常:{} bean is null",implementName);
throw new RuntimeException("bean is null");
}
return bean;
}
public enum FruitsTypeEnum {
APPLE(1,"apple", "苹果"),
/**记为Spring容器中的一个Bean**/
BANANA(2,"banana", "香蕉"),
/**code**/
public Integer code;
/**接口的实现类名**/
public String implement;
/**备注**/
public String desc;
public Integer getCode() {
return code;
}
public void setCode(Integer code) {
this.code = code;
}
public String getImplement() {
return implement;
}
public void setImplement(String implement) {
this.implement = implement;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
FruitsTypeEnum(Integer code, String implement, String desc) {
this.code = code;
this.implement = implement;
this.desc = desc;
}
public static String getImplementByCode(Integer code) {
for (FruitsTypeEnum value : FruitsTypeEnum.values()) {
if (value.getCode().equals(code)) {
return value.getImplement();
}
}
return null;
}
}
}
使用
public void Controller {
@Resource
StrategyFactory strategyFactory;
public void test(int code){
Fruits fruits = strategyFactory.getServiceByType(code);
fruits.show();
}
}
自定义注解，来优雅实现策略模式
自定义注解
import com.hong.strategy.enums.OrderTypeEnum;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定义策略注解
*/
@Target({ElementType.TYPE})
@Retention(value = RetentionPolicy.RUNTIME)
public @interface FruitsTypeAnnotation {
/**
* 策略类型
*/
String fruitsType();
}
接口实现
//实现1
@FruitsTypeAnnotation(type = "apple")
@Service
public class Apple implements Fruits {
@Override
public void show() {
System.out.println("我是苹果");
}
}
//实现2
@FruitsTypeAnnotation(type = "banana")
@Service
public class Banana implements Fruits {
@Override
public void show() {
System.out.println("我是香蕉");
}
}
一个水果品种实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Type {
private String name;
}
向spring容器中注入
@Component
public class StrategyFactory {
private Map<String, Fruits> map;
@Autowired
public void setMap(List<Fruits> fruitsInterfaces) {
map = fruitsInterfaces.stream().collect(
Collectors.toMap(t -> AnnotationUtils.findAnnotation(t.getClass(), FruitsTypeAnnotation.class).type(),
v -> v, (v1, v2) -> v1));
}
public void fruitsService(List<Type> list){
list.forEach(t->{
//可以根据注解的值判断走哪个实现类，如果有多个实现类就会依次走
Fruits fruits = map.get(t.getName());
fruits.show();
});
}
}
测试
@Autowired
private StrategyFactory strategyFactory;
@Test
void test(){
Type apple = new Type("apple");
Type banana = new Type("banana");
strategyFactory.fruitsService(Arrays.asList(apple,banana));
}