接上一篇Spring AOP 的实现原理(1):
上面类中出现的Logger类和Level枚举还是和上一上例子的实现是一样的.这里就不贴出代码了.
让我们写一个Test类去测试一下.代码如下:
Test.java
1
package
sinosoft.dj.aop.proxyaop;
2
3
public
class
Test
{
4
public
static
void
main(String[] args)
{
5
IHello hello
=
(IHello)
new
DynaProxyHello().bind(
new
Hello());
6
hello.sayGoogBye(
"
Double J
"
);
7
hello.sayHello(
"
Double J
"
);
8
9
}
10
}
11
运行输出的结果如下:
Tue Mar
04
21
:
24
:
03
CST
2008
sayGoogBye Method end
.
Double J GoodBye!
2008
-
3
-
4
21
:
24
:
03
sayGoogBye Method Start!
Tue Mar
04
21
:
24
:
03
CST
2008
sayHello Method end
.
Hello Double J
2008
-
3
-
4
21
:
24
:
03
sayHello Method Start!
由于线程的关系,第二个方法的开始出现在第一个方法的结束之前.这不是我们所关注的!
从上面的例子我们看出.只要你是采用面向接口编程,那么,你的任何对象的方法执行之前要加上记录日志的操作都是可以的.他(DynaPoxyHello)
自动去代理执行被代理对象(Hello)中的每一个方法,一个java.lang.reflect.InvocationHandler接口就把我们的代
理对象和被代理对象解藕了.但是,我们又发现还有一个问题,这个DynaPoxyHello对象只能跟我们去在方法前后加上日志记录的操作.我们能不能把
DynaPoxyHello对象和日志操作对象(Logger)解藕呢?
结果是肯定的.让我们来分析一下我们的需求.
我们要在被代理对象的方法前面或者后面去加上日志操作代码(或者是其它操作的代码),
那么,我们可以抽象出一个接口,这个接口里就只有两个方法,一个是在被代理对象要执行方法之前执行的方法,我们取名为start,第二个方法就是在被代理对象执行方法之后执行的方法,我们取名为end .接口定义如下 :
1
package
sinosoft.dj.aop.proxyaop;
2
3
import
java.lang.reflect.Method;
4
5
public
interface
IOperation
{
6
/** */
/**
7
* 方法执行之前的操作
8
*
@param
method
9
*/
10
void
start(Method method);
11
/** */
/**
12
* 方法执行之后的操作
13
*
@param
method
14
*/
15
void
end(Method method);
16
}
17
我们去写一个实现上面接口的类.我们把作他真正的操作者,如下面是日志操作者的一个类:
LoggerOperation.java
package
sinosoft.dj.aop.proxyaop;
import
java.lang.reflect.Method;
public
class
LoggerOperation
implements
IOperation
{
public
void
end(Method method)
{
Logger.logging(Level.DEBUGE, method.getName()
+
"
Method end
.
"
);
}
public
void
start(Method method)
{
Logger.logging(Level.INFO, method.getName()
+
"
Method Start!
"
);
}
}
然后我们要改一下代理对象DynaProxyHello中的代码.如下:
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
*/
11
private
Object proxy;
12
/** */
/**
13
* 要处理的对象(也就是我们要在方法的前后加上业务逻辑的对象,如例子中的Hello)
14
*/
15
private
Object delegate;
16
17
/** */
/**
18
* 动态生成方法被处理过后的对象 (写法固定)
19
*
20
*
@param
delegate
21
*
@param
proxy
22
*
@return
23
*/
24
public
Object bind(Object delegate,Object proxy)
{
25
26
this
.proxy
=
proxy;
27
this
.delegate
=
delegate;
28
return
Proxy.newProxyInstance(
29
this
.delegate.getClass().getClassLoader(),
this
.delegate
30
.getClass().getInterfaces(),
this
);
31
}
32
/** */
/**
33
* 要处理的对象中的每个方法会被此方法送去JVM调用,也就是说,要处理的对象的方法只能通过此方法调用
34
* 此方法是动态的,不是手动调用的
35
*/
36
public
Object invoke(Object proxy, Method method, Object[] args)
37
throws
Throwable
{
38
Object result
=
null
;
39
try
{
40
//
反射得到操作者的实例
41
Class clazz
=
this
.proxy.getClass();
42
//
反射得到操作者的Start方法
43
Method start
=
clazz.getDeclaredMethod(
"
start
"
,
44
new
Class[]
{ Method.
class
}
);
45
//
反射执行start方法
46
start.invoke(
this
.proxy,
new
Object[]
{ method }
);
47
//
执行要处理对象的原本方法
48
result
=
method.invoke(
this
.delegate, args);
49
//
反射得到操作者的end方法
50
Method end
=
clazz.getDeclaredMethod(
"
end
"
,
51
new
Class[]
{ Method.
class
}
);
52
//
反射执行end方法
53
end.invoke(
this
.proxy,
new
Object[]
{ method }
);
54
55
}
catch
(Exception e)
{
56
e.printStackTrace();
57
}
58
return
result;
59
}
60
61
}
62
然后我们把Test.java中的代码改一下.测试一下:
package
sinosoft.dj.aop.proxyaop;
public
class
Test
{
public
static
void
main(String[] args)
{
IHello hello
=
(IHello)
new
DynaProxyHello().bind(
new
Hello(),
new
LoggerOperation());
hello.sayGoogBye(
"
Double J
"
);
hello.sayHello(
"
Double J
"
);
}
}
结果还是一样的吧.
如果你想在每个方法之前加上日志记录,而不在方法后加上日志记录.你就把LoggerOperation类改成如下:
1
package
sinosoft.dj.aop.proxyaop;
2
3
import
java.lang.reflect.Method;
4
5
public
class
LoggerOperation
implements
IOperation
{
6
7
public
void
end(Method method)
{
8
//
Logger.logging(Level.DEBUGE, method.getName() + " Method end
.");
9
}
10
11
public
void
start(Method method)
{
12
Logger.logging(Level.INFO, method.getName()
+
"
Method Start!
"
);
13
}
14
15
}
16
运行一下.你就会发现,每个方法之后没有记录日志了. 这样,我们就把代理者和操作者解藕了!
下面留一个问题给大家,如果我们不想让所有方法都被日志记录,我们应该怎么去解藕呢.?
我的想法是在代理对象的public Object invoke(Object proxy, Method method, Object[]
args)方法里面加上个if(),对传进来的method的名字进行判断,判断的条件存在XML里面.这样我们就可以配置文件时行解藕了.如果有兴趣的
朋友可以把操作者,被代理者,都通过配置文件进行配置 ,那么就可以写一个简单的SpringAOP框架了.
分享到:
相关推荐
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则在此基础上提供了更高级的抽象,让我们可以方便地定义和管理切面,从而实现更灵活的...
2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑实现 (需要知道原理的请看spring aop源码,此处不做赘述) 3、可在现有源码上快速进行功能扩展 4、spring boot,mybatis,druid,spring aop的使用
本示例将简要介绍如何在Spring应用中实现AOP,通过实际的代码示例帮助理解其工作原理。 首先,我们要理解AOP的核心概念。AOP是一种编程范式,它允许开发者定义“切面”(Aspects),这些切面封装了特定的关注点,如...
6. **代理(Proxy)**:Spring AOP通过动态代理实现切面的织入。对于接口,使用JDK动态代理;对于非接口类,使用CGLIB动态代理。 Spring的IOC和AOP机制使得开发者能够更专注于业务逻辑,而不是繁琐的依赖管理和横切...
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的基本概念来深入...
Spring AOP,全称Aspect Oriented Programming,即面向切面编程,是Spring框架的一个重要特性,用于实现横切关注点的模块化。AOP通过在运行时动态地将代码编织到一起,使得我们可以在不修改原有业务代码的情况下,对...
本篇文章将深入探讨如何使用Spring AOP实现性能监控器,并通过源码分析来理解其工作原理。 首先,我们要了解AOP的核心概念——切面(Aspect)、通知(Advice)、连接点(Join Point)、切入点(Pointcut)和织入...
可以帮助我们更好地理解其工作原理,例如,可以查看`org.springframework.aop.framework.ProxyFactoryBean`、`org.springframework.aop.aspectj.autoproxy.AspectJProxyFactoryBean`、`org.springframework.aop....
- **事务管理**:通过AOP实现声明式事务管理,简化事务控制代码。 - **性能监控**:在关键方法前、后插入性能计时通知,便于性能分析。 - **权限校验**:在方法执行前进行用户权限验证,确保安全。 5. **源码...
AOP(Aspect-Oriented Programming,面向方面编程)是一种编程范式,旨在提供更好的模块化和组织代码的方式,...通过理解Spring AOP的实现原理,开发者可以更好地设计和优化应用程序,提升系统架构的灵活性和可扩展性。
综上所述,SpringBoot结合AspectJ实现SpringAOP拦截指定方法,主要涉及到Spring AOP的原理、切点和通知的定义、自定义注解的使用,以及如何在SpringBoot项目中整合AspectJ进行更复杂的切面编程。通过这些知识点,...