Spket 默认编码是GBK，要换成UTF-8应怎么做？
选择 project 或者 file, 点鼠标右键，选 properties 菜单，在弹出窗口，选 Resource, 设置 Text file encoding 为 UTF-8 就 ok 了
posted @ 2008-11-13 18:55 caihaibo 阅读(527) | 评论 (1) | 编辑 收藏
配置 JSP SEVLET 使用的IDE的过程（MyEclipse插件和EclipseIDE）
 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开发环境就搭建完毕了！
参考资料：http://www.webdn.com/web_file/program/jsp/0602080402/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开发环境就搭建完毕了！
参考资料：http://www.webdn.com/web_file/program/jsp/0602080402/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开发环境就搭建完毕了！
参考资料：http://www.webdn.com/web_file/program/jsp/0602080402/
posted @ 2008-11-13 11:43 caihaibo 阅读(529) | 评论 (0) | 编辑 收藏
windows XP 锁定电脑的方法
 
在Windows Xp系统中，按“Alt+Ctrl+Delete”出现的是任务管理器，不是
安全对话框这样不能锁定计算机，可以打开控制面板，点击“切换到经典视图”
后选择“用户账户”，在选择“更改用户登录或注销方式”，不选“使用欢迎
屏幕”，然后确定。在按Alt+Ctrl+Delete”出现的是Windows安全对话框，点
“锁定计算机”即可OK。
posted @ 2008-11-12 13:33 caihaibo 阅读(213) | 评论 (0) | 编辑 收藏
异常备忘：java.lang.UnsupportedClassVersionError: Bad version number in .class file
今天在导入一个工程时，编译并打包到Tomcat后，发现出现java.lang.UnsupportedClassVersionError: Bad version number in .class file异常，检查了一下我的myEclipse，发现不知道啥时候不小心将编译器改成JDK6.0了，那个工程是从同事的机上拷贝过来的，用的编译器是JDK5.0，试了一下，果然是这个问题引起。
    那次在Linux上部署工程时也出现过因为版本不同引起的问题，那时我们用的IDE的编译器是JDK5.0，而那台Linux装的是JDK6.0，部署后发现很多功能都出错，看来有些东西还是得注意一下啊。
    附，在myEclipse中改变编译器的方法：Project->Properties->Java Compiler->Configure Workspace Setting，在弹出的页面中可以进行设置。
posted @ 2008-11-09 21:59 caihaibo 阅读(280) | 评论 (1) | 编辑 收藏
tomcat添加用户经典方法与懒人方法
手动安装的tomcat没有生成admin跟manager用户,要进入tomcat的admin管理界面必须自己手动添加.

打开tomcat安装目录下的conf/tomcat-users.xml文件,在<tomcat-users>和</tomcat-user>中间添加:

<role rolename="manager"/>
<role rolename="admin"/>
和
<user username="manager" password="tomcat" roles="manager"/>
<user username="admin" password="tomcat" roles="admin"/>

其中user字段中的username和password就是你的用户名跟密码,添加完成后就可以用这个用户名跟密码登录tomcat的admin以及manager页面了.

http://localhost:8080/admin
http://localhost:8080/manager

懒人方法：

<user username="both" password="tomcat"

                                  roles="manager,tomcat,role1"/>

直接添加到此处，下一次tomcat启动时将自动添加一个manager用户！

posted @ 2008-11-09 21:15 caihaibo 阅读(181) | 评论 (0) | 编辑 收藏
MyEclipse 6.0官方下载地址及注册序列号
MyEclipse 6.0官方下载地址：
http://www.myeclipseide.com/module-htmlpages-display-pid-4.html

MyEclipse 6.0注册序列号:
Subscriber:QQ24785490
Subscription Code:DLR8ZC-855551-65657857678050018
posted @ 2008-11-05 18:19 caihaibo 阅读(3967) | 评论 (9) | 编辑 收藏
4个mysql客户端工具的比较
 mysql是我以前学习和练习所使用的数据，现在在工作中也在使用，之前公司里用oracle，我在做自己的东西的时候觉得用oracle太不方便，于是就找了mysql（当时也考虑过sqlserver，觉得还是没有mysql小巧），从那时起我就开始接触下面所说的几种mysql客户端工具了。
           我接触的mysql客户端工具一共有4个，mysqlfront, mysqlyog, mysqlbrowser, ems mysql manager,其中mysqlbrowser是我最早使用的一个mysql客户端工具（一年前），当时是在一个自己接的交友网站中使用mysql，于是就找到了这个mysqlbrowser，
