Spring核心概念

Spring 是最受欢迎的企业级 Java 应用程序开发框架，数以百万的来自世界各地的开发人员使用 Spring 框架来创建性能好、易于测试、可重用的代码。
作为轻量级的框架，它大大简化了Java企业级开发，提供了强大、稳定的功能。它也是一个三层架构，提供了一个集成框架，在Web层有Spring MVC，在业务层有Spring Core，在持久层有Spring ORM。Spring框架的核心就是IoC（控制反转）和AOP（面向切面编程）。
Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
目的：解决企业应用开发的复杂性
功能：通过IOC和AOP等机制，能够对项目中的组件进行解耦合管理，建立一个低耦合的应用框架，并提供了更多的企业应用功能
范围：任何Java应用
它是一个容器框架，用来装javabean（java对象），中间层框架（万能胶）可以起一个连接作用。简单来说，Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

Spring IOC

理解控制反转

控制反转（Inversion of Control，IoC）也称为依赖注入（Dependency Injection，dl）是面向对象编程中的一种一种设计理念，用来程序代码之间的耦合度。

什么是依赖

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

如何使用IOC

示例：输出Hello,Spring（开发工具IDEA）

1. 导入Spring的主要依赖（jar包）

 <dependencies>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>
    </dependencies>

2. 编写HelloSpring类

package cn.bdqn.spring.IOC;

public class HelloSpring {
    public HelloSpring(){
        System.out.println("调用无参构造方法");
    }
    public String getWho() {
        return who;
    }

    public void setWho(String who) {
        this.who = who;
    }

    //定义一个who属性，该属性的值通过Spring框架进行设置
    private String who;
    public void print(){
        System.out.println("Hello"+this.getWho()+"!");
    }
}

3.编写Spring配置文件，在resources目录下创建spring.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.xsd">
    <bean id="HelloSpring" class="cn.bdqn.spring.IOC.HelloSpring">
        <property name="who">
            <value>Spring</value>
        </property>
        <!--property元素用来为实例的属性赋值，此次实际是调用了setWho()方法实现赋值操作
        而value实际是将此处的字符串“Spring”赋值给who属性
        连起来就相当于调用了setWho(Srping);-->
    </bean>
</beans>

解析
在Spring配置文件中，使用元素来定义Bean（也可称为组件）的实例。这个元素有两个常用属性:一个是id，表示定义的Bean实例的名称；另一个是class,表示定义的Bean实例的类型。
4.编写测试类：

import cn.bdqn.spring.IOC.HelloSpring;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class HelloSpringTest {
    public static void main(String[] args) {
        //通过ClassPathXmlApplicationContext实例化Spring的上下文
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        //通过ApplicationContext的getBean()方法，根据Spring配置文件配置的Bean的id来获取Bean的实例
        HelloSpring helloSpring=context.getBean("HelloSpring",HelloSpring.class);
        //也可进行强转
        //HelloSpring helloSpring=(HelloSpring)context.getBean("HelloSpring");
        helloSpring.print();
    }
}

解析
在示例中，ApplicationContext是一个接口，负责读取Spring配置文件，管理对象的加载和生成，维护Bean对象与Bean对象之间的依赖关系，负责Bean的生命周期等。ClassPathXmlApplicationContext是ApplicationContext接口的实现类，用于从classpath路径中读取Spring配置文件。
结果

Spring AOP（面向切面编程）

如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。

AOP理解为面向切面编程

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

• 将复杂的需求分解出不同方面，将公共功能集中解决
• 采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能。

什么是横切逻辑

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

什么是面向切面编程

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

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

• 增强处理（Advice）：切面在某个特定连接点上执行的代码逻辑。（简单说就是在代理类中的方法）
• 切入点（Pointcut）：对连接点的特征进行描述，可使用正则表达式，类似于Servlet的url-pattern，用于匹配连接点（方法）。增强处理与一个切入点表达式相关联，并在与这个切入点匹配的某个连接点运行。（简单说就是增强处理都有一个地点性，在哪增强，而切入点就告诉在哪增强）
• 连接点（Join Point）：程序执行中的某个具体执行点。如上例中原对象（非代理对象）的方法。（简单说就是和切入点相联系，连接点就是切入点需要切入的位置）
• 切面（Aspect）：一个模块化的横切逻辑（也称横切关注点），可能会横切多个对象。（由切入点和增强共同组成，将多个切入点连接起来就称为切面）
• 目标对象（Target object）：被一个或多个切面增强的对象。（被增强的那个类）
• AOP代理（Aop proxy）：由AOP所创建的对象，实现执行增强处理方法等功能。（代理类）
• 织入（Weaving）：将增强处理连接到应用程序中的类型或对象上的过程，叫织入。
• 增强处理类型：在原对象的方法连接点之前插入的增强处理叫前置增强，在其之后的叫后置增强。此外还有环绕增强、异常抛出增强、最终增强等类型。
  

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

