Spring核心概念

一、初识Spring

Spring简述以及用途

学习一个框架，我们必然要先知道这个框架可以做什么。做过大型项目的朋友都知道，这些比较大的企业级应用结构复杂，涉及的资源众多，事务密集等等，传统Java EE解决企业级应用问题时的“重量级”架构体系，使它的开发效率、维护成本、应用性能等方面都令人失望。比如各个层级对象之间的耦合度总是达不到一个理想的状态，正是因为对象之间保持着一定程度的依赖，可能当我们需要对一个功能模块进行修改或者增加一个功能时，多个层级的代码都需要修改，甚至需要修改的代码贯穿整个架构层，这显然不是一个好的方案。于是一个屌炸天的哥们——Rod Johnson在2002年发表的一本书中，对Java EE技术日益臃肿、低效提出了质疑，也提出了Interface 21，这也是Spring框架的雏形。2003年2月Spring框架正式成为一个开源项目，发布于SourceForge中。

说了这么多，Spring框架到底可以帮助我们做哪些事呢？怎么说呢，它可以帮我们优化好多东西，它是一个全面的解决方案，不仅仅专注于某一层，而是贯穿表现层、业务层、持久层，可以说是“一站式”选择。作为轻量级的框架，它大大简化了Java企业级开发，提供了强大、稳定的功能。它也是一个三层架构，提供了一个集成框架，在Web层有Spring MVC，在业务层有Spring Core，在持久层有Spring ORM。Spring框架的核心就是IoC（控制反转）和AOP（面向切面编程）。

典型应用场景：解耦，简化开发；

                         对程序进行监控、拦截等；

                         组合其他框架，百搭。

Spring家族

Spring框架大约由20个功能模块组成，这些模块又被分为6部分，分别是Core Container、Data Access/Integration、Web、AOP（Aspect Oriented Programming）、Instrumentation、Test，如下图所示。

二、Spring IoC

IoC（Inversion of Control），即控制反转，也称为依赖注入（Dependency Injection，DI）。控制反转是面向对象编程中的一种涉及理念，用来降低程序代码之间的耦合度、依赖，它也是Spring的一个核心概念。

首先理解一下什么是依赖？在程序中，我们所说的依赖一般指通过局部变量、方法参数、返回值等建立的对于其他对象的调用关系。有点绕，通俗地说，在A类中有一个方法，实例化了一个B类的对象，然后调用了B类对象的方法完成一个功能，那么我们就说A类依赖于B类。根据面向对象的思想，我们考虑“什么事由谁去做”，所以几乎所有的应用都是依靠多个类之间的相互合作来实现一套完整的功能，但是类与类之间的依赖关系又增加了程序的复杂程度，我们对一个类进行修改时往往还要修改依赖于这个类的其他类。比如我们已经实现了一个功能，现在需要进行功能扩展，方法体需要多传入一个参数，那么我们要先修改这个底层方法，然后所有调用这个方法的层都需要修改，每次扩展起来都需要这样大动刀，是很累的一件事。这就是为什么我们经常说“高复用，低耦合”。

在进行代码示例之前，首先要明确项目中的哪一部分需要Spring帮我们注入。一般我们对业务逻辑层和DAO层使用注入，因为这两部分不做数据存储，一般情况下它们里面的东西不是经常改变的，只需要使用这些类中的方法就行了。对于实体类这种，我们一般是不采用依赖注入的方式的，因为实体类的信息是经常变化的，而且实体类一般都是需要多次创建的，不像服务层或者DAO层那样可以以单例模式存在。

接下来我们实现打印机打印内容的这个过程，理解依赖注入。其中打印机可以填入不同规格的纸张。

创建纸张接口

package Print;

public interface Paper {
    public static final String newLine="\r\n";  //换行

    /**
     *  输出一个字符到纸张
     * */
    public void putInChar(char c);

    /**
     *  获取纸张上的内容
     * */
    public String getContent();
}

创建纸张实现类

package Print;

public class TextPaper implements Paper {
    private int charPerLine;  //每一行的字符数
    private int linePerPage;  //每一页的行数
    private String content="";  //纸张中的内容
    private int posX=0;  //当前横向位置，从0到charPerLine-1
    private int posY=0;  //当前行数，从0到linePerPage-1
    private int posP=1;  //当前页数