mysqlbrowser的优点是简单，及其的简单，安装之后能够立刻上手，马上就能使用的那种，布局也很简陋，功能也很简陋，简单使用没有问题，尤其是刚开始学习mysql的同学，可以尝试一下。

          接下来我使用的是ems，ems到了另外一个极端，强大，非常强大，表和字段的任何属性都能随意修改，那么它强大的同时必然带来了使用的复杂，可以说刚开始 使用的时候很不习惯它的布局。它有一个我比较赞赏的优点，就是快捷键，它有很多快捷键，这一点和mysqlbrowser比有天壤之别。

         我第三个遇到的mysql客户端工具是mysqlfront，它给我的感觉是功能和易用性介于mysqlbrowser和ems之间，它有不少缺点，不如说无法修改表的一些属性，和一些字段的属性等等。

          第四个就是mysqlyog，这个工具给我的感觉是介于mysqlbrowser和mysqlfront之间，总体感觉没有mysqlfront强大。
          通过我的一些认识，我觉得它们的排名是1mysqlbrowser，2mysqlyog，3mysqlfront，4ems。这是根据功能的强大与否来排名的。ems的功能是最强大，所以我现在一直在使用它。我也推荐大家使用ems mysql manager。ems有两个版本，lite版（免费），professional（专业版），我一直使用的lite版，程序员而言，lite版已经完全够用了。
posted @ 2008-11-04 10:43 caihaibo 阅读(178) | 评论 (0) | 编辑 收藏
Java设计模式—模板方法(Template Method)
模板是指在薄片塑料板上面写字后挖空,再使用毛笔或色笔涂满挖空部分,就能看到纯手工而以不失工整的字样,看到模板上的挖空形状,马上就知道最后会变出什么样子的字,不过实际上所显现出来的字样还是要依所使用的画笔种类而定.拿黑色签字笔当画笔,结果当然就是签字笔的字样;当用铅笔来画,得到的也只会是灰黑色的铅笔字;如果用五颜六色的彩色笔,自然能创出让人眼花的多色字.但是,无论使用哪种文具,制作出来的字样都还是脱不了模板上已经固定的形状。

   下面我们用例子说明模板方法

  程序示例类之间的关系

  1.模板类，相当于我们上面提到的薄片塑料板

Java代码 复制代码
  1. package com.pattern.templateMethod;   
  2.   
  3. /**  
  4.  * 抽象类,充当模板角色  
  5.  * @author administrator  
  6.  *  
  7.  */  
  8. public abstract class AbstractDisplay {   
  9.     //由子类实现的抽象方法   
  10.     public abstract void open();      
  11.     public abstract void print();   
  12.     public abstract void close();   
  13.     //抽象类实现的方法,final可以保证在子类不会被修改   
  14.     public final void display() {   
  15.         open();   //先open...   
  16.         for(int i=0; i < 5; i++) {  //反复输出5次   
  17.             print();     
  18.         }   
  19.         close(); //输出完毕,close   
  20.     }   
  21. }  

 

  2.字符类，输出单个字符

Java代码 复制代码
  1. package com.pattern.templateMethod;   
  2.   
  3. public class CharDisplay extends AbstractDisplay {   
  4.     private char ch;     //应输出的字符   
  5.     public CharDisplay(char ch) {  //把构造函数传递过来的字符ch,存储在字段内   
  6.         this.ch = ch;   
  7.     }   
  8.      
  9.     public void open() {   
  10.         System.out.print("<<");   //输出"<<"作为开始字符串   
  11.     }   
  12.     public void close() {   
  13.         System.out.println(">>");  //输出 ">>"作为结束字符串   
  14.     }   
  15.     public void print() {   
  16.         System.out.print(ch);    //输出存储在字段的字符   
  17.     }   
  18.   
  19. }  

 

   3.字符串类，输出字符串

