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.
升级会员 