SpringIOC&AOP

Spring是为简化企业级系统开发而诞生的，Spring框架为J2EE应用常见的问题提供了简单、有效的解决方案，使用Spring，你可以用简单的POJO(Plain Old Java Object)来实现那些以前只有EJB才能实现的功能。这样不只是能简化服务器端开发，任何Java系统开发都能从Spring的简单、可测试和松耦合特征中受益。可以简单的说，Spring是一个轻量级的反向控制（IoC）和面向切面编程（AOP）容器框架[3]。Spring IoC，借助于依赖注入设计模式， 使得开发者不用理会对象自身的生命周期及其关系，而且能够改善开发者对J2EE模式的使用；Spring AOP，借助于Spring实现的拦截器，开发者能够实现以声明的方式使用企业级服务，比如安全性服务、事务服务等。Spring IoC和 Spring ; AOP组合，一起形成了Spring，这样一个有机整体，使得构建轻量级的J2EE架构成为可能，而且事实证明，非常有效。没有Spring IoC的Spring AOP是不完善的，没有Spring AOP的Spring IoC是不健壮的。本文是以Spring架构的成功的实际商务系统项目为背景，阐述了反向控制原理和面向切面的编程技术在Spring框架中的应用，同时 抽取适量代码示意具体应用，并和传统开发模式进行对比，展示了Spring framework的简单，高效，可维护等优点。

1、Spring IoC 1.1 反向控制原理

　　反向控制是Spring框架的核心。但是，反向控制是什么意思？到底控制的什么方面被反向 了呢？2004年美国专家Martin Fowler发表了一篇论文《Inversion of Control Containers and the Dependency Injection pattern》阐述了这个问题，他总结说是获得依赖对象的方式反向了，根据这个启示，他还为反向控制提出了一个更贴切的名字：Dependency Injection(DI 依赖注入)。

　　通常，应用代码需要告知容器或框架,让它们找到自身所需要的类,然后再由应用代码创建待使 用的对象实例。因此，应用代码在使用实例之前，需要创建对象实例。然而，IoC模式中,创建对象实例的任务交给IoC容器或框架(实现了IoC设计模式的 框架也被称为IoC容器)，使得应用代码只需要直接使用实例，这就是IoC。相对IoC 而言，“依赖注入”的确更加准确的描述了这种设计理念。所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关 系注入到组件之中。

　　1.2 IoC在Spring中的实现

　　任何重要的系统都需要至少两个相互合作的类来完成业务逻辑。通常，每个对象都要自己负责得 到它的合作（依赖DI）对象。你会发现，这样会导致代码耦合度高而且难于测试。使用IoC，对象的依赖都是在对象创建时由负责协调系统中各个对象的外部实体提 供的，这样使软件组件松散连接成为可能。

　　DI依赖注入
　　　　DI（依赖注入）是IoC实现的重要技术，有如下2中方式：
　　　　1) setter方式注入

      2) 构造方式注入
　　　   3)接口注入(不是很常用，这里就不讲了)

　　4)注解注入
　　　　注入类型有如下几种：简单值、集合、bean对象 Ioc和DI的关系？ 我们认为Spring是具有IoC特性的框架。 实现IoC是由Spring容器来完成的，Spring容器通过依赖注入DI建立　　　　起对象（组件、Bean） 乊间的关系。 我们可以这样理解：DI是IoC实现的一种手段，Ioc通过DI来实现。下面示意了Spring IoC 应用，步骤如下：

定义一个接口Dao.java

package Dao;

public interface Dao {
    public void say();
}

　　一个Dao的实现类StuDaoImpl.java

package Dao.Impl;

import Dao.Dao;

public class StuDaoImpl implements Dao{

    public void say() {
        System.out.println("我是学生");
        
    }
}

一个Dao的实现类TeaDaoImpl.java

package Dao.Impl;

import Dao.Dao;

public class TeaDaoImpl implements Dao{

    public void say() {
      System.out.println("我是老师");
        
    }
    
}

一个Service的Say方法

package Dao.Service;

import Dao.Dao;

public class Say {
    private Dao tea;

    public void setTea(Dao tea) {
        this.tea = tea;
    }
    /*public Say(Dao tea){//构造器注入的时候用
        this.tea=tea;
    }*/
    public void saywork(){
        tea.say();
    }
}

一个测试类Test.java

package Test;

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

import Dao.Service.Say;


public class test {
    public static void main(String[] args) {
        String conf="applicationContext.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(conf);
        Say say=(Say)ac.getBean("say");
        say.saywork();
    }
}

