Spring IOC 容器 Bean 对象实例化模拟
思路:
- 定义 Bean ⼯⼚接⼝，提供获取 bean ⽅法
- 定义 Bean ⼯⼚接⼝实现类，解析配置⽂件，实例化Bean对象
- 实现获取 Bean ⽅法
定义 Bean 属性对象
package com.xxxx.spring;
/**
* bean对象
* ⽤来接收配置⽂件中bean标签的id与class属性值
*/
public class MyBean {
private String id; // bean对象的id属性值
private String clazz; // bean对象的类路径
public MyBean() {
}
public MyBean(String id, String clazz) {
this.id = id;
this.clazz = clazz;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getClazz() {
return clazz;
}
public void setClazz(String clazz) {
this.clazz = clazz;
}
}
添加 dom4j 坐标依赖
<!-- dom4j -->
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<!-- XPath -->
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency>
准备⾃定义配置⽂件
spring.xml
<?xml version="1.0" encoding="utf-8" ?>
<beans>
<bean id="userService" class="com.xxxx.service.UserService"></bean>
<bean id="accountService" class="com.xxxx.service.AccountService"></bean>
</beans>
定义 Bean ⼯⼚接⼝
package com.xxxx.spring;
/**
* Bean ⼯⼚接⼝定义
*/
public interface MyFactory {
// 通过id值获取对象
public Object getBean(String id);
}
定义 Bean 接⼝的实现类
package com.xxxx.spring;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.XPath;
import org.dom4j.io.SAXReader;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 模拟Spring的实现
* 1、通过构造器得到相关配置⽂件
* 2、通过dom4j解析xml⽂件，得到List 存放id和class
* 3、通过反射实例化得到对象 Class.forName(类的全路径).newInstance(); 通过Map<id,Class>存 储
* 4、得到指定的实例化对象
*/
public class MyClassPathXmlApplicationContext implements BeanFactory {
private Map beans = new HashMap(); // 实例化后的对象放⼊map
private List<MyBean> myBeans; // 存放已读取bean 配置信息
/* 1、通过构造器得到相关配置⽂件 */
public MyClassPathXmlApplicationContext(String fileName) {
/* 2、通过dom4j解析xml⽂件，得到List （存放id和class） */
this.parseXml(fileName);
/* 3、通过反射实例化得到对象Class.forName(类路径).newInstance(); 通过Map存储 */
this.instanceBean();
}
/**
* 通过dom4j解析xml⽂件，得到List 存放id和class
* 1、获取解析器
* 2、得到配置⽂件的URL
* 3、通过解析器解析xml⽂件（spring.xml）
* 4、通过xpath语法，获取beans标签下的所有bean标签
* 5、通过指定语法解析⽂档对象，返回集合
* 6、判断集合是否为空，遍历集合
* 7、获取标签元素中的属性
* 8、得到Bean对象，将Bean对象设置到集合中
* @param fileName
*/
private void parseXml(String fileName) {
// 1、获取解析器
SAXReader reader = new SAXReader();
// 2、得到配置⽂件的URL
URL url = this.getClass().getClassLoader().getResource(fileName);
try {
// 3、通过解析器解析xml⽂件（spring.xml）
Document document = reader.read(url);
// 4、通过xpath语法，获取beans标签下的所有bean标签
XPath xPath = document.createXPath("beans/bean");
// 通过指定语法解析⽂档对象，返回集合
List<Element> list = xPath.selectNodes(document);
// 判断集合是否为空，遍历集合
if (list != null && list.size() > 0) {
myBeans = new ArrayList<>();
for(Element el : list) {
// 获取标签元素中的属性
String id = el.attributeValue("id"); // id 属性值
String clazz = el.attributeValue("class"); // class 属性值
System.out.println(el.attributeValue("id"));
System.out.println(el.attributeValue("class"));
// 得到Bean对象
MyBean bean = new MyBean(id, clazz);
// 将Bean对象设置到集合中
myBeans.add(bean);
}
}
} catch (DocumentException e) {
e.printStackTrace();
}
}
/**
* 通过反射实例化得到对象
* Class.forName(类的全路径).newInstance();
* 通过Map<id,Class>存储
*/
private void instanceBean() {
// 判断bean集合是否为空，不为空遍历得到对应Bean对象
if (myBeans != null && myBeans.size() > 0) {
for (MyBean bean : myBeans){
try {
// 通过类的全路径实例化对象
Object object = Class.forName(bean.getClazz()).newInstance();
// 将id与实例化对象设置到map对象中
beans.put(bean.getId(), object);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
/**
* 通过key获取map中的指定value
* @param id
* @return
*/
@Override
public Object getBean(String id) {
Object object = beans.get(id);
return object;
}
}
测试⾃定义 IOC 容器
- 创建与配置⽂件中对应的Bean对象
UserService.java
package com.xxxx.service;
public class UserService {
public void test(){
System.out.println("UserService Test...");
}
}
AccountService.java
package com.xxxx.service;
public class AccountService {
public void test(){
System.out.println("AccountService Test...");
}
}
- 测试是否可以获取实例化的Bean对象
package com.xxxx;
import com.xxxx.spring.MyFactory;
import com.xxxx.spring.MyClassPathXmlApplicationContext;
import com.xxxx.service.AccountService;
import com.xxxx.service.UserService;
public class App {
public static void main(String[] args) {
MyFactory factory = new MyClassPathXmlApplicationContext("spring.xml");
// 得到实例化对象
UserService userService = (UserService) factory.getBean("userService");
userService.test();
UserService userService2 = (UserService) factory.getBean("userService");
System.out.println(userService+"=====" + userService2);
AccountService accountService =
(AccountService)factory.getBean("accountService");
accountService.test();
}
}
Spring 容器在启动的时候 读取xml配置信息，并对配置的 bean 进⾏实例化（这⾥模拟的⽐较简单，仅⽤于帮助⼤家理解），同时通过上下⽂对象提供的 getBean() ⽅法拿到我们配置的 bean 对象，从⽽实现外部容器⾃动化维护并创建 bean 的效果。
Spring IOC 配置⽂件加载
Spring 配置⽂件加载
spring.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="userService" class="com.xxxx.service.UserService"></bean>
</beans>
根据相对路径加载资源
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
根据绝对路径加载资源（了解）
ApplicationContext ac = new
FileSystemXmlApplicationContext("C:/IdeaWorkspace/spring01/src/main/resources/spring.x
ml");
Spring 多配置⽂件加载
Spring 框架启动时可以加载多个配置⽂件到环境中。对于⽐较复杂的项⽬，可能对应的配置⽂件有多个，项⽬在启动部署时会将多个配置⽂件同时加载进来。
service.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="userService" class="com.xxxx.service.UserService"></bean>
</beans>
dao.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="userDao" class="com.xxxx.dao.UserDao"></bean>
</beans>
可变参数，传⼊多个⽂件名
// 同时加载多个资源⽂件
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml","dao.xml");
通过总的配置⽂件import其他配置⽂件
spring.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">
<!--导⼊需要包含的资源⽂件-->
<import resource="service.xml"/>
<import resource="dao.xml"/>
</beans>
加载时只需加载总的配置⽂件即可
// 加载总的资源⽂件
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
Spring IOC 容器 Bean 对象实例化
构造器实例化
注：通过默认构造器创建 空构造⽅法必须存在 否则创建失败
- 设置配置⽂件 spring.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="userService" class="com.xxxx.service.UserService"></bean>
</beans>
- 获取实例化对象
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService) ac.getBean("userService");
userService.test();
静态⼯⼚实例化
注：
要有该⼯⼚类及⼯⼚⽅法
⼯⼚⽅法为静态的
- 定义静态⼯⼚类
package com.xxxx.factory;
import com.xxxx.service.UserService;
/**
* 定义静态⼯⼚类
*/
public class StaticFactory {
/**
* 定义对应的静态⽅法，返回实例化对象
* @return
*/
public static UserService createUserService() {
return new UserService();
}
}
- 设置配置⽂件 spring.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="userService" class="com.xxxx.factory.StaticFactory" factorymethod="createUserService"></bean>
</beans>
- 获取实例化对象.
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService) ac.getBean("userService");
userService.test();
当我们指定Spring使⽤静态⼯⼚⽅法来创建Bean实例时，Spring将先解析配置⽂件，并根据配置
⽂件指定的信息，通过反射调⽤静态⼯⼚类的静态⼯⼚⽅法，并将该静态⼯⼚⽅法的返回值作为
Bean实例，在这个过程中，Spring不再负责创建Bean实例，Bean实例是由⽤户提供的静态⼯⼚⽅
法提供的。
实例化⼯⼚实例化
注：
⼯⼚⽅法为⾮静态⽅法
需要配置⼯⼚bean，并在业务bean中配置factory-bean，factory-method属性
- 定义⼯⼚类
package com.xxxx.factory;
import com.xxxx.service.UserService;
/**
* 定义⼯⼚类
*/
public class InstanceFactory {
/**
* 定义⽅法，返回实例化对象
* @return
*/
public UserService createUserService() {
return new UserService();
}
}
- 设置配置⽂件 spring.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">
<!--
实例化⼯⼚
1.定义实例化⼯⼚bean
2.引⽤⼯⼚bean 指定⼯⼚创建⽅法(⽅法为⾮静态)
-->
<bean id="instanceFactory" class="com.xxxx.factory.InstanceFactory"></bean>
<bean id="userService" factory-bean="instanceFactory" factorymethod="createUserService"></bean>
</beans>
- 获取实例化对象
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
UserService userService = (UserService) ac.getBean("userService");
userService.test();
Spring三种实例化Bean的⽅式⽐较
⽅式⼀：通过bean的缺省构造函数创建，当各个bean的业务逻辑相互⽐较独⽴的时候或者和外界
关联较少的时候可以使⽤。
⽅式⼆：利⽤静态factory⽅法创建，可以统⼀管理各个bean的创建，如各个bean在创建之前需要
相同的初始化处理，则可⽤这个factory⽅法险进⾏统⼀的处理等等。
⽅式三：利⽤实例化factory⽅法创建，即将factory⽅法也作为了业务bean来控制，1可⽤于集成其
他框架的bean创建管理⽅法，2能够使bean和factory的⻆⾊互换。
开发中项⽬⼀般使⽤⼀种⽅式实例化bean，项⽬开发基本采⽤第⼀种⽅式，交给Spring托管，使⽤时
直接拿来使⽤即可。
扫一扫
689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