Java代码 复制代码
  1. package com.pattern.templateMethod;   
  2.   
  3. /**  
  4.  *   
  5.  * @author administrator  
  6.  */  
  7. public class StringDisplay extends AbstractDisplay {   
  8.     private String string;  //应输出的字符串   
  9.     private int width;      //以byte为单位所求出的字符串的"长度"   
  10.        
  11.     public StringDisplay(String string) {   
  12.         this.string =string;   
  13.         width = string.getBytes().length;   
  14.     }   
  15.   
  16.     public void open() {  //打印头装饰字符串   
  17.         printLine();   
  18.     }   
  19.     public void print() { //打印内容   
  20.         System.out.println("|"+string+"|");   
  21.     }   
  22.     public void close() { //打印尾装饰字符串   
  23.         printLine();   
  24.     }   
  25.   
  26.     public void printLine() {   
  27.         System.out.print("+");  //输出"+"号表示边框位置   
  28.         for(int i=0; i < width; ++i) {   
  29.             System.out.print("-");  //当作线段   
  30.         }   
  31.         System.out.println("+");  //输出"+"号表示边框位置   
  32.     }   
  33. }  

  4.测试类

Java代码 复制代码
  1. package com.pattern.templateMethod;   
  2.   
  3. public class Main {   
  4.     public static void main(String[] args) {   
  5.         //建立1个有'A'的CharDisplay的对象   
  6.         AbstractDisplay d1 = new CharDisplay('A');   
  7.         //建立1个有"Hello world"的StringDisplay的对象   
  8.         AbstractDisplay d2 = new StringDisplay("Hello World");   
  9.            
  10.         //d1,d2都是AbstractDisplay的子类对象,可以调用继承到的display()方法   
  11.         d1.display();   
  12.         d2.display();   
  13.     }   
  14. }  

 

 输出:

 

C代码 复制代码
  1.  <<AAAAA>>   
  2. +-----------+   
  3. |Hello World|   
  4. |Hello World|   
  5. |Hello World|   
  6. |Hello World|   
  7. |Hello World|   
  8. +-----------+  

 

 

 

 

 

设计思想：

  作为模板的方法定义在父类（父类为抽象类），而方法定义使用抽象方法，实现抽象方法的是子类，要在子类实现方法，才能决定具体的操作。如果在不同的子类执行不同实现就可以发展出不同的处理内容。不过，无论在哪个子类执行任何一种实现，处理的大致流程都还是要依照父类制定的方式。

posted @ 2008-11-04 10:32 caihaibo 阅读(383) | 评论 (0) | 编辑 收藏
Proxy 代理模式学习笔记

1. 意图:
为其他对象提供一种代理以控制对这个对象的访问

2. 别名:
surrogate替身

3. 动机
按需创建, 替代对象

4. 适用性
* 远程代理
* 虚代理
* 保护代理
* 智能指引

5. 结构


6. 实例

Java代码 复制代码
  1. package net.yeah.fanyamin.pattern.proxy;   
  2.   
  3. /**  
  4.  * @author walter  
  5.  */  
  6. interface Greet {   
  7.     void sayHello(String name);   
  8.     void goodBye();   
  9. }   
  10.   
  11. class GreetImpl implements Greet {   
  12.     public void sayHello(String name) {   
  13.         System.out.println("Hello " + name);   
  14.     }   
  15.     public void goodBye() {   
  16.         System.out.println("Good bye.");   
  17.     }   
  18. }   
  19.   
  20. public class SimpleProxy implements Greet {   
  21.     private Greet greet = null;   
  22.        
  23.     SimpleProxy(Greet greet) {   
  24.         this.greet = greet;   
  25.     }   
  26.        
  27.     public void sayHello(String name) {   
  28.         System.out.println("--before method sayHello");   
  29.         greet.sayHello(name);   
  30.         System.out.println("--after method sayHello");   
  31.     }   
  32.        
  33.     public void goodBye() {   
  34.         System.out.println("--before method goodBye");   
  35.         greet.goodBye();   
  36.         System.out.println("--after method goodBye");   
  37.     }   
  38.     /**  
  39.      * @param args  
  40.      */  
  41.     public static void main(String[] args) {   
  42.         Greet greet = new SimpleProxy(new GreetImpl());   
  43.         greet.sayHello("walter");   
  44.         greet.goodBye();   
  45.   
  46.     }   
  47.   
  48. }  

 利用JDK中的动态代理

