JavaWeb学习-Spring框架-5-Spring配置详解之模块化配置和Spring属性注入

最新推荐文章于 2022-03-24 15:25:36 发布

Anthony_tester

最新推荐文章于 2022-03-24 15:25:36 发布

阅读量485

点赞数

分类专栏： Anthony的JavaWeb学习记录文章标签：模块化配置 set方法注入构造方法注入 p名称空间方法注入 spel注入

本文链接：https://blog.csdn.net/u011541946/article/details/91348683

版权

Anthony的JavaWeb学习记录专栏收录该内容

125 篇文章 33 订阅

订阅专栏

继续学习Spring相关配置的知识，本篇第一个知识点来学习下模块化配置，了解一个根目录下xml配置文件如何配置管理多个模块下的子配置文件。然后学习spring中的bean对象的四种注入方式，主要掌握set方法注入和构造方法注入。

1.模块化配置

在Spring中需要管理很多对象，可能几百个，我们有时候方便，一个模块写一个xml配置文件，然后在src根目录下有一个总的applicationContext.xml文件，我们只需要在这个总的xml文件导入其他模块的配置文件，就可以在运行的时候加载src根目录下的配置文件，去创建和操作对象。

文件结构

我在src下的applicationContext管理create包下的applicationContext文件

src下配置文件导入模块配置文件的方法

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd ">

	<!-- 导入其他Spring配置文件 -->
	<import resource="com/anthony/create/applicationContext.xml"/>
	
</beans>

create包下的xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd ">

	<!-- 对象创建方式1：空参构造 -->
	<bean name="user" class="com.anthony.bean.User" init-method="init" destroy-method="destory" ></bean>
	
</beans>

然后在test包下的demo1测试类，引用配置文件是写的src根目录下这个总配置文件

package com.anthony.test;

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

import com.anthony.bean.User;

public class Demo1 {

	@Test
	public void fun1() {
		//1 创建容器对象
		ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2 向容器 要 user对象
		User u = (User) ac.getBean("user");
		//3 打印user对象
		System.out.println(u);
		ac.close();
	}

}

测试运行下

信息: Loading XML bean definitions from class path resource [com/anthony/create/applicationContext.xml]
User类的空参构造调用！！！
我是初始化方法
com.anthony.bean.User@1786dec2
六月 08, 2019 11:08:12 下午 org.springframework.context.support.ClassPathXmlApplicationContext doClose
信息: Closing org.springframework.context.support.ClassPathXmlApplicationContext@2280cdac: startup date [Sat Jun 08 23:08:11 CST 2019]; root of context hierarchy
我是销毁方法

2.Spring属性注入

2.1 set方法注入（掌握）

我们这里来演示在xml配置文件中注入name和age属性的值。

根据前面代码基础，准备上面一个新的包，拷贝一个测试和一个配置文件过去，为了待会能打印name和age的值，我们这里修改下User.java这个类下，添加toString方法

        @Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + "]";
	}

这个时候injection包下的配置文件这样写

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	   xmlns="http://www.springframework.org/schema/beans" 
	   xsi:schemaLocation="http://www.springframework.org/schema/beans 
	   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- set方法注入 -->
	<bean name="user" class="com.anthony.bean.User" >
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<property name="name" value="tom" ></property>
		<property name="age" value="18" ></property>
	</bean>
	
</beans>

注入地方就是property这两组标签内，分别注入tom和18岁。

测试Demo1.java代码如下

package com.anthony.injection;

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

import com.anthony.bean.User;

public class Demo1 {

	@Test
	public void fun1() {
		//1 创建容器对象
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/anthony/injection/applicationContext.xml");
		//2 向容器 要 user对象
		User u = (User) ac.getBean("user");
		//3 打印user对象
		System.out.println(u);
	}

}

运行结果如下

User类的空参构造调用！！！
User [age=18, name=tom]

打印结果来看，这个上面配置文件是采用set方法进行注入的，因为在User类中我们没有写带这两个参数的构造方法。

在来一个对象注入，例如User.class下有一个属性是car，这里先来一个Car的Bean类。

package com.anthony.bean;

public class Car {
	
	private String name;
	private String color;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	@Override
	public String toString() {
		return "Car [name=" + name + ", color=" + color + "]";
	}
	
}

然后User.java类修改如下

package com.anthony.bean;

public class User {
	
	public User() {
		System.out.println("User类的空参构造调用！！！");
	}
	
	private int age;
	private String name;
	private Car car;
	
	public Car getCar() {
		return car;
	}
	public void setCar(Car car) {
		this.car = car;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public void init() {
		System.out.println("我是初始化方法");
	}
	
	public void destory() {
		System.out.println("我是销毁方法");
	}
	@Override
	public String toString() {
		return "User [age=" + age + ", name=" + name + ", car=" + car + "]";
	}
	
}

回到配置文件，改成这样

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	   xmlns="http://www.springframework.org/schema/beans" 
	   xsi:schemaLocation="http://www.springframework.org/schema/beans 
	   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- set方法注入 -->
	<bean name="user" class="com.anthony.bean.User" >
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<property name="name" value="tom" ></property>
		<property name="age" value="18" ></property>
		<property name="car" ref="car" ></property>
	</bean>
	
