Spring定义
一个轻量级full-stack(全栈)框架
优势：
覆盖面广：自身提供了很多开源的项目，比如SpringMVC,Spring Data,SpringSecrity等
生态强大：与各大常用的框架，中间件等都有集成方案。
我们常说的Spring通常指SpringFramework
SpringFramework
两个核心能力：IOC、AOP
IOC：
依赖注入（DI）/ 控制反转（IOC）
IOC与DI 都是说的一回事。DI是从容器的角度来讲，谁依赖某个东西，容器就给谁注入进去；IOC是从对象的角度来讲，对象不再创建与管理所依赖对象，交由IOC容器来创建bean和管理bean。
对象失去了创建与管理所依赖对象的权利，得到了无需处理创建对象与管理依赖对象的福利。
AOP：
面向切面（方面）编程
将横切代码抽取出来，集中处理，让业务类能更加专注于业务逻辑的处理。
如何自定义一个拥有IOC与AOP能力的框架？
1.首先应该有一个IOC容器，这个容器负责Bean的创建，及Bean生命周期的管理
2.配置信息放到xml文件中，Ioc容器通过反射的方式来创建Bean
3.创建Bean时，如果发现bean的属性中含有Aop相关注解，则给bean生成一个代理对象，来集中处理bean的各个方法执行时机，达到切面插入前置或后置逻辑的目的。
配置信息beans.xml：
<beans>
<!--id标识对象，class是类的全限定类名-->
<bean id="serviceA" class="com.test.service.ServiceA">
<property name="serviceB" ref="serviceA"/>
</bean>
<bean id="serviceB" class="com.test.service.ServiceB">
<property name="serviceC" ref="serviceC"/>
</bean>
<bean id="serviceC" class="com.test.service.ServiceC">
<property name="serviceA" ref="serviceA"/>
</bean>
</beans>
Ioc容器中IOC部分核心方法：
/**
* 根据名称获取bean
* @param name
* @return
*/
Object getBean(String name);
/**
* 根据类型获取bean
* @param clazz
* @param <T>
* @return
*/
<T> T getBean(Class<T> clazz);
Ioc容器ApplicationContext如何初始化呢，应该获取配置文件中的信息，解析出来的bean配置用BeanDefinition来存储，还应该生成Bean。
ApplicationContext核心方法如下：
/**
* 初始化容器
* @throws Exception
*/
protected void init() throws Exception {
// 解析 bean定义
this.initBeanDefinition();
this.initBeans();
}
/**
* 初始化bean定义
* <p>1.解析bean标签并生成BeanDefinition</p>
* <p>2.解析bean标签下的property标签并生成BeanPropertyDefinition</p>
*/
@Override
public void initBeanDefinition() {
SAXReader saxReader = new SAXReader();
try {
Document document = saxReader.read(inputStream);
Element rootElement = document.getRootElement();
List<Element> beanList = rootElement.selectNodes("//bean");
for (Element beanNode : beanList) {
BeanDefinition beanDefinition = XmlBeanParser.parse(beanNode);
beanDefinitionMap.put(beanDefinition.getId(), beanDefinition);
beanDefinitionMap.put(beanDefinition.getTargetClassName(), beanDefinition);
for (Class<?> anInterface : beanDefinition.getInterfaces()) {
beanDefinitionMap.put(anInterface.getName(), beanDefinition);
}
List<Element> propertyElementList = beanNode.selectNodes("property");
List<BeanPropertyDefinition> propertyList = resolveProperties(propertyElementList);
beanDefinition.setPropertyList(propertyList);
}
} catch (DocumentException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
* 初始化Bean，并注册到单例池中
* @throws Exception
*/
private void initBeans() throws Exception {
for (Map.Entry<String, BeanDefinition> definitionEntry : beanDefinitionMap.entrySet()) {
BeanDefinition definition = definitionEntry.getValue();
if (!definition.isLazy() && definition.getScope() == BeanScope.SINGLETON && !definition.isCreated()) {
Object instance = this.createAndInitBean(definition);
// 注册bean到单例池
registryBean(definition, instance);
}
}
}
/**
* 创建Bean并执行初始化操作
* @param definition
* @return
* @throws Exception
*/
private Object createAndInitBean(BeanDefinition definition) throws Exception {
// 创建实例
Object instance = this.doCreateInstance(definition);
definition.setCreated(true);
System.out.println("Created instance: " + instance);
tempBeanMap.put(definition.getId(), instance);
// 执行初始化方法
invokeBeanInitMethod(instance, definition);
// bean是否有依赖
initBeanDependsOn(definition, instance);
// 解析注入配置项
resolveBeanProperties(definition, instance);
// 包装proxy
instance = wrapProxyIfNecessary(instance);
return instance;
}
/**
* 根据bean定义，创建bean
*
* @param definition
* @return
*/
private Object doCreateInstance(BeanDefinition definition)
throws IllegalAccessException, InstantiationException, NoSuchMethodException,
InvocationTargetException, ClassNotFoundException {
Class<?> clazz = definition.getTargetClass();
Object instance;
String factoryBeanName = definition.getFactoryBeanClass();
String factoryMethodName = definition.getFactoryMethodName();
if (factoryBeanName != null && factoryMethodName != null) {
FactoryBean factoryBean = (FactoryBean) this.getBean(factoryBeanName);
Method factoryMethod =
factoryBean.getClass().getMethod(factoryMethodName, Object.class);
instance = factoryMethod.invoke(factoryBean, "getObject");
} else {
// 默认使用无参构造函数创建
instance = clazz.newInstance();
}
return instance;
}
AOP部分核心代码：
/**
* 需要时包装一层动态代理
*
* @param target
* @return
*/
private Object wrapProxyIfNecessary(Object target) {
boolean hasTxAnnotation = target.getClass().getAnnotation(Transactional.class) != null;
if (!hasTxAnnotation) {
Set<Method> methods =
ReflectionUtils.getAnnotatedMethod(target.getClass(), Transactional.class);
hasTxAnnotation = methods.size() > 0;
}
if (!hasTxAnnotation) {
return target;
}
ProxyFactory proxyFactory = getWrapFactory(target);
return proxyFactory.getProxy(target);
}
/**
* 生成代理工厂
*
* @param target
* @return
*/
private ProxyFactory getWrapFactory(Object target) {
if (target.getClass().getInterfaces().length == 0) {
// 没有实现接口，采用cglib
return this.getBean(CglibTransProxyFactory.class);
} else {
// 有实现接口，采用jdk动态代理
return this.getBean(JdkTransProxyFactory.class);
}
}
自定义容器使用与测试：
@Test
public void testXmlIocContainer() {
InputStream inputStream = this.getClass().getResourceAsStream("beans.xml");
BeanFactory beanFactory = new XmlApplicationContext(inputStream);
TransferService service = beanFactory.getBean(TransferService.class);
System.out.println(service);
Object temp = beanFactory.getBean(AccountDao.class);
System.out.println(temp);
}
