• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

MyEclipse是Eclipse的一个插件，所以，你必须先安装Eclipse才可以安装MyEclipse。
MyEclipse是一个编译器，要做JAVA程序，就要配置基本的JDK环境变量
一、安装JDK

首先下载JDK 5.0（JDK 5.0的下载页面为：http://java.sun.com/j2se/1.5.0/download.jsp）； 然后运行JDK 5.0安装程序jdk-1_5_0_06-windows-i586-p.exe，安装过程中所有选项保持默认；最后配置JDK的环境变量：在“我的电脑”上点右键—>“属性”—>“高级”—> “环境变量(N)”。



新建系统变量JAVA_HOME：C:\Program Files\Java\jdk1.5.0_06；

新建系统变量CLASSPATH：.;%JAVA_HOME%\lib;（注意：点号表示当前目录，不能省略）

在系统变量Path的值的前面加入以下内容：%JAVA_HOME%\bin;(注意:这里的分号不能省略)

到这里，JDK安装完毕。

注意:如果以后要安装诸如Eclipse、Borland JBuilder、JCreator、IntelliJ IDEA等集成开发环境(IDE,Integrated Development Environment),应该在IDE中编译运行一个简单的HelloWorld程序，以保证IDE可以识别出JDK的位置。

二、安装Tomcat

首先下载jakarta-tomcat-5.0.30.zip，之所以下载免安装版的好处是可以使用多个Tomcat（jakarta-tomcat-5.0.30.zip的下载页面为：

http://apache.linuxforum.net/tomcat/tomcat-5/v5.0.30/bin/）；

然后将jakarta-tomcat-5.0.30.zip直接解压到D盘根目录：



最后配置Tomcat的环境变量：在“我的电脑”上点右键—>“属性”—>“高级”—> “环境变量(N)”。

新建系统变量CATALINA_HOME：D:\jakarta-tomcat-5.0.30

在系统变量CLASSPATH的值的后面加入：%CATALINA_HOME%\common\lib;

在系统变量Path的值中"%JAVA_HOME%\bin;"的后面加入以下内容：%CATALINA_HOME%\bin;

到这里，Tomcat安装完毕。

进行完一、二两步的设置以后，各系统变量的值如下：

JAVA_HOME:C:\Program Files\Java\jdk1.5.0_06
CATALINA_HOME:D:\jakarta-tomcat-5.0.30
CLASSPATH:.;%JAVA_HOME%\lib;%CATALINA_HOME%\common\lib;
Path:%JAVA_HOME%\bin;%CATALINA_HOME%\bin;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem

三、安装Eclipse

首先下载eclipse-SDK-3.1.2-win32.zip（eclipse-SDK-3.1.2-win32.zip下载地址为：

http://www.eclipse.org/downloads/）；

然后将eclipse-SDK-3.1.2-win32.zip直接解压到D盘根目录：



到这里， Eclipse安装完毕。

四、安装MyEclipse

首先下载EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe（EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe 的下载地址为：
http://www.myeclipseide.com/ContentExpress-display-ceid-10.html）；

然后安装EnterpriseWorkbenchInstaller_4.1.1GA_E3.1.exe。注意：安装时候要选择Eclipse的安装路径，其他选项保持默认。



安装完毕之后，将MyEclipse安装目录下的features和plugins这2个目录覆盖到Eclipse的安装目录下。

最后将刚才安装的 MyEclipse 卸载。

解释一下上面这样做的原因： 因为MyEclipse是Eclipse的插件，所以只要把features和plugins这2个目录覆盖到Eclipse的安装目录，Eclipse就会自动认出这些插件。

到这里，MyEclipse安装完毕。

五、破解MyEclipse

运行MyEclipse4.1.1注册机MyEclipseKeyGen.exe，选择MyEclipse的版本号，输入注册名，生成序列号。（MyEclipse4.x注册机的下载地址为：

http://esoft.g8.com.cn/UploadFiles/2006-5/520753587.rar）

运行eclipse.exe（首次运行要求指定Workspace），依次点击Window ----> Preferences ---->MyEclipse---->Subscription ----> Enter Subscription，输入注册名以及注册机生成的注册码。

到这里，MyEclipse破解完毕。

六、指定Eclipse+MyEclipse的JRE
1.设定Eclipse+MyEclipse的JRE

一般情况下，Eclipse可以自动找到JRE，我们不用进行过多的设置。

到这里，我们的Eclipse+MyEclipse开发环境就搭建完毕了！

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