Java代码 复制代码
  1. /**  
  2.  *   
  3.  */  
  4. package net.yeah.fanyamin.pattern.proxy;   
  5.   
  6. import java.lang.reflect.InvocationTargetException;   
  7. import java.lang.reflect.Method;   
  8.   
  9. /**  
  10.  * @author walter  
  11.  */  
  12. public class DebugProxy implements java.lang.reflect.InvocationHandler {   
  13.   
  14.     private Object obj;   
  15.   
  16.     public static Object newInstance(Object obj) {   
  17.         return java.lang.reflect.Proxy.newProxyInstance(obj.getClass().getClassLoader(),   
  18.                                                         obj.getClass().getInterfaces(), new DebugProxy(obj));   
  19.     }   
  20.   
  21.     private DebugProxy(Object obj) {   
  22.         this.obj = obj;   
  23.     }   
  24.   
  25.     public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {   
  26.         Object result;   
  27.         try {   
  28.             System.out.println("--before method " + m.getName());   
  29.             result = m.invoke(obj, args);   
  30.         } catch (InvocationTargetException e) {   
  31.             throw e.getTargetException();   
  32.         } catch (Exception e) {   
  33.             throw new RuntimeException("unexpected invocation exception: " + e.getMessage());   
  34.         } finally {   
  35.             System.out.println("--after method " + m.getName());   
  36.         }   
  37.         return result;   
  38.     }   
  39.   
  40.     /**  
  41.      * @param args  
  42.      */  
  43.     public static void main(String[] args) {   
  44.         Greet greet = (Greet) DebugProxy.newInstance(new GreetImpl());   
  45.         greet.sayHello("walter");   
  46.         greet.goodBye();   
  47.     }   
  48.   
  49. }  



动态代理确实很有价值，而且java的反射机制其实性能并不慢，只不过被代理的Object需要有个Interface就是了。
实际中，代理多用在访问，权限控制
其实从类的实现表现形式来说，和装饰模式，适配器模式，都比较相似，只不过具体实现意义不一样
posted @ 2008-11-04 10:20 caihaibo 阅读(108) | 评论 (0) | 编辑 收藏
策略模式(Strategy模式)

1. 以一个算术运算为例，传统做法为：

java 代码
  1. package org.common;   
  2.   
  3. public class Calculate {   
  4.        
  5.     public String getResult(float a,float b,char c){   
  6.            
  7.         float add = a+b;   
  8.         float sub = a-b;   
  9.         float mult = a*b;   
  10.         float division = a/b;   
  11.            
  12.         switch(c){   
  13.             case '+':   
  14.                 return "相加结果为:" + add;   
  15.             case '-':   
  16.                 return "相减结果为:" + sub;   
  17.             case '*':   
  18.                 return "相乘结果为:" + mult;   
  19.             case '/':   
  20.                 return "相除结果为:" + division;   
  21.             default:   
  22.                 return "出错";   
  23.         }   
  24.     }   
  25.   
  26. }  

 

java 代码
  1. package org.common;   
  2.   
  3. public class Test {   
  4.        
  5.     public static void main(String[] args){   
  6.         float a = 200;   
  7.         float b = 50;   
  8.         Calculate cal = new Calculate();   
  9.         System.out.println(cal.getResult(a, b, '+'));   
  10.         System.out.println(cal.getResult(a, b, '-'));   
  11.         System.out.println(cal.getResult(a, b, '*'));   
  12.         System.out.println(cal.getResult(a, b, '/'));   
  13.         System.out.println(cal.getResult(a, b, '('));   
  14.     }   
  15.   
  16. }   

 

运行结果为：

 相加结果为:250.0
相减结果为:150.0
相乘结果为:10000.0
相除结果为:4.0
出错

