场景
SpringBoot中策略模式+工厂模式业务实例(接口传参-枚举类查询策略映射关系-执行不同策略)规避大量if-else：
https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/130503707
设计模式-策略模式在Java中的使用示例：
https://blog.csdn.net/BADAO_LIUMANG_QIZHI/article/details/127622238
上面在讲策略模式具体在SpringBoot中应用时在规则工厂类中直接使用@Autowired注解将信号灯的规则全部注入。
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Map;
/**
* 信号灯规则工厂类
*/
@Component
public class SignalLightRulesFactory {
//Spring会自动将Strategy接口的实现类注入到这个Map中，key为bean id
即前面@Component注解指定的名称，value值则为对应的策略实现类
@Autowired
Map<String,SignalLightRules>
signalLightRulesStrategy;
public SignalLightRules getSignalLightRules(String
signalLightKey){
SignalLightRules
signalLightRules = signalLightRulesStrategy.get(signalLightKey);
return signalLightRules;
}
}
这里的信号灯规则接口类
public interface SignalLightRules {
List<SignalrightDevsDTO> getSignalrightDevsDtoList(String mineApiCode);
}
规则具体实现示例一
@Component(Constants.SIFANGJISIGNAL)
public class SiFangJiSignalLightRules implements
SignalLightRules{
@Override
public List<SignalrightDevsDTO>
getSignalrightDevsDtoList(String mineApiCode) {
List<SignalrightDevsDTO>
signalrightDevsDtoList = null;
//省略
return signalrightDevsDtoList;
}
}
这里使用注解@Autowired将所有的声明类注入到map中。这是因为
Spring会自动将Strategy接口的实现类注入到这个Map中，key为bean id 即前面@Component注解指定的名称，
value值则为对应的策略实现类。
注：
博客：
https://blog.csdn.net/badao_liumang_qizhi
实现
其实不光是map可以，如果是数组集合也可以，这块可以查看@Autowired注解的源码声明
/*
* Copyright 2002-2019 the
original author or authors.
*
*
Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the
License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable
law or agreed to in writing, software
* distributed
under the License is distributed on an "AS IS" BASIS,
*
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing
permissions and
* limitations under the License.
*/
package org.springframework.beans.factory.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Marks a constructor, field,
setter method, or config method as to be autowired by
*
Spring's dependency injection facilities. This is an alternative to the
JSR-330
* {@link javax.inject.Inject} annotation, adding
required-vs-optional semantics.
*
* <h3>Autowired Constructors</h3>
* <p>Only one constructor of any given bean class may
declare this annotation with the
* {@link #required} attribute set to {@code true}, indicating
<i>the</i> constructor
* to autowire when
used as a Spring bean. Furthermore, if the {@code required}
* attribute is set to {@code true}, only a
single constructor may be annotated
* with {@code @Autowired}. If multiple
<i>non-required</i> constructors declare the
* annotation, they will be considered as candidates for
autowiring. The constructor
* with the greatest number
of dependencies that can be satisfied by matching beans
* in the Spring container will be chosen. If none of the
candidates can be satisfied,
* then a primary/default
constructor (if present) will be used. Similarly, if a
*
class declares multiple constructors but none of them is annotated with
* {@code @Autowired}, then a primary/default
constructor (if present) will be used.
* If a class only
declares a single constructor to begin with, it will always be used,
* even if not annotated. An annotated constructor does not
have to be public.
*
*
<h3>Autowired Fields</h3>
* <p>Fields
are injected right after construction of a bean, before any config methods
* are invoked. Such a config field does not have to be
public.
*
* <h3>Autowired
Methods</h3>
* <p>Config methods may have an
arbitrary name and any number of arguments; each of
*
those arguments will be autowired with a matching bean in the Spring
container.
* Bean property setter methods are
effectively just a special case of such a general
*
config method. Such config methods do not have to be public.
*
* <h3>Autowired
Parameters</h3>
* <p>Although {@code @Autowired} can technically be declared
on individual method
* or constructor parameters since
Spring Framework 5.0, most parts of the
* framework
ignore such declarations. The only part of the core Spring Framework
* that actively supports autowired parameters is the JUnit
Jupiter support in
* the {@code spring-test} module
(see the
* <a href="TestContext'"
DESIGNTIMESP=2532>https://docs.spring.io/spring/docs/current/spring-framework-reference/testing.html#testcontext-junit-jupiter-di">TestContext
framework</a>
* reference documentation for
details).
*
* <h3>Multiple
Arguments and 'required' Semantics</h3>
*
<p>In the case of a multi-arg constructor or method, the {@link #required} attribute
* is applicable to all arguments. Individual parameters may
be declared as Java-8 style
* {@link java.util.Optional}
or, as of Spring Framework 5.0, also as {@code @Nullable}
* or a not-null parameter type in Kotlin, overriding the
base 'required' semantics.
*
*
<h3>Autowiring Arrays, Collections, and Maps</h3>
* <p>In case of an array, {@link
java.util.Collection}, or {@link java.util.Map}
* dependency type, the container autowires all beans
matching the declared value
* type. For such purposes,
the map keys must be declared as type {@code String}
* which will be resolved to the corresponding bean names.
Such a container-provided
* collection will be ordered,
taking into account
* {@link
org.springframework.core.Ordered Ordered} and
* {@link
org.springframework.core.annotation.Order @Order} values of the target
* components, otherwise following their registration order
in the container.
* Alternatively, a single matching
target bean may also be a generally typed
* {@code Collection} or {@code Map} itself,
getting injected as such.
*
*
<h3>Not supported in {@code BeanPostProcessor} or {@code BeanFactoryPostProcessor}</h3>
* <p>Note that actual injection is performed through
a
* {@link
org.springframework.beans.factory.config.BeanPostProcessor
* BeanPostProcessor} which in turn means that you
<em>cannot</em>
* use {@code @Autowired} to inject references
into
* {@link
org.springframework.beans.factory.config.BeanPostProcessor
* BeanPostProcessor} or
* {@link
org.springframework.beans.factory.config.BeanFactoryPostProcessor
BeanFactoryPostProcessor}
* types. Please consult the
javadoc for the {@link
AutowiredAnnotationBeanPostProcessor}
* class (which, by
default, checks for the presence of this annotation).
*
* @author Juergen Hoeller
* @author Mark Fisher
* @author Sam
Brannen
* @since 2.5
* @see
AutowiredAnnotationBeanPostProcessor
* @see Qualifier
* @see Value
*/
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD,
ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface
Autowired {
/**
* Declares whether the
annotated dependency is required.
* <p>Defaults
to {@code true}.
*/
boolean required() default true;
}
其中这里写到
In case of an array, java.util.Collection, or java.util.Map dependency type, the container autowires all beans matching the declared value type. For such purposes, the map keys must be declared as type String which will be resolved to the corresponding bean names.
翻译过来。
