spring 必知

spring 为什么可以一统江湖

答案很简单，所有的对象都要在容器里存活。可见spring的重要程度，并不亚于jvm。懂了spring的原理后！我们可以很优雅地去集成我们的代码。
Inversion of Contro 简称IOC 是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。也就是面向接口编程的思想。
简单的说就是使用配置的方式，修改程序代码的实现。能灵活的切换代码，不用修改逻辑代码。其实就是解决硬编码创建对象的问题。

学习的路线设定

• 了解有多少种方式添加对象到容器中

这个很重要，在工作中经常出现类找不到的异常，熟悉这个的话，问题很容易找到。

• 再从spring对一个类的处理的源码开始解析spring的原理

Spring配置有两种,详细法就可以参考一下Spring的使用教程。

xml配置与注解方式配置。其他本质是一样的。

• xml
• 配置类上加Configuration

扫描加载bean的规则有，这些不是很重要.

• @bean

	<bean id="person" class="com.enjoy.cap1.Person">
		<property name="name" value="wolf"></property>
		<property name="age" value="19"></property>
	</bean>
或在Configuration类中使用,现在的spring boot都是用@Configuration方式的 

@Configuration
@Import(value = { Dog.class })
public class Cap6MainConfig {}

• @@Component与@ComponentScan(value = "bgy.bean")

一般用这种，在类上加@Component就可以ComponentScan加载到容器中

    @Component
	 public class Dog{}

• @@Import(bgy.beanout.Fly.class) 单独加入

@Configuration
@Import(value = { Dog.class })
public class Cap6MainConfig {}

• 实现ImportSelector

public class MyImportSelector implements ImportSelector{
	@Override
	public String[] selectImports(AnnotationMetadata importingClassMetadata){
		//返回全类名的bean
		return new String[]{"com.enjoy.cap6.bean.Fish","com.enjoy.cap6.bean.Tiger"};
	}
}

//把MyImportSelector当成bean导入
@Import(value = {ImportSelector.class})

• 使用FactoryBean

public class JamesFactoryBean implements FactoryBean<Monkey>{

	@Override
	public Monkey getObject() throws Exception {
		// TODO Auto-generated method stub
		return new Monkey();
	}

	@Override
	public Class<?> getObjectType() {
		// TODO Auto-generated method stub
		return Monkey.class;
	}
	
	@Override
	public boolean isSingleton() {
		return true;
	}
}

• 使用HdkImportBeanDefinitionRegistrar

public class HdkImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {

	/*
	*AnnotationMetadata:当前类的注解信息
	*BeanDefinitionRegistry:BeanDefinition注册类
	*    把所有需要添加到容器中的bean加入;
	*    @Scope
	*/
	@Override
	public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
		boolean bean1 = registry.containsBeanDefinition("com.enjoy.cap6.bean.Dog");
		boolean bean2 = registry.containsBeanDefinition("com.enjoy.cap6.bean.Cat");
		//如果Dog和Cat同时存在于我们IOC容器中,那么创建Pig类, 加入到容器
		//对于我们要注册的bean, 给bean进行封装,
		if(bean1 && bean2){
			RootBeanDefinition beanDefinition = new RootBeanDefinition(Pig.class);
			registry.registerBeanDefinition("pig", beanDefinition);
		}
	}

}

• BeanDefinitionRegistryPostProcessor

public class JamesBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor{


	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		System.out.println("JamesBeanDefinitionProcessor..postProcessBeanFactory(),Bean的数量"+beanFactory.getBeanDefinitionCount());
	}


	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		System.out.println("amesBeanDefinition.postProcessBeanDefinitionRegistry()...bean的数量"+registry.getBeanDefinitionCount());
		//RootBeanDefinition rbd = new RootBeanDefinition(Moon.class);
		AbstractBeanDefinition rbd = BeanDefinitionBuilder.rootBeanDefinition(Moon.class).getBeanDefinition();//注册一个beandefinition
		registry.registerBeanDefinition("hello", rbd);
	}

}

