spring如何区分多个实现类 • Worktile社区

worktile

Worktile官方账号

在Spring中，要区分多个实现类，可以使用以下几种方式：

使用@Qualifier注解：在托管给Spring容器的多个实现类中，可以使用@Qualifier注解来指定具体使用哪一个实现类。例如：

@Component
@Qualifier("implOne")
public class ImplementationOne implements MyInterface {
    // 实现类代码
}

@Component
@Qualifier("implTwo")
public class ImplementationTwo implements MyInterface {
    // 实现类代码
}

然后在使用的地方，通过@Qualifier注解指定具体使用哪一个实现类：

@Autowired
@Qualifier("implOne")
MyInterface myInterface;

使用@Primary注解：可以在多个实现类中，使用@Primary注解指定一个默认的实现类。当使用@Autowired注解进行依赖注入时，会首先选择带有@Primary注解的实现类。例如：

@Component
@Primary
public class ImplementationOne implements MyInterface {
    // 实现类代码
}

@Component
public class ImplementationTwo implements MyInterface {
    // 实现类代码
}

使用配置文件：可以在配置文件（如application.properties或application.yml）中指定具体使用哪一个实现类。例如：

myInterface.implementation=implOne // 配置文件中的配置

然后在使用的地方，通过@Value注解来注入实现类的名称，并根据名称选择具体使用哪一个实现类：

@Autowired
@Qualifier("${myInterface.implementation}")
MyInterface myInterface;

以上是几种常用的方式来区分Spring中的多个实现类，根据具体情况选择适合的方式来实现。

1年前 0条评论

不及物动词

这个人很懒，什么都没有留下～

在Spring框架中，可以通过以下方式来区分多个实现类：

使用@Qualifier注解：使用@Qualifier注解可以指定特定实现类的名称，将其与注入点进行关联。首先，在实现类的Bean定义上给出一个名称，然后在注入点上使用@Qualifier注解来指定该名称，从而指定要注入的实现类。

@Component("implementationA")
public class ImplementationA implements SomeInterface {
    // implementation
}

@Component("implementationB")
public class ImplementationB implements SomeInterface {
    // implementation
}

@Component
public class MyClass {
    @Autowired
    @Qualifier("implementationA")
    private SomeInterface implementationA;

    @Autowired
    @Qualifier("implementationB")
    private SomeInterface implementationB;

    // use the implementations
}

使用@Primary注解：通过在多个实现类的Bean定义上使用@Primary注解，可以指定一个默认的首选实现类。如果注入点没有指定特定的实现类名称或使用@Qualifier注解，将使用@Primary注解标记的实现类。

@Component
@Primary
public class ImplementationA implements SomeInterface {
    // implementation
}

@Component
public class ImplementationB implements SomeInterface {
    // implementation
}

@Component
public class MyClass {
    @Autowired
    private SomeInterface implementationA; // ImplementationA will be injected

    @Autowired
    private SomeInterface implementationB; // ImplementationB will be injected

    // use the implementations
}

使用泛型依赖注入：Spring支持泛型依赖注入，可以通过使用泛型类型来实现不同实现类的注入。

@Component
public class ImplementationA implements SomeInterface {
    // implementation
}

@Component
public class ImplementationB implements SomeInterface {
    // implementation
}

@Component
public class MyClass<T extends SomeInterface> {
    @Autowired
    private T implementation; // ImplementationA or ImplementationB will be injected, based on the type parameter

    // use the implementation
}

使用@Autowired和@Qualifier的组合：@Autowired和@Qualifier注解可以一起使用，在注入点上使用@Qualifier注解指定特定实现类的名称。

@Component("implementationA")
public class ImplementationA implements SomeInterface {
    // implementation
}

@Component("implementationB")
public class ImplementationB implements SomeInterface {
    // implementation
}

@Component
public class MyClass {
    @Autowired
    @Qualifier("implementationA")
    private SomeInterface implementationA;

    @Autowired
    @Qualifier("implementationB")
    private SomeInterface implementationB;

    // use the implementations
}

使用配置文件：在Spring的配置文件中，可以指定注入点使用哪个实现类。

<bean id="implementationA" class="com.example.ImplementationA" />
<bean id="implementationB" class="com.example.ImplementationB" />

<bean id="myClass" class="com.example.MyClass">
    <property name="implementationA" ref="implementationA" />
    <property name="implementationB" ref="implementationB" />
</bean>

以上是一些常见的区分多个实现类的方法，根据项目需要和实际情况选择合适的方式。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

在Spring框架中，如果有多个实现类，可以通过以下几种方式来区分和选择相应的实现类：

使用@Qualifier注解：
可以为每个实现类添加一个自定义的限定符（Qualifier），然后在需要注入的地方使用@Qualifier注解来指定要注入的具体实现类。例如：

@Service
@Qualifier("implementationA")
public class ImplementationA implements InterfaceA {
    // 实现类A的具体逻辑...
}

@Service
@Qualifier("implementationB")
public class ImplementationB implements InterfaceA {
    // 实现类B的具体逻辑...
}

在需要注入InterfaceA的地方，可以使用@Qualifier注解来指定要注入的具体实现类：

@Autowired
@Qualifier("implementationA")
private InterfaceA interfaceA;

使用@Primary注解：
可以在实现类中使用@Primary注解来指定一个默认的实现类。当有多个实现类存在时，使用@Primary注解的实现类会被默认注入。例如：
```
@Service
@Primary
public class ImplementationA implements InterfaceA {
    // 实现类A的具体逻辑...
}

@Service
public class ImplementationB implements InterfaceA {
    // 实现类B的具体逻辑...
}
```
在需要注入InterfaceA的地方，可以直接使用@Autowired注解来注入实现类：
```
@Autowired
private InterfaceA interfaceA;
```
这样，Spring会自动注入带有@Primary注解的实现类。
使用@Bean注解：
如果使用Java配置类配置Bean，可以使用@Bean注解来指定要创建的Bean的具体实现类。使用@Bean注解时，需要为每个实现类指定一个唯一的方法名。例如：
```
@Configuration
public class MyAppConfig {
    @Bean
    public InterfaceA implementationA() {
        return new ImplementationA();
    }

    @Bean
    public InterfaceA implementationB() {
        return new ImplementationB();
    }
}
```
在需要注入InterfaceA的地方，可以直接使用@Autowired注解来注入实现类：
```
@Autowired
private InterfaceA interfaceA;
```
这样，Spring会根据方法名找到对应的实现类进行注入。
使用@Conditional注解：
可以使用@Conditional注解结合自定义的Condition类来进行条件判断，根据不同的条件选择注入不同的实现类。例如：
```
@Service
@Conditional(OnEnvironmentCondition.class)
public class ImplementationA implements InterfaceA {
    // 实现类A的具体逻辑...
}

@Service
@Conditional(OnEnvironmentCondition.class)
public class ImplementationB implements InterfaceA {
    // 实现类B的具体逻辑...
}
```
在自定义的Condition类中，可以根据特定的条件返回true或false，从而控制被注解的Bean是否被创建和使用。

需要注意的是，以上方法可以同时使用，以便更灵活地选择和注入实现类。

1年前 0条评论