spring提供的三种注入方式

属性注入

构造函数注入

工厂方法注入

demo项目目录结构

image.png

属性注入:

首先新建一个注入的类

package model;

/**
 * 属性注入: 即set注入
 * property的name必须要和字段名相同
 */
public class PropertyInjection {
    private String name;
    private int age;

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

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

然后在resources目录下新建propertyInjection.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean name="propertyInjectionBean" class="model.PropertyInjection">
        <property name="name" value="属性注入"/>
        <property name="age">
            <value>18</value>
        </property>
    </bean>
</beans>

再在test目录下新建BeanFactoryTest.class进行测试

import model.Car;
import model.ConstructorInjection;
import model.PropertyInjection;
import org.junit.Test;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;


public class BeanFactoryTest {
    
    @Test
    public void propertyInjectionBeanTest() {
        ApplicationContext applicationContextObj = new ClassPathXmlApplicationContext("propertyInjection.xml");
        PropertyInjection propertyInjectionObj = applicationContextObj.getBean("propertyInjectionBean", PropertyInjection.class);
        System.out.println(propertyInjectionObj.getName());
    } 

运行结果

image.png

构造函数注入:

新建java类Car.class

package model;

public class Car {
    private String brand;
    private String color;
    private int maxSpeed;

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getMaxSpeed() {
        return maxSpeed;
    }

    public void setMaxSpeed(int maxSpeed) {
        this.maxSpeed = maxSpeed;
    }
}

在新建一个构造函数注入类

package model;

/**
 * 构造函数注入
 */
public class ConstructorInjection {
    private String name;
    private int age;
    private Car car;

    public ConstructorInjection(String name, int age, Car car) {
        this.name = name;
        this.age = age;
        this.car = car;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

测试

  @Test
    public void constructorInjectionBeanTest() {
        ApplicationContext applicationContextObj = new ClassPathXmlApplicationContext("constructorInjection.xml");
        ConstructorInjection constructorInjection = applicationContextObj.getBean("constructorInjectionBean", ConstructorInjection.class);
        System.out.println(constructorInjection.getName());
        System.out.println(constructorInjection.getCar().getBrand());
    }

image.png

工厂方法注入:

首先新建一个工厂方法注入类:

package model;

/**
 * 工厂方法注入
 */
public class FactoryMethodInjection {
    /**
     * 非静态工厂方法
     * 工厂类的工厂方法为非静态, 故需在xml中先制定工厂类Bean, 然后再创建Bean的工厂方法
     *
     * @return
     */
    public Car createNoStaticFactory() {
        Car car = new Car();
        car.setBrand("非静态工厂方法: 黑旗");
        return car;
    }

    /**
     * 静态工厂方法
     * 工厂类的工厂方法为非静态, 故需在xml中先制定工厂类Bean, 然后再创建Bean的工厂方法
     *
     * @return
     */
    public static Car createStaticFactory() {
        Car car = new Car();
        car.setBrand("静态工厂方法: 红旗");
        return car;
    }
}

新建bean配置factoryMethodInjection.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--1,非静态工厂方法先创建工厂类Bean(相当于实例化)-->
    <bean id="factoryMethodInjectionBean" class="model.FactoryMethodInjection"/>
    <!--2,调用静态类中的非静态工厂方法-->
    <bean id="noStaticfactoryMethodInjectionBean"
          factory-bean="factoryMethodInjectionBean"
          factory-method="createNoStaticFactory"/>


    <!--静态工厂方法直接制定class即可factory-method静态方法-->
    <bean id="staticfactoryMethodInjectionBean" class="model.FactoryMethodInjection"
          factory-method="createStaticFactory"/>
</beans>

首先测试非静态工厂方法注入

 @Test
    public void noStaticFactoryMethodInjectionBean() {
        ApplicationContext applicationContextObj = new ClassPathXmlApplicationContext("factoryMethodInjection.xml");
        Car carObj = applicationContextObj.getBean("noStaticfactoryMethodInjectionBean", Car.class);
        System.out.println(carObj.getBrand());
    }

image.png

测试静态工厂方法注入

@Test
    public void staticFactoryMethodInjectionBean() {
        ApplicationContext applicationContextObj = new ClassPathXmlApplicationContext("factoryMethodInjection.xml");
        Car carObj = applicationContextObj.getBean("staticfactoryMethodInjectionBean", Car.class);
        System.out.println(carObj.getBrand());
    }

image.png