    /**
     *  提供charPerLine的setter方法，供Spring注入
     * */
    public void setCharPerLine(int charPerLine) {
        this.charPerLine = charPerLine;
    }

    /**
     *  提供linePerPage的setter方法，供Spring注入
     * */
    public void setLinePerPage(int linePerPage) {
        this.linePerPage = linePerPage;
    }

    /**
     * 输出一个字符到纸张
     *
     * @param c
     */
    @Override
    public void putInChar(char c) {
        content+=c;
        posX++;  //当前横向位置+1

        if (posX==charPerLine){
            content+=Paper.newLine;  //如果当前横向位置等于最大行字符数，说明到了此行的尾部，加一个换行符
            posX=0;  //跳到下一行的第一个位置，归零
            posY++;  //行数加1
        }

        if (posY==linePerPage){
            content+="======第"+posP+"页======";
            content+=Paper.newLine+Paper.newLine;  //换两行加以区分

            posP++;
            posY=0;
            posX=0;
        }
    }

    /**
     * 获取纸张上的内容
     */
    @Override
    public String getContent() {
        String ret=this.content;
        if (!(posX==0&&posY==0)){
            int count=linePerPage-posY;
            for (int i=0;i<count;i++){
                ret+=Paper.newLine;  //如果本页中有内容并且有空行，则补齐本页空行
            }
        }
        return ret;
    }
}

创建打印机类

package Print;

public class Printer {
    //面向接口编程
    private Paper paper=null;


    /**
     *  设置注入所需的setter方法
     *  @param paper 传入纸张参数
     * */
    public void setPaper(Paper paper){
        this.paper=paper;
    }

    /**
     *  打印内容
     *  @param str 传入打印内容
     * */
    public void print(String str){
        System.out.println("打印内容");
        //逐字符输出到纸张
        for (int i = 0,j=str.length(); i <j ; i++) {
            paper.putInChar(str.charAt(i));
        }
        //将纸张的内容输出
        System.out.println(paper.getContent());
    }
}

创建Spring配置文件applicationContext.xml

<?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-3.2.xsd
 
    <!--B5纸张-->
    <bean id="paperB5" class="Print.TextPaper">
        <property name="charPerLine" value="10"/>
        <property name="linePerPage" value="3"/>
    </bean>
    <!--A4纸张-->
    <bean id="paperA4" class="Print.TextPaper">
        <property name="linePerPage" value="2"/>
        <property name="charPerLine">
            <value>8</value>
        </property>
    </bean>
    <!--组装打印机-->
    <bean id="printer" class="Print.Printer">
        <property name="paper" ref="paperA4"/>
    </bean>


    
</beans>

最后创建我们的测试类

package Print;

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

public class PrintTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        Printer printer=(Printer)context.getBean("printer");
        String content="大江东去，千层浪"
                +"你知它为何叫长江？"
                +"滚滚的波涛，流不尽,"+
                "东汉唐宋写华章。";
        printer.print(content);
    }
}

运行结果

上面描述的这个过程，我们可以看到，我们调用打印机的功能时，只需要给它一个需要打印的文本，方法不需要传入纸张参数，它不再依赖于纸张。打印机类中的纸张参数，在创建打印机类的时候Spring会根据配置文件中的配置为打印机类注入一个纸张类，而不需要它自己在业务方法内再new一个纸张类，只关心它自己的业务即可，达到了一个解耦。当我们需要给打印机插入不同的纸张中，只需要在配置文件中将打印机的paper属性的ref指向其他规格的纸张即可。这样一来，打印机只管拿着文本去纸张上打印，至于纸张是什么规格、怎样排版、什么时候换行等等，这些细节打印机统统不关心，我们只需要明确关联组件的接口定义，不关心具体实现，这也是所谓的“面向接口编程”。当纸张需要重新排版的时候，我们只需要修改纸张内部的代码实现，是影响不到打印机类的。这种方式达到了解耦，避免各组件之间通过编码的方式掺杂在一起。

Spring在创建Bean实例后，会调用相应的setter方法为其设置属性值，而不是由程序中的代码来主动创建和管理，改为被动地接受Spring的注入。至此，我们可以理解为，Spring依赖注入就是在它初始化时就主动将它所需要的依赖传递给它，而不是由这个类再去主动地new它所需要的组件。而且注入的方式可以很方便地管理各组件之间的关系，并且默认全是单例，省资源开销。

 三、Spring AOP

