面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式

目录

一、IOC与AOP介绍

IOC
控制反转（IOC）是一种设计思想，就是将原本在程序中需要手动创建对象，现在交由Spring管理创建。举个例子，原本我们要在A类中调用B类的方法，就要直接在A中new出B类对象，然后调用B类中的方法，虽然能实现效果，不过存在一个问题，更改需求会对源代码进行修改，这是大忌。现在创建B对象就交给了Spring，在Spring中，B类对象被看成Bean对象（Spring中类就是Bean），这个Bean对象由spring容器进行创建和管理，当我们在配置文件中配置

<Bean>

下的

<property>

子元素（类的属性）时，Spring就会自动执行在A中B对象的setter方法（前提要有），这样的话A对象获取B对象中的方法，由主动new，变成被动等Spring创建。主动变被动，就可以理解成控制反转，通俗讲就是“你别动，我(Spring)来做就好”，主动变被动，这样就大大降低了耦合，Spring中全都用这种思想，即依赖类不由程序员实例化，而是通过Spring容器帮我们new指定实例并且将实例注入到需要该对象的类中，Spring通过DI（依赖注入）实现IOC（控制反转）。

可以看到后面讲aop时，applicationContext.xml（Spring配置）中就体现这种思想，比如applicationContext.xml注册三个bean，也就是Spring创建了这三个类。id可以理解成变量名，class就是实现类，第一个bean可以等价于UserService userService = new UserServiceImpl(); 同理，第二个等价于Log log = new Log();

以前Person类中定义age属性，并有getAge/setAge，然后创建并赋值

Person person = new Person(); person.setAge(16);

现在换成Spring的话就是

<bean id="person" class="com.yx.entity.Person"><property name="age" value="16"></property></bean>

，这两个是一一对应的，id相当于变量名person，属性property会自动执行对应的setAge方法。Spring负责创建，这就是以前需主动创建，现在由Spring创建与管理，大大降低耦合，体现控制反转思想（主动变被动）。

AOP
面向切片编程（AOP—Aspect Oriented Programming）可以说是对OOP（面向对象编程）的补充和完善，面向对象就是将事物的特性和行为抽象为一个对象，如people类有身高、体重、年龄等属性，也有吃饭、睡觉等行为。把这些特性和行为封装成一个类，然后可以统一调用。面向切片也可以举个例子，比如people类有自己的属性和行为，但是有小一部分人生病要去医院看病，看病这个业务逻辑就不属于哪一个类，因为people泛指所有人，所有人不会都看病。AOP就是把医院看病这一个业务逻辑功能抽取出来，然后动态把这个功能切入到需要的方法（或行为）中，需要的才切入，这样便于减少系统的重复代码，降低模块间的耦合度。常用到AOP的就是安全校验、日志操作、事务操作等，给你先定义好，然后在想用的地方用，这样不会影响已经在服务器运行的项目，然后又能注入新功能，灵活。我们开发dao->service->controller是纵向的，这个AOP就是横向切入，如横向切入一个日志Log，打印执行过程。

Spring AOP就是基于动态代理实现的， 分为两种代理，jdk动态代理（基于接口）和cglib代理（基于类的）。如果目标对象实现了接口，就用jdk动态代理，如果未实现接口就用cglib动态代理。虽然动态代理可以解决耦合问题，但比较抽象，复杂，属于底层实现代理模式，我们这里直接用AOP，AOP做了很多封装，只要调用API即可，简化开发，但是AOP底层原理还是需要了解。

注意：动态代理底层利用了反射机制，反射包下Proxy类，如果想了解底层原理的，推荐这个视频 动态代理详解。

如果是面试，可以按上面文字答（图片上面的部分），比如面试官让你谈谈对IOC和AOP理解。

二、实现AOP的四种方式

首先，先要建一个maven项目，下面是pom.xml依赖和项目结构

Spring AOP支持五种类型的通知（先有个印象）：

