Spring使用Setter完成依赖注入方式

Spring使用Setter完成依赖注入方式的完整攻略

什么是依赖注入

依赖注入（Dependency Injection，简称DI）是一种编程思想，它将一个对象所依赖的其他对象交给容器在运行期间动态地注入。这样可以消除类与类之间的耦合，降低代码的复杂度，提高代码的可维护性和可复用性。

Spring框架中使用依赖注入来管理对象之间的依赖关系，开发者只需要负责定义好各个对象和它们之间的关系，Spring容器就负责将对象实例化、组装、维护以及提供各种支持。

使用Setter完成依赖注入

Spring框架中使用Setter完成依赖注入是最常见的一种方式。当使用Setter方式注入依赖关系时，Spring容器会通过调用对象的Setter方法来设置依赖关系。

步骤

1.定义Bean的Class

首先，我们需要在Spring的配置文件中定义需要注入依赖关系的Bean的Class。

<bean id="dependency" class="com.example.Dependency">
    <property name="dependencyName" value="exampleDependency"></property>
</bean>

<bean id="dependent" class="com.example.Dependent">
    <property name="dependency" ref="dependency"></property>
</bean>

在上面的配置文件中，我们定义了两个Bean，一个是名为dependency的Bean，另一个是名为dependent的Bean。其中，dependency表示需要注入到dependent中的对象，dependent表示需要使用dependency的对象。

2.定义依赖关系

在定义了需要注入依赖关系的Bean之后，我们需要在dependent的Class中定义一个Setter方法来接收dependency。

public class Dependent {
    private Dependency dependency;

    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

在上面的代码中，dependent的Class定义了一个名为setDependency的Setter方法来接收dependency。Setter方法的命名必须以set开头，后跟与Bean属性名称相同的名称，具有一个以Bean的属性类型作为参数的方法体。

3.测试

在定义完依赖关系之后，我们可以通过Spring容器获取dependent对象，然后调用它的方法来访问dependency。

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Dependent dependent = (Dependent) context.getBean("dependent");
        dependent.operation();
    }
}

在上面的代码中，我们使用Spring的ApplicationContext来获取dependent对象，并调用它的operation方法来访问dependency。

示例

下面我们通过两个示例演示如何使用Setter完成依赖注入。

示例一

我们定义了一个接口MessageService和两个实现类EmailMessageService和SMMessageService。

public interface MessageService {
    void sendMessage(String message);
}

public class EmailMessageService implements MessageService {
    public void sendMessage(String message) {
        System.out.println("EmailMessageService：" + message);
    }
}

public class SMMessageService implements MessageService {
    public void sendMessage(String message) {
        System.out.println("SMMessageService：" + message);
    }
}

然后，我们需要定义一个类MessageProcessor来使用MessageService。

public class MessageProcessor {
    private MessageService messageService;

    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }

    public void processMessage(String message) {
        messageService.sendMessage(message);
    }
}

在上面的代码中，我们定义了一个名为messageService的私有成员变量，并提供了一个名为setMessageService的Setter方法来接受MessageService实例。

我们在配置文件中定义了两个BeanemailService和smService，分别表示两个不同的MessageService实现类。

<bean id="emailService" class="com.example.EmailMessageService" />

<bean id="smService" class="com.example.SMMessageService" />

然后，我们在配置文件中定义了messageProcessor的Bean，并使用dependency属性来设置messageService依赖。

<bean id="messageProcessor" class="com.example.MessageProcessor">
    <property name="messageService" ref="emailService" />
</bean>

我们可以通过Spring容器获取messageProcessor对象，并调用processMessage方法来使用EmailMessageService。

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MessageProcessor messageProcessor = (MessageProcessor) context.getBean("messageProcessor");
        messageProcessor.processMessage("Hello World!");
    }
}

当我们运行上述代码时，控制台输出如下：

EmailMessageService：Hello World!

示例二

我们定义了一个Person类，其中包含了一个Address对象。

public class Person {
    private String name;
    private Address address;

    public void setName(String name) {
        this.name = name;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I am from " + address);
    }
}

public class Address {
    private String city;
    private String street;

    public Address(String city, String street) {
        this.city = city;
        this.street = street;
    }

    @Override
    public String toString() {
        return "Address{" + "city='" + city + '\'' + ", street='" + street + '\'' + '}';
    }
}

我们在配置文件中定义了person和address两个Bean。

<bean id="person" class="com.example.Person">
    <property name="name" value="Zhangsan" />
    <property name="address" ref="address" />
</bean>

<bean id="address" class="com.example.Address">
    <constructor-arg value="Beijing" />
    <constructor-arg value="Wangjing" />
</bean>

使用<property>标签来设置依赖关系，其中name属性为person的成员变量名称，value属性为给成员变量赋的值。另外，ref属性表示需要被注入的Bean的ID。

我们可以通过Spring容器获取person对象，并调用sayHello方法。

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = (Person) context.getBean("person");
        person.sayHello();
    }
}

当我们运行上述代码时，控制台输出如下：

Hello, my name is Zhangsan, I am from Address{city='Beijing', street='Wangjing'}

总结

Setter方式是Spring中最常用的依赖注入方式之一，使用时只需要定义对应的Setter方法即可。使用Setter完成依赖注入可以降低类与类之间的耦合度，提高代码的可维护性和可复用性，Spring的依赖注入机制使得开发过程变得更加简单和灵活。