	<!-- 先把Car对象配置到容器中 -->
	<bean name="car" class="com.anthony.bean.Car">
		<property name="name" value="兰博基尼" ></property>
		<property name="color" value="黄色" ></property>
	</bean>
</beans>

注意，上面先把car作为bean对象添加到Spring容器中，然后在user对象下，name为car的属性，ref是英文单词reference，引用的意思，根据car去找bean对象中name为car的对象，这种方式叫做引用类型注入。

demo1.java的代码不变，测试一下

User类的空参构造调用！！！
User [age=18, name=tom, car=Car [name=兰博基尼, color=黄色]]

2.2 构造方法注入（掌握）

要走构造方式，我们在User类中得先有带参数的构造方法。在User.java中添加这个构造方法。

        public User(int age, String name, Car car) {
                System.out.println("构造方法注入调用！");
		this.age = age;
		this.name = name;
		this.car = car;
	}

配置文件，写成这样

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	   xmlns="http://www.springframework.org/schema/beans" 
	   xsi:schemaLocation="http://www.springframework.org/schema/beans 
	   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 构造方法注入 -->
	<bean name="user" class="com.anthony.bean.User" >
		<!-- 为User对象中名为name的属性注入tom作为值 -->
		<constructor-arg name="name" value="Anthony"></constructor-arg>
		<constructor-arg name="age" value="23"></constructor-arg>
		<constructor-arg name="car" ref="car"></constructor-arg>
	</bean>
	
	<!-- 先把Car对象配置到容器中 -->
	<bean name="car" class="com.anthony.bean.Car">
		<property name="name" value="兰博基尼" ></property>
		<property name="color" value="黄色" ></property>
	</bean>
</beans>

再次运行Demo1.java这个单元测试用例

构造方法注入调用！
User [age=23, name=Anthony, car=Car [name=兰博基尼, color=黄色]]

这个输出，说明没有走set方法的默认构造方法，而是走的带参数的构造方法的注入。

2.3 p名称空间注入（了解）

在使用p名称空间之前，我们需要xml中写好导入格式，完整的xml配置文件如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	   xmlns="http://www.springframework.org/schema/beans"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans 
	   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- p名称空间注入 -->
	<bean name="user" class="com.anthony.bean.User" p:name="jack" p:age="19" p:car-ref="car">
	</bean>
	
	<!-- 先把Car对象配置到容器中 -->
	<bean name="car" class="com.anthony.bean.Car">
		<property name="name" value="兰博基尼" ></property>
		<property name="color" value="黄色" ></property>
	</bean>
</beans>

再次运行demo1.java，

User类的空参构造调用！！！
User [age=19, name=jack, car=Car [name=兰博基尼, color=黄色]]

可以看出来，p名称空间注入，走的set方法。

2.4 spel注入（了解）

spel的全称是Spring Expression Language，spring表达式语言。采用spel的配置文件写法举例如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	   xmlns="http://www.springframework.org/schema/beans"
	   xmlns:p="http://www.springframework.org/schema/p"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans 
	   http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- p名称空间注入 -->
	<bean name="user" class="com.anthony.bean.User" p:name="jack" p:age="19" p:car-ref="car">
	</bean>
	
	<!-- 先把Car对象配置到容器中 -->
	<bean name="car" class="com.anthony.bean.Car">
		<property name="name" value="兰博基尼" ></property>
		<property name="color" value="黄色" ></property>
	</bean>
	
	<!-- spel注入 -->
	<bean name="user1" class="com.anthony.bean.User">
	    <!-- user.name表示用上面user中获取的name的value来当做user1对象中name的值 -->
		<property name="name" value="#{user.name}"></property>
		<property name="age" value="#{user.age}"></property>
		<property name="car" value="#{user.car}"></property>
	</bean>
</beans>

其实这里我们看到#{user.name}，和前面学习JSP中的EL表达式一样，EL表达式写法是${}

在demo1.java中，把获取user1这个对象

package com.anthony.injection;

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

import com.anthony.bean.User;

public class Demo1 {

	@Test
	public void fun1() {
		//1 创建容器对象
		ApplicationContext ac = new ClassPathXmlApplicationContext("com/anthony/injection/applicationContext.xml");
		//2 向容器 要 user对象
		User u = (User) ac.getBean("user1");
		//3 打印user对象
		System.out.println(u);
	}

}

运行结果

User类的空参构造调用！！！
User类的空参构造调用！！！
User [age=19, name=jack, car=Car [name=兰博基尼, color=黄色]]

总结：由于p名称空间和spel这两种注入方式是后来spring新加的功能，程序员们早已习惯set注入和构造函数注入，使用后两种注入的人很少使用。