spring多子类如何自动注入

不及物动词 1年前其他 59

共3条回复我来回复

worktile
Worktile官方账号
评论
在Spring框架中，如果有多个子类实现了同一个接口或继承了同一个父类，并且希望将它们自动注入到相应的地方，可以通过以下几种方式来实现。
1. @Autowired和@Qualifier注解结合使用：
  在需要自动注入实例的地方，使用@Autowired注解标注该字段或方法，Spring会自动寻找匹配的实例注入。但是，如果有多个实例满足条件，可以使用@Qualifier注解指定具体的实例。
  示例代码如下：
```
public interface Animal {
}

@Component("cat")
public class Cat implements Animal {
}

@Component("dog")
public class Dog implements Animal {
}

@Component
public class Zoo {
    @Autowired
    @Qualifier("cat")
    private Animal cat;

    @Autowired
    @Qualifier("dog")
    private Animal dog;

    // ...
}
```
2. 使用@Primary注解：
  在多个实现类中，可以使用@Primary注解标注某个实现类为首选的实例，当需要自动注入时，如果没有指定具体的实例，则将注入该首选实例。
  示例代码如下：
```
public interface Animal {
}

@Component
@Primary
public class Cat implements Animal {
}

@Component
public class Dog implements Animal {
}

@Component
public class Zoo {
    @Autowired
    private Animal cat;

    @Autowired
    private Animal dog;

    // ...
}
```
3. 使用List或Map来存储实例：
  如果希望将所有满足条件的实例都注入到一个集合中，可以使用List或Map，然后使用@Autowired注解将所有实例自动注入。
  示例代码如下：
```
public interface Animal {
}

@Component
public class Cat implements Animal {
}

@Component
public class Dog implements Animal {
}

@Component
public class Zoo {
    @Autowired
    private List<Animal> animals;

    // ...
}
```
通过以上三种方式，可以实现在Spring中自动注入多个子类的实例。根据具体的业务需求，选择适合的方式来实现多子类的自动注入。
1年前 0条评论
不及物动词
这个人很懒，什么都没有留下～
评论
在Spring框架中，当存在多个子类时，可以通过使用自动注入的方式将合适的子类注入到目标对象中。Spring提供了几种主要的自动注入方式，包括构造器注入、属性注入和方法注入。
1. 构造器注入：通过在目标对象的构造器中声明参数来完成注入。在有多个子类的情况下，可以在构造器参数中使用@Qualifier注解来指定要注入的子类。示例代码如下：
```
@Component
public class TargetClass {
    
    private final ParentClass parentClass;

    public TargetClass(@Qualifier("childClass1") ParentClass parentClass) {
        this.parentClass = parentClass;
    }
}
```
1. 属性注入：通过在目标对象的属性上使用@Autowired注解来完成注入。同样，可以使用@Qualifier注解来指定要注入的子类。示例代码如下：
```
@Component
public class TargetClass {
    
    @Autowired
    @Qualifier("childClass1")
    private ParentClass parentClass;
}
```
1. 方法注入：通过在目标对象的方法上使用@Autowired注解来完成注入。同样，可以使用@Qualifier注解来指定要注入的子类。示例代码如下：
```
@Component
public class TargetClass {
    
    private ParentClass parentClass;
    
    @Autowired
    public void setParentClass(@Qualifier("childClass1") ParentClass parentClass) {
        this.parentClass = parentClass;
    }
}
```
1. 使用注解列表：通过在目标对象的属性上使用@Autowired注解来实现注入。在子类上使用自定义注解，并使用@Qualifier注解指定要注入的子类。在属性上使用@Autowired注解，并将@Qualifier注解的参数设置为自定义注解。示例代码如下：
```
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Qualifier
public @interface Child {

}

@Component
@Child
public class ChildClass1 implements ParentClass {
    //...
}

@Component
@Child
public class ChildClass2 implements ParentClass {
    //...
}

@Component
public class TargetClass {
    
    @Autowired
    @Child
    private List<ParentClass> childClasses;
}
```
1. 使用@Primary注解：通过在子类上使用@Primary注解来指定一个主要的子类，然后在目标对象的属性上使用@Autowired注解来完成注入。示例代码如下：
```
@Component
@Primary
public class ChildClass1 implements ParentClass {
    //...
}

@Component
public class ChildClass2 implements ParentClass {
    //...
}

@Component
public class TargetClass {
    
    @Autowired
    private ParentClass parentClass;
}
```
通过以上几种方式，可以在存在多个子类的情况下，实现自动注入。
1年前 0条评论
fiy
Worktile&PingCode市场小伙伴
评论
在Spring中，如果有多个子类实现了同一个接口或继承了同一个父类，并且需要自动注入到其他类中使用，可以通过以下方法实现。
1. 使用@Qualifier注解
  使用@Qualifier注解来标记具体的实现类，用于指定要注入的子类实例。首先，需要在接口或父类的实现类上使用@Qualifier注解来给它们分配一个唯一的标识，然后在需要注入的地方使用@Autowired和@Qualifier注解来指定具体要注入的子类实例。
