- 浏览: 922180 次
- 性别:
- 来自: 北京
文章分类
- 全部博客 (251)
- WebService (17)
- IBatis (22)
- Hibernate (1)
- SpringMVC - 基础篇 (32)
- Spring (15)
- Java (11)
- JVM及调优 - 基础篇 (4)
- 集群 (14)
- 数据库 (17)
- WebSphere (5)
- 多线程 (4)
- 集合、容器 (2)
- DB Pool (1)
- Power Designer (5)
- Maven基础 (5)
- JS (14)
- WEB 前端 (5)
- 实用小工具 (17)
- 社会、人 (2)
- 乱七八糟 (18)
- ASM&CGLIB - 基础篇 (12)
- 缓存 (1)
- 性能 (1)
- 设计之殇 (1)
- 分布式事务 (1)
- 单点登录 (11)
- 分布式 Session (4)
- Memcached - 基础篇 (6)
最新评论
-
一笑_奈何:
楼主写的还真行不错。
扫盲贴 - J2EE集群之JNDI集群实现 -
xuezhongyu01:
博主写的很详细,但最后还是没明白,最后调用BasicDataS ...
Spring中的destroy-method方法 -
Mr梁:
commons-fileupload.jar commons- ...
SpringMVC 中文件上传 MultipartResolver -
Eywa:
总结的很不错
ORACLE CASE WHEN 及 SELECT CASE WHEN的用法 -
TryRelax:
fastjson 比 jackson 好用吧?
Spring MVC Jackson DateFormat
前段时间使用AOP做日志拦截,由于很长时间没有使用过AOP了,在开发过程中遇到各种各样的问题,都快要郁闷死了。。。 现重新温习,做个记录。如有不正确指出还请指点!
首先,在OO设计中,由类组成了模块化,而AOP的出现,弥补了OO中的不足点。原因是:在AOP中模块化的单元是切面。切面能对关注点进行模块化,例如:横切多个类型和对对象的事务管理,而每个关注点被称作为横切关注点。
一 AOP的基本概念
1. 切面(Aspect):
一个关注点的模块化,可以横切多个对象,例如:事务管理。在Spring AOP中,切面可以使用基于模式或者基于Aspect注解的方式来实现。
2. 连接点(Jointpoint)
在程序执行过程中某个特定的点。比如某个方法调用的时候或者处理异常的时候。在Spring AOP中,一个连接点总表示一个方法的执行。
3. 通知(advice)
许多AOP框架都是以拦截器做通知模型,并维护一个以连接点为中心的拦截器链。
在切面的某个特定连接点上执行的动作。
4. 切入点(Pointcut)
匹配连接点的断言。通知和一个切入点表达式关联,并在满足这个切入点的连接点上运行(例如:当执行某个特定名称的方法时)。切入点表达式如何和连接点匹配是AOP的核心。Spring缺省使用AspectJ切入点语法。
5. 引入(Introduction)
用来给一个类型声明额外的方法或属性(也被称为连接类型声明)。Spring允许引入一个新的接口以及对应的实现到任何被代理的对象。例如:你可以使用引入来使一个bean实现IsModified接口,以便简化缓存机制。
6. 目标对象(Target Object)
被一个或多个切面通知的对象,也被称为被通知对象。而在Spring AOP中,目标对象是通过运行时代理实现的,所以这个对象永远是被代理(Proxied)对象。
7. AOP代理(AOP Proxy)
AOP框架创建的对象,用来实现某个契约。在AOP中,AOP代理可以是JDK的Proxy或者CGLib。
8. 织入(Weaving)
把切面连接到其它应用程序类型或对象上,并创建一个被通知的对象。这些可以在编译时(如使用AspectJ编译器),类加载时或运行时完成。Spring和其它的AOP都是在运行时织入。
二 通知(Advice)的类型
主要包含以下五种通知:
1) Before Advice
在连接点执行的通知。
2) After returning Advice
在连接点之后执行的通知,如果没有任何异常,那就返回。
3) After throwing Advice
执行连接点时抛出异常退出时执行的通知。
4) After Advice
在连接点退出的时候执行的通知,不管任何时候,都会被执行。
5) Around Advice
包围一个连接点的通知,如方法调用,这是最强大的通知类型。可以在连接点前后完成自定义的行为,也可以选择是否继续执行连接点或者直接返回值或抛出异常来终止执行。
Spring对AOP的支持有以下4种情况:
经典的基于代理的aop(各版本spring)
@AspectJ注解驱动的切面(spring2.0后)
纯pojo切面(spring2.0后)
注入式AspectJ切面(各版本spring)
工程目录结构如下
一、基于XML文件的配置
Spring文件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: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-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/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd"> <bean id="personServiceBean" class="service.impl.PersonServiceBean"></bean> <!-- 开启aspectj注解 --> <aop:aspectj-autoproxy /> <bean id="springAOP" class="aop.SpringAOP"></bean> <!-- 基于XML配置 --> <bean id="springAOPBean" class="aop.SpringAOPXML"></bean> <aop:config> <aop:aspect id="aspect" ref="springAOPBean"> <!-- 定义了返回值类型!!!String --> <!-- <aop:pointcut id="mycut" expression="execution(java.lang.String service.impl.PersonBean.*(..))" />--> <!-- 定义了输入参数类型!!!String --> <!--<aop:pointcut id="mycut" expression="execution(* service.impl.PersonBean.*(java.lang.String,..))" />--> <!-- 返回所有不是void类型的所有方法 --> <!--<aop:pointcut id="mycut" expression="execution( !void service.impl.PersonBean.*(..))" />--> <!-- service包下的类和子包 <aop:pointcut id="mycut" expression="execution( * service.*.*(..))" /> <aop:before pointcut-ref="mycut" method="doAccessCheck" /> <aop:after-returning pointcut-ref="mycut" method="doAfterReturningString" returning="personId" /> <aop:after-returning pointcut-ref="mycut" method="doAfterReturningObject" returning="person" /> <aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing" />--> <!-- <aop:after pointcut-ref="mycut" method="doAfter"/> --> <!-- <aop:around pointcut-ref="mycut" method="doAround"/> --> </aop:aspect> </aop:config> </beans>
log4j.properties
og4j.rootLogger=DEBUG, stdout
log4j.category.service.impl=DEBUG
#stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %5p [%t] - %m%n
#logfile 后置通知并返回值(String)
log4j.logger.afterReturnString= INFO, ars
log4j.appender.ars=org.apache.log4j.DailyRollingFileAppender
log4j.appender.ars.DatePattern=yyyy-MM-dd HH:mm:ss
log4j.appender.ars.layout=org.apache.log4j.PatternLayout
log4j.appender.ars.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.ars.File=D:/logs/afterReturnS.log
#logfile 后置通知并返回值(Object)
log4j.logger.afterReturnObject= INFO, aro
log4j.appender.aro=org.apache.log4j.DailyRollingFileAppender
log4j.appender.aro.DatePattern=yyyy-MM-dd HH:mm:ss
log4j.appender.aro.layout=org.apache.log4j.PatternLayout
log4j.appender.aro.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.aro.File=D:/logs/afterReturnO.log
#logfile 前置通知
log4j.logger.before= INFO, bef
log4j.appender.bef=org.apache.log4j.DailyRollingFileAppender
log4j.appender.bef.DatePattern=yyyy-MM-dd HH:mm:ss
log4j.appender.bef.layout=org.apache.log4j.PatternLayout
log4j.appender.bef.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.bef.File=D:/logs/before.log
切面定义
personServiceBean.java
package service.impl;
import model.Person;
import service.PersonService;
public class PersonServiceBean implements PersonService{
private Person person = null;
private String user = null;
public PersonServiceBean(){}
public PersonServiceBean(String user) {
this.user = user;
}
public String getUser() {
return user;
}
public Person getPerson(){
person = new Person();
person.setName("wy");
person.setAddress("bj");
person.setPhone("110");
return person;
}
public String getPersonName(Integer personId) {
return (personId.intValue()+1)+"";
}
public void save(String name) {
//throw new RuntimeException("例外通知!!!");
System.out.println("执行save()方法");
}
public void update(String name, Integer personId) {
System.out.println("执行update()方法");
}
}
单元测试类JunitSpringAopTest
package junit.test;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import service.PersonService;
public class JunitSpringAopTest {
@BeforeClass
public static void setUpBeforeClass() throws Exception {
}
@Test
public void interceptor() {
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"applicationContext.xml");
PersonService person = (PersonService) ctx.getBean("personServiceBean");
// person.save("xxx");
// person.getPersonName(2);
person.getPerson();
}
}
注意需要说明的地方:对每个拦截的方法打出日志并放到对应的日志文件中,详细看注释。
二、基于注解
注解配置AOP,大致分为三步:
1. 使用注解@Aspect来定义一个切面,在切面中定义切入点(@Pointcut),通知类型(@Before, @AfterReturning,@After,@AfterThrowing,@Around).
2. 开发需要被拦截的类。
3. 将切面配置到xml中,当然,我们也可以使用自动扫描Bean的方式。这样的话,那就交由Spring AoP容器管理。
切面定义
SpringAOP.java
package aop; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.AfterThrowing; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; import org.springframework.stereotype.Component; /** * @Aspect 此类是一个 切面 * @Component 将此类纳入到Spring容器中 */ @Component @Aspect public class SpringAOP { @SuppressWarnings("unused") @Pointcut("execution(* service.impl.PersonServiceBean.*(..))") private void anyMethod(){}//声明一个切点 @Before("anyMethod() && args(name)") public void doAccessCheck(String name){ System.out.println("前置通知!!!"+name); } @AfterReturning("anyMethod()") public void doAfterReturning(){ System.out.println("后置通知!!!"); } @AfterReturning(pointcut="anyMethod()",returning="result") public void doAReturn(String result){ System.out.println(result); } @AfterThrowing("anyMethod()") public void doAfterThrowing() { System.out.println("例外通知!!!"); } @AfterThrowing( pointcut="anyMethod()" ,throwing="e") public void doAfterThrow(Exception e) { System.out.println("例外通知:"+e+" "+e.getMessage()); } @Around("anyMethod()") public Object doAround(ProceedingJoinPoint pjp) throws Throwable{ //非常适合做权限的判断 //使用了环绕通知就可以不适用前面的通知 System.out.println("进入方法!!!"); Object result = pjp.proceed(); System.out.println("退出方法!!!"); return result; } }
一、什么是 AOP。
AOP(Aspect Orient Programming),也就是面向切面编程 。可以这样理解,面向对象编程(OOP)是从静态角度考虑程序结构,面向切面编程(AOP)是从动态角度考虑程序运行过程 。
二、AOP 的作用。
常常通过 AOP 来处理一些具有横切性质的系统性服务 ,如事物管理、安全检查、缓存、对象池管理 等,AOP 已经成为一种非常常用的解决方案。
三、AOP 的实现原理。
如图:AOP 实际上是由目标类的代理类实现的 。AOP 代理其实是由 AOP 框架动态生成的一个对象,该对象可作为目标对象使用 。AOP 代理包含了目标对象的全部方法,但 AOP 代理中的方法与目标对象的方法存在差异,AOP 方法在特定切入点添加了增强处理,并回调了目标对象的方法 。
四、Spring 中对 AOP 的支持
Spring 中 AOP 代理由 Spring 的 IoC 容器负责生成、管理,其依赖关系也由 IoC 容器负责管理 。因此,AOP 代理可以直接使用容器中的其他 Bean 实例作为目标,这种关系可由 IoC 容器的依赖注入提供。Spring 默认使用 Java 动态代理来创建 AOP 代理 , 这样就可以为任何接口实例创建代理了。当需要代理的类不是代理接口的时候, Spring 自动会切换为使用 CGLIB 代理,也可强制使用 CGLIB 。
AOP 编程其实是很简单的事情。纵观 AOP 编程, 其中需要程序员参与的只有三个部分:
- 定义普通业务组件。
- 定义切入点,一个切入点可能横切多个业务组件。
- 定义增强处理,增强处理就是在 AOP 框架为普通业务组件织入的处理动作。
所以进行 AOP 编程的关键就是定义切入点和定义增强处理。一旦定义了合适的切入点和增强处理,AOP 框架将会自动生成 AOP 代理,即:代理对象的方法 = 增强处理 + 被代理对象的方法 。
五、Spring 中 AOP 的实现。
Spring 有如下两种选择来定义切入点和增强处理。
- 基于 Annotation 的“零配置”方式:使用@Aspect、@Pointcut等 Annotation 来标注切入点和增强处理。
- 基于 XML 配置文件的管理方式:使用 Spring 配置文件来定义切入点和增强点。
1、基于 Annotation 的“零配置”方式。
(1)、首先启用 Spring 对 @AspectJ 切面配置的支持。
- <?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:aop="http://www.springframework.org/schema/aop"
- xsi:schemaLocation="http://www.springframework.org/schema/beans
- http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
- http://www.springframework.org/schema/aop
- http://www.springframework.org/schema/beans/spring-aop-3.0.xsd">
- <!-- 启动对@AspectJ 注解的支持 -->
- <aop:aspectj-autoproxy/>
- </beans>
如果不打算使用 Spring 的 XML Schema 配置方式,则应该在 Spring 配置文件中增加如下片段来启用@AspectJ 支持。
- <!-- 启用 @AspectJ 支持 -->
- <bean class = "org.springframeword.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />
(2)、定义切面 Bean。
当启动了@AspectJ 支持后,只要在 Spring 容器中配置一个带@Aspect 注释的 Bean, Spring 将会自动识别该 Bean 并作为切面处理。
- // 使用@Aspect 定义一个切面类
- @Aspect
- public class LogAspect {
- // 定义该类的其他内容
- ...
- }
(3)、定义 Before 增强处理。
- // 定义一个切面
- @Aspect
- public class BeforeAdviceTest {
- // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点
- @Before ( "execution(* com.wicresoft.app.service.impl.*.*(..))" )
- public void authorith(){
- System.out.println("模拟进行权限检查。" );
- }
- }
上面使用@Before Annotation 时,直接指定了切入点表达式,指定匹配 com.wicresoft.app.service.impl包下所有类的所有方法执行作为切入点。
关于这个表达式的规则如下图。
(4)、定义 AfterReturning 增强处理。
- // 定义一个切面
- @Aspect
- public class AfterReturningAdviceTest {
- // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点
- @AfterReturning (returning= "rvt" , pointcut= "execution(* com.wicresoft.app.service.impl.*.*(..))" )
- public void log(Object rvt) {
- System.out.println("模拟目标方法返回值:" + rvt);
- System.out.println("模拟记录日志功能..." );
- }
- }
(5)、定义 AfterThrowing 增强处理。
- // 定义一个切面
- @Aspect
- public class AfterThrowingAdviceTest {
- // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点
- @AfterThrowing (throwing= "ex" , pointcut= "execution(* com.wicresoft.app.service.impl.*.*(..))" )
- public void doRecoverActions(Throwable ex) {
- System.out.println("目标方法中抛出的异常:" + ex);
- System.out.println("模拟抛出异常后的增强处理..." );
- }
- }
(6)、定义 After 增强处理。
After 增强处理与AfterReturning 增强处理有点相似,但也有区别:
-
AfterReturning 增强处理处理只有在目标方法成功完成后才会被织入。
- After 增强处理不管目标方法如何结束(保存成功完成和遇到异常中止两种情况),它都会被织入。
- // 定义一个切面
- @Aspect
- public class AfterAdviceTest {
- // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点
- @After ( "execution(* com.wicresoft.app.service.impl.*.*(..))" )
- public void release() {
- System.out.println("模拟方法结束后的释放资源..." );
- }
- }
(7)、Around 增强处理
Around 增强处理近似等于 Before 增强处理和 AfterReturning 增强处理的总和。它可改变执行目标方法的参数值,也可改变目标方法之后的返回值。
- // 定义一个切面
- @Aspect
- public class AroundAdviceTest {
- // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点
- @Around ( "execution(* com.wicresoft.app.service.impl.*.*(..))" )
- public Object processTx(ProceedingJoinPoint jp) throws java.lang.Throwable {
- System.out.println("执行目标方法之前,模拟开始事物..." );
- // 执行目标方法,并保存目标方法执行后的返回值
- Object rvt = jp.proceed(new String[]{ "被改变的参数" });
- System.out.println("执行目标方法之前,模拟结束事物..." );
- return rvt + "新增的内容" ;
- }
- }
(8)、访问目标方法的参数。
访问目标方法最简单的做法是定义增强处理方法时将第一个参数定义为 JoinPoint 类型,当该增强处理方法被调用时,该 JoinPoint 参数就代表了织入增强处理的连接点。JoinPoint 里包含了如下几个常用方法。
- Object[] getArgs(): 返回执行目标方法时的参数。
- Signature getSignature(): 返回被增强的方法的相关信息。
- Object getTarget(): 返回被织入增强处理的目标对象。
- Object getThis(): 返回 AOP 框架为目标对象生成的代理对象。
提示 :当时使用 Around 处理时,我们需要将第一个参数定义为 ProceedingJoinPoint 类型,该类型是 JoinPoint 类型的子类 。
(9)、定义切入点。
所谓切入点,其实质就是为一个切入点表达式起一个名称,从而允许在多个增强处理中重用该名称。
Spring 切入点定义包含两个部分:
- 一个切入点表达式。
- 一个包含名字和任意参数的方法签名。
- // 使用@Pointcut Annotation 时指定切入点表达式
- @pointcut ( "execution * transfer(..)" )
- // 使用一个返回值为void,方法体为空的方法来命名切入点
- private void anyOldTransfer(){}
- // 使用上面定义的切入点
- @AfterReturning (pointcut= "anyOldTransfer()" , returning= "reVal" )
- public void writeLog(String msg, Object reVal){
- ...
- }
2、基于 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:aop="http://www.springframework.org/schema/aop"
- xsi:schemaLocation="http://www.springframework.org/schema/beans
- http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
- http://www.springframework.org/schema/aop
- http://www.springframework.org/schema/beans/spring-aop-3.0.xsd">
- <aop:config>
- <!-- 将 fourAdviceBean 转换成切面 Bean, 切面 Bean 的新名称为:fourAdviceAspect,指定该切面的优先级为2 -->
- <aop:aspect id="fourAdviceAspect" ref= "fourAdviceBean" order= "2" >
- <!-- 定义个After增强处理,直接指定切入点表达式,以切面 Bean 中的 Release() 方法作为增强处理方法 -->
- <aop:after pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method= "release" />
- <!-- 定义个Before增强处理,直接指定切入点表达式,以切面 Bean 中的 authority() 方法作为增强处理方法 -->
- <aop:before pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method= "authority" />
- <!-- 定义个AfterReturning增强处理,直接指定切入点表达式,以切面 Bean 中的 log() 方法作为增强处理方法 -->
- <aop:after-returning pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method= "log" />
- <!-- 定义个Around增强处理,直接指定切入点表达式,以切面 Bean 中的 processTx() 方法作为增强处理方法 -->
- <aop:around pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method= "processTx" />
- </aop:aspect>
- </aop:config>
- <!-- 省略各个Bean 的配置 -->
- <!-- ... -->
- </beans>
- 配置切入点
- <?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:aop="http://www.springframework.org/schema/aop"
- xsi:schemaLocation="http://www.springframework.org/schema/beans
- http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
- http://www.springframework.org/schema/aop
- http://www.springframework.org/schema/beans/spring-aop-3.0.xsd">
- <aop:config>
- <!-- 定义一个切入点,myPointcut,直接知道它对应的切入点表达式 -->
- <aop:pointcut id="myPointcut" expression= "execution(* com.wicresoft.app.service.impl.*.*(..))" method= "release" />
- <aop:aspect id="afterThrowingAdviceAspect" ref= "afterThrowingAdviceBean" order= "1" >
- <!-- 使用上面定于切入点定义增强处理 -->
- <!-- 定义一个AfterThrowing 增强处理,指定切入点以切面 Bean 中的 doRecovertyActions() 方法作为增强处理方法 -->
- <aop:after-throwing pointcut-ref="myPointcut" method= "doRecovertyActions" throwing= "ex" />
- </aop:aspect>
- </aop:config>
- <!-- 省略各个Bean 的配置 -->
- <!-- ... -->
- </beans>
发表评论
-
properties 文件 属性值换行
2013-09-24 16:33 2129在项目开发中遇到属性文件propertie ... -
扩展PropertyPlaceholderConfigurer对prop文件中的属性加密
2013-09-24 13:53 7100转载:http://my.oschina.net/noah ... -
精通有状态vs无状态(Stateful vs Stateless)—Immutable模式之姐妹篇
2013-09-10 18:06 2159今天给别人解释 Stateful vs Stateless ... -
Spring的DTD验证
2013-03-28 15:45 3775转载:http://a123159521.iteye. ... -
用spring annotation声明的bean,当打包在jar中时,无法被扫描到
2012-10-16 16:33 1233我们项目是由N个工程组成的,外围工程是web工程,内部的工程打 ... -
what’s new in spring 3
2012-10-15 21:35 1177spring3发布已经很久了,但现在为止还不太清楚spring ... -
利用AbstractRoutingDataSource实现动态数据源切换(Spring+Ibatis)
2012-10-14 15:49 3503Spring+Ibatis 与 Spring+Hibernat ... -
利用AbstractRoutingDataSource实现动态数据源切换 (二、Spring+Hibernate)
2012-10-14 13:55 2762用spring 的AbstractRoutingData ... -
利用AbstractRoutingDataSource实现动态数据源切换 (一、Spring+Hibernate)
2012-10-14 13:26 23400在Spring 2.0.1中引入了AbstractR ... -
Spring中的destroy-method方法
2012-05-20 12:29 21993转载:http://technoboy.iteye.com/b ... -
Spring事务(一)
2012-02-26 17:48 953一、Spring中定义了5中不同的事务隔离级别 1 ... -
Spring容器启动过程
2011-09-17 22:58 1802一、一切从手动启动IoC ... -
Spring AOP续
2011-09-03 16:37 1421三 AOP的实现方式---Proxy Spring默认使用J2 ... -
Web开发中获取Spring的ApplicationContext的几种方式
2011-08-24 21:49 11928在 WEB 开发中,获取到由 Spring 进行管理的某些 B ...
相关推荐
3、对spring aop认识模糊的,不清楚如何实现Java 自定义注解的 4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑...
spring aop jar 包
描述一下Spring AOP? 在Spring AOP中关注点(concern)和横切关注点(cross-cutting concern)有什么不同? AOP有哪些可用的实现? Spring中有哪些不同的通知类型(advice types)? Spring AOP 代理是什么? 引介...
基于注解实现SpringAop基于注解实现SpringAop基于注解实现SpringAop
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理(csdn)————程序
spring aop切面拦截指定类和方法实现流程日志跟踪 一般情况下,在不侵入业务代码的情况下,需要做流程日志跟踪是比较合理的 采用springaop切面思想
AOP的意思就是面向切面编程。本文主要是通过梳理JDK中自带的反射机制,实现 AOP动态代理模式,这也是Spring AOP 的实现原理
springaop依赖的jar包,spring版本2.5.6,如果需要,可以下载使用,欢迎各位评论指出不足
springAOP配置实现动态代理,有利于熟悉动态代理原理,深入了解spring。
Spring源码最难问题:当Spring AOP遇上循环依赖.docx
spring aop的demo spring aop的demo
Spring AOP 入门 作者:廖雪峰
spring aop spring aop spring aop spring aop spring aop spring aop spring aop spring aop spring aop
Spring AOP 日志管理 实例LoggingThrowsAdvice.java
Spring AOP 几个不同使用方法的完整例子,使用Junit4c测试, 在我的博客上有不同配置组合的说明,可以参考
Spring AOP的实现机制中文版,动态代理及原理,自定义类加载器
Spring AOP简单demo 入门级的 advice
springAOP详解
spring aop 经典例子(原创),无论新手还是老手,可以快速对Spring AOP有个总体的认识。基于JDK1.6,Spring2.0.5,Eclipse IDE。
springaop多数据库读写分离