深入认识Spring两大特性IOC和AOP

众所周知，Spring有两大特性：Ioc和Aop。

IOC:英文全称是Inversion of Control，意为控制反转/依赖注入。

AOP:英文全称是Aspect-Oriented Programming，意为面向切面编程。

总的来说，Spring是一个轻量级的控制反转(Ioc)和面向切面编程(Aop)的容器框架.

Spring常用注解

注解名称	备注
@Controller	标注控制层
@Service	标注服务层
@Component	标注此类是Spring管理的组件
@Autowired	按类型自动装配
@Resource	按名称自动装配

控制反转ioc

通常我们实例化一个对象时，都是使用类的构造方法new一个对象，这个过程是我们自己来控制的，而ioc是把new对象的工作交给了Spring容器。

依赖注入

Spring依赖注入的方式主要有4个:基于注解注入方式、set注入方式、构造器注入、静态方法注入。目前大都使用的是注解注入，配置少，比较方便。

基于注解注入示例

控制层

@Controller
public class UsersController {
    @Autowired
    private UsersService usersService;
}

我们可以使用@Autowired或@Resource来装配bean，它们的区别在于：

@Autowired默认按类型自动装配，默认要求依赖对象必须存在，如果要允许为Null，需设置required = false

@Controller
public class UsersController {
    @Autowired(required = false)
    private UsersService usersService;
}

@Resource默认按名称自动装配，名称可以通过name属性来指定，如果不指定，当注解写在字段上，默认取字段名进行装配；

如果写在setter方法上，默认取属性名进行装配。当找不到与名称相匹配的Bean时，会按照类型进行装配。

服务层

@Service
public class UsersServiceImpl implements UsersService {
}

面向切面aop

面向切面编程，通俗的讲共有功能的实现。

比如：每个接口都会调用方法，我们想记录这些调用返回的信息，不需要每一个都进行日志或其他方式记录，通过aop的概念，处理一次即可。

aop通知类型

注解名称	备注
@Before	前置通知，在方法调用前执行
@After	后置通知，在方法调用后执行
@Around	环绕通知，包裹了被通知的方法，在被通知的方法调用之前之后执行自定义的行为。
@AfterReturning	返回通知，目标方法成功执行后调用通知
@AfterThrowing	异常通知，在目标方法抛出异常后调用通知

@Pointcut语法

任意公共方法的执行： 
execution(public * *(..)) 
任何一个以“set”开始的方法的执行： 
execution(* set*(..)) 
AccountService 接口的任意方法的执行： 
execution(* com.xyz.service.AccountService.*(..)) 
定义在service包里的任意方法的执行： 
execution(* com.xyz.service.*.*(..)) 
定义在service包和所有子包里的任意类的任意方法的执行： 
execution(* com.xyz.service..*.*(..))

使用Aop

第一步：引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

创建一个类

@Log4j2
@Aspect
@Component
public class AopTest {
    /**
     * 指定切入点（可以是方法）
     * service下所有的方法
     */
    @Pointcut("execution(* com.ssw.core.service.*.*(..))")
    public void aopTest(){}

    /**
     * 前置通知
     * @param joinPoint
     */
    @Before("aopTest()")
    public void doBefore(JoinPoint joinPoint){
        log.info("即将进入方法:{}",joinPoint.getSignature().getName());
        List<Object> params=Arrays.asList(joinPoint.getArgs());
        log.info("输入参数为:{}",params);
    }

    /**
     * 后置通知
     * @param joinPoint
     */
    @After("aopTest()")
    public void doAfter(JoinPoint joinPoint){
        log.info("执行完成方法:{}",joinPoint.getSignature().getName());
    }
}

写一个get的测试方法

输入参数在进行输出，调用查看下效果

接下来重点介绍下@Around，环绕通知，该方法可以包含@Before、@After、@AfterThrowing、@AfterRunning。

环绕通知的功能最全面，需要携带ProceedingJoinPoint 类型的参数，且必须有返回值，返回值为目标方法的返回值。

示例如下：

/**
     * 环绕通知
     * @param joinPoint
     * @return
     */
    @Around("aopTest()")
    public Object doAround(ProceedingJoinPoint joinPoint){
        //返回结果
        Object result=null;
        String methodName=joinPoint.getSignature().getName();
        //1.前置通知
        log.error("前置通知=====>方法名：{}，方法参数：{}",methodName,Arrays.asList(joinPoint.getArgs()));
        //执行目标方法
        try {
            result=joinPoint.proceed();
            //2.返回通知方法
            log.error("返回通知=====>返回结果：{}",result);
        } catch (Throwable throwable) {
            //3.异常通知方法
            log.error("异常通知=====>方法名：{}",methodName);
            throwable.printStackTrace();
        }
        //4.后置通知
        log.error("后置通知=====>{}",methodName);
        return result;
    }

调用方法