Spring中三种注入方式

Spring中比较重要的是IOC的注入方式：

• 第一种：通过无参构造器进行注入
• 第二种：通过静态工厂进行注入
• 第三种：通过工厂模式进行注入

个人觉得通过无参构造器注入比较简单，也比较快捷

下面先为大家展示一下代码：

 第一种方式：无参构造器注入

首先在entity架包里面创建一个User.java的实体类

package com.hp.entity;

import java.io.Serializable;

public class User implements Serializable {

	/**
	 * 反序列化
	 */
	private static final long serialVersionUID = 1L;

	//无参构造器
	public User() {
		super();
		// TODO Auto-generated constructor stub
		System.out.println("通过无参构造器进行注入。。。。");
	}
	
	public void say(String name) {
		System.out.println(name+"你好！");
	}
	
	
	
}

然后在src下面创建一个applicationContext.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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
	<!-- 第一种注入方式：无参构造器注入 -->
	<bean id="user" class="com.hp.entity.User"></bean>
	
</beans>

在里面可以看到注释里面写的第一种注入方式

id是唯一名字，可以自己随便起，但一定是唯一的，class是我们刚刚创建的那个user.java的绝对路径

接下来我们看测试类SayTest.java

package com.hp.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.hp.entity.User;
import com.hp.entity.UserFactory;
import com.hp.entity.UserStatic;

public class SayTest {
	public static void main(String[] args) {
		//初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		//第一种方式：无参构造器进行注入
		//获取user对象
		User user = (User) context.getBean("user");
		user.say("海燕");
		
	}

}

我们首先要初始化Spring容器，ApplicationContext是Springjar包里面的一个方法，括号里面写的地址是我们刚刚创建的applicationContext.xml。getBean方法里面写的是我们在配置文件里面对应的唯一id名字，这个要特别注意 一定要保持一致

 

第二种：静态工厂注入

我们在entity包下再创建一个UserStatic.java

package com.hp.entity;

import java.io.Serializable;

public class UserStatic implements Serializable {

	/**
	 * 反序列化
	 */
	private static final long serialVersionUID = 1L;
	//第二种注入方式：通过静态工厂注入
	
	//定义属性
	private String name;
	//有参方法 是为了区别无参构造器注入
	public UserStatic(String name) {
		super();
		this.name = name;
	}
	
	/**
	 * 创建静态工厂
	 */
	public static UserStatic getUserStatic() {
		UserStatic userStatic = new UserStatic("");
		System.out.println("通过静态工厂进行注入。。。。");
		return userStatic;
	}
	
	/**
	 * say方法
	 */
	public void say(String name) {
		System.out.println(name+"你好！");
	}
}

里面用到的有参构造器是为了区分无参构造器注入，是为了证明不是通过无参构造来实现的，有参我们就要定义属性。使用静态工厂注入最主要的就是要有静态方法，然后通过这个方法获取返回值。

接下来是配置文件applicationContext.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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
	<!-- 第二种注入方式：静态工厂注入 -->
	<bean id="userStatic" class="com.hp.entity.UserStatic" factory-method="getUserStatic"></bean>
	
</beans>

里面的id还是唯一名字，自己定义，class是我们的刚刚创建的那个UserStatic.java的路径，factory-method是我们写的那个静态方法

我们再写测试类SayTest.java

package com.hp.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.hp.entity.User;
import com.hp.entity.UserFactory;
import com.hp.entity.UserStatic;

public class SayTest {
	public static void main(String[] args) {
		//初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
		
		//第二种方式：静态工厂进行注入
		UserStatic userStatic = (UserStatic) context.getBean("userStatic");
		userStatic.say("硕硕");
		
	}

}

跟我们第一种方法一样，注意getBean里面写的是我们配置文件里面的id。

 

第三种：工厂模式注入

首先我们再entity里面创建一个UserFactory.java

package com.hp.entity;

import java.io.Serializable;

public class UserFactory implements Serializable{

	/**
	 * 反序列化
	 */
	private static final long serialVersionUID = 1L;
	//定义属性
	private String name;
	//有参构造方法
	public UserFactory(String name) {
		super();
		this.name = name;
	}
	/**
	 * say方法
	 */
	public void say(String name) {
		System.out.println(name+"你好！");
	}
}

然后我们再在com.hp.factory包下面创建一个Factory.java

package com.hp.factory;

import com.hp.entity.UserFactory;

public class Factory {
	/**
	 * 工厂处理
	 */
	public UserFactory getUserFactory() {
		UserFactory userFactory = new UserFactory("");
		System.out.println("第三种注入方式：通过工厂模式注入。。。。");
		return userFactory;
	}
}

要用工厂注入首先我们得有工厂，我们创建工厂

再配置applicationContext.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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
	
	<!-- 第三种注入方式：工厂模式注入  -->
	<bean id="factory" class="com.hp.factory.Factory"></bean>
	<bean id="userFactory" class="com.hp.entity.UserFactory" factory-bean="factory" factory-method="getUserFactory"></bean>
</beans>

配置文件我们首先要找到工厂，找到之后我们再跟我们前两种一样找到我们的实体类，factory-bean里面写的是我们工厂的那个id

这让它们两个联系起来，然后在写上工厂里面的那个方法。

测试类SayTest.java

package com.hp.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.hp.entity.User;
import com.hp.entity.UserFactory;
import com.hp.entity.UserStatic;

public class SayTest {
	public static void main(String[] args) {
		//初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		
	
		
		//第三种方式：工厂模式进行注入
		UserFactory userFactory = (UserFactory) context.getBean("userFactory");
		userFactory.say("戏精");
	}

}

跟前两种一样，这里我就不再过多强调

我已经把所需要的Spring jar包上传了，大家可以自己下载试试看https://download.csdn.net/download/amazing_banana/11016062

接下来让大家看看我的运行效果