spring aop编程——基于XML开发
基于xml
1.目标类:接口 + 实现
接口代码:
public interface UserService {
public String findUser();
public void addUser();
public void updateUser();
public void deleteUser();
}
实现类:
public class UserServiceImpl implements UserService{
public void addUser() {
System.out.println("addUser............");
}
public void updateUser() {
System.out.println("updateUser...........");
}
public void deleteUser() {
System.out.println("deleteUser.............");
}
public String findUser() {
System.out.println("findUser.............");
return "张三";
}
}
2.切面类:编写多个通知,采用aspectj 通知名称任意(方法名任意)
public class MyAspect {
//前置通知
public void myBefore(){
System.out.println("开启事务..........");
}
//后置通知
public void myAfterReturning(Object o){
System.out.println("提交事务..........."+o);
}
//环绕通知
public Object myAround(ProceedingJoinPoint joinPoint) throws Throwable{
System.out.println("开启事务..........");
//手动执行目标方法
Object obj = joinPoint.proceed();
System.out.println("提交事务...........");
return obj;
}
//抛出异常通知
public void myAfterThrowing(Throwable t){
System.out.println("抛出异常通知..........."+t.getMessage());
}
//最终通知
public void myAfter(){
System.out.println("最终通知..............");
}
}
3.aop编程,将通知应用到目标类
3.1Spring配置
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!-- 1 创建目标类 -->
<bean id="userService" class="cn.ithuplion.spring_aop_xml.UserServiceImpl"></bean>
<!-- 2 创建切面类(通知) -->
<bean id="myAspect" class="cn.ithuplion.spring_aop_xml.MyAspect"></bean>
<!-- 3 aop编程
<aop:aspect> 将切面类 声明“切面”,从而获得通知(方法)
ref 切面类引用
<aop:pointcut> 声明一个切入点,所有的通知都可以使用。
expression 切入点表达式
id 名称,用于其它通知引用
-->
<aop:config>
<aop:aspect ref="myAspect">
<aop:pointcut expression="execution(* cn.ithuplion.spring_aop_xml.UserServiceImpl.*(..))" id="myPointcut"/>
<!-- 3.1 前置通知 :目标方法前执行
<aop:before method="" pointcut="" pointcut-ref=""/>
method : 通知,及方法名
pointcut :切入点表达式,此表达式只能当前通知使用。
pointcut-ref : 切入点引用,可以与其他通知共享切入点。
通知方法格式:public void myBefore(JoinPoint joinPoint){
参数1:org.aspectj.lang.JoinPoint 用于描述连接点(目标方法),获
得目标方法名等
-->
<aop:before method="myBefore" pointcut-ref="myPointcut"/>
<!-- 3.2后置通知 :目标方法后执行,获得返回值
<aop:after-returning method="" pointcut-ref="" returning=""/>
returning 通知方法第二个参数的名称
通知方法格式:public void myAfterReturning(JoinPoint joinPoint,Object
returnValue){
参数1:连接点描述
参数2:类型Object,参数名 returning="returnValue" 配置的
-->
<aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut" returning="o"/>
<!-- 3.3 环绕通知
<aop:around method="" pointcut-ref=""/>
通知方法格式:public Object myAround(ProceedingJoinPoint joinPoint)
throws Throwable{
返回值类型:Object
方法名:任意
参数:org.aspectj.lang.ProceedingJoinPoint
抛出异常
执行目标方法:Object obj = joinPoint.proceed();
-->
<aop:around method="myAround" pointcut-ref="myPointcut"/>
<!-- 3.4 抛出异常
<aop:after-throwing method="" pointcut-ref="" throwing=""/>
throwing :通知方法的第二个参数名称
通知方法格式:public void myAfterThrowing(JoinPoint joinPoint,Throwable t)
{
参数1:连接点描述对象
参数2:获得异常信息,类型Throwable ,参数名由throwing="t" 配置
-->
<aop:after-throwing method="myAfterThrowing" pointcut-ref="myPointcut" throwing="t"/>
<!-- 3.5 最终通知 -->
<aop:after method="myAfter" pointcut-ref="myPointcut"/>
</aop:aspect>
</aop:config>
</beans>
4.测试
@Test
public void test1(){
ApplicationContext applicationContext=new
ClassPathXmlApplicationContext("cn/ithuplion/spring_aop_xml/bean.xml");
UserService userService = (UserService)
applicationContext.getBean("userService");
userService.addUser();
userService.updateUser();
userService.deleteUser();
userService.findUser();
}
分享到:
相关推荐
本文将深入探讨“Spring AOP——Schema”,这是Spring AOP的一种配置方式,通过XML schema定义切面和通知。 首先,我们需要理解AOP的基本概念。面向切面编程是一种编程范式,旨在提高软件的模块化程度,将关注点...
Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来实现横切关注点,如日志、事务管理、性能监控等。本入门案例将帮助你理解并掌握Spring AOP的基本概念和使用方法。 在...
现在,我们回到主题——"springaop依赖的jar包"。在Spring 2.5.6版本中,使用Spring AOP通常需要以下核心jar包: - `spring-aop.jar`:这是Spring AOP的核心库,包含了AOP相关的类和接口。 - `spring-beans.jar`:...
在IT行业中,Spring框架是Java企业级应用开发的首选,而Spring AOP(面向切面编程)则是其核心特性之一,用于实现横切关注点的模块化,如日志、事务管理等。@AspectJ是Spring AOP的一种注解驱动方式,它极大地简化了...
"spring-aop-jar"这个主题涉及到Spring框架中的核心组件之一——Spring AOP。这里我们将深入探讨Spring AOP、相关jar文件以及它们在实际开发中的作用。 首先,我们来看一下提供的文件: 1. aopalliance.jar:这是一...
尤其是`org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator`和`org.springframework.aop.aspectj.AspectJExpressionPointcut`这两个类,它们分别处理了基于注解的切面创建和切入点...
在Spring框架中,AOP(面向切面编程)是一种强大的设计模式,它允许开发者将关注点分离,将横切关注点(如日志、事务管理、权限检查等)与核心业务逻辑解耦。AOP的核心概念是切面、通知、连接点、切入点和织入。在...
Spring AOP(面向切面编程)是一个强大的工具,常用于实现业务逻辑中的横切关注点,如日志、事务管理以及我们的案例——数据权限控制。本篇将深入探讨如何结合Spring AOP和Oracle数据库来实现精细化的数据权限控制。...
Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的一个重要组成部分。它是对传统面向对象编程(OOP)的一种补充,旨在解决业务逻辑中的横切关注点,如日志记录、事务管理、权限控制等。...
- Spring支持基于代理的AOP和基于注解的AOP。 4. **IoC容器** - IoC容器是Spring的基石,负责管理对象的生命周期和对象之间的依赖关系。 - 容器通过读取配置元数据(XML、注解或Java配置类)来创建和管理Bean。 ...
**Spring的AOP实例——XML与@AspectJ双版本解析** Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统的交叉关注点,如日志、事务管理等。AOP的核心概念包括切面...
- **基于注解的AOP**:在Spring 2.5之后引入,无需编写XML配置,直接在方法上使用注解如`@Before`, `@After`, `@Around`, `@AfterThrowing`等定义通知。 ### 3. Spring AOP的核心组件 - **`@Aspect`**:标记一个类...
《深入解析Spring AOP框架——基于spring-aop.jar的探讨》 在Java开发领域,Spring框架无疑是使用最为广泛的轻量级应用框架之一。其强大的功能和灵活的设计使得它成为企业级应用开发的首选。其中,AOP(Aspect ...
在Spring框架中,AOP(面向切面编程)是一种强大的设计模式,它允许开发者将关注点分离,将横切关注点(如日志、事务管理、安全检查等)与核心业务逻辑解耦。"9Spring AOP 盗梦空间之四——Around"这个标题暗示我们...
Struts2作为MVC框架负责控制层,而Spring则提供了全面的依赖注入(DI)和面向切面编程(AOP)功能。将这两者集成可以实现强大的应用架构。然而,集成过程中可能会遇到一些问题,尤其是当涉及到Spring的AOP时。 首先...
在本篇博文中,我们将深入探讨Spring AOP(面向切面编程)中的一个重要概念——AfterReturning通知,这是Spring框架提供的一种强大的功能,允许我们在方法成功执行并返回后执行额外的操作。我们将通过源码分析和实际...
实验主题涉及Spring AOP(面向切面编程)的两种实现方式——基于XML配置和基于注解的编程,用于模拟银行账户的存钱和取钱操作。AOP的主要目的是分离关注点,将业务逻辑与横切关注点(如日志、事务管理等)解耦。 一...
此外,Spring AOP还提供了强大的表达式语言——AspectJ的LTW(Load-Time Weaving),它允许在程序加载时进行切面的编织,无需修改现有代码,增加了灵活性。LTW的配置通常需要额外的类加载器支持,如AspectJ Weaver ...