Spring提供俩种方式实现AOPWord下载.docx

Spring提供俩种方式实现AOPWord下载.docx

《Spring提供俩种方式实现AOPWord下载.docx》由会员分享，可在线阅读，更多相关《Spring提供俩种方式实现AOPWord下载.docx（43页珍藏版）》请在冰豆网上搜索。

5. 

public 

void 

transferFunds（String 

from, 

String 

to, 

int 

amount） 

6. 

sysLogger.log（"

transfer 

funds 

from 

"

+ 

to 

to）;

7. 

if（authMgr.accessAble（from） 

&

authMgr.accessAble（to）） 

8. 

access 

successfully"

）;

9. 

CustomerAccount 

findAccount（from）;

10. 

findAccount（to）;

11. 

from.debit（amount）;

12. 

to.credit（amount）;

13. 

} 

else 

14. 

deny"

15. 

16. 

$"

amount 

successfully!

17. 

18.} 

publicclassAccountManager{

privatestaticfinalsysLogger=SystemLogger.getInstance（）;

privateAuthorizationManagerauthMgr=newAuthorizationManager（）;

publicvoidtransferFunds（Stringfrom,Stringto,intamount）{

sysLogger.log（"

transferfundsfrom"

+from+"

to"

+to）;

if（authMgr.accessAble（from）&

authMgr.accessAble（to））{

sysLogger.log（"

accesssuccessfully"

CustomerAccountfrom=findAccount（from）;

CustomerAccountto=findAccount（to）;

from.debit（amount）;

to.credit（amount）;

}else{

accessdeny"

}

+to+"

$"

+amount+"

successfully!

}

}

这个例子虽然是很好的面向对象代码,但是在业务处理逻辑中夹杂这日志处理和权限判断,变得复杂混乱.

在AOP中，正交关注点（如安全和日志记录）被识别为系统中的常见横切关注点。

说它们是横切,

是因为它们总是切入模块（如包、类和代码文件）的多个单位。

也许横切关注点可能不是核心业务逻辑的一部分,但是它们是应用程序的基本部分。

AOP的实现主要是通过方法的拦截实现.在不使用AOP框架的情况下,我们可以通过JDK提供的动态代理来实现方法的拦截

注意:

使用JDK提供的动态代理实现

要求我们的目标对象必须实现接口

IUserBean接口

1.package 

com.royzhou.aop;

3.public 

interface 

IUserBean 

getUser（）;

addUser（）;

updateUser（）;

deleteUser（）;

12.} 

packagecom.royzhou.aop;

publicinterfaceIUserBean{

publicvoidgetUser（）;

publicvoidaddUser（）;

publicvoidupdateUser（）;

publicvoiddeleteUser（）;

IUserBean实现类UserBean.java

UserBean 

implements 

user 

null;

UserBean（） 

UserBean（String 

user） 

this.user 

user;

setUser（String 

18. 

addUser（） 

19. 

System.out.println（"

this 

is 

method!

20. 

21. 

22. 

deleteUser（） 

23. 

24. 

25. 

26. 

getUser（） 

27. 

28. 

29. 

30. 

updateUser（） 

31. 

32. 

33.} 