SPring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans default-lazy-init="true">
    
    <bean id="student"
        class="Dao.Impl.StuDaoImpl"    >
    </bean>
    <bean id="teacher"
        class="Dao.Impl.TeaDaoImpl"    >
    </bean>
    <bean id="say" class="Dao.Service.Say">
        <property name="tea" ref="teacher"></property><!--setter注入法-->
        <!--<constructor-arg index="0" ref="teacher"></constructor-arg><!--构造器注入法-->
        </bean>
</beans>

最后因为id=teacher通过<property name="tea" ref="teacher"></property>注入到say类中，所以程序输出“我是老师”

如果想输出"我是学生"那么直接改一下配置文件就好了，不需要改动源文件的内容。

注解方式配置

常用配置方式有XML文档配置，还有一种是通过注解方式配置。 采用注解方式的目的就是为了简化XML配置文件。 注解方式（也叫注释）是JDK5版本提供的，之前的版本丌支持。 Spring2.5版本后支持注解方式，之前的版本不支持。

组件自动扫描功能
首先需要在applicationContext.xml中添加<context:component-scan/>

1) 扫描Bean组件的注解，替代xml中的<bean>元素的定义。
　　 @Service 用于Service业务组件
　　 @Control 用于Action控制组件
 　　@Respository 用于DAO数据访问组件

      @Component 用于其他组件
      Bean组件扫描到容器后，
默认名字为类名(首字母小写)如果需要自定义名称可以使用@Service("id名")

2) 依赖注入的注解标记
　　 @Resource 按名称@Resource(name="id名")
　　 @AutoWired 按名称
　　 @Autowired
　　 @Qualifier("id名")

3)其他注解
　　 @Scope 等价于<bean scope="">
　　 @PostConstruct 等价于<bean init-method="">
 　　@PreDestroy 等价于<bean destroy-method="">

我们不采用xml的方式注入属性了，采用注解的方式注入
1) 使用工程spring1
2) 采用注解的方式
a. 修改applicationContext.xml
Xml文档中丌再配置bean了，我们引入新的标签 <context:component-scan>标签的作用是迚行组件自劢扫描 注意，使用此标签的前提是必须具有xmlns:context命名空间 注意，和之前的applicationContext.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"
        xmlns:p="http://www.springframework.org/schema/p" 
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context" xmlns:jee="http://www.springframework.org/schema/jee"
        xsi:schemaLocation="
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">
<context:component-scan base-package="Dao"></context:component-scan>

</beans>

修改StuDaoImpl.java

package Dao.Impl;

import org.springframework.stereotype.Service;

import Dao.Dao;
@Service
public class StuDaoImpl implements Dao{
    public void say() {
        System.out.println("我是学生");
        
    }
}

修改TeaDaoImpl.java

package Dao.Impl;

import org.springframework.stereotype.Service;

import Dao.Dao;
@Service("tea")//别名
public class TeaDaoImpl implements Dao{

    public void say() {
      System.out.println("我是老师");
        
    }
    
}

修改Say.java

package Dao.Service;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import Dao.Dao;
@Service
public class Say {
    @Resource
    private Dao tea;
　　
    /*public Say(Dao tea){
        this.tea=tea;
    }*/
    public void saywork(){
        tea.say();
    }
}

修改测试类Test.java

package Test;

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

import Dao.Service.Say;


public class test {
    public static void main(String[] args) {
        String conf="applicationContext.xml";
        ApplicationContext ac=new ClassPathXmlApplicationContext(conf);
        Say say=(Say)ac.getBean("say");
        say.saywork();
    }
}

结果是一样的

仔细观察一下上面的代码，可以看到：

　　（1）我们的组件并不需要实现框架指定的接口，因此可以轻松的将组件从Spring中脱离，甚至不需要任何修改，这在基于EJB框架实现的应用中是难以想象的。

　　（2）组件间的依赖关系减少，极大改善了代码的可重用性。Spring的依赖注入机制，可以在运行期为组件配置所需资源，而无需在编写组件代码时就加以指定，从而在相当程度上降低了组件之间的耦合。

2、Spring AOP

　　2.1 面向切面编程基础

　　通常，系统由很多组件组成，每个组件负责一部分功能，然而，这些组件也经常带有一些除了核 心功能之外的附带功能 。系统服务如日志、事务管理和安全经常融入到一些其他功能模块中。这些系统服务通常叫做交叉业务，这是因为它们总是分布在系统的很多组件中。通过将这些业 务分布在多个组件中，给我们的代码引入了双重复杂性。

　　(1) 实现系统级业务的代码在多个组件中复制。这意味着如果你要改变这些业务逻辑，你就必须到各个模块去修改。就算把这些业务抽象成一个独立模块，其它模块只是调用它的一个方法，但是这个方法调用也还是分布在很多地方。

