IOC和AOP是什么

转载：https://blog.csdn.net/qq_38735934/article/details/81074852  作者：星星点灯ht 

 

IOC

定义：
IOC（Inverse of Contro）控制反转，有时候也被称为DI依赖注入，它是一种降低对象耦合关系的一种设计思想。

 1.概念引入：
      1.1一般而言，在开发中使用分层体系结构，都是上层调用下层的接口，上层依赖下层的执行，这就使得调用者依赖被调用者。所以现在调用者和被调用者之间就存在紧密的联系，假如现在一方要进行变动，那么就会导致程序出现较大得变动，显然这不合适，这样降低了程序的可扩展性。

      举个例子：现在要给一家卖茶叶商家做一个管理系统：该商家一开始只卖绿茶，但是现在业务扩展了要开始卖红茶，传统的方法我们会针对茶抽象出一个基类，绿茶只需要继承该基类即可。

采用上面的方法实现后，在需要GreenTea的时候只需要执行以下的代码即可，AbstracTea tea = new GreenTea(); 虽然这种方式是可以满足设计要求的，但是明显存在可扩展性不好的缺点，假如现在商家发现绿茶销售不好，开始销售红茶，那么理论上是只需要实现一个Black类，并且让这个类继承AbstracTeam类即可，但是，系统中所有用到了AbstracTea tea = new GreenTea();的地方都需要改编成AbstracTea tea = new BlackTea();而这种创建实例的方式往往会导致程序的改动量非常的大。

1.2那么问题来了，怎么做才能够增强系统的可扩展性呢?首先我们能想到的方式是采用工厂模式把创建对象的行为包装起来：

通过上面的方式，我们把创建对象的过程委托给TeaFactory来完成，在需要使用Tea对象的时候只需要调用工厂类的gettea方法即可，具体创建对象的逻辑我们放在工厂累类中去实现，当商家需要改变茶的类别时候，我们只需要去改动工厂类中创建对象的逻辑即可，这样就满足了系统的可扩展性。

 

IOC的使用

上面提到的工厂模式虽然增强了系统的可扩展性，但是从本质上来讲，工厂模式只不过是把会变动的逻辑移动到了工厂类里里面，当系统类较多的时候，系统的扩展就使得系统经常需要改变工厂类中的代码，但是我们采用了IOC设计思想后，程序就会有更好的可扩展性：

Spring容器将会根据配置文件来创建调用者对象，同时把被调用的对象的实例化对象通过构造函数或者set()方法的形式注入到调用者对象当中。

首先创建Spring的配置文件

<beans>
   <bean id = "sale" class = "Sale" singleton = "false">
      <constrctor-arg>
           <ref bean = "tea"/>
      </constrctor-arg>
   </bean>
   <bean id = "tea" class = "Bluetea" singleton = "false"/>
</beans>

在实现sale类的时候，需要按照下面的方式进行：

class Sale{
   
    private AbstracTea tea;
    public Sale(AbstracTea tea){
       this.tea = tea;
     }
}

当spring容器创建sale对象的时候，就会根据配置文件创建一个BlueTea对象，作为Sale构造函数的参数。当需要把BlueTea改成BlackTea时，只需要修改上述配置文件，而不需要修改代码。

需要使用Sale时候，可以通过下面的方式来创建sale对象：

ApplicationContext ttt = new FileSystemXmlApplicationContext("配置文件");
Sale s = （Sale）ctx.getBean（"sale"）;

spring采用IOC的方式来实现把实例化的对象注入到开发人员自定义的对象中，具有强的扩展性。

 

IOC总结

优点：

• 通过IOC容器，开发人员不需要关注对象是如何创建的，同时增加新类也非常方便，只需要修改配置文件即可实现对象的热插拔。
• IOC容器可以通过配置文件来确定需要注入的实例化对象，因此非常便于进行单元测试。

缺点：

• 对象是通过反射机制实例化出来的，因此对系统的性能有一定的影响。
• 创建对象的流程变的复杂。
   

AOP

概念：AOP面向切面编程，是面向对象开发的一种补充，它允许开发人员在不改变原来模型的以满足新的需求，例如，开发人员可以在不改变原来业务逻辑模型的基础可以进行动态的增加日志，安全或异常处理功能。

面向切面编程，一种横向抽取机制，依赖于动态代理模式。包含：

              JoinPoint：连接点，就是可以被增强的方法。

              PointCut：切入点，对哪些JoinPoint进行拦截。

              Advice：通知，就是拦截后的动作。

              Aspect：切面，把增强应用到具体的方法的过程。

              Spring的AOP需要通过XML来实现，可以通过XML，也可以通过注解来完成。

              实际开发中，对于AOP最常用的就是事务了。

例子：

1.创建一个接口以及实现这个接口的类。

public interface TestAOPIn{
 
     public void doSomething();
}

public class TestAOPImpl implements TestAOPIn{
 
   public void doSomething(){
 
      System.out.println("TestAOPImp:doSomething");
     }
 
}

2.配置文件，使得这个类的实例化对象可以被注入到使用这个对象的Test类当中。

<?xml version = "1.0" encoding = "utf-8"?>
 
<DOCTYPE beans PUBLIC " -//SPING//DTD BEAN//EN" "http//www.springframework.org/dtd/spring-beans.dtd">
 
<beans>
       <bean id = "testAOPBean" class = "org.springframework.aop.framework.ProxyFactoryBean">
             <property name = "target">
                     <bean class = "testAOPIn" singleton = "false"/>
             </property>
       </bean>
</beans>

3.完成配置文件后，编写测试代码：

public class Test{
 
       public static void mian(String []args){
          
             ApplicationContext ctx = new FileSystemXmlAppicationContext("配置文件");
             TestAOPIn t = (TestAOPIn)ctx.getBean(testAOPBean);
             t.dosomething();      
 
       }
 
}

运行程序后我们会发现程序的输出结果是：TestAOPImp:doSomething