Object serialization的定义：Object serialization 允许你将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象

javaBean实现java.io.Serializable接口的作用

日期:2007-05-02 01:41:02

所谓的Serializable,就是java提供的通用数据保存和读取的接口。 任何类型只要实现了Serializable接口，就可以被保存到文件中，或者作为数据流通过网络发送到别的地方。也可以用管道来传输到系统的其他程序中。 这样子极大的简化了类的设计。只要设计一个保存一个读取功能就能解决上面说得所有问题。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师

概述：CVS是一个C/S系统，多个开发人员通过一个中心版本控制系统来记录文件版本，从而达到保证文件同步的目的。 





CVS服务器（文件版本库） 

/ | \ 

（版 本 同 步） 

/ | \ 

开发者1 开发者2 开发者3 



以下是本文主要内容：开发人员可以主要挑选2, 6看就可以了，CVS的管理员则更需要懂的更多一些 



CVS环境初始化：CVS环境的搭建 管理员 

CVS的日常使用：日常开发中最常用的CVS命令， 开发人员 管理员 

CVS的分支开发：项目按照不同进度和目标并发进行 管理员 

CVS的用户认证：通过SSH的远程用户认证，安全，简单 管理员 

CVSWEB：CVS的WEB访问界面大大提高代码版本比较的效率 管理员 

CVS TAG：将$Id$加入代码注释中，方便开发过程的跟踪 开发人员 

CVS vs VSS: CVS和Virsual SourceSafe的比较 

一个系统20%的功能往往能够满足80%的需求，CVS也不例外，以下是CVS最常用的功能，可能用到的还不到它全部命令选项的10%，更多的功能请在实际应用过程中体会，学习过程中应该是用多少，学多少，用到了再学也不迟。 





CVS环境初始化 

============ 



环境设置：指定CVS库的路径CVSROOT 

tcsh 

setenv CVSROOT /path/to/cvsroot 

bash 

CVSROOT=/path/to/cvsroot ; export CVSROOT 



后面还提到远程CVS服务器的设置： 

CVSROOT=:ext:$USER@test.server.address#port:/path/to/cvsroot CVS_RSH=ssh; export CVSROOT CVS_RSH 



初始化：CVS版本库的初始化。 

cvs init 



一个项目的首次导入 

cvs import -m "write some comments here" project_name vendor_tag release_tag 

执行后：会将所有源文件及目录导入到/path/to/cvsroot/project_name目录下 

vender_tag: 开发商标记 

release_tag: 版本发布标记 



项目导出：将代码从CVS库里导出 

cvs checkout project_name 

cvs 将创建project_name目录，并将最新版本的源代码导出到相应目录中。这个checkout和Virvual SourceSafe中的check out不是一个概念，相对于Virvual SourceSafe的check out是cvs update， check in是cvs commit。 



CVS的日常使用 

============= 



注意：第一次导出以后，就不是通过cvs checkout来同步文件了，而是要进入刚才cvs checkout project_name导出的project_name目录下进行具体文件的版本同步（添加，修改，删除）操作。 



将文件同步到最新的版本： 

cvs update 

不制定文件名，cvs将同步所有子目录下的文件，也可以制定某个文件名/目录进行同步 

cvs update file_name 

最好每天开始工作前或将自己的工作导入到CVS库里前都要做一次，并养成“先同步 后修改”的习惯，和Virvual SourceSafe不同，CVS里没有文件锁定的概念，所有的冲突是在commit之前解决，如果你修改过程中，有其他人修改并commit到了CVS库中，CVS会通知你文件冲突，并自动将冲突部分用 

>>>>>> 

content on cvs server 

<<<<<< 

content in your file 

>>>>>> 

标记出来，由你确认冲突内容的取舍。 

版本冲突一般是在多个人修改一个文件造成的，但这种项目管理上的问题不应该指望由CVS来解决。 



确认修改写入到CVS库里： 

cvs commit -m "write some comments here" file_name 



注意：CVS的很多动作都是通过cvs commit进行最后确认并修改的，最好每次只修改一个文件。在确认的前，还需要用户填写修改注释，以帮助其他开发人员了解修改的原因。如果不用写-m "comments"而直接确认`cvs commit file_name` 的话，cvs会自动调用系统缺省的文字编辑器(一般是vi)要求你写入注释。 

注释的质量很重要：所以不仅必须要写，而且必须写一些比较有意义的内容：以方便其他开发人员能够很好的理解 

不好的注释，很难让其他的开发人员快速的理解：比如： -m "bug fixed" 甚至 -m "" 

好的注释，甚至可以用中文: -m "在用户注册过程中加入了Email地址校验" 



修改某个版本注释：每次只确认一个文件到CVS库里是一个很好的习惯，但难免有时候忘了指定文件名，把多个文件以同样注释commit到CVS库里了，以下命令可以允许你修改某个文件某个版本的注释： 

cvs admin -m 1.3:"write some comments here" file_name 



添加文件 

创建好新文件后，比如：touch new_file 

cvs add new_file 

注意：对于图片，Word文档等非纯文本的项目，需要使用cvs add -b选项，否则有可能出现文件被破坏的情况 

比如：cvs add -kb new_file.gif 

然后确认修改并注释 

cvs ci -m "write some comments here" 



删除文件： 

将某个源文件物理删除后，比如：rm file_name 

cvs rm file_name 

然后确认修改并注释 

cvs ci -m "write some comments here" 

以上面前2步合并的方法为： 

cvs rm -f file_name 

cvs ci -m "why delete file" 





注意：很多cvs命令都有缩写形式：commit=>ci; update=>up; checkout=>co; remove=>rm; 





添加目录： 

cvs add dir_name 



查看修改历史：cvs log file_name 

cvs history file_name 



查看当前文件不同版本的区别 

cvs diff -r1.3 -r1.5 file_name 

查看当前文件（可能已经修改了）和库中相应文件的区别 

cvs diff file_name 

cvs的web界面提供了更方便的定位文件修改和比较版本区别的方法，具体安装设置请看后面的cvsweb使用 



正确的通过CVS恢复旧版本的方法： 

如果用cvs update -r1.2 file.name 

这个命令是给file.name加一个STICK TAG： "1.2" ，虽然你的本意只是想将它恢复到1.2版本 

正确的恢复版本的方法是：cvs update -p -r1.2 file_name >file_name 

如果不小心已经加成STICK TAG的话：用cvs update -A 解决 



移动文件：文件重命名 

cvs里没有cvs move或cvs rename，因为这两个操作是先cvs remove old_file_name，然后cvs add new_file_name实现的。 



删除，移动目录： 

最方便的方法是让管理员直接移动，删除CVSROOT里相应目录（因为CVS一个项目下的子目录都是独立的，移动到$CVSROOT目录下都可以作为新的独立项目：好比一颗树，其实砍下任意一枝都能独立存活），对目录进行了修改后，要求其开发人员重新导出项目cvs checkout project_name 或者用cvs update -dP同步。 



CVS Branch：项目多分支同步开发 

============================= 



确认版本里程碑：多个文件各自版本号不一样，项目到一定阶段，可以给所有文件统一指定一个阶段里程碑版本号，方便以后按照这个阶段里程碑版本号导出项目，同时也是项目的多个分支开发的基础。 

cvs tag release_1_0 



开始一个新的里程碑： 

cvs commit -r 2 标记所有文件开始进入2.x的开发 



注意：CVS里的revsion和软件包的发布版本可以没有直接的关系。但所有文件使用和发布版本一致的版本号比较有助于维护。 



在开发项目的2.x版本的时候发现1.x有问题，但2.x又不敢用，则从先前标记的里程碑：release_1_0导出一个分支release_1_0_patch 

cvs rtag -b -r release_1_0 release_1_0_patch proj_dir 



一些人先在另外一个目录下导出release_1_0_patch这个分支：解决1.0中的紧急问题， 

cvs checkout -r release_1_0_patch 

而其他人员仍旧在项目的主干分支2.x上开发 



在release_1_0_patch上修正错误后，标记一个1.0的错误修正版本号 

cvs tag release_1_0_patch_1 



如果2.0认为这些错误修改在2.0里也需要，也可以在2.0的开发目录下合并release_1_0_patch_1中的修改到当前代码中： 

cvs update -j release_1_0_patch_1 



CVS的远程认证：通过SSH远程访问CVS 

================================ 



使用cvs本身的远程认证很麻烦,需要定义服务器和用户组，用户名，设置密码等，而且不安全，因此和系统本地帐号认证并通过SSH传输是比较好的办法，通过在客户机的/etc/profile里设置一下内容： 

CVSROOT=:ext:$USER@test.server.address#port:/path/to/cvsroot CVS_RSH=ssh; export CVSROOT CVS_RSH 

