spring中的IOC和AOP

最新推荐文章于 2024-04-29 16:21:54 发布

master_yao

最新推荐文章于 2024-04-29 16:21:54 发布

阅读量2k

点赞数 8

分类专栏： java 文章标签： spring IOC AOP spring中的IOC和AOP

本文链接：https://blog.csdn.net/master_yao/article/details/50152733

版权

java 专栏收录该内容

77 篇文章 0 订阅

订阅专栏

spring中的IOC和AOP

IOC（反转控制）：对成员变量的赋值的控制权从代码中反转到配置文件中。
AOP：Aspect（切面） Oriented（面向） Programming（编程），面向切面编程。
差不多就够了，再看就是Spring的事务处理，基本就这些。

IOC

我们平常使用对象的时候，一般都是直接使用关键字类new一个对象，那这样有什么坏处呢？其实很显然的，使用new那么就表示当前模块已经不知不觉的和 new的对象耦合了，而我们通常都是更高层次的抽象模块调用底层的实现模块，这样也就产生了模块依赖于具体的实现，这样与我们JAVA中提倡的面向接口面向抽象编程是相冲突的，而且这样做也带来系统的模块架构问题。很简单的例子，我们在进行数据库操作的时候，总是业务层调用DAO层，当然我们的DAO一般都是会采用接口开发，这在一定程度上满足了松耦合，使业务逻辑层不依赖于具体的数据库DAO层。但是我们在使用的时候还是会new一个特定数据库的DAO 层，这无形中也与特定的数据库绑定了，虽然我们可以使用抽象工厂模式来获取DAO实现类，但除非我们一次性把所有数据库的DAO写出来，否则在进行数据库迁移的时候我们还是得修改DAO工厂类，所以我们就思考新的方法

IOC 就是一个杯子，我们配置依赖注入就比如鱼缸里的水倒到杯子里，使得浴缸里就剩下鱼。正如model层，把逻辑业务都给 spring 了，剥离干净了model层。你的鱼要活，必须用我杯子里的水，你用其他地方新的水，鱼就死了。也就是你需要操做model对象，必须用我初始化好的方法。你自己new 你一个，只能告诉你 null异常。

IoC其实是遵循了软件设计理念的依赖倒转原则，面向对象的设计就是为了实现软件的更好的复用行和扩展性，我们就必须降低我们每个pojo的依赖关系，也就是解耦，耦合度低了，我们才能更好的重用和扩展。
Spring AOP是其实是通过动态代理来实现业务逻辑的插入，是开发者在开发是不用关注其他与业务无关的点，通过代理的方式做到了插拔式操作。

说到：Spring AOP是其实是通过动态代理来实现业务逻辑的插入

试问：AOP 能在业务逻辑方法中间插入？

