spring如何注入抽象类

fiy 1年前其他 121

共3条回复我来回复

worktile
Worktile官方账号
评论
在Spring中，注入抽象类与注入普通类的方式是相同的。Spring提供了两种方式进行抽象类的注入：构造方法注入和属性注入。
1. 构造方法注入：
  通过构造方法将依赖的抽象类注入到目标类中。在目标类中定义一个与抽象类相同的构造方法，并在该方法中接收抽象类作为参数。Spring会根据配置文件自动实例化抽象类，并注入到目标类的构造方法中。
  
  例如，假设有如下抽象类和它的实现类：
```
public abstract class AbstractClass {
    // 抽象类的成员变量和方法
}

public class ConcreteClass extends AbstractClass {
    // 实现类的成员变量和方法
}
```
  在目标类中使用构造方法注入：
```
public class TargetClass {
    private AbstractClass abstractClass;

    public TargetClass(AbstractClass abstractClass) {
        this.abstractClass = abstractClass;
    }
    
    // 目标类的其他成员变量和方法
}
```
  在Spring配置文件中进行配置：
```
<bean id="abstractClass" class="com.example.ConcreteClass" />

<bean id="targetClass" class="com.example.TargetClass">
    <constructor-arg ref="abstractClass" />
</bean>
```
2. 属性注入：
  通过属性将依赖的抽象类注入到目标类中。在目标类中定义一个与抽象类对应的属性，并提供相应的setter方法。Spring会根据配置文件自动实例化抽象类，并通过setter方法将实例注入到目标类的属性中。
  
  例如，继续使用上述的抽象类和实现类，修改目标类如下：
```
public class TargetClass {
    private AbstractClass abstractClass;

    public void setAbstractClass(AbstractClass abstractClass) {
        this.abstractClass = abstractClass;
    }
    
    // 目标类的其他成员变量和方法
}
```
  在Spring配置文件中进行配置：
```
<bean id="abstractClass" class="com.example.ConcreteClass" />

<bean id="targetClass" class="com.example.TargetClass">
    <property name="abstractClass" ref="abstractClass" />
</bean>
```
无论是构造方法注入还是属性注入，Spring都会根据配置文件中定义的bean来实例化抽象类，并自动注入到目标类中。通过这种方式，可以方便地实现对抽象类的注入和使用。
1年前 0条评论
fiy
Worktile&PingCode市场小伙伴
评论
在Spring中，注入抽象类与注入普通类的方式大致相同，只需稍作调整即可。
1. 使用@Autowired注解：
  使用@Autowired注解可以实现自动注入。在需要注入抽象类的地方，使用@Autowired注解进行标记。Spring会自动查找合适的实现类进行注入。示例代码如下：
```
public abstract class AbstractClass {
    // ...
}

public class ConcreteClass extends AbstractClass {
    // ...
}

public class SomeClass {
    @Autowired
    private AbstractClass abstractClass;

    // ...
}
```
2. 使用@Resource注解：
  @Resource注解也可以实现抽象类的注入。使用@Resource注解时，可以通过指定name或type属性来指定要注入的实现类。示例代码如下：
```
public abstract class AbstractClass {
    // ...
}

public class ConcreteClass extends AbstractClass {
    // ...
}

public class SomeClass {
    @Resource(name="concreteClass")
    private AbstractClass abstractClass;

    // ...
}
```
3. 使用@Bean注解：
  使用@Bean注解可以将实现类注册为Spring的Bean，并通过参数的方式注入到其他类中。示例代码如下：
```
public abstract class AbstractClass {
    // ...
}

@Configuration
public class AppConfig {
    @Bean
    public AbstractClass abstractClass() {
        return new ConcreteClass();
    }
}

public class SomeClass {
    @Autowired
    private AbstractClass abstractClass;

    // ...
}
```
4. 使用Java配置类：
  可以使用Java配置类定义抽象类的注入方式。通过@Configuration注解将配置类标记为配置类，使用@Bean注解将实现类注册为Bean，然后通过@Autowired注解注入到其他类中。示例代码如下：
```
public abstract class AbstractClass {
    // ...
}

@Configuration
public class AppConfig {
    @Bean
    public AbstractClass abstractClass() {
        return new ConcreteClass();
    }
}

public class SomeClass {
    @Autowired
    private AbstractClass abstractClass;

    // ...
}
```
5. 使用XML配置文件：
  如果你使用的是XML配置文件，可以使用标签将实现类注册为Spring的Bean，然后将其注入到其他类中。示例代码如下：
```
<beans>
    <bean id="concreteClass" class="com.example.ConcreteClass" />
    <bean id="someClass" class="com.example.SomeClass">
        <property name="abstractClass" ref="concreteClass" />
    </bean>
</beans>
```
以上是几种常见的注入抽象类的方式，根据具体的需求选择适合的方式即可。
1年前 0条评论
不及物动词
这个人很懒，什么都没有留下～
评论
在Spring中，可以通过使用@Autowired注解将抽象类注入到其他类中。这个过程叫做依赖注入。下面是一个简单的示例来说明如何在Spring中注入抽象类。

首先，我们需要定义一个抽象类。假设我们有一个名为Animal的抽象类，其中有一个抽象的方法makeSound：
```
public abstract class Animal {
    public abstract void makeSound();
}
```
接下来，我们需要一个具体的实现类来继承Animal抽象类，并实现makeSound方法。假设我们有一个名为Cat的类：
```
@Component
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow");
    }
}
```
注意，我们在Cat类上添加了@Component注解，这个注解告诉Spring这是一个需要进行依赖注入的类。

然后，我们需要一个类来使用Animal的实例。假设我们有一个名为AnimalService的类：
```
@Service
public class AnimalService {
    private Animal animal;

    @Autowired
    public void setAnimal(Animal animal) {
        this.animal = animal;
    }

    public void sound() {
        animal.makeSound();
    }
}
```
在AnimalService类中，我们使用@Autowired注解将Animal对象注入到animal字段中。

最后，我们需要在Spring配置文件中配置自动扫描和注入。假设我们使用的是注解驱动的配置方式，那么我们需要在配置文件中添加以下内容：
```
<context:annotation-config/>
<context:component-scan base-package="com.example"/>
```
这里的com.example是指示Spring扫描哪个包以查找注解类并进行注入。

现在，我们可以在其他类中使用AnimalService的实例了。例如：
```
public class MainClass {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        AnimalService animalService = context.getBean(AnimalService.class);
        animalService.sound();
    }
}
```
注意，我们使用getBean方法从ApplicationContext中获取AnimalService的实例，并调用其sound方法。

这样，当我们运行MainClass时，将会输出"Meow"，表示Cat类中的makeSound方法被调用了。

通过以上的步骤，我们成功地将抽象类Animal注入到其他类中，并且可以使用其实现类的方法。
1年前 0条评论