面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式[通俗易懂]

您所在的位置：网站首页 › 如何理解ioc和aop › 面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式[通俗易懂]

面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式[通俗易懂]

2023-03-24 06:12| 来源: 网络整理| 查看: 265

大家好，又见面了，我是你们的朋友全栈君。

目录一、IOC与AOP介绍二、实现AOP的四种方式方式1：基于经典代理来实现方式2：使用Spring AOP的API接口方式3：自定义类来实现AOP方式4：基于注解实现一、IOC与AOP介绍

IOC 控制反转（IOC）是一种设计思想，就是将原本在程序中需要手动创建对象，现在交由Spring管理创建。举个例子，原本我们要在A类中调用B类的方法，就要直接在A中new出B类对象，然后调用B类中的方法，虽然能实现效果，不过存在一个问题，更改需求会对源代码进行修改，这是大忌。现在创建B对象就交给了Spring，在Spring中，B类对象被看成Bean对象（Spring中类就是Bean），这个Bean对象由spring容器进行创建和管理，当我们在配置文件中配置下的子元素（类的属性）时，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的话就是，这两个是一一对应的，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]：环绕通知围绕在连接点前后，比如一个方法调用的前后。 org.aspectj aspectjweaver 1.9.1 org.springframework spring-context 5.3.6 test org.springframework spring-aop 5.3.6 compile junit junit 4.12 test 方式1：基于经典代理来实现

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

public interface Sleep { void sleep(); //睡觉 }

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

public class Baby implements Sleep{ @Override public void sleep() { System.out.println("一岁小宝宝睡觉了。。。"); } }

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

import org.springframework.aop.AfterReturningAdvice; import org.springframework.aop.MethodBeforeAdvice; import java.lang.reflect.Method; public class BabyHelper implements MethodBeforeAdvice, AfterReturningAdvice { @Override public void before(Method method, Object[] objects, Object o) throws Throwable { System.out.println("睡觉前帮宝宝脱去衣服！！！"); } @Override public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable { System.out.println("起床后帮宝宝穿衣服！！！"); } }

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

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

如果切面理解还是不深，没关系，后面还有三种实现方式会一直重复切面=通知+连接点+切入点

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

public class test { //通过AOP代理的方式执行Baby的sleep()方法，会在执行前、执行后切入，实现了AOP的效果 @Test public void aoptest() { @SuppressWarnings("resource") ApplicationContext appCtx = new FileSystemXmlApplicationContext("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接口

public interface UserService { void add(); void del(); void update(); void select(); }

并写一个实现类UserServiceImpl

public class UserServiceImpl implements UserService { @Override public void add() { System.out.println("增加了一个用户"); } @Override public void del() { System.out.println("删除了一个用户"); } @Override public void update() { System.out.println("更新了一个用户"); } @Override public void select() { System.out.println("查询了一个用户"); } }

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

BeforeLog.java

import org.springframework.aop.MethodBeforeAdvice; import java.lang.reflect.Method; public class BeforeLog implements MethodBeforeAdvice { //Method：要执行目标对象的方法 //args：参数 //target：目标对象 @Override public void before(Method method, Object[] args, Object target) throws Throwable { System.out.println(target.getClass().getName()+"->方法："+method.getName()+"被执行"); } }

AfterLog.java

import org.springframework.aop.AfterReturningAdvice; import java.lang.reflect.Method; public class AfterLog implements AfterReturningAdvice { @Override public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable { System.out.println("执行了"+method.getName()+"，返回结果为："+returnValue); } }

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

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

写一个测试类进行测试

import com.yx.service.UserService; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class MyTest { public static void main(String[] args) { //加载配置文件 ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml"); //通过目标的bean id，获得代理对象 UserService proxy = (UserService)context.getBean("userService");//获取注册的bean对象，实例对象变成bean对象，就是代理对象 proxy.add(); } }

这样比第一个基于经典代理实现方式更简洁，只要两步 1、先注册实体类，实例对象就变为bean对象 2、配置aop切面，这里只要在中配置切点和通知即可，切点配合expression为表达式指定具体哪些切入方法

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

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

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

public class diyPointCut { public void before(){ System.out.println("=========方法执行前=========="); } public void after(){ System.out.println("=========方法执行后=========="); } }

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

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类中的全部方法

import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; @Aspect public class AnnotationPointCut { @Before("execution(* com.yx.service.UserServiceImpl.*(..))") public void before(){ System.out.println("==========方法执行前（注解）=========="); } @After("execution(* com.yx.service.UserServiceImpl.*(..))") public void after(){ System.out.println("==========方法执行后（注解）=========="); } }

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

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

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

下面是整体总结构

发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/150704.html原文链接：https://javaforall.cn

【本文地址】

面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式[通俗易懂]

面试官：谈谈你对IOC和AOP的理解及AOP四种实现方式[通俗易懂]

今日新闻

推荐新闻