前置通知[Before advice]：在连接点前面执行，前置通知不会影响连接点的执行，除非此处抛出异常。 
正常返回通知[After returning advice]：在连接点正常执行完成后执行，如果连接点抛出异常，则不会执行。 
异常返回通知[After throwing advice]：在连接点抛出异常后执行。 
返回通知[After advice]：在连接点执行完成后执行，不管是正常执行完成，还是抛出异常，都会执行返回通知中的内容。 
环绕通知[Around advice]：环绕通知围绕在连接点前后，比如一个方法调用的前后。

<dependencies><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.1</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.3.6</version><scope>test</scope></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-aop</artifactId><version>5.3.6</version><scope>compile</scope></dependency><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version><scope>test</scope></dependency></dependencies>

方式1：基于经典代理来实现

首先我们要先写一个Sleep接口

publicinterfaceSleep{voidsleep();//睡觉}

Baby类，Baby要睡觉，但是在冬天宝宝睡觉前要脱掉几件厚重的衣服，起床后穿上衣服，那么就可以用AOP切入

publicclassBabyimplementsSleep{@Overridepublicvoidsleep(){System.out.println("一岁小宝宝睡觉了。。。");}}

BabyHelper类，帮宝宝脱衣服的人，含前置通知和正常返回通知

importorg.springframework.aop.AfterReturningAdvice;importorg.springframework.aop.MethodBeforeAdvice;importjava.lang.reflect.Method;publicclassBabyHelperimplementsMethodBeforeAdvice,AfterReturningAdvice{@Overridepublicvoidbefore(Method method,Object[] objects,Object o)throwsThrowable{System.out.println("睡觉前帮宝宝脱去衣服！！！");}@OverridepublicvoidafterReturning(Object o,Method method,Object[] objects,Object o1)throwsThrowable{System.out.println("起床后帮宝宝穿衣服！！！");}}

有上面三个后，再定义最核心的配置文件，配置切面，application.xml

切面定义：通知、连接点、切入点共同组成了切面：时间、地点和要发生的“故事”，相当于数学里的点连成面，这里就是切点->切面。

如果切面理解还是不深，没关系，后面还有三种实现方式会一直重复

切面=通知+连接点+切入点

<beansxmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"><!-- 定义被代理者 --><beanid="baby"class="com.yx.bean.Baby"></bean><!-- 定义通知内容，也就是切入点执行前后需要做的事情 --><beanid="sleepHelper"class="com.yx.bean.BabyHelper"></bean><!-- 定义切入点位置 sleep方法前后--><beanid="sleepPointcut"class="org.springframework.aop.support.JdkRegexpMethodPointcut"><propertyname="pattern"value=".*sleep"></property></bean><!-- 使切入点与通知相关联，完成切面配置--><beanid="sleepHelperAdvisor"class="org.springframework.aop.support.DefaultPointcutAdvisor"><!--通知，前置通知before，返回通知afterReturning--><!--连接点可以认为方法调用就是一个连接点，通知就是把控切入哪个位置，切点就是具体要做的行为
        通知可以告诉这些行为在哪个位置做，连接点把这些行为连接起来--><propertyname="advice"ref="sleepHelper"></property><!--切点--><propertyname="pointcut"ref="sleepPointcut"></property></bean><!-- 设置代理 --><beanid="proxy"class="org.springframework.aop.framework.ProxyFactoryBean"><!-- 代理的对象，有睡觉能力 --><propertyname="target"ref="baby"></property><!-- 代理接口，睡觉接口 --><propertyname="proxyInterfaces"value="com.yx.bean.Sleep"></property><!-- 使用切面 即向代理对象切入--><propertyname="interceptorNames"value="sleepHelperAdvisor"></property></bean></beans>

然后我们来运行测试test.java

publicclass test {//通过AOP代理的方式执行Baby的sleep()方法，会在执行前、执行后切入，实现了AOP的效果@Testpublicvoidaoptest(){@SuppressWarnings("resource")ApplicationContext appCtx =newFileSystemXmlApplicationContext("application.xml");Sleep baby =(Sleep) appCtx.getBean("proxy");//获取代理对象，application.xml定义了id="proxy"的bean对象
        baby.sleep();}}

如下，就成功在sleep()前后切入两个行为

上面我们就应该对AOP具体实现有了初步理解，这是最经典的，也是最接近原理的配置，就是先配置切点、通知，然后才能组成切面，再使用配置好的切面向代理对象切入，通知把控切入位置，前面还是后面，切点就是要切入的具体内容

