一、概念解析(AOP & IOC/DI)

本文主要是通过代码实现Spring Boot中的IOC和AOP配置。这里的AOP和IOC是属于Spring容器框架的范畴。和SpringBoot关系不大，因为Spring Boot的初中是整合简化了Spring和Spring MVC的开发。

1、关于IOC/DI的概念分析(简单全面)

　Ioc—Inversion of Control，即“控制反转”，不是什么技术，而是一种设计思想。在Java开发中，Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。如何理解好Ioc呢？理解好Ioc的关键是要明确“谁控制谁，控制什么，为何是反转（有反转就应该有正转了），哪些方面反转了”，那我们来深入分析一下：

　　●谁控制谁，控制什么：传统Java SE程序设计，我们直接在对象内部通过new进行创建对象，是程序主动去创建依赖对象；而IoC是有专门一个容器来创建这些对象，即由Ioc容器来控制对 象的创建；谁控制谁？当然是IoC 容器控制了对象；控制什么？那就是主要控制了外部资源获取（不只是对象包括比如文件等）。

　　●为何是反转，哪些方面反转了：有反转就有正转，传统应用程序是由我们自己在对象中主动控制去直接获取依赖对象，也就是正转；而反转则是由容器来帮忙创建及注入依赖对象；为何是反转？因为由容器帮我们查找及注入依赖对象，对象只是被动的接受依赖对象，所以是反转；哪些方面反转了？依赖对象的获取被反转了。

2、关于AOP的概念解析 

什么是AOP

AOP（Aspect-Oriented Programming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即切面。所谓“切面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用拦截方法的方式，对该方法进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“切面”，从而使得编译器可以在编译期间织入有关“切面”的代码。

AOP相关概念

为了更好的理解AOP，我们有必要先了解AOP的相关术语。

切面（Aspect）

横切关注点的模块化（跨越应用程序多个模块的功能，比如 日志功能），这个关注点实现可能另外横切多个对象。

连接点（Join point）

连接点是在应用执行过程中能够插入切面的一个点。这个点可以是类的某个方法调用前、调用后、方法抛出异常后等。切面代码可以利用这些点插入到应用的正常流程之中，并添加行为。

通知（Advice）

在特定的连接点，AOP框架执行的动作。

Spring AOP 提供了5种类型的通知：

• 前置通知（Before）：在目标方法被调用之前调用通知功能。
• 后置通知（After）：在目标方法完成之后调用通知，无论该方法是否发生异常。
• 后置返回通知（After-returning）：在目标方法成功执行之后调用通知。
• 后置异常通知（After-throwing）：在目标方法抛出异常后调用通知。
• 环绕通知（Around）：通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。

切点（Pointcut）

指定一个通知将被引发的一系列连接点的集合。AOP 通过切点定位到特定的连接点。切点和连接点不是一对一的关系，一个切点匹配多个连接点，切点通过 org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。每个类都拥有多个连接点，例如 ArithmethicCalculator类的所有方法实际上都是连接点。

引入（Introduction）

添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。Spring中要使用Introduction, 可有通过DelegatingIntroductionInterceptor来实现通知，通过DefaultIntroductionAdvisor来配置Advice和代理类要实现的接口

目标对象（Target Object）

包含连接点的对象。也被称作被通知或被代理对象。

AOP代理（AOP Proxy）

AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

织入(Weaving)

织入描述的是把切面应用到目标对象来创建新的代理对象的过程。 Spring AOP 的切面是在运行时被织入，原理是使用了动态代理技术。Spring支持两种方式生成代理对象：JDK动态代理和CGLib，默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。

二、在项目中SpringBoot中式如何去配置IOC的 

这里标题可能有点会产生歧义，这里旨在介绍在项目开发中是如何配置IOC的(注重的是功能使用，而不是Spring Boot底层的源码阅读)。
 

1、概念扩展：在Spring&Spring中我们式如何注册Bean的？ 

在使用Spring,Spring MVC中我们使用通常头两种方式

1、基于XML的配置方式；

打个比方: 假如使用Spring基于XML的配置的话，开发的基本流程就是: Java Bean实体编写——>XML（配置Bean）。

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

2、基于注解的方式配置；

举个例子: 假如使用基于注解的配置方式的话，首先需要在Spring配置文件中开启注解扫描，当然也可以写Java配置文件，添加@Configuration用于开启注解扫描。这里方便起见就使用配置文件(XML)的方式做演示。然后开启注解扫描也有两种不同的配置方式：