Condition 条件加载，在spring boot中使用比较广泛，用来过滤加载到IOC容器中的bean

public class WinCondition implements Condition{
	
	/*
	*ConditionContext: 判断条件可以使用的上下文(环境)
	*AnnotatedTypeMetadata: 注解的信息
	*
	*/
	@Override
	public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
		// TODO 是否为WINDOW系统
		//能获取到IOC容器正在使用的beanFactory
		ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
		//获取当前环境变量(包括我们操作系统是WIN还是LINUX??)
		Environment environment = context.getEnvironment();
		String os_name = environment.getProperty("os.name");
		if(os_name.contains("Windows")){
			return true;
		}
		return false;
	}

}

小结：

实现的spring包为：spring-context。上下文容器类都是继承了AbstractApplicationContext 类的。重点：开发时可以按需要自定义上下文。

spring 源码解析

从加载容器开始

      ApplicationContext applicationContext=new AnnotationConfigApplicationContext(myconfig.class);
       // ApplicationContext applicationContext=new ClassPathXmlApplicationContext("beans.xml");

上下文抽象类，此设计用的是模板方法设计模式, 在refresh里 固定好加载时的方法调用顺序。

 public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();//加载 bean的配置定义
            this.prepareBeanFactory(beanFactory);

            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);//如果有配置类则添加配置类处理器，并将优先级排为最高
                this.registerBeanPostProcessors(beanFactory);//注册其他的处理器，并设置好处理顺序。
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                this.onRefresh();
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);//注册所有注入进来的bean实例到容器中
                this.finishRefresh();
            } catch (BeansException var9) {
                if(this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }

                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }

        }
    }

BeanPostProcessors

后置处理器接口，实现了这个接口类可以对所有的类初始化方法进行拦截处理，分别为：postProcessBeforeInitialization，postProcessAfterInitialization
AutowiredAnnotationBeanPostProcessor @autowired就是使用这个处理器去处理的，很多Bean处理的阶段，都是使用BeanPostProcessors去处理的，可以在所有的bean创建后第一时间处理bean的一系列动作

@Component
////每个对象创建时都会执行
public class MyBeanPostProcessor implements BeanPostProcessor{

/**
*将这个{@code BeanPostProcessor}应用于给定的新bean实例<i>在任何bean之前
*初始化回调（比如InitializingBean的{@code afterPropertiesSet}
*或自定义初始化方法）。bean将已经填充了属性值。
*返回的bean实例可能是原始实例的包装器。
*<p>默认实现按原样返回给定的{@code bean}。
*@param bean 新的bean实例
*@param beanName bean的名字
*@返回要使用的bean实例，可以是原始实例，也可以是包装好的实例；
*如果{@code null}，则不会调用后续的BeanPostProcessor
*@org。springframework。豆。错误情况下的Bean例外
*@see org。springframework。豆。工厂初始化Bean#AfterPropertieSet
*/
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		//返回一个的对象(传过来的对象)
		//在初始化方法调用之前进行后置处理工作,
		//什么时候调用它: 对象的构造方法之后，init-method=init之前调用
		System.out.println("postProcessBeforeInitialization...."+beanName+"..."+bean);
		return bean;
	}

/**
*将这个{@code BeanPostProcessor}应用于给定的新bean实例<i>之后的任何bean
*初始化回调（比如InitializingBean的{@code afterPropertiesSet}
*或自定义初始化方法）。bean将已经填充了属性值。
*返回的bean实例可能是原始实例的包装器。
*对于FactoryBean，将为FactoryBean和
*实例和FactoryBean创建的对象（从Spring 2.0开始）。这个
*后处理器可以决定是应用于FactoryBean还是创建的
*通过相应的{@code bean instanceof FactoryBean}检查。
*<p>此回调也将在由故障触发的短路后调用
*{@link instantiationwarebeanpostprocessor#postprocessabefore instantiation}方法，
*与所有其他{@code BeanPostProcessor}回调不同。
*默认实现按原样返回给定的{@code bean}。
*@param bean新的bean实例
*@param beanName豆子的名字
*@返回要使用的bean实例，可以是原始实例，也可以是包装好的实例；
*如果{@code null}，则不会调用后续的BeanPostProcessor
*/
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
                //init-method=init之后调用
		System.out.println("postProcessAfterInitialization...."+beanName+"..."+bean);
		return bean;
	}
}