下面我们再写一个类似案例，作为巩固

方式2：使用Spring AOP的API接口

然后再新建一个Maven项目，pom文件还是用上面一样，创建service包，并在其中写一个业务UserService，用户可以进行增删改查，我们一样先给出整体结构

UserSerivce接口

publicinterfaceUserService{voidadd();voiddel();voidupdate();voidselect();}

并写一个实现类UserServiceImpl

publicclassUserServiceImplimplementsUserService{@Overridepublicvoidadd(){System.out.println("增加了一个用户");}@Overridepublicvoiddel(){System.out.println("删除了一个用户");}@Overridepublicvoidupdate(){System.out.println("更新了一个用户");}@Overridepublicvoidselect(){System.out.println("查询了一个用户");}}

再写一个Log包，里面写日志，就是需要新增的功能，实际开发中常常也需要切入安全校验，日志操作和事务操作，写一个前置一个后置

BeforeLog.java

importorg.springframework.aop.MethodBeforeAdvice;importjava.lang.reflect.Method;publicclassBeforeLogimplementsMethodBeforeAdvice{//Method：要执行目标对象的方法//args：参数//target：目标对象@Overridepublicvoidbefore(Method method,Object[] args,Object target)throwsThrowable{System.out.println(target.getClass().getName()+"->方法："+method.getName()+"被执行");}}

AfterLog.java

importorg.springframework.aop.AfterReturningAdvice;importjava.lang.reflect.Method;publicclassAfterLogimplementsAfterReturningAdvice{@OverridepublicvoidafterReturning(Object returnValue,Method method,Object[] args,Object target)throwsThrowable{System.out.println("执行了"+method.getName()+"，返回结果为："+returnValue);}}

resources包进行相关配置，包括注册bean，配置切面

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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
       http://www.springframework.org/schema/aop/spring-aop.xsd"><!--注册bean，将所有的实体类先注册--><beanid="userService"class="com.yx.service.UserServiceImpl"></bean><beanid="beforeLog"class="com.yx.log.BeforeLog"></bean><beanid="afterLog"class="com.yx.log.AfterLog"></bean><!--配置aop切面--><aop:config><!--切入点 expression为表达式，参数为切入的位置，UserServiceImpl.*表示类中所有方法都切入，*(..)两个点表示不指定参数（任意）--><aop:pointcutid="pointcut"expression="execution(* com.yx.service.UserServiceImpl.*(..))"/><!--配置类切入到哪里:如beforeLog类切入到expression表达式指的位置，即UserServiceImpl类下的所有方法--><aop:advisoradvice-ref="beforeLog"pointcut-ref="pointcut"/><aop:advisoradvice-ref="afterLog"pointcut-ref="pointcut"/></aop:config></beans>

用Spring AOP的API接口进行切入的好处就是，他会自动帮你创建和管理类，不用亲自和以前一样new对象，这样可以实现解耦，因为你只要设置目标类路径即可，然后无论类怎么变都无需进行改动，上面就可以把beforeLog和afterLog切入到UserServiceImpl所有方法中。

写一个测试类进行测试

importcom.yx.service.UserService;importorg.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext;publicclassMyTest{publicstaticvoidmain(String[] args){//加载配置文件ApplicationContext context =newClassPathXmlApplicationContext("applicationContext.xml");//通过目标的bean id，获得代理对象UserService proxy =(UserService)context.getBean("userService");//获取注册的bean对象，实例对象变成bean对象，就是代理对象
        proxy.add();}}

这样比第一个基于经典代理实现方式更简洁，只要两步
1、先注册实体类，实例对象就变为bean对象
2、配置aop切面，这里只要在

<aop:config></aop:config>

中配置切点和通知即可，切点配合expression为表达式指定具体哪些切入方法

再回顾一下这两步，是不是精简许多

<!--1、注册bean，将实体类注册--><beanid="userService"class="com.yx.service.UserServiceImpl"></bean><beanid="beforeLog"class="com.yx.log.BeforeLog"></bean><beanid="afterLog"class="com.yx.log.AfterLog"></bean><!--2、配置AOP切面--><aop:config><!--切入点 expression为表达式，参数为切入的位置，UserServiceImpl.*表示类中所有方法都切入，*(..)两个点表示不指定参数（任意）--><aop:pointcutid="pointcut"expression="execution(* com.yx.service.UserServiceImpl.*(..))"/><!--配置类切入到哪里:如beforeLog类切入到expression表达式指的位置，即UserServiceImpl类下的所有方法--><aop:advisoradvice-ref="beforeLog"pointcut-ref="pointcut"/><aop:advisoradvice-ref="afterLog"pointcut-ref="pointcut"/></aop:config>

方式3：自定义类来实现AOP

在创建一个Diy包，在其中自定义一个类diyPointCut，类中定义要切入的方法

publicclass diyPointCut {publicvoidbefore(){System.out.println("=========方法执行前==========");}publicvoidafter(){System.out.println("=========方法执行后==========");}}

applicationContext1.xml配置文件，和方式1类似，但稍微有不同，不同就是自定义注册

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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
       http://www.springframework.org/schema/aop/spring-aop.xsd"><!--注册bean--><beanid="userService"class="com.yx.service.UserServiceImpl"></bean><beanid="diy"class="com.yx.Diy.diyPointCut"></bean><aop:config><!--自定义切面--><aop:aspectref="diy"><!--切入点--><aop:pointcutid="point"expression="execution(* com.yx.service.UserServiceImpl.*(..))"/><!--通知（指定diyPointCut类中的哪个method，aop:before就表示前置）--><aop:beforemethod="before"pointcut-ref="point"></aop:before><aop:aftermethod="after"pointcut-ref="point"></aop:after></aop:aspect></aop:config></beans>

MyTest改成加载

applicationContext1.xml

并运行，结果如下

自定义的好处：可以直接在一个自定义类中定义切入的多个方法，并且不用实现对应接口，比如之前的用API接口的实现方式，还要去写用了什么通知，前置通知还是后置通知，但这里不用了，如下图

implements MethodBeforeAdvice

和

implements AfterReturningAdvice

这里自定义就不用去实现了，直接用

aop:before

或者

aop:after

就可以表示用了什么通知，只要在自定义类中定义需要切入的方法即可，如此处diyPointCut自定义类就定义了before和after这两个普通方法

上面这样就更简便了，能不能更简便一点，能！！！注解大法来了，我们开发中常用的什么@AutoWired，@Controller注解，都是编译自动帮你做了注册bean等操作，虽然开发可以这么做，但是我们最好还是要知道原理，不能仅仅做个调接口的程序员。

方式4：基于注解实现

新增一个注解类，@Aspect表示切面，@Before表示前置通知，@After表示后置通知，通知结合

execution(* com.yx.service.UserServiceImpl.*(..))

表示对类中哪些方法有通知，这里指的是UserServiceImpl类中的全部方法

importorg.aspectj.lang.annotation.After;importorg.aspectj.lang.annotation.Aspect;importorg.aspectj.lang.annotation.Before;@AspectpublicclassAnnotationPointCut{@Before("execution(* com.yx.service.UserServiceImpl.*(..))")publicvoidbefore(){System.out.println("==========方法执行前（注解）==========");}@After("execution(* com.yx.service.UserServiceImpl.*(..))")publicvoidafter(){System.out.println("==========方法执行后（注解）==========");}}

本质还是扫描到注解以后，就会转成类似方式3的配置文件，@Before(切点)
applicationContext2.xml只需要注册bean，开启注解即可

<?xml version="1.0" encoding="UTF-8"?><beansxmlns="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
       http://www.springframework.org/schema/aop/spring-aop.xsd"><!--注册bean--><beanid="userService"class="com.yx.service.UserServiceImpl"></bean><beanid="annotationPointCut"class="com.yx.Diy.AnnotationPointCut"></bean><!--开启注解支持，会自动扫描注解--><aop:aspectj-autoproxy/></beans>

MyTest修改加载的配置文件，改成

applicationContext2.xml

至此四种方式都讲解完毕，我们常常用最后一种，因为基于注解来写，真的太简单了！！！

下面是整体总结构