spring详解：spring IOC依赖注入的几种方式

依赖注入（Dependency Injection）是用于实现控制反转（Inversion of Control）的最常见的方式之一,本文详细接收依赖注入各种数据类型和多种方法

准备

准备的两个类：User、Student

User类有三个属性，和两个构造器

package cn.mym.entity;

public class User {
	private Integer userId;
	private String username;
	private String password;
	
	public User(Integer userId, String username, String password) {
		this.userId = userId;
		this.username = username;
		this.password = password;
	}
	
	public User(){}		//默认构造器再次显示的声明
	
	public Integer getUserId() {
		return userId;
	}
	public void setUserId(Integer userId) {
		this.userId = userId;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}

	@Override
	public String toString() {
		return "User [userId=" + userId + ", username=" + username
				+ ", password=" + password + "]";
	}

Student中有自定义引用类型、复杂类型的准备

package cn.mym.entity;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class Student {
	
	private User user;			//引用类型的注入

	private String[] arr;		//数组类型注入
	
	private List<String> list;	//List类型注入

	private Set<String> set;		//Set类型注入
	
	private Map<String,Integer> map;	//Map类型注入
	
	private Properties pro;			//Properties类型注入
	
	/**演示构造器注入引用类型*/
	public Student(User user){
		this.user = user;
	}
    
        public Student(){}        //显示声明默认构造器

     //===========setter方法  由于篇幅问题，省略了 用来获取数据的getter方法===================
	
	public void setUser(User user) {
		this.user = user;
	}
	
	public void setArr(String[] arr) {
		this.arr = arr;
	}

	public void setList(List<String> list) {
		this.list = list;
	}

	public void setSet(Set<String> set) {
		this.set = set;
	}

	public void setMap(Map<String, Integer> map) {
		this.map = map;
	}

	public void setPro(Properties pro) {
		this.pro = pro;
	}

 }

属性注入的两种方式

setter方法注入

User类中的几个属性的注入，几个属性都需要有setter方法

配置：

<bean id="user" class="cn.mym.entity.User">
        	<!-- 注入user对象中的属性 -->
        	<property name="userId" value="10"></property>
        	<property name="username" value="123mmm"></property>
        	<property name="password" value="456yyy"></property>
 </bean>

测试：

@Test
public void test() {
	User user = (User) ac.getBean("user");
	System.out.println(user);
}

结果：输出：User [userId=10, username=123mmm, password=456yyy]

构造器注入

构造器注入基本封装类型--注入常量

配置：

        <!-- 构造器注入基本封装类型 -->
       <bean id="user1" class="cn.mym.entity.User">
        	<constructor-arg index="0" value="20"/>
        	<constructor-arg index="1" value="123m"/>
        	<constructor-arg index="2" value="456y"/>
        </bean>

测试输出：User [userId=20, username=123m, password=456y]

构造器注入自定义引用类型的属性--注入变量

用Student的对象创建演示构造器注入User类型属性
配置：

        <!-- 构造器注入自定义引用类型-变量 -->
        <bean id="stu" class="cn.mym.entity.Student">
        	<!-- 
        		通过构造器方式指定注入的bean
        		type：要注入的bean类型全名
        		ref：就是要注入的bean
         	-->
        	<constructor-arg index="0" type="cn.mym.entity.User" ref="user1"/>
        </bean>

测试：

        @Test
	public void test() {
		Student stu = (Student) ac.getBean("stu");
		System.out.println(stu.getUser());
	}

输出：User [userId=20, username=123m, password=456y]

注入外部bean

注入外部bean也就是注入自定义引用类型的属性，这里使用Student类来说明注入user属性

配置：

        <bean id="stu1" class="cn.mym.entity.Student">
        	<!-- name:要注入的属性
        		ref：注入的bean的id，此user1已经配置好
        	 -->
        	<property name="user" ref="user1"></property>
        </bean>

测试：

	@Test
	public void test() {
		Student stu = (Student) ac.getBean("stu1");
		System.out.println(stu.getUser());
	}

结果：User [userId=120, username=stu1123m, password=stu1456y]

内部bean注入

即要注入的bean在内部定义

配置：

        <!-- 注入内部bean -->
        <bean id="stu2" class="cn.mym.entity.Student">
        	<property name="user">
        		<bean class="cn.mym.entity.User">
        			<!-- user的属性注入-这里为了篇幅注入一个 -->
        			<property name="username" value="one"></property>
        		</bean>
        	</property>
        </bean>

测试：

        @Test
	public void test() {
		Student stu = (Student) ac.getBean("stu2");
		System.out.println(stu.getUser());
	}

结果：User [userId=null, username=one, password=null]

P名称空间注入

 p 名称空间给对象的属性注入值(spring3.0以上版本才支持)

通过User类bean的创建来说明

配置：

首先约束要声明p名称空间：

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

创建bean：

 <!-- p名称空间注入 -->
 <bean id="user2" class="cn.mym.entity.User" p:username="pName"/>

测试：

@Test
	public void testUser() {
		User user = (User) ac.getBean("user2");
		System.out.println(user);
	}

结果：User [userId=null, username=pName, password=null]

注入复杂数据类型

注入数组

注入Set集合

注入List集合

注入Map集合

注入Properties类型

<!-- 注入复杂数据类型 -->
        <bean id="stu3" class="cn.mym.entity.Student">
        	<property name="arr">
        		<list>
        			<value>a1</value>
        			<value>a2</value>
        		</list>
        	</property>
        	<property name="list">
        		<list>
        			<value>l1</value>
        			<value>l2</value>
        		</list>
        	</property>
        	<property name="set">
        		<set>
        			<value>s1</value>
        			<value>s2</value>
        		</set>
        	</property>
        	<property name="map">
        		<map>
        			<entry key="m1" value="123"/>
        			<entry key="m2" value="456"/>
        		</map>
        	</property>
        	<property name="pro">
        		<props>
        			<prop key="p1" >777</prop>
        			<prop key="p2" >999</prop>
        		</props>
        	</property>
        </bean>

测试：

       @Test
	public void testStu() {
		Student stu = (Student) ac.getBean("stu3");
		System.out.println(stu.getArr());
		System.out.println(stu.getList());
		System.out.println(stu.getSet());
		System.out.println(stu.getMap());
		System.out.println(stu.getPro());
	}

结果：

[Ljava.lang.String;@6e9ba4a9
[l1, l2]
[s1, s2]
{m1=123, m2=456}
{p2=999, p1=777}

小结：以上就是全部的依赖注入各种数据类型的多种方式，常用的就是通过setter方法进行注入，所以说过，一个类的属性想要通过spring进行注入，需要提供：无参构造器+属性的setter方法

spring的再次回顾总结，若有详述不当之处，感谢您私信纠正