面向切面编程（Aspect Oriented Programming，AOP）是软件编程思想发展到一定程度的产物，是对面向对象编程的有益补充。AOP一般适用于具有横切逻辑的场合，如事务管理、访问控制、性能监控等。

那么，什么是横切逻辑呢？

在业务系统中，总有一些散落、渗透到系统各处且不得不处理的事情，这些穿插在既定业务中的操作就是所谓的“横切逻辑”，也称为切面。比如在一个系统中，多个业务方法中都存在相同的一部分内容：日志记录、异常处理、事务控制。这些都是保证程序健壮性的必要元素，但是重复性地编写这一段类似的代码，使得原本就比较复杂的业务体变得更加复杂，因为开发者还需要关注这些日志记录是否正常，事务是否正确控制，导致一个业务方法体内真正与业务有关的代码只有那么几行，而大量的篇幅却花在了这些事情上。针对这种情况，我们很容易想到把这些固定代码封装成一个方法体，但这样依然没有实现既定业务与横切逻辑的彻底解耦，因为在在业务代码中还是要调用这些方法，我们希望的是无须我们显式编写，在需要的时候，系统能够自动调用所需要的功能，这正是AOP要解决的问题。

面向切面编程，简单地说就是在不改变源程序的基础上为代码段增加新的功能，对代码段进行增强处理。

面向切面编程，它的编程思想来源于代理模式。什么是代理模式？代理模式就是为一个对象设置一个代理对象，在进行业务调用时调用代理对象，再由代理对象进行一些增强处理后调用真正的对象。当通过调用代理对象的代理方法时，就可以在调用原对象的方法之前或者之后进行一些额外的操作。比如，一个客户想实现一个功能，这个客户是找产品经理谈，而不是直接找程序员，产品经理就可以看作是程序员的代理对象，他根据客户的需求是否合理、工期是否可观等因素，决定是否接下这个任务并交付给程序员去实现。而在这个场景中，程序员只需要关心他所需要实现的功能，而不去直接跟客户打交道，使得自己有大量的精力运用在代码实现上。在这中设计模式下，如果我们需要在实现一个功能之前做一下判断处理，那么我们可以直接在业务层中创建一个新的业务控制类，将逻辑控制代码布置到业务控制类中，再根据环境进行判断是否调用原有业务功能即可，这样我们就可以不改变原有的代码，而是在新的代理对象上动手脚。

对面向切面编程有了感性认识后，还需要认识一下它的几个基本概念：

1、切面：一个模块化的横切逻辑（也称横切关注点），可能会横切多个对象。

2、连接点：程序执行中的某个具体执行点。如上例中原对象（非代理对象）的方法。

3、增强处理：切面在某个特定连接点上执行的代码逻辑。

4、切入点：对连接点的特征进行描述，可使用正则表达式，类似于Servlet的url-pattern，用于匹配连接点（方法）。增强处理与一个切入点表达式相关联，并在与这个切入点匹配的某个连接点运行。

5、目标对象：被一个或多个切面增强的对象。

6、AOP代理：由AOP所创建的对象，实现执行增强处理方法等功能。

7、织入：将增强处理连接到应用程序中的类型或对象上的过程，叫织入。

8、增强处理类型：在原对象的方法连接点之前插入的增强处理叫前置增强，在其之后的叫后置增强。此外还要环绕增强、异常抛出增强、最终增强等类型。

切面可以理解为由增强处理和切入点组成，既包含了横切逻辑的定义，又包含了连接点的定义。面向切面编程主要关心两个问题，即在什么位置，执行什么功能。Spring AOP是负责实施切面的框架，即由Spring AOP完成织入工作。

说了那么多，接下来就来一个简单的增强处理，在执行某个方法前后做一个日志记录。

请先准备两个依赖包aopalliance-.jar和aspectjweaver-1.6.9.jar。（其实还需要一个spring-aop-5.0.8.RELEASE.jar，只不过这个jar包在上面下载的Spring包中有）。

首先创建Service类

package AOPTest;

public class Service {
    public int doing(){
        System.out.println("这是原对象的doing()方法");
        return 1;
    }
}

创建包含增强方法的Bean组件ServiceLogger

package AOPTest;

