一、自定义SpringIOC
1.1、案例
现要对下面的配置文件进行解析,并自定义Spring框架的IOC对涉及到的对象进行管理。
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userService" class="com.test.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
<bean id="userDao" class="com.test.dao.impl.UserDaoImpl"></bean>
</beans>
1.2、定义bean相关的pojo类
1.2.1、PropertyValue类
用于封装bean的属性,体现到上面的配置文件就是封装bean标签的子标签property标签数据。
/**
* @version v1.0
* @ClassName: PropertyValue
* @Description: 用来封装bean标签下的property标签的属性
* name属性
* ref属性
* value属性 : 给基本数据类型及String类型数据赋的值
*/
public class PropertyValue {
private String name;
private String ref;
private String value;
public PropertyValue() {
}
public PropertyValue(String name, String ref, String value) {
this.name = name;
this.ref = ref;
this.value = value;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getRef() {
return ref;
}
public void setRef(String ref) {
this.ref = ref;
}
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
}
1.2.2、MutablePropertyValues类
一个bean标签可以有多个property子标签,所以再定义一个MutablePropertyValues类,用来存储并管理多个PropertyValue对象。
/**
* @version v1.0
* @ClassName: MutablePropertyValues
* @Description: 用户存储和管理多个PropertyValue对象
*/
public class MutablePropertyValues implements Iterable<PropertyValue> {
//定义list集合对象,用来存储PropertyValue对象
private final List<PropertyValue> propertyValueList;
public MutablePropertyValues() {
this.propertyValueList = new ArrayList<PropertyValue>();
}
public MutablePropertyValues(List<PropertyValue> propertyValueList) {
if(propertyValueList == null) {
this.propertyValueList = new ArrayList<PropertyValue>();
} else {
this.propertyValueList = propertyValueList;
}
}
//获取所有的PropertyValue对象,返回以数组的形式
public PropertyValue[] getPropertyValues() {
//将集合转换为数组并返回
return propertyValueList.toArray(new PropertyValue[0]);
}
//根据name属性值获取PropertyValue对象
public PropertyValue getPropertyValue(String propertyName) {
//遍历集合对象
for (PropertyValue propertyValue : propertyValueList) {
if (propertyValue.getName().equals(propertyName)) {
return propertyValue;
}
}
return null;
}
//判断集合是否为空
public boolean isEmpty() {
return propertyValueList.isEmpty();
}
//添加PropertyValue对象
public MutablePropertyValues addPropertyValue(PropertyValue pv) {
//判断集合中存储的PropertyValue对象是否和传递进行的重复了,如果重复了,进行覆盖
for (int i = 0; i < propertyValueList.size(); i++) {
//获取集合中每一个PropertyValue对象
PropertyValue currentPv = propertyValueList.get(i);
if(currentPv.getName().equals(pv.getName())) {
propertyValueList.set(i,pv);
return this; //目的就是实现链式编程
}
}
this.propertyValueList.add(pv);
return this;//目的就是实现链式编程
}
//判断是否有指定name属性值的对象
public boolean contains(String propertyName) {
return getPropertyValue(propertyName) != null;
}
//获取迭代器对象
public Iterator<PropertyValue> iterator() {
return propertyValueList.iterator();
}
}
1.2.3、BeanDefinition类
BeanDefinition类用来封装bean信息的,主要包含id(即bean对象的名称)、class(需要交由spring管理的类的全类名)及子标签property数据。
/**
* @version v1.0
* @ClassName: BeanDefinition
* @Description: 用来封装bean标签数据
* id属性
* class属性
* property子标签的数据
*/
public class BeanDefinition {
private String id;
private String className;
private MutablePropertyValues propertyValues;
public BeanDefinition() {
propertyValues = new MutablePropertyValues();
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getClassName() {
return className;
}
public void setClassName(String className) {
this.className = className;
}
public MutablePropertyValues getPropertyValues() {
return propertyValues;
}
public void setPropertyValues(MutablePropertyValues propertyValues) {
this.propertyValues = propertyValues;
}
}
1.3、定义注册表相关类
1.3.1、BeanDefinitionRegistry接口
BeanDefinitionRegistry接口定义了注册表的相关操作,定义如下功能:
-
注册BeanDefinition对象到注册表中
-
从注册表中删除指定名称的BeanDefinition对象
-
根据名称从注册表中获取BeanDefinition对象
-
判断注册表中是否包含指定名称的BeanDefinition对象
-
获取注册表中BeanDefinition对象的个数
-
获取注册表中所有的BeanDefinition的名称
/**
* @version v1.0
* @ClassName: BeanDefinitionRegistry
* @Description: 注册表对象
*/
public interface BeanDefinitionRegistry {
//注册BeanDefinition对象到注册表中
void registerBeanDefinition(String beanName, BeanDefinition beanDefinition);
//从注册表中删除指定名称的BeanDefinition对象
void removeBeanDefinition(String beanName) throws Exception;
//根据名称从注册表中获取BeanDefinition对象
BeanDefinition getBeanDefinition(String beanName) throws Exception;
boolean containsBeanDefinition(String beanName);
int getBeanDefinitionCount();
String[] getBeanDefinitionNames();
}
1.3.2、SimpleBeanDefinitionRegistry类
该类实现了BeanDefinitionRegistry接口,定义了Map集合作为注册表容器。
/**
* @version v1.0
* @ClassName: SimpleBeanDefinitionRegistry
* @Description: 注册表接口的子实现类
*/
public class SimpleBeanDefinitionRegistry implements BeanDefinitionRegistry {
//定义一个容器,用来存储BeanDefinition对象
private Map<String,BeanDefinition> beanDefinitionMap = new HashMap<String, BeanDefinition>();
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) {
beanDefinitionMap.put(beanName,beanDefinition);
}
public void removeBeanDefinition(String beanName) throws Exception {
beanDefinitionMap.remove(beanName);
}
public BeanDefinition getBeanDefinition(String beanName) throws Exception {
return beanDefinitionMap.get(beanName);
}
public boolean containsBeanDefinition(String beanName) {
return beanDefinitionMap.containsKey(beanName);
}
public int getBeanDefinitionCount() {
return beanDefinitionMap.size();
}
public String[] getBeanDefinitionNames() {
return beanDefinitionMap.keySet().toArray(new String[0]);
}
}
1.4、定义解析器相关类
1.4.1、BeanDefinitionReader接口
BeanDefinitionReader是用来解析配置文件并在注册表中注册bean的信息。定义了两个规范:
-
获取注册表的功能,让外界可以通过该对象获取注册表对象。
-
加载配置文件,并注册bean数据。
/**
* @version v1.0
* @ClassName: BeanDefinitionReader
* @Description:
* 用来解析配置文件的,而该接口只是定义了规范
*/
public interface BeanDefinitionReader {
//获取注册表对象
BeanDefinitionRegistry getRegistry();
//加载配置文件并在注册表中进行注册
void loadBeanDefinitions(String configLocation) throws Exception;
}
1.4.2、XmlBeanDefinitionReader类
XmlBeanDefinitionReader类是专门用来解析xml配置文件的。该类实现BeanDefinitionReader接口并实现接口中的两个功能。
/**
* @version v1.0
* @ClassName: XmlBeanDefinitionReader
* @Description: 针对xml配置文件进行解析的类
*/
public class XmlBeanDefinitionReader implements BeanDefinitionReader {
//声明注册表对象
private BeanDefinitionRegistry registry;
public XmlBeanDefinitionReader() {
registry = new SimpleBeanDefinitionRegistry();
}
public BeanDefinitionRegistry getRegistry() {
return registry;
}
public void loadBeanDefinitions(String configLocation) throws Exception {
//使用dom4j进行xml配置文件的解析
SAXReader reader = new SAXReader();
//获取类路径下的配置文件
InputStream is = XmlBeanDefinitionReader.class.getClassLoader().getResourceAsStream(configLocation);
Document document = reader.read(is);
//根据Document对象获取根标签对象 (beans)
Element rootElement = document.getRootElement();
//获取根标签下所有的bean标签对象
List<Element> beanElements = rootElement.elements("bean");
//遍历集合
for (Element beanElement : beanElements) {
//获取id属性
String id = beanElement.attributeValue("id");
//获取class属性
String className = beanElement.attributeValue("class");
//将id属性和class属性封装到BeanDefinition对象中
//1,创建BeanDefinition
BeanDefinition beanDefinition = new BeanDefinition();
beanDefinition.setId(id);
beanDefinition.setClassName(className);
//创建MutablePropertyValues对象
MutablePropertyValues mutablePropertyValues = new MutablePropertyValues();
//获取bean标签下所有的property标签对象
List<Element> propertyElements = beanElement.elements("property");
for (Element propertyElement : propertyElements) {
String name = propertyElement.attributeValue("name");
String ref = propertyElement.attributeValue("ref");
String value = propertyElement.attributeValue("value");
PropertyValue propertyValue = new PropertyValue(name,ref,value);
mutablePropertyValues.addPropertyValue(propertyValue);
}
//将mutablePropertyValues对象封装到BeanDefinition对象中
beanDefinition.setPropertyValues(mutablePropertyValues);
//将beanDefinition对象注册到注册表中
registry.registerBeanDefinition(id,beanDefinition);
}
}
}
1.5、IOC容器相关类
1.5.1、BeanFactory接口
在该接口中定义IOC容器的统一规范即获取bean对象。
/**
* @version v1.0
* @ClassName: BeanFactory
* @Description: IOC容器父接口
*/
public interface BeanFactory {
Object getBean(String name) throws Exception;
<T> T getBean(String name, Class<? extends T> clazz) throws Exception;
}
1.5.2、ApplicationContext接口
该接口的所以的子实现类对bean对象的创建都是非延时的,所以在该接口中定义 refresh() 方法,该方法主要完成以下两个功能:
-
加载配置文件。
-
根据注册表中的BeanDefinition对象封装的数据进行bean对象的创建。
/**
* @version v1.0
* @ClassName: ApplicationContext
* @Description: 定义非延时加载功能
*/
public interface ApplicationContext extends BeanFactory {
void refresh() throws Exception;
}
1.5.3、AbstractApplicationContext类
-
作为ApplicationContext接口的子类,所以该类也是非延时加载,所以需要在该类中定义一个Map集合,作为bean对象存储的容器。
-
声明BeanDefinitionReader类型的变量,用来进行xml配置文件的解析,符合单一职责原则。BeanDefinitionReader类型的对象创建交由子类实现,因为只有子类明确到底创建BeanDefinitionReader哪儿个子实现类对象。
/**
* @version v1.0
* @ClassName: AbstractApplicationContext
* @Description: ApplicationContext接口的子实现类,用于立即加载
*/
public abstract class AbstractApplicationContext implements ApplicationContext {
//声明解析器变量
protected BeanDefinitionReader beanDefinitionReader;
//定义用于存储bean对象的map容器
protected Map<String, Object> singletonObjects = new HashMap<String, Object>();
//声明配置文件路径的变量
protected String configLocation;
public void refresh() throws Exception {
//加载BeanDefinition对象
beanDefinitionReader.loadBeanDefinitions(configLocation);
//初始化bean
finishBeanInitialization();
}
//bean的初始化
private void finishBeanInitialization() throws Exception {
//获取注册表对象
BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
//获取BeanDefinition对象
String[] beanNames = registry.getBeanDefinitionNames();
for (String beanName : beanNames) {
//进行bean的初始化
getBean(beanName);
}
}
}
1.5.4、ClassPathXmlApplicationContext类
该类主要是加载类路径下的配置文件,并进行bean对象的创建,主要完成以下功能:
-
在构造方法中,创建BeanDefinitionReader对象。
-
在构造方法中,调用refresh()方法,用于进行配置文件加载、创建bean对象并存储到容器中。
-
重写父接口中的getBean()方法,并实现依赖注入操作。
/**
* @version v1.0
* @ClassName: ClassPathXmlApplicationContext
* @Description: IOC容器具体的子实现类
* 用于加载类路径下的xml格式的配置文件
*/
public class ClassPathXmlApplicationContext extends AbstractApplicationContext {
public ClassPathXmlApplicationContext(String configLocation) {
this.configLocation = configLocation;
//构建解析器对象
beanDefinitionReader = new XmlBeanDefinitionReader();
try{
this.refresh();
} catch (Exception e) {
}
}
//根据bean对象的名称获取bean对象
public Object getBean(String name) throws Exception {
//判断对象容器中是否包含指定名称的bean对象,如果包含,直接返回即可,如果不包含,需要自行创建
Object obj = singletonObjects.get(name);
if (obj != null) {
return obj;
}
//获取BeanDefinition对象
BeanDefinitionRegistry registry = beanDefinitionReader.getRegistry();
BeanDefinition beanDefinition = registry.getBeanDefinition(name);
//获取bean信息中的className
String className = beanDefinition.getClassName();
//通过反射创建对象
Class<?> clazz = Class.forName(className);
Object beanObj = clazz.newInstance();
//进行依赖注入操作
MutablePropertyValues propertyValues = beanDefinition.getPropertyValues();
for (PropertyValue propertyValue : propertyValues) {
//获取name属性值
String propertyName = propertyValue.getName();
//获取value属性
String value = propertyValue.getValue();
//获取ref属性
String ref = propertyValue.getRef();
if(ref != null && !"".equals(ref)) {
//获取依赖的bean对象
Object bean = getBean(ref);
//拼接方法名
String methodName = StringUtils.getSetterMethodByFieldName(propertyName);
//获取所有的方法对象
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if (methodName.equals(method.getName())) {
//执行该setter方法
method.invoke(beanObj,bean);
}
}
}
if(value != null && !"".equals(value)) {
//拼接方法名
String methodName = StringUtils.getSetterMethodByFieldName(propertyName);
//获取method对象
Method method = clazz.getMethod(methodName, String.class);
method.invoke(beanObj,value);
}
}
//在返回beanObj对象之前,将该对象存储到map容器中
singletonObjects.put(name,beanObj);
return beanObj;
}
public <T> T getBean(String name, Class<? extends T> clazz) throws Exception {
Object bean = getBean(name);
if(bean == null) {
return null;
}
return clazz.cast(bean);
}
}
1.6、自定义Spring IOC总结
1.6.1、使用到的设计模式
-
工厂模式。这个使用工厂模式 + 配置文件的方式。
-
单例模式。Spring IOC管理的bean对象都是单例的,此处的单例不是通过构造器进行单例的控制的,而是spring框架对每一个bean只创建了一个对象。
-
模板方法模式。AbstractApplicationContext类中的finishBeanInitialization()方法调用了子类的getBean()方法,因为getBean()的实现和环境息息相关。
-
迭代器模式。对于MutablePropertyValues类定义使用到了迭代器模式,因为此类存储并管理PropertyValue对象,也属于一个容器,所以给该容器提供一个遍历方式。
spring框架其实使用到了很多设计模式,如AOP使用到了代理模式,选择JDK代理或者CGLIB代理使用到了策略模式,还有适配器模式,装饰者模式,观察者模式等。
1.7、测试
1.7.1、对上面代码进行打包,放入本地仓库,引入依赖
<dependency>
<groupId>com.test</groupId>
<artifactId>test_spring</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
1.7.2、数据访问层。定义UserDao接口及其子实现类
/**
* @version v1.0
* @ClassName: UserDao
* @Description: 数据访问层接口
*/
public interface UserDao {
public void add();
}
/**
* @version v1.0
* @ClassName: UserDaoImpl
* @Description: 数据访问层实现类
*/
public class UserDaoImpl implements UserDao {
private String username;
private String password;
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
public UserDaoImpl() {
System.out.println("userDao被创建了");
}
public void add() {
System.out.println("UserDao ..." + username + "==" + password);
}
}
1.7.3、业务逻辑层。定义UserService接口及其子实现类
/**
* @version v1.0
* @ClassName: UserService
* @Description: 业务逻辑层接口
*/
public interface UserService {
public void add();
}
/**
* @version v1.0
* @ClassName: UserServiceImpl
* @Description: 业务逻辑层实现类
*/
public class UserServiceImpl implements UserService {
//声明一个UserDao类型的变量
private UserDao userDao;
public UserServiceImpl() {
System.out.println("userService被创建了");
}
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void add() {
System.out.println("UserService ...");
userDao.add();
}
}
1.7.4、定义UserController类,使用main方法模拟controller层
/**
* @version v1.0
* @ClassName: UserController
* @Description: 入口
*/
public class UserController {
public static void main(String[] args) throws Exception {
//1,创建spring的容器对象
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
//2,从容器对象中获取userService对象
UserService userService = applicationContext.getBean("userService", UserService.class);
//3,调用userService方法进行业务逻辑处理
userService.add();
}
}
1.7.5、编写配置文件。在类路径下编写一个名为ApplicationContext.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="userDao" class="com.test.dao.impl.UserDaoImpl">
<property name="username" value="zhangsan"></property>
<property name="password" value="123456"></property>
</bean>
<bean id="userService" class="com.test.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"></property>
</bean>
</beans>