DI (Dependency Injection）依赖注入

@ YJCK

IOC,也可为依赖倒置的意思,
所谓依赖，从程序的角度看，就是比如A要调用B的方法，那么A就依赖于B，反正A要用到B，则A依赖于B。
所谓倒置，你必须理解如果不倒置，会怎么着，因为A必须要有B，才可以调用B，如果不倒置，意思就是A主动获取B的实例：B b = new B()，这就是最简单的获取B实例的方法（当然还有各种设计模式可以帮助你去获得B的实例，比如工厂、Locator等等），然后你就可以调用b对象了。
所以，不倒置，意味着A要主动获取B，才能使用B；到了这里，你就应该明白了倒置的意思了。倒置就是A要调用B的话，A并不需要主动获取B，而是由其它人自动将B送上门来。

形象的举例就是：

通常情况下，假如你有一天在家里口渴了，要喝水，那么你可以到你小区的小卖部去，告诉他们，你需要一瓶水，然后小卖部给你一瓶水！

这本来没有太大问题，关键是如果小卖部很远，那么你必须知道：从你家如何到小卖部；小卖部里是否有你需要的水；你还要考虑是否开着车去；等等等等，也许有太多的问题要考虑了。也就是说，为了一瓶水，你还可能需要依赖于车等等这些交通工具或别的工具，问题是不是变得复杂了？那么如何解决这个问题呢？

解决这个问题的方法很简单：小卖部提供送货上门服务，凡是小卖部的会员，你只要告知小卖部你需要什么，小卖部将主动把货物给你送上门来！这样一来，你只需要做两件事情，你就可以活得更加轻松自在：
第一：向小卖部注册为会员
第二：告诉小卖部你需要什么

是不是和Spring的做法很类似呢？Spring就是小卖部，你就是A对象，水就是B对象
第一：在Spring中声明一个类：A
第二：告诉Spring，A需要B

假设A是UserAction类，而B是UserService类

<bean id="userService" class="org.leadfar.service.UserService"/>
<bean id="documentService" class="org.leadfar.service.DocumentService"/>
<bean id="orgService" class="org.leadfar.service.OrgService"/>

<bean id="userAction" class="org.leadfar.web.UserAction">
     <property name="userService" ref="userService"/>
</bean>

在Spring这个商店（工厂）中，有很多对象/服务：userService,documentService,orgService，也有很多会员：userAction等等，声明userAction需要userService即可，Spring将通过你给它提供的通道主动把userService送上门来，因此UserAction的代码示例类似如下所示：

<pre name="code" class="java">package org.leadfar.web;
public class UserAction{
     private UserService userService;
     public String login(){
          userService.valifyUser(xxx);
     }
     public void setUserService(UserService userService){ 
          this.userService = userService;
     }
}

在这段代码里面，你无需自己创建UserService对象（Spring作为背后无形的手，把UserService对象通过你定义的setUserService()方法把它主动送给了你，这就叫依赖注入！）

Spring依赖注入的实现技术是：动态代理

AOP

再说说AOP，即面向切面编程，面向切面编程的目标就是分离关注点。什么是关注点呢，就是你要做的事，就是关注点。假如你是个公子哥，没啥人生目标，天天就是衣来伸手，饭来张口，整天只知道玩一件事！那么，每天你一睁眼，就光想着吃完饭就去玩（你必须要做的事），但是在玩之前，你还需要穿衣服、穿鞋子、叠好被子、做饭等等等等事情，这些事情就是你的关注点，但是你只想吃饭然后玩，那么怎么办呢？这些事情通通交给别人去干。在你走到饭桌之前，有一个专门的仆人A帮你穿衣服，仆人B帮你穿鞋子，仆人C帮你叠好被子，仆人C帮你做饭，然后你就开始吃饭、去玩（这就是你一天的正事），你干完你的正事之后，回来，然后一系列仆人又开始帮你干这个干那个，然后一天就结束了！

AOP的好处就是你只需要干你的正事，其它事情别人帮你干。也许有一天，你想裸奔，不想穿衣服，那么你把仆人A解雇就是了！也许有一天，出门之前你还想带点钱，那么你再雇一个仆人D专门帮你干取钱的活！这就是AOP。每个人各司其职，灵活组合，达到一种可配置的、可插拔的程序结构。

从Spring的角度看，AOP最大的用途就在于提供了事务管理的能力。事务管理就是一个关注点，你的正事就是去访问数据库，而你不想管事务（太烦），所以，Spring在你访问数据库之前，自动帮你开启事务，当你访问数据库结束之后，自动帮你提交/回滚事务！

AOP可以说是对OOP的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
将程序中的交叉业务逻辑（比如安全，日志，事务等），封装成一个切面，然后注入到目标对象（具体业务逻辑）中去。

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码
简单点解释，比方说你想在你的biz层所有类中都加上一个打印‘你好’的功能这你经可以用aop思想来做，你先写个类写个方法，方法经实现打印‘你好’然后你Ioc这个类 ref＝“biz.*”让每个类都注入。总之让你可以让你在其他想引用这个逻辑的所有类中都可以快速调用。

上面例子介绍这么多，总而言之

从字面上的意思和理解和回答可以让自己条理清晰讲出，也可以让听者条理清楚地理解。

ioc控制反转，说的是一种操作方式，或者说是一种思想的概括，谁控制谁啦？怎么就反转了啦？要通过自己对spring的运用才能知道，spring容器控制了所有的bean，不用spring以前，一个bean要依赖另一个bean就在这个bean里初始化另一个bean才能使用另一个bean，是这个bean在控制另一个bean。现在spring容器控制所有的bean，并把另一个bean注入给这个bean。反转:是指控制bean的权利转移给容器了。

aop：面向切面编程。先了解切面，什么是我们所谓的切面？我们在什么地方切面？
当然，我们谈得是在方法上的切面，那么方法上都会有哪些切面呢？经过我们的学习，我们可以在方法的前面、后面、中间。这样有点笼统。具体是调用方法之前、调用方法返回之后、调用方法返回之前，调用方法出现异常时等等，在这些地方都可以插入自己相干的事儿，这些事儿就是切面了。

下一步，我们如何去插入我们的这些事儿呢？代理，动态代理，不管是针对接口代理，还是生成其子类代理，这些代理技术就是解决了怎么样插入切面的问题，你还有其他方式来解决如何插入切面问题吗？spring解决了这个问题，我们所要做的只是编写切面，配置切面的切入点、切面类型等……