ApplicationContextAware

使用实现了这个接口的bean都可以获取到容器原上下文。下面讲到的spring mvc中就用到这个方法。

public interface ApplicationContextAware extends Aware {
    void setApplicationContext(ApplicationContext var1) throws BeansException;
}

bean中

   public void setApplicationContext(ApplicationContext applicationContext) {
        if(this.webApplicationContext == null && applicationContext instanceof WebApplicationContext) {
            this.webApplicationContext = (WebApplicationContext)applicationContext;
            this.webApplicationContextInjected = true;
        }

    }

spring 应用组件扩展

spring mvc 原理

先用一句话总结：通过url请求路径，反射调用容器中的bean方法。

首先从问题开始

• 请求路径是如何定位到一个ｓｅｒｖｌｅｔ的？

这个问题开始学ｓｅｒｖｌｅｔ时就会的。在ｗｅｂ．ｘｍｌ配置一下就行了！其实就是一个ｍａｐ，ｋｅｙ＝请求路径　　ｖａｌｕｅ＝ｓｅｒｖｌｅｔ。
就可以快速找到浏览器上传过来的请求路径。这里重要不是讲servlet，感兴趣的可以看看tomcat的源码。http如果到servlet的。

• 请求如何找到ＭＶＣ中的＠RequestMapping（＂ｖｉｅｗ”）方法呢？

• 在mvc的web.xml找到servlet的配置。
  

• 再看看DispatcherServlet是个什么玩意
  

ｔｏｍｃａｔ的所有ｓｅｒｖｌｅｔ请求都会经过HttpServlet．service，MVC中的DispatcherServlet类就是一个实现了HttpServlet接口中的一个类型。DispatcherServlet．service中的方法的触> 发将从ｔｏｍｃａｔ中发起。DispatcherServlet中将会获取请求的上下文。

容器类将加载@Controller的类型的实例加载到容器中。@Controller其实就是一个@Component

dispatcherServlet将@Controller的bean与RequestMapping的value做映射HandlerMappings

• initStrategies 初始化相关信息
  

initHandlerMappings

将所有的RequestMapping的value与controller加到handlerMappings中。后面通过放射调用标注了RequestMapping的方法。
private List handlerMappings;

doService()

• 看看调用堆
  

    protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        AnnotationMethodHandlerAdapter.ServletHandlerMethodResolver methodResolver = this.getMethodResolver(handler);
        Method handlerMethod = methodResolver.resolveHandlerMethod(request);//获取到controller中的方法
        AnnotationMethodHandlerAdapter.ServletHandlerMethodInvoker methodInvoker = new AnnotationMethodHandlerAdapter.ServletHandlerMethodInvoker(methodResolver);
        ServletWebRequest webRequest = new ServletWebRequest(request, response);
        ExtendedModelMap implicitModel = new BindingAwareModelMap();
        Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
        ModelAndView mav = methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);
        methodInvoker.updateModelAttributes(handler, mav != null?mav.getModel():null, implicitModel, webRequest);
        return mav;
    }

1 找到处理类controller

2 找到处理方法进行反射

3 调用到requestmapping的方法

设计模式发现

可适配类型

下面用实现controller接口的方式实现请求处理类。这种方式 使用的是SimpleControllerHandlerAdapter这种适配器，servlet的话就会使用SimpleServletHandlerAdapter。

@Component
@RequestMapping("index")
public class TestController implements org.springframework.web.servlet.mvc.Controller {
    
    @Override
    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
        return new ModelAndView("index.jsp");
    }
}

总结