publicclassUserBeanimplementsIUserBean{

privateStringuser=null;

publicUserBean（）{

publicUserBean（Stringuser）{

this.user=user;

publicvoidsetUser（Stringuser）{

publicvoidaddUser（）{

System.out.println（"

thisisaddUser（）method!

publicvoiddeleteUser（）{

thisisdeleteUser（）method!

publicvoidgetUser（）{

thisisgetUser（）method!

publicvoidupdateUser（）{

thisisupdateUser（）method!

我们希望在UserBean执行方法之前先检查userName是不是为空,以此做为权限判断.

当然我们可以在没个方法里面去加这些判断,但是这需要为每个方法都添加同样的判断,维护不便.

使用JDK提供的动态代理技术可以很方便的实现上面的需求:

通过java.lang.reflect.Proxy;

提供的

publicstaticObjectnewProxyInstance（ClassLoaderloader,

Class<

?

>

[]interfaces,

InvocationHandlerh）

方法可以生成一个动态代理对象

其中

loader是类装载器

interfaces是目标对象实现的一系列接口

h是一个实现InvocationHandler接口的类,我们对代理对象的所有操作都经过它处理

这样我们就可以拦截到UserBean的方法,在方法执行前先判断是否有权限,如果有则执行方法,

没有权限的话就不执行方法.

编写我们的代理类:

JDKProxy.java

3.import 

java.lang.reflect.InvocationHandler;

4.import 

java.lang.reflect.Method;

5.import 

java.lang.reflect.Proxy;

7.public 

JDKProxy 

InvocationHandler 

Object 

targetObject;

createProxyObject（Object 

targetObject） 

this.targetObject 

//生成代理对象 

return 

Proxy.newProxyInstance（this.targetObject.getClass（）.getClassLoader（）,this.targetObject.getClass（）.getInterfaces（）,this）;

invoke（Object 

proxy, 

Method 

method, 

Object[] 

args） 

throws 

Throwable 

userBean 

（UserBean） 

userName 

userBean.getUserName（）;

result 

//权限判断 

if（userName!

=null 

!

.equals（userName）） 

//调用目标对象的方法 

method.invoke（targetObject, 

args）;

result;

28.} 

importjava.lang.reflect.InvocationHandler;

importjava.lang.reflect.Method;

importjava.lang.reflect.Proxy;

publicclassJDKProxyimplementsInvocationHandler{

privateObjecttargetObject;

publicObjectcreateProxyObject（ObjecttargetObject）{

this.targetObject=targetObject;

//生成代理对象

returnProxy.newProxyInstance（this.targetObject.getClass（）.getClassLoader（）,this.targetObject.getClass（）.getInterfaces（）,this）;

publicObjectinvoke（Objectproxy,Methodmethod,Object[]args）throwsThrowable{

UserBeanuserBean=（UserBean）targetObject;

StringuserName=userBean.getUserName（）;

Objectresult=null;

//权限判断

if（userName!

=null&

!

.equals（userName））{

//调用目标对象的方法

result=method.invoke（targetObject,args）;

}

returnresult;

通过调用createProxyObject可以生成代理对象,

编写测试类如下:

TestProxy 

main（String[] 

jProxy 

JDKProxy（）;

（IUserBean） 

jProxy.createProxyObject（new 

UserBean（"

royzhou"

））;

userBean.addUser（）;

10.} 

publicclassTestProxy{

publicstaticvoidmain（String[]args）{

JDKProxyjProxy=newJDKProxy（）;

IUserBeanuserBean=（IUserBean）jProxy.createProxyObject（newUserBean（"

userBean.addUser（）;

执行成功后输出:

再次修改测试类:

UserBean（））;

IUserBeanuserBean=（IUserBean）jProxy.createProxyObject（newUserBean（））;

即当用户没有权限时,控制台不输出东西,说明我们拦截方法对其做的权限判断生效了.

从上面这个例子可以成功拦截了调用的方法并对其做了相应的处理

如果不使用JDK提供的Proxy类

通过cglib创建代理类,好处是不要求我们的目标对象实现接口

Enhancerenhancer=newEnhancer（）;

enhancer.setSuperclass（this.targetObject.getClass（））;

enhancer.setCallback（this）;

//回调,参数是一个实现MethodInterceptor接口的类,我们对代理对象的所有操作都经过它处理

returnenhancer.create（）;

//创建代理对象

修改UserBean去掉IUserBean接口

userName） 

this.userName 

userName;

getUserName（） 

33. 

34. 

setUserName（String 

35. 

36. 

37.} 

publicclassUserBean{

privateStringuserName=null;

publicUserBean（StringuserName）{

this.userName=userName;

publicStringgetUserName（）{

returnuserName;

publicvoidsetUserName（StringuserName）{

通过cglib创建代理类

CGLibProxy.java

net.