2. 用策略模式来实现：

策略模式的用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。
策略模式使得算法可以在不影响到客户端的情况下发生变化。使用策略模式可以把行为和环境分割开来。
环境类负责维持和查询行为类，各种算法则在具体策略中提供。由于算法和环境独立开来，算法的修改都不会影响环境和客户端

策略模式：

由三部分组成

A:  抽象策略角色：策略类，通常由一个接口或者抽象类实现
B:  具体策略角色：包装了相关的算法和行为
C:  环境角色：持有一个策略类的引用，最终给客户端调用的。

一个抽象策略角色：

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 抽象策略角色  
  4.  */  
  5. public abstract class AbstractStrategy {   
  6.   
  7.     public abstract String calculate(float a,float b);   
  8. }   

几个具体策略角色：

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 具体策略角色  
  4.  */  
  5. public class SubStrategy extends AbstractStrategy{   
  6.   
  7.     public  String calculate(float a,float b){   
  8.         float result = a-b;   
  9.         return "相减结果为:" + result;   
  10.     }   
  11. }  

 

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 具体策略角色  
  4.  */  
  5. public class AddStrategy extends AbstractStrategy{   
  6.   
  7.     public  String calculate(float a,float b){   
  8.         float result = a+b;   
  9.         return "相加结果为:" + result;   
  10.     }   
  11. }   

 

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 具体策略角色  
  4.  */  
  5. public class MultStrategy extends AbstractStrategy{   
  6.   
  7.     public  String calculate(float a,float b){   
  8.         float result = a*b;   
  9.         return "相乘结果为:" + result;   
  10.     }   
  11. }  

 

 

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 具体策略角色  
  4.  */  
  5. public class DivisionStrategy extends AbstractStrategy{   
  6.   
  7.     public  String calculate(float a,float b){   
  8.         float result = a/b;   
  9.         return "相除结果为:" + result;   
  10.     }   
  11. }   

环境角色：

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 环境角色，最终给客户端调用的  
  4.  */  
  5. public class ContextRole {   
  6.   
  7.     /**  
  8.      * 拥有一个策略类的引用  
  9.      */  
  10.     private AbstractStrategy abstactStrategy;   
  11.        
  12.     public ContextRole(AbstractStrategy abstactStrategy){   
  13.         this.abstactStrategy = abstactStrategy;   
  14.     }   
  15.        
  16.     public String calculate(float a,float b) {   
  17.         String result = abstactStrategy.calculate(a, b);   
  18.         return result;   
  19.     }   
  20. }  

客户端调用：

java 代码
  1. package org.strategy;   
  2. /**  
  3.  * 客户端  
  4.  */  
  5. public class Test {   
  6.        
  7.     public static void main(String[] args){   
  8.         float a = 200;   
  9.         float b = 25;   
  10.            
  11.         ContextRole contextRole1 = new ContextRole(new AddStrategy());   
  12.         System.out.println(contextRole1.calculate(a, b));   
  13.            
  14.         ContextRole contextRole2 = new ContextRole(new SubStrategy());   
  15.         System.out.println(contextRole2.calculate(a, b));   
  16.            
  17.         ContextRole contextRole3 = new ContextRole(new MultStrategy());   
  18.         System.out.println(contextRole3.calculate(a, b));   
  19.            
  20.         ContextRole contextRole4 = new ContextRole(new DivisionStrategy());   
  21.         System.out.println(contextRole4.calculate(a, b));   
  22.            
  23.     }   
  24.   
  25. }   

 

输出结果为：

相加结果为:225.0
相减结果为:175.0
相乘结果为:5000.0
相除结果为:8.0

总结：

策略模式优点:

1.可以很方便的动态改变算法或行为

2.避免使用多重条件转移语句

策略模式缺点:


1.客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
2.造成很多的策略类。

posted @ 2008-11-04 09:38 caihaibo 阅读(246) | 评论 (0) | 编辑 收藏
仅列出标题
共8页: 上一页 1 2 3 4 5 6 7 8 下一页 
Powered by: 博客园 模板提供：沪江博客 Copyright ©2024 caihaibo