所有客户机所有本地用户都可以映射到CVS服务器相应同名帐号了。 



如果CVS所在服务器的SSH端口不在缺省的22，或者和客户端与CVS服务器端SSH缺省端口不一致，有时候设置了： 

:ext:$USER@test.server.address#port:/path/to/cvsroot 



仍然不行，比如有以下错误信息： 

ssh: test.server.address#port: Name or service not known 

cvs [checkout aborted]: end of file from server (consult above messages if any) 



解决的方法是做一个脚本指定端口转向（不能使用alias，会出找不到文件错误）： 

创建一个/usr/bin/ssh_cvs文件： 

#!/usr/bin/sh 

/path/to/ssh -p 34567 "$@" 

然后：chmod +x /usr/bin/ssh_cvs 

并CVS_RSH=ssh_cvs; export CVS_RSH 



注意：port是指相应服务器SSH的端口，不是cvs pserver的端口 



CVSWEB：提高程序员比较文件修改效率 

================================ 



CVSWEB就是CVS的WEB界面，可以大大提高程序员定位修改的效率: 

使用的样例可以看：http://www.freebsd.org/cgi/cvsweb.cgi 



CVSWEB的下载：CVSWEB从最初的版本已经演化出很多功能界面更丰富的版本，这个是个人感觉觉得安装设置比较方便的： 

http://www.spaghetti-code.de/software/linux/cvsweb/ 



下载解包： 

tar zxf cvsweb.tgz 

把配置文件cvsweb.conf放到安全的地方（比如和apache的配置放在同一个目录下）， 

修改：cvsweb.cgi让CGI找到配置文件： 

$config = $ENV{'CVSWEB_CONFIG'} || '/path/to/apache/conf/cvsweb.conf'; 



转到/path/to/apache/conf下并修改cvsweb.conf： 



修改CVSROOT路径设置： 

%CVSROOT = ( 

'Development' => '/path/to/cvsroot', #<==修改指向本地的CVSROOT 

); 

缺省不显示已经删除的文档： 

"hideattic" => "1",#<==缺省不显示已经删除的文档 

在配置文件cvsweb.conf中还可以定制页头的描述信息，你可以修改$long_intro成你需要的文字 

CVSWEB可不能随便开放给所有用户，因此需要使用WEB用户认证： 

先生成 passwd: 

/path/to/apache/bin/htpasswd -c cvsweb.passwd user 



修改httpd.conf: 增加 

<Directory "/path/to/apache/cgi-bin/cvsweb/"> 

AuthName "CVS Authorization" 

AuthType Basic 

AuthUserFile /path/to/cvsweb.passwd 

require valid-user 

</Directory> 



CVS TAGS: who? when? 

==================== 



将$Id$ 加在程序文件开头的注释里是一个很好的习惯，cvs能够自动解释更新其中的内容成：file_name version time user_name 的格式，比如：cvs_card.txt,v 1.1 2002/04/05 04:24:12 chedong Exp，可以这些信息了解文件的最后修改人和修改时间 



几个常用的缺省文件： 

default.php 

<?php 

/* 

* Copyright (c) 2002 Company Name. 

* $Header$ 

*/ 



?> 



==================================== 

Default.java: 注意文件头一般注释用 /* 开始 JAVADOC注释用 /** 开始的区别 

/* 

* Copyright (c) 2002 Company Name. 

* $Header$ 

*/ 



package com.netease; 



import java.io; 



/** 

* comments here 

*/ 

public class Default { 

/** 

* 

* @param 

* @return 

*/ 

public toString() { 



} 

} 



==================================== 

default.pl: 

#!/usr/bin/perl -w 

# Copyright (c) 2002 Company Name. 

# $Header$ 



# file comments here 



use strict; 





CVS vs VSS　 

=========== 



CVS没有文件锁定模式，VSS在check out同时，同时记录了文件被导出者锁定。 



CVS是update commit， VSS是check out check in 



在CVS中，标记自动更新功能缺省是打开的，这样也带来一个潜在的问题，就是不用-kb方式添加binary文件的话在cvs自动更新时可能会导致文件失效。 



Virsual SourceSafe中这个功能称之为Keyword Explaination，缺省是关闭的，需要通过OPITION打开，并指定需要进行源文件关键词扫描的类型：*.txt,*.java,*.html... 



对于Virsual SourceSafe和CVS都通用的TAG有： 

$Header$ 

$Author$ 

$Date$ 

$Revision$ 



尽量使用通用的关键词保证代码在CVS和VSS都能方便的跟踪。 



　 



相关资源： 



CVS HOME： 

http://www.cvshome.org/ 



CVS FAQ： 

http://www.loria.fr/~molli/cvs-index.html 



相关网站: 

http://directory.google.com/Top/Computers/Software/Configuration_Management/Tools/Concurrent_Versions_System/ 



CVS 免费书: 

http://cvsbook.red-bean.com/ 



CVS 命令的速查卡片： 

http://www.refcards.com/about/cvs.html 











Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=327935

• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

• 快来参加7月17日在成都举行的SOA中国技术论坛
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师

原来采用纯粹的aspectj进行的开发，是可以控制spring mvc层的
现在用spring2.5来实现代码和测试都通过了可是就是实际部署运行的时候没有反应，不知道大家遇到没，请大家指点,谢谢~！

用同样的方法控制其它的相关类都是可以的，代码如下：

Java代码

1. CAspect.java里：   
2. @Pointcut("execution(* com..action.*Controller.*(..)) && args(request,response)")    
3. public void pointcutMVC(HttpServletRequest request, HttpServletResponse response){   
4. }   
5.   
6. @Around("pointcutMVC(request,response)")   
7.     public Object aroundMvc(ProceedingJoinPoint jp,HttpServletRequest request, HttpServletResponse response){   
8.     System.out.println("mvc aop arounding...");    
9. ..  }   
10.   
11. spring配置文件：   
12. <aop:<SPAN class=hilite1><SPAN class=hilite1>aspectj</SPAN></SPAN>-autoproxy >   
13.     <aop:include name="CAspect"/>   
14. </aop:<SPAN class=hilite1><SPAN class=hilite1>aspectj</SPAN></SPAN>-autoproxy>         
15. <bean id="CAspect" class="com.axt.aop.CAspect" />  

CAspect.java里：
@Pointcut("execution(* com..action.*Controller.*(..)) && args(request,response)") 
public void pointcutMVC(HttpServletRequest request, HttpServletResponse response){
}

@Around("pointcutMVC(request,response)")
	public Object aroundMvc(ProceedingJoinPoint jp,HttpServletRequest request, HttpServletResponse response){
	System.out.println("mvc aop arounding...");	
..	}

spring配置文件：
<aop:aspectj-autoproxy >
	<aop:include name="CAspect"/>
</aop:aspectj-autoproxy>      
<bean id="CAspect" class="com.axt.aop.CAspect" />

• 搜狐网站诚聘Java、PHP和C++工程师
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 快来参加7月17日在成都举行的SOA中国技术论坛
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。

(转载)http://www.javaeye.com/topic/31023

软件环境 ： Eclipse3.1.1 , AJDT 1.3 , JDK1.4.2 , AspectJ1.5, Struts1.1 ， Jetty5.1.6

场景介绍 ： workspace中已存在一个java项目，并已部署与Jetty服务器上，这里我采用了一个简单的struts项目，我将演示如何在不改变原有项目的任何代码和配置的基础上，在runtime对struts项目中的一些代码进行拦截。

首先，让我们来新建已个AspectJ项目，名字为AspectJDemo。

在新建project的build path中加入aspectjrt.jar

在Aspectj InPath中加入aspectj代码中需要用到的类及jar，这边我加入了struts的所有jar及StrutsDemo的类编译路径

好，接下来说一下我要拦截的代码片断，在原项目中有一个名叫UserLoginForm的FormBean，希望在runtime的时候，当struts调用这个form中的setUsername方法时拦截代码，相关的struts代码如下：

Java代码

1. public class UserLoginForm extends ActionForm {   
2.     private String username;   
3.     private String password;   
4.        
5.     public String getPassword() {   
6.         return password;   
7.     }   
8.     public void setPassword(String password) {   
9.         this.password = password;   
10.     }   
11.     public String getUsername() {   
12.         return username;   
13.     }   
14.     public void setUsername(String username) {   
15.         this.username = username;   
16.     }      
17. }  

public class UserLoginForm extends ActionForm {
	private String username;
	private String password;
	
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}	
}

Java代码

1. public class UserLoginAction extends Action {   
2.     private final String LOGIN_FAILURE = "failure";   
3.     private final String LOGIN_SUCCESS = "success";   
4.        
5.     public ActionForward execute(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response) throws Exception {   
6.     UserLoginForm ulf = (UserLoginForm)form;   
7.     LOG.info("Username:"+ulf.getUsername()+"+Password:"+ulf.getPassword());   
8.            
9.     return mapping.findForward(LOGIN_FAILURE);   
10. }   
11. }  