aop的好处

让我们专心做事，将我们程序中的共同功能代码抽离出来，让我们只关系业务逻辑就行了。
一图胜千言：

演示简单的增强处理

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

 <dependency>
            <groupId>aopalliance</groupId>
            <artifactId>aopalliance</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

• 编写前置增强和后置增强
  先创建一个目标类目标方法

此类可以是如何类任何方法

package cn.bdqn.spring.AOP;

public class UserServiceImpl implements UserService{
    public int addUser(String Username) {
        System.out.println("目标方法");
        return 1;
    }
}

编写一个增强类

package cn.bdqn.spring.AOP;

import org.aspectj.lang.JoinPoint;

import java.util.Arrays;

/**
 * 增强类
 */
public class UserServiceLog {
    //前置增强：方法执行前执行
    public void before(JoinPoint jp){
        //JoinPoint jp参数是用来获取目标对象的一些信息
        System.out.println("进入前置增强方法");
        System.out.println("目标对象的一些信息：调用的目标对象"+jp.getTarget()+"的"+jp.getSignature().getName()+
                "方法，方法的参数是："+ Arrays.toString(jp.getArgs()));
    }
    //后置增强:方法正确执行后运行
    public void afterReturning(JoinPoint jp,Object result){
        System.out.println("进入后置增强方法");
        System.out.println("目标对象的一些信息：调用的目标对象"+jp.getTarget()+"的"+jp.getSignature().getName()+
                "方法，方法的参数是："+ Arrays.toString(jp.getArgs())+"，方法的返回值是："+result);
    }
    //最终增强：方法执行后运行（无论方法是否正确finally）
    public void after(JoinPoint jp){
        System.out.println("进入最终增强方法");
    }
    //异常抛出增强：方法出现指定异常运行
    public void afterThrowing(JoinPoint jp,Exception e){
        System.out.println("进入异增强方法："+e.getMessage());
    }
}

• 编写Spring配置文件，对业务进行增强处理

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--bean元素声明Spring创建的对象实例-->
    <!--声明目标类的bean元素（实例）-->
    <bean id="UserService" class="cn.bdqn.spring.AOP.UserServiceImpl"/>
    <!--声明增强处理类的bean元素（实例）-->
    <bean id="UserServiceLog" class="cn.bdqn.spring.AOP.UserServiceLog"/>
    <aop:config>
        <!--切入点-->
        <!--告诉Spring在哪切入 expression（连接点）告诉Spring连接谁-->
        <aop:pointcut id="pc" expression="execution(public int addUser(..))"/>
        <!--切面，告诉Spring增强谁（织入增强处理）-->
        <aop:aspect ref="UserServiceLog">
            <!--前置增强，method告诉Spring前置增强的方法是哪个，pointcut-ref引入切入点，告诉Spring切入谁（增强谁）-->
            <aop:before method="before" pointcut-ref="pc"></aop:before>
            <!--returning注入目标方法的返回值-->
            <aop:after-returning method="afterReturning" pointcut-ref="pc" returning="result"></aop:after-returning>
            <aop:after method="after" pointcut-ref="pc"/>
            <aop:after-throwing method="afterThrowing" pointcut-ref="pc" throwing="e"/>
        </aop:aspect>
    </aop:config>
</beans>

• 编写代码获取带有增强处理的业务对象

import cn.bdqn.spring.AOP.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AOPtest {
    @Test
    public void test(){
        ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
        UserService service=context.getBean("UserService",UserService.class);
        service.addUser("张三");
    }
}

解析
其中连接点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总结

从上面的示例就可以看出，业务代码和日志代码是完全分离的，经过AOP的配置以后，不做任何的修改就在目标方法前后实现了日志的输出。只需要稍微修改切入点的指示符，不仅可以为UserServiceImpl的addUser()方法增强日志功能，为所有业务方法进行增强也可以轻松实现。并且不仅可以增强日志功能，访问控制、事务管理、性能检测等等其它功能都可以。
看起来有点类似于以前用的通用类DAO相似，但是DAO还需要显试的调用，AOP就不需要显试的调用，也就可以安心的只写业务逻辑代码了不需要再管其它的了。