- 浏览: 1589904 次
- 来自: 上海
文章分类
- 全部博客 (374)
- Java (101)
- Struts (54)
- Oracle (30)
- JavaScript (16)
- Spring (27)
- Hibernate (16)
- MyEclipse (3)
- JSF (1)
- FreeMarker (2)
- SiteMesh (2)
- JfreeChart (2)
- Ibatis (2)
- JSP (12)
- MyBatis (4)
- SWFupload (1)
- EJB (4)
- Jboss (4)
- WebService (2)
- Linux (16)
- Android (2)
- XML (6)
- Java 网络编程 (13)
- AXIS2 (1)
- FTP (1)
- Jswing (1)
- Socket (3)
- 杂文选集 (6)
- solr (2)
- PS (1)
- Tomcat (7)
- JDBC (9)
- Highcharts (1)
- maven (1)
- Nodejs (0)
- navicat (2)
- Exception (5)
- eclipse (3)
- jQuery (1)
- springMVC (4)
- MySQL (11)
- SVN (1)
- Sql Server (1)
- zookeeper (1)
- JVM (1)
- Groovy (2)
- Git (1)
- Nginx (1)
- DynamicReport (1)
- IDEA (2)
- JasperReports (1)
- Postgresql (2)
- Mac (1)
- gradle (1)
- 数据结构算法 (1)
最新评论
-
hpu145:
引用引用
java 千分位的添加和去除 -
被遗忘的下路:
少了个junit-4.8.2的包
SSH2整合完整案例(四十三) -
白天看黑夜:
java过滤emoji字符处理,希望能帮到你http://ww ...
emoji 表情图片解决方法 -
caipeiming:
这个挺好JavaScript实现input输入框控件只允许输入 ...
js 控制文本框只能输入中文、英文、数字等 -
双子树:
东西太好啦受教啊
Struts2 JSP中将list,set ,Map传递到Action然后<s:iterator>遍历(三十五)
AOP(Aspect Orient Programming)也就是 面向切面编程,AOP和OOP 互补
<?xml version="1.0" encoding="UTF-8"?> <!-- 采用 DTD 来约束spring 配置文件 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd"> --> <!-- 下面采用 XML Schema 约束--> <!--default-autowire-candidates="*abc" 该bens 下面的 所以以abc 结尾的 bean 不作为 自动注入的bean --> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd"> <!--自动搜索bean组件,自动搜索切面类---> <context:component-scan base-package="annotation.model,annotation.aop"> <context:include-filter type="annotation" expression="org.aspectj.lang.annotation.Aspect"/> </context:component-scan> <!-- 这种表示全部使用 注解来配置aop 而且采用cglib来生成代理--> <aop:aspectj-autoproxy proxy-target-class="true"/> <!--如果不采用 XML Schema配置方式,则需要配置 下面的bean <bean class="org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator"/> --> </beans>
package annotation.aop.point; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; //定义一个切面 @Aspect public class SystemArchitecture { /** * execution(pat1 pat2 pat3 pat4 pat5 pat6) 包含6部分 * pat1 : modifiers-pattern: 方法的修饰符 public default protected private 可以省略 * pat2 : ret-type-pattern: 方法的返回值类型 "*" 表示匹配所有的返回值类型 * pat3 : decaring-type-pattern: 指定方法所属的类 支持通配符 ,可以省略. * pat4 : name-pattern: 方法名字 ,支持通配符, 可以使用 * 匹配所有方法 * pat5 : param-pattern: 方法 的参数列表 "*" 表示一个任意类型的参数 ".." 任意个数任意类型的参数 * pat6 :throws-pattern: 指定方法声明抛出的异常,支持通配符,可以省略 * */ //定义一个 切入点 // 这个表达式 是 pat1=(省略) pat2=* pat3=annotation.model.impl.Peo* pat4=eat* pat5=(..) pat6=(省略) @Pointcut("execution(* annotation.model.impl.Peo*.eat*(..))") public void myPointcut(){ } //匹配所有 public 方法 @Pointcut("execution(public * * (..))") public void pintcut1(){ } //所有set 开头的方法 @Pointcut("execution(* set*(..))") public void pintcut2(){ } //所有impl 包下所有类的所有方法 @Pointcut("execution(* annotation.model.impl.*.*(..))") public void pintcut3(){ } //所有People类 下的所有 方 @Pointcut("execution(* annotation.model.impl.People.*(..))") public void pintcut4(){ } //impl 包中的所有 连接点 @Pointcut("within(annotation.model.impl.*)") public void pintcut5(){ } //impl 和 impl 子包中的所有 连接点 @Pointcut("within(annotation.model.impl..*)") public void pintcut6(){ } //匹配实现了Perosn接口的目标对象的所有连接点 @Pointcut("this(annotation.model.interfaces.Person)") public void pintcut7(){ } //限定目标对象 必须是指定类的实例 @Pointcut("target(annotation.model.interfaces.Person)") public void pintcut8(){ } //对连接点的参数类型进行设置 //匹配只接受一个参数.且是 Serializable的所有连 接点 //和 execution的区别是 args 是匹配运行时候的 参数类型 //execution 是匹配方法签名 时候的参数类型 @Pointcut("args(java.io.serializabel)") public void pintcut9(){ } //匹配以People的bean 内的连接点 @Pointcut("bean(*People)") public void pintcut10(){ } //匹配以stoneAxe 内方法的连接点 @Pointcut("bean(stoneAxe)") public void pintcut11(){ } @AfterReturning(pointcut="myPointcut() && args(name,..)",returning="rtv") public void writeLog(String name,Object rtv){ System.out.println("内部"); System.out.println("参数值name:"+name); System.out.println("返回值:"+rtv); } }
//before 在方法之前执行
package annotation.aop; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; @Aspect public class BeforeAdviceTest{ @Before("execution(* annotation.model.impl.*.*(..))") public void authrity(){ System.out.println("before: 模拟执行权限检查"); } }
//afterReturning 只有在目标方法执行完后被织入,能够获取方法的返回值,如果中途出现异常了,就不会被增强
package annotation.aop; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.Aspect; @Aspect public class AfterRetruningAdviceTest { //只有 在方法 完成返回后 才能执行 如果中间 出现异常了 是不会执行的 @AfterReturning(returning="rvt",pointcut="execution(* annotation.model.impl.*.*(..))") public void log(Object rvt){ //如果是Object 则 返回值 为任意类型的 都会被拦截 进行处理 System.out.println("AfterReturning获取目标返回值:"+rvt); System.out.println("AfterReturning 模拟记录日志功能..."); } @AfterReturning(returning="rvt",pointcut="execution(* annotation.model.impl.*.*(..))") public void log(int rvt){ //只拦截 返回值为 int的 方法 System.out.println("AfterReturning 我要的结果:"+rvt); } }
//AfterThrowing 主要用于处理程序中未处理的异常,能够指定值增强抛出那些异常的方法
package annotation.aop; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Aspect; import org.springframework.stereotype.Component; @Aspect //@Component public class AfterThrowingAdviceTest { //可以 指定只抛出指定的异常 可以对抛出的异常进行处理,但是不能对异常进行完全处理,异常还是会向上抛出 @AfterThrowing(throwing="ex",pointcut="execution(* annotation.model.impl.*.*(..))") public void doRecoveryActions(Throwable ex){ //NullPointerException ex System.out.println("AfterThrowing 目标方法中抛出的异常:"+ex); System.out.println("AfterThrowing 模拟抛出异常后的增强处理..."); } }
//after 不管目标方法 怎么结束(正常结束,抛出异常结束) 都会织入, 所以类是 finally{}
package annotation.aop; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; @Aspect public class AfterAdviceTet { //类是 finally{ //dosomething... //} @After("execution(* annotation.model.impl.*.*(..))") public void release(){ System.out.println("After 模拟方法结束后关闭资源"); } }
//Around (before + afterReturning) 该增强处理比较强大,
比before强大; 在目标方法执行前,进行增强,可以决定 目标方法 是否执行,和什么时候执行.可以改变目标方法的参数值(也可以阻止目标方法执行)
比afterReturning强大: 可以在方法正常结束后进行增强, 可以改变方法的返回值.
注意:由于 Around 功能强大,因此需要在线程安全的环境下使用,如过用 before 和afterReturning能够解决的问题,就没必要 用 Around 了
package annotation.aop; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; @Aspect public class AroundAdviceTest { @Around("execution(* annotation.model.impl.*.*(..))") public Object proccesTx(ProceedingJoinPoint jp) throws Throwable{ System.out.println("Around :执行目标方法前开始事务"); Object rvt=jp.proceed(new String[]{"被改变的参数"}); System.out.println("Around:执行目标方法之后,模拟结束事务"); return rvt+"Around:新增的内容"; } }
//访问目标方法的 参数
//Object[] getArgs(): 获取目标方法的参数 //Sigature getSignature()返回被增强法方法的相关信息 //Object getTarget() 返回被织入 增强处理的目标对象 //Object getThis() 返回AOP框架为目标对象生成的代理对象 //============================================== package annotation.aop; import java.util.Arrays; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.core.annotation.Order; import org.springframework.stereotype.Component; @Aspect @Order(1) //@Component public class FourAdviceTest { static{ System.out.println("aop 1"); } @Around("execution(* annotation.model.impl.*.*(..))") public Object processTx(ProceedingJoinPoint jp) throws Throwable{ System.out.println("-------------------Around增强: 执行目标方法前 ,模拟开始事务...."); //获取执行目标方法的参数 Object[] args=jp.getArgs(); if(args!=null && args.length>0 && args[0].getClass() == String.class){ args[0]="被改变的参数"; } Object rvt=jp.proceed(args); System.out.println("Around增强:执行目标方法之后,模拟结束事务..."); return rvt+"新增的内容"; } @Before("execution(* annotation.model.impl.*.*(..))") public void authority(JoinPoint jp){ System.out.println("-------------------Before增强处理:"); System.out.println("模拟执行权限检查"); System.out.println("被织入增强处理的目标方法为"+jp.getSignature().getName()); System.out.println("目标方法参数为:"+Arrays.toString(jp.getArgs())); System.out.println("被织入增强处理的目标对象为:"+jp.getTarget()); } @AfterReturning(pointcut="execution(* annotation.model.impl.*.*(..))",returning="rvt") public void log(JoinPoint jp,Object rvt){ System.out.println("-------------------AfterReturning增强处理"); System.out.println("获取目标返回值:"+rvt); System.out.println("模拟日志记录功能"); System.out.println("被织入增强处理的目标方法为"+jp.getSignature().getName()); System.out.println("目标方法参数为:"+Arrays.toString(jp.getArgs())); System.out.println("被织入增强处理的目标对象为:"+jp.getTarget()); } @After("execution(* annotation.model.impl.*.*(..))") public void release(JoinPoint jp){ System.out.println("-------------------After增强处理"); System.out.println("模拟方法结束后,释放资源"); System.out.println("被织入增强处理的目标方法为"+jp.getSignature().getName()); System.out.println("目标方法参数为:"+Arrays.toString(jp.getArgs())); System.out.println("被织入增强处理的目标对象为:"+jp.getTarget()); } }
采用XML配置文件来配置AOP
<?xml version="1.0" encoding="UTF-8"?> <!-- 采用 DTD 来约束spring 配置文件 <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd"> --> <!-- 下面采用 XML Schema 约束--> <!--default-autowire-candidates="*abc" 该bens 下面的 所以以abc 结尾的 bean 不作为 自动注入的bean --> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xmlns:mvc="http://www.springframework.org/schema/mvc" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd"> <context:component-scan base-package="annotation.model,annotation.aop"> </context:component-scan> <!--使用xml来配置AOP --> <!-- 定义一个切面类 <bean id="fourAdvice" class="annotation.aop.FourAdviceTest"/> <bean id="fourAdvice1" class="annotation.aop.FourAdviceTest1"/> --> <!-- proxy-target-class="false": 默认 采用 com.sun.proxy 代理(表示被代理的类必须是实现了接口,纯 接口实现类) 如果被代理的累是 一个javaBean 则 只能使用 cglib 创建代理 expose-proxy="true" : 决定当前代理是否被暴露在一个ThreadLocal 中以便被目标对象访问。 如果目标对象需要获取代理而且exposeProxy属性被设为 true, 目标对象可以使用AopContext.currentProxy()方法。 --> <aop:config proxy-target-class="true"> <aop:pointcut id="pt1" expression="execution(* annotation.model.impl.*.*(..))"/> <aop:aspect id="oneAdvice" ref="fourAdvice" order="1"> <aop:after method="release" pointcut-ref="pt1"/> <aop:before method="authority" pointcut-ref="pt1"/> <aop:after-returning returning="rvt" method="log" pointcut-ref="pt1"/> <!-- 匹配返回值为 String的 --> <aop:around method="processTx" pointcut="execution(String annotation.model.impl.*.*(..))"/> </aop:aspect> <!-- 注解的时候 使用 && || ! 在使用XML配置的时候 使用 and or not --> <aop:aspect id="twoAdvice" ref="fourAdvice1" order="2"> <aop:pointcut id="pt2" expression="execution(* annotation.model.impl.*.*(..)) and args(name)"/> <aop:before method="authority" pointcut-ref="pt2"/> </aop:aspect> <aop:aspect id="errorAdvice" ref="afterThrowingAdviceTest" order="1"> <aop:after-throwing method="doRecoveryActions" pointcut-ref="pt1" throwing="ex"/> </aop:aspect> </aop:config> </beans>
发表评论
-
spring-session 中的坑
2017-07-06 15:34 9995spring-session 配置 依赖 gradle ... -
Spring AspectJ Aop Annotation
2017-03-29 17:08 709import org.aspectj.lang.Proce ... -
spring 第13天 使用@scheduled注解执行定时任务
2015-01-06 23:11 54085我们使用spring的注解 @Scheduled 执行定时任务 ... -
Spring 第12天,事务传播属性和 隔离级别
2014-09-28 00:36 8161 事务的传播属性(Propagation) 1) REQ ... -
spring 第11天 quartz任务调度
2014-08-24 13:59 1146Quartz是一个强大的企业级任务调度框架,Spring中继承 ... -
spring 第9天 Resurce 资源访问
2014-08-17 22:20 1868Spring Resource接口 spring提供的Reso ... -
spring 第8天 Spring 注解
2014-08-17 15:33 1472spring注解 @Component:标注一个普通的sp ... -
spring 第7天 Bean,BeanFactory处理器,配置器
2014-08-16 21:46 1238spring 两种后处理器 第一种,Bean 后处理器 对容器 ... -
spring 第6天SpEL,P命名空间,Util Schema
2014-08-13 22:52 1315使用p名称空间配置属性 ... -
spring 第5天不同作用域的bean,注入Field,方法返回值
2014-08-11 22:31 2113协调作用域不同步的bean 问题是;当一个singleton的 ... -
spring 第4天bean继承,init,destory-method
2014-08-10 17:54 1654深入理解Spring容器中的b ... -
spring 第3天使用java类和XML配置bean
2014-08-09 16:51 1506下面采用java类来配置bean,前面都采用xml进行配置be ... -
spring 第2天,bean作用域,自动注入集合
2014-08-06 22:16 1932sping容器中的Bean <!---beans的全 ... -
spring 第1天 IOC,DI,国际化,容器事件
2014-08-04 21:27 13951.构造注入(就是使用 构 ... -
SpringMVC 注解 和非注解
2014-01-26 10:29 18018首先看看非注解的项目结构 在web.xml文件 配置spr ... -
详解spring 每个jar的作用
2013-11-19 23:54 3911spring.jar 是包含有完整 ... -
Spring配置Hibernate事务
2013-11-10 13:45 1217为了保证数据的一致性,在编程的时候往往需要引入事务这个概念。事 ... -
Spring 中引用Properties文件
2013-08-29 14:39 10657其中部分配置信息(邮件发送相关): #邮件发送的相关配置 ... -
Spring IOC控制反转 依赖注入DI
2012-12-15 09:37 2330目录 1.使用IOC控制反转 中的DI依赖注入 手工注入 ... -
Spring IOC控制反转 依赖注入DI
2012-12-14 16:23 8目录 1.使用IOC控制反转 中的DI依赖注入 (两种配置方式 ...
相关推荐
面向切面编程(AOP)是Spring框架的重要特性,它允许开发者将关注点分离,将横切关注点(如日志、事务管理、安全检查等)从核心业务逻辑中解耦出来。Spring AOP实现了Aspect Oriented Programming(面向切面编程),...
在IT领域,Spring框架是Java开发中的核心组件之一,它为开发者提供了许多强大的功能,包括依赖注入、面向切面编程(AOP)以及事务管理。本章将详细探讨Spring4中的切面事务处理、事物通知以及传播行为。 一、切面...
标题中的"spring_day03_aop.zip_Who_spring"暗示了本次讨论的主题是关于Spring框架的AOP(面向切面编程)模块。在Spring框架中,AOP是一种强大的工具,用于实现关注点分离,它允许程序员定义横切关注点,如日志记录...
【Spring AOP设计模式】是Spring框架中面向切面编程的重要组成部分,它允许开发者通过分离关注点来解耦代码,实现灵活的模块化设计。在本章中,我们将探讨17种设计模式在Spring AOP中的应用和实现,以及它们如何帮助...
在本章"Spring AOP 基础1"中,我们主要探讨了Spring AOP(面向切面编程)的核心概念和实现方式。AOP是一种编程范式,它允许程序员定义"切面",这些切面封装了跨越多个对象的横切关注点,如日志、事务管理等。以下是...
Spring AOP API 设计与实现是Spring框架的重要组成部分,它提供了面向切面编程的能力,使得开发者可以在不修改源代码的情况下,对程序进行横切关注点的处理,如日志记录、事务管理等。本章主要涵盖了Spring AOP的多...
作为一款广泛应用的Java企业级开发框架,Spring以其强大的依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)能力,极大地简化了应用的构建和管理。以下是对这次培训笔记的...
Spring的核心特性包括依赖注入(DI)、面向切面编程(AOP)、事务管理等,这些都极大地提高了代码的可测试性和可维护性。 2. **依赖注入**:Spring的核心设计原则之一是依赖注入,它允许开发者将对象间的依赖关系交...
Spring是Java企业级应用中最广泛使用的轻量级框架,它提供了丰富的功能来简化开发流程,包括依赖注入(DI)、面向切面编程(AOP)、数据访问、事务管理、Web应用支持等。 1. **依赖注入(Dependency Injection, DI...
Spring框架是Java开发中不可或缺的一部分,它以其强大的依赖注入(DI)和面向切面编程(AOP)功能闻名。在2016年的版本中,Spring框架已经相当成熟,为开发者提供了丰富的特性和工具,帮助他们构建高效、可维护的...
在本项目"Stringboot AOPdemo,执行controller中方法.zip"中,主要展示了Spring Boot集成AOP(面向切面编程)技术,用于实现细粒度的功能控制,如登录校验、操作日志记录等。下面将详细介绍其中涉及的关键知识点。 1...
Spring框架是Java企业级应用开发的核心工具,它简化了依赖注入、AOP(面向切面编程)、数据访问、Web应用开发等多个方面的工作。Spring in Action第四版主要涵盖了以下知识点: 1. **Spring概述**:讲解Spring的...
Spring Framework,作为Java开发中的核心框架,以其强大的依赖注入(Dependency Injection,DI)和面向切面编程(Aspect-Oriented Programming,AOP)功能,极大地提升了企业级应用的开发效率。本文将深入探讨Spring...
3. **AOP(面向切面编程)**:阐述了Spring的AOP模块,讲解如何通过切面来实现代码的解耦,包括通知类型、切点表达式、代理模式等。 4. **数据访问**:涵盖了JDBC、ORM(对象关系映射)框架如Hibernate和MyBatis的...
它通过依赖注入(Dependency Injection, DI)和面向切面编程(Aspect-Oriented Programming, AOP)提供了一个灵活的基础架构。 2. **依赖注入**:Spring的核心特性之一是依赖注入,它允许对象之间的关系在运行时...
2. **AOP(面向切面编程)**:Spring支持AOP,允许开发者定义“切面”来封装横切关注点,如日志、事务管理等。源码中会有实际的切面定义和通知(advisors)使用示例。 3. **Spring MVC**:Spring的Web MVC框架提供...
第10章通常会涉及到Spring框架的核心概念和高级特性,包括依赖注入、AOP(面向切面编程)、事务管理等关键知识点。 首先,我们来探讨Spring的核心特性——依赖注入(Dependency Injection,DI)。依赖注入是Spring...
Spring框架是Java开发中不可或缺的一部分,它以其IoC(Inversion of Control,控制反转)和AOP(Aspect Oriented Programming,面向切面编程)两大核心特性,极大地简化了企业级应用的开发工作。"spring jar"通常指...
Spring是一个广泛应用的Java企业级应用开发框架,它提供了一种模块化且可扩展的方式来构建应用程序,支持依赖注入、AOP(面向切面编程)、MVC(模型-视图-控制器)等核心特性。描述中的"spring4 -1"可能是课程或者...
- AOP(面向切面编程):理解AOP的基本原理,以及如何在Spring中实现切面。 2. **第二章:搭建Spring环境** - 安装与配置:介绍如何配置Java开发环境,包括JDK、IDE和构建工具如Maven或Gradle。 - 创建第一个...