在运行过程中出现
ClassNotFoundException: org.hibernate.hql.ast.HqlToken 错误weblogic异常退出。
原因:
Hibernate3.0 采用新的基于ANTLR的HQL/SQL查询翻译器，在Hibernate的配置文件中，hibernate.query.factory_class属性用来选择查询翻译器。
（1）选择Hibernate3.0的查询翻译器：
hibernate.query.factory_class= org.hibernate.hql.ast.ASTQueryTranslatorFactory
（2）选择Hibernate2.1的查询翻译器
hibernate.query.factory_class= org.hibernate.hql.classic.ClassicQueryTranslatorFactory
为了使用3.0的批量更新和删除功能，只能选择（1）否则不能解释批量更新的语句，当使用的时候出现了不支持条件输入中文的情况。选择（2）可以支持输入中文，但没法解释批量更新语句了
在hibernate3中需要用到antlr，然而这个包在weblogic.jar中已经包含了antrl类库，就会产生一些类加载的错误，无法找到在war或者ear中的hibernate3.jar。
出现这个错误之后，antlr会调用System.exit()，这样weblogic就会中止服务。
解决方法:
1.是在hibernate.properties文件中增加属性：hibernate.query.factory_class，属性的值是org.hibernate.hql.classic.ClassicQueryTranslatorFactory，这样就可以解决问题了。
但是部分功能会有问题，譬如
但本系在批量删除和更新会有问题,本系统不采用
2.将antlr-2.7.5H3.jar到Weblogic的pre_Classpath :用WinRar或Winzip打开C:\bea\weblogic81\server\lib\weblogic.jar 删除里面的antlr目录, 然后再antlr-2.7.5H3.jar放在weblogic.jar的同一目录(注:替换之后没做做过严格测试,尚不知是否有后遗症)
3. 1、拷贝Hibernate3里带的包antlr-2.7.5H3.jar到%WL_HOME%\server\lib下
2、修改% mydomain% \ startWebLogic.cmd ：
在set CLASSPATH之前加上下面一句：
set PRE_CLASSPATH=%WL_HOME%\server\lib\antlr-2.7.5H3.jar;
在set CLASSPATH之后加上下面一句：
set CLASSPATH=%PRE_CLASSPATH%;%CLASSPATH%
一切OK！
具体原因可参照此页：http://dev2dev.bea.com/blog/pmalani/archive/2005/07/configuring_web.html

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

前一段时间刚来公司,看到一个项目中以前有人写的struts代码。是使用了FormFile来处理关于文件上传的模块。但是用力一段时间后，发现出问题了。写完的这个模块，上传文件是没有问题的，但是当服务器的空间较小的时候，穿一个比较大的文件就出问题了，文件还没有上传完，就抛出一个错误的页面,报告上传模块出了问题，而且是Tomcat默认的出错页面。

      于是想办法，修改，查看源代码，发现原来写这段代码的人是默认等文件上传完以后进入Action了才判断文件大小是否超出了限制。

      但是，默认配置下使用struts的FormFile比较特殊，FormFile是struts包对外的一个接口，而且org.apache.struts.upload包是使用的commons-fileupload-1.0进行的封装。如果使用了它来实现文件上传的功能，则必须是FormFile对象在被初始化以后才能使用，那什么时候它才是被初始化的呢？

      答案是：在进入Action之前就已经初始化好了！

      因此，原先的设计：在Action中判断文件大小是根本不能在上传过程中起到提示作用的，因为这时候文件已经上传完了。而且这个设计还有一个确定就是不能捕获上传过程中出现的任何问题。也就是说：在Action里我们得到的FormFile对象是上传的一个结果，而不是一个未上传好就可以使用的对象！

      那如何控制FormFile上传的过程呢？显然，在Action里处理已经不能奏效了，想想别的办法，让我们翻看一下Struts的源代码找找灵感吧。 

      这是struts1.1的org.apache.struts.upload包的描述：

 从上图我们可以看出有有CommonsMultipartRequestHandler和DiskMultipartRequestHandler两个类实现了MultipartRequestHandler接口。

      大家都知道，Commons-fileupload控件在上传的时候，使用的enctype为：enctype="multipart/form-data"，因此不难看出MultipartRequestHandler的实现就是来处理enctype="multipart/form-data"这样的post请求的。

      但是这里有两个类，CommonsMultipartRequestHandler和DiskMultipartRequestHandler。到底哪个是处理FormFile的上传的呢？这个问题应该从org.apache.struts.config包里来找。

org.apache.struts.config包是用来处理struts配置文件的数据的包。找到org.apache.struts.config. ControllerConfig。

      看这几行：

  /**

     * The fully qualified Java class name of the MultipartRequestHandler

     * class to be used.

     */

    protected String multipartClass =

        "org.apache.struts.upload.CommonsMultipartRequestHandler"; 


    public String getMultipartClass() {

        return (this.multipartClass);

    } 


    public void setMultipartClass(String multipartClass) {

        if (configured) {

            throw new IllegalStateException("Configuration is frozen");

        }

        this.multipartClass = multipartClass;

   } 

这几行的意思很明白，如果没有在配置文件中配置MultipartRequestHandler实现类的绝对路径，那就使用org.apache.struts.upload.CommonsMultipartRequestHandler类默认处理。

   ^_^，这就是关键了:struts是默认使用org.apache.struts.upload.CommonsMultipartRequestHandler类来处理FormFile指定的上传文件的。

   马上转到org.apache.struts.upload.CommonsMultipartRequestHandler来看看：