```
public interface Animal {
    void makeSound();
}

public class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow");
    }
}

public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof");
    }
}

@Component
@Qualifier("cat")
public class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow");
    }
}

@Component
@Qualifier("dog")
public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof");
    }
}

@Component
public class AnimalService {
    private final Animal cat;
    private final Animal dog;
  
    public AnimalService(@Qualifier("cat") Animal cat, @Qualifier("dog") Animal dog) {
        this.cat = cat;
        this.dog = dog;
    }
  
    public void makeSounds() {
        cat.makeSound();
        dog.makeSound();
    }
}
```
在上面的例子中，我们使用@Qualifier("cat")和@Qualifier("dog")分别标记了Cat和Dog类，然后在AnimalService类的构造方法参数上使用@Qualifier注解来指定具体要注入的实例。
1. 使用@Primary注解
  使用@Primary注解来标记其中一个子类实现为首选注入实例。首先，需要在接口或父类的实现类上使用@Primary注解来标记其为主要实现类，然后在需要注入的地方使用@Autowired来自动注入。
```
public interface Animal {
    void makeSound();
}

@Primary
@Component
public class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow");
    }
}

@Component
public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof");
    }
}

public class AnimalService {
    private final Animal animal;
  
    public AnimalService(Animal animal) {
        this.animal = animal;
    }
  
    public void makeSound() {
        animal.makeSound();
    }
}
```
在上面的例子中，我们使用@Primary标记了Cat类，表示Cat类为首选注入实例。当需要注入Animal类的时候，会自动注入Cat类的实例。
1. 使用List或Map集合
  Spring还支持将多个子类实例注入为List或Map集合的方式。首先，需要在接口或父类的实现类上使用@Component注解进行标记，然后在需要注入的地方使用@Autowired注解进行注入。当存在多个子类实例时，Spring会自动将它们注入到List或Map集合中。
```
public interface Animal {
    void makeSound();
}

@Component
public class Cat implements Animal {
    public void makeSound() {
        System.out.println("Meow");
    }
}

@Component
public class Dog implements Animal {
    public void makeSound() {
        System.out.println("Woof");
    }
}

@Component
public class AnimalService {
    private final List<Animal> animals;
  
    public AnimalService(List<Animal> animals) {
        this.animals = animals;
    }
  
    public void makeSounds() {
        for (Animal animal : animals) {
            animal.makeSound();
        }
    }
}
```
在上面的例子中，我们将Cat和Dog类都标记为@Component注解，表示它们都是Spring容器中的Bean。然后，在AnimalService类的构造方法上使用List来接收注入的子类实例。当需要使用这些子类实例时，可以通过循环遍历List来进行操作。

总结：
使用@Qualifier注解、@Primary注解、List或Map集合的方式都可以实现在Spring中自动注入多个子类实例的需求。具体选择哪种方式取决于实际业务需求和个人偏好。
1年前 0条评论