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 IoC

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

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

三、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完成织入工作。

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

        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"可不是一个字符串，它的真实值是目标方法的返回值。