/**

   *默认文件上传的大小是250M

   */

   public static final long DEFAULT_SIZE_MAX = 250 * 1024 * 1024; 


   /**

   *上传文件在内存中使用的缓冲区大小，超过次数值的数据写入硬盘。

   */

   public static final int DEFAULT_SIZE_THRESHOLD = 256 * 1024; 

 还有，最最重要的实现方法：

/**

   * Parses the input stream and partitions the parsed items into a set of

   * form fields and a set of file items. In the process, the parsed items

   * are translated from Commons FileUpload <code>FileItem</code> instances

   * to Struts <code>FormFile</code> instances.

   *

   * @param request The multipart request to be processed.

   *

   * @throws ServletException if an unrecoverable error occurs.

              就是这个函数处理上传文件的request，把request交给

              Commons FileUpload 控件处理，并解析FileItem转换成Struts的FormFile。

   */

   public void handleRequest(HttpServletRequest request)

               throws ServletException 

再看看这个函数内部是怎么实现的吧？

   // 使用了DiskFileUpload。
 // （Commons-FileUpload很老版本的一个上传实现类了，还在用？我的显示是Deprecated）

   DiskFileUpload upload = new DiskFileUpload();

   // 上传最大值

   upload.setSizeMax((int) getSizeMax(ac));

   // 上传文件在内存中使用的缓冲区大小

   upload.setSizeThreshold((int) getSizeThreshold(ac));

   // 存在硬盘的什么地方，一般是默认

   upload.setRepositoryPath(getRepositoryPath(ac)); 

接着看handleRequest如何处理request的：

     // Parse the request into file items.

           List items = null;

           try {

               items = upload.parseRequest(request);

           }          //这里是关键：上传过程中出了超出最大值的异常了，如何处理？

     catch (DiskFileUpload.SizeLimitExceededException e) { 

               // Special handling for uploads that are too big.

               request.setAttribute(

                       MultipartRequestHandler.ATTRIBUTE_MAX_LENGTH_EXCEEDED,

                       Boolean.TRUE);

               return;

           } 

               //出了其他异常，如enctype不对，磁盘空间不足怎么办？

   catch (FileUploadException e) {

               log.error("Failed to parse multipart request", e);

               throw new ServletException(e);

           }

 这次一目了然了：

         Struts根本没有把上传过程中出的超出最大值的异常带到Action，因为那是不可能的，而是把它放到了rquest的Attribute里。

         而出了其他异常如enctype不对，磁盘空间不足怎么办？很遗憾，Struts没有去处理它，而是log了一下，抛给了上一层了。 

         那我一定要获得这些全部异常咋办呢？没办法，自己定制一个MultipartRequestHandler吧，那样就能彻底解决上传过程中的控制问题了！

         在此之前，我们得先去最新版的commons-fileupload控件看看上传过程中可能抛出多少异常？

         //所有上传异常的父类

         org.apache.commons.fileupload.FileUploadException 

