12.控制反转IOC与面向切面编程AOP

目录

一、IOC-控制反转。

二、AOP-面向切面编程。

---

一、IOC-控制反转。

IOC（Inversion of Control）是控制反转的缩写，指的是将对象的创建过程和依赖关系的处理交给外部容器来实现，从而实现对象之间的解耦。因此，IOC不是容器，是一种编程思想，将对象之间的依赖关系的处理从程序中转移到容器（或者其他外部实现）中，控制程序的对象创建和依赖关系的管理。而容器是实现IOC思想的一种技术手段，即通过容器来实现对象之间的解耦。因此，可以说IOC既是控制反转，也是一种容器。

当使用IoC容器时，应用程序不直接调用对象，而是通过容器请求依赖关系。下面是一个简单的示例：

服务接口：

```
public  interface  IMyService  {
        void  doSomething();
}
```

服务实现：

```
public  class  MyService  implements  IMyService  {
        @Override
        public  void  doSomething()  {
                System.out.println(  Doing  something...  );
        }
}
```

客户端类：

```
public  class  Client  {
        private  IMyService  myService;
        
        public  Client(IMyService  myService)  {
                this.myService  =  myService;
        }
        
        public  void  doSomething()  {
                myService.doSomething();
        }
}
```

使用Spring的IoC容器配置：

```
<bean id=myService class=com.example.MyService />

<bean id=client class=com.example.Client>
        <constructor-arg  ref=myService />
</bean>
```

在这个示例中，客户端类依赖于接口IMyService。通过使用IoC容器，容器创建服务对象，并将其注入到客户端类的构造函数中，从而协调对象之间的依赖关系。这种设计方法通过将依赖关系从代码中移出来，使程序易于维护和测试。

二、AOP-面向切面编程。

AOP（Aspect-Oriented  Programming）是面向切面编程，是一种软件的编程思想。它是在OOP的基础上，通过预编译方式和运行期动态代理技术实现程序功能的统一维护的技术。在AOP中，通过预编译方式和运行期动态代理技术实现程序功能的统一维护。

AOP的作用是在不修改原有类的前提下，动态地为原有类提供额外的功能，比如安全验证、事务管理、日志记录、缓存等。下面通过一个简单的代码示例说明AOP的作用：  

我们假设有一个简单的Java类，其中包含了一个add()方法：

```java
public  class  Calculator  {
        public  int  add(int  num1,  int  num2)  {
                return  num1  +  num2;
        }
}
```

现在我们需要在add()方法执行时记录方法的执行时间，并打印日志。使用AOP，我们不需要修改原有类，只需要在AOP中实现这个功能，并在运行时将其注入到Calculator类中。

```java
public  class  LogAspect  {
        public  void  logMethodExecutionTime(JoinPoint  joinPoint)  {
                long  start  =  System.currentTimeMillis();
                joinPoint.proceed();
                long  end  = System.currentTimeMillis();
                System.out.println(Method + joinPoint.getSignature().getName()  
                 + executed  in +  (end  -  start) + ms);
        }
}

public  class  Calculator  {
        public  int  add(int  num1,int  num2)  {
                return  num1+num2;
        }
}

<bean  id=  logAspect    class=  com.example.LogAspect  />

<aop:config>
        <aop:aspect  ref=  logAspect  >
                <aop:pointcut  id=  calculation    expression=  execution(*  com.example.Calculator.add(..))  />
                <aop:before  method=  logMethodExecutionTime    pointcut-ref=  calculation  />
        </aop:aspect>
</aop:config>
```

以上代码中，LogAspect类实现了在方法执行时记录执行时间的功能。通过AOP配置，我们将LogAspect注入到Calculator类中，并指定在add()方法执行前执行logMethodExecutionTime()方法。当调用Calculator的add()方法时，AOP会自动执行LogAspect中的logMethodExecutionTime()方法，并在控制台输出方法执行时间的日志信息。