1加载:RequestMappingHandlerMapping.afterPropertiesSet调用AbstractHandlerMethodMapping.initHandlerMethods将requestmapping与controller类初始化到一个handlerMappings
2处理请求：通过request在handlerMappings中找到相应的controller与requestmapping的方法，反射调用方法。

spring aop

在Spring中，AOP是一个比较重要的组件，主要用于日志处理，如：记录操作日志，记录异常日志等。

原理也很简单，主要关注所有方法的调用前，中，后，还有异常。很明显适用代理模式。项目中的bean这么多，当然不能为每个bean写个代理实现类，静态代理肯定不行。所以用jdk的动态代理或CGLIB的动态代理来创建这些代理对象是唯一的选择。在spring中使用后置处理器，为每个bean创建代理对象，所以当程序调用bean时已经不是以前那个bean了！已经是带有增强的代理实例来的了。

通知方法

• 前置通知: logStart(),在目标方法(div)运行之前运行 (@Before)
• 后置通知:logEnd(), 在目标方法(div)运行结束之后运行,无论正常或异常结束 (@After)
• 返回通知:logReturn, 在目标方法(div)正常返回之后运行 (@AfterReturning)
• 异常通知:logException, 在目标方法(div)出现异常后运行(@AfterThrowing)
• 环绕通知:@Around以上没写,动态代理, 手动执行目标方法运行joinPoint.procced(),最底层通知,

原理

• 通过@Pointcut("execution(public int com.enjoy.cap10.aop.Calculator.*(..))") 配置找到要代理拦截的方法。

• DefaultAdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice 生成拦截链加到list遍历调用。

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Advised config, Method method, @Nullable Class<?> targetClass) {
        List<Object> interceptorList = new ArrayList(config.getAdvisors().length);
        Class<?> actualClass = targetClass != null?targetClass:method.getDeclaringClass();
        boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        Advisor[] var8 = config.getAdvisors();
        int var9 = var8.length;

        for(int var10 = 0; var10 < var9; ++var10) {
            Advisor advisor = var8[var10];
            MethodInterceptor[] interceptors;
            if(advisor instanceof PointcutAdvisor) {
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor)advisor;
                if(config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                    interceptors = registry.getInterceptors(advisor);
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    if(MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
                        if(mm.isRuntime()) {
                            MethodInterceptor[] var15 = interceptors;
                            int var16 = interceptors.length;

                            for(int var17 = 0; var17 < var16; ++var17) {
                                MethodInterceptor interceptor = var15[var17];
                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                            }
                        } else {
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            } else if(advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor)advisor;
                if(config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                    interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            } else {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }

        return interceptorList;
    }

• 虽然是顺序结构,但是调用执行顺序却是从下面开始的，类似递归算法那样。下往上执行。
  

• 执行拦截器链ReflectiveMethodInvocation.proceed()

   public Object proceed() throws Throwable {
        if(this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return this.invokeJoinpoint();
        } else {
            Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
            if(interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
                InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;
                return dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)?dm.interceptor.invoke(this):this.proceed();
            } else {
                return ((MethodInterceptor)interceptorOrInterceptionAdvice).invoke(this);
            }
        }
    }

总结

spring 是管理bean的一个框架，在面向对象编程中，一个程序是由一个或多个对象组成的，spring就是用来管理这些对象的
，spring把这些对象抽象成bean,bean的生命周期分三个阶段：创建，初始化，销毁.
创建：spring把bean的定义描述从xml或class读出来，创建好放到容器中。
spring为bean抽象了两个方法：初始化，销毁。
初始化:可以按一定的逻辑去动态设置bean的初始化属性状态，或者执行其他的方法。
销毁：在销毁前执行其他的方法。
在开发过程中如果需要按一定的逻辑去处理bean的话，使用配置的方法比较麻烦，每个bean都是实现初始化方法。
spring 提供了一种后置处理器接口BeanPostProcessor，实现了这个接口就可以拦截初始化方法来统一处理。
如：BeanValidationPostProcessor验证bean，或ServletContextAwareProcessor servlet中的上下文档context的初始化。