//注意：这个类的类名是FileUploadBase.SizeLimitExceededException是个public内//部类。上传的formdata总的数据超出了规定大小

         org.apache.commons.fileupload.FileUploadBase.SizeLimitExceededException 

         //注意：也是个内部类。这个才是上传的文件超出了规定大小

         org.apache.commons.fileupload.FileUploadBase.FileSizeLimitExceededException

         其它的，也看看吧：

         org.apache.commons.fileupload.FileUploadBase.FileUploadIOException

         org.apache.commons.fileupload.FileUploadBase.InvalidContentTypeException

         org.apache.commons.fileupload.FileUploadBase.IOFileUploadException

         org.apache.commons.fileupload.FileUploadBase.UnknownSizeException 

         要想获得尽可能仔细的数据就在处理的try/catch块里把上面的异常都catch一下，放到request的attribute里去就OK了。

         另外还有要说的是，最好用commons-fileupload控件的最新版本，因为DiskFileUpload这个类，commons-fileupload已经弃用了，取而代之的是ServletFileUpload类了，所以一定要注意！切记，切记….. 

         这是我写的CommonsMultipartRequestHandler替代类的public void handleRequest(HttpServletRequest request) throws ServletException函数： 

 public void handleRequest(HttpServletRequest request) throws ServletException

         ...{ 


               // Get the app config for the current request.

               ModuleConfig ac = (ModuleConfig) request.getAttribute(Globals.MODULE_KEY); 


               // DiskFileItem工厂,主要用来设定上传文件的参数

               DiskFileItemFactory fileItemFactory = new DiskFileItemFactory();

               // 上传文件所用到的缓冲区大小,超过此缓冲区的部分将被写入到磁盘

               fileItemFactory.setSizeThreshold((int) this.getSizeThreshold(ac));

               // 上传文件用到的临时文件存放位置

               fileItemFactory.setRepository(this.getRepository(ac)); 


               // 使用fileItemFactory为参数实例化一个ServletFileUpload对象

               // 注意:该对象为commons-fileupload-1.2新增的类.

               // 对于1.2以下的commons-fileupload版本并不存在此类.

               ServletFileUpload upload = new ServletFileUpload(fileItemFactory);

               // 从session中读取对本次上传文件的最大值的限制

               String maxUploadSize = (String) request.getSession().getAttribute(BasicConstants.maxUploadSize);

               // 获取struts-config文件中controller标签的maxFileSize属性来确定默认上传的限制

               // 如果struts-config文件中controller标签的maxFileSize属性没设置则使用默认的上传限制250M.

               long defaultOrConfigedMaxUploadSize = this.getSizeMax(ac); 


               if (maxUploadSize != null && maxUploadSize != "")

               ...{

                     // 如果maxUploadSize设定不正确则上传限制为defaultOrConfigedMaxUploadSize的值

                     // 正确则为maxUploadSize转换成的字节数

                     upload.setSizeMax((long) this.convertSizeToBytes(maxUploadSize, defaultOrConfigedMaxUploadSize));

               }

               else

               ...{

                     // 如果maxUploadSize没设置则使用默认的上传限制

                     upload.setSizeMax(defaultOrConfigedMaxUploadSize);

               } 


               // 从session中清空maxUploadSize

               request.getSession().removeAttribute("maxUploadSize"); 


               // Create the hash tables to be populated.

               elementsText = new Hashtable();

               elementsFile = new Hashtable();

               elementsAll = new Hashtable(); 


               // Parse the request into file items.

               List items = null;

               // ServletFileUpload类来处理表单请求

               // 抛出的异常为FileUploadException的子异常

               // 如果捕获这些异常就将捕获的异常放到session中返回.

               try

               ...{

                     items = upload.parseRequest(request);

               }

               catch (FileUploadBase.SizeLimitExceededException e)

               ...{

                     // 请求数据的size超出了规定的大小.

                     request.getSession().setAttribute(BasicConstants.baseSizeLimitExceededException, e);

                     return;

               }

               catch (FileUploadBase.FileSizeLimitExceededException e)

               ...<

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

“西湖美景，三月天呐，春雨如酒，柳如烟呐；有缘千里来相会，无缘对面手难牵，十年修得同船度，百年修得共枕眠。”走在西湖边上，嘴里哼着这首歌，想象着当年许仙和白娘子在断桥上相逢，那场面啊，今天想起来确实有些感觉。而今我是一个人漫步在这西湖边上，头顶着烈日，任凭周围人声嘈杂，心中却是欢喜的，毕竟是出来旅游嘛，心情当然不错。更何况是这美丽的西湖呢，脑中又浮现出一句，“若把西湖比西子，淡妆浓抹总相宜。”怪不得同事说，他跟他老婆走在西湖边上，边走边作诗呢，当时我还不信，现在我信了，这么美的景色面前，才思如泉涌一般的冒出来了。据说来西湖最好的时间是清明前后，或者十月份（山核桃下来了，很好吃）。去之前，我盼望着下雨，那时就可以雨中漫步西湖了，可并未随我心愿，又是艳阳高照，最高气温达到35°，但对于没来过西湖的我来说，不管是下火也好，也阻挡不了我游玩的脚步。我从武林门，一直走到断桥，然后徒步走过白堤，到了岳庙，这在地图上也是一段不近的距离呢，估计去过杭州的人应该知道，像我这样的没有几个吧。我想走这么远的路是跟心情有关的，我的心情一直都很愉快。所以也就一路走来了。白堤是没有什么特别的，两旁都种了很多树，而且路两旁的风景各异。走在白堤上可以望见远处的在湖中的一个个郁郁葱葱的小岛，那是三潭印月，就是湖中的三个岛，需要乘船过去；再远处依稀可见雷峰塔还有远山。白堤的另一侧，则是一池荷花，还有那青翠逼人的山，让人看着真是舒服。一路上有美景陪伴，所以也就不觉得累了。来西湖之前，我告诉自己一定要来岳飞庙看看，总觉得这是个一定要去的地方，说心中有几分崇敬之情是一点也不夸张的。在去岳庙的途中，路过了苏小小的墓，之前，我一直以为苏小小是苏东坡的妹妹呢，呵呵，我在那照相留念，希望沾点她的才情和她那不俗气质。中午12点半了，我终于到了岳庙。站在岳庙门前，我几乎睁不开眼睛，强烈的太阳光直射地面，然后又反射到我的身上，把我像馒头一样的烤着:) 又是留影，无非是想告诉别人我来过这了。一个人旅游就是这点不好，想留个影总得麻烦别人，这不，我又麻烦别人了。我喜欢岳庙里面那些很有气节的题词，比如心昭天日、还我河山、精忠报国、一门忠孝、气壮山河等等。这时候不管是谁，都会精神振奋的！人们纷纷跟大英雄岳飞合影，终于轮到我了，我紧紧的握住岳飞的手，让那一瞬间成为了永恒。当然还有那些遭人唾弃的叛徒，比如说秦桧，他老婆王氏。很早以前听我妈说过，秦桧和王氏的铜像是跪着的，并且游人路过都要唾弃一番，所以想象着比较恶心，今日亲眼所见，确实挺那个的，唉，名垂千史和遗臭万年都是会让人们记住的，只不过，纪念的方式不同罢了。他们估计也没想想到这么多年过去了，他们竟是这样的下场。好在现代人的素质高了，随地吐痰是不文明的，大家多吃几根油条就行了，一样解恨了。油条不就是炸得秦桧和王氏么？我没有再多留片刻，因为我实在是有些虚脱了，在这炎炎烈日下，我又徒步走了这么多路，实在是没那个体力了。本来我想去雷峰塔还有龙井村去看看呢，可是只能留给下次了，人生本来就是要留些遗憾的，不然怎么还会有下次呢。

