step into就是单步执行，遇到子函数就进入并且继续单步执行；
step over是在单步执行时，在函数内遇到子函数时不会进入子函数内单步执行，而是将子函数整个执行完再停止，也就是把子函数整个作为一步。有一点,经过我们简单的调试,在不存在子函数的情况下是和step into效果一样的。
step out就是但单步执行到子函数内时，用step out就可以执行完子函数余下部分，并返回到上一层函
数。
step into：进入子函数
step over：越过子函数，但子函数会执行
step out：跳出子函数
posted @
2008-08-13 18:36 竹子 阅读(10948) |
评论 (0) |
编辑 收藏
如何计算某一天是星期几?
—— 蔡勒（Zeller）公式
历史上的某一天是星期几？未来的某一天是星期几？关于这个问题，有很多计算公式（两个通用计算公式和一些分段计算公式），其中最著名的是蔡勒（Zeller）公式。即w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1
公式中的符号含义如下，w：星期；c：世纪-1；y：年（两位数）；m：月（m大于等于3，小于等于14，即在蔡勒公式中，某年的1、2月要看作上一年的13、14月来计算，比如2003年1月1日要看作2002年的13月1日来计算）；d：日；[ ]代表取整，即只要整数部分。(C是世纪数减一，y是年份后两位，M是月份，d是日数。1月和2月要按上一年的13月和 14月来算，这时C和y均按上一年取值。)
算出来的W除以7，余数是几就是星期几。如果余数是0，则为星期日。
以2049年10月1日（100周年国庆）为例，用蔡勒（Zeller）公式进行计算，过程如下：
蔡勒（Zeller）公式：w=y+[y/4]+[c/4]-2c+[26(m+1)/10]+d-1
=49+[49/4]+[20/4]-2×20+[26× (10+1)/10]+1-1
=49+[12.25]+5-40+[28.6]
=49+12+5-40+28
=54 (除以7余5)
即2049年10月1日（100周年国庆）是星期5。
你的生日（出生时、今年、明年）是星期几？不妨试一试。
不过，以上公式只适合于1582年10月15日之后的情形（当时的罗马教皇将恺撒大帝制订的儒略历修改成格里历，即今天使用的公历）。
过程的推导:(对推理不感兴趣的可略过不看)
星期制度是一种有古老传统的制度。据说因为《圣经·创世纪》中规定上帝用了六
天时间创世纪，第七天休息，所以人们也就以七天为一个周期来安排自己的工作和生
活，而星期日是休息日。从实际的角度来讲，以七天为一个周期，长短也比较合适。所
以尽管中国的传统工作周期是十天（比如王勃《滕王阁序》中说的“十旬休暇”，即是
指官员的工作每十日为一个周期，第十日休假），但后来也采取了西方的星期制度。
在日常生活中，我们常常遇到要知道某一天是星期几的问题。有时候，我们还想知
道历史上某一天是星期几。通常，解决这个方法的有效办法是看日历，但是我们总不会
随时随身带着日历，更不可能随时随身带着几千年的万年历。假如是想在计算机编程中
计算某一天是星期几，预先把一本万年历存进去就更不现实了。这时候是不是有办法通
过什么公式，从年月日推出这一天是星期几呢？
答案是肯定的。其实我们也常常在这样做。我们先举一个简单的例子。比如，知道
了2004年5月1日是星期六，那么2004年5月31日“世界无烟日”是星期几就不难推算出
来。我们可以掰着指头从1日数到31日，同时数星期，最后可以数出5月31日是星期一。
其实运用数学计算，可以不用掰指头。我们知道星期是七天一轮回的，所以5月1日是星
期六，七天之后的5月8日也是星期六。在日期上，8-1=7，正是7的倍数。同样，5月15
日、5月22日和5月29日也是星期六，它们的日期和5月1日的差值分别是14、21和28，也
都是7的倍数。那么5月31日呢？31-1=30，虽然不是7的倍数，但是31除以7，余数为2，
这就是说，5月31日的星期，是在5月1日的星期之后两天。星期六之后两天正是星期一。
这个简单的计算告诉我们计算星期的一个基本思路：首先，先要知道在想算的日子
之前的一个确定的日子是星期几，拿这一天做为推算的标准，也就是相当于一个计算的
“原点”。其次，知道想算的日子和这个确定的日子之间相差多少天，用7除这个日期
的差值，余数就表示想算的日子的星期在确定的日子的星期之后多少天。如果余数是
0，就表示这两天的星期相同。显然，如果把这个作为“原点”的日子选为星期日，那
么余数正好就等于星期几，这样计算就更方便了。
但是直接计算两天之间的天数，还是不免繁琐。比如1982年7月29日和2004年5月
1日之间相隔7947天，就不是一下子能算出来的。它包括三段时间：一，1982年7月29
日以后这一年的剩余天数；二，1983-2003这二十一个整年的全部天数；三，从2004年
元旦到5月1日经过的天数。第二段比较好算，它等于21*365+5=7670天，之所以要加
5，是因为这段时间内有5个闰年。第一段和第三段就比较麻烦了，比如第三段，需要把
5月之前的四个月的天数累加起来，再加上日期值，即31+29+31+30+1=122天。同理，第
一段需要把7月之后的五个月的天数累加起来，再加上7月剩下的天数，一共是155天。
所以总共的相隔天数是122+7670+155=7947天。
仔细想想，如果把“原点”日子的日期选为12月31日，那么第一段时间也就是一个
整年，这样一来，第一段时间和第二段时间就可以合并计算，整年的总数正好相当于两
个日子的年份差值减一。如果进一步把“原点”日子选为公元前1年12月31日（或者天文
学家所使用的公元0年12月31日），这个整年的总数就正好是想算的日子的年份减一。这
样简化之后，就只须计算两段时间：一，这么多整年的总天数；二，想算的日子是这一
年的第几天。巧的是，按照公历的年月设置，这样反推回去，公元前1年12月31日正好是
星期日，也就是说，这样算出来的总天数除以7的余数正好是星期几。那么现在的问题就
只有一个：这么多整年里面有多少闰年。这就需要了解公历的置闰规则了。
我们知道，公历的平年是365天，闰年是366天。置闰的方法是能被4整除的年份在
2月加一天，但能被100整除的不闰，能被400整除的又闰。因此，像1600、2000、2400
年都是闰年，而1700、1800、1900、2100年都是平年。公元前1年，按公历也是闰年。
因此，对于从公元前1年（或公元0年）12月31日到某一日子的年份Y之间的所有整年
中的闰年数，就等于
[(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400]，
[...]表示只取整数部分。第一项表示需要加上被4整除的年份数，第二项表示需要去掉
被100整除的年份数，第三项表示需要再加上被400整除的年份数。之所以Y要减一，这
样，我们就得到了第一个计算某一天是星期几的公式：
W = (Y-1)*365 + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + D． (1)
其中D是这个日子在这一年中的累积天数。算出来的W就是公元前1年（或公元0年）12月
31日到这一天之间的间隔日数。把W用7除，余数是几，这一天就是星期几。比如我们来
算2004年5月1日：
W = (2004-1)*365 + [(2004-1)/4] - [(2004-1)/100] + [(2004-1)/400] +
(31+29+31+30+1)
= 731702，
731702 / 7 = 104528……6，余数为六，说明这一天是星期六。这和事实是符合的。
上面的公式(1)虽然很准确，但是计算出来的数字太大了，使用起来很不方便。仔
细想想，其实这个间隔天数W的用数仅仅是为了得到它除以7之后的余数。这启发我们是
不是可以简化这个W值，只要找一个和它余数相同的较小的数来代替，用数论上的术语
来说，就是找一个和它同余的较小的正整数，照样可以计算出准确的星期数。
显然，W这么大的原因是因为公式中的第一项(Y-1)*365太大了。其实，
(Y-1)*365 = (Y-1) * (364+1)
= (Y-1) * (7*52+1)
= 52 * (Y-1) * 7 + (Y-1)，
这个结果的第一项是一个7的倍数，除以7余数为0，因此(Y-1)*365除以7的余数其实就
等于Y-1除以7的余数。这个关系可以表示为：
(Y-1)*365 ≡ Y-1 (mod 7)．
其中，≡是数论中表示同余的符号，mod 7的意思是指在用7作模数（也就是除数）的情
况下≡号两边的数是同余的。因此，完全可以用(Y-1)代替(Y-1)*365，这样我们就得到
了那个著名的、也是最常见到的计算星期几的公式：
W = (Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + D． (2)
这个公式虽然好用多了，但还不是最好用的公式，因为累积天数D的计算也比较麻
烦。是不是可以用月份数和日期直接计算呢？答案也是肯定的。我们不妨来观察一下各
个月的日数，列表如下：
月 份：1月 2月 3月 4月 5月 6月 7月 8月 9月 10月 11月 12月
--------------------------------------------------------------------------
天 数： 31 28(29) 31 30 31 30 31 31 30 31 30 31
如果把这个天数都减去28（=4*7），不影响W除以7的余数值。这样我们就得到另一张
表：
月 份：1月 2月 3月 4月 5月 6月 7月 8月 9月 10月 11月 12月
------------------------------------------------------------------------
剩余天数： 3 0(1) 3 2 3 2 3 3 2 3 2 3
平年累积： 3 3 6 8 11 13 16 19 21 24 26 29
闰年累积： 3 4 7 9 12 14 17 20 22 25 27 30
仔细观察的话，我们会发现除去1月和2月，3月到7月这五个月的剩余天数值是3,2,3,2,
3；8月到12月这五个月的天数值也是3,2,3,2,3，正好是一个重复。相应的累积天数中，
后一月的累积天数和前一月的累积天数之差减去28就是这个重复。正是因为这种规律的
存在，平年和闰年的累积天数可以用数学公式很方便地表达：
╭ d； （当M＝1）
D = { 31 + d； （当M＝2） (3)
╰ [ 13 * (M+1) / 5 ] - 7 + (M-1) * 28 + d + i． （当M≥3）
其中[...]仍表示只取整数部分；M和d分别是想算的日子的月份和日数；平年i=0，闰年
i=1。对于M≥3的表达式需要说明一下：[13*(M+1)/5]-7算出来的就是上面第二个表中的
平年累积值，再加上(M-1)*28就是想算的日子的月份之前的所有月份的总天数。这是一
个很巧妙的办法，利用取整运算来实现3,2,3,2,3的循环。比如，对2004年5月1日，有：
D = [ 13 * (5+1) / 5 ] - 7 + (5-1) * 28 + 1 + 1
= 122，
这正是5月1日在2004年的累积天数。
假如，我们再变通一下，把1月和2月当成是上一年的“13月”和“14月”，不仅仍
然符合这个公式，而且因为这样一来，闰日成了上一“年”（一共有14个月）的最后一
天，成了d的一部分，于是平闰年的影响也去掉了，公式就简化成：
D = [ 13 * (M+1) / 5 ] - 7 + (M-1) * 28 + d． （3≤M≤14） (4)
上面计算星期几的公式，也就可以进一步简化成：
W = (Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + [ 13 * (M+1) / 5 ] - 7
+ (M-1) * 28 + d．
因为其中的-7和(M-1)*28两项都可以被7整除，所以去掉这两项，W除以7的余数不变，
公式变成：
W = (Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] + [ 13 * (M+1) / 5 ] + d．
(5)
当然，要注意1月和2月已经被当成了上一年的13月和14月，因此在计算1月和2月的日子
的星期时，除了M要按13或14算，年份Y也要减一。比如，2004年1月1日是星期四，用这
个公式来算，有：
W = (2003-1) + [(2003-1)/4] - [(2003-1)/100] + [(2003-1)/400] + [13*(13+1)/5]
+ 1
= 2002 + 500 - 20 + 5 + 36 + 1
= 2524；
2524 / 7 = 360……4．这和实际是一致的。
公式(5)已经是从年、月、日来算星期几的公式了，但它还不是最简练的，对于年
份的处理还有改进的方法。我们先来用这个公式算出每个世纪第一年3月1日的星期，列
表如下：
年份： 1(401,801,…,2001) 101(501,901,…,2101)
--------------------------------------------------------------------
星期： 4 2
====================================================================
年份：201(601,1001,…,2201) 301(701,1101,…,2301)
--------------------------------------------------------------------
星期： 0 5
可以看出，每隔四个世纪，这个星期就重复一次。假如我们把301(701,1101,…,2301)
年3月1日的星期数看成是-2（按数论中对余数的定义，-2和5除以7的余数相同，所以可
以做这样的变换），那么这个重复序列正好就是一个4,2,0,-2的等差数列。据此，我们
可以得到下面的计算每个世纪第一年3月1日的星期的公式：
W = (4 - C mod 4) * 2 - 4． (6)
式中，C是该世纪的世纪数减一，mod表示取模运算，即求余数。比如，对于2001年3月
1日，C=20，则：
W = (4 - 20 mod 4) * 2 - 4
= 8 - 4
= 4．
把公式(6)代入公式(5)，经过变换，可得：
(Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400] ≡ (4 - C mod 4) * 2 - 1
(mod 7)． (7)
因此，公式(5)中的(Y-1) + [(Y-1)/4] - [(Y-1)/100] + [(Y-1)/400]这四项，在计算
每个世纪第一年的日期的星期时，可以用(4 - C mod 4) * 2 - 1来代替。这个公式写
出来就是：
W = (4 - C mod 4) * 2 - 1 + [13 * (M+1) / 5] + d． (8)
有了计算每个世纪第一年的日期星期的公式，计算这个世纪其他各年的日期星期的公式
就很容易得到了。因为在一个世纪里，末尾为00的年份是最后一年，因此就用不着再考
虑“一百年不闰，四百年又闰”的规则，只须考虑“四年一闰”的规则。仿照由公式(1)
简化为公式(2)的方法，我们很容易就可以从式(8)得到一个比公式(5)更简单的计算任意
一天是星期几的公式：
W = (4 - C mod 4) * 2 - 1 + (y-1) + [y/4] + [13 * (M+1) / 5] + d． (9)
式中，y是年份的后两位数字。
如果再考虑到取模运算不是四则运算，我们还可以把(4 - C mod 4) * 2进一步改写
成只含四则运算的表达式。因为世纪数减一C除以4的商数q和余数r之间有如下关系：
4q + r = C，
其中r即是 C mod 4，因此，有：
r = C - 4q
= C - 4 * [C/4]． (10)
则
(4 - C mod 4) * 2 ＝ (4 - C + 4 * [C/4]) * 2
＝ 8 - 2C + 8 * [C/4]
≡ [C/4] - 2C + 1 (mod 7)． (11)
把式(11)代入(9)，得到：
W = [C/4] - 2C + y + [y/4] + [13 * (M+1) / 5] + d - 1． (12)
这个公式由世纪数减一、年份末两位、月份和日数即可算出W，再除以7，得到的余数是
几就表示这一天是星期几，唯一需要变通的是要把1月和2月当成上一年的13月和14月，
C和y都按上一年的年份取值。因此，人们普遍认为这是计算任意一天是星期几的最好的
公式。这个公式最早是由德国数学家克里斯蒂安·蔡勒（Christian Zeller, 1822-
1899）在1886年推导出的，因此通称为蔡勒公式（Zeller’s Formula）。为方便口算，
式中的[13 * (M+1) / 5]也往往写成[26 * (M+1) / 10]。
现在仍然让我们来算2004年5月1日的星期，显然C=20，y=4，M=5，d=1，代入蔡勒
公式，有：
W = [20/4] - 40 + 4 + 1 + [13 * (5+1) / 5] + 1 - 1
= -15．
注意负数不能按习惯的余数的概念求余数，只能按数论中的余数的定义求余。为了方便
计算，我们可以给它加上一个7的整数倍，使它变为一个正数，比如加上70，得到55。
再除以7，余6，说明这一天是星期六。这和实际是一致的，也和公式(2)计算所得的结
果一致。
最后需要说明的是，上面的公式都是基于公历（格里高利历）的置闰规则来考虑
的。对于儒略历，蔡勒也推出了相应的公式是：
W = 5 - C + y + [y/4] + [13 * (M+1) / 5] + d - 1． (13)
这样，我们终于一劳永逸地解决了不查日历计算任何一天是星期几的问题。
posted @
2008-08-13 13:46 竹子 阅读(505) |
评论 (0) |
编辑 收藏import java.security.MessageDigest;
/**
* MD5加密类
* @author zhang
*/
public class MD5Encoding
{
/**
*
*
*/
private MD5Encoding()
{
}
/**
* 加密算法MD5
*
* @param text 明文
* @return String 密文
*/
public final static String encoding(String text)
{
char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
String encodingStr = null;
try
{
byte[] strTemp = text.getBytes();
MessageDigest mdTemp = MessageDigest.getInstance("MD5");
mdTemp.update(strTemp);
byte[] md = mdTemp.digest();
int j = md.length;
char str[] = new char[j * 2];
int k = 0;
for (int i = 0; i < j; i++)
{
byte byte0 = md[i];
str[k++] = hexDigits[byte0 >>> 4 & 0xf];
str[k++] = hexDigits[byte0 & 0xf];
}
encodingStr = new String(str);
}
catch (Exception e)
{
}
return encodingStr;
}
public static void main(String[] areg)
{
MD5Encoding md5 = new MD5Encoding();
md5.encoding("admin");
}
}
posted @
2008-08-12 22:55 竹子 阅读(173) |
评论 (0) |
编辑 收藏1, Tomcat内存参数配置
如果是Win与Linux系统启动Tomcat服务器,需要在tomcat/bin/catalina.sh与/tomcat/bin/catalina.bat两个文件:在两个文件里面加如:
SET CATALINA_OPTS= -Xms64m -Xmx128m
2, Tomcat连接数配置
配置Tomcat连接数.需要在Server.xml文件里面加如:
maxThreads="150" 表示最多同时处理150个连接
minSpareThreads="25" 表示即使没有人使用也开这么多空线程等待
maxSpareThreads="75" 表示如果最多可以空75个线程，例如某时刻有80人访问，之后没有人访问了，则tomcat不会保留80个空线程，而是关闭5个空的。
acceptCount="100" 当同时连接的人数达到maxThreads时，还可以接收排队的连接，超过这个连接的则直接返回拒绝连接。
connectionTimeout="20000" maxThreads="150"
minSpareThreads="25"
maxSpareThreads="75"
enableLookups="false"
acceptCount="100" debug="0"
disableUploadTimeout="true"
redirectPort="8443" URIEncoding="UTF-8"/>
URIEncoding="UTF-8" 是设定JSP编码格式.
posted @
2008-08-12 22:46 竹子 阅读(1319) |
评论 (0) |
编辑 收藏
许多人都向地震中的汶川伸出援手，其中也有我们的邻邦。“动用国家全部的运输机”、“搬光国家战略储备的帐篷”这种倾囊相助的国家，就是我们坚定的盟友-巴基斯坦。
巴基斯坦在汶川中的感动还不仅仅是这些。当巴基斯坦的首批医疗队赶赴灾区的时候，我方的接待人员想给医疗队员做出妥善的生活安排的时候，他们的领队回道：不用操心医疗队的吃饭、接待问题，他们是去救人的，有菜叶吃就行。
奥运会在北京召开，届时世界各国的领导和世界各国的运动员都会到场．这是中国人像外展示自己的时候！我们要让世界知道中国是懂得感恩的民族．让巴基斯坦的民众知道中国的民众也是把他们看做是自己的兄弟！我们要用这种方式像他们表示最诚挚的谢意！让他们感觉到不管他们会遇到什么样的困难，中国人永远会和他们站在一起！虽然我们和他们的长相和人种不同，但我们的心在一起！也让美国人知道什么才是和谐世界，和谐中国．让中国和巴基斯坦的友谊成为世界的典范！也让巴铁的兄弟们知道在中国遇到灾难时他们能搬空自己的战略储备来支援中国，中国也能在他们遇到灾难时付出的更多！
古人云：＂滴水之恩，当涌泉相报＂奥运会就是中国报答巴基斯坦的最佳时机。患难见真情。巴基斯坦的朋友在我们需要帮助的时候，给与我们最及时的帮助，这些援助对他们而言就是倾其所有。
同时我们应像社会招集一些口号之类的东西在奥运会开幕式时展示出来．让那些亡我中国之心不死的人，感受到中国人团结的力量．也让那些和中国人一起的人们感受一下中国人的团结让他们更坚定的和中国站在一起．
巴基斯坦，中国欢迎你！北京欢迎你！虽去不了北京在电视屏幕前的我，也会起立，鼓掌！
希望广大网友转帖！
posted @
2008-07-25 13:52 竹子 阅读(96) |
评论 (0) |
编辑 收藏
- “一切从名字开始”。无论是开发大的项目，写学习代码或打patch，都要注意给项目、变量、函数起一个好名字。
- “不要COPY第二次”，当一个常量用到第二次的时候，就立刻给它做预定义。比如起一个常量名或用一个变量赋值。
- “不要以误小而为之”。“这点小错无所谓”的态度对自己百害而无一利。
- “不以善小而不为”。你有下面的情况吗？“修个小BUG没意思”，“随便起个名字无所谓”，“懒得提炼函数，直接复制代码”。如果有必须改。
- “工欲善其事，必先利其器”，一定要把自己的工作环境打理好。
- “精益求精”，代码不简陋，不冗余。html页面要对齐，配置文件不混乱，执行效率不得过且过。
- “切喜新厌旧”。多钻研开源代码，多研究学习别人的代码。
- “重构 、 测试 、调试”。这三件法宝，是你提髙开发能力的利器。
无论JAVA还是.net、erlang还是C都有前景，关键是要做深做透，掌握正确获取知识的方法、处理项目的能力是相通的，具体的说就是不要把目光盯在做硬件还是做软件上，用java还是C，要勤动手打好基础，提高自己对系统总体设计的能力，从系统的眼光看问题。为什么都是做JAVA的有的毕业拿3000，有的5000、8000，除了运气和关系外，重要的是你对事物的认识深度和高度。我一直都记住这句话：有前途的人做什么都有前途，没前途的人做什么都没前途。
posted @
2008-07-22 18:05 竹子 阅读(114) |
评论 (0) |
编辑 收藏
做个记录，以备使用.
0x1 鼠标左键
0x2 鼠标右键
0x3 CANCEL 键
0x4 鼠标中键
0x8 BACKSPACE 键
0x9 TAB 键
0xC CLEAR 键
0xD ENTER 键
0x10 SHIFT 键
0x11 CTRL 键
0x12 MENU 键
0x13 PAUSE 键
0x14 CAPS LOCK 键
0x1B ESC 键
0x20 SPACEBAR 键
0x21 PAGE UP 键
0x22 PAGE DOWN 键
0x23 END 键
0x24 HOME 键
0x25 LEFT ARROW 键
0x26 UP ARROW 键
0x27 RIGHT ARROW 键
0x28 DOWN ARROW 键
0x29 SELECT 键
0x2A PRINT SCREEN 键
0x2B EXECUTE 键
0x2C SNAPSHOT 键
0x2D INSERT 键
0x2E DELETE 键
0x2F HELP 键
0x90 NUM LOCK 键
A 至 Z 键与 A – Z 字母的 ASCII 码相同：
值 描述
65 A 键
66 B 键
67 C 键
68 D 键
69 E 键
70 F 键
71 G 键
72 H 键
73 I 键
74 J 键
75 K 键
76 L 键
77 M 键
78 N 键
79 O 键
80 P 键
81 Q 键
82 R 键
83 S 键
84 T 键
85 U 键
86 V 键
87 W 键
88 X 键
89 Y 键
90 Z 键
0 至 9 键与数字 0 – 9 的 ASCII 码相同：
值 描述
48 0 键
49 1 键
50 2 键
51 3 键
52 4 键
53 5 键
54 6 键
55 7 键
56 8 键
57 9 键
下列常数代表数字键盘上的键：
值 描述
0x60 0 键
0x61 1 键
0x62 2 键
0x63 3 键
0x64 4 键
0x65 5 键
0x66 6 键
0x67 7 键
0x68 8 键
0x69 9 键
0x6A MULTIPLICATION SIGN (*) 键
0x6B PLUS SIGN (+) 键
0x6C ENTER 键
0x6D MINUS SIGN (–) 键
0x6E DECIMAL POINT (.) 键
0x6F DIVISION SIGN (/) 键
下列常数代表功能键：
值 描述
0x70 F1 键
0x71 F2 键
0x72 F3 键
0x73 F4 键
0x74 F5 键
0x75 F6 键
0x76 F7 键
0x77 F8 键
0x78 F9 键
0x79 F10 键
0x7A F11 键
0x7B F12 键
0x7C F13 键
0x7D F14 键
0x7E F15 键
0x7F F16 键
posted @
2008-07-22 00:40 竹子 阅读(1504) |
评论 (0) |
编辑 收藏DAO模式在现在的开发中应用非常的广泛，它可以帮助我们实现持久化逻辑和业务逻辑的分离，同时实现对多种持久化实现的支持。当然现在你可以通过 hibernate来实现对多种持久化的支持，由于新的技术新的方式的出现，DAO也相应的做出了一些调整，比如泛型DAO，在SpringSide中有很还得例子可以参考这方面的实现。
这里聊下传统意义上的DAO模式（在阎宏的JAVA与模式书中有详细的介绍），需要注意的几个方面：
1、不要DAO中出现业务逻辑
DAO只需关注持久化部分，可以通过Facade来控制事务的边界，从而提高DAO的复用性，在不同的事务策略中应用
2、不要过多的在 DAO层捕捉异常
在很多的开发中，会喜欢使用Checked Exception，抛到servcie层、再到action层，其实在DAO中发生的异常常常是不可恢复的（比如DB的连接问题），所以应该选择 RuntimeException，我们所需要的只是log的记录并通知管理员，并通过全局的异常处理画面告之。
暂时这些，由于ORM的懒加载技术，在DAO中可能会有些调整，为了增加DAO的复用性，这方面的技术也应该剥离出来，不过暂时还没这么处理过，所以无法总结，希望有这方面经验的人提供一些
posted @
2008-07-20 09:41 竹子 阅读(114) |
评论 (0) |
编辑 收藏本节是单元测试的第三篇。我以为这是重中之重的一章。单元测试的关键在于代码要可测。可测才能测。要做好单元测试，就必须在代码的可测性方面努力，在设计、重构方面用心。本篇主要分享我在如何写出可测性代码方面的理解，与大家共勉！
单元测试(提升篇)
------编写可测试性代码
一、可测试性设计
1.
接口依赖
这是最重要的一点，因为这可以使得我们很容易的针对一个接口实现Mock对象，模拟/替换实际对象会变的很容易。达到使一个被测对象处于一个孤立环境的测试要求。
这里，ClassA依赖于ClassB的具体实现，TestCase根本无法独立于ClassB对ClassA进行独立测试。
因此，我们将ClassA改为依赖于接口B_Inf。这样，可以很容易的实现一个Mock_B替换ClassB去ClassA进行孤立测试。
2.
依赖注入
一个方法对外部类的依赖，应该是可注入的。即可以通过构造方法、get/set方法的方式在外部将依赖关系注入。事实上，这也为我们在测试用例中替换待测类的依赖对象提供了机会。不应该出现在方法内部新建对象使用的情况。
3.
降低耦合度
待测类应与最少的类耦合，即最小交互原则。特别是要减少与那些离了具体环境就不能运行的类的耦合。可以通过门面模式等对外部调用进行隔离。
5．AOP
面向切面编程。给我们提供的启示是，将真正需要测的逻辑分离出来。摆脱那些无意义且简单重复的代码对测试的干扰。
6. 明确的契约
方法一定要有明确清晰的输入/输出。建议在方法的注释描述中，分三段“描述”“前置条件”“后置条件”。
二、可测试性重构
1.
可恶的静态方法
在我们的代码中有大量的调用静态方法的地方。用起来我们很爽，但这对测试来说却是灾难。因为我们除了通过改变代码创建stub来改变这些方法的行为外，我们没有任何途径。更要命的是，写这些stub的代价非常的巨大，常常令人望而却步。
解决方案：
将方法内部的这些调用提取成protected方法。在外部创建待测类的子类，重写该protected方法。
最佳实践：
这些静态方法由单态类提供，单态类由工厂方法获取，具体类使用这些单态类的接口。
我们在方法中通过接口使用对外部模块的调用。一方面，隔离了外部模块改变对我们产生的冲击，另一方面，也使我们使用Mock替换实际的外部组件，创建孤立测试环境成为可能。
2.
待测类方法中，new出另一个对象并使用其方法
两种方案：1）将new 出对象的过程封装成protected方法。同重构1。2)将该对象提取成类属性，即由使用关系变成关联关系。
3.
分离不可测/不必测代码
在不影响的情况下，将不可测部分分离到一些不需要测的简单方法中去。或者将可测的部分提取到一个私有方法中去。然后针对这个私有方法进行测试。
通常这种做法使用范围有限，但有些时候还是值的一试。
4.
单一职责
职责太多，肯定不好测。针对于这一点“不好测的方法必然不好用”。当方法过大，承担责任过多时，拆分是应该的。
5.
为类提供一个空构造方法。
我们的各个测试方法都依赖于对象处于一个特定的状态，满足一定的前置条件。而要将对象置为我们希望的状态，我们必须首先拥有一个对象。然而，很多时候，在一个隔离的单元测试环境下，构造函数由于各种原因不能正常初始化。
此时，可以为类提供一个的空的构造方法。在外部构造一个“裸”对象，而后根据前置条件将各个属性设置成需要的Mock对象。
-----------------------------------------------------------------------------------------------------------------------------------------------------------
事实上，要想写出具有可测性的代码，最佳的办法就是测试驱动开发。先写测试代码把功能体现出来，再写功能代码让测试通过。这样写出的代码显而易见会更具有测试性。
原地址:http://www.blogjava.net/wukaichun600/archive/2008/07/18/214125.html
posted @
2008-07-20 09:32 竹子 阅读(137) |
评论 (0) |
编辑 收藏本节是单元测试系列的第二篇。重点讲解如何使用Mock/Stub和依赖注入技术进行单元测试。关于工具JUnit等则不做累赘介绍。 希望通过本章能够帮助大家开始单元测试的有益实践，与大家共勉！
单元测试（技能篇）
一、Stub技术
这是最为古老的一种测试技能。通过类层次上的替换实现了对待测环境的模拟。
实现的时候有两种途径：
1、重写实际类，在测试时，先于实际类加载，即覆盖。如：我们在unittest/stub文件夹下针对于每一个重写类都有相同的包结构和类名：
在类路径中优先加载：
2、在实际代码中添加判断。比如，如果当前是测试环境if(isUT)执行XX操作，截断真正需要做的事。
publicvoid sendCommand(int cmdCode)
{
if(isUT())
{
//...
}
else
{
//...
}
}
Stub技术的问题就在于我们在重写这些类的时候，不仅仅要关注接口，还要关注其内部逻辑。如果你只是简单的返回一个固定的响应，会很简单。但是对于每一次运行需要根据不同的输入返回不同的输出时方法内部的处理就会复杂的多。
由于实现的难度，所以，使用时就要注意：有高价值、重用度高、数量少。这就是说，重写一个类，就可以有一大批类可以用。
二、Mock技术
Mock是目前单元测试中最常用的。用来在对象层次上实现细类度替换十分方便。
当我们在测试中，需要其它类/接口的一个方法时，我们可以通过继承/实现其一个子类对象来替换实际对象。在Mock子类中将需要的方法直接返回需要的结果就行了。
privateclass Mock_QueryCtrl extends QueryCtrl
{
public List queryNEList()
{
List neList = new ArrayList();
//直接填充并返回你需要的数据...
return neList;
}
}
同样，我们也可以通过测试待测类的子类来测试待测类。这对于被测方法使用了自身类的方法时很适用。
三、依赖注入
单元测试的一个关键就是替换。类层次上的替换，通过在类路径中提前加载就可以实现。而在对象层次上，java的反射机制提供了很好的帮助。
1）.获取/注入私有属性
2）.执行私有方法
附：注入私有属性的实现：
publicvoid setFieldObject(Object instance, String fieldName, Object
value)
throws IllegalArgumentException, IllegalAccessException,
NoSuchFieldException {
Field field = null;
Class c = instance.getClass();
do {
try
{
field = c.getDeclaredField(fieldName);
} catch (SecurityException e)
{
e.printStackTrace();
} catch (NoSuchFieldException e)
{
c = c.getSuperclass();
}
}
while (c.getName() != "java.lang.Object" && field
== null);
if (field != null)
{
field.setAccessible(true);
field.set(instance, value);
}
else
{
thrownew NoSuchFieldException(fieldName);
}
}
注：这是一个简单实现，实际中需要优化。
四、实例：
下例演示了如何测试类NEListTable的ShowNETable()方法。其中注意的是，方法中调用了类QueryCtrl的queryNEList()方法。
待测类：
publicclass NEListTable
{
QueryCtrl ctrl = null;
publicvoid ShowNETable()
{
List neList =
ctrl.queryNEList();
for(int i =
0;i<neList.size();i++)
{
//将neList转换为表格行
}
//显示表格...
}
}
publicclass QueryCtrl {
public List queryNEList()
{
returnnull;
}
}
测试类：
public class TestNEListTable extends TestCase
{
private
NEListTable table = null;
private
TestHelper helper = null;
public
void testShowNETable()
{
Mock_QueryCtrl ctrl = new
Mock_QueryCtrl();
helper.setObjectField(table,"ctrl",ctrl);//将Mock对象注入table
table.ShowNETable();
assertTrue(table.getRowCount()>0);
}
private
class Mock_QueryCtrl extends
QueryCtrl
{
public
List queryNEList()
{
List neList = new
ArrayList();
//返回你需要的数据...
return neList;
}
}
}
原地址:http://www.blogjava.net/wukaichun600/archive/2008/07/10/213790.html
posted @
2008-07-20 09:31 竹子 阅读(150) |
评论 (0) |
编辑 收藏