public class UserLoginAction extends Action {
	private final String LOGIN_FAILURE = "failure";
	private final String LOGIN_SUCCESS = "success";
	
	public ActionForward execute(ActionMapping mapping, ActionForm form,HttpServletRequest request, HttpServletResponse response) throws Exception {
	UserLoginForm ulf = (UserLoginForm)form;
	LOG.info("Username:"+ulf.getUsername()+"+Password:"+ulf.getPassword());
		
	return mapping.findForward(LOGIN_FAILURE);
}
}

Java代码

1. <html:form action="/login" focus="username" onsubmit="">   
2. <table border="0" width="100%">   
3. <tr>   
4.     <th align="right">Username:</th>   
5.     <td align="left">   
6.     <html:text property="username" size="16" maxlength="18" />   
7.     </td>   
8. </tr>   
9. <tr>   
10.     <th align="right">Password:</th>   
11.     <td align="left">   
12.     <html:password property="password" size="16" maxlength="18" redisplay="false" />   
13.     </td>   
14. </tr>   
15. <tr>   
16.     <td align="right"><html:submit value="Submit" /></td>   
17.     <td align="left"><html:reset /></td>   
18. </tr>   
19. </table>   
20. </html:form>  

<html:form action="/login" focus="username" onsubmit="">
<table border="0" width="100%">
<tr>
	<th align="right">Username:</th>
	<td align="left">
	<html:text property="username" size="16" maxlength="18" />
	</td>
</tr>
<tr>
	<th align="right">Password:</th>
	<td align="left">
	<html:password property="password" size="16" maxlength="18" redisplay="false" />
	</td>
</tr>
<tr>
	<td align="right"><html:submit value="Submit" /></td>
	<td align="left"><html:reset /></td>
</tr>
</table>
</html:form>

Java代码

1. public aspect LoginAspect {   
2.     //建立一个pointcut，这个pointcut对所有方法签名为    
3.      //public void setUsername(String) 的方法被执行的时候有效   
4.     public pointcut setUsername() :   
5.         execution (public void setUsername(String));   
6.     //设定拦截位置，在setUsername这个pointcut执行前打印出一段message   
7.     before() : setUsername() {   
8.         System.out.println("setUsername method has been invoked!!!");   
9.     }   
10. }  

public aspect LoginAspect {
    //建立一个pointcut，这个pointcut对所有方法签名为 
     //public void setUsername(String) 的方法被执行的时候有效
    public pointcut setUsername() :
    	execution (public void setUsername(String));
    //设定拦截位置，在setUsername这个pointcut执行前打印出一段message
    before() : setUsername() {
    	System.out.println("setUsername method has been invoked!!!");
    }
}

Java代码

1. <Call name="addWebApplications">   
2.     <Arg></Arg>   
3.     <Arg>./webapp/</Arg>   
4.     <Arg><SystemProperty name="jetty.home" default="."/>/etc/webdefault.xml</Arg>   
5.     <Arg type="boolean">true</Arg><!--extract WARs-->   
6.     <Arg type="boolean">false</Arg><!-- java 2 compliante class loader -->   
7.   </Call>  

<Call name="addWebApplications">
    <Arg></Arg>
    <Arg>./webapp/</Arg>
    <Arg><SystemProperty name="jetty.home" default="."/>/etc/webdefault.xml</Arg>
    <Arg type="boolean">true</Arg><!--extract WARs-->
    <Arg type="boolean">false</Arg><!-- java 2 compliante class loader -->
  </Call>

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>   
2. <aspectj>   
3.     <aspects>   
4.         <aspect name="lenson.presentation.LoginAspect"/>   
5.     </aspects>   
6. </aspectj>  

<?xml version="1.0" encoding="UTF-8"?>
<aspectj>
	<aspects>
		<aspect name="lenson.presentation.LoginAspect"/>
	</aspects>
</aspectj>

Java代码

1. -Djetty.home="D:\development\jetty-5.1.6"  

-Djetty.home="D:\development\jetty-5.1.6"

Java代码

1. ./jetty5.xml  

./jetty5.xml

Java代码

1. setUsername method has been invoked!!!   
2. 21:51:59,211  INFO UserLoginAction:22 - Username:test+Password:test  

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 快来参加7月17日在成都举行的SOA中国技术论坛

  AspectJ是一个面向切面的框架，它扩展了Java语言。AspectJ定义了AOP语法所以它有一个专门的编译器用来生成遵守Java字节编码规范的Class文件。


一、AspectJ概述



图1 ：FigureEditor例子的UML图

      AspectJ（也就是AOP）的动机是发现那些使用传统的编程方法无法很好处理的问题。考虑一个要在某些应用中实施安全策略的问题。安全性是贯穿于系统所有模块间的问题，每个模块都需要应用安全机制才能保证整个系统的安全性，很明显这里的安全策略的实施问题就是一个横切关注点，使用传统的编程解决此问题非常的困难而且容易产生差错，这就正是AOP发挥作用的时候了。

      传统的面向对象编程中，每个单元就是一个类，而类似于安全性这方面的问题，它们通常不能集中在一个类中处理因为它们横跨多个类，这就导致了代码无法重用，可维护性差而且产生了大量代码冗余，这是我们不愿意看到的。

      面向方面编程的出现正好给处于黑暗中的我们带来了光明，它针对于这些横切关注点进行处理，就好象面向对象编程处理一般的关注点一样。而作为AOP的具体实现之一的AspectJ，它向Java中加入了连接点（Join Point）这个新概念，其实它也只是现存的一个Java概念的名称而已。它向Java语言中加入少许新结构：切点(pointcut)、通知(Advice)、类型间声明(Inter-type declaration)和方面(Aspect)。切点和通知动态地影响程序流程，类型间声明则是静态的影响程序的类等级结构，而方面则是对所有这些新结构的封装。

      一个连接点是程序流中指定的一点。切点收集特定的连接点集合和在这些点中的值。一个通知是当一个连接点到达时执行的代码，这些都是AspectJ的动态部分。其实连接点就好比是程序中的一条一条的语句，而切点就是特定一条语句处设置的一个断点，它收集了断点处程序栈的信息，而通知就是在这个断点前后想要加入的程序代码。AspectJ中也有许多不同种类的类型间声明，这就允许程序员修改程序的静态结构、名称、类的成员以及类之间的关系。AspectJ中的方面是横切关注点的模块单元。它们的行为与Java语言中的类很象，但是方面还封装了切点、通知以及类型间声明。

动态连接点模型

      任何面向方面编程的关键元素就是连接点模型。AspectJ提供了许多种类的连接点集合，但是本篇只介绍它们中的一个：方法调用连接点集(method call join points)。一个方法调用连接点捕捉对象的方法调用。每一个运行时方法调用都是一个不同的连接点，许多其他的连接点集合可能在方法调用连接点执行时运，包括方法执行时的所有连接点集合以及在方法中其他方法的调用。我们说这些连接点集合在原来调用的连接点的动态环境中执行。

 

切点

       在AspectJ中，切点捕捉程序流中特定的连接点集合。例如，切点

              call(void Point.setX(int))

