Spring实战 | 第一部分 Spring的核心（第一章 Spring之旅）

时间 2019-11-08

标签 spring 实战第一部分核心第一章之旅栏目 Spring 繁體版

原文原文链接

Spring的bean容器

介绍Spring的核心模块

更为强大的Spring生态系统

Spring的新功能

1、简化java开发前端

为了下降Spring开发的复杂性，Spring采起了如下4钟关键策略：java

基于POJO的轻量级和最小侵入性编程；
经过依赖注入和面向接口实现松耦合；
基于切面和惯性进行声明式编程；
经过切面和模板减小样式代码。

一、激发POJO潜能（POJO即普通的java类）web

二、依赖注入（dependency injection DI）spring

依赖注入这个词让人望而生畏，如今已经演变成一项复杂的编程技巧或设计模式理念。但事实证实依赖注入并不像它听上去那么复杂，在项目中应用DI，你会发现你的代码会变得异常简单并且更容易理解和测试。编程

① DI功能是如何实现的设计模式

程序都是由多个类组合而成的，这些类之间进行协做完成特定的业务逻辑。按照传统的作法，每一个对象负责管理与本身相互协做的对象（即它所依赖的对象）的引用，这将会致使高度耦合和难以测试的代码。安全

② 耦合具备两面性。网络

一方面，紧耦合的代码难以测试、难以复用、难以理解，而且典型地表现出“打地鼠”式的bug特性（修复一个bug，将会出现一个或者更多的新bug）。另外一方面，必定程序的耦合又是必须的，彻底没有耦合的代码啥也作不了。为了完成有实际意义的功能，不一样的类必须以适当的方式进行交互。总而言之，耦合是必须的，但应当被当心谨慎的管理。session

经过DI，对象的依赖关系将由系统中负责协调各队的第三方组件在常见对象的时候进行设定。对象无需自行建立或管理他们的依赖关系，以下图，依赖关系将自动注入到须要他们的对象中去。app

③ 依赖注入的方式

spring支持3种依赖注入的方式

属性注入

属性注入即经过setter方法注入bean的属性值或依赖的对象

属性注入使用元素，使用name属性指定bean的属性名称，value属性或子节点属性值

属性注入是实际开发中最多见的注入方式

public void setName(String name)
{
    System.out.println("setName:"+name);
    this.name=name;
}

<bean id="helloWorld" class="spring.bean.HelloWorld">
    <property name="name" value="Spring"></property>
</bean>

构造器注入

经过构造方法注入bean的属性值或者依赖的对象（引用），保证了bean实例在实例化后就可使用

构造器注入在元素里声明属性，没有name属性

建立一个People对象