而自动装配实现就需要注解扫描，这时发现了两种开启注解扫描的方式，即**context:annotation-config/和context:component-scan**

<context:annotation-config>:注解扫描是针对已经在Spring容器里注册过的Bean

<context:component-scan>:不仅具备<context:annotation-config>的所有功能，还可以在指定的package下面扫描对应的bean

 在以上配置文件中开启注解扫描机制之后呢，以后的Bean可开发就可以直接使用注解的方式定义Bean了(@Service)。使用@Autowired注入已经注册的Bean。前提条件就是要保证添加注解的package在XML配置的包内，否则可能导致Bean未注册的情况。

2、SpringBoot默认扫描路径问题：

一般来说spring boot默认的扫描路径是启动类当前的包和子包。不在自动扫描路径下，需要修改自定义扫描包路径。

@SpringBootApplication
@EnableTransactionManagement(proxyTargetClass = true)
@MapperScan(basePackages = {"com.frame.springboot.dao", "com.frame.springboot.base"})
public class SpringbootApplication {
 
 
    public static void main(String[] args) {
 
        SpringApplication app = new SpringApplication(SpringbootApplication.class);
        app.addListeners(new MyApplicationStartedEventListener());
        app.run(args);
 
    }
 
    static class MyApplicationStartedEventListener implements ApplicationListener<ApplicationStartedEvent> {
        private Logger logger = LoggerFactory.getLogger(MyApplicationStartedEventListener.class);
 
        @Override
        public void onApplicationEvent(ApplicationStartedEvent event) {
            SpringApplication app = event.getSpringApplication();
            app.setBannerMode(Banner.Mode.OFF);// 不显示banner信息
            logger.info("==MyApplicationStartedEventListener==");
        }
    }
 
}

 例如以上这个类的包和子类。

3、自定义SpringBoot包扫描路径问题： 

在Spring中默认Bean注解扫描路径是当前启动类所在的包下和同级目录下。但是当我们需要自定义包扫描路径的时候可以使用下面的注解配置basePackages属性指定。

@ComponentScan(basePackages = {"com.xxx.service1.*","com.xxx.service2.**"})

 如下是一个自己写的Demo的例子：
package com.xcy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;
import org.springframework.context.annotation.Configuration;

/**
 * Maven命令行创建Spring Boot项目启动类
 *
 */
@Configuration
@SpringBootApplication
@ComponentScan(basePackages = {"com.xcy.**"})
public class App 
{
    public static void main( String[] args )
    {
        System.out.println( "Hello World!" );
        SpringApplication.run(App.class,args);
    }
}

 三、在项目中SpringBoot中式如何去配置AOP的

针对AOP的配置方案有两种；

1、第一种: 包路径扫描

第一种方式是针对包的位置进行代理，编写切点，切面，通知等一步一步的操作。

execution(public * com.xcy..*.*(..))

 2、第二种: 请求方式(格式)

针对请求方式，比如RequestMapping，PostMapping，GetMapping。以下的代码就是针对该种方式进行操作写的一个环绕通知，一步解决AOP代码问题。

主要实现代码如下:

package com.xcy.config;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;

@Aspect
@Component
@Slf4j
public class BaseAspect {
    @Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)"
            + " || @annotation(org.springframework.web.bind.annotation.PostMapping)"
            + " || @annotation(org.springframework.web.bind.annotation.GetMapping)"
            + "")
    public Object api(ProceedingJoinPoint joinPoint) {
        long startTime = System.currentTimeMillis();
        String method = joinPoint.getTarget().getClass().getSimpleName() + "." + joinPoint.getSignature().getName();
        // 调用接口方法
        Object response = null;
        try {
            Object body = joinPoint.getArgs().length > 0 ? joinPoint.getArgs()[0] : null;
            String jsonBody = StringUtils.isEmpty(body)?"请求参数为空":body.toString();
            log.info("Api接口Start：{}，输入参数：{}",method,jsonBody);
            response = joinPoint.proceed();
            log.info("Api接口End：{}，返回参数：{}",method,JSON.toJSON(response));
            long endTime = System.currentTimeMillis();
            log.info("程序运行时间：{}",(endTime - startTime) + "ms");
        } catch (Throwable e) {
            e.printStackTrace();
            log.info("Api接口Error：{}，Cause：{}",method,e);
            return e.toString();
        } finally {

        }
        return response;
    }
}