　　(2) 组件会因为那些与自己核心业务无关的代码变得杂乱。一个向地址录中添加条目的方法应该只关心如何添加地址，而不是关心它是不是安全或支持事务的。

　　此时，我们该怎么办呢？这正是AOP用得着的地方。AOP帮助我们将这些服务模块化，并把它们声明式地应用在需要它们的地方，使得这些组件更加专注于自身业务，完全不知道其它涉及到的系统服务。

　　这里的概念切面，就是我们要实现的交叉功能，是应用系统模块化的一个方面或领域。切面的最 常见例子就是日志记录。日志记录在系统中到处需要用到，利用继承来重用日志模块是不合适的，这样，就可以创建一个日志记录切面，并且使用AOP在系统中应 用。下图展示了切面应用方式

图表 1 应用切面

　　其中，通知Advice是切面的实际实现。连接点Joinpoint是应用程序执行过程中 插入切面的地点，这个地点可以是方法调用，异常抛出，甚至可以是要修改的字段，切面代码在这些地方插入到你的应用流程中，添加新的行为。切入点 Pointcut定义了Advice应该应用在那些连接点，通常通过指定类名和方法名，或者匹配类名和方法名式样的正则表达式来指定切入点。

　　2.2 AOP在Spring中的实现

　　基于AOP，业界存在各种各样的AOP实现，比如，JBoss AOP、Spring AOP、ASPectJ、 Aspect Werkz等。各自实现的功能也不一样。AOP实现的强弱在很大程度上取决于连接点模型。目前，Spring只支持方法级的连接点。这和一些其他AOP框 架不一样，如AspectJ和JBoss，它们还提供了属性接入点，这样可以防止你创建特别细致的通知，如对更新对象属性值进行拦截。然而，由于 Spring关注于提供一个实现J2EE服务的框架，所以方法拦截可以满足大部分要求，而且Spring的观点是属性拦截破坏了封装，让Advice触发在属性值改变而不是方法调用上无疑是破坏了这个概念。

　　Spring的AOP框架的关键点如下：

　　（1）Spring实现了AOP联盟接口。在Spring AOP中，存在如下几种通知（Advice）类型

　　Before通知：在目标方法被调用前调用，涉及接口org.springFramework.aop.MethodBeforeAdvice;

　　After通知：在目标方法被调用后调用，涉及接口为org.springframework.aop.AfterReturningAdvice;

　　Throws通知：目标方法抛出异常时调用，涉及接口org.springframework.aop.MethodBeforeAdvice;

　　Around通知：拦截对目标对象方法调用，涉及接口为org.aopalliance.intercept.MethodInterceptor。

　　（2）用Java编写Spring通知，并在Spring的配置文件中，定义在什么地方应用通知的切入点。

　　（3）Spring的运行时通知对象。代理Bean只有在第一次被应用系统需要的时候才被 创建。如果你使用的是ApplicationContext，代理对象在BeanFactory载入所有Bean的时候被创建。Spring有两种代理创 建方式。如果目标对象实现了一个或多个接口暴露的方法，Spring将使用JDK的 java.lang.reflect.Proxy类创建代理。这个类让Spring动态产生一个新的类，它实现所需的接口，织入了通知，并且代理对目标对 象的所有请求。如果目标对象没有实现任何接口，Spring使用CGLIB库生成目标对象的子类。在创建这个子类的时候，Spring将通知织入，并且将 对目标对象的调用委托给这个子类。此时，需要将Spring发行包lib/cglib目录下的JAR文件发布到应用系统中。

　　2.3 Spring AOP的优势

　　借助于Spring AOP，Spring IoC能够很方便的使用到非常健壮、灵活的企业级服务，是因为Spring AOP能够提供如下几方面的优势：

　　（1）允许开发者使用声明式企业服务，比如事务服务、安全性服务；EJB开发者都知道，EJB组件能够使用J2EE容器提供的声明式服务，但是这些服务要借助于EJB容器，而Spring AOP却不需要EJB容器，借助于Spring的事务抽象框架就可以这些服务。

　　（2）开发者可以开发满足业务需求的自定义切面；

　　（3）开发Spring AOP Advice很方便。因为这些AOP Advice仅是POJO类，借助于Spring提供的ProxyFactoryBean,能够快速的搭建Spring AOP Advice。

下面我们来看一个SpringAOP的列子

SpringIOC&AOP,布布扣,bubuko.com

SpringIOC&AOP

原文：http://www.cnblogs.com/plf112233/p/3638184.html