java开发两年，连Spring的依赖注入的方式都搞不清楚，你工作可能有点悬！

Spring依赖注入

常的java开发中，程序员在某个类中需要依赖其它类的方法，则通常是new一个依赖类再调用类实例的方法，这种开发存在的问题是new的类实例不好统一管理，spring提出了依赖注入的思想，即依赖类不由程序员实例化，而是通过spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是“控制反转”，通俗的理解是：平常我们new一个实例，这个实例的控制权是我们程序员，而控制反转是指new实例工作不由我们程序员来做而是交给spring容器来做。

构造函数注入

在bean标签的内部使用constructor-arg标签就可以进行构造函数注入了。

constructor-arg标签的属性：

type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引的位置从0开始
name：用于给指定构造函数中指定名称的参数赋值
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据，就是在IOC容器中出现过的bean对象

bean.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

        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="accountService" class="com.sks.service.imp.AccountServiceImpl">

        <constructor-arg type="java.lang.String" value="张三"/>

        <constructor-arg index="1" value="20"/>

        <constructor-arg name="birthday" ref="birthday"/>

    </bean>

    <bean id="birthday" class="java.util.Date"/>

</beans>

AccountServiceImpl 类

public class AccountServiceImpl implements AccountService {

    private String name;

    private Integer age;

    private Date birthday;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        this.age = age;

    }

    public Date getBirthday() {

        return birthday;

    }

    public void setBirthday(Date birthday) {

        this.birthday = birthday;

    }

    @Override

    public String toString() {

        return "AccountServiceImpl{" +

                "name='" + name + '\'' +

                ", age=" + age +

                ", birthday=" + birthday +

                '}';

    }

    public AccountServiceImpl(String name, Integer age, Date birthday) {

        System.out.println("含参的构造方法被调用了");

        this.name = name;

        this.age = age;

        this.birthday = birthday;

    }

    public AccountServiceImpl() {

        System.out.println("构造方法调用");

    }

    @Override

    public int addMoney(int money) {

        System.out.println("向账户中加钱:" + money);

        return 0;

    }

    @Override

    public void saveAccount(Account account) {

        System.out.println("saveAccount方法执行了");

    }

}

测试

	/**

     * 测试构造函数注入

     */

    @Test

    public void test8() {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");;

        AccountService accountService = (AccountService) applicationContext.getBean("accountService");

        System.out.println(accountService.toString());

    }

运行测试以后，可以在控制台看到以下内容：

优点：在获取bean对象时，注入数据是必须的操作，否则对象无法创建成功。

缺点：改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据也必须提供。

setter方法注入

在bean标签内部使用property标签进行配置。

property标签的属性：

name：用于指定注入时所调用的set方法名称
value：用于提供基本类型和String类型的数据
ref：用于指定其他的bean类型数据

这里面我们注入了基本类型、包装类型、日期类型数据。

AccountServiceImpl 类

public class AccountServiceImpl implements AccountService {

    private String name;

    private Integer age;

    private Date birthday;

    public String getName() {

        return name;

    }

    public void setName(String name) {

        System.out.println("给name设置值");

        this.name = name;

    }

    public Integer getAge() {

        return age;

    }

    public void setAge(Integer age) {

        System.out.println("给age设置值");

        this.age = age;

    }

    public Date getBirthday() {

        return birthday;

    }

    public void setBirthday(Date birthday) {

        System.out.println("给birthday设置值");

        this.birthday = birthday;

    }

    @Override

    public String toString() {

        return "AccountServiceImpl{" +

                "name='" + name + '\'' +

                ", age=" + age +

                ", birthday=" + birthday +

                '}';

    }

    public AccountServiceImpl(String name, Integer age, Date birthday) {

        System.out.println("含参的构造方法被调用了");

        this.name = name;

        this.age = age;

        this.birthday = birthday;

    }

    public AccountServiceImpl() {

        System.out.println("构造方法调用");

    }

    @Override

    public int addMoney(int money) {

        System.out.println("向账户中加钱:" + money);

        return 0;

    }

    @Override

    public void saveAccount(Account account) {

        System.out.println("saveAccount方法执行了");

    }

}

bean.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

        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="accountService" class="com.sks.service.imp.AccountServiceImpl">

    	<!--注入基本类型、包装类型、日期类型数据-->

       <property name="age" value="22"/>

        <property name="name" value="李四"/>

        <property name="birthday" ref="birthday"/>

    </bean>

    <bean id="birthday" class="java.util.Date"/>

</beans>

测试

    /**

     * 测试setter方法注入

     */

    @Test

    public void test9() {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");;

        AccountService accountService = (AccountService) applicationContext.getBean("accountService");

        System.out.println(accountService.toString());

    }

运行测试以后，可以在控制台看到以下内容：

优势：创建对象时没有明确的限制，可以直接使用默认构造函数。

缺点：如果又某个成员必须有值，则获取对象有可能是set方法没有执行。

对集合类型数据进行注入

AccountService2Impl 类

public class AccountService2Impl implements AccountService2 {

    private String[] myStrs;

    private List<String> myList;

    private Set<String> mySet;

    private Map<String, String> myMap;

    private Properties myProps;

    public String[] getMyStrs() {

        return myStrs;

    }

