写在前面：
小伙伴儿们，大家好！上一篇我们讲了Spring中的核心思想IOC控制反转——Spring系列——带你了解什么是IOC（控制反转）？
这期让我们继续学习Spring中依赖注入的几种方式！
思维导图：
一、属性注入；
比方说我刚开始输出一个对象的话，看代码：
-
先建立一个实体类People：
package com.java.entity;
public class People {
private int id;
private String name;
private int age;
public People() {
//调用默认的构造方法
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
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;
}
}
-
然后是配置文件beans.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 id="people" class="com.java.entity.People"></bean>
</beans>
-
再来个测试类：
package com.java.test;
import com.java.entity.People;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test2 {
public static void main(String[] args) {
//加载beans.xml文件，调用Spring接口
ApplicationContext ac=new ClassPathXmlApplicationContext("beans.xml");
//通过id获取bean，返回一个对象
People people=(People)ac.getBean("people");
//调用方法
System.out.println(people);
}
}
我们看运行结果：
那么，属性注入又是怎么回事呢？
属性注入就是可以在beans配置文件中主动加入属性，以此来改变输出对象的特点；
-
我们在People类里面添加一下构造函数，并重写一下toString方法：
public People() {
//调用默认的构造方法
}
@Override
public String toString() {
return "People{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
-
在配置文件中加入属性：
//属性注入
<bean id="people2" class="com.java.entity.People">
<property name="id" value="1"></property>
<property name="age" value="18"></property>
<property name="name" value="张三"></property>
</bean>
-
测试函数：
//属性注入
People people2=(People)ac.getBean("people2");
System.out.println(people2);
我们看运行效果：
二、构造函数注入；(通过类型；通过索引；联合使用)
这里有三种注入方式；
-
先要把实体类的属性构造方法加上：
public People(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
-
然后是配置文件：
<!--类型注入-->
<bean id="people3" class="com.java.entity.People">
<constructor-arg type="int" value="2"></constructor-arg>
<constructor-arg type="String" value="李四"></constructor-arg>
<constructor-arg type="int" value="19"></constructor-arg>
</bean>
<!--索引注入-->
<bean id="people4" class="com.java.entity.People">
<constructor-arg index="0" value="3"></constructor-arg>
<constructor-arg index="1" value="王五"></constructor-arg>
<constructor-arg index="2" value="20"></constructor-arg>
</bean>
<!--联合使用-->
<bean id="people5" class="com.java.entity.People">
<constructor-arg type="int" index="0" value="4"></constructor-arg>
<constructor-arg type="String" index="1" value="赵六"></constructor-arg>
<constructor-arg type="int" index="2" value="21"></constructor-arg>
</bean>
-
测试函数：
//类型注入
People people3=(People)ac.getBean("people3");
System.out.println(people3);
//类型注入
People people4=(People)ac.getBean("people4");
System.out.println(people4);
//联合使用
People people5=(People)ac.getBean("people5");
System.out.println(people5);
运行结果:
三、工厂方法注入；(非静态工厂，静态工厂)；
这里分为静态工厂和非静态工厂； 一般用得多的都是静态工厂；
-
我们先建立一个工厂实体类：
package com.java.factory;
import com.java.entity.People;
public class PeopleFactory {
//非静态工厂
public People createPeople(){
People p=new People();
p.setId(5);
p.setName("阿七");
p.setAge(22);
return p;
}
//静态工厂
public static People createPeople1(){
People p=new People();
p.setId(6);
p.setName("阿八");
p.setAge(23);
return p;
}
}
-
配置文件：
<!--工厂模式的非静态方法-->
<bean id="peopleFactory" class="com.java.factory.PeopleFactory"></bean>
<bean id="people6" factory-bean="peopleFactory" factory-method="createPeople"></bean>
<!--工厂模式的静态方法-->
<bean id="people7" class="com.java.factory.PeopleFactory" factory-method="createPeople1"></bean>
-
测试类：
//工厂方式注入，非静态
People people6=(People)ac.getBean("people6");
System.out.println(people6);
//工厂方式注入，静态
People people7=(People)ac.getBean("people7");
System.out.println(people7);
运行结果：
好了，今天就先分享到这里了，下期继续给大家带来Spring系列后续讲解！欢迎关注我的原创技术公众号~ 干货多多满满~
原创实属不易，求个关注吧~