package com.container;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class People {
        private String name;
        private String sex;
        private int age;

        public People(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public People(String name, String sex) {
            this.name = name;
            this.sex = sex;
        }

        @Override
        public String toString() {
            return "people{" +
                    "name='" + name + '\'' +
                    ", sex='" + sex + '\'' +
                    ", age=" + age +
                    '}';
        }

        public static void main(String[] args) {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");
            People people1 = (com.container.People) applicationContext.getBean("people1");
            System.out.println(people1);
            People people2 = (com.container.People) applicationContext.getBean("people2");
            System.out.println(people2);
        }
    }

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="people1" class="com.container.People">
        <constructor-arg value="江疏影" type="java.lang.String"></constructor-arg>
        <constructor-arg value="20" type="int"></constructor-arg>
    </bean>
    <bean id="people2" class="com.container.People">
        <constructor-arg value="江疏影" type="java.lang.String"></constructor-arg>
        <constructor-arg value="man" type="java.lang.String"></constructor-arg>
    </bean>
</beans>

工厂方法注入（知道就行，不推荐）

三、应用切面

DI可以让相互协做的软件组件保持松散耦合，而面向切面编程（aspect-oriented programming，AOP）容许你把遍及应用各处的功能分离出来造成可重用的组件。

面向切面编程每每被定义为促使软件系统实现关注点分离的一项技术。系统由许多不一样的组件组成，每个组件各负责一块特定功能。除了实现自身核心的功能外，这些组件还常常承担着额外的职责。诸如日志、事务管理和安全这样的系统服务也会融入到核心业务组件中，这些系统服务一般被称为横切关注点，由于它们会跨越系统的多个组件。

若是将这些关注点所有分散到多个组件中去，你的代码将会带来双重的复杂性。

实现系统关注点功能的代码将会重复的出如今多个组件中，这就意味着若是你要改变这些关注点的逻辑，必须修改各个模块中的相关实现。即便你把关注点对象抽象为一个独立的模块，其它模块只要调用它的方法，但方法的调用仍是会出重复出如今各个模块中。
组件会由于那些与自身核心业务无关的代码而变得混乱。一个向地址簿增长地址条目的方法应该只关注如何添加地址，而不该该关注它是否是安全的或者是否须要支持事务。

下图展现了这种复杂性，左边的业务代码与系统服务结合的过于紧密。每一个对象不但要知道它须要记日志、进行安全控制和参与事务，还要亲自执行这些服务。

AOP可以使这些服务模块化，并以声明的方式将它们应用到它们须要影响的组件中去。而形成的结果就是这些组件会具备更高的内聚性而且会更加关注自身的业务，彻底不须要了解设计系统服务所带来的复杂性。总之，AOP可以确保POJO的简单性。

以下图所示，咱们能够把切面想象为覆盖在不少组件之上的一个外壳。应用是由那些实现各自业务功能的模块组成，借助AOP，可使用各类功能层去包裹核心业务层，这些层以声明的方式灵活的应用在系统中，你的核心应用甚至不知道他们的存在，这是一个很是强大的理念，能够将安全、事务和日志关注点与核心业务逻辑相分离。

经过少许的XML配置，声明一个Spring切面。

四、使用模块消除样板式代码

2、Spring容器

Spring容器，顾名思义是用来容纳东西的，装的就是Bean。Spring容器负责建立、配置、管理Bean。spring容器有两个核心接口：BeanFactory和ApplicationContext接口，后者是前者的子接口。在基于spring的Java EE程序中，全部的组件都被当成Bean来处理，包括数据源对象、hibernate的sessionFactory、事务管理等，程序中的全部Java类均可以被当成spring容器中的bean。

在基于Spring的应用中，你的应用对象生存于Spring容器（container）中。以下图所示，Spring容器负责建立对象，装配它们，配置它们并管理它们的整个生命周期，从生存到死亡（在这里可能就是new到finalize()）。

一、spring容器

spring容器的核心接口是BeanFactory，它有一个子接口就是ApplicationContext。ApplicationContext也被称为spring上下文。

调用者只须要使用getBean()方法便可得到指定bean的引用。对于大部分的Java程序而言，使用ApplicationContext做为spring容易更为方便。其经常使用的实现类有FileSystemXmlApplicationContext、ClassPathXmlApplicationContext和AnnotationConfigXmlApplicationContext。若是Java web中使用spring容器，则一般有XmlWebApplicationContext、AnnotationConfigWebApplicationContext两个容器。

建立spring容器的实例时，必须提供spring容器管理的bean的配置文件，也就是咱们常说的spring.xml配置文件。所以在建立beanFactory时配置文件做为参数传入。xml配置文件通常以resource对象传入。resource是spring提供的资源访问接口，经过该接口spring更简单、透明的访问磁盘，网络系统和类路径上的相关资源。

对于独立的Java EE应用程序，能够经过以下方法来实例化BeanFactory。

//在当前项目类路径下搜索配置文件
ApplicationContext appContext = new ClassPathXmlApplicationContext("beans_7_3_3.xml");
//在文件系统搜索配置文件
appContext = new FileSystemXmlApplicationContext("D:\\spring-tool-workspace\\myspring\\src\\beans_7_3_3.xml");
//获取chinese的Bean，而且返回的类型为Chinese
Person chinese = appContext.getBean("chinese", Chinese.class);
chinese.useAxe();

二、使用ApplicationContext

大部分时间，都不会使用beanFactory实例做为spring容器，而是使用ApplicationContext做为spring容器，所以spring容器也被称为spring上下文。ApplicationContext加强了beanFactory的功能，提供了不少有用、方便开发的功能。

在web中能够利用如contextLoader的支持类，在web应用启动的时候自动建立ApplicationContext。

除了提供beanFactory所支持的所有功能外，application还额外的提供以下功能：

① ApplicationContext会默认初始化全部的singleton bean（单例bean），也能够经过配置取消。

② ApplicationContext继承了messageSource接口，所以提供国际化支持。

③ 资源访问，好比URL和文件。

④ 事件机制。

⑤ 同时加载多个配置文件。

⑥ 以声明式方式启动并建立spring容器。

ApplicationContext包括beanFactory的全部功能，并提供了一些额外的功能，优先使用ApplicationContext。对于在内存消耗的才使用beanFactory。

当系统建立ApplicationContext容器时，会默认初始化singleton bean，包括调用构造器建立该bean的实例，经过元素驱动spring调用setting方法注入所依赖的对象。这就意味着，系统前期建立ApplicationContext会有很大的开销，可是一旦初始化完成后面获取bean实例就会拥有较好的性能。为了阻止在使用ApplicationContext做为spring容器初始化singleton bean能够在元素添加lazy-init="true"属性。

三、ApplicationContext的国际化支持

ApplicationContext接口继承了MessageSource接口，所以具有国际化功能。

//MessageSource接口提供的国际化的两个方法
String getMessage(String code, Object [] args, Locale loc){
}
String getMessage(String code, Object[]args, String default, Locale loc){
}

spring国际化的支持，实际上是创建在Java国际化的基础上的。其核心思路将程序中须要国际化的消息写入资源文件，而代码中仅仅使用国际化信息响应的key。

四、ApplicationContext的事件机制

ApplicationContext的事件机制是观察者设计模式的实现。经过ApplicationEvent和ApplicationListener接口实现，前者是被观察者，后者是观察者。

spring事件框架有两个核心的接口：

ApplicationEvent（事件）：必须由ApplicationContext来发布。

ApplicationListener（监听器）：实现了此接口就能够担任容器中的监听器bean。

实际上，spring的事件机制是由事件（实现ApplicationEvent接口的类）、事件源（也就是spring容器，而且有Java代码显示的触发）、监听器（ApplicationListener接口实现类）。这就像咱们在页面点击一个button。button是事件源，单机的这个动做就是事件，处理函数就是监听器。

如下代码演示spring事件机制：

import org.springframework.context.ApplicationEvent;

public class EmailEvent extends ApplicationEvent{
    private String address;
    private String text;
    public EmailEvent(Object source) {
        super(source);
    }

    public EmailEvent(Object source, String address, String text) {
        super(source);
        this.address = address;
        this.text = text;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }
}

import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class EmailNotifier implements ApplicationListener {
    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        //处理email事件
        if(event instanceof EmailEvent){
            EmailEvent email = (EmailEvent) event;
            System.out.println(email.getAddress()+"  "+email.getText());
        }else {
            //输出spring容器的内置事件
            System.out.println("其它事件："+event);
        }
    }

    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans_7_4_4.xml");
        EmailEvent emailEvent = applicationContext.getBean("emailEvent",EmailEvent.class);
        applicationContext.publishEvent(emailEvent);
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean class="EmailNotifier"></bean>
    <bean id="emailEvent" class="EmailEvent">
        <constructor-arg value="test"></constructor-arg>
        <constructor-arg value="123@qq.com"></constructor-arg>
        <constructor-arg value="this is a test"></constructor-arg>
    </bean>
</beans>

从上面的代码能够看出，事件监听器不只监听到了咱们程序显示触发的事件，还监听了spring容器内置的事件。若是实际开发须要，咱们能够在spring容器初始化或销毁时回调自定义方法，就能够经过上面的事件监听机制来完成。

spring提供了以下几个内置对象：

ContextRefreshedEvent、ContextStartedEvent、ContextClosedEvent、ContextStoppedEvent、RequestHandledEvent。

五、让bean获取spring容器

上面都是经过ApplicationContext建立spring容器，再调用spring容器的getBean()方法获取bean。这种状况下，程序老是持有spring容器的引用。可是在web应用中，咱们能够用声明式的方法来建立spring容器：在web.xml文件中配置一个监听，让这个监听类帮咱们来建立spring容器，前端MVC框架直接调用bean，使用依赖注入功能，无需访问spring容器自己。

在某些特殊状况下，bean须要实现某个功能（好比：bean须要输出国际化信息，或向spring容器发布事件），这些功能都须要借助spring容器来完成。就是说咱们须要将spring容器做为一个bean来注入到其它bean中，只不过spring容器bean是一个容器级别的bean。

为了让bean获取它所在容器的引用，可让bean实现beanFactoryAware接口。该接口只有一个方法setBeanFactory(BeanFactory beanFactory)方法，方法的beanFactory参数指向spring容器，会由spring容器注入。咱们bean中定义一个setter方法后，一般都是由在配置文件中配置元素来驱动spring容器来注入依赖bean的，可是这里咱们并无这样作，这是由于一个bean若是实现了beanFactory接口，spring在建立该bean时，会自动注入spring容器自己。与beanFactoryAware接口相似的还有BeanNameAware、ResourceLoaderAware接口，这些接口都会提供相似的setter方法，这些方法会由spring容器来注入。

六、bean的生命周期

正确理解Spring bean的生命周期很是重要，由于你或许要利用Spring提供的扩展点来自定义bean的建立过程。下图展现了bean装载到Spring应用上下文中的一个典型的生命周期过程。

正如你所见，在bean准备就绪前，bean工厂执行了若干启动步骤。

如今你已经了解了如何建立和加载一个Spring容器。可是一个空的容器并无太大的价值，在你把东西放进去以前，它什么也没有。为了从Spring的DI中受益，咱们必须将应用对象装配进Spring容器中。咱们将在第二章对bean装配进行更详细的探讨。

咱们如今首先浏览一下Spring的体系结果，了解一下Spring框架的基本组成部分和最新版本的Spring所发布的新特性。

3、俯瞰Spring风景线

一、Spring模块

Spring发布版本中lib目录下有多个jar文件。

Spring核心容器

Spring的AOP模块

数据访问与集成

web与远程调用

测试

Spring Boot(第二十一章介绍)

4、Spring的新功能

5、小结

Spring致力于简化企业级Java开发，促进代码的松散耦合，成功的关键在于依赖注入和AOP。

Spring实战@目录