其实我来杭州的一个主要的目的是奔好吃的来的。在杭州吃的第一顿饭就是在马滕路的外婆家，这是家很有名的餐厅，早上十点多就有很多人在就餐了，我去的时候刚好，人还不多，我把这得招聘菜点了个遍，别忘了我是一个人啊，一个人的战斗啊，一个人吃了这么多的菜，珊瑚虾、茶香鸡、西湖醋鱼、酒酿圆子等等，可把我撑坏了，周围就餐的人和服务员一定以为我几天没吃饭了呢，我顾不得那么多了，谁让我是“见了吃不要命”呢。所以吃完了，我就去宾馆躺着去了，实在是走不动了。中午吃得多也就算了，谁知道，下午从灵隐寺回来，又遇上了美味，真是可与而不可求啊--“知味观”。这又是杭州的一个无人不知无人不晓的地方。虽然我毫无饿意，但我还是走进去了，唉，见了吃不要命嘛。我点了东坡肉、猫耳朵、千层木瓜酥、小笼包......居然这么美味。当时我脑子里突然冒出一个念头，我要是在杭州买房多好啊。真想一辈子陪着这些美食过。到了第二天，我知道下午就要回上海了，但是心里面总觉还缺了点什么，那就是--“爆鳝面”。来杭州之前，我就Google了一下杭州的美食，有一个叫做“奎元馆”的地方给我很深印象，据说，金庸每次来杭州，必到奎元馆吃一碗爆鳝面。想必这爆鳝面必定是美味了。所以，在临走之前，我一定要吃上一碗再走。为了这碗面，我又付出了沉重的代价。我走街串巷，四处询问，估计打车也得花上几十块钱的路程，但不管怎么说，我找到了，在解放路上的这家奎元馆。下午四点钟，我坐在大厅里，吃着爆鳝面，那叫一个香，什么千里迢迢，跋山涉水啊，统统抛到脑后了，此时此刻，就享受一碗爆鳝面。在杭州一共就吃了这三顿饭，让人回味无穷啊。

当然在这次旅行中，给我印象最深是两位素不相识的大妈。她们的热情好客，给我这次一个人的旅行很多鼓舞，也让我心情变得很愉快，很轻松。她们给我讲当地的风土人情，告诉到到哪买上好的丝绸，去哪买正宗的龙井，还有就是到哪吃正宗的爆鳝面，呵呵，这些除了龙井茶外，我都领略过了。真的由衷的感谢他们。杭州有了这群可爱的人们明天会更好！

杭州，我还会再来的！

• Windows7在微软WinHEC 2008上揭开神秘面纱
• 搜狐网站诚聘Java、PHP和C++工程师

• 搜狐网站诚聘Java、PHP和C++工程师
• Windows7在微软WinHEC 2008上揭开神秘面纱

