`

Spring之aop入门实例

阅读更多
最近在研究aop,看了点资料,总结如下:
所谓AOP就是将分散在各个方法处的公共代码提取到一处,并通过类似拦截器的机制实现代码的动态整合。可以简单地想象成,在某个方法的调用前、执行中、调用后和抛出异常时,动态插入自己的代码。

网上碰到个例子还不错,整理了一下:

首先看一个简单的spring IOC例子:

用户买书接口:
package aop;
public interface BuyBook {	
	public void buyBook(String customer,String book)throws NoBookException;
}


用户买书的接口实现:
package aop;
public class BuyBookImpl implements BuyBook{
	public void buyBook(String customer,String book) {		
		System.out.println(customer+"你好!你成功购了一本"+book+"!");
	}
}


测试用户买书类:
package aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestAop {
	public static void main(String args[]) throws Exception{		
        ApplicationContext ctx = new FileSystemXmlApplicationContext("aop.xml");   
        BuyBook b = (BuyBook)ctx.getBean("newBuyBook");
        b.buyBook("小东", "《楚留香》");
    }
}


配置文件aop.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="newBuyBook" class="aop.BuyBookImpl"/> 
</beans>


此时运行程序仅出现:
小东你好!你成功购了一本《楚留香》!

===================================================================================
AOP ----切面编程
所谓切面编程:在不改变原方法(令为methodA)的定义与使用、也不改变原程序的流程的情况下,变更该methodA的功能。在变更时,最激动人心的时能获得methodA的类的对象,meahtoidA的参数,也可获得mehodA执行的结果,还能得到调用meahtoidA的对象。
    简单理解:允许用户在指定地方,插入新的函数,
包括:
1 methodA运行前,执行用户指定的其它方法methodOther,然后返回
2 methodA运行完毕,执行用户指的其它方法methodOther,然后返回
3 在执行methodA的地方,变成执行在用户指定的其它方法methodOther,
在methodOther方法中, methodA运不运行,何时运行,随用户自行安排,然后返回
4  methodA执行出现异常时,执行用户指定的其它方法methodOther,然后返回。

产生动机:
在一个程序中,当我们要 使用一个方法(令为methodA);由于不同的用户对methodA的功能要 求不一样,因此在这个methodA的地方就出现了变化点。所以要在这个变化点上进行封装,留下一个可扩展的接口,便于日后修改维护。

本质:
1  Aop核心是一个适配器,把变动前的方法,与变动后的方法联接在一起。
2  这个适配器实现的核心是动态代理 Proxy机制
3  四个核心子接口:
a  MethodBeforeAdvice ----methodA函数调用前执行用户定义的方法
b  AfterReturningAdvice ----- methodA函数调后执行用户定义的方法
c  MethodInterceptor -------彻底变更MethodA函数为用户定义的方法
d  ThrowsAdvice------methodA函数调用出现异常执行用户定义的方法


===================================================================================
下面加入aop的内容:
一、在买书前加入新功能(欢迎光临!小东)

增加类MyBeforeAdvice :
package aop;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;

public class MyBeforeAdvice implements MethodBeforeAdvice{
	public void before(Method arg0, Object[] arg1, Object target) throws Throwable {
	String customer = (String)arg1[0];		
        System.out.println("欢迎光临!"+customer+"!");   
    }	
}


修改配置文件aop.xml:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="buyBook" class="aop.BuyBookImpl"/> 
    <bean id="myBeforeAdvice" class="aop.MyBeforeAdvice"/>
    <bean id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces" value="aop.BuyBook"/> 
        <property name="interceptorNames">
            <list>
                  <value>myBeforeAdvice</value>
            </list>
        </property>
        <property name="target" ref="buyBook"/>
    </bean>
</beans>


运行后输出结果:
欢迎光临!
小东你好!你成功购了一本《楚留香》!


二、在买书后加入新功能(Good Bye!小东)

增加MyAfterAdvice类:
package aop;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class MyAfterAdvice implements AfterReturningAdvice{	
	public void afterReturning(Object o1, Method m, Object[] objects, Object o2){	
		System.out.println("Good Bye!" + objects[0]);		
	}
}


修改配置文件aop.xml:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="buyBook" class="aop.BuyBookImpl"/> 
    <bean id="myBeforeAdvice" class="aop.MyBeforeAdvice"/>
    <bean id="myAfterAdvice" class="aop.MyAfterAdvice"/>
    <bean id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces" value="aop.BuyBook"/> 
        <property name="interceptorNames">
            <list>
                  <value>myBeforeAdvice</value>
                  <value>myAfterAdvice</value>
            </list>
        </property>
        <property name="target" ref="buyBook"/>
    </bean>
</beans>



运行后输出结果:
欢迎光临!
小东你好!你成功购了一本《楚留香》!
Good Bye!小东

三、修改原来方法的内容,比如加入相关业务判断,一个人只能买一本书:
修改用户买书类:
package aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestAop {
	public static void main(String args[]) throws Exception{		
        ApplicationContext ctx = new FileSystemXmlApplicationContext("aop.xml");   
        BuyBook b = (BuyBook)ctx.getBean("newBuyBook");
        b.buyBook("小东", "《楚留香》");
        b.buyBook("小东", "《楚留香2》");
    }
}


增加拦截器类MyMethodInterceptor:
package aop;
import java.util.HashSet;
import java.util.Set;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class MyMethodInterceptor implements MethodInterceptor{
	private Set customers = new HashSet();	
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		String customer = (String)invocation.getArguments()[0];
	    Object result = null;
	    if(customers.contains(customer)){
	         System.out.println("注意,一名顾客只能买一本打折书!");
	    } else{
	         result = invocation.proceed();
	    }
	    customers.add(customer);
	    return result;
	}
}



修改配置文件aop.xml:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="buyBook" class="aop.BuyBookImpl"/> 
    <bean id="myMethodInterceptor" class="aop.MyMethodInterceptor"/>

    <bean id="newBuyBook" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces" value="aop.BuyBook"/> 
        <property name="interceptorNames">
            <list>
                  <value>myMethodInterceptor</value>
            </list>
        </property>
        <property name="target" ref="buyBook"/>
    </bean>
</beans>


运行结果:
小东你好!你成功购了一本《楚留香》!
注意,一名顾客只能买一本打折书!

分享到:
评论
1 楼 ls1259775 2016-08-19  
写的太好了,通俗易懂。

相关推荐

    spring AOP入门实例

    在这个入门实例中,我们将深入理解Spring AOP如何实现简单日志记录。 首先,AOP的核心概念包括切面(Aspect)、通知(Advice)、连接点(Join Point)、切入点(Pointcut)和织入(Weaving)。切面是AOP中的核心...

    spring2-aop入门实例教程

    ### Spring2-AOP入门实例教程知识点详解 #### 一、Spring框架概述 - **轻量级J2EE开发框架**:Spring是一个轻量级的Java应用框架,它为开发复杂的企业级应用提供了一种简化的方法。 - **发展历程**:自2002年发布...

    Spring AOP 入门实例1

    以下是一个简单的Spring AOP入门实例步骤: 1. 首先,定义一个切面类,包含通知方法。例如,一个简单的日志切面: ```java @Aspect @Component public class LoggingAspect { @Before("execution(* com.example*...

    Spring AOP 入门实例

    **Spring AOP 入门实例** 在Java编程中,面向切面编程(Aspect-Oriented Programming,简称AOP)是一种编程范式,它允许程序员定义“横切关注点”,如日志、事务管理、性能监控等,然后将这些关注点与核心业务逻辑...

    Spring AOP入门及其实例讲解、下载

    **Spring AOP 入门及其实例讲解** 在软件开发中,面向切面编程(Aspect Oriented Programming,简称AOP)是一种编程范式,它旨在提高代码的可重用性,减少冗余,并将关注点分离。Spring框架是Java开发中的一个流行...

    Spring -Aop入门

    ### Spring AOP 入门详解 #### 一、Spring AOP 概述 Spring AOP (Aspect Oriented Programming) 是一种面向切面编程的技术,在Spring框架中得到了良好的支持。通过这种方式,开发者可以更加灵活地组织代码,使得...

    Spring AOP @AspectJ 入门实例

    在IT行业中,Spring框架是Java企业级应用开发的首选,而Spring AOP(面向切面编程)则是其核心特性之一,用于实现横切关注点的模块化,如日志、事务管理等。本实例将带你深入理解并实践Spring AOP与@AspectJ的结合...

    最简单的SpringAOP入门案例

    本教程将通过一个简单的Spring AOP入门案例,帮助初学者理解这一概念。 ### 一、AOP基础 1. **切面(Aspect)**:切面是关注点的模块化,它封装了跨越多个对象的行为或数据。在Spring AOP中,切面可以由一个类定义...

    spring AOP 实例(@AspectJ)

    一个基于@AspectJ的spring2.0 AOP应用实例,很小很简单,没有任何额外信息,最适合AOP入门学习。使用log4j打印信息。把项目直接import进myeclipse就可以使用啦......

    Spring AOP 入门作者:廖雪峰

    ### Spring AOP 入门详解 #### 一、Spring AOP 概述 Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的一个关键特性,它为开发者提供了在运行时动态添加代码(即横切关注点或切面)到已有...

    Spring 之IoC入门实例

    **Spring之IoC入门实例详解** 在Java世界中,Spring框架以其强大的依赖注入(Dependency Injection,简称DI)和控制反转(Inversion of Control,简称IoC)能力而广受赞誉。IoC是一种设计模式,它将对象的创建和...

    一个Spring的入门实例;一个Struts的入门实例

    以上就是 Spring 和 Struts 的基础概念及入门实例的创建流程。这两个框架各有优势,Spring 更注重模块化和灵活性,而 Struts 则更侧重于 MVC 结构的实现。在实际项目中,两者常被一起使用,形成所谓的“Spring + ...

    spring_aop1.rar_java aop_spring mvc 例子

    本实例“spring_aop1.rar”是一个关于Spring AOP入门的教程,旨在帮助开发者更好地理解和运用Spring的AOP特性,同时也涉及到Spring MVC的相关知识。下面我们将深入探讨这两个关键概念。 首先,让我们了解一下Spring...

    spring-boot入门实例(jpa+postgresql+aop实现valid切面式校验)

    这个入门实例将向我们展示如何使用Spring Boot与JPA(Java Persistence API)、PostgreSQL数据库以及AOP(面向切面编程)来实现数据验证。 首先,让我们详细了解一下Spring Boot。Spring Boot的核心理念是“约定...

    springAOP-dome

    在这个名为"springAOP-dome"的实例中,我们将探讨如何利用Spring AOP实现一个简单的日志记录功能,以作为入门学习。 首先,了解AOP的基本概念是必要的。面向切面编程是一种编程范式,旨在解决程序中的横切关注点,...

    Spring_02_入门篇_AOP_简单实例

    本教程将深入探讨Spring中的核心概念之一——面向切面编程(Aspect-Oriented Programming,简称AOP),并提供基于注解和XML配置的两种实现方式的简单实例。 **一、什么是AOP** 面向切面编程(AOP)是一种编程范式...

    spring菜鸟入门经典实例

    在Spring入门阶段,首先要理解的是依赖注入(DI)。DI是一种设计模式,它允许我们解耦组件,让它们之间通过接口而非具体的实现进行交互。Spring通过容器管理对象的生命周期和依赖关系,我们只需要配置好bean的定义,...

Global site tag (gtag.js) - Google Analytics