Spring原理 - 最通俗易懂理解AOP

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，是Spring一个主要内核。
AOP与OOP是面向不同领域的两种设计思想。

• OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。
• AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。
  例如，可以对于“学生”这样一个业务实体进行封装，自然是OOP的任务，我们可以建立一个“Student”类，并将“学生”相关的属性和行为封装其中。而用AOP 设计思想对“学生”进行封装则无从谈起。但是AOP可以针对“Student”中的某个方法进行操作：
  
  还是用SpringBoot举一个简单的例子来说，例如我们首先封装了一个用户类：

//将该类加入spring容器
@Component
//lombok注解，自定义类属性的get与set方法
@Data
public class User {
    private String name;
    private Integer age;
}

然后用户的行为，我们也采用OOP思想进行封装：

//将该类加入spring容器，该类属于业务层
@Service
public class UserService {

    public void eat(User user){
        System.out.println(user.getName()+" eat .. ");
    }
}

当然，"吃"这个动作也可以封装在用户类中，但是一般项目里是将业务逻辑封装到某一个类中的，这里就按照这个约定执行吧。现在我们来测试一下：

@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class DemoApplicationTests {

    @Autowired
    private UserService userService;

    @Autowired
    private User user;

    @Test
    void contextLoads() {
        user.setName("xinxin");
        user.setAge(18);
        userService.eat(user);
    }

}

系统直接打印出：

xinxin eat .. 

那么假如代码已经写好了，但是我们要做一件事情，那就是要求所有的User对象“吃饭前洗手”，“饭后睡觉”。当然有人可能会说直接修改eat()方法中的源代码，补充进去就好。但是我不想这么做，因为“吃饭前洗手”，“饭后睡觉”其实与“吃饭”这个动作无关，我们希望做到一种解藕，不要在一类中耦合太多其他的东西。而且“吃饭前洗手”，“饭后睡觉”的要求是动态的，也许某一天学生们兴致很高，饭后并不想睡觉也说不准。于是采用AOP的思想，我们来做以下操作：

//指定为切面类
@Aspect
//将该类放入Spring容器中
@Component
public class MyAspect {
		//定义一个名为"myPointCut()"的切面，位置就在eat()这个方法中
    @Pointcut("execution(public * com.xinxin.service.UserService.eat(..))")
    public void myPointCut(){}

  	//在这个方法执行前
    @Before("myPointCut()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        Object[] objs=joinPoint.getArgs();
        User user=(User)objs[0];
        user.setAge(19);

        System.out.println(user.getName()+ " wash hands .. ");
    }

		//在这个方法执行后
    @After("myPointCut()")
    public void doAfter(JoinPoint joinPoint) throws Throwable {
        System.out.println(user.getName()+ " sleep .. ");
    }
}

再次执行测试方法:

xinxin wash hands .. 
xinxin eat .. 
xinxin sleep .. 

我们还可以定义一些切面方法，比如吃饭前学生的年龄为最初设定的18岁，假如吃饭当天为该学生的生日，吃饭时为凌晨，那么吃完饭学生就变成19岁。也可以采用aop编程来实现，为此只需要修改@before与@after即可：

    @Before("myPointCut()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        Object[] objs=joinPoint.getArgs();
        User user=(User)objs[0];
        System.out.println(user.getName()+"的年龄："+user.getAge());
        System.out.println(user.getName()+ " wash hands .. ");
    }


    @After("myPointCut()")
    public void doAfter(JoinPoint joinPoint) throws Throwable {
        Object[] objs=joinPoint.getArgs();
        User user=(User)objs[0];
      	//将年龄设为19岁
        user.setAge(19);
        System.out.println(user.getName()+"的年龄:"+user.getAge());
        System.out.println(user.getName()+" sleep .. ");
    }

于是再次执行测试方法:

xinxin的年龄：18
xinxin wash hands .. 
xinxin eat .. 
xinxin的年龄:19
xinxin sleep ..

成功的让User对象过了生日。当然Spring还为我们提供了很多切面编辑的注解，例如@Around环绕，@AfterThrowing以及@AfterReturning等等，在此不再赘述，Spring官网可以查询到很多。这里可以看出AOP编程就是可以在不影响方法业务逻辑的情况下指定切面，对切面进行业务操作。切面编程的主要应用场景有：

• Authentication（权限认证）
• Auto Caching（自动缓存处理）
• Error Handling（统一错误处理）
• Debugging（调试信息输出）
• Logging（日志记录）
• Transactions（事务处理）。

那么在Spring中是如何实现AOP编程的呢？
这里主要参考网友的理解，其实就是通过代理来实现，spring用代理类包裹切面，把他们织入到Spring管理的bean中。也就是说代理类伪装成目标类，它会截取对目标类中方法的调用，让调用者对目标类的调用都先变成调用伪装类，伪装类中就先执行了切面，再把调用转发给真正的目标bean。

那么怎么搞出来这个伪装类，才不会被调用者发现？（由于JAVA类都需要过JVM的检查，JAVA是强类型检查，哪里都要检查类型）。其实是用了两种思路：

• 实现和目标类相同的接口，我也实现和你一样的接口，反正上层都是接口级别的调用，这样我就伪装成了和目标类一样的类（实现了同一接口，咱是兄弟了），也就逃过了类型检查，到java运行期的时候，利用多态的后期绑定（所以spring采用运行时），伪装类（代理类）就变成了接口的真正实现，而他里面包裹了真实的那个目标类，最后实现具体功能的还是目标类，只不过伪装类在之前干了点事情（写日志，安全检查，事物等）。

• 生成子类调用，这次用子类来做为伪装类，当然这样也能逃过JVM的强类型检查，因为是继承的，当然查不出来了。子类重写了目标类的所有方法，当然在这些重写的方法中，不仅实现了目标类的功能，还在这些功能之前，实现了一些其他的（写日志，安全检查，事物等）的功能。