Aspect Oriented Programming
AOP概念
Aspect Oriented Programming（AOP）是近来较为热门的一个话题。AOP，国内
大致译作“面向方面编程”。
“面向方面编程”,这样的名字并不是非常容易理解，且容易产生一些误导。笔者不止
一次听到类似“OOP/OOD11即将落伍，AOP是新一代软件开发方式”这样的发言。显然，
发言者并没有理解AOP的含义。
Aspect，没错，的确是“方面”的意思。不过，华语传统语义中的“方面”，大多数情
况下指的是一件事情的不同维度、或者说不同角度上的特性，比如我们常说：“这件事情要
从几个方面来看待”，往往意思是：需要从不同的角度来看待同一个事物。这里的“方面”，
指的是事务的外在特性在不同观察角度下的体现。
而在AOP中，Aspect的含义，可能更多的理解为“切面”比较合适。所以笔者更倾向
于“面向切面编程”的译法。
另外需要提及的是，AOP、OOP在字面上虽然非常类似，但却是面向不同领域的两种
设计思想。OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，
以获得更加清晰高效的逻辑单元划分。
而AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步
骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。这两种设计思想在目标上有
着本质的差异。
上面的陈述可能过于理论化，举个简单的例子，对于“雇员”这样一个业务实体进行封
装，自然是OOP/OOD的任务，我们可以为其建立一个“Employee”类，并将“雇员”相
关的属性和行为封装其中。而用AOP设计思想对“雇员”进行封装将无从谈起。
同样，对于“权限检查”这一动作片断进行划分，则是AOP的目标领域。而通过OOD/OOP
对一个动作进行封装，则有点不伦不类。
换而言之，OOD/OOP面向名词领域，AOP面向动词领域。
AOP和OOD/OOP并不冲突，我们完全可以在一个应用系统中同时应用OOD/OOP和
AOP设计思想，通过OOD/OOP对系统中的业务对象进行建模，同时通过AOP对实体处理
过程中的阶段进行隔离处理。即使不是OOD/OOP，而是在传统的POP（面向过程编程）中，
AOP也能起到同样的作用。
将不同阶段领域加以分隔，这是否就算是AOP呢？
AOP还有另外一个重要特点：源码组成无关性。
11 OOD ＝ Object Oriented Design OOP = Object Oriented Programming
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
倘若应用中通过某个具体的业务逻辑类实现了独立的权限检查，而请求调度方法通过预
编码调用这个权限模块实现权限管理。那么这也不算是AOP。对于AOP组件而言，很重要
的一点就是源码组成无关性，所谓源码组成无关性，体现在具体设计中就是AOP组件必须
与应用代码无关，简单来讲，就是应用代码可以脱离AOP组件独立编译。
为了实现源码组成无关性，AOP往往通过预编译方式（如AspectJ）和运行期动态代理
模式（如Spring AOP 和JBoss AOP）实现。
稍后章节中我们会就Spring Framework中的AOP实现机制进行更加深入的探讨。
下面先来看AOP中几个比较重要的概念：
1． 切面（Aspect）
切面，对象操作过程中的截面。这可能是AOP中最关键的一个术语。
我们首先来看一个应用开发中常见的切面：用户权限检查。大概只要是完整的应用，都
少不了用户权限检查这个模块，不同身份的用户可以做什么，不可以做什么，均由这个模块
加以判定。而这个模块调用的位置通常也比较固定：用户发起请求之后，执行业务逻辑之前。
针对权限检查这一模块进行分离，我们就得到了一个切面：
切面意义何在？
首先根据上例，假设我们实现了一个通用的权限检查模块，那么就可以在这层切面上进
行统一的集中式权限管理。而业务逻辑组件则无需关心权限方面的问题。也就是说，通过切
面，我们可以将系统中各个不同层次上的问题隔离开来，实现统一集约式处理。各切面只需
集中于自己领域内的逻辑实现。
这一方面使得开发逻辑更加清晰，专业化分工更加易于进行；另一方面，由于切面的隔
离，降低了耦合性，我们就可以在不同的应用中将各个切面组合使用，从而使得代码可重用
性大大增强。
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
2． 连接点（JoinPoint）
程序运行过程中的某个阶段点。如某个方法调用，或者某个异常被抛出。
3． 处理逻辑（Advice）
在某个连接点所采用的处理逻辑
（这里的Advice，国内不少文案中翻译为“通知”，估计是源于金山词霸，与实际含义不符，因而这
里采用意译）
处理逻辑的调用模式通常有三种：
i. Around
在连接点前后插入预处理过程和后处理过程。
ii. Before
仅在连接点之前插入预处理过程。
iii. Throw
在连接点抛出异常时进行异常处理。
4． 切点（PointCut）
一系列连接点的集合，它指明处理方式（Advice）将在何时被触发。
上述几个概念我们将在稍后的“AOP应用”一节中结合实际使用进行具体探讨。
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
AOP in Spring
Spring中提供的内置AOP支持，是基于动态AOP机制实现。从技术角度来讲，所谓动
态AOP，即通过动态Proxy模式，在目标对象的方法调用前后插入相应的处理代码。
而Spring AOP中的动态Proxy模式，则是基于Java Dynamic Proxy（面向Interface）
和CGLib（面向Class）实现。
前面曾经提及，Spring Framework中的“事务管理”服务，实际上是借助AOP机制
完成。我们这里就以“事务管理”为例，对动态AOP的实现加以探讨，一方面对动态AOP
的实现原理加以探究，另一方面，也可以加深对Spring中事务管理机制的理解。
首先，我们来看基于Java Dynamic Proxy的AOP实现原理。
Dynamic Proxy 与Spring AOP
Dynamic Proxy是JDK 1.3版本中新引入的一种动态代理机制。它是Proxy模式的一
种动态实现版本。
我们先来看传统方式下一个Proxy的实现实例。
假设我们有一个UserDAO接口及其实现类UserDAOImp:
UserDAO.java:
public interface UserDAO {
public void saveUser(User user);
}
UserDAOImp.java:
public class UserDAOImp implements UserDAO{
public void saveUser(User user) {
……
}
}
UserDAOImp.saveUser方法中实现了针对User对象的数据库持久逻辑。
如果我们希望在UserDAOImp.saveUser方法执行前后追加一些处理过程，如启动/
提交事务，而不影响外部代码的调用逻辑，那么，增加一个Proxy类是个不错的选择：
UserDAOProxy.java
public class UserDAOProxy implements UserDAO {
private UserDAO userDAO;
public UserDAOProxy(UserDAO userDAO) {
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
this.userDAO = userDAO;
}
public void saveUser(User user) {
UserTransaction tx = null;
try {
tx = (UserTransaction) (
new InitialContext().lookup("java/tx")
);
userDAO.saveUser(user);
tx.commit();
} catch (Exception ex) {
if (null!=tx){
try {
tx.rollback();
}catch(Exception e) {
}
}
}
}
}
UserDAOProxy同样是UserDAO接口的实现，对于调用者而言，saveUser方法的使
用完全相同，不同的是内部实现机制已经发生了一些变化――我们在UserDAOProxy中为
UserDAO.saveUser方法套上了一个JTA事务管理的外壳。
上面是静态Proxy模式的一个典型实现。
现在假设系统中有20个类似的接口，针对每个接口实现一个Proxy，实在是个繁琐无
味的苦力工程。
Dynamic Proxy的出现，为这个问题提供了一个更加聪明的解决方案。
我们来看看怎样通过Dynamic Proxy解决上面的问题：
public class TxHandler implements InvocationHandler {
private Object originalObject;
public Object bind(Object obj) {
this.originalObject = obj;
return Proxy.newProxyInstance(
obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
if (!method.getName().startsWith("save")) {
UserTransaction tx = null;
try {
tx = (UserTransaction) (
new InitialContext().lookup("java/tx")
);
result = method.invoke(originalObject, args);
tx.commit();
} catch (Exception ex) {
if (null != tx) {
try {
tx.rollback();
} catch (Exception e) {
}
}
}
} else {
result = method.invoke(originalObject, args);
}
return result;
}
}
首先注意到，上面这段代码中，并没有出现与具体应用层相关的接口或者类引用。也就
是说，这个代理类适用于所有接口的实现。
其中的关键在两个部分：
1.
return Proxy.newProxyInstance(
obj.getClass().getClassLoader(),
obj.getClass().getInterfaces(),
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
this);
java.lang.reflect.Proxy.newProxyInstance方法根据传入的接口类型
（obj.getClass().getInterfaces()）动态构造一个代理类实例返回，这个代理类是JVM
在内存中动态构造的动态类，它实现了传入的接口列表中所包含的所有接口。
这里也可以看出，Dynamic Proxy要求所代理的类必须是某个接口的实现
（obj.getClass().getInterfaces()不可为空），否则无法为其构造响应的动态类。这也
就是为什么Spring对接口实现类通过Dynamic Proxy实现AOP，而对于没有实现任何接口
的类通过CGLIB实现AOP机制的原因，关于CGLIB，请参见稍后章节的讨论。
2.
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
……
result = method.invoke(originalObject, args);
……
return result;
}
InvocationHandler.invoke方法将在被代理类的方法被调用之前触发。通过这个方
法中，我们可以在被代理类方法调用的前后进行一些处理，如代码中所示，
InvocationHandler.invoke方法的参数中传递了当前被调用的方法（Method），以及被
调用方法的参数。
同时，我们可以通过Method.invoke方法调用被代理类的原始方法实现。这样，我们
就可以在被代理类的方法调用前后大做文章。
在示例代码中，我们为所有名称以“save”开头的方法追加了JTA事务管理。
谈到这里，可以回忆一下Spring事务配置中的内容：
<property name="transactionAttributes">
<props>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
想必大家已经猜测到Spring事务管理机制的实现原理。
是的，只需通过一个Dynamic Proxy对所有需要事务管理的Bean进行加载，并根据配
置，在invoke方法中对当前调用的方法名进行判定，并为其加上合适的事务管理代码，那
么就实现了Spring式的事务管理。
当然，Spring中的AOP实现更为复杂和灵活，不过基本原理一致。
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
代码胜千言，下面是笔者在客户培训过程中编写的一个Dynamic Proxy based AOP
实现示例，非常简单，有兴趣的读者可以看看。
AOPHandler.java:
public class AOPHandler implements InvocationHandler {
private static Log logger = LogFactory.getLog(AOPHandler.class);
private List interceptors = null;
private Object originalObject;
/**
* 返回动态代理实例
* @param obj
* @return
*/
public Object bind(Object obj) {
this.originalObject = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(),
obj
.getClass().getInterfaces(), this);
}
/**
* 在Invoke方法中，加载对应的Interceptor，并进行
* 预处理(before)、后处理(after)以及异常处理（exceptionThrow）过程
*/
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object result = null;
Throwable ex = null;
InvocationInfo invInfo = new InvocationInfo(proxy, method, args,
result, ex);
logger.debug("Invoking Before Intercetpors!");
invokeInterceptorsBefore(invInfo);
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
try {
logger.debug("Invoking Proxy Method!");
result = method.invoke(originalObject, args);
invInfo.setResult(result);
logger.debug("Invoking After Method!");
invokeInterceptorsAfter(invInfo);
} catch (Throwable tr) {
invInfo.setException(tr);
logger.debug("Invoking exceptionThrow Method!");
invokeInterceptorsExceptionThrow(invInfo);
throw new AOPRuntimeException(tr);
}
return result;
}
/**
* 加载Interceptor
* @return
*/
private synchronized List getIntercetors() {
if (null == interceptors) {
interceptors = new ArrayList();
//Todo：读取配置，加载Interceptor实例
//interceptors.add(new MyInterceptor());
}
return interceptors;
}
/**
* 执行预处理方法
* @param invInfo
*/
private void invokeInterceptorsBefore(InvocationInfo invInfo) {
List interceptors = getIntercetors();
int len = interceptors.size();
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
for (int i = 0; i < len; i++) {
((Interceptor) interceptors.get(i)).before(invInfo);
}
}
/**
* 执行后处理方法
* @param invInfo
*/
private void invokeInterceptorsAfter(InvocationInfo invInfo) {
List interceptors = getIntercetors();
int len = interceptors.size();
for (int i = len - 1; i >= 0; i--) {
((Interceptor) interceptors.get(i)).after(invInfo);
}
}
/**
* 执行异常处理方法
* @param invInfo
*/
private void invokeInterceptorsExceptionThrow(InvocationInfo
invInfo) {
List interceptors = getIntercetors();
int len = interceptors.size();
for (int i = len - 1; i >= 0; i--) {
((Interceptor)
interceptors.get(i)).exceptionThrow(invInfo);
}
}
}
Interceptor.java:
public interface Interceptor {
public void before(InvocationInfo invInfo);
public void after(InvocationInfo invInfo);
public void exceptionThrow(InvocationInfo invInfo);
}
InvocationInfo.java:
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
public class InvocationInfo {
Object proxy;
Method method;
Object[] args;
Object result;
Throwable Exception;
public InvocationInfo(Object proxy, Method method, Object[] args,
Object result, Throwable exception) {
super();
this.proxy = proxy;
this.method = method;
this.args = args;
this.result = result;
Exception = exception;
}
public Object getResult() {
return result;
}
public void setResult(Object result) {
this.result = result;
}
public Object[] getArgs() {
return args;
}
public void setArgs(Object[] args) {
this.args = args;
}
public Throwable getException() {
return Exception;
}
public void setException(Throwable exception) {
Exception = exception;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
public Object getProxy() {
return proxy;
}
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
public void setProxy(Object proxy) {
this.proxy = proxy;
}
}
AOPFactory.java:
public class AOPFactory {
private static Log logger = LogFactory.getLog(AOPFactory.class);
/**
* 根据类名创建类实例
* @param clzName
* @return
* @throws ClassNotFoundException
*/
public static Object getClassInstance(String clzName){
Class cls;
try {
cls = Class.forName(clzName);
return (Object)cls.newInstance();
} catch (ClassNotFoundException e) {
logger.debug(e);
throw new AOPRuntimeException(e);
} catch (InstantiationException e) {
logger.debug(e);
throw new AOPRuntimeException(e);
} catch (IllegalAccessException e) {
logger.debug(e);
throw new AOPRuntimeException(e);
}
}
/**
* 根据传入的类名，返回AOP代理对象
* @param clzName
* @return
*/
public static Object getAOPProxyedObject(String clzName){
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
AOPHandler txHandler = new AOPHandler();
Object obj = getClassInstance(clzName);
return txHandler.bind(obj);
}
}
MyInterceptor.java:
public class MyInterceptor implements Interceptor{
private static Log logger = LogFactory.getLog(MyInterceptor.class);
public void before(InvocationInfo invInfo) {
logger.debug("Pre-processing");
}
public void after(InvocationInfo invInfo) {
logger.debug("Post-processing");
}
public void exceptionThrow(InvocationInfo invInfo) {
logger.debug("Exception-processing");
}
}
Spring中Dynamic Proxy AOP实现类为：
org.springframework.aop.framework.JdkDynamicAopProxy
SpringFrameWork Developer’s Guide Version 0.6
October 8, 2004 So many open source projects. Why not Open your Documents?
CGLib 与Spring AOP
上面曾经提过，Dynamic Proxy是面向接口的动态代理实现，其代理对象必须是某个
接口的实现。Dynamic Proxy通过在运行期构建一个此接口的动态实现类完成对目标对象
的代理（相当于在运行期动态构造一个UserDAOProxy，完成对UserDAOImp的代理任
务）。
而如果目标代理对象并未实现任何接口，那