    public void setMyStrs(String[] myStrs) {

        this.myStrs = myStrs;

    }

    public List<String> getMyList() {

        return myList;

    }

    public void setMyList(List<String> myList) {

        this.myList = myList;

    }

    public Set<String> getMySet() {

        return mySet;

    }

    public void setMySet(Set<String> mySet) {

        this.mySet = mySet;

    }

    public Map<String, String> getMyMap() {

        return myMap;

    }

    public void setMyMap(Map<String, String> myMap) {

        this.myMap = myMap;

    }

    public Properties getMyProps() {

        return myProps;

    }

    public void setMyProps(Properties myProps) {

        this.myProps = myProps;

    }

    @Override

    public String toString() {

        return "AccountService2Impl{" +

                "myStrs=" + Arrays.toString(myStrs) +

                ", myList=" + myList +

                ", mySet=" + mySet +

                ", myMap=" + myMap +

                ", myProps=" + myProps +

                '}';

    }

}

bean.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

        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="accountService2" class="com.sks.service.imp.AccountService2Impl">

        <property name="myStrs">

            <array>

                <value>AAA</value>

                <value>BBB</value>

                <value>CCC</value>

            </array>

        </property>

        <property name="myList">

            <list>

                <value>list1</value>

                <value>list2</value>

                <value>list3</value>

            </list>

        </property>

        <property name="mySet">

            <set>

                <value>set1</value>

                <value>set2</value>

                <value>set3</value>

            </set>

        </property>

        <property name="myProps">

            <props>

                <prop key="name">柯森</prop>

                <prop key="age">23</prop>

            </props>

        </property>

        <property name="myMap">

            <map>

                <entry key="key1" value="value1"/>

                <entry key="key2" value="value2"/>

                <entry key="key3">

                    <value>value3</value>

                </entry>

            </map>

        </property>

    </bean>

</beans>

测试

    /**

     * 测试注入复杂类型/集合数据

     */

    @Test

    public void test10() {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");

        AccountService2 accountService2 = (AccountService2) applicationContext.getBean("accountService2");

        System.out.println(accountService2.toString());

    }

运行测试以后，可以看到在控制台打印输出了以下内容：

这说明我们注入集合类型数据成功了。

注解注入

用于注入数据的注解

bean.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"

       xmlns:context="http://www.springframework.org/schema/context"

       xsi:schemaLocation="http://www.springframework.org/schema/beans

        https://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--创建bean时要扫描的包-->

    <context:component-scan base-package="com.sks"/>

</beans>

AccountService4Impl 类

@Component

public class AccountService4Impl implements AccountService3 {

    @Autowired

    private AccountDao accountDao;

    @Override

    public void addMoney(int money) {

        System.out.println("向账户中加钱....AccountService3Impl");

    }

}

假设此时只有一个AccountDao的实现类，并且这个类也加上了@Repository注解，那么我们这样注入是可以成功的，但是如果容器中存在多个AccountDao的实现类，此时仅仅使用AccountDao是不能完成数据注入的，需要配合@Qualifier注解使用注入数据。

假设现有如下两个实现类，那我们应该怎么写才能成功注入数据？

@Component

public class AccountService4Impl implements AccountService3 {

	//错误写法，默认会去容器中查找名称为accountDao的bean

	 //@Autowired

   	//private AccountDao accountDao;

	//正确写法

	//@Autowired

	//private AccountDao accountDao1

	//正确写法

	//@Autowired

	//private AccountDao accountDao1;

	//正确写法

    @Autowired

    @Qualifier("accountDao1")

    private AccountDao accountDao;

    @Override

    public void addMoney(int money) {

        System.out.println("向账户中加钱....AccountService3Impl");

    }

}

测试

    @Test

    public void test2() {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");

        AccountService4Impl accountService4 = (AccountService4Impl) applicationContext.getBean("accountService4Impl");

        System.out.println("accountService4:" + accountService4);

    }

@Value注解的基本使用

在使用@Value注入基本类型和String类型的数据时使用"#“号；使用@Value读取配置文件的值时需要使用”$"符号，同时使用@PropertySource注解指定配置文件的位置。

@Component

@PropertySource("classpath:db.properties")

public class AccountService4Impl implements AccountService3 {

    @Autowired

    @Qualifier("accountDao1")

    private AccountDao accountDao;

	//使用SPEL表达式只注入值

    @Value("#{19 - 9}")

    private int age;

    @Value("zhangsan")

    private String name;

	//读取操作系统的名称

    @Value("#{systemProperties['os.name']}")

    private String osname;

    //读取数据库配置文件中的值

    @Value("${password}")

    private String password;

    @Override

    public void addMoney(int money) {

        System.out.println("向账户中加钱....AccountService3Impl");

    }

}

测试

    @Test

    public void test2() {

        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:bean.xml");

        AccountService4Impl accountService4 = (AccountService4Impl) applicationContext.getBean("accountService4Impl");

        System.out.println("accountService4:" + accountService4 + " " + accountService4.getName() + " " + accountService4.getAge());

    }

断点调试可以看到如下结果，说明我们使用@Value注入数据成功。

最后

欢迎关注公众号：前程有光，领取一线大厂Java面试题总结+各知识点学习思维导+一份300页pdf文档的Java核心知识点总结！

巴特西