转自一篇个人觉得写得很好的Spring AOP关于面向切面编程的文章。
http://www.blogjava.net/DoubleJ/archive/2008/03/04/183796.html
好长时间没有用过Spring了. 突然拿起书.我都发现自己对AOP都不熟悉了.
其实AOP的意思就是面向切面编程.
OO注重的是我们解决问题的方法(封装成Method),而AOP注重的是许多解决解决问题的方法中的共同点,是对OO思想的一种补充!
还是拿人家经常举的一个例子讲解一下吧:
比如说,我们现在要开发的一个应用里面有很多的业务方法,但是,我们现在要对这个方法的执行做全面监控,或部分监控.也许我们就会在要一些方法前去加上一条日志记录,
我们写个例子看看我们最简单的解决方案
我们先写一个接口IHello.java代码如下:
1
package
sinosoft.dj.aop.staticaop;
2
3
public
interface
IHello
{
4
/** */
/**
5
* 假设这是一个业务方法
6
*
@param
name
7
*/
8
void
sayHello(String name);
9
}
10
里面有个方法,用于输入"Hello" 加传进来的姓名;我们去写个类实现IHello接口
package
sinosoft.dj.aop.staticaop;
public
class
Hello
implements
IHello
{
public
void
sayHello(String name)
{
System.out.println(
"
Hello
"
+
name);
}
}
现在我们要为这个业务方法加上日志记录的业务,我们在不改变原代码的情况下,我们会去怎么做呢?也许,你会去写一个类去实现IHello接口,并依赖Hello这个类.代码如下:
1
package
sinosoft.dj.aop.staticaop;
2
3
public
class
HelloProxy
implements
IHello
{
4
private
IHello hello;
5
6
public
HelloProxy(IHello hello)
{
7
this
.hello
=
hello;
8
}
9
10
public
void
sayHello(String name)
{
11
Logger.logging(Level.DEBUGE,
"
sayHello method start
.
"
);
12
hello.sayHello(name);
13
Logger.logging(Level.INFO,
"
sayHello method end!
"
);
14
15
}
16
17
}
18
其中.Logger类和Level枚举代码如下:
Logger.java
1
package
sinosoft.dj.aop.staticaop;
2
3
import
java.util.Date;
4
5
public
class
Logger
{
6
/** */
/**
7
* 根据等级记录日志
8
*
@param
level
9
*
@param
context
10
*/
11
public
static
void
logging(Level level, String context)
{
12
if
(level.equals(Level.INFO))
{
13
System.out.println(
new
Date().toLocaleString()
+
"
"
+
context);
14
}
15
if
(level.equals(Level.DEBUGE))
{
16
System.err.println(
new
Date()
+
"
"
+
context);
17
}
18
}
19
20
}
21
Level.java
1
package
sinosoft.dj.aop.staticaop;
2
3
public
enum
Level
{
4
INFO,DEBUGE;
5
}
6
那我们去写个测试类看看,代码如下:
Test.java
1
package
sinosoft.dj.aop.staticaop;
2
3
public
class
Test
{
4
public
static
void
main(String[] args)
{
5
IHello hello
=
new
HelloProxy(
new
Hello());
6
hello.sayHello(
"
Doublej
"
);
7
}
8
}
9
运行以上代码我们可以得到下面结果:
Tue Mar
04
20
:
57
:
12
CST
2008
sayHello method start
.
Hello Doublej
2008
-
3
-
4
20
:
57
:
12
sayHello method end!
从上面的代码我们可以看出,hello对象是被HelloProxy这个所谓的代理态所创建的.这样,如果我们以后要把日志记录的功能去掉.那我们只要把得到hello对象的代码改成以下:
1
package
sinosoft.dj.aop.staticaop;
2
3
public
class
Test
{
4
public
static
void
main(String[] args)
{
5
IHello hello
=
new
Hello();
6
hello.sayHello(
"
Doublej
"
);
7
}
8
}
9
上面代码,可以说是AOP最简单的实现!
但是我们会发现一个问题,如果我们像Hello这样的类很多,那么,我们是不是要去写很多个HelloProxy这样的类呢.没错,是的.其实也是一种很
麻烦的事.在jdk1.3以后.jdk跟我们提供了一个API java.lang.reflect.InvocationHandler的类.
这个类可以让我们在JVM调用某个类的方法时动态的为些方法做些什么事.让我们把以上的代码改一下来看看效果.
同样,我们写一个IHello的接口和一个Hello的实现类.在接口中.我们定义两个方法;代码如下 :
IHello.java
1
package
sinosoft.dj.aop.proxyaop;
2
3
public
interface
IHello
{
4
/** */
/**
5
* 业务处理A方法
6
*
@param
name
7
*/
8
void
sayHello(String name);
9
/** */
/**
10
* 业务处理B方法
11
*
@param
name
12
*/
13
void
sayGoogBye(String name);
14
}
15
Hello.java
1
package
sinosoft.dj.aop.proxyaop;
2
3
public
class
Hello
implements
IHello
{
4
5
public
void
sayHello(String name)
{
6
System.out.println(
"
Hello
"
+
name);
7
}
8
public
void
sayGoogBye(String name)
{
9
System.out.println(name
+
"
GoodBye!
"
);
10
}
11
}
12
我们一样的去写一个代理类.只不过.让这个类去实现java.lang.reflect.InvocationHandler接口,代码如下:
1
package
sinosoft.dj.aop.proxyaop;
2
3
import
java.lang.reflect.InvocationHandler;
4
import
java.lang.reflect.Method;
5
import
java.lang.reflect.Proxy;
6
7
public
class
DynaProxyHello
implements
InvocationHandler
{
8
9
/** */
/**
10
* 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
11
*/
12
private
Object delegate;
13
14
/** */
/**
15
* 动态生成方法被处理过后的对象 (写法固定)
16
*
17
*
@param
delegate
18
*
@param
proxy
19
*
@return
20
*/
21
public
Object bind(Object delegate)
{
22
this
.delegate
=
delegate;
23
return
Proxy.newProxyInstance(
24
this
.delegate.getClass().getClassLoader(),
this
.delegate
25
.getClass().getInterfaces(),
this
);
26
}
27
/** */
/**
28
* 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用
29
* 此方法是动态的,不是手动调用的
30
*/
31
public
Object invoke(Object proxy, Method method, Object[] args)
32
throws
Throwable
{
33
Object result
=
null
;
34
try
{
35
//
执行原来的方法之前记录日志
36
Logger.logging(Level.DEBUGE, method.getName()
+
"
Method end
.
"
);
37
38
//
JVM通过这条语句执行原来的方法(反射机制)
39
result
=
method.invoke(
this
.delegate, args);
40
//
执行原来的方法之后记录日志
41
Logger.logging(Level.INFO, method.getName()
+
"
Method Start!
"
);
42
}
catch
(Exception e)
{
43
e.printStackTrace();
44
}
45
//
返回方法返回值给调用者
46
return
result;
47
}
48
49
}
50
上面类中出现的Logger类和Level枚举还是和上一上例子的实现是一样的.这里就不贴出代码了.
下一篇继续,写不完了!
分享到:
相关推荐
NULL 博文链接:https://zhang-yingjie-qq-com.iteye.com/blog/319927
Spring框架中的AOP模块使用了动态代理来实现AOP概念。Spring AOP允许开发者定义切面,并在这些切面中指定拦截的方法。Spring AOP支持不同的代理策略,包括JDK动态代理和CGLIB代理。如果被代理的类没有实现接口,...
**Spring AOP 实现机制详解** Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许程序员在不修改源代码的情况下,通过“切面”来插入额外的业务逻辑,如日志、事务管理等。AOP的引入极大地提高了代码的...
Spring AOP 实现原理详解之 AOP 切面的实现 Spring AOP 是基于 IOC 的 Bean 加载来实现的,本文主要介绍 Spring AOP 原理解析的切面实现过程。AOP 切面的实现是将切面类的所有切面方法根据使用的注解生成对应 ...
### Spring AOP面向方面编程原理:AOP概念详解 #### 一、引言 随着软件系统的日益复杂,传统的面向对象编程(OOP)逐渐暴露出难以应对某些横切关注点(cross-cutting concerns)的问题。为了解决这一挑战,面向方面编程...
本文将深入探讨Spring AOP的实现原理,以及如何使用反射来实现动态代理模式。 首先,我们需要了解AOP的基本概念。AOP的核心思想是切面,它包含两个主要部分:切点(Pointcut)和通知(Advice)。切点定义了在程序...
总的来说,JDK动态代理是Spring AOP实现的基础,它允许我们在运行时动态创建代理对象,实现对方法调用的拦截和增强。Spring AOP则在此基础上提供了更高级的抽象,让我们可以方便地定义和管理切面,从而实现更灵活的...
本示例将简要介绍如何在Spring应用中实现AOP,通过实际的代码示例帮助理解其工作原理。 首先,我们要理解AOP的核心概念。AOP是一种编程范式,它允许开发者定义“切面”(Aspects),这些切面封装了特定的关注点,如...
2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 (需要知道原理的请看spring aop源码,此处不做赘述) 3、可在现有源码上快速进行功能扩展 4、spring boot,mybatis,druid,spring aop的使用
1. **切面**:AOP中的切面是包含横切关注点的模块,它可以是类或接口,Spring通过代理实现切面的织入。 2. **通知(Advice)**:是切面在特定连接点执行的动作,如前置通知(Before)、后置通知(After)、返回通知...
二、Spring AOP实现原理 1. **代理模式**:Spring AOP采用动态代理技术实现,主要有两种代理方式:JDK动态代理和CGLIB代理。JDK代理用于接口类,CGLIB代理则针对无接口或非代理接口的类。 2. **切面(Aspect)**:...
4. **事务管理Demo**:结合Spring的事务管理特性,展示了如何使用AOP实现数据库操作的事务控制。 通过这些示例,你可以深入理解Spring AOP的工作原理,掌握其配置和使用方式,从而在实际项目中灵活地应用切面编程,...
Spring AOP 的底层实现技术 --- Jdk 动态代理原理 JDK 动态代理是 Spring AOP 的底层实现技术,允许开发者在运行期创建接口的代理实例。在 JDK 1.3 以后,JDK 动态代理技术提供了实现 AOP 的绝好底层技术。JDK 动态...
在深入理解 Spring AOP 的源码时,需要熟悉 Spring IoC 的工作原理,以及 AOP 相关的概念,如切点表达式、通知类型等。了解这些基础知识可以帮助我们更好地掌握 Spring AOP 的实现细节。在分析源码时,可以参考作者...
在Spring框架中,AOP(面向切面编程)就是基于Java动态代理来完成的,用于实现横切关注点,如日志、事务管理等。这篇博客的文章链接虽然没有给出具体内容,但我们可以根据Java动态代理和Spring AOP的基本概念来深入...
1. 首先,Spring会检查目标类是否实现了接口,如果实现了接口,那么Spring会选择JDK动态代理;如果没有实现接口,Spring则会选择Cglib代理。 2. 使用Cglib的Enhancer类,它是Cglib的核心,用于创建代理对象。...
本篇文章将深入探讨如何使用Spring AOP实现性能监控器,并通过源码分析来理解其工作原理。 首先,我们要了解AOP的核心概念——切面(Aspect)、通知(Advice)、连接点(Join Point)、切入点(Pointcut)和织入...
可以帮助我们更好地理解其工作原理,例如,可以查看`org.springframework.aop.framework.ProxyFactoryBean`、`org.springframework.aop.aspectj.autoproxy.AspectJProxyFactoryBean`、`org.springframework.aop....
- **事务管理**:通过AOP实现声明式事务管理,简化事务控制代码。 - **性能监控**:在关键方法前、后插入性能计时通知,便于性能分析。 - **权限校验**:在方法执行前进行用户权限验证,确保安全。 5. **源码...
Spring AOP的实现原理包括以下几个关键点: 1. **切面(Aspect)**:切面是AOP的核心,它封装了特定的横切关注点,如日志、事务管理。切面通常由一个或多个通知(advises)组成。 2. **通知(Advice)**:通知是切...