import org.apache.log4j.Logger;
import org.aspectj.lang.JoinPoint;

import java.util.Arrays;

/**
 *  包含增强方法的JavaBean
 * */
public class ServiceLogger {
    private static final Logger log=Logger.getLogger(ServiceLogger.class);

    /**
     *  前置增强
     * */
    public void before(JoinPoint joinPoint){
        log.info("调用"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()+"方法。方法入参是："+ Arrays.toString(joinPoint.getArgs()));
    }

    /**
     *  后置增强
     * */
    public void after(JoinPoint joinPoint,Object result){
        log.info("调用"+joinPoint.getTarget()+"的"+joinPoint.getSignature().getName()+"方法。方法返回值："+result);
    }
}

在我们之前的applicationContext配置文件中添加如下内容

<bean id="theLog" class="AOPTest.ServiceLogger"/>
    <bean id="service" class="AOPTest.Service"/>
    <aop:config>
        <aop:pointcut id="pointDemo" expression="execution(public int doing())"/>
        <aop:aspect ref="theLog">
            <aop:before method="before" pointcut-ref="pointDemo"/>
            <aop:after-returning method="after" pointcut-ref="pointDemo" returning="result"/>
        </aop:aspect>
    </aop:config>

最后的测试类

package AOPTest;

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



public class ServiceTest {
    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
        Service service=(Service) context.getBean("service");
        service.doing();
    }
}

运行结果

 可以看到，我们没有在doing方法中调用ServiceLogger中的两个方法，也没有在测试类中调用，但是这两个方法却根据我们的要求分别在doing()方法的前后执行。这就是AOP，这就是增强处理，我们连显式地调用都不需要，系统会根据我们的要求在指定的地方（连接点）前或后执行相应的代码块。

上述代码中，在ServiceLogger类中的方法里，我们都传入了一个JoinPoint类型的参数，这是为了能够在增强方法中获取当前连接点的信息，比如方法名、目标对象名等，以便实施相关的判断和处理。这个参数Spring会自动为我们注入该实例，然后通过该实例的getTarget()方法可以得到被代理的目标对象，getSignature()方法返回被代理的目标方法，getArgs()方法返回传递给目标方法的参数数组。对于后置增强的方法体，还可以定义一个参数来接受目标方法所返回的值，进而做处理。

在上述的配置文件中，我们先引入包含增强方法的Bean组件，然后引入一个指向Service类的Bean，然后在<aop:config>元素中进行相关的配置。这些都是什么意思呢？我们首先使用<aop:pointcut>元素创建了一个切入点，此元素的expression属性中execution括号里的内容，即是一个表达式，是一个切入点指示符，可以配置需要增强处理的方法的特征，支持模糊匹配，主要有以下几种匹配方式：

1、public * methodName(Entity.User);  表示匹配任意返回值类型的

2、public void *(Entity.User);  表示匹配任意方法名

3、public void methodName(..);  表示匹配任意参数类型及个数的方法。

4、* com.service.*.*(..);  表示匹配com.service包下所有类的所有方法。

5、* com.service..*.*(..);  表示匹配com.service包及其子包下所有的类的所有方法。

大家可以根据自己的需要，结合着使用，当然匹配的规则和关键字还有很多，大家可以查阅开发手册。

新建了一个切入点之后，我们还要在切入点处插入增强处理，增强处理就会在切入点所匹配的方法（连接点）之前或之后执行，这个过程的专业叫法是“织入”。使用<aop:aspect>元素进行织入，此元素的ref属性引用包含增强方法的Bean，此处及为我们引入的ServiceLogger。然后在<aop:aspect>元素的子节点中插入两个元素，第一个是<aop:before>，见名知义这是前置增强标签，一般我们只写两个属性，method表示<aop:aspect>所引用的Bean中包含的方法，pointcut-ref表示此标签要关联的切入点。因为我们在后置增强方法中需要用到目标方法的返回值，所以对于后置增强我们使用<aop:after-returning>元素指定后置增强，与前置增强标签的用法一样，只不过我们需要多指定一个returning，值为result即可，注意"result"可不是一个字符串，它的真实值是目标方法的返回值。

总结

框架的东西就是需要记的东西多，而且还不能光记，还得会用，理解它的原理，每一步是干嘛的。在接下来的博文中，介绍IoC以及AOP的高级用法。