做一个网站分析应该怎么做,主机托管业务,成都那家网站制作公司好,做网站和推广需要多少钱文章目录 一、目标#xff1a;初始化和销毁方法二、设计#xff1a;初始化和销毁方法三、实现#xff1a;初始化和销毁方法3.1 工程结构3.2 Spring应用上下文和Bean对象扩展初始化和销毁类图3.3 定义初始化和销毁方法的接口3.3.1 定义初始化接口3.3.2 定义销毁接口3.3.3 定义… 文章目录 一、目标初始化和销毁方法二、设计初始化和销毁方法三、实现初始化和销毁方法3.1 工程结构3.2 Spring应用上下文和Bean对象扩展初始化和销毁类图3.3 定义初始化和销毁方法的接口3.3.1 定义初始化接口3.3.2 定义销毁接口3.3.3 定义销毁方法适配器(接口和配置) 3.4 Bean属性定义新增初始化和销毁3.4.1 Bean对象3.4.2 XML处理Bean注册3.4.3 配置Bean工厂接口3.4.4 通用的注册表实现3.4.5 实现默认Bean创建的抽象Bean工厂超类 3.5 虚拟机关闭钩子时注册调用销毁方法3.5.1 配置应用上下文接口3.5.2 应用上下文抽象类 四、测试初始化和销毁方法4.1 配置测试环境4.1.1 修改UserDao用户对象4.1.2 修改UserService用户对象4.1.3 修改配置文件 4.2 单元测试 五、总结初始化和销毁方法 一、目标初始化和销毁方法 如何在 Spring 初始化和销毁对象时对这些内容做一些操作呢 当我们的类创建的 Bean 对象交给 Spring 容器管理以后这个类对象就可以被赋予更多的使用。 如给类对象添加了修改注册 Bean 定义未实例化前的属性信息修改和初始化过程中的前置和后置处理。 除此之外我们还希望在 Bean 初始化过程执行一些操作。 如数据的加载执行链接注册中心暴露 RPC 接口在 Web 程序关闭时执行链接断开、内存销毁等。 需要满足用户可以在 xml 中配置初始化和销毁的方法也可以通过实现类的方式处理。 如使用 Spring 时用到的 InitializingBean、DisposableBean 两个接口。
二、设计初始化和销毁方法 技术设计spring.xml配置文件配置初始化和销毁方法 对于 这样在 Bean 容器初始化过程中额外添加的处理操作就是预先执行了一个定义好的接口或者是反射调用类中 xml 中配置的方法。最终只要按照接口定义实现就会有 Spring 容器在处理的过程中进行调用即可。 在 spring.xml 配置中添加 init-method、destroy-method 两个注解在配置文件加载的过程中把注解配置一并定义到 BeanDefinition 的属性当中。 这样在 initializeBean 初始化操作的工程中就可以通过发射的方式来调用配置在 Bean 定义属性当中的方法信息了。另外如果是接口实现的方式那么直接可以通过 Bean 对象调用对应接口定义的方法即可。((InitializingBean) bean).afterPropertiesSet()两种方式的效果是一样的。 除了在初始化的操作外destroy-method 和 DisposableBean 接口的定义都会在 Bean 对象初始化完成阶段执行注册销毁方法的信息到 DefaultSingletonBeanRegistry 类中的 disposableBeans 属性里这里为了后续统一操作。 适配器模式因为反射调用和接口直接调用是两种方式所以需要使用适配器进行包装。参考 DisposableBeanAdapter的具体实现销毁方法需要在虚拟机执行关闭之前进行操作所以这里需要用到一个注册钩子的操作。 如Runtime.getRuntime().addShutdownHook(new Thread(this::close)) 另外也可以手动调用 ApplicationContext.close() 方法关闭容器。
三、实现初始化和销毁方法
3.1 工程结构
spring-step-07
|-src|-main| |-java| |-com.lino.springframework| |-beans| | |-factory| | | |-config| | | | |-AutowireCapableBeanFactory.java| | | | |-BeanDefinition.java| | | | |-BeanFactoryPostProcessor.java| | | | |-BeanPostProcessor.java| | | | |-BeanReference.java| | | | |-ConfigurableBeanFactory.java| | | | |-SingletonBeanRegistry.java| | | |-support| | | | |-AbstractAutowireCapableBeanFactory.java| | | | |-AbstractBeabDefinitionReader.java| | | | |-AbstractBeabFactory.java| | | | |-BeabDefinitionReader.java| | | | |-BeanDefinitionRegistry.java| | | | |-CglibSubclassingInstantiationStrategy.java| | | | |-DefaultListableBeanFactory.java| | | | |-DefaultSingletonBeanRegistry.java| | | | |-DisposableBeanAdapter.java| | | | |-InstantiationStrategy.java| | | | |-SimpleInstantiationStrategy.java| | | |-support| | | | |-XMLBeanDefinitionReader.java| | | |-BeanFactory.java| | | |-ConfigurableListableBeanFactory.java| | | |-DisposableBean.java| | | |-HierarcgicalBeanFactory.java| | | |-InitializingBean.java| | | |-ListableBeanFactory.java| | |-BeansException.java| | |-PropertyValue.java| | |-PropertyValues.java| |-context| | |-support| | | |-AbstractApplicationContext.java| | | |-AbstractRefreshableApplicationContext.java| | | |-AbstractXmlApplicationContext.java| | | |-ClassPathXmlApplicationContext.java| | |-ApplicationContext.java| | |-ConfigurableApplicationContext.java| |-core.io| | |-ClassPathResource.java| | |-DefaultResourceLoader.java| | |-FileSystemResource.java| | |-Resource.java| | |-ResourceLoader.java| | |-UrlResource.java| |-util| | |-ClassUtils.java|-test|-java|-com.lino.springframework.test|-bean| |-UserDao.java| |-UserService.java|-ApiTest.java|-resources|-spring.xml3.2 Spring应用上下文和Bean对象扩展初始化和销毁类图 整个类图结构描述出来的是本次新增 Bean 实例化过程中的初始化方法和销毁方法。一共实现了两种方式的初始化和销毁方法xml 配置和定义接口。 定义接口InitializingBean、DisposableBean。xml 配置XmlBeanDefinitionReader 加载 spring.xml 配置信息到 BeanDefinition 中。 接口 ConfigurableBeanFactory 定义了 destroySingletons 方法。 把实现接口的操作又交给继承的父类处理是一种隔离分层服务的设计方式。 最后就是向虚拟机注册钩子保证在虚拟机关闭之前执行销毁操作。 Runtime.getRuntime().addShutdownHook(new Thread(this::close))
3.3 定义初始化和销毁方法的接口
InitializingBean、DisposableBean两个接口方法都是比较常用的在结合一些 Spring 实现的组件中经常会使用这两个方法来做一些参数的初始化和销毁操作。 如接口暴露、数据库数据读取、配置文件加载等。
3.3.1 定义初始化接口 InitializingBean.java package com.lino.springframework.beans.factory;/*** description: 实现此接口的 Bean 对象会在 BeanFactory 设置属性后做出相应的处理* 如执行自定义初始化或者仅仅检查是否设置了所有强制属性*/
public interface InitializingBean {/*** Bean 处理属性填充后调用** throws Exception 异常*/void afterPropertiesSet() throws Exception;
}3.3.2 定义销毁接口 DisposableBean.java package com.lino.springframework.beans.factory;/*** description: 销毁接口*/
public interface DisposableBean {/*** 销毁方法** throws Exception 异常*/void destroy() throws Exception;
}3.3.3 定义销毁方法适配器(接口和配置) DisposableBeanAdapter.java package com.lino.springframework.beans.factory.support;import cn.hutool.core.util.StrUtil;
import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.factory.DisposableBean;
import com.lino.springframework.beans.factory.config.BeanDefinition;
import java.lang.reflect.Method;/*** description: 销毁方法适配器*/
public class DisposableBeanAdapter implements DisposableBean {private final Object bean;private final String beanName;private String destroyMethodName;public DisposableBeanAdapter(Object bean, String beanName, BeanDefinition beanDefinition) {this.bean bean;this.beanName beanName;this.destroyMethodName beanDefinition.getDestroyMethodName();}Overridepublic void destroy() throws Exception {// 1.实现接口 DisposableBeanif (bean instanceof DisposableBean) {((DisposableBean) bean).destroy();}// 2.注解配置 destroy-method {判断是为了避免二次执行销毁}if (StrUtil.isNotEmpty(destroyMethodName) !(bean instanceof DisposableBean destory.equals(this.destroyMethodName))) {Method destroyMethod bean.getClass().getMethod(destroyMethodName);if (null destroyMethod) {throw new BeansException(Couldt find a destroy method named destroyMethodName on bean with name beanName );}destroyMethod.invoke(bean);}}
}这是一个适配器的类因为销毁方法有两种甚至多种方式。目前有 实现接口 DisposableBean、配置信息 spring.xml 两种方式。 而这两种方式的销毁动作是由 AbstractApplicationContext 在注册虚拟机钩子后虚拟机关闭前执行的操作动作。 那么在销毁执行时不太希望还得关注都销毁哪些类型的方法它的使用更希望是有一个统一的接口进行销毁所以这里添加了适配类做统一处理。
3.4 Bean属性定义新增初始化和销毁
3.4.1 Bean对象 BeanDefinition.java package com.lino.springframework.beans.factory.config;import com.lino.springframework.beans.PropertyValues;/*** description: Bean 对象信息定义*/
public class BeanDefinition {/*** bean对象*/private Class beanClass;private PropertyValues propertyValues;private String initMethodName;private String destroyMethodName;public BeanDefinition(Class beanClass) {this.beanClass beanClass;this.propertyValues new PropertyValues();}public BeanDefinition(Class beanClass, PropertyValues propertyValues) {this.beanClass beanClass;this.propertyValues propertyValues ! null ? propertyValues : new PropertyValues();}public Class getBeanClass() {return beanClass;}public void setBeanClass(Class beanClass) {this.beanClass beanClass;}public PropertyValues getPropertyValues() {return propertyValues;}public void setPropertyValues(PropertyValues propertyValues) {this.propertyValues propertyValues;}public String getInitMethodName() {return initMethodName;}public void setInitMethodName(String initMethodName) {this.initMethodName initMethodName;}public String getDestroyMethodName() {return destroyMethodName;}public void setDestroyMethodName(String destroyMethodName) {this.destroyMethodName destroyMethodName;}
}在 BeanDefinition 新增加了两个属性initMethodName、destroyMethodName。 这两个属性是为了在 spring.xml 配置的 Bean 对象中可以配置 init-methodinitDataMethod destroy-methoddestroyDataMethod 操作最终实现接口的效果是一样的。一个是接口方法的直接调用另外一个是在配置文件中读取到方法反射调用。
3.4.2 XML处理Bean注册 XMLBeanDefinitionReader.java package com.lino.springframework.beans.factory.xml;import cn.hutool.core.lang.copier.SrcToDestCopier;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.XmlUtil;
import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.PropertyValue;
import com.lino.springframework.beans.factory.config.BeanDefinition;
import com.lino.springframework.beans.factory.config.BeanReference;
import com.lino.springframework.beans.factory.support.AbstractBeanDefinitionReader;
import com.lino.springframework.beans.factory.support.BeanDefinitionRegistry;
import com.lino.springframework.core.io.Resource;
import com.lino.springframework.core.io.ResourceLoader;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import java.io.IOException;
import java.io.InputStream;/*** description: XML处理Bean注册*/
public class XMLBeanDefinitionReader extends AbstractBeanDefinitionReader {...protected void doLoadBeanDefinitions(InputStream inputStream) throws ClassNotFoundException {Document doc XmlUtil.readXML(inputStream);Element root doc.getDocumentElement();NodeList childNodes root.getChildNodes();for (int i 0; i childNodes.getLength(); i) {// 判断元素if (!(childNodes.item(i) instanceof Element)) {continue;}// 判断对象if (!bean.equals(childNodes.item(i).getNodeName())) {continue;}// 解析标签Element bean (Element) childNodes.item(i);String id bean.getAttribute(id);String name bean.getAttribute(name);String className bean.getAttribute(class);String initMethod bean.getAttribute(init-method);String destroyMethodName bean.getAttribute(destroy-method);// 获取 Class, 方便获取类中的名称Class? clazz Class.forName(className);// 优先级 id nameString beanName StrUtil.isNotEmpty(id) ? id : name;if (StrUtil.isEmpty(beanName)) {beanName StrUtil.lowerFirst(clazz.getSimpleName());}// 定义beanBeanDefinition beanDefinition new BeanDefinition(clazz);beanDefinition.setInitMethodName(initMethod);beanDefinition.setDestroyMethodName(destroyMethodName);// 读取属性并填充for (int j 0; j bean.getChildNodes().getLength(); j) {// 判断元素if (!(bean.getChildNodes().item(j) instanceof Element)) {continue;}// 判断对象if (!property.equals(bean.getChildNodes().item(j).getNodeName())) {continue;}// 解析标签propertyElement property (Element) bean.getChildNodes().item(j);String attrName property.getAttribute(name);String attrValue property.getAttribute(value);String attrRef property.getAttribute(ref);// 获取属性值引入对象、值对象Object value StrUtil.isNotEmpty(attrRef) ? new BeanReference(attrRef) : attrValue;// 创建属性信息PropertyValue propertyValue new PropertyValue(attrName, value);beanDefinition.getPropertyValues().addPropertyValue(propertyValue);}if (getRegistry().containsBeanDefinition(beanName)) {throw new BeansException(Duplicate beanName[ beanName ] is not allowed);}// 注册 BeanDefinitiongetRegistry().registerBeanDefinition(beanName, beanDefinition);}}
}Bean 属性定义增加初始化和销毁后还需要在 XMLBeanDefinitionReader 类中增加对新增属性的读取并添加到 BeanDefinition 中。
3.4.3 配置Bean工厂接口 ConfigurableBeanFactory.java package com.lino.springframework.beans.factory.config;import com.lino.springframework.beans.factory.HierarchicalBeanFactory;/*** description: 配置Bean工厂接口*/
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {String SCOPE_SINGLETON singleton;String SCOPE_PROTOTYPE prototype;/*** 添加修改新实例化 Bean 对象的扩展点** param beanPostProcessor 新实例化 Bean 对象*/void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);/*** 销毁单例*/void destroySingletons();
}新增加 destroySingletons() 销毁单例方法。
3.4.4 通用的注册表实现 DefaultSingletonBeanRegistry.java package com.lino.springframework.beans.factory.support;import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.factory.DisposableBean;
import com.lino.springframework.beans.factory.config.SingletonBeanRegistry;import java.util.HashMap;
import java.util.Map;
import java.util.Set;/*** description: 通用的注册表实现*/
public class DefaultSingletonBeanRegistry implements SingletonBeanRegistry {private MapString, Object singletonObjects new HashMap();private final MapString, DisposableBean disposableBeans new HashMap();Overridepublic Object getSingleton(String beanName) {return singletonObjects.get(beanName);}Overridepublic void registerSingletonBean(String beanName, Object singletonObject) {singletonObjects.put(beanName, singletonObject);}public void registerDisposableBean(String beanName, DisposableBean bean) {disposableBeans.put(beanName, bean);}public void destroySingletons() {SetString keySet this.disposableBeans.keySet();Object[] disposableBeanNames keySet.toArray();for (int i disposableBeanNames.length - 1; i 0; i--) {Object beanName disposableBeanNames[i];DisposableBean disposableBean disposableBeans.remove(beanName);try {disposableBean.destroy();} catch (Exception e) {throw new BeansException(Destroy method on bean with name beanName threw an exception, e);}}}
}新增加 MapString, DisposableBean disposableBeans 销毁方法 Map 属性并添加根据对象名称获取销毁对象的方法。 registerDisposableBean(String beanName, DisposableBean bean)。
3.4.5 实现默认Bean创建的抽象Bean工厂超类 AbstractAutowireCapableBeanFactory.java package com.lino.springframework.beans.factory.support;import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.PropertyValue;
import com.lino.springframework.beans.PropertyValues;
import com.lino.springframework.beans.factory.DisposableBean;
import com.lino.springframework.beans.factory.InitializingBean;
import com.lino.springframework.beans.factory.config.AutowireCapableBeanFactory;
import com.lino.springframework.beans.factory.config.BeanDefinition;
import com.lino.springframework.beans.factory.config.BeanPostProcessor;
import com.lino.springframework.beans.factory.config.BeanReference;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;/*** description: 实现默认bean创建的抽象bean工厂超类*/
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {private InstantiationStrategy instantiationStrategy new CglibSubclassingInstantiationStrategy();Overrideprotected Object createBean(String beanName, BeanDefinition beanDefinition, Object[] args) {Object bean null;try {bean createBeanInstance(beanDefinition, beanName, args);// 给bean填充属性applyPropertyValues(beanName, bean, beanDefinition);// 执行 Bean 的初始化方法和 BeanPostProcessor 的前置和后置处理方法bean initializeBean(beanName, bean, beanDefinition);} catch (Exception e) {throw new BeansException(Instantiation of bean failed, e);}// 注册实现 DisposableBean 接口的 Bean 对象registerDisposableBeanIfNecessary(beanName, bean, beanDefinition);registerSingletonBean(beanName, bean);return bean;}private void registerDisposableBeanIfNecessary(String beanName, Object bean, BeanDefinition beanDefinition) {if (bean instanceof DisposableBean || StrUtil.isNotEmpty(beanDefinition.getDestroyMethodName())) {registerDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, beanDefinition));}}private Object initializeBean(String beanName, Object bean, BeanDefinition beanDefinition) {// 1.执行 BeanPostProcessor Before 处理Object wrappedBean applyBeanPostProcessorsBeforeInitialization(bean, beanName);// 执行 Bean 对象的初始化方法try {invokeInitMethods(beanName, wrappedBean, beanDefinition);} catch (Exception e) {throw new BeansException(Invocation of init method of bean[ beanName ] failed, e);}// 2.执行 BeanPostProcessor After 处理wrappedBean applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);return wrappedBean;}private void invokeInitMethods(String beanName, Object bean, BeanDefinition beanDefinition) throws Exception {// 1.实现接口 InitializingBeanif (bean instanceof InitializingBean) {((InitializingBean) bean).afterPropertiesSet();}// 2.注解配置 init-method {判断是为了避免二次执行初始化}String initMethodName beanDefinition.getInitMethodName();if (StrUtil.isNotEmpty(initMethodName) !(bean instanceof InitializingBean)) {Method initMethod beanDefinition.getBeanClass().getMethod(initMethodName);if (null initMethod) {throw new BeansException(Could not find an init method named initMethodName on bean with name beanName );}initMethod.invoke(bean);}}...
}执行 Bean 对象的初始化方法 抽象类 AbstractAutowireCapableBeanFactory 中的 createBean 是用来创建 Bean 对象的方法在这个方法中我们已经扩展了 BeanFactoryPostProcessor、BeanPostProcessor 操作现在继续完善执行 Bean 对象的初始化方法的处理动作。在方法 invokeInitMethods 中主要分两块来执行。 实现了 InitializingBean 接口的操作处理 afterPropertiesSet 方法。另外一个是判断配置信息 init-method 是否存在执行反射调用 initMethod.invoke(bean)。这两种方式都可以在 Bean 对象初始化过程中进行处理加载 Bean 对象中的初始化操作让使用者可以额外新增加自己想要的动作。 创建 Bean 时注册销毁方法对象 在创建 Bean 对象的实例的时候需要把销毁方法保存起来方便后续执行销毁动作进行调用。那么这个销毁方法的具体方法信息会被注册到 DefaultSingletonBeanRegistry 中新增加的 MapString, DisposableBean disposableBeans 属性中去。 因为这个接口的方法最终可以被类 AbstractApplicationContext 的 close 方法通过 getBeanFactory().destroySingletons() 调用。 在注册销毁方法的时候会根据是接口类型和配置类型统一交给 DisposableBeanAdapter 销毁适配器类来做统一处理。 实现某个接口的类可以被 instanceof 判断或者强转后调用接口方法。
3.5 虚拟机关闭钩子时注册调用销毁方法
3.5.1 配置应用上下文接口 ConfigurableApplicationContext.java package com.lino.springframework.context;import com.lino.springframework.beans.BeansException;/*** description: SPI 接口配置应用上下文*/
public interface ConfigurableApplicationContext extends ApplicationContext {/*** 刷新容器** throws BeansException 对象异常*/void refresh() throws BeansException;/*** 注册虚拟机钩子方法*/void registerShutdownHook();/*** 手动关闭*/void close();
}首先需要在 ConfigurableApplicationContext 接口中定义注册虚拟机钩子的方法 registerShutdownHook 和手动执行关闭的方法 close。
3.5.2 应用上下文抽象类 AbstractApplicationContext.java package com.lino.springframework.context.support;import com.lino.springframework.beans.BeansException;
import com.lino.springframework.beans.factory.ConfigurableListableBeanFactory;
import com.lino.springframework.beans.factory.config.BeanFactoryPostProcessor;
import com.lino.springframework.beans.factory.config.BeanPostProcessor;
import com.lino.springframework.context.ConfigurableApplicationContext;
import com.lino.springframework.core.io.DefaultResourceLoader;
import java.util.Map;/*** description: 抽象应用上下文*/
public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {Overridepublic void refresh() throws BeansException {// 1.创建 BeanFactory并加载 BeanDefinitionrefreshBeanFactory();// 2.获取 BeanFactoryConfigurableListableBeanFactory beanFactory getBeanFactory();// 3.在 Bean 实例化之前执行 BeanFactoryPostProcessinvokeBeanFactoryPostProcessor(beanFactory);// 4.BeanPostProcessor 需要提前与其他 Bean 对象实例化之前执行注册操作registerBeanPostProcessor(beanFactory);// 5.提前实例化单例 Bean 对象beanFactory.preInstantiateSingletons();}Overridepublic void registerShutdownHook() {Runtime.getRuntime().addShutdownHook(new Thread(this::close));}Overridepublic void close() {getBeanFactory().destroySingletons();}...
}这里主要体现了关于注册钩子和关闭的方法实现根据方法 Runtime.getRuntime().addShutdownHook(new Thread(this::close))。
四、测试初始化和销毁方法
4.1 配置测试环境
4.1.1 修改UserDao用户对象 UserDao.java package com.lino.springframework.test.bean;import java.util.HashMap;
import java.util.Map;/*** description: 模拟用户DAO类*/
public class UserDao {private static MapString, String hashMap new HashMap();public void initDataMethod() {System.out.println(执行init-method);hashMap.put(10001, 张三);hashMap.put(10002, 李四);hashMap.put(10003, 王五);}public void destroyDataMethod() {System.out.println(执行destroy-method);hashMap.clear();}public String queryUserName(String uId) {return hashMap.get(uId);}
}添加初始化方法 initDataMethod 和销毁方法 destroyDataMethod。
4.1.2 修改UserService用户对象 UserService.java package com.lino.springframework.test.bean;import com.lino.springframework.beans.factory.DisposableBean;
import com.lino.springframework.beans.factory.InitializingBean;/*** description: 模拟用户 Bean 对象*/
public class UserService implements InitializingBean, DisposableBean {private String uId;private String company;private String location;private UserDao userDao;Overridepublic void destroy() throws Exception {System.out.println(执行UserService.destroy);}Overridepublic void afterPropertiesSet() throws Exception {System.out.println(执行UserService.afterPropertiesSet);}/*** 查询用户信息*/public String queryUserInfo() {return userDao.queryUserName(uId) , company , location;}public String getuId() {return uId;}public void setuId(String uId) {this.uId uId;}public String getCompany() {return company;}public void setCompany(String company) {this.company company;}public String getLocation() {return location;}public void setLocation(String location) {this.location location;}public UserDao getUserDao() {return userDao;}public void setUserDao(UserDao userDao) {this.userDao userDao;}
}实现接口 InitializingBean、DisposableBean 的两个方法 afterPropertiesSet()、destroy()处理相应的初始化和销毁方法的动作。
4.1.3 修改配置文件 spring.xml ?xml version1.0 encodingutf-8 ?
beansbean iduserDao classcom.lino.springframework.test.bean.UserDaoinit-methodinitDataMethoddestroy-methoddestroyDataMethod/bean iduserService classcom.lino.springframework.test.bean.UserServiceproperty nameuId value10001/property namecompany value阿里/property namelocation value杭州/property nameuserDao refuserDao//bean
/beans配置文件新增加了 init-methodinitDataMethod、destroy-methoddestroyDataMethod 两个配置。这两个配置是为了加入到 BeanDefinition 定义类之后写入到类 DefaultListableBeanFactory 中的 beanDefinitionMap 属性中去。
4.2 单元测试 ApiTest.java Test
public void test_xml() {// 1.初始化 BeanFactoryClassPathXmlApplicationContext applicationContext new ClassPathXmlApplicationContext(classpath:spring.xml);applicationContext.registerShutdownHook();// 3.获取Bean对象调用方法UserService userService applicationContext.getBean(userService, UserService.class);String result userService.queryUserInfo();System.out.println(测试结果 result);
}测试方法中新增加了一个注册钩子的动作。applicationContext.registerShutdownHook()。 测试结果 执行init-method
执行UserService.afterPropertiesSet
测试结果张三,阿里,杭州
执行UserService.destroy
执行destroy-method从测试结果来看xi能增加的初始化和销毁方法都有输出结果了。
五、总结初始化和销毁方法
主要完成了关于初始化和销毁方法的两种方法。 使用接口定义implements InitializingBean, DisposableBean在 spring.xml 中配置 init-methodinitDataMethod destroy-methoddestroyDataMethod 具体在 AbstractAutowireCapableBeanFactory 完成初始化方法和 AbstractApplicationContext 完成销毁动作的具体实现过程。
