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{

	@Override

	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {

		//返回一个的对象(传过来的对象)

		//在初始化方法调用之前进行后置处理工作,

		//什么时候调用它: 对象的构造方法之后，init-method=init之前调用

		System.out.println("postProcessBeforeInitialization...."+beanName+"..."+bean);

		return bean;

	}

	@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加载:将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的初始化。

巴特西

spring 为什么可以一统江湖

spring 为什么可以一统江湖

学习的路线设定

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

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

spring 源码解析

从加载容器开始

BeanPostProcessors

ApplicationContextAware

spring 应用组件扩展

spring mvc 原理

总结

spring aop

通知方法

原理

总结

最新文章

热门文章