Spring中AOP和IOC深入理解

Posted 2020-08-14

                                    spring框架

 

  Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性的角度而言，绝大部分Java应用都可以从Spring中受益。

◆目的：解决企业应用开发的复杂性

◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能

◆范围：任何Java应用

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。

Spring IOC：

  控制反转（Inversion of Control,IOC）,也被称为依赖注入（Dependency Injection,DI）,是面向对象编程中的一种设计理念

  依赖注入（spring只有set访问器注入和构造注入）：

  1.set访问器注入（打印机例子）

  01.架构

  

02.引入的Jar包

03.接口及其实现类代码

package cn.ink;
/*
 * 墨盒接口
 */
public interface Ink {
    public String getColor();
}

package cn.ink;
/*
 * 灰色墨盒类
 */
public class GrayInk implements Ink{

    @Override
    public String getColor() {
        // TODO Auto-generated method stub
        return "灰色墨盒";
    }

}

package cn.ink;
/*
 * 彩色墨盒类
 */
public class ColorInk implements Ink{

    @Override
    public String getColor() {
        // TODO Auto-generated method stub
         return "彩色墨盒";
    }

}

package cn.paper;
/*
 * 纸张接口
 */
public interface Paper {
       public String getContent();
    
}

package cn.paper;
/*
 * A4纸张
 */
public class A4Paper implements Paper{

    @Override
    public String getContent() {
        // TODO Auto-generated method stub
        return  "一张淡定的A4纸";
    }

}

package cn.paper;
/*
 * B5纸张类
 */
public class B5Paper implements Paper{

    @Override
    public String getContent() {
        // TODO Auto-generated method stub
        return  "一张淡定的B5纸";
    }

}

package cn.printer;
/*
 * 打印机类
 */
import cn.ink.Ink;
import cn.paper.Paper;

public class Print {
        private Ink ink;
        private Paper paper;
         public void print(){
                System.out.println("用"+ink.getColor()+"在"+paper.getContent()+"上打印内容");
            }
        public Ink getInk() {
            return ink;
        }
        public void setInk(Ink ink) {
            this.ink = ink;
        }
        public Paper getPaper() {
            return paper;
        }
        public void setPaper(Paper paper) {
            this.paper = paper;
        }
        
}

04.Application.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd">

     <bean id="colorInk" class="cn.ink.ColorInk"/>
   <bean id="grayInk" class="cn.ink.GrayInk"/>
   <!--对Paper的初始化 -->
   <bean id="paper" class="cn.paper.A4Paper"/>
    <!-- 对打印机进行配置-->
    <bean id="printer" class="cn.printer.Print">
       <property name="ink" ref="colorInk"></property> 
       <property name="paper" ref="paper"></property>   
    </bean>
      
    </beans>
    

 

05.测试类

package cn.test;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.printer.Print;

public class PrintExam {
    @Test
    public void testprint(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Print printer = (Print)context.getBean("printer");
        printer.print();
        
    }

        
    
}

 

  2.接口注入

  3.构造注入

IOC定义和优点：

IOC(Inverse of Control)控制反转是Spring容器的内核，AOP，声明式事务等功能都是在此基础上开花结果的。所谓IOC，就是通过容器来控制业务对象之间的依赖关系，而非传统实现中，由代码直接控制。这也就是“控制反转”概念所在;控制权由应用代码转到了外部容器，控制权的转移，就是反转。控制权转移带来的好处就是降低了业务对象之间的依赖程度。

二.Spring AOP:

关于为什么要使用AOP,下面这个例子可以很好的解释。首先，按照软件重构思想的理念，如果多个类中出现相同的代码，应该考虑定义一个共同的抽象类，将这些相同的代码提取到抽象类当中去。比如Horse、Pig、Camel这些对象都有run()、eat()方法，通过引入一个包含这两个方法抽象的Animal父类，Horse、Pig、Camel就可以通过集成Animal复用到run()和eat()方法。通过引入父类消除多个类中的重复代码的方式在大多数情况下是可行的，但世界并非永远这么简单，比如下面所示的景区管理业务类。

作者：郭无心
链接：http://www.zhihu.com/question/19993030/answer/77125144
来源：知乎
著作权归作者所有，转载请联系作者获得授权。

import com.smart.dao.ViewPointDao;
import com.smart.dao.ViewSpaceDao;
import com.smart.domain.ViewSpace;

/**
 * 景区管理的服务类
 */
public class ViewSpaceService {

    private TransactionManager transManager;
    private PerformanceMonitor pmonitor;
    private ViewSpaceDao viewSpaceDao;
    private ViewPointDao viewPointDao;

    /**
     * 新增一个旅游景区
     *
     * @param viewSpace
     */
    public void addViewSpace(ViewSpace viewSpace) {
        pmonitor.start();
        transManager.beginTransaction();
        viewSpaceDao.addViewSpace(viewSpace);
        transManager.endTransaction();
        pmonitor.end();
    }


    /**
     * 删除某个景点
     *
     * @param pointId
     */
    public void deleteViewPoint(int pointId) {
        pmonitor.start();
        transManager.beginTransaction();
        viewPointDao.deleteViewPoint(pointId);
        transManager.endTransaction();
        pmonitor.end();
    }

}

其中pmonitor是方法性能监视代码，它在方法调用前启动，在方法调用返回前结束，并在内部记录性能监视的结果信息。其中transManager的代码是事务开始和事务提交的代码，我们发现我们的业务代码淹没在重复化非业务性的代码之中，性能监视和事务管理这些非业务性代码葛藤缠树搬包围着业务性代码。此时我们就不能通过抽象父类的方式消除以上的重复性代码，因为这些逻辑依附在业务类方法的流程中，它们不能够转移到其他地方去。于是产生了AOP这种思想.

  优点：AOP主要是提供另外一种编程思路，可以把类似的行为抽离出来统一处理。

总结补充：

   IOC是解耦,提供一种构造对象的方式，使得一种功能能有多种实现，且不构成依赖。spring 的IOC的缺点：占用内存多、构造对象慢、启动慢。springAOP是提供一种基于spring框架的切面编程企业级解决方案，虽然这个已经很强大，但是依然还是没有aspectj强大，比如：目前还不支持流程切面。织入慢执行效率低、不支持new关键字创建的对象的切入，必须使用bean factory织入。