• 深入理解java：4.2. 框架编程之Spring框架的设计理念

    什么是Spring呢？

    Spring是为了解决企业应用开发的复杂性而创建的一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。

    Spring优点

           简单了解Spring之后，我们看一下Spring的优点。

    1、方便解耦，简化开发。
    2、AOP编程的支持。
    3、声明式事务的支持。
    4、方便程序的测试。。
    5、方便集成各种优秀框架。

    6、降低Java EE API的使用难度。

    Spring的骨骼架构

    Spring总共有十几个组件，但是真正核心组件只有三个：Core、Context和Beans。

    没有它们就不可能有AOP、Web、ORM等上层的扩展的特性功能。

    Spring的设计理念

    Spring的三个核心组件，Bean比作一场演出中的演员的话，那Context就是这场演出的舞台背景，而Core应该就是演出的道具了。

    三个核心组件中最核心那就非Beans组件莫属了，因为Spring就是面向Bean的编程（BOP,Bean Oriented Programming），Bean在Spring 中才是真正的主角。Bean在Spring中作用就像Object对OOP的意义一样。

    Bean包装的是Object，而Object必然有数据，如何给这些数据提供生存环境就是Context要解决的问题，对Context来说他就是要发现每个Bean之间的关系，为它们建立这种关系并且要维护好 这种关系。

    Core就是发现、建立和维护每 个Bean之间的关系所需要的一些列的工具，从这个角度看来，Core这个组件叫Util更能让你理解。

    Bean组件

    org.springframework.beans包下，这个包下的所有类主要解决了三件事：对Bean 的创建、Bean的定义、Bean的解析。

    对Spring的使用者来说唯一需要关心的就是Bean的创建，其他两个由Spring在内部帮你完成了。

    Bean的创建时典型的工厂模式，他的顶级接口是BeanFactory，有三个子类：可列表的ListableBeanFactory、有继承关系的HierarchicalBeanFactory和自动装配的Autowire Capable BeanFactory。

    最终的默认实现类是DefaultListableBeanFactory，他实 现了所有的接口。

    Bean的定义主要有BeanDefinition描述，就是完整的描述了在Spring的配置文件中你定义的节点中所有的信息，包括各种子节点。

    当Spring成功解析你定义的一个节点后，在Spring的内部他就被转化 成BeanDefinition对象。

    Bean的解析过程非常复杂，功能被分的很细，因为这里需要被扩展的地方很多，Bean的解析主要就是对Spring配置文件的解析。

    Context组件

    org.springframework.context包下，Context组件在Spring中的作用，实际上就是给Spring提供一个运行时的环境。

    ApplicationContext是Context组件的顶级父类，ApplicationContext继承了BeanFactory，这也说明了Spring容器中运行的主体对象是Bean，

    另外ApplicationContext继承了ResourceLoader接口，使得ApplicationContext可以访 问到任何外部资源，这里将会使用到Core组建。

    ApplicationContext的子类主要有ConfigurableApplicationContext，表示该Context是可修改的，其下面又有一个子类，可更新的Context，即 AbstractRefreshableApplicationContext类。

    ApplicationContext的子类还有一个WebApplicationContext，就是为web准备的Context。他可以直接访问到ServletContext，通常情况下，这个接口使用的少。

    Core组件

    包含了很多的关键类，其中一个重要组成部分就是定义了资源的访问方式。

    Resource接口封装了各种可能的资源类型，也就是对使用者来说屏蔽了文件类型的不同。

    Resource 接口继承了InputStreamSource接口，这个接口中有个getInputStream方法，返回的是InputStream类。这样所有的资源都被可以通过InputStream这个类来获取，所以也屏蔽了资源的提供者。

    另外还有一 个，资源的加载者要统一，这个任务是由ResourceLoader接口完成，他屏蔽了所有的资源加载者的差异，只需要实现这个接口就可以加载所有的资源， 他的默认实现是DefaultResourceLoader。

    如何创建BeanFactory工厂

    Ioc容器实际上就是Context组件结合其他两个组件共同构建了一个Bean关系网，如何构建这个关系网？

    构建的入口就在AbstractApplicationContext类的refresh方法中。

    清单1.AbstractApplicationContext.refresh   //这个方法就是构建整个Ioc容器过程的完整的代码，了解了里面的每一行代码基本上就了解大部分Spring的原理和功能了。

    1. public void refresh() throws BeansException, IllegalStateException {  
    2.  
    3.     synchronized (this.startupShutdownMonitor) {  
    4.  
    5.         // Prepare this context for refreshing.  
    6.  
    7.         prepareRefresh();  
    8.  
    9.         // Tell the subclass to refresh the internal bean factory.  
    10.  
    11.         ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();  //里面调用loadBeanDefinitions();开始加载、解析 Bean的定义，也就是把用户定义的数据结构转化为Ioc容器中的特定数据结构。
    12.  
    13.         // Prepare the bean factory for use in this context.  
    14.  
    15.         prepareBeanFactory(beanFactory);  //添加一些Spring本身需要的一些工具类
    16.  
    17.         try {  
    18.  
    19.             // Allows post- processing of the bean factory in context subclasses.  
    20.  
    21.             postProcessBeanFactory(beanFactory);  //扩展了Spring的功能： 让你现在可以对已经构建的BeanFactory的配置做修改
    22.  
    23.             // Invoke factory processors registered as beans in& nbsp;the context.  
    24.  
    25.             invokeBeanFactoryPostProcessors(beanFactory);  //扩展了Spring的功能： 让你现在可以对已经构建的BeanFactory的配置做修改
    26.  
    27.             // Register bean processors that intercept bean crea tion.  
    28.  
    29.             registerBeanPostProcessors (beanFactory);  //扩展了Spring的功能： 让你可以对以后再 创建Bean的实例对象时添加一些自定义的操作
    30.  
    31.             // Initialize message source for this context.  
    32.  
    33.             initMessageSource();  
    34.  
    35.             // Initialize event multicaster for this context.  
    36.  
    37.             initApplicationEventMulticaster();  
    38.  
    39.             // Initialize other special beans in specific contex t subclasses.  
    40.  
    41.             onRefresh();  
    42.  
    43.             // Check for listener beans and register them.  
    44.  
    45.             registerListeners();  
    46.  
    47.             // Instantiate all remaining (non-lazy-init) singletons.  
    48.  
    49.             finishBeanFactoryInitialization (beanFactory);  //Bean的实例化
    50.  
    51.             // Last step: publish corresponding event.  
    52.  
    53.             finishRefresh();  
    54.  
    55.         }  
    56.  
    57.         catch (BeansException ex) {  
    58.         略
    60.         }  
    61.  
    62.     }  

    一个非常重要的Bean——FactoryBean，

    可以说Spring一大半的扩展的功能都与这个Bean有关，这是个特殊的Bean他是个工厂Bean，可以产生Bean的Bean，这里的产生Bean是指 Bean的实例，

    如果一个类继承FactoryBean，用户可以自己定义产生实例对象的方法只要实现他的getObject方法。

    然后在Spring内部这个Bean的实例对象是FactoryBean，通过调用这个对象的getObject方 法就能获取用户自定义产生的对象，从而为Spring提供了很好的扩展性。Spring获取FactoryBean本身的对象是在前面加上&来完成的。

    Ioc容器的扩展点

    如何让这些Bean对象有一定的扩展性，就是可以加入用户的一些操作。

    BeanFactoryPostProcessor，BeanPostProcessor。他们分别是在构建BeanFactory和构建Bean对象时调用。

    还有就是InitializingBean和DisposableBean 他们分别是在Bean实例创建和销毁时被调用。用户可以实现这些接口中定义的方法，Spring就会在适当的时候调用他们。

    还有一个是FactoryBean他是个特殊的Bean，这个Bean可以被用户更多的控制。

    如何精通Spring就看你有没有掌握好Spring有哪些扩展点，并且如何使用他们，要知道如何使用他们就必须了解他们内在的机理。

    把Ioc容器比作一个箱子，

    这个箱子里有若干个球的模子，可以用这些模子来造很多种不同的球，

    还有一个造这些球模的机器，这个机器可以产生球模。

    那么他们的对应关系就是BeanFactory就是 那个造球模的机器，

    球模就是Bean，

    而球模造出来的球就是Bean的实例。

    那前面所说的几个扩展点又在什么地方呢？

    BeanFactoryPostProcessor对应到当造球模被造出来时，你将有机会可以对其做出设 当的修正，也就是他可以帮你修改球模。

    而InitializingBean和DisposableBean是在球模造球的开始和结束阶段，你可以完成一些预备和扫尾工作。

    BeanPostProcessor就可以让你对球模造出来的球做出 适当的修正。

    最后还有一个FactoryBean，它可是一个神奇的自定义球模。这个球模不是预先就定型了，而是由你来给他确定它的形状，既然你可以确定这个球模型的形状，当然他造出来的球肯定就是你想要的 球了，这样在这个箱子里尼可以发现所有你想要的球。

    SpringAOP如何实现

    静态代理模式的实现原理

    Offer接口：

    Offer实现：

    Offer代理：

    我们要通过下面的方式来使用：

    上面的例子的输出为：

    上面的例子中，OfferProxy实现了IOffer，而所有的业务实现均委托给其成员offer；

    可以想像，这应该就是最简单的AOP的实现了；

    但这种方式会存在一个问题：如果有非常多的这种业务对象需要性能监控，我们就需要写同样多的XyzProxy来满足需求，这也是非常巨大的工作量。

    Jdk动态代理

    JDK动态代理，顾名思义，是基于JDK的反射(reflect)机制；在JDK中，提供了InvocationHandler这个接口，下面是JDK里面的注释：

    该接口由被代理对象的handler所实现；当调用代理对象的方法时，该方法调用将被编码，然后交给代理对象的invoke方法去执行；

    是不是有一种豁然开朗的感觉呢？没错，答案就在你心中。

    这样，上面的代码就可以改成下面的实现方式：

    调用端：

    通过这种方式，你不需要为针对每一个业务写一个代理对象，就可以很轻松地完成你的需求；

    但也许你已经注意到了，JDK的动态代理，在创建代理对象(上面红色代码部分)时，被代理的对象需要实现接口(即面向接口编程)；

    这就是JDK的动态代理，简单吧！下面看看CGLIB代理方式。

     

    CGLIB类代理

    如果目标对象没有实现任何接口，那怎么办呢？不用担心，你可以用CGLIB来实现代理：

    调用端：

    使用CGLIB创建的代理对象，其实就是继承了要代理的目标类，然后对目标类中所有非final方法进行覆盖，

    但在覆盖方法时会添加一些拦截代码(上面CglibProxyFactory类中的intercept方法)。

    Spring AOP的几个概念

    Spring AOP中的几个基本概念，每次学习AOP都被这几个概念折腾的很不爽，我们在这里再把这几个概念描述一遍，力争把这几个概念搞清，在每次review这块内容的时候可以很快上手。

    1.切面(Aspect)=切入点(Pointcut)+通知(Advice)：切面就是一个关注点的模块化，如事务管理、日志管理、权限管理等；

    2.连接点(Joinpoint)：程序执行时的某个特定的点，在Spring中就是某个方法的执行；

    3.通知(Advice)：通知就是在切面的某个连接点上执行的操作，也就是事务管理、日志管理等；

    4.切入点(Pointcut)=多个连接点(Joinpoint)的集合：切入点就是描述某一类选定的连接点，也就是指定某一类要织入通知的方法；

    5.目标对象(Target)=连接点(Joinpoint)所在的对象：就是被AOP动态代理的目标对象；

    用一张图来形象地表达AOP的概念及其关系如下：

    Spring AOP中切入点、通知、切面的实现

    1.切入点(Pointcut)：它定义了哪些连接点需要被织入横切逻辑；在Java中，连接点对应哪些类(接口)的方法。

    因此，我们都能猜到，所谓的切入点，就是定义了匹配哪些娄的哪些方法的一些规则，可以是静态的基于类(方法)名的值匹配，也可以是基于正则表达式的模式匹配。

    2.通知(Advice)：通知定义了具体的横切逻辑。

    3.切面(Aspect)：在Spring中，Advisor就是切面；

    但与通常的Aspect不同的是，Advisor通常只有一个Pointcut和一个Advice，而Aspect则可以包含多个Pointcut和多个Advice，因此Advisor是一种特殊的Aspect。但，这已经够用了！

     

     

    参考资料：

    http://developer.51cto.com/art/201006/205212_all.htm

    http://www.uml.org.cn/j2ee/201301102.asp
  • 相关阅读:
    Python多进程编程
    Cython学习
    cProfile——Python性能分析工具
    Python垃圾回收机制:gc模块
    新纪元
    类模版的static成员
    我的2015plan
    Linux之sed
    getenv, _wgetenv
    vs2010下如何调试带输入参数的程序
  • 原文地址：https://www.cnblogs.com/my376908915/p/6782604.html
Copyright © 2020-2023  润新知