捕捉每一个签名为void Point.setX(int)的方法调用的连接点，也就是说，调用Point对象的有一个整型参数的void setX方法。切点能与其他切点通过或(||)、与(&&)以及非(!)操作符联合。例如 call(void Point.setX(int)) || call(void Point.setY(int)) 捕捉setX或setY调用的连接点。切点还可以捕捉不同类型的连接点集合，换句话说，它们能横切类型。例如

       call(void FigureElement.setXY(int,int)) || call(void Point.setX(int))

       || call(void Point.setY(int) || call(void Line.setP1(Point))

       || call(void Line.setP2(Point));

捕捉上述五个方法调用的任意一个的连接点集合。它在本文的例子中捕捉当FigureElement移动时的所有连接点集合。AspectJ使程序员可以命名一个切点集合，以便通知的使用。例如可以为上面的那些切点命名

pointcut move():

call(void FigureElement.setXY(int,int)) || call(void Point.setX(int))

|| call(void Point.setY(int)) || call(void Line.setP1(Point)) || call(void Line.setP2(Point));

无论什么时候，程序员都可以使用move()代替捕捉这些复杂的切点。

       前面所说的切点都是基于显示的方法签名，它们称为基于名字(name-based)横切。AspectJ还提供了另一种横切，称为基于属性(property-based)的横切。它们可以使用通配符描述方法签名，例如 call(void Figure.make*(..)) 捕捉Figure对象中以make开头的参数列表任意的方法调用的连接点。而 call(public & Figure.*(..)) 则捕捉Figure对象中的任何公共方法调用的连接点。但是通配符不是AspectJ支持的唯一属性，AspectJ中还有许多其他的属性可供程序员使用。例如cflow，它根据连接点集合是否在其他连接点集合的动态环境中发生标识连接点集合。例如 cflow(move()) 捕捉被move()捕捉到的连接点集合的动态环境中发生的连接点。

 

通知

       虽然切点用来捕捉连接点集合，但是它们没有做任何事。要真正实现横切行为，我们需要使用通知机制。通知包含了切点和要在每个连连接点处执行的代码段。AspectJ有几种通知。

·前通知(Before Advice)      当到达一个连接点但是在程序进程运行之前执行。例如，前通知在方法实际调用之前运行，刚刚在方法的参数被分析之后。

       Before() : move(){ System.out.println(“物体将移动了”);}

·后通知(After Advice) 当特定连接点处的程序进程执行之后运行。例如，一个方法调用的后通知在方法体运行之后，刚好在控制返回调用者之前执行。因为Java程序有两种退出连接点的形式，正常的和抛出异常。相对的就有三种后通知：返回后通知(after returning)、抛出异常后通知(after throwing)和清楚的后通知(after)，所谓清楚后通知就是指无论是正常还是异常都执行的后通知，就像Java中的finally语句。

       After() returning : move(){    System.out.println(“物体刚刚成功的移动了”);}

·在周围通知(Around Advice)    在连接点到达后，显示的控制程序进程是否执行（暂不讨论）

 

暴露切点环境

       切点不仅仅捕捉连接点，它还能暴露连接点处的部分执行环境。切点中暴露的值可以在通知体中声明以后使用。通知声明有一个参数列表（和方法相同）用来描述它所使用的环境的名称。例如后通知

       after(FigureElement fe,int x,int y) returning : somePointcuts {  someCodes  }

使用了三个暴露的环境，一个名为fe的FigureElement对象，两个整型变量x,y。通知体可以像使用方法的参数那样使用这些变量，例如

       after(FigureElement fe,int x,int y) returning : somePointcuts {

              System.out.println(fe+”移动到(”+x+”,”+y+”)”);

}

通知的切点发布了通知参数的值，三个原生切点this、target和args被用来发布这些值/所以上述例子的完整代码为

       after(FigureElement fe,int x,int y) returning : call(void FigureElement.setXY(int,int)

&& target(fe) && args(x,y) {

              System.out.println(fe+”移动到(”+x+”,”+y+”)”);

}

目标对象是FigureElement所以fe是after的第一个参数，调用的方法包含两个整型参数所以x和y为after的第二和第三个参数。所以通知打印出方法setXY调用返回后对象移动到的点x和y。当然还可以使用命名切点完成同样的工作，例如

       pointcut setXY(FigureElement fe,int x,int y):call(void FigureElement.setXY(int,int)

              && target(fe) && args(x,y);

       after(FigureElement fe,int x,int y) returning : setXY(fe,x,y){

       System.out.println(fe+”移动到(”+x+”,”+y+”)”);

       }

 

类型间声明

       AspectJ的类型间声明指的是那些跨越类和它们的等级结构的声明。这些可能是横跨多个类的成员声明或者是类之间继承关系的改变。不像通知是动态地操作，类型间声明编译时的静态操作。考虑一下，Java语言中如何向一个一些的类中加入新方法，这需要实现一个特定接口，所有类都必须在各自内部实现接口声明的方法，而使用AspectJ则可以将这些工作利用类型间声明放在一个方面中。这个方面声明方法和字段，然后将它们与需要的类联系。

假设我们想有一个Sreen对象观察Point对象的变化，当Point是一个存在的类。我们可以通过书写一个方面，由这个方面声明Point对象有一个实例字段observers,用来保存所有观察Point对象的Screen对象的引用，从而实现这个功能。

       Aspect PointObserving{

              Private    Collection Point.observers=new ArrayList();

……

}

observers字段是私有字段，只有PointObserving能使用。因此，要在aspect中加入方法管理observers聚集。

       Aspect PointObserving{

              Private Collection Point.observers=new ArrayList();

              Public static void addObserver(Point p,Screen s){

                     p.observers.add(s);

              }

              public static void removeObserver(Point p,Screen s){

                     p.observers.remove(s);

              }

              ……

}

然后我们可以定义一个切点stateChanges决定我们想要观察什么并且提供一个after通知定义当观察到变化时我们想要做什么。

       Aspect PointObserving{

              Private Collection Point.observers=new ArrayList();

              Public static void addObserver(Point p,Screen s){

                     p.observers.add(s);

              }

              public static void removeObserver(Point p,Screen s){

                     p.observers.remove(s);

              }

              pointcut stateChanges(Point p) : target(p) && call(void Point.set*(int));

              after(Point p) : stateChanges(p){

                     Iterator it=p.observers.iterator();

                     While(it.hasNext()){

                            UpdateObserver(p,(Screen)it.next()));

                     }

              }

              private static void updateObserver(Point p,Screen s){

                     s.display(p);

              }

}

注意无论是Sreen还是Point的代码都没有被修改，所有的新功能的加入都在方面中实现了，很酷吧！

 

方面

       方面以横切模块单元的形式包装了所有的切点、通知和类型间声明。这非常像Java语言的类。实际上，方面也可以定义自己的方法，字段和初始化方法。像类一样一个方面也可以用abstrace关键字声明为抽象方面，可以被子方面继承。在AspectJ中方面的设计实际上使用了单例模式，缺省情况下，它不能使用new构造，但是可以使用一个方法实例化例如方法aspectOf()可以获得方面的实例。所以在方面的通知中可以使用非静态的成员字段。

例如

       aspect Tracing {

              OutputStream trace=System.out;

              After() : move(){    trace.println(“物体成功移动”); }


二、AspectJ应用范围

       如前所述，AspectJ可以用于应用开发的不同阶段。下面讨论不同阶段的AspectJ的具体应用情况。

开发型方面(Development Aspects)

       开发方面可以很容易的从真正的产品中删除。而产品方面则被可用于开发过程和生产过程，但是仅仅影响某几个类。

       这一部分将通过几个例子说明方面在Java应用的开发阶段是如何使用的。这些方面包括调试、测试和性能检测等工作。方面定义的行为范围包括简单的代码跟踪、测试应用的内在联系等等。使用AspectJ不仅使得模块化这些功能变为可能，同时也使得根据需要打开和关闭这些功能变成可能。

 

代码跟踪(Tracing)
       首先让我们看看如何增加一个程序内部工作的可视性。我们定义一个简单的方面用于代码跟踪并且在每个方法调用时输出一些信息。在前一篇的图形编辑例子中，这样的方面可能仅仅简单的跟踪什么时候画一个点。

aspect SimpleTracing {
    pointcut tracedCall():
        call(void FigureElement.draw(GraphicsContext));
 
    before(): tracedCall() {
        System.out.println("Entering: " + thisJoinPoint);
    }
}
代码利用了thisJoinPoint变量。在所有的通知体内，这个变量将与描述当前连接点的对象绑定。所以上述代码在每次一个FigureElement对象接受到draw方法时输出如下信息：

Entering: call(void FigureElement.draw(GraphicsContext))

通常我们在调式程序时，会在特定的地方放置几条输出语句，而当调试结束时还需要找到这些代码段将它们删除，这样做不但使我们的代码很难看而且很费时间。而使用AspectJ我们可以克服以上的两个问题，我们可以通过定义切点捕捉任何想要观察的代码段，利用通知可以在方面内部书写输出语句，而不需要修改源代码，当不在需要跟踪语句的时候还可以很轻松的将方面从应用中删除并重新编译代码即可。

 

前提条件和后续条件(Pre-and Post-Conditions)
       许多的程序员使用按契约编程(Design by Contract)的形式。这种形式的编程需要显式的前提条件测试以保证方法调用是否合适，还需要显式的后续条件测试保证方法是否工作正常。AspectJ使得可以模块化地实现这两种条件测试。例如下面的代码

aspect PointBoundsChecking {

    pointcut setX(int x):

        (call(void FigureElement.setXY(int, int)) && args(x, *))

        || (call(void Point.setX(int)) && args(x));

 

    pointcut setY(int y):

        (call(void FigureElement.setXY(int, int)) && args(*, y))

        || (call(void Point.setY(int)) && args(y));

 

    before(int x): setX(x) {

        if ( x < MIN_X || x > MAX_X )

            throw new IllegalArgumentException("x is out of bounds.");

    }

 

    before(int y): setY(y) {

        if ( y < MIN_Y || y > MAX_Y )

            throw new IllegalArgumentException("y is out of bounds.");

    }

}

它实现了边界检测功能。当FigureElement对象移动时，如果x或y的值超过了定义的边界，程序将会抛出IllegalArgumentException异常。

 

合同实施(Contract Enforcement)
       基于属性的横切机制在定义更加复杂的合同实施上非常有用。一个十分强大的功能是它可以强制特定的方法调用只出现在对应的程序中，而在其他程序中不出现。例如，下面的方面实施了一个限制，使得只有在知名的工厂方法中才能向注册并添加FigureElement对象。实施这个限制的目的是为了确保没有任何一个FigureElement对象被注册多次。

static aspect RegistrationProtection {

    pointcut register(): call(void Registry.register(FigureElement));

    pointcut canRegister(): withincode(static * FigureElement.make*(..));

 

    before(): register() && !canRegister() {

        throw new IllegalAccessException("Illegal call " + thisJoinPoint);

    }

}

这个方面使用了withincode初始切点，它表示在FigureElement对象的工厂方法(以make开始的方法)体内出现的所有连接点。在before通知中声明一个异常，该通知用于捕捉任何不在工厂方法代码内部产生的register方法的调用。该通知在特定连接点处抛出一个运行时异常，但是AspectJ能做地更好。使用declare error的形式，我们可以声明一个编译时的错误。

static aspect RegistrationProtection {

    pointcut register(): call(void Registry.register(FigureElement));

    pointcut canRegister(): withincode(static * FigureElement.make*(..));

 

    declare error: register() && !canRegister(): "Illegal call"

}

当使用这个方面后，如果代码中存在定义的这些非法调用我们将无法通过编译。这种情况只出现在我们只需要静态信息的时候，如果我们需要动态信息，像上面提到的前提条件实施时，就可以利用在通知中抛出带参数的异常来实现。

 

配置管理(Configuration Management)
       AspectJ的配置管理可以使用类似于make-file等技术进行处理。程序员可以简单的包括他们想要的方面进行编译。不想要任何方面出现在产品阶段的开发者也可以通过配置他们的make-file使用传统的Java编译器编译整个应用。

 

产品型方面(Production Aspects)

       这一部分的方面例子将描述方面用于生产阶段的应用。产品方面将向应用中加入功能而不仅仅为程序的内部工作增加可视性。

改变监视(Change Monitoring)
       在第一个例子，方面的角色是用于维护一位数据标志，由它说明对象从最后一次显示刷新开始是否移动过。在方面中实现这样的功能是十分直接的，testAndClear方法被显示代码调用以便找到一个图形元素是否在最近移动过。这个方法返回标志的状态并将它设置为假。切点move捕捉所有能够是图形移动的方法调用。After通知截获move切点并设置标志位。

aspect MoveTracking {

private static boolean dirty = false;

 

    public static boolean testAndClear() {

        boolean result = dirty;

        dirty = false;

        return result;

    }

 

    pointcut move():

        call(void FigureElement.setXY(int, int)) ||

        call(void Line.setP1(Point)) ||

        call(void Line.setP2(Point)) ||

        call(void Point.setX(int)) ||

        call(void Point.setY(int));

 

    after() returning: move() {

        dirty = true;

    }

}
 

这个简单例子同样说明了在产品代码中使用AspectJ的一些好处。考虑使用普通的Java代码实现这个功能：将有可能需要包含标志位，testAndClear以及setFlag方法的辅助类。这些方法需要每个移动的图形元素包含一个对setFlag方法的调用。这些方法的调用就是这个例子中的横切关注点。

·显示的捕捉了横切关注点的结构

·功能容易拔插

·实现更加稳定

 

传递上下文(Context Passing)
横切结构的上下文传递在Java程序中是十分复杂的一部分。考虑实现一个功能，它允许客户设置所创建的图形对象的颜色。这个需求需要从客户端传入一个颜色或颜色工厂。而要在大量的方法中加入一个参数，目的仅仅是为传递上下文信息这种不方便的情况是所有的程序员都十分熟悉的。

使用AspectJ，这种上下文的传递可以使用模块化的方式实现。下面代码中的after通知仅当一个图形对象的工厂方法在客户ColorControllingClient的某个方法控制流程中调用时才运行。

aspect ColorControl {

    pointcut CCClientCflow(ColorControllingClient client):

        cflow(call(* * (..)) && target(client));

 

    pointcut make(): call(FigureElement Figure.make*(..));

 

    after (ColorControllingClient c) returning (FigureElement fe):

            make() && CCClientCflow(c) {

        fe.setColor(c.colorFor(fe));

    }

}

这个方面仅仅影响一小部分的方法，但是注意该功能的非AOP实现可能 需要编辑更多的方法。

 

提供一致的行为(Providing Consistent Behavior)
接下来的例子说明了基于属性的方面如何在很多操作中提供一致的处理功能。这个方面确保包com.bigboxco的所有公共方法记录由它们抛出的任何错误。PublicMethodCall切点捕捉包中的公共方法调用， after通知在任何一个这种调用抛出错误后运行并且记录下这个错误。

aspect PublicErrorLogging {

    Log log = new Log();

 

    pointcut publicMethodCall():

        call(public * com.bigboxco.*.*(..));

 

    after() throwing (Error e): publicMethodCall() {

        log.write(e);

    }

}

在一些情况中，这个方面可以记录一个异常两次。这在com.bigboxco包内部的代码自己调用本包中的公共方法时发生。为解决这个问题，我们可以使用cflow初始切点将这些内部调用排除：

after() throwing (Error e) : publicMethodCall() && !cflow(publicMethodCall()) {

    log.write(e);

}

 

结论

       AspectJ是对Java语言的简单而且实际的面向方面的扩展。仅通过加入几个新结构，AspectJ提供了对模块化实现各种横切关注点的有力支持。向以有的Java开发项目中加入AspectJ是一个直接而且渐增的任务。一条路径就是通过从使用开发方面开始再到产品方面当拥有了AspectJ的经验后就使用开发可重用方面。当然可以选取其他的开发路径。例如，一些开发者将从使用产品方面马上得到好处，另外的人员可能马上编写可重用的方面。

       AspectJ可以使用基于名字和基于属性这两种横切点。使用基于名字横切点的方面仅影响少数几个类，虽然它们是小范围的，但是比起普通的Java实现来说它们能够减少大量的复杂度。使用基于属性横切点的方面可以有小范围或着大范围。使用AspectJ导致了横切关注点的干净、模块化的实现。当编写AspectJ方面时，横切关注点的结构变得十分明显和易懂。方面也是高度模块化的，使得开发可拔插的横切功能变成现实。

       AspectJ提供了比这两部分简短介绍更多的功能。本系列的下一章内容，The AspectJ Language，将介绍 AspectJ语言的更多细节和特征。系列的第三章，Examples将通过一些完整的例子说明如何使用AspectJ。建议大家在仔细阅读了接下来的两章后再决定是否在项目中加入AspectJ。


三、AspectJ的高级特性

（一）、The reflection API

说到高级特性，首先要说的就是AspectJ提供的一套reflection API，主要包括JoinPoint、JoinPoint.StaticPart和Signature三个主要的接口。你可以从aspectj.jar中的javadoc来了解它们的详细情况。那它们能提供什么功能呢？其实从字面上就能大致明白：通过这三个接口能访问到Join Points的信息。譬如，调用thisJoinPoint.getArgs()就可以得到方法的参数列表。

（二）、Aspect precedence

在AspectJ中，pointcut和advice都会包含在一个aspect中。在应用系统中，对同一个join point会有多种advice（logging，caching等），这就会引出一个问题：如果系统中有很多的aspect，而这些aspect很有可能会捕获同样的join points，那这些aspect的执行顺序是如何安排的呢？

AspectJ早已为我们考虑到了这个问题，它提供了一种设置aspect precedence的方法。对三种不同的advice来说：

1、before advice是先执行higher-precedence，后执行lower-precedence；

2、around advice是higher-precedence包含lower-precedence，当higher-precedence around advice没有调用proceed()方法时，lower-precedence不会被执行；

3、after advice与before advice正好相反，先执行执行lower-precedence，然后执行higher-precedence。

那应该如何来声明aspect precedence？非常简单，只要在aspect中使用如下的语法即可：

declare precedence : TypePattern1, TypePattern2, ..;

从左往右，排在前面的是higher-precedence advice，后面的是lower-precedence。

（三）、Aspect association

在Java中，为了节省对象每次构建的耗费，增加效率，很多人会考虑使用Singleton模式，让jvm中只有一个实例存在。AspectJ当然为我们考虑到这个问题，Aspect association实际上就是aspect与advised join point object的一种关联关系，这很类似于OO中association，譬如1:1，1:m等。Aspect association能让我们能更好地控制aspect的状态信息。

在AspectJ中可以把Aspect association大致分为三类：

1、Per virtual machine (default)

一个jvm中只有一个aspect instance，AspectJ默认association。

2、Per object

每一个advised join point object都会产生一个aspect instance，不过同一个object instance只会产生一个aspect instance。

3、Per control-flow association

这种association稍微复杂一些，它主要针对程序调用的控制流，譬如：A方法调用B方法，B方法又调用C方法，这就是control-flow。

在aspect中声明这三种association非常简单，它的主要语法如下：

aspect [()] {
... aspect body
}

Per virtual machine是aspectj的默认association，不需要你额外的声明，正常使用即可。

Per object主要有两种方式：perthis()和pertarget()。perthis()主要用于execution object，pertarget()主要用于target object，两者非常类似。

Per control-flow中也包含两种方式：percflow()和percflowbelow()。这两者也很类似，只是两者的control-flow不太一样而已。

维护aspect的状态信息还有一种方法，就是使用introduce。可以在aspect中introduce member fields，通过fields来保存状态信息。

 

四、AspectJ实例

 

使用方面的Tracing程序

       写一个具有跟踪能力的类是很简单的事情：一组方法，一个控制其开或关的布尔变量，一种可选的输出流，可能还有一些格式化输出能力。这些都是Trace类需要的东西。当然，如果程序需要的话，Trace类也可以实现的十分的复杂。开发这样的程序只是一方面，更重要的是如何在合适的时候调用它。在大型系统开发过程中，跟踪程序往往影响效率，而且在正式版本中去除这些功能十分麻烦，需要修改任何包含跟踪代码的源码。出于这些原因，开发人员常常使用脚本程序以便向源码中添加或删除跟踪代码。

       AspectJ可以更加方便的实现跟踪功能并克服这些缺点。Tracing可以看作是面向整个系统的关注点，因此，Tracing方面可以完全独立在系统之外并且在不影响系统基本功能的情况下嵌入系统。

 

应用实例

整个例子只有四个类。应用是关于Shape的。TwoShape类是Shape类等级的基类。

public abstract class TwoDShape {

    protected double x, y;

    protected TwoDShape(double x, double y) {

        this.x = x; this.y = y;

    }

    public double getX() { return x; }

    public double getY() { return y; }

    public double distance(TwoDShape s) {

        double dx = Math.abs(s.getX() - x);

        double dy = Math.abs(s.getY() - y);

        return Math.sqrt(dx*dx + dy*dy);

    }

    public abstract double perimeter();

    public abstract double area();

    public String toString() {

        return (" @ (" + String.valueOf(x) + ", " + String.valueOf(y) + ") ");

    }

}

TwoShape类有两个子类，Circle和Square   

public class Circle extends TwoDShape {

    protected double r;

    public Circle(double x, double y, double r) {

        super(x, y); this.r = r;

    }

    public Circle(double x, double y) { this(  x,   y, 1.0); }

    public Circle(double r)           { this(0.0, 0.0,   r); }

    public Circle()                   { this(0.0, 0.0, 1.0); }

    public double perimeter() {

        return 2 * Math.PI * r;

    }

    public double area() {

        return Math.PI * r*r;

    }

    public String toString() {

        return ("Circle radius = " + String.valueOf(r) + super.toString());

    }

}

public class Square extends TwoDShape {

    protected double s;    // side

    public Square(double x, double y, double s) {

        super(x, y); this.s = s;

    }

    public Square(double x, double y) { this(  x,   y, 1.0); }

    public Square(double s)           { this(0.0, 0.0,   s); }

    public Square()                   { this(0.0, 0.0, 1.0); }

    public double perimeter() {

        return 4 * s;

    }

    public double area() {

        return s*s;

    }

    public String toString() {

        return ("Square side = " + String.valueOf(s) + super.toString());

    }

}

 

Tracing版本一

首先我们直接实现一个Trace类并不使用方面。公共接口Trace.java

public class Trace {

    public static int TRACELEVEL = 0;

    public static void initStream(PrintStream s) {...}

    public static void traceEntry(String str) {...}

    public static void traceExit(String str) {...}

}

如果我们没有AspectJ，我们需要在所有需要跟踪的方法或构造子中直接调用traceEntry和traceExit方法并且初试化TRACELEVEL和输出流。以上面的例子来说，如果我们要跟踪所有的方法调用（包括构造子）则需要40次的方法调用并且还要时刻注意没有漏掉什么方法，但是使用方面我们可以一致而可靠的完成。TraceMyClasses.java

aspect TraceMyClasses {

    pointcut myClass(): within(TwoDShape) || within(Circle) || within(Square);

    pointcut myConstructor(): myClass() && execution(new(..));

    pointcut myMethod(): myClass() && execution(* *(..));

 

    before (): myConstructor() {

        Trace.traceEntry("" + thisJoinPointStaticPart.getSignature());

    }

    after(): myConstructor() {

        Trace.traceExit("" + thisJoinPointStaticPart.getSignature());

    }

 

    before (): myMethod() {

        Trace.traceEntry("" + thisJoinPointStaticPart.getSignature());

    }

    after(): myMethod() {

        Trace.traceExit("" + thisJoinPointStaticPart.getSignature());

    }

}

这个方面在合适的时候调用了跟踪方法。根据此方面，跟踪方法在Shape等级中每个方法或构造子的入口和出口处调用，输出的是各个方法的签名。因为方法签名是静态信息，我们可以利用thisJoinPointStaticPart对象获得。运行这个方面的main方法可以获得以下输出：

  --> tracing.TwoDShape(double, double)

  <-- tracing.TwoDShape(double, double)

  --> tracing.Circle(double, double, double)

  <-- tracing.Circle(double, double, double)

  --> tracing.TwoDShape(double, double)

  <-- tracing.TwoDShape(double, double)

  --> tracing.Circle(double, double, double)

  <-- tracing.Circle(double, double, double)

  --> tracing.Circle(double)

  <-- tracing.Circle(double)

  --> tracing.TwoDShape(double, double)

  <-- tracing.TwoDShape(double, double)

  --> tracing.Square(double, double, double)

  <-- tracing.Square(double, double, double)

  --> tracing.Square(double, double)

  <-- tracing.Square(double, double)

  --> double tracing.Circle.perimeter()

  <-- double tracing.Circle.perimeter()

c1.perimeter() = 12.566370614359172

  --> double tracing.Circle.area()

  <-- double tracing.Circle.area()

c1.area() = 12.566370614359172

  --> double tracing.Square.perimeter()

  <-- double tracing.Square.perimeter()

s1.perimeter() = 4.0

  --> double tracing.Square.area()

  <-- double tracing.Square.area()

s1.area() = 1.0

  --> double tracing.TwoDShape.distance(TwoDShape)

    --> double tracing.TwoDShape.getX()

    <-- double tracing.TwoDShape.getX()

    --> double tracing.TwoDShape.getY()

    <-- double tracing.TwoDShape.getY()

  <-- double tracing.TwoDShape.distance(TwoDShape)

c2.distance(c1) = 4.242640687119285

  --> double tracing.TwoDShape.distance(TwoDShape)

    --> double tracing.TwoDShape.getX()

    <-- double tracing.TwoDShape.getX()

    --> double tracing.TwoDShape.getY()

    <-- double tracing.TwoDShape.getY()

  <-- double tracing.TwoDShape.distance(TwoDShape)

s1.distance(c1) = 2.23606797749979

  --> String tracing.Square.toString()

    --> String tracing.TwoDShape.toString()

    <-- String tracing.TwoDShape.toString()

  <-- String tracing.Square.toString()

s1.toString(): Square side = 1.0 @ (1.0, 2.0)

 

Tracing版本二

       版本二实现了可重用的tracing方面，使其不仅仅用于Shape的例子。首先定义如下的抽象方面Trace.java

abstract aspect Trace {

 

    public static int TRACELEVEL = 2;

    public static void initStream(PrintStream s) {...}

    protected static void traceEntry(String str) {...}

    protected static void traceExit(String str) {...}

abstract pointcut myClass();

 

}

为了使用它，我们需要定义我们自己的子类。

public aspect TraceMyClasses extends Trace {

    pointcut myClass(): within(TwoDShape) || within(Circle) || within(Square);

 

    public static void main(String[] args) {

        Trace.TRACELEVEL = 2;

        Trace.initStream(System.err);

        ExampleMain.main(args);

    }

}

注意我们仅仅在类中声明了一个切点，它是超类中声明的抽象切点的具体实现。版本二的Trace类的完整实现如下

abstract aspect Trace {

 

    // implementation part

 

    public static int TRACELEVEL = 2;

    protected static PrintStream stream = System.err;

    protected static int callDepth = 0;

 

    public static void initStream(PrintStream s) {

        stream = s;

    }

    protected static void traceEntry(String str) {

        if (TRACELEVEL == 0) return;

        if (TRACELEVEL == 2) callDepth++;

        printEntering(str);

    }

    protected static void traceExit(String str) {

        if (TRACELEVEL == 0) return;

        printExiting(str);

        if (TRACELEVEL == 2) callDepth--;

    }

    private static void printEntering(String str) {

        printIndent();

        stream.println("--> " + str);

    }

    private static void printExiting(String str) {

        printIndent();

        stream.println("<-- " + str);

    }

    private static void printIndent() {

        for (int i = 0; i < callDepth; i++)

            stream.print("  ");

    }

 

    // protocol part

 

    abstract pointcut myClass();

 

    pointcut myConstructor(): myClass() && execution(new(..));

    pointcut myMethod(): myClass() && execution(* *(..));

 

    before(): myConstructor() {

        traceEntry("" + thisJoinPointStaticPart.getSignature());

    }

    after(): myConstructor() {

        traceExit("" + thisJoinPointStaticPart.getSignature());

    }

 

    before(): myMethod() {

        traceEntry("" + thisJoinPointStaticPart.getSignature());

    }

    after(): myMethod() {

        traceExit("" + thisJoinPointStaticPart.getSignature());

    }

}

它与版本一的不同包括几个部分。首先在版本一中Trace用单独的类来实现而方面是针对特定应用实现的，而版本二则将Trace所需的方法和切点定义融合在一个抽象方面中。这样做的结果是traceEntry和traceExit方法不需要看作是公共方法，它们将由方面内部的通知调用，客户完全不需要知道它们的存在。这个方面的一个关键点是使用了抽象切点，它其实与抽象方法类似，它并不提供具体实现而是由子方面实现它。

 

Tracing版本三

       在前一版本中，我们将traceEntry和traceExit方法隐藏在方面内部，这样做的好处是我们可以方便的更改接口而不影响余下的代码。

       重新考虑不使用AspectJ的程序。假设，一段时间以后，tracing的需求变了，我们需要在输出中加入方法所属对象的信息。至少有两种方法实现，一是保持traceEntry和traceExit方法不变，那么调用者有责任处理显示对象的逻辑，代码可能如下

       Trace.traceEntry("Square.distance in " + toString());

另一种方法是增强方法的功能，添加一个参数表示对象，例如

  public static void traceEntry(String str, Object obj);

  public static void traceExit(String str, Object obj);

然而客户仍然有责任传递正确的对象，调用代码如下

       Trace.traceEntry("Square.distance", this);

这两种方法都需要动态改变其余代码，每个对traceEntry和traceExit方法的调用都需要改变。

       这里体现了方面实现的另一个好处，在版本二的实现中，我们只需要改变Trace方面内部的一小部分代码，下面是版本三的Trace方面实现

abstract aspect Trace {

 

    public static int TRACELEVEL = 0;

    protected static PrintStream stream = null;

    protected static int callDepth = 0;

 

    public static void initStream(PrintStream s) {

        stream = s;

    }

 

    protected static void traceEntry(String str, Object o) {

        if (TRACELEVEL == 0) return;

        if (TRACELEVEL == 2) callDepth++;

        printEntering(str + ": " + o.toString());

    }

 

    protected static void traceExit(String str, Object o) {

        if (TRACELEVEL == 0) return;

        printExiting(str + ": " + o.toString());

        if (TRACELEVEL == 2) callDepth--;

    }

 

    private static void printEntering(String str) {

        printIndent();

        stream.println("Entering " + str);

    }

 

    private static void printExiting(String str) {

        printIndent();

        stream.println("Exiting " + str);

    }

 

    private static void printIndent() {

        for (int i = 0; i < callDepth; i++)

            stream.print("  ");

    }

 

    abstract pointcut myClass(Object obj);

 

    pointcut myConstructor(Object obj): myClass(obj) && execution(new(..));

    pointcut myMethod(Object obj): myClass(obj) &&

        execution(* *(..)) && !execution(String toString());

 

    before(Object obj): myConstructor(obj) {

        traceEntry("" + thisJoinPointStaticPart.getSignature(), obj);

    }

    after(Object obj): myConstructor(obj) {

        traceExit("" + thisJoinPointStaticPart.getSignature(), obj);

    }

 

    before(Object obj): myMethod(obj) {

        traceEntry("" + thisJoinPointStaticPart.getSignature(), obj);

    }

    after(Object obj): myMethod(obj) {

        traceExit("" + thisJoinPointStaticPart.getSignature(), obj);

    }

}

在此我们必须在methods切点排除toString方法的执行。问题是toString方法在通知内部调用，因此如果我们跟踪它，我们将陷入无限循环中。这一点不明显，所以必须在写通知时格外注意。如果通知回调对象，通常都回存在循环的可能性。

       事实上，简单的排除连接点的执行并不够，如果在这之中调用了其他跟踪方法，那么就必须提供以下限制

&& !cflow(execution(String toString()))

排除toString方法的执行以及在这之下的所有连接点。

       总之，为了实现需求的改变我们必须在Trace方面中做一些改变，包括切点说明。但是实现的改变只局限于Trace方面内部，而如果没有方面，则需要更改每个应用类的实现。

• 北京: 千橡集团暨校内网诚聘软件研发工程师
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• 快来参加7月17日在成都举行的SOA中国技术论坛

1. 概述 
Acegi是一个专门为SpringFramework应用提供安全机制的开放源代码项目，全称为Acegi Security System for Spring，当前版本为 
0.8.3。它使用了Spring的方式提供了安全和认证安全服务，包括使用Bean Context，拦截器和面向接口的编程方式。通过精心 
配置Acegi安全系统能够轻松地适用于复杂的安全需求。它既能应用于WEB应用也能应用于非WEB应用。在 本文的示例程序 
里，我将演示如何将Acegi应用于WEB应用程序。通过这个例子详细介绍如何配置Acegi的各个组件，同时介绍如何扩展Acegi 
使其能够从数据库中读取配置信息。

2. 例子说明 
本文的例子是一个联系人管理程序，使用SpringFramework 1.2.4 和 Acegi0.8.3，数据库采用Mysql。程序的目录结构如下： 　 
acegi-sample 
│ contactadd.jsp//增加联系人页面 
│ contactedit.jsp//编辑联系人页面 
│ contactlist.jsp//联系人列表页面 
│ contactmainterance.jsp//联系人操作页面 
│ index.jsp//主页面 
│ login.jsp//登录页面 
│ logoff.jsp//登出页面 
│
├─WEB-INF 
│ │ web.xml 
│ │ applicationContext-basic.xml 
│ │ applicationContext-security-acegi.xml 
│ │ log4j.properties 
│ │ 
│ ├─src 
│ │ └─sample//java代码目录 
│ ├─classes 
│ └─lib//依赖包目录 
└─db//建表脚本目录 

3.配置文件说明 
接下来，我们将进入本文的重要内容，开始对Acegi应用程序所牵涉到的配置文件进行一一说明。 

3.1 web.xml 
首先声明SpringFramework的配置文件列表。为了便于管理，将业务方法相关的配置文件和Acegi安全配置相关的配置文件分 
开。 　 

  
contextConfigLocation 

/WEB-INF/applicationContext-basic.xml 
/WEB-INF/applicationContext-security-acegi.xml 


其次声明Acegi过滤器。 　 
<!--Acegi Filter Chain Proxy -->

Acegi Filter Chain Proxy 
net.sf.acegisecurity.util.FilterToBeanProxy 

targetClass 
net.sf.acegisecurity.util.FilterChainProxy 



Acegi Filter Chain Proxy 
/* 

说明：Acegi对WEB应用的支持主要是依靠servlet 过滤器（filter） 来实现的。每一个http request都将被这些过滤器层层拦截 并 
进行安全处理（包括认证和授权）。针对不同的安全处理，Acegi提供了不同的过滤器。过滤器的配置信息位于web.xml，但是 
我们又希望把Acegi的过滤器配置信息放在SpringFramework的配置文件里（applicationContext-security-acegi.xml），从而实现对 
这些过滤器的“控制反转”。解决这个问题的方法是采用Acegi提供的FilterToBeanProxy。FilterToBeanProxy顾名思义就是对 
Acegi过滤器Bean的代理，它的主要功能就是将http请求依次分派给对应的过滤器Bean。 
3.2 applicationContext-security-acegi.xml 
applicationContext-security-acegi.xml主要包括认证相关配置信息和WEB资源授权配置信息。首先是声明过滤器序列。 　 



CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON 
PATTERN_TYPE_APACHE_ANT 
/**=httpSessionContextIntegrationFilter,authenticationProcessingFilter,anonymousProcessingFilter,securityEnforcementFilter 



各个过滤器的作用如下： 
httpSessionContextIntegrationFilter 
根据session中存放的信息组装ContextHolder。ContextHolder主要用于存放SecureContext， 
包括用户的权限信息 
authenticationProcessingFilter 处理认证请求（通常是一个登录页面的表单请求） 

anonymousProcessingFilter 
匿名用户处理。如果用户尚未登录，将生成一个匿名用户的Authentication存放到 
ContextHolder中 
securityEnforcementFilter 强制安全验证过滤器。验证所请求的url是否在用户的权限范围内。 
3.2.1 httpSessionContextIntegrationFilter相关配置信息 
　

net.sf.acegisecurity.context.security.SecureContextImpl

说明： context属性指定context的实现类。 
3.2.2 authenticationProcessingFilter相关配置信息 
authenticationProcessingFilter的配置比较复杂，我们通过下图来看一下： 
authenticationProcessingFilter配置说明： 

authenticationManager 认证管理器 
authenticationFailureUrl 认证失败后，重定向的url 
defaultTargetUrl 认证成功后，重定向的url 
filterProcessesUrl 
该过滤器拦截的url，通常是/j_acegi_security_check，和登录页面（login.jsp）的登录表单的action相 
同 
authenticationManager（认证管理器）用于管理AuthenticationProvider（认证提供者）。它的作用是使你能够通过多个不同的认 
证管理源来对用户进行认证。认证管理器将依次调用认证提供者的认证方法，直到认证通过。本程序使用两种认证提供者。 
authenticationManager配置说明： 
daoAuthenticationProvider 基于数据库的认证提供者。 
anonymousAuthenticationProvider 用于认证匿名用户。 
daoAuthenticationProvider主要功能是从数据库取出用户名和密码，判断登录信息是否正确，如果是，则取出用户权限等用户 
信息，并且存放到cache中，以便以后再次使用。具体流程可以参考：DaoAuthenticationProvider的authenticate方法。 
daoAuthenticationProvider配置说明： 
authenticationDao 认证数据访问对象，用于获取用户信息，包括：用户名，用户密码，用户状态和用户权限。 
userCache 用户信息cache实现bean 
jdbcDaoImpl是认证数据访问对象，它能够从默认的数据库结构中获取用户信息，由于Acegi默认的数据库结构和本程序的不 
同，因此需要修改jdbcDaoImpl的默认sql。注意，采用这种方式能够使Acegi很好的兼容旧的应用程序，因为它对底层的数据结 
构并没有强制要求。jdbcDaoImpl配置说明： 
dataSource 数据源bean 
usersByUsernameQuery 用户信息查询sql 
authoritiesByUsernameQuery 用户权限查询sql 
userCache用于定义用户信息cache功能的提供者。userCache配置说明： 
cache 定义ehcache工厂bean 
本程序采用ehcache作为cache实现。由于认证管理器在每次对http请求进行认证之前都会查找用户信息，通过使用cache就可以 
避免每次都重复访问数据库。 
3.2.3 anonymousProcessingFilter相关配置信息： 
foobar
anonymousUser,AUTH_ANONYMOUS
说明：anonymousProcessingFilter的作用是判断ContextHolder中是否有Authentication对象，如果没有就创建一个Authentication对 
象，其中包含的用户名是anonymousUser，用户权限是AUTH_ANONYMOUS。这使得没有登录的匿名用户能够自动的获得匿 
名的用户名和权限。 
3.2.4 securityEnforcementFilter相关配置信息 

securityEnforcementFilter的配置比较复杂
securityEnforcementFilter配置说明： 
filterSecurityInterceptor 实现对URL资源进行授权访问。 
authenticationEntryPoint 配置登录界面信息。 
securityEnforcementFilter的作用主要是将http请求转发给filterSecurityInterceptor，由filterSecurityInterceptor来对HTTP请求的合法 
性进行判断。 
filterInvocationInterceptor配置说明： 
authenticationManager 认证管理器 
accessDecisionManager 投票通过策略管理器 
objectDefinitionSource 
URL的权限配置信息。用于指定不同的URL资源对应的权限。配置如下： 
/**/*.jpg=AUTH_ANONYMOUS,AUTH_USER 
/**/*.gif=AUTH_ANONYMOUS,AUTH_USER 
/**/*.png=AUTH_ANONYMOUS,AUTH_USER 
/login.jsp*=AUTH_ANONYMOUS,AUTH_USER 
/**=AUTH_USER 
以上配置指定AUTH_ANONYMOUS权限的用户（即匿名用户）只可以访问图片资源和登录页 
面，AUTH_USER权限的用户可以访问全部WEB资源。 
accessDecisionManager（访问决策管理器）首先通过authenticationManager判断用户是否通过认证（即是否已经登录），然后根 
据objectDefinitionSource的配置信息调用accessDecisionManager对用户权限进行投票。 
httpRequestAccessDecisionManager配置说明： 
allowIfAllAbstainDecisions 设定是否允许：“没人反对就通过”的投票策略 
decisionVoters 投票者 

httpRequestAccessDecisionManager（投票通过策略管理器）用于管理投票通过策略。Acegi提供三种投票通过策略的实现： 
AffirmativeBased（至少一个投票者同意方可通过），ConsensusBased（多数投票者同意方可通过），UnanimousBased（所有投 
票者同意方可通过）。本程序采用AffirmativeBased策略，并且禁止“没人反对就通过”的投票策略。 
roleVoter配置说明： 
rolePrefix 
该投票者支持的权限前缀，默认是“ROLE_”，本程序所有的权限字符串均以“AUTH_”开头， 
故设为“AUTH_” 
通过设定rolePrefix可以指定roleVoter所支持的权限范围。 
3.3 applicationContext-basic.xml 
applicationContext-basic.xml主要包括数据访问对象，业务方法，业务方法安全管理拦截器的配置信息。主要讲解业务方法安全管理拦截器（MethodSecurityInterceptor）的相关配置，其它的配置就不再赘述了，请参考相关文 
档。 
3.3.1 contactManager相关配置信息 
  
sample.service.IContactManager
contactManager的实现类是ProxyFactoryBean（代理工厂），它使用Spring AOP技术拦截代理接口里的方法，并依次执行拦截器 
列表里的拦截器对应的操作。contactManager有事务拦截器和业务方法安全拦截器。 
3.3.2 contactManagerSecurity相关配置信息 
authenticationManager 认证管理器 
accessDecisionManager 
投票通过策略管理器，和filterInvocationInterceptor采用相同的策略管理器，在实际项目中，如果有 
需要可以采用不同的策略管理器。 
objectDefinitionSource 业务方法的权限配置信息。用于指定不同的业务方法资源对应的权限。 
注意：contactManagerSecurity的实现类是MethodSecurityInterceptor，缺省情况下MethodSecurityInterceptor的 
objectDefinitionSource属性是通过net.sf.acegisecurity.intercept.method.MethodDefinitionSourceEditor来设置的。 
MethodDefinitionSourceEditor只支持属性配置文件的格式（同filterInvocationInterceptor的objectDefinitionSource属性），而实际 
情况中，由于业务方法比较多，显然配置信息存放在数据库中比较好。因此，我们通过注册一个CustomEditorConfigurer来修 
改MethodDefinitionSource类型属 性的对应读取类。配置如下： 　 
DataSourceMethodDefinitionSourceEditor根据以下SQL读取业务方法安全配置信息： 　 
select authority,PROTECTED_RES from authorities where AUTH_TYPE='FUNCTION' and authority like 
'AUTH_FUNC_ContactManager%' 

4.总结 
在本文的示例程序中我们只对业务对象（ContactManager）进行安全保护，对业务领域对象（Contact）的访问并没有作限 
制，这是由于在Acegi框架中采用ACL（访问控制列表）技术实现这个功能，这使得一旦我们的业务领域对象数量很多的话， 
效率将变得很低，因此我们将对业务领域对象访问控制的代码放在业务对象的业务方法中。 
将业务无关的代码从业务代码中剥离，使业务代码更干净，系统结构更合理是每个开发人员的梦想。随着AOP技术的日渐流 
行和日益发展，这个梦想已经离我们不远了。本文中的例子通过结合使用SpringFramework和Acegi两种开源框架，实现了将安 
全认证和授权代码和事务代码从业务代码中分离。  

• 快来参加7月17日在成都举行的SOA中国技术论坛
• 北京: 千橡集团暨校内网诚聘软件研发工程师
• Oracle专区上线，有Oracle最新文章，重要下载及知识库等精彩内容，欢迎访问。
• JavaEye问答大赛开始了！ 从6月23日 至 7月6日，奖品丰厚 ！
• 搜狐网站诚聘Java、PHP和C++工程师