BlogJava-张江宁的个人博客-文章分类-Java技术备藏http://www.blogjava.net/lijiezjn/category/19235.html学习无回头zh-cnFri, 02 Mar 2007 06:32:16 GMTFri, 02 Mar 2007 06:32:16 GMT60(转载)个人建站流程全接触http://www.blogjava.net/lijiezjn/articles/94157.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:51:00 GMThttp://www.blogjava.net/lijiezjn/articles/94157.html
网站早已不再神秘，再也不是什么高技术活。普通用户也可以轻松的建立出相对专业的网站。下面向大家简单介绍一下个人建站的一些流程和注意事项。
    一、域名
    要想让人家访问自己的网站，域名是必不可少的。域名要尽可能的短、尽可能的方便记忆，当然现在好记的、有特征的域名已经不多了，这需要你自己进行考虑，只要觉得有一定的规律或便于用户记忆即可。

    二、空间
    要建网站，其次必须要有一个空间，即存放网站的地方。对于个人用户，建议购买虚拟主机。在购买虚拟主机时要看其服务、速度、响应时间等。一般选择有一定名气的服务商即可。
    注：域名、空间目前国内比较好的服务商像中国万网、中资源等都是非常好的选择，不过它们的价格比一般的服务商要贵一些。

    三、网站程序
    网站程序当然是选择现成的，因为个人没有必要去从头开始编制一个网站程序，也没有那个实力。现在网上有现成的网站管理系统，像网奇Dvnews建站系统就是一款非常适合个人站长建站的工具。当然，这类系统还有很多，可以在自己综合试用的基本上进行选择。
     在选择网站程序时，还必须考虑到其通用性和二次开发。对于通用性不好、不利于二期开发的，虽然功能强大但不建议选用，因为网站有了一定规模后需要进行个性化功能设计时会很麻烦。另外程序尽量选择asp（asp.net），PHP、JSP等在国内不是特别流行；在asp和asp.net之间也尽量选用 asp.net，毕竟其基于.net架构是发展的潮流。

    四、网站设计
    选择好了网站程序后，则需要根据自己的需要进行网站设计。一般来说，如果有专业的美工和程序员进行修改自然最好。不过个人站长可能不一定具备这种条件。这时不防根据自己选用的程序来进行定制或选择增值服务。例如动易就提供网站定制服务，不过动易对网站空间的要求比较多，需要进行组件注册，有很多服务商并不提供该项服务；其次网奇Dvnews 建站系统等在提供源码的同时，还提供增值服务，例如满足用户的需求设计个性模板，定制模板同时赠送LOGO、Banner等设计。当然如果不希望花钱的话，也可以到到网奇（http://www.wangqi.com）下载免费模板，非常适合个人网站站长初次投资较少的情况。

    五、更新
    更新是一件比较麻烦的事，在具体的实施过程中可以注意以下几点：
    以质取胜：即靠内容的质量取胜；
    以新取胜：即以一定的原创内容取胜；
    以时取胜：即尽量追究时效，对内容尽早的发布；
    综合言之，如果能做到人无我有，人有我新那么就可以了。

    六、推广
    有了好的内容是不必过于担心网站访问量的。毕竟口碑的力量还是很大的。当然这并不是说我们就不需要推广，像登录搜索引擎、相互宣传、相互链接等都是行之有效的方法，各位站长可以在摸索的过程中不断前进。
    这里只是粗略的介绍个人网站的流程，希望对大家有所帮助。
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:51 发表评论
]]>(转载)Web开发常用js功能性小技巧http://www.blogjava.net/lijiezjn/articles/94156.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:46:00 GMThttp://www.blogjava.net/lijiezjn/articles/94156.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE> New Document </TITLE>

</HEAD>

<BODY>
<FORM METHOD=POST ACTION="">
<input onpaste="return false;" type="text" name="textfield" style="width:400px; ime-mode:disabled" value=" English only">
</FORM>
</BODY>
</HTML>

-----------------------------------------------------------------------------
只能输入数字

<script LANGUAGE="javascript">
<!--
function check()
{
if (document.form.tell.value==""){
alert("請輸入電話號碼！");
document.form.tell.focus();
return false;
}
else{
var Letters = "0123456789()+-";
for (i=0; i< document.form.tell.value.length; i++){
var CheckChar = document.form.tell.value.charAt(i);
if (Letters.indexOf(CheckChar) == -1){
alert("電話號碼格式不正確！");
document.form.tell.focus();
return false;
}
}
}
}
//-->
</script>

在<body>...</body>之间的表单．
<form method="POST" name=form action="" onSubmit="return check();">
<p align="center">
请输入电话号码：<input type="text" name="tell" size="20">
<input type="submit" value="提交" name="B1"></p>
</form>

--------------------------------------------------------------------------------
e mail 合法性检查
function check()
{
if(document.register.email.value.length!=0)
{
if (document.register.email.value.charAt(0)=="." ||
document.register.email.value.charAt(0)=="@"||
document.register.email.value.indexOf('@', 0) == -1 ||
document.register.email.value.indexOf('.', 0) == -1 ||
document.register.email.value.lastIndexOf("@") 　　
　 ==document.register.email.value.length-1 ||
document.register.email.value.lastIndexOf(".")
==document.register.email.value.length-1)
{
alert("Email的格式不正確！");
document.register.email.focus();
return false;
}
}
else
{
alert("Email的不能为空！");
document.register.email.focus();
return false;
}
return false;
}
-----------------------------------------------------------
页面右键屏蔽
<body oncontextmenu="return false">

----------------------------------------------------------------
自动清除输入框中的空格

再<head>...</head>间加入
<SCRIPT LANGUAGE="JavaScript">
<!--//
function ignoreSpaces(string) {
var temp = "";
string = '' + string;
splitstring = string.split(" "); //双引号之间是个空格；
for(i = 0; i < splitstring.length; i++)
temp += splitstring[i];
return temp;
}
//-->
</script>

如下代码加入<body>区

<form method="post" action="...">
<input type=text size=25 onBlur="this.value=ignoreSpaces(this.value);" name="text">
<input type=submit value="Ok" name="button">
</form>

-----------------------------------------------------------------------
右键菜单的淡入淡出效果
<HTML><HEAD><TITLE>右键菜单的淡入淡出效果</TITLE>
<META content="text/html; charset=gb2312" http-equiv=Content-Type>
<SCRIPT language=JavaScript>
<!-- // RightClickMenu
var intDelay=10; //设置菜单显示速度，越大越慢
var intInterval=5; //每次更改的透明度
function showmenuie5(){
var rightedge=document.body.clientWidth-event.clientX
var bottomedge=document.body.clientHeight-event.clientY
if (rightedge<ie5menu.offsetWidth)
ie5menu.style.left=document.body.scrollLeft+event.clientX-ie5menu.offsetWidth
else
ie5menu.style.left=document.body.scrollLeft+event.clientX
if (bottomedge<ie5menu.offsetHeight)
ie5menu.style.top=document.body.scrollTop+event.clientY-ie5menu.offsetHeight
else
ie5menu.style.top=document.body.scrollTop+event.clientY
ie5menu.style.visibility="visible"
//ie5menu.style.visibility=""
ie5menu.filters.alpha.opacity=0
GradientShow()
return false
}
function hidemenuie5(){
//ie5menu.style.visibility="hidden"
GradientClose()
}
function highlightie5(){
if (event.srcElement.className=="menuitems"){
event.srcElement.style.backgroundColor="highlight"
event.srcElement.style.color="white"
}
}
function lowlightie5(){
if (event.srcElement.className=="menuitems"){
event.srcElement.style.backgroundColor=""
event.srcElement.style.color="#000000"
}
}
function jumptoie5(){
if (event.srcElement.className=="menuitems"){
if (event.srcElement.url != ''){
if (event.srcElement.getAttribute("target")!=null)
window.open(event.srcElement.url,event.srcElement.getAttribute("target"))
else
window.location=event.srcElement.url
}
}
}

function GradientShow() //实现淡入的函数
{
ie5menu.filters.alpha.opacity+=intInterval
if (ie5menu.filters.alpha.opacity<100) setTimeout("GradientShow()",intDelay)
}

function GradientClose() //实现淡出的函数
{
ie5menu.filters.alpha.opacity-=intInterval
if (ie5menu.filters.alpha.opacity>0) {
setTimeout("GradientClose()",intDelay)
}
else {
ie5menu.style.visibility="hidden"
}
}

function ChangeBG() //改变菜单项的背景颜色，这里的两种颜色值可以改为你需要的
{
oEl=event.srcElement
if (oEl.style.background!="navy") {
oEl.style.background="navy"
}
else {
oEl.style.background="#cccccc"
}
}
// -->
</SCRIPT>

<style type=text/css>
.cMenu {
FILTER: alpha(opacity=0);BACKGROUND-COLOR: #D6D3CE;BORDER-BOTTOM: #666666 2px solid; BORDER-LEFT: #E4E4E4 2px solid; BORDER-RIGHT: #666666 2px solid; BORDER-TOP: #E4E4E4 2px solid; COLOR: #000000; CURSOR: default; FONT-SIZE: 9pt; color:#000000;FONT-WEIGHT: normal; LINE-HEIGHT: 20px; POSITION: absolute; VISIBILITY: hidden; WIDTH: 110px
}
.menuitems {
font-size:9pt;
MARGIN: 2px;
PADDING-BOTTOM: 0px;
PADDING-LEFT: 15px;
PADDING-RIGHT: 3px;
PADDING-TOP: 0px;
}
</style>

<META content="Microsoft FrontPage 4.0" name=GENERATOR>
</HEAD>
<BODY>
<OBJECT classid=CLSID:8856F961-340A-11D0-A96B-00C04FD705A2 height=0 id=WebBrowser width=0>
</OBJECT>
<RIGHTCLICK><!--[if IE]>
<DIV class=cMenu id=ie5menu onclick=jumptoie5() onmouseout=lowlightie5()
onmouseover=highlightie5()>

<DIV class=menuitems url="javascript:click_obj(0)">后退</DIV>
<DIV class=menuitems url="javascript:click_obj(1)">前进</DIV>
<DIV class=menuhr><hr style="width:100%"></DIV>
<DIV class=menuitems url="javascript:click_obj(2)">刷新</DIV>
<DIV class=menuitems url="javascript:click_obj(3)">加入收藏夹</DIV>
<DIV class=menuitems url="javascript:click_obj(4)">查看源文件</DIV>
<DIV class=menuhr><hr style="width:100%"></DIV>
<DIV class=menuitems url="javascript:click_obj(5)">属性</DIV>

</DIV>
<![endif]-->

<SCRIPT language=JavaScript>
<!--
function click_obj(id){
switch(id){
case 0:
history.back()
break
case 1:
history.forward()
break
case 2:
window.location.reload()
break
case 3:
window.external.AddFavorite(location.href, document.title)
break
case 4:
window.location = "view-source:" + window.location.href
break
case 5:
document.all.WebBrowser.ExecWB(10,1)
break
}
}

if (document.all&&window.print){
ie5menu.className="cMenu"
document.oncontextmenu=showmenuie5
document.body.onclick=hidemenuie5
}
//-->
</SCRIPT>
</RIGHTCLICK>
</BODY></HTML>

----------------------------------------------------------------------------
ie用activex实现打印 我没有检测过版本，ie6下正常
<head>...</head>加入：
<SCRIPT LANGUAGE=javascript>
<!--
function setPrint()
{
WB.ExecWB(8,1);
}
function previewPrint()
{
WB.ExecWB(7,1)
}
//-->
</SCRIPT>

在<body>...</body>加入：
<OBJECT classid=CLSID:8856F961-340A-11D0-A96B-00C04FD705A2 height=0 id=WB width=0>
</OBJECT>
<INPUT type="button" value="Set" id=button1 name=button1 onclick="setPrint();">
<INPUT type="button" value="Preview" id=button2 name=button2 onclick="previewPrint();">


----------------------------------------------------------------
超链接提交表单
<script LANGUAGE="JavaScript">
function checkvalue()
{
if(document.welcomeform.nickname.value=="")
{
alert("昵称不能为空！");
return(false);
}
if(document.welcomeform.password.value=="")
{
alert("密码不能为空！");
return(false);
}
document.welcomeform.submit();
return(true);
}
</script>

在<body>...</body>之间加入如下代码：
<form name="welcomeform" method="post" action="welcome.asp">
<a href="#" onclick="javascript:checkvalue();return false:">登录</a>
</form>
----------------------------------------------------------
不允许缓存页面
使用java提供的方法，在jsp或者servlet中都可以
<%
response.setHeader("Pragma","No-cache");
response.setHeader("Cache-Control","no-cache");
response.setDateHeader("Expires", 0);
%>

----------------------------------------
待......................


_________________

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:46 发表评论
]]>(转载)java程序员面试经常会问的问题http://www.blogjava.net/lijiezjn/articles/94155.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:45:00 GMThttp://www.blogjava.net/lijiezjn/articles/94155.html

1. 问：怎样用 Win95 的记事本 (Notepad) 来编辑 Java源程序？

答：记得存档时扩展名要加上".java"，文件类型改成：“所有的文件(*.*)”。

 

2. 问：到底 Java 是如何传递参数的？是by value或by reference？

答：All parameters (values of primitive types, and values that are references to objects) are passed by value [JLS sect 8.4.1]。根据以上 Java规格文件的说法, 所有参数应该都是传值的(by value)。但实际上, 实际经验却告诉我们所有 Java 的对象都是传址的(by reference)。因此我们可以这样解释: 基本类型(如int, float, char等)是by value，而所谓“对象”(Object)则是by value of reference to object。

 

3. 问：String这个类型的class为何定义成final？

答： 主要是为了“效率” 和 “安全性” 的缘故。若 String允许被继承, 由于它的高度被使用率, 可能会降低程序的性能，所以String被定义成final。

 

4. 问：finalizers和C++ 的 destructors有何差异?

答：Java内部具有“内存使用回收” 的机制， 虽然它也提供了类似 (C++ 的) destructors的 finalize()，每个对象都可以使用这个方法 method，但必须冒著破坏原先回收机制的危险。所以建议尽量避免使用finalize()，不妨考虑多使用 null 及 dispose() 来释出资源会好一些。

 

5. 问：继承了一个class叫做 Frotz，编译器却给我“No constuctor Frotz() in the class”这样的错误提示，为什么呢？

答：记住每当您定义了一个 class的constructor，除非您一开始就去call 这个constructor，否则 Java 会自动引入superclass原先不含参数的 constructor， 如果superclass的 constructor都是有参数的，那么问题中的错误提示便出现了。 解决的方法很简单, 找一找 API文件，加上正确的参数就得了。

 

6. 问：怎样让char类型的东西转换成int类型？

答：

char c = 'A'；

int i = c；

//反过来只要作强制类型转换就行了

c = (char) I；

 

7. 问：我的applet原先好好的, 一放到web server就会有问题，为什么？

答：一般来说，从以下方向试试：

确定class文件的格式没错——已经编译过，也没有损坏的情形；

确定所有用到的class文件放到web server上，少一个都不行；

确定所有的文件名和class名称一致，特别检查大小写有无差错；

如果程序中用到package，web server上的目录就要当心了。譬如您在class中宣告了一个叫COM.foo.util的package，那么web server的applet codebase目录底下就非得有 COM/foo/util这个子目录不可。(注意目录名称也有大小写之分)；

web server上的文件档案应该事先设定好。(尤其是search，read和execute权限)

 

8. 问：怎样在 Applet中用某个图形涂满整个背景？

答：在背景建立 Panel 或 Canvas, 然後用图形填满它。

 

9. 问：怎样在 Applet 中建立自己的菜单(MenuBar/Menu)？

答：首先在Applet的init() 方法中建立Frame instance， 然后将Menus， Menubar都加上去即可。 (setMenuBar() 是 Frame下的方法)或者，找到Applet上层的Frame后依法炮制。

Container parent = getParent();

while (! (parent instanceof Frame) )

parent = parent.getParent();

Frame theFrame = (Frame) parent;

注意：第二个方法在Mac或某些browsers上并不可行。

如果您使用的是JDK 1.1，也可以考虑使用popup menu，这样就不必理会Frame的问题了。

 

10. 怎样比较两个类型为String的字符串？

答：在两个对象之间使用 "=="，会将“两个对象是否有同一reference”的结果传回。也就是说, 这等同于“两个对象是否拥有同一地址 (address)”，或者“两个对象物件是否为同一对象”。如果您的意思是判断两个字符串的内容是否相同，那么应该使用以下的方法才对：

if (s1.equals(s2) )

or if (s1.equalsIgnoreCase(s2) )

or if (s1.startsWith(s2) )

or if (s1.endsWith(s2) )

or if (s1.regionMatches(s1_offset, s2, s2_offset, length) )

or if (s1.compareTo(s2) <0)

 

11. 怎样将浮点数(float)相加 ? Float 好像没有办法？

答：我猜想您的程式大概写成这样：

Float One;

Float Two;

Float Hard = One + Two;

请注意 float 和 Float 是不同的，前者是 Java 基本类型之一, 而后者却是class。您应该将源代码改为：

float One;

float Two;

float Hard = One + Two;

或

Float One = new Float(1.0);

Float Two = new Float(2.0);

Float Hard = new Float(One.floatValue() + Two.floatValue());

 

12. 如何将字串String转换成整数int？

答：有两个方法：

1)int i = Integer.parseInt([String]); 或

 

i = Integer.parseInt([String],[int radix]);

2)int i = Integer.valueOf(my_str).intValue();

注: 字串转成Double, Float, Long的方法大同小异。

 

13. 如何将整数 int 转换成字串 String？

答：有三种方法：

1)String s = String.valueOf(i);

2)String s = Integer.toString(i);

3)String s = "" + i;

注：Double, Float, Long 转成字串的方法大同小异。

 

14. 如何从一个文件档案的尾端新增记录？

答：有两种方法：

1)RandomAccessFile fd = new RandomAccessFile(file,"rw");

fd.seek(fd.length());

然后使用 fd 的method写入

2)使用FileOutputStream(String name，boolean append) throws IOException这个 constructor

 

15. 如何设置Java 2(JDK1.2)的环境变量？

答：Java 2安装后，需要设置PATH和JAVA_HOME环境变量。与JDK1.1不同的是：设置好JAVA_HOME环境变量后，JVM将自动搜索系统类库以及用户的当前路径。Java 2环境变量的设置如下例所示：

Solaris平台： setenv JAVA_HOME Java2的安装路径
setenv PATH $JAVA_HOME/bin:${PATH}

Windows平台：set JAVA_HOME=Java2的安装路径
set PATH=$JAVA_HOME\bin;%PATH%

 

16. 哪些Java集成开发工具支持Java 2？

答：目前流行的Java集成开发环境,如Inprise的Jbuilder；Symantec的Visual Cafe,；Sybase的PowerJ都支持Java 2。

 

17. 如果在Netscape或IE浏览器中运行Java applet时出现了错误,如何确定错误范围？

答：当java applet在浏览器中运行时，使用的是浏览器本身的缺省JVM。而不同浏览器对JDK的支持程度也不尽相同。因此，在Netscape或IE浏览器中运行Java applet出现了错误，建议使用JDK提供的工具appletviewer或Sun公司的Hotjava浏览器来测试该applet，以确定错误的产生是与浏览器相关。如果applet在appletviewer或Hotjava中运行一切正常，则错误的产生是由于浏览器不完全兼容JDK而引起的。此时，解决方法可以是使用Hotjava浏览器或者安装 Sun公司的Java Plugin。如果applet在Hotjava浏览器或appletviewer中运行即发生错误，则应当根据错误提示检查applet程序。

 

18. 在Java语言中,如何列出PC机文件系统中的所有驱动器名？

答:在Java 2版本中，java.io包中的File类新增加了方法listRoots()可以实现这一功能。

 

19. 为什么Runtime.exec("ls")没有任何输出？

答：调用Runtime.exec方法将产生一个本地的进程，并返回一个Process子类的实例，该实例可用于控制进程或取得进程的相关信息。由于调用Runtime.exec方法所创建的子进程没有自己的终端或控制台，因此该子进程的标准IO(如stdin，stdou，stderr)都通过 Process.getOutputStream()，Process.getInputStream()， Process.getErrorStream()方法重定向给它的父进程了。用户需要用这些stream来向子进程输入数据或获取子进程的输出。所以正确执行Runtime.exec("ls")的例程如下:

try

{

process = Runtime.getRuntime().exec (command);

InputStreamReader ir=newInputStreamReader(process.getInputStream());

LineNumberReader input = new LineNumberReader (ir);

String line;

while ((line = input.readLine ()) != null)

System.out.println(line);

}

catch (java.io.IOException e){

System.err.println ("IOException " + e.getMessage());

}

 

20. 若通过ObjectOutputStream向一个文件中多次以追加方式写入object，为什么用ObjectInputStream读取这些object时会产生StreamCorruptedException？

答:使用缺省的serializetion的实现时，一个ObjectOutputStream的构造和一个ObjectInputStream的构造必须一一对应。ObjectOutputStream的构造函数会向输出流中写入一个标识头，而ObjectInputStream会首先读入这个标识头。因此，多次以追加方式向一个文件中写入object时，该文件将会包含多个标识头。所以用ObjectInputStream来 deserialize这个ObjectOutputStream时，将产生StreamCorruptedException。

一种解决方法是可以构造一个ObjectOutputStream的子类，并覆盖writeStreamHeader()方法。被覆盖后的 writeStreamHeader()方法应判断是否为首次向文件中写入object？若是，则调用super.writeStreamHeader ()；若否，即以追加方式写入object时，则应调用ObjectOutputStream.reset()方法。

 

21. 对象的序列化(serialization)类是面向流的,应如何将对象写入到随机存取文件中？

答: 目前,没有直接的方法可以将对象写入到随机存取文件中。但是可以使用ByteArray输入/输出流作为中介，来向随机存取文件中写入或从随机存取文件中读出字节，并且可以利用字节流来创建对象输入/输出流，以用于读写对象。需要注意的是在字节流中要包含一个完整的对象，否则读写对象时将发生错误。例如， java.io.ByteArrayOutputStream可用于获取ObjectOutputStream的字节流，从中可得到byte数组并可将之写入到随机存取文件中。相反，我们可以从随机存取文件中读出字节数组，利用它可构造ByteArrayInputStream,进而构造出 ObjectInputStream,以读取对象。

 

22. 在JDK1.1中Thread类定义了suspend()和resume()方法，但是在JDK1.2中已经过时,应使用什么方法来替代之？

答: Thread.suspend本身易于产生死锁。如果一个目标线程对某一关键系统资源进行了加锁操作,然后该线程被suspend，那么除非该线程被 resume，否则其它线程都将无法访问该系统资源。如果另外一个线程将调用resume，使该线程继续运行，而在此之前，它也需要访问这一系统资源，则将产生死锁。

因此,在Java 2中，比较流行的方式是定义线程的状态变量，并使目标线程轮询该状态变量，当状态为悬挂状态时，可以使用wait()方法使之处于等待状态。一旦需要该线程继续运行，其它线程会调用notify()方法来通知它。


如果您有更好的答案，请跟贴。谢谢！

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:45 发表评论
]]>(转载)Java学习，是一条漫长的道路http://www.blogjava.net/lijiezjn/articles/94154.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:43:00 GMThttp://www.blogjava.net/lijiezjn/articles/94154.html
　　我在Java 1.0正式问世前就开始学习Java，这么多年过去了，到现在我的Java学习历程还没有停过。我阅读原文书，研究原始码，撰写程序，自认为走得扎实，不奢望一步登天。像我这样老式的学习方式，显然和现在的快餐主义背道而驰。从许多读者的来信和学生的反应中，我发现大多数的人对于Java的学习历程都差不多是:因为公司需要使用Java来进行服务器的计画，所以急急忙忙地学习Java语言，然后就开始使用J2EE的API，开始写起程序来了。如此急就章的学习方式，程序员基础能力根本就不够，对于对象导向精髓不能掌握，对于Java语言内部的运作机制毫无所悉，对API的整体连贯性懵懵懂懂。

　　当然，我们也不好因此责怪程序员，毕竟软件技术变动得太快。公司不可能给程序员足够的训练之后才开始做计画。程序员一下子被指派使用A技术，还没弄懂A技术是怎么回事，又被指派使用B技术，而且都是缝缝补补的方式边学边用，每次都像是全新的开始，遑论技术能量的累积。

　　我很庆幸的是，我不太有这样的困扰。因为我是资讯工程系出身(而且我大学时上课一向很认真)，所以理论基础稳固，学习新技术对我来说不是难事。我就读大学时，周遭许多同学都瞧不起数据结构、程序语言、操作系统这些所谓「学院派」的课程，以为这些课程一点都不实用。他们认为到了外面公司，这些信息科系所学的一切都派不上用场，「只要会Visual Basic和数据库就够了」。这种偏差的心态，恐怕会使得他们在知识经济时代吃足了苦头。

　　另外还有一派同学很瞧不起程序设计工作，他们告诉我，像我这样会写程序的人，未来进了社会「还不是被他们这些走管理的人踩在脚下」。所以，他们很轻忽理工课程的学习，甚至还有人相当热衷「成功学」，认为这是迈向成功的快捷方式，却因此把学校的课业弃之不顾。我不敢相信有人竟然如此地本末倒置。

　　前一类的人太过于短视近利，后一类的人太过于好高骛远。我一直很不能理解这些人的想法为什么会这样，或许是因为社会环境的风气使然。我很庆幸我到目前还没被社会的大染缸给玷污了(最好这辈子都不要)。我不认为我的学习方式是一种典范，但是一路走来，倒也颇有进展。许多读者来信问我的学习历程，虽然我个人的学习方式不见得适用于每个人，但或许还有一些参考价值(特别是对于那些有志进入信息行业的年轻学子)，我想透过本文简短地叙述一下。

　　我一向是采用先深后广(也称为Bottom-Up，Deep-First)的学习方式。比方说，当我在学A技术的时候，学到一半发现需要B技术的基础，我会到书局找出一两本B技术的书，然后把A先搁着，开始看起B技术的书。甚至，我在技术书籍上看到不太熟悉的英文句构时，我会找出一本英文文法书详细读过。这种先深后广的学习方式，适合学生时代全面地自我能力提升，但不适合业界人士。试想，老板要你开发的ERP系统已经延迟了，你怎有空研究 J2EE原文书中的英文文法。先深后广的好处是，学习很扎实;缺点是有时候会偏离主题太多。有一次我发现我原本是要学某软件技术，几次「先深后广」下来，我居然看起老子的道德经了。

　　在技术上，我一直都是一个喜新厌旧的人，很少有软件技术能让我持续研究半年以上，我几乎每隔几个月就要换一次领域。Java 能让我持续这么久，也正是因为Java的领域广。透过Java，我的技术视野变开阔了。这些年来，我换过的 Java 相关领域包括了:虚拟机器、数据库、企业运算、多媒体、2D/3D图学、网络.…..等。

　　我的学习完全是兴趣导向的，所以压力并不大。因为有兴趣，所以我会很想充分理解一切细节。又因为理解，所以许多原本片片断断的知识都可以渐渐互相融会贯通，累积技术能量，理论和实务之间的藩篱被打破了，学习效率倍增。

　　我多年来的学习触觉很敏锐，我常常会抢先一步学好有前瞻性的技术。比方说，Java还在beta时、UML还在0.8时、XML还在draft 时，我都已经透过网络下载技术文件回来每天抱着猛读了。而在Java、UML、XML当红之后，我已经差不多把这些技术都摸熟了。

　　至于该学什么技术，我的判断方式是以技术的优劣来决定。优秀而有独到之处的技术是我的最爱，虽然这类的技术不见得会在市场上胜出，但学习这些技术所得到的启发，对于技术能量的累积与能力的提升会有相当大的助益。至于技术差，但市场需求甚殷者，我还是懒得碰。(好吧!我承认我曾因为市场需求的缘故而学过MFC。越清楚MFC的技术细节，越是讨厌它，这真是个不堪回首的经验。)

　　我通常只看英文技术资料，毕竟大部分第一手的技术信息都是以英文来传播。所以我很早就开始阅读英文技术资料。读英文技术资料的好处是，就算没有学到书中的专业知识，至少也累积培养了英文阅读能力，我一直都是抱着这样的态度。一开始是正襟危坐的看英文技术书籍，字典、翻译机随侍在侧;几年下来，现在是躺着看、趴着看、很随性地看英文技术书籍，因为看英文技术书籍变成一种习惯了。现在，我可以用很快的速度吸收英文技术书籍的知识(有人叫我「吃书的机器」，我把这称号当作是一种恭维)。

　　近年来，我花在写程序的时间不多，因为时间对我来说很宝贵，而写程序很浪费时间。对初学者来说，大量地写程序是必要的，但过了某个阶段之后，写程序所带来的技术能力成长已经到了极限，还不如多花一点时间看书，学新技术和新观念。

　　我从国小时期开始学习写程序，迄今已有近十八年的时间;采取上述的方式密集学习，迄今也有近十年的光景。迩来数年，我接触的领域越来越广，而且学习速度正在加快，我认为是以前那些努力植下的根苗开始成长了。看看现在的我，或许你会觉得羡慕，但回顾这段学习的岁月，何尝不是一条漫长的道路。

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:43 发表评论
]]>(转载)学习Java的30个基本概念http://www.blogjava.net/lijiezjn/articles/94152.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:39:00 GMThttp://www.blogjava.net/lijiezjn/articles/94152.html
在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念.



　　Java概述:

　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合pc应用程序的开发,其发展逐渐变成在开发手持设备,互联网信息站,及车载计算机的开发.Java于其他语言所不同的是程序运行时提供了平台的独立性,称许可以在 windows,solaris,linux其他操作系统上使用完全相同的代码.Java的语法与C++语法类似,C++/C程序员很容易掌握,而且 Java是完全的彻底的面向对象的,其中提出了很好的GC(Garbage Collector)垃圾处理机制,防止内存溢出.

　　Java的白皮书为我们提出了Java语言的11个关键特性.

　　(1)Easy:Java的语法比C++的相对简单,另一个方面就是Java能使软件在很小的机器上运行,基础解释其和类库的支持的大小约为40kb,增加基本的标准库和线程支持的内存需要增加125kb.

　　(2)分布式:Java带有很强大的TCP/IP协议族的例程库,Java应用程序能够通过URL来穿过网络来访问远程对象,由于servlet机制的出现,使Java编程非常的高效,现在许多的大的web server都支持servlet.

　　(3)OO:面向对象设计是把重点放在对象及对象的接口上的一个编程技术.其面向对象和C++有很多不同,在与多重继承的处理及Java的原类模型.

　　(4)健壮特性:Java采取了一个安全指针模型,能减小重写内存和数据崩溃的可能性。

　　(5)安全:Java用来设计网路和分布系统,这带来了新的安全问题,Java可以用来构建防病毒和防攻击的System.事实证明Java在防毒这一方面做的比较好.
(6)中立体系结构:Java编译其生成体系结构中立的目标文件格式可以在很多处理器上执行,编译器产生的指令字节码(Javabytecode)实现此特性,此字节码可以在任何机器上解释执行.

　　(7)可移植性:Java中对基本数据结构类型的大小和算法都有严格的规定所以可移植性很好.

　　(8)多线程:Java处理多线程的过程很简单,Java把多线程实现交给底下操作系统或线程程序完成.所以多线程是Java作为服务器端开发语言的流行原因之一

　　(9)Applet和servlet:能够在网页上执行的程序叫Applet,需要支持Java的浏览器很多,而applet支持动态的网页,这是很多其他语言所不能做到的.

　　基本概念:

　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率.

　　2.OOP中最重要的思想是类,类是模板是蓝图,从类中构造一个对象,即创建了这个类的一个实例(instance)

　　3.封装:就是把数据和行为结合起在一个包中)并对对象使用者隐藏数据的实现过程,一个对象中的数据叫他的实例字段(instance field)

　　4.通过扩展一个类来获得一个新类叫继承(inheritance),而所有的类都是由Object根超类扩展而得,根超类下文会做介绍.

　　5.对象的3个主要特性
　　behavior---说明这个对象能做什么.
　　state---当对象施加方法时对象的反映.
　　identity---与其他相似行为对象的区分标志.
　　每个对象有唯一的indentity 而这3者之间相互影响.
6.类之间的关系:
　　use-a :依赖关系
　　has-a :聚合关系
　　is-a :继承关系--例:A类继承了B类,此时A类不仅有了B类的方法,还有其自己的方法.(个性存在于共性中)

　　7.构造对象使用构造器:构造器的提出,构造器是一种特殊的方法,构造对象并对其初始化.
　　例Data类的构造器叫Data
　　new Data()---构造一个新对象,且初始化当前时间.
　　Data happyday=new
　　Data()---把一个对象赋值给一个变量happyday,从而使该对象能够多次使用,此处要声明的使变量与对象变量二者是不同的.new返回的值是一个引用.
　　构造器特点:构造器可以有0个,一个或多个参数
　　构造器和类有相同的名字
　　一个类可以有多个构造器
　　构造器没有返回值
　　构造器总是和new运算符一起使用.

　　8.重载:当多个方法具有相同的名字而含有不同的参数时,便发生重载.编译器必须挑选出调用哪个方法.

　　9.包(package)Java允许把一个或多个类收集在一起成为一组,称作包,以便于组织任务,标准Java库分为许多包.java.lang java.util java,net等,包是分层次的所有的java包都在java和javax包层次内.

　　10.继承思想:允许在已经存在的类的基础上构建新的类,当你继承一个已经存在的类时,那么你就复用了这个类的方法和字段,同时你可以在新类中添加新的方法和字段.

　　11.扩展类:扩展类充分体现了is-a的继承关系. 形式为:class (子类) extends (基类).

　　12.多态:在java中,对象变量是多态的.而java中不支持多重继承.
13.动态绑定:调用对象方法的机制.
　　(1)编译器检查对象声明的类型和方法名.
　　(2)编译器检查方法调用的参数类型.
　　(3)静态绑定:若方法类型为priavte static final 编译器会准确知道该调用哪个方法.
　　(4)当程序运行并且使用动态绑定来调用一个方法时,那么虚拟机必须调用x所指向的对象的实际类型相匹配的方法版本.
　　(5)动态绑定:是很重要的特性,它能使程序变得可扩展而不需要重编译已存代码.

　　14.final类:为防止他人从你的类上派生新类,此类是不可扩展的.

　　15.动态调用比静态调用花费的时间要长,

　　16.抽象类:规定一个或多个抽象方法的类本身必须定义为abstract例: public abstract string getDescripition

　　17.Java中的每一个类都是从Object类扩展而来的.

　　18.object类中的equal和toString方法.equal用于测试一个对象是否同另一个对象相等.toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)

　　19.通用编程:任何类类型的所有值都可以同object类性的变量来代替.

　　20.数组列表:ArrayList动态数组列表,是一个类库,定义在java.uitl包中,可自动调节数组的大小.

　　21.class类 object类中的getclass方法返回ckass类型的一个实例,程序启动时包含在main方法的类会被加载,虚拟机要加载他需要的所有类,每一个加载的类都要加载它需要的类.

　　22.class类为编写可动态操纵java代码的程序提供了强大的功能反射,这项功能为JavaBeans特别有用,使用反射Java能支持VB程序员习惯使用的工具.能够分析类能力的程序叫反射器,Java中提供此功能的包叫Java.lang.reflect反射机制十分强大.
　　1.在运行时分析类的能力.
　　2.在运行时探察类的对象.
　　3.实现通用数组操纵代码.
　　4.提供方法对象.
　　而此机制主要针对是工具者而不是应用及程序.
　　反射机制中的最重要的部分是允许你检查类的结构.用到的API有:
　　java.lang.reflect.Field 返回字段.
　　java.reflect.Method 返回方法.
　　java.lang.reflect.Constructor 返回参数.
　　方法指针:java没有方法指针,把一个方法的地址传给另一个方法,可以在后面调用它,而接口是更好的解决方案.
23.接口(Interface)说明类该做什么而不指定如何去做,一个类可以实现一个或多个interface.

　　24.接口不是一个类,而是对符合接口要求的类的一套规范.若实现一个接口需要2个步骤:
　　1.声明类需要实现的指定接口.
　　2.提供接口中的所有方法的定义.
　　声明一个类实现一个接口需要使用implements 关键字class actionB implements Comparable 其actionb需要提供CompareTo方法,接口不是类,不能用new实例化一个接口.

　　25.一个类只有一个超类,但一个类能实现多个接口.Java中的一个重要接口Cloneable

　　26.接口和回调.编程一个常用的模式是回调模式,在这种模式中你可以指定当一个特定时间发生时回调对象上的方法.例:ActionListener 接口监听.
　　类似的API有:java.swing.JOptionPane
　　　　　　　　java.swing.Timer
　　　　　　　　java.awt.Tookit

　　27.对象clone:clone方法是object一个保护方法,这意味着你的代码不能简单的调用它.

　　28.内部类:一个内部类的定义是定义在另一个内部的类
　　原因是:1.一个内部类的对象能够访问创建它的对象的实现,包括私有数据
　　2.对于同一个包中的其他类来说,内部类能够隐藏起来.
　　3.匿名内部类可以很方便的定义回调.
　　4.使用内部类可以非常方便的编写事件驱动程序.

　　29.代理类(proxy):1.指定接口要求所有代码　2.object类定义的所有的方法(toString equals)

　　30.数据类型:Java是强调类型的语言,每个变量都必须先申明它都类型,java中总共有8个基本类型.4种是整型,2种是浮点型,一种是字符型,被用于Unicode编码中的字符,布尔型.

(转载文章请保留出处： 北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:39 发表评论
]]>(转载)Java初学问题实录http://www.blogjava.net/lijiezjn/articles/94151.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:38:00 GMThttp://www.blogjava.net/lijiezjn/articles/94151.html
1. 问：在JAVA与JSP中要调用一个LINUX上的脚本程序,或WINDOWS上的脚本程序,该怎么写？
答：System.getRuntime().exec("bash < aaa.sh");

2. 问：java中用什么表示双引号
答："""

3. 问：如何在JSP程序里另起一个线程？
答：
JSP本身就是独立线程运行而不象CGI都是独立进程.
一般:
Thread t = new Thread("你的对象\");
t.start();就可以了.
要求你这个对象要实现runnable接口或继承thread.

4. 问：jsp如何获得客户端的IP地址？
答：
request.getRemoteAddr()
看看各个webserver的API文档说明，一般都有自带的，resin和tomcat都有

5. 问：程序终止与输出终止
答：
程序中止:return;
输出中止:out.close();这一句相当于ASP的response.end

6. 问：jsp中如何得到上页的URL？
答：request.getHeader("referer");

7. 问：提交网页的网页过期功能是怎么做的？
答：response.setHader("Expires","0");

8. 问：在JSP网页中如何知道自已打开的页面的名称
答：
request.getRequestURI() ;//文件名
request.getRequestURL() ;//全部ＵＲＬ

9. 问：提交表单后验证没有通过，返回提交页面，如何使原提交页面中的数据保留？
答：javascript的go(-1)可以把上页的表单内容重新显示出来,但password域没有

10. 问：如何取得http的头信息？
答：request.getHader(headerName);

11. 问：&&和&的区别？
答：
&&是短路的与操作，也就是当地一个条件是false的时候，第二个条件不用执行
&相反，两个条件总是执行。

12. 问：将*以正弦曲线的一个周期显示出来
答：
public void paint(Graphics g)
{
for(int i=0;i<200;i++)
g.drawString("*",i,(int)(Math.sin(i)*20)+50);
}
}

13. 问：浮点数相乘后结果不精确如100.0 * 0.6 结果等于 60.0004
答：
这不叫错误,float和double是这样实现的.如果要精确计算，java提供了一个
strictfp,它的计算遵循IEEE 754标准.而普通的float和double是由地平台浮点格式或
硬件提
供的额外精度或表示范围。

14. 问：如何获得当前用的cursors的位置？
答：
int row = rs.getRow()就是当前指针行数,还有
isFrist();isBeforeFist();isLast();isAfterLast();可以测试是不是在方法名所说的
位置

15. 问：表单成功提交了，点后退显示网页过期
答：
在里面加以下代码



或者
在表单页中加上


16. 问：接口的简单理解
答：接口为了规范,比如我在接口中定义了一个方法:
getData()
这是用来从不同的数据库中取数据的,就是JDBC的实现
对于用户,我不要知道每种数据库是如何做的,但我知道如何它们要实现这个接口就一定
有这个方法可以供我调
用.这样SUN就把这个接口给各个数据库开发商,让他们自己实现.
但为什么不用继承而用接口哩,因为继承只能从一个你类继承,而接口可以实现多个,就
是说我实现的子类有多
个规定好的接口中的功能.
这只是简单的理解,等你深入理解抽象的时候就知道抽象到抽象类时为什么还要再抽象
到接口.

17. 问：怎样编写一个取消按钮（怎样返回上一个页面，象工具栏的后退按钮）？
答：
javascript把每次浏览过的location都压到了一个栈中,这个栈就是
history,然后你如果要回到第几个页面它就做几次POP操作,把最后POP出来的那个LOCA
TION给你.
这就是JAVASCRIPT在实现history.go(-x)的原理.

18. 问：什么是回调？
答：
简单说,回调用不是让你去监听谁做完了什么事,而是谁做完了什么事就报告给你.
这就是回调用的思想.例子太多了,AWT的事件,SWING事件模型都是这样有.
还有多线程中,如果要控制线程数,不能总是查询每个线程是否结束,要在每个线程结束
时让线程自己告诉主线
程我结束了,你可以开新的线程了.

19. 问：简要介绍一下compareTo方法
答：
compareTo方法是Comparable 接口必需实现的方法,只要实现Comparable 就可以用Arr
ays.srot()排序就象实
现Runnable接口的run就能Thread()一样.

20. 问：如何可以从别的Web服务器检索页, 然后把检索到的网页的HTML代码储存在一个变
量中返回过来
答：这是一个简单的WEB ROBOT实现,用URL类实现从网页中抓内容,然后自己写一个分析
程序从中找出新的URL,不断递归下去就行了.

张彬 2005-11-21 17:56
(二)
21. 问：applet中如何获得键盘的输入
答：application的System.in是当前系统的标准输入,applet因为安全的原因不可能读
取当前系统(客户端)的标准输入,只能从它的ROOT组件的事件中,比如键盘事件中取得键值.

22. 问：怎样计算代码执行所花费的时间？
答：
代码开始取时间，结束后取时间，相减
long t1 = System.currentTimeMillis();
///////////////// your code
long t2 = System.currentTimeMillis() ;
long time = t2-t1;

23. 问：如何获在程序中获得一个文件的ContentType？
答：
URL u = new URL("file:///aaa.txt");
URLConnection uc = u.openConnection();
String s = uc.getContentType();

24. 问：连接池的使用是建立很多连接池，还是一个连接池里用多个连接？
答：
只有在对象源不同的情况下才会发生多个池化,如果你只连一结一个数据源,永远不要用
多个连结池.
所以连结池的初始化一定要做成静态的,而且应该在构造对象之前,也就是只有在类LOA
D的时候,别的时候不应该有任何生成新的连结池的时候。

25. 问：JavaMail要怎么安装？
答：下载两个包，一个是javamail包，另一个是jaf包。下载完直接把这两个包不解压
加到CLASSPATH。

26. 问：怎样把地址栏里的地址锁定？
答：把你的服务器的可访问目录索引选项关闭就行了,任何服务器都有一个conf文件,里
面都有这个选项。

27. 问：在JAVA中怎么取得环境变量啊。比如： TEMP = C：TEMP ？
答：String sss = System.getProperty(key)。

28. 问：怎样实现四舍五入，保留小数点后两位小数？
答：
import java.text.*;
...
NumberFormat nf=NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(2);
nf.setMinimumFractionDigits(2);
nf.format(numb);

29. 问：Applet和form如何通信？
答：
取得的参数传到param里面



30. 问：java-plug-in是什么？
答：Java Runtime Environment的插件。用来运行java程序。不需要什么特别的设置。
等于你的机器里面有了jvm。

31. 问：WEB上面怎么样连接上一个EXCEL表格？
答：
定义页面得contentType="application/vnd.ms-excel",让页面以excel得形式打开。
同样也可以以word得形式打开:application/msword。

32. 问：怎样才能避免textarea字数限制？
答：是使用了FORM的默认方法的缘故,如果什么也不写默认是GET改用Post即可，在For
m中定义mothod="post"。

33. 问：为什么加了插入数据库的
中文，依然是乱码？
答：
这要从环境看,能显示说明你的JSP引擎没有问题,但写入数据库时你的JDBC能不能处理
中文,同
一公司不同版本的JDBC都有支持中文和不支持中文的情况,RESIN自带的MYSQL JDBC就不
支持,MM
的就支持,还有你的数据库类型是否支持中文?CHAR的一般支持,但是否用binary存储双
字节码

34. 问：对于JFrame，hide()，show()与setVisibel()有什么区别吗？
答：
setVisible()从Component继承过来，而hide(),show()从Window里面继承过来。
Makes the Window visible. If the Window and/or its owner are not yet displa
yable, both are made
displayable. The Window will be validated prior to being made visible. If t
he Window is already
visible, this will bring the Window to the front.
区别在这。

36. 问：sendRedirect为什么不可以转到mms协议的地址的？response.sendRedirect("mms
://missiah.adsldns.org:9394");
答：java平台目前实现的protocol中并没有mms,你可以取系统属性java.protocol.han
dler.pkgs看看它的值中有没有mms,所以如果要想重定向到mms://host这样和URL,只有生成
客户端的JAVASCRIPT让它来重定向

37. 问：JTable中怎样定义各个Columns和Width和怎样设置表格的内容靠做靠右或居中？
答：
TableColumn tc = table.getColumn("Name");//取得列名为“Name”的列Handle
int currentWidth = tc.getPreferredWidth(); //取得该列当前的宽度
tc.setPreferredWidth(200); //设置当前列宽
tc.setMaxWidth(200); //设置该列最大宽度
tc.setMinWidth(50); //设置该列最小宽度

38. 问：批操作是否可用于select语句？
答：批操作其实是指成批理更新的操作,绝对不可能用于select操作。

39. 问：为什么jsp路径太深文件名太长就无法读取文件？
答：path不能超过255长度,不然就找不到了.这是作业系统的事。

张彬 2005-11-21 17:59
(三)
51. 问：object的clone方法为什么不能直接调用？
答：
这个方法在object中是protected
为什么要把这个方法定义为protected,这是一个折中,它的目的是想知道你这个方法在
Object里只是一个标记,而不是一个实现,比如

public class Object
{

.............
protected Object clone()
{}
}

所以直接继承的clone()方法并不能做任何时,你要使用这个方法就要重载这个方法并放
宽访问权限为public,或实现cloneable接口.
但它没法这样告诉你它没有真的实现,只好用protected 方法加以警示

52. 问：一个页面中如何刷新另外一个页面？
答：
要求是这些面页必须有关联,一是它们都有一个共同的顶层帧,也就是说是一个帧内的分
级页面,当然可以是任意级,帧内再分帧也可以,另一个可能是当前窗口弹出的窗口,如果没有
联系,那就不可能用一个页面刷新另一个页面.
帧内只要一级一级引用就行了.
比如在左帧中一个页面中写
top.right.location.reload();那么名为right的右帧中的页面就会刷新.
弹出的一样,用open时的名称刷新子窗口,子窗口用opener刷新主窗口

53. 问：如何在jsp中怎么样向客户端写cookies？
答：
Cookie coo = new Cookie(name, value);
HttpServletResponse.addCookie(name);

54. 问：为什么jTextField1.setText("aaabbb");jTextField2.setText("AAABBB"); 得到
的字体宽度不一样？
答：就是说如果不是指定为等宽字体,每个字体的宽度都是不一样的.因此JAVA中用Fon
tMetrics 类来取字符宽度。

55. 问：String kk=application/octet-stream; name="G:/SMBCrack.exe";如何得到SMBC
rack.exe？
答：
这应该是解析上传时候的二进制流得到的
这一行里面格式是固定的，取到name="后面的字符串，然后把";去掉。
然后取最后一个/后面的所有字符组成一个新字符串就行了。

56. 问：如何传值并不刷新页面？
答：
弹出一个页面进行值的选择或者输入，ok后使用将值传给原窗口，使用javascript关闭
打开的窗口即可：
window.close();opener.focus();


57. 问：有一个字符串：“EF0C114EA4”，如何变为a[0] = 0xEF a[1] = 0x0C a[2] = 0x
11 a[3] = 0x4E a[4] = 0xA4？
答：
String str="EF0C114EA4F";
out.print(str+"");
int l=str.length()/2+str.length()%2,j=0,k=0;
String[] a=new String[l];
for(int i=0;i");
j+=2;
}

58. 问：怎样将一个int转换成一个四字节的byte数组？
答：
int x = 1234567;
byte[] b = new byte[4];
for(int i=0;i>( i*8)) & 0xFF;
}

59. 问：indexOf()的使用需要注意什么？
答：参数是指从第几位（1，2，3，...）开始搜索，而返回值是指搜索到的位置（0，
1，2，3.......）注意是从零算起的。

60. 问：在Java应用程序中如何动态的添加一个按钮？
答：
这里涉及一个组件重绘的问题,组件要先于panel被显示之处存在,如果一panel已经显示
了,那么加在上面你能看到吗?但如果在同一个panel上,先有button A,假如按下它加了butt
on B,这时你如果使整个panel重给,那么A本身要重绘,它的事件监听就没有了,当然也就加不
成B了,所以如果要先有另一个panel,当按A时把B加在这个panel上并重绘这个paenl,其实更
好的方法是先把B加在panel中,同一个也行.把它setVisiable(flase),按A时设为true。

张彬 2005-11-21 18:00
(四)
61. 问：book mybook=new book(bookid);book是servlet,出错。
答：
book是servlet,能book mybook=new book(bookid);
说明自己实现了servlet容器?不然,servlet能让你自己去调用?
servlet如果调用其实和EJB连1%的区别都没有,它们都是自己继承或实现一些接口,在这
些父类或接口中实现了如果和容器"打交道"的方法,然后容器调用这些方法来管理它,让它
生成实例,池化,钝化,销毁,再生等.所以这样写是错误的。

62. 问：给定一个字符串5*(5+9)/7怎样计算出结果？
答：
可有两种方法
1。用堆栈完成
2。最简单的方法，不用编程，如果有任何一个数据库的化，
用select (5*(5+9)/7) from oneTable

63. 问：如何实现递交表单内容的加密解密？
答：
如果你用IE目前只能用SSL协议,这一层不要你考虑,否则只你用你自己的工具加密传输
,接收后再解密友,至于如何加解,如果要和公认的系统结合,就用通用的MD5,RAS等公开算法
,如果你只是自己传自己解,你随便按你的想法把数据加上一些东西,取回来按规则减掉这些
东西,我敢保证除你自己没有任何人能知道解密方法.

64. 问：为什么Integer.parseInt("+1");会抛出NumberFormatException的异常？
答：因为"+"运行算在JAVA中被重载.系统无法确定你用的是算术加还是字符+。

这一点可以在JAVASCRIPT中更好地理解:


var a = document.t.s.value+1;
这时a = 12345,因为document.t.s.value作为字符串.
但var a = document.t.s.value-1;
a 就是1233,因为系统知道-运算肯定是算术运行.所以把document.t.s.value
转换成数字.


65. 问：hashCode() 有什么用为什么有时候需要覆盖Object里的hashcode()方法？
答：这就是这个对象的身份证啊,要不如何区分哪个对象。

66. 问：怎样在tomcat中实现一个定时执行的东东？
答：
在应用程序启动时自动运行。servlet2.3中定义了ServletListener,监听Servlet Con
text的启动或则关闭（可在配置文件中配置），启动时触发一个守护程序的运行(可以实现
java.util.Timer或则javax.swing.Timer).

67. 问：程序可以输出自己吗？
答：孔德悖论这个非常有名的法则.就是说任何程序都不可能输出自己.

68. 问：能够把字符转化成ASCII码？比如将 A 转化成 65？
答：
int a=´A´;
out.println(a);

69. 问：如何区分输入的文字中的全角与半角？
答：由于不能分辨出全角和半角字符的值有什么规律,只好把全角符号牧举出来了.

70. 问：用户注册后的自动发信程序该怎么做？
答：
这种发信程序不考虑性能,因为不可能1秒就有一个人注册,我们说的考虑性能的发信程
序是指上百万封信在队列里要不停发送的那种,象你这个随便怎么写一个程序都行,没有必要
用JAVAMAIL.只要指定一个发信的服务器然后用cocket连它的25口就行了.
自己用SOCKET连SMTP的25口发一封信就好象两个邻居之间送一样东西,直接递过去得了
,用JAVAMAIL,消息机制就是你把这个东西从邮局寄给你的邻居了.
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:38 发表评论
]]>(转载)JSP基本语法介绍http://www.blogjava.net/lijiezjn/articles/94147.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:35:00 GMThttp://www.blogjava.net/lijiezjn/articles/94147.html

JSP编译器指引与指令元件有五种型态.在JSP 1.0之后，大部分的JSP是包含在以<% 作为开始%>作为结束的单一标签里.新的 JSP 1.1规格已经发表了，它同时也与XML相容.

五种JSP的编译器指引如下所示：
1 编译器指引 <%@ 编译器指引 %>
2 预定义 <%! 预定义 %>
3 运算式 <%= 运算式 %>
4 程序代码 <% 程序代码 %>
5 注解 <%-- 注解 --%>

　下面我们分析一个简单的 JSP 页面。您可以在 JSWDK 的 examples 目录下创建另外一个目录存放此文件，文件名字可以任意，但扩展名必须为 .jsp 。从下面的代码清单中可以看到， JSP 页面除了比普通 HTML 页面多一些 Java 代码外，两者具有基本相同的结构。 Java 代码是通过 < % 和 %> 符号加入到 HTML 代码中间的，它的主要功能是生成并显示一个从 0 到 9 的字符串。在这个字符串的前面和后面都是一些通过 HTML 代码输出的文本。
　 < HTML>
　 < HEAD>< TITLE>JSP 页面 < /TITLE>< /HEAD>
　 < BODY>
　 < %@ page language="java" %>
　 < %! String str="0"; %>
　 < % for (int i=1; i < 10; i++) {
　 str = str + i;
　 } %>
　 JSP 输出之前。
　 < P>
　 < %= str %>
　 < P>
　 JSP 输出之后。
　 < /BODY>
　 < /HTML>
　　 这个 JSP 页面可以分成几个部分来分析。
首先是 JSP 指令。它描述的是页面的基本信息，如所使用的语言、是否维持会话状态、是否使用缓冲等。 JSP 指令由 < %@ 开始， %> 结束。在本例中，指令“ < %@ page language="java" %> ”只简单地定义了本例使用的是 Java 语言（当前，在 JSP 规范中 Java 是唯一被支持的语言）。
接下来的是 JSP 声明。 JSP 声明可以看成是定义类这一层次的变量和方法的地方。 JSP 声明由 < %! 开始， %> 结束。如本例中的“ < %! String str="0"; %> ”定义了一个字符串变量。在每一项声明的后面都必须有一个分号，就象在普通 Java 类中声明成员变量一样。
位于 < % 和 %> 之间的代码块是描述 JSP 页面处理逻辑的 Java 代码，如本例中的 for 循环所示。
最后，位于 < %= 和 %> 之间的代码称为 JSP 表达式，如本例中的“ < %= str %> ”所示。 JSP 表达式提供了一种将 JSP 生成的数值嵌入 HTML 页面的简单方法。 　

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:35 发表评论
]]>(转载)JSP开发入门http://www.blogjava.net/lijiezjn/articles/94145.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:34:00 GMThttp://www.blogjava.net/lijiezjn/articles/94145.html
　　JSP与微软的Active Server Pages 兼容，但它是使用类似HTML的卷标以及Java程序代码段而不是VBScript。当你所使用的网站服务器没有提供本地ASP支持，也就是Apache 或Netscape服务器时，你可以考虑使用JSP。虽然你可以取得这些服务器的ASP附加配备模块，但价格相当昂贵，而目前Sun并没有对你所需要的 JSP组件收取费用(虽然Sun未来有可能会收费)。对于Solaris与Linux以及Windows，这些组件也都很容易取得。　

　　请不要将JSP与服务器端的JavaScript混为一谈。网站服务器会自动将以JSP写成的Java程序代码段转换成Java servlets。而许多先前必须以Perl手写程序或服务器特定的API（如ASP）控制的功能也都可透过JSP来自动化处理。

　　现在就让我们开始动手帮助你建立一个可执行JSP范例网站。

一、安装好你的机器来使用JSP
二、JSP语法的基本原理
三、JSP与JavaBean
四、JJSP的内部对象
五、JSP其他相关资源

JSP开发入门2
安装好你的机器来使用JSP

　　你将会需要Java 2软件开发工具(JSDK)，它原来的名称是Java发展工具(JDK)以及JavaServer网站发展工具(JSWDK)，Tomcat，或是其它支持JSP的网络服务器。Sun免费提供JSDK与JSWDK来供Windows，Solaris，以及Linux平台使用。　

如果你想要在你目前的网络服务器上使用JSP，但服务器本身并不支持JSP与Java servlets，你可以试试看Allaire的Jrun，它的作用就像是针对Netscape企业版与FastTrack服务器、微软的网际网络信息服务器(IIS)与个人网络服务器(PWS)、Apache、以及其它服务器的网络服务器附加设备。你也可以使用Apache网络服务器的Java版本，最新的JSWDK里有提供。

　　下载与安装你需要的组件


　　目前发布的1.2.2-001，JSDK可下载的版本是以可安装的压缩形式。下载的文件大约是20MB，可提供完整的Java发展环境，让你能建立利用标准API为核心的Java解决之道。然而，你的网络服务器需要应用到JSP的唯一一件事是Java编译器。要让网络服务器知道编译器的位置，将环境变量JAVA.HOME设到JSDK的安装目录。如果你是在Windows上安装并且接受预设目录，将这行程序代码set JAVA.HOME=C:1.2.2加到你的autoexec.bat档案并且重新开机。

在安装好JSDK之后，下载并且安装 JSWDK或beta版的Tomcat，以Java为主的Apache网络服务器。安装在哪里并不重要，重要的是你可以找到它。一般而言，它会放在上层目录，这种方式可以让你取代JSWDK或 JSDK的网络服务器，不需要移动其它的网络服务器。在你安装好这个档案之后，你就可以准备发展JSP了。
　　在你正确的安装JSWDK之后，执行startserver指令文件来激活网络服务器，预设通讯端口 为 8080。要看你在激活服务器之后是均C有正确的安装工具，你可以加载范例JSP档案中的任何一个(http://localhost: 8080/examples/jsp/)。如果你能够成功的执行一个范例档案，你可以知道你已经正确的设定好软件了。如果你在激活服务器的控制台窗口看到错误讯息，那么你需要解决这个问题。最常发生的问题是没有设定(或者不正确设定)环境变量JAVA.HOME。要检视目前的环境设定，在DOS模式下键入 set。


　　开始


　　解释JSP语法之前，先建立一个显示目前日期与时间的快速网页并且将它储存成sample.jsp:

　　<html>

　　<head>

　　<title>First Page</title>

　　</head>

　　<body>

　　

Today is:

　　<%= new java.util.Date() %>

　　



　　</body>

　　</html>.

将这个档案与你所有的HTML与JSP网页放在你JSWDK安装目录下的网页目录里. 你可以在http://localhost:8080/sample.jsp下载此页.当你第一次参观这个网页时，网站服务器会将JSP翻译成Java servlet程序代码，那你就会看到目前的日期与时间.
　　现在你已经下载，安装，并且架构好发展环境，你已经准备好要了解JSP语法与建立你自己的JSP为主的解决之道.

JSP开发入门3
JSP语法的基本原理


安装之后，接下来我们要讨论JSP的语法.如果要偷懒，你可以下载语法卡而如果你不熟悉 Java的程序设计，你可能会想要参考Sun的使用手册；然而，网站建立者不应该做太多的Java发展。除了几个函式呼叫之外，出现在你JSP网页上的 Java程序代码应该将它减到最少;
　　记住这点之后，现在让我们先来看看JSP的编译器指引与指令组件，之后我们将解释JavaBeans 与内部对象. JSP编译器指引与指令组件有五种型态.JSP 1.0之后，大部分的JSP是包含在以<% 作为开始%>作为结束的单一卷标里.新的 JSP 1.1规格已经发表了，它同时也与XML兼容.


JSP的编译器指引与指令组件


　　编译器指示　　　　　　　<%@ 编译器指示 %>

　　声明　　　　　　　　　　<%! 声明 %>

　　表达式 　　　　　　　　<%= 表达式 %>

　　程序代码段/小型指令　　　<% 程序代码片段 %>

　　注释　　　　　　　　　　<%-- 注释 --%>


　　编译器指示


　　JSP的编译器指示是针对JSP引擎。它们并不会直接产生任何看得见的输出；相反的，它们是在告诉引擎如何处理其它的JSP网页。它们永远包含在 <%@ ?%>卷标里。两个主要的指引是 page与include。我们不会讨论taglib编译器指引但它可以在JSP1.1里用来建立自订卷标。

　　你几乎可以在你所有的JSP网页最上面找到page编译器指示。虽然这不是必须的，但它可以让你指定到哪里可以找到支持的Java类别这类的事：

　　<%@ page import="java.util.Date" %>，　

　　当发生Java问题的事件时应该将讯息传送到哪里：

　　<%@ page errorPage="errorPage.jsp" %>，　

　　以及你是?需要为使用者管理通话期的信息，可能存取多个网页(稍后在JavaBeans里会有更多通话期的讨论):

　　<%@ page session="true" %>。　

　include编译器指示让你将你的内容分成几个可管理的组件，就像那些有表头或脚注的网页。所包含的网页可以是固定格式的HTML网页或者是JSP内容的网页:

　　<%@ include file="filename.jsp" %>。


　　宣告


　　JSP声明让你定义网页层的变量，来储存信息或定义支持的函式，让JSP网页的其余部分能够使用。如果你发现自己有太多的程序代码，你最好将它们放在不同的Java类别里。你可以在 <%! ?%>卷标里找到声明。记住要在变量声明的后面加上分号，就跟任何有效的Java叙述的形式一样: <%! int i=0; %>。


　　表达式


　　JSP里有表达式，评估表达式的结果可以转换成字符串并且直接使用在输出网页上。JSP运算是属于 <%= ?%> 卷标里，并不包含分号，加引号字符串的无用部分。

　　<%= i %>

　　<%= "Hello" %> 。


　　程序代码段/小型指令文件


　　JSP程序代码片段或小型指令文件是包含在<% ?%> 卷标里。当网络服务器接受这段请求时，这段Java程序代码会执行。小型指令文件可以是原始的HTML或XML，其内部的程序代码片段可以让你建立有条件的执行程序代码，或者只是一些使用另一块程序代码的东西。举例来说，下列的程序代码结合了表达式与小型指令文件，在H1，H2，H3，以及H4卷标里显示字符串"Hello"。小型指令文件不限于一行的原始程序代码 :

　　<% for (int i=1; i<=4; i++) { %>

　　<H<%=i%>>Hello</H<%=i%>>

　　<% } %>。


　　注释


　　最后一个主要JSP组件是嵌入式注释。虽然你可以在你的档案里包含HTML注释，如果使用者检视网页的原始码，他们也会看到这些注释。如果你不要让使用者看到你的批注，你可以将它放在<%-- ?--%>卷标里:

　　<%-- 针对服务器端的注释 --%>。


JSP开发入门4
JSP与JavaBean
　　虽然你可以在小型指令文件里放入一大块的程序代码，但是大多数的Java程序代码是属于可以重复使用的组件，称为JavaBean。JavaBean就跟ActiveX控件一样:它们提供已知的功能，并且是为了可随时重复使用的目的而设计的。

　　JavaBean的价值在于它可以经由一组特性来使用，而这些特性则提供对JavaBean设定的存取。以人来作范例，此人就是JavaBean，而他的姓名，社会福利安全号码，以及住址可以是特性。对于JSP网站，基本上你是将"JavaBean"动态的连接到你的网站。

　　假设 JavaBean是在建立网站之前建好的，你要做的第一件事是告诉JSP网页它所需要使用JavaBean.这工作可以用<jsp: useBean>卷标来完成：<jsp:useBean id="localName" class="com.jguru.Person" scope="application" />.

　　<jsp: useBean>卷标需要你以id 属性来辨识豆子.在这里，你提供一个名称让JSP网页来辨识豆子，除了id 属性之外，你也必须告诉网页要到哪里去找这个豆子，或者是它的Java类别名称。类别属性提供如何在各式方法之中找到它，最后一个需要的组件是scope 属性.有了范围属性的帮助，你可以告诉豆子，要它为单一网页(预设)[scope="page"]；为一个被请求的网页[scope= "request"]；为通话期[scope="session"]；或为整个应用程序[scope="application"]来维护它自己的信息. 对于通话期范围，你可以很容易的维护JSP网页里的项目，例如购物车。

　　一但你宣告了JavaBean之后，你就可以存取它的特性来订定它。要取得一特性的值，使用<jsp:getProperty>卷标。有了<jsp:getProperty>卷标，你可以指定要使用的豆子名称(从useBean的id字段)，以及你要取得值的特性。接着，真正的值就会放在输出里：<jsp:getProperty id="localName" property="name" />.

　　要更改JavaBean的特性，你需要使用 <jsp:setProperty>卷标.对这个卷标，你也需要辨认豆子以及要修正的特性，除此之外，你还需要提供新值.如果命名正确，这些可以直接经由规定的格式取得：<jsp:setProperty id="localName" property="*" />;　

　　要从一参数取得，你必须直接命名此特性以及参数: <jsp:setProperty id="localName" property="address" param="parameterName" />;　

　　或是直接以名称与值来设定: <jsp:setProperty id="localName" property="serialNumber" value="string" /> or <jsp:setProperty id="localName" property="serialNumber" value= <%= expression %> />.

　　有关JavaBean的最后一点:要让网络服务器可以找到JavaBean，你需要将它们的类别档案放在特别位置。对JSWDK而言，最简单的地方是在安装目录里的类别目录，例如 jswdk-1.0.1classes.


JSP开发入门5
JSP的内部对象
　　最后一个与JSP语法有关的组件叫做内部对象.在JSP小型指令文件内，你可以存取这些内部对象来与执行JSP网页的servlet环境相互作用。许多对内部对象的存取应该要简化。然而，这些是范例，它们的存取都是可接受的，要完整的利用内部对象设定则需要对最新的Java Servlet API有所了解。

　　下表列出你可以使用的内部对象。


　　内部对象说明


　　request 　　客户端请求，此请求会包含来自GET/POST请求的参数

　　response　　网页传回客户端的响应

　　pageContext 网页的属性是在这里管理

　　session 　　与请求有关的会话

　　application servlet正在执行的内容

　　out 　　　　用来传送响应的输出流

　　config　　　servlet的架构对象

　　page　　　　JSP网页本身

　　exception　　针对错误网页，未捕捉的例外

　　那么，这些是做什么的，而你应该如何使用它们呢?基本上，在你的小型指令文件里，你可以使用它们来存取执行JSP程序代码的servlet。为了避免谈论到太多Servlet API 的细节，让我们来检视一些你可以利用它们来做的事:　

　　不必使用表达式，你可以直接存取内部out对象来打印一些东西到response:

　　<% out.println("Hello"); %>.　

　　不必直接传送参数到JavaBean，你可以藉由请求对象来取得参数的值:

　　<% String name=request.getParameter("name"); out.println(name); %>。

　　当你以JSP写了许多的应用程序之后，如果你建立了JavaBeans或者发现你自己将太多的Java原始码放入你的JSP档案，你需要建立支持的Java类别，这样可以鼓励重复使用并且降低JSP网页转换时所需要的时间。当你需要建立Java类别时，你必须:

　　将JDSWK的安装目录in目录加到你的PATH。在你的autoexec.bat档案的PATH行的最后，加入C:1.2.2in; 。

　　以下面的指令将JAR档案复制到jrelibext目录:

　　copy c:jswdk-1.0.1libservlet.jar c:jdk1.2.2jrelibext. (转载文章请保留出处：Java家(www.javajia.com))

 

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:34 发表评论
]]>(转载)JSP程序员成长全计划http://www.blogjava.net/lijiezjn/articles/94142.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:32:00 GMThttp://www.blogjava.net/lijiezjn/articles/94142.html
　　１、建立并且理解你的Web Server。
　　因为Apache 是免费的并且在大多数平台上工作，为训练目的推荐 Apache。
　　安装时间：2 天。

　　２、 保证你理解 HTML / XHTML 。
　　你将需要了解html基础, 特别是 HTML 布局中的table的使用。XHTML 不久将代替 HTML ，学习 XHTML 的基础是一个好主意。许多程序员通过 HTML IDE 学习 HTML ( 集成开发环境 ) 。因为大多数 HTML IDE产生混乱的HTMl语法，所以花时间学习手工写作html是很有必要的。因为你将会使用 JSP 和 HTML 混合编程，精通HTML语法是重要的。所以，你必须能流利地写 HTML 。
　　训练时间：2 ～ 4 个星期。

　　３、开始学习 Java 。
　　开始学习 Java 1.3 理解 Java 基础是很重要的。不用担心学习Swing或 Java 的图形方面，因为在JSP 中你不会使用这些特征。集中精力在 Java 工作的细节，学习 Java 的逻辑，也在 Java Bean上花时间。学习Applet是好的, 但是就象Swing， JSP 的大多数应用将不使用小程序。
　　训练时间：3 ～ 6 个星期。

　　４、学习并且理解你的Web Server的更好的细节。
　　熟悉Web Server的特征，这是很重要的。
　　训练时间：2 天。

　　５、建立你的 JSP Server
　　我推荐以Tomcat开始。它可以很好地运行JSP程序。当你不能在生产使用Tomcat时，学习尽可能多的知识以便于更好的运行程序。另外, 许多 JSP 程序员使用Tomcat。因此当你遇到一个问题时，你将容易发现帮助。
　　安装时间：一～ 2 天。

　　６、开始学习 JSP 。
　　基本的 JSP 学习通过的步骤 1到步骤6可以完成, 然后使用 JSP 对象和脚本写 JSP 程序来联系。学习 JSP 的另外一个方面可以学习怎么创建一个分布式的应用程序。
　　训练时间：4 ～ 6 个星期。

　　７、学习更多的 JSP server。
　　没有关于更多的 JSP Server当然也可以运行jsp程序。然而, 许多 JSP server都由自己特殊的特征，可以让你更好的理解你的JSP 工程。

　　学习更多的Jsp server如何处理jsp程序是有必要的。同样也可以优化你的 JSP 应用程序，并且使之运行得更快而不出任何问题。
训练时间：2 ～ 7 天。

　　８、 学习 JDBC 。
　　JSP 大多数应用将使用数据库，JDBC 被用于数据库连接。经常忽略的一个事实就是，每个 JDBC Driver 所支持的东西是相当不同的。了解并熟悉在jsp工程上被使用的 JDBC driver的细节是很重要的。
　　（有时这部分的学习被包含在前面 Java 或JSP的学习中了 。）
　　训练时间：1～ 2 个星期。

　　到现在，你已经成为了熟练的 JSP 程序员。仍然有很多需要学习，你可以考虑扩展你的知识比如 DHTML ， XML ，java证书， JSP Tag Libraries 或 Servlets , 看你想要造什么类型的网站而决定了。

　　这些训练是JSP 的核心。你不必都学习上面所有的, 取决于你在工程中分配到什么任务和你已经有什么知识。但是这是我成功地训练程序员的时间表。关键的单元是时间。平均的说, 5 个月时间确实能够训练一个人 ( 从开始到完成 ) 成为一个对jsp熟悉程序员。5 个月时间似乎很长，但要成为一个资深的WEB程序员所学的东西远远不止这一些。

　　也许你认为这样学习一种语言花费的时间太长了，因为学 ASP 会更快、时间会更短。 但是学习 ASP 不需要学习java的。

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:32 发表评论
]]>(转载)Tomcat环境的建立http://www.blogjava.net/lijiezjn/articles/94140.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:31:00 GMThttp://www.blogjava.net/lijiezjn/articles/94140.html
Tomcat是在SUN的JSWDK的基础上发展起来的另一个优秀的JSP服务器，它不但支持Servlet，而且还提供了Web服务器的功能。作为一个开放源码的软件，Tomcat有着自己独特的优势，可以和目前大部分的主流服务器一起工作，而且有着相当高的运行效率。

　　通过本章，读者将会看到：

　　· Tomcat的基本概念
　　· 如何让Tomcat和IIS一起工作
　　· 如何让Tomcat和Apache一起工作
　　· 如何设定JSP的虚拟目录
　　· 如何将Tomcat设为Windows服务运行

　　Jakarta-Tomcat概貌

　　综述：Tomcat是一个带有JSP环境的servlet容器。servlet容器是一个根据用户的行为可以管理和激活servlet的运行时的shell。

　　我们可以粗略地将servlet容器分为如下几类：

　　独立的servlet容器

　　内置有web服务器的一部分。指使用基于Java的web服务器的情形，例如servlet容器是JavaWebServer的一个部分。独立的servlet容器是Tomcat的默认模式。

　　然而，大多数的web服务器并非基于Java。因此，我们可以得出如下两种容器的模式：

　　进程内的servlet容器

　　servlet容器作为web服务器的插件和Java容器的实现。Web服务器插件在内部地址空间打开一个JVM（Java virtual machine）使Java容器得以在内部运行。如有某个需要调用servlet的请求，插件将取得对此请求的控制并将它传递（使用JNI）给Java容器。进程内容器对于多线程、单进程的服务器非常合适并且提供很好的运行速度，但伸缩性有所不足。

　　进程外的servlet容器

　　servlet容器运行于web服务器之外的地址空间且作为web服务器的插件和Java容器的实现的结合。web服务器插件和Java容器 JVM使用IPC机制（通常是TCP/IP）进行通讯。当一个调用servlet的请求到达时，插件将取得对此请求的控制并将其传递（使用IPC等）给 Java容器，进程外容器的反应时间或进程外容器引擎不如进程内容器，但进程外容器引擎在许多其他可比的范围内更好（伸缩性、稳定性等）。

　　Tomcat既可作为独立的容器（主要是用于开发与调试），又可作为对现有服务器的附加（当前支持Apache、IIS和Netscape服务器）。所以在配置Tomcat时，必须决定如何应用它，如果选择第二或第三种模式，还需要安装一个web服务器接口。

　　Tomcat与Jserv有何区别？Tomcat是Jserv吗？

　　这是个常见的误解。Jserv是Servlet API2.0兼容并与Apache一起使用的容器。Tomcat是一个完全重写的并与Servlet API2.2和JSP1.1兼容的容器。
　　另外，Tomcat使用了一些为Jserv而写的代码，特别是Jserv的Apache接口，但这是唯一的相同之处。

　　怎样安装Tomcat的二进制版本？

　　非常简单，只需：下载 zip/tar.gz 任何压缩文件，从http://jakarta.apche.org/download/binindex.html处解压缩此文件到某目录(如： foo)，将会生成一子目录，名为"tomcat"，转换到"tomcat"目录设置一新的环境变量(TOMCAT_HOME)指向你安装的tomcat 的目录：
　　WIN32平台，键入： set TOMCAT_HOME=foo/tomcat

　　Unix平台：

　　如是bash/sh环境，键入：TOMCAT_HOME=foo/tomcat;export TOMCAT_HOME"
　　如是tcsh环境，键入：setenv TOMCAT_HOME foo/tomcat
　　设置环境变量JAVA_HOME指向你JDK的目录，然后添加JAVA解释器到你的PATH环境变量。
　　好了！现在可以运行TOMCAT并作为一个独立的Servlet容器(模式一)

　　启动与关闭Tomcat

　　使用"bin"目录中的脚本启动与关闭Tomcat。

　　启动：

　　uinx:bin/startup.sh
　　win32:binstartup


　　关闭：

　　unix:bin/shutdown.sh
　　win32:binshutdown
　　Tomcat目录结构


　　假设读者已将Tomcat解压，这时将得到下列目录结构：

目录名
描述
bin包含启动/关闭脚本。
conf包含不同的配置文件，包括 server.xml（Tomcat的主要配置文件）和为不同的Tomcat配置的web应用设置缺省值的文件web.xml。
doc包含各种Tomcat文档。
lib包含Tomcat使用的jar文件。unix平台此目录下的任何文件都被加到Tomcat的classpath中。
logs Tomcat摆放日志文件的地方。
srcServletAPI源文件。先别高兴，这里只有些必须在Servlet容器内实现的空接口和抽象类。
webapps包含web项目示例。
workTomcat自动生成，放置Tomcat运行时的临时文件（如编译后的JSP文件），如果在Tomcat运行时删除此目录.JSP页面将不能运行。
classes你可以创建此目录来添加一些附加的类到类路径中，任何你加到此目录中的类都可在Tomcat的类路径中找到自身。


　　Tomcat的脚本

　　Tomcat是一个Java程序，因此在设置好几个环境变量后即可用命令行的方式运行。然而设置Tomcat使用的每个环境变量和如下的命令行参数乏味且容易出错。因此，Tomcat开发组提供了一些脚本使启动和关闭Tomcat变得非常轻松。
　　注意：这些脚本仅仅是个便利的方法去启动和关闭Tomcat。你可修改他们来定制CLASSPATH，环境变量如PATH、LD_LIBRARY_PATH等等，只要是生成一个正确的命令行即可。
　　这些脚本是什么呢？下面列出对一般用户最重要的脚本。
　　Tomcat：主脚本。设置合适的环境变量，包括CLASSPATH、TOMCAT_HOME以及JAVA_HOME和用适合的命令行参数启动Tomcat 。
　　startup ：在后台启动Tomcat。它是"tomcat start"命令的替换方式。
　　shutdown ：关闭Tomcat。它是"tomcat stop"命令的替换方式。

　　对用户最重要的脚本是tomcat(tomcat.bat/tomcat.sh)。其他Tomcat相关的脚本作为一个简单的面向单任务的指向Tomcat脚本(设置不同的命令行参数等)的入口。

　　仔细考察tomcat.bat/tomcat.sh，它按以下步骤运行：

　　在Unix下的步骤：

　　如未指定，推测 TOMCAT_HOME
　　如未指定，推测 JAVA_HOME
　　设置CLASS_PATH包含：

　　1．${TOMCAT_HOME}/classes目录(如果存在)
　　2．${TOMCAT_HOME}/lib的一切内容
　　3．${JAVA_HOME}/lib/tools.jar（此jar文件包含工具Javac，我们需要Javac处理jsp文件）

　　运行带有设定Java环境变量的命令行参数的Java命令，调入tomcat.home和 org.apache.tomcat.startup.Tomcat 作为启始类。同时也传递命令行参数到org.apache.tomcat.startup.Tomcat ，例如：执行start/stop/run 等的操作。另外，此Tomcat进程使用指向server.xml的路径，例如server.xml放置于etc/server_1.xml并且用户意图在后台启动apache，键入如下命令行：

　　bin/tomcat.sh start -f /etc/server_1.xml
win32版的tomcat.bat与Unix版的几乎一致。尤其在它不推测TOMCAT_HOME和JAVA_HOME的值，并且不将所有的jar文件放入类路径中。

　　Tomcat的配置文件

　　这一部分将讲述如何使用配置文件server.xml和web.xml。我们不会包含web.xml的内部机制，这些内部机制深入到了Servlet API的细节，因此，我们将讨论涵盖这两个配置文件在Tomcat关系环境中的用法。
Tomcat的配置基于两个配置文件：

　　1．server.xml - Tomcat的全局配置文件，完成两个目标：
　　（1）提供Tomcat组件的初始配置
　　（2）说明Tomcat的结构、含义，使得Tomcat通过实例化组件完成启动及构建自身。
结构、含义的说明是通过元素来实现的，下面将描述这些元素。

　　Server：server.xml文件中最重要的元素。Server定义了一个Tomcat服务器。一般读者不用对它担心太多。Server元素能包含Logger和ContextManager元素类型。

　　Logger：此元素定义一个Logger对象，每个Logger都有一个名字去标识，也有一个纪录Logger的输出和冗余级别(描述此日志级别)和包含日志文件的路径，通常有servlet的Logger(ServletContext.log()处)，JSP和Tomcat运行时的Logger。

　　ContextManager：它说明了一套ContextInterceptor、RequestInterceptor、Context和它们的Connectors的配置及结构。ContextManager有几个随同提供的特性：

　　a．用来纪录调试信息的调试级别
　　b．webapps/、conf/、logs/和所有已定义的环境的基本位置。用来使Tomcat可以在TOMCAT_HOME外的其他目录启动。
　　c．工作目录的名字

　　ContextInterceptor&RequestInterceptor：这些侦听器(interceptors)侦听具体发生在 ContextManager中的事件，例如，ContextInterceptor侦听Tomcat的启动及终止事件， RequestInterceptor监视在它服务过程中用户请求需要通过的不同阶段。Tomcat的管理员不必知道太多关于侦听器的知识；另外，开发者应该知道这是如何在Tomcat中实现一个"全局"型的操作(例如安全性及每个请求日志) 。

　　Connector：表示一个到用户的联接，不管是通过web服务器或直接到用户浏览器（在一个独立配置中）。Connector负责管理Tomcat的工作线程和读/写连接到不同用户的端口的请求/响应。Connector的配置包含如下信息：

　　a．句柄类
　　b．句柄监听的TCP/IP端口
　　c．句柄服务器端口的TCP/IP的backlog

　　Context：每个Context提供一个指向你放置你Web项目的Tomcat的下属目录。每个Context包含如下配置：

　　a．Context放置的路径，可以是与ContextManager主目录相关的路径
　　b．纪录调试信息的调试级别
　　c．可重载的标志。开发Servlet时,重载更改后的Servlet,这是一个非常便利的特性

　　2．web.xml--在Tomcat中配置不同的关系环境
　　有一个和Tomcat有关的小"特性"与web.xml有关。Tomcat可以让用户通过将缺省的web.xml放入conf目录中来定义所有关系环境的web.xml的缺省值。建立一个新的关系环境时，Tomcat使用缺省的web.xml文件作为基本设置和应用项目特定的web.xml（放在应用项目的WEB-INF/web.xml文件）来覆盖这些缺省值。

　　如何将Tomcat装入IIS

　　IIS，即Internet Information Server，是微软公司提供的一种功能强大的Web服务器，它对ASP有着很好的支持，这一点相信很多读者都已经知道。现在，JSP已经流行起来，如何才能让IIS支持该技术呢？读者将会从本节得到答案。

　　一、安装环境Windows 2000、IIS 5.0

　　Tomcat 3.1下载地址
　　http://jakarta.apache.org/builds/tomcat/release/v3.1/bin/
　　isapi_redirect.dll下载地址
　　http://jakarta.apache.org/builds/tomcat/release/v3.1/bin/win32/i386/
　　放到{TOMCATHOME}\bin\iis\i386\isapi_redirect.dll

　　二、先要保证Tomcat可以正确执行

　　三、将下面的begin和end之间的Jakarta.reg文件装入机器，我的Tomcat装在c:\\jakarta-tomcat，你可根据自己的环境修改Jakarta.reg文件

　　Jakarta.reg：
　　---begin---
　　Windows Registry Editor Version 5.00
　　[HKEY_LOCAL_MACHINE\SOFTWARE\Apache Software Foundation\Jakarta Isapi Redirector\1.0]
　　"extension_uri"="/jakarta/isapi_redirect.dll"
　　"log_file"="c:\\jakarta-tomcat\\logs\\isapi.log"
　　"log_level"="debug"
　　"worker_file"="c:\\jakarta-tomcat\\conf\\workers.properties"
　　"worker_mount_file"="c:\\jakarta-tomcat\\conf\\uriworkermap.properties"
　　---end---

　　四、按照上文配置IIS，以作者的经验安装好isapi_redirect.dll后，需要重新启动机器（重启IIS不好使），实在不行的话再装一次。

　　五、启动tomcat，然后在IE中键入http://baryon/examples/，看一下效果如何，没有用8080端口也可以用jsp和 servlet了。注意不启动tomcat，光有IIS是不行的。再注意http://baryon/examples/最后的"/"一定要有，否则会找不到的。

　　如何在windows 9x环境下配置Apache ＋ Tomcat?

　　如果读者使用的是windows 9x操作系统，那么读了下文后，建立自己的JSP运行环境，将变得十分简单。

　　系统配置如下：

　　windows 98（NT主要是环境变量的设法不同，和下面程序的设置无关）

　　jdk1_2_2.exe
　　apache_1_3_9_win32.exe
　　ApacheModuleJServ.dll
　　tomcat.zip(3.1)

　　一、安装

　　1．安装JDK1.2.2，并将jdk1.2.2的目录加入到环境变量PATH中（Autoexec.bat）；
　　2．安装apache_1_3_9_win32.exe；
　　3．将ApacheModuleJServ.dll拷到Apache所在目录的modules子目录中；
　　4．安装Tomcat 3.1(解压并拷到某个目录中)；
　　此时所需部件都已经安装完毕，以下是配置过程。

　　二、配置

　　1．首先编辑Apache的conf子目录下的http.conf文件使其能正常运行并配合自己的机器配置

　　2．设置以下环境变量（可以放在autoexec.bat中）：
　　SET TOMCAT_HOME=C:\PROGRA~1\Tomcat

　　（注：此时如果有Windows风格目录，一定要写成DOS下目录格式，不然容易出问题）
　　SET JAVA_HOME=C:\PROGRA~1\jdk1.2.2

　　3．打开TOMCAT的conf子目录下的tomcat.conf文件，将以下行前的注释去掉：
　　LoadModule jserv_module modules/ApacheModuleJServ.dll
　　再将对应LINUX的类似一行用注释屏蔽掉。 ／

　　4、打开apache的httpd文件，在最后加入一行：
　　include c:/progra~1/tomcat/conf/tomcat.conf

　　三、启动与测试：

　　1．首先启动apache，此时如果正确，应当显示为：

　　Apache/1.3.9 (Win32) tomcat/1.0 running...

　　2．进入到tomcat的执行目录(bin)。

　　注一：此目录如果为windows风格目录，一定要用windows目录表示法进入，如：progra~1 一定要写为program files

　　注二：通常要求执行命令的运行环境变量大小为4096

　　3．用tomcat.bat start或tomcat.bat run启动tomcat，此时应当可以看到正确输出的classpath，说明Tomcat启动成功！
　　4．在浏览器中输入http://localhost/examples/，此时应当可以看到server返回的三个目录列表。点击其中JSP的就可以看到示例了。

　　只要用官方站下载的程序，照上述几步应当能正确启动JSP环境，接下来的问题就是如何加入context以便映射到自己的工作目录，请读者参考1.2.5节。

　　如何在Windows NT 4.0下安装Apache ＋ Servlet ＋ JSP

　　环境配置一向是比较烦的一件工作！本节的目的就是要轻松为读者搞定NT下安装和配置SERVLET和JSP的执行环境。

　　首先，到Java.apache.org去下载一个tomcat3.1或tomcat3.2。下载的是一个ZIP文件。将它解压到一个目录下面。比如 c:\下面。在c盘下面就会出现一个jakatar-tomcat的目录。读者可以将这个目录改个名字，假设改为tomcat。现在打开c:\ tomcat\conf目录下的server.xml文件。找到ContextManager标签，将可以看到：

　　＜Connector className="org.apache.tomcat.service.SimpleTcpConnector"＞
　　＜Parameter name="handler" value="org.apache.tomcat.service.http. HttpConnectionHandler"/＞
　　＜Parameter name="port" value="80"/＞
　　＜/Connector＞

　　因为tomcat可以作为一个独立的服务器使用，所以有它自己的端口号。在这里可以修改它缺省的端口号，而该号在本机未被占用。假设改成9000。

　　现在到c:\tomcat\bin目录下面，读者可以看到一个startup.bat的批处理文件。在执行这个文件前，如果你用的是JDK1.2.1或 JDK1.2.2的话，请将JDK_HOME\LIB\tools.jar这个文件放到classpath中去。（注：设置classpath的方法：右键单击"我的电脑"－＞选择属性-＞环境，如果还没有classpath这个环境变量，就添加一个，如果有了就在它的基础上修改，加上JDK_HOME\LIB\tools.jar）。

　　现在可以执行startup.bat这个文件了。（如果在执行时出现out of environment space的提示，就将DOS窗口的缓冲区大小开得大些。具体作法：在DOS 窗口的菜单中的属性－＞ 内存 －＞ 总共和初始环境改大点）

　　在执行完后，startup.bat会在另一个窗口打开start tomcat。打开浏览器，在地址栏中输入：http://localhost:9000/

　　然后回车。这时应该看到了一只jakatar-tomcat。现在在地址栏键入： http://localhost:9000/examples/servlet/，回车，应该看到一个servlet的index的页面，点击其中的例子servlet看看吧。现在在地址栏键入http://localhost:9000/examples/jsp/，回车，读者也会看到一个类似刚才 servlet index页面的一个页面，点击jsp的例子看看吧。如果在点击了一个JSP的例子后出现500的错误，如果没有别的错误信息，在IE5的工具菜单－＞ Internet选项－＞高级，把显示友好的HTTP错误的选项去掉，然后IE就会报出具体的出错信息。原因是你没有将tools.jar放到 classpath中去。

　　现在要将tomcat连接到apache上去了。首先到www.apache.org上去下载一个 Apache Web Server。再到Java.apache.org上去下载一个Jserv。先安装Apache Web Server（比如安装在c:\apache目录下面）。安装完后需要修改c:\apache\conf\httpd.conf文件，找到 Servername，修改为自己喜欢的名字，找到port，修改为未被占用的端口。再安装Jserv（比如安装在c:\Jserv目录下面）。安装 Jserv需要指定JVM所在的目录，你可以指定JDK_HOME\BIN目录。需要指定JSDK所在目录。（实际上它要找的是servlet.jar这个文件，你可以指定tomcat\lib\servlet.jar试一试）

　　这时候实际上Apache已经支持Servlet了，但还不支持JSP。所以还需修改c:\apache\conf\httpd.conf文件。用文本编辑器打开httpd.conf，在文件最后加上： Include "Tomcat_Home\conf\tomcat-apache.conf"。（请注意，tomcat-apache.conf这个文件是在 tomcat运行后由tomcat自动产生的。所以要先开tomcat，再打开Apache）

　　现在先启动tomcat（c:\ tomcat\bin\startup.bat），当出现了另一个窗口后，启动Apache（c:\apache\bin\apache.exe或者通过开始菜单－＞程序－＞Apache Web Server－＞Start Apache启动）。如果此时通过后者启动Apache，有一个DOS窗口一闪后就消失了，说明对Apache+JServ+tomcat的配置还有问题，应该通过第一种方法启动Apache，此时能在屏幕上看到具体的出错信息。

　　如果出错信息是：apj* : can't be specified more than once per host。（*号代表一些字符串，比如ApJServLogLevel等等），就要修改c:\Jserv\conf\jserv.conf文件，将 apj*的相关行注释掉就可以，可能需要注释5-6行。如果Apache也正常启动的话，现在你可以在地址栏键入http://localhost: apache_port/examples/servlet/ 来通过Apache+tomcat调试Servlet，这里apache_port是Apache的端口号，可以通过修改c:\apache\conf\ httpd.conf这个文件修改端口号；在地址栏键入http://localhost:apache_port/examples/jsp/ 来调试JSP。

　　怎样设置JSP的虚拟目录？

　　如果读者细心的话，会发现前面测试用的都是examples\jsp目录。现在就讲一下怎么创建自己的工作目录。

　　首先在d:\tomcat\webapps（假定安装目录为d:\tomcat）目录下面创建myweb目录，接着在myweb目录下面创建jsp目录和classes目录。然后用文本编辑器打开d:\tomcat\conf目录下面的server.xml，查找到＜ContextManager＞标签，并在该标签的结束标签＜/ContextManager＞前面加上：

　　＜Context path="/myweb" docBase="webapps/myweb" debug="0" reloadable="true" ＞
　　＜/Context＞

　　其中path的值是虚拟目录，docbase的值是你的硬盘的的目录的绝对路径。
然后将d:\tomcat\webapps\myweb\classes目录放到classpath这个环境变量中去。用文本编辑器编辑下面这个文件。

　　＜html＞
　　＜body＞
　　＜%
　　for(int i=1;i＜3;i++){
　　out.println("＜h" + i + "＞Hello World＜/h" + i + "＞");
　　}
　　%＞
　　＜/body＞
　　＜/html＞

　　存为c:\tomcat\webapps\myweb\jsp\helloworld.jsp。

　　在地址栏键入：http://localhost:apache_port/testdir/jsp/helloworld.jsp 看看结果吧。

　　再测试一下Servlet。用文本编辑器编辑下面这个文件。

　　import Java.io.*;
　　import Java.text.*;
　　import Java.util.*;
　　import Javax.servlet.*;
　　import Javax.servlet.http.*;

　　public class HelloWorld extends HttpServlet {
　　public void service(HttpServletRequest request, HttpServletResponse response)
　　throws IOException, ServletException
　　{
　　response.setContentType("text/html");
　　ServletOutputStream out = response.getOutputStream();
　　out.println("＜html＞");
　　out.println("＜head＞");
　　String title = "Hello World";
　　out.println("＜title＞" + title + "＜/title＞");
　　out.println("＜/head＞");
　　out.println("＜body bgcolor=\"white\"＞");
　　out.println("＜body＞");
　　out.println("＜h1＞" + title + "＜/h1＞");
　　out.println("＜/body＞");
　　out.println("＜/html＞");
　　}
　　}

　　存为c:\tomcat\webapps\myweb\classes\HelloWorld.Java，用Javac编译后，在地址栏键入 http://localhost:apache_port/testdir/servlet/HelloWorld 看看结果吧。

　　如何设定Tomcat作为Windows的服务而启动？

　　上面我们已经谈到，要使用Tomcat作为Web服务时，必须先手工启动Tomcat，这显然不是一个适合Tomcat作为Web服务的方法，在 Linux下可以通过修改启动脚本自动启动Tomcat，在Windows下则可以设定Tomcat作为Windows的服务而启动。

　　我们可以借助工具，使Tomcat作为Windows NT/2000的一个服务：

　　一、下载工具，这里作为例子的是gservany--将NT下的一般应用程序作为服务运行的工具。下载网址为http: //www.advok.com/gservany.html。将zip文件解压缩，将gservany.exe放入winnt\system32下

　　二、在NT/2000的command下输入：gservany -i tomcat "C:\Jakarta-tomcat\bin" "startup.bat" "C:\Jakarta-tomcat\bin" "shutdown.bat"。其中C:\Jakarta-tomcat为Tomcat的安装目录。

　　三、启动service管理器，会看到tomcat service被装上。

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:31 发表评论
]]>(转载)Hibernate快速入门http://www.blogjava.net/lijiezjn/articles/94136.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:24:00 GMThttp://www.blogjava.net/lijiezjn/articles/94136.html
其实Hibernate本身是个独立的框架，它不需要任何web server或application server的支持。然而，大多数的Hibernate入门介绍都加入了很多非Hibernate的东西，比如: Tomcat, Eclipse, Log4J,Struts, XDoclet, 甚至JBoss。这容易让人产生Hibernate复杂难懂的误解，特别是打击了初学者的积极性。

　　在这篇文章将不涉及Eclipse, log4j, Struts, Tomcat, XDoclet，和JBoss。本文的目的是演示一下Hibernate的安装过程以及最基本的功能，从而给初学者一个低得不能再低的入门门槛。

　　下载文件

　　你需要Java SDK、 Hibernate包、Ant包、和JDBC Driver。

　　1、Hibernate包下载地址:
　　http://prdownloads.sourceforge.net/hibernate/?sort_by=date&sort=desc

　　2、Ant包下载地址:
　　http://archive.apache.org/dist/ant/

　　3、JDBC Driver要根据你用的database来定，一般database官方网站上都会有。Hibernate支持常用的database，比如 MySQL, Oracle, PostgreSQL, 和MS-SQL Server。这些数据库都有JDBC Driver:

　　Oracle JDBC Driver下载地址(下载前必须同意Oracle协议书)
　　http://otn.oracle.com/software/htdocs/distlic.html?/software/tech/java/sqlj_jdbc/htdocs/jdbc9201.html

　　MySQL JDBC Driver下载地址
　　http://dev.mysql.com/downloads/connector/j/3.0.html

　　PostgreSQL JDBC Driver下载地址
　　http://jdbc.postgresql.org/download.html

　　MS-SQL Server JDBC Driver下载地址
　　http://www.microsoft.com/downloads/details.aspx?FamilyID=9f1874b6-f8e1-4bd6-947c-0fc5bf05bf71&displaylang=en

　　4、将Hibernate包和Ant包分别解压至c:\dev\下(此目录不重要，你可以换其它任何目录)。

　　配置环境

　　1、你需要添加一个新的环境变量: ANT_HOME，让它指向c:\dev\<的ANT包所在目录>并在PATH环境变量里添加%ANT_HOME%\bin。

　　2、你需要添加一个新的环境变量: JAVA_HOME，让它指向你的j2sdk根目录。并在PATH环境变量里添加%JAVA_HOME%\bin。

　　3、创建一个项目ā?目录，比如c:\workspace\My1stHibernate。

　　在项目目录下，另外创建三个目录: src, classes, lib。

　　在lib目录下，创建两个目录: hibernate和db。

　　这样你有了如下的文件结构:

　　c:\workspace\My1stHibernate\
　　c:\workspace\My1stHibernate\src
　　c:\workspace\My1stHibernate\classes
　　c:\workspace\My1stHibernate\lib
　　c:\workspace\My1stHibernate\lib\hibernate
　　c:\workspace\My1stHibernate\lib\db

　　4、将c:\dev\<的Hibernate包所在目录>hibernate2.jar文件copy到c:\workspace\My1stHibernate\lib\hibernate下。

　　将c:\dev\<的Hibernate包所在目录>lib\下的所有文件同样copy到c:\workspace\My1stHibernate\lib\hibernate下。

　　将你的JDBC Driver文件(一般是一个jar文件)copy到c:\workspace\My1stHibernate\lib\db下。

　　创建数据库

　　1、用你最喜爱的database软件，创建一个hibernate_test的数据库。

　　2、在此数据库下，新建一个table名为CUSTOMER

CREATE TABLE CUSTOMER
(
　CID INTEGER NOT NULL PRIMARY KEY, USERNAME VARCHAR(12) NOT NULL, PASSWORD VARCHAR(12)
);

　　编写Java文件

public class Customer {
　private int id;
　private String username;
　private String password;

　public int getId() {
　　return id;
　}

　public String getPassword() {
　　return password;
　}

　public String getUsername() {
　　return username;
　}

　public void setId(int id) {
　　this.id = id;
　}

　public void setPassword(String password) {
　　this.password = password;
　}

　public void setUsername(String username) {
　　this.username = username;
　}

}

　　将此类存为c:\workspace\My1stHibernate\src\Customer.java文件。

　　编写Test类

import net.sf.hibernate.*;
import net.sf.hibernate.cfg.*;

public class Test {

　public static void main(String[] args) {
　　try {
　　　SessionFactory sf = new Configuration().configure().buildSessionFactory();
　　　Session session = sf.openSession();
　　　Transaction tx = session.beginTransaction();

　　　for (int i = 0; i <200; i++) {
　　　　Customer customer = new Customer();
　　　　custoā?mer.setUsername("customer" + i);
　　　　customer.setPassword("customer");
　　　　session.save(customer);
　　　}

　　　tx.commit();
　　　session.close();
　　} catch (HibernateException e) {
　　　e.printStackTrace();
　　}
　}
}

　　将此类存为c:\workspace\My1stHibernate\src\Test.java文件。

　　创建Hibernate映射文件

　　因为这里只有一个Class --- Customer 和一个Table --- CUSTOMER，你只需要建立一个映射文件--- Customer.hbm.xml，来对应Customer类和CUSTOMER表之间的关系。

<xml version="1.0"?>
<DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<ibernate-mapping>
<lass name="Customer" table="CUSTOMER">
<d name="id" column="CID">
<enerator class="increment" />
<id>
<roperty name="username" column="USERNAME" />
<roperty name="password" column="PASSWORD" />
<class>
<hibernate-mapping>

　　把此文件存为c:\workspace\My1stHibernate\src\Customer.hbm.xml，和Customer.java放在同一目录下。

　　编写Ant build.xml文件

　　你不一定要知道这个build.xml的细节，其实Ant也不是Hibernate所必须的。这里用Ant是为了简化一些任务，比如: 编译、copy、运行，等。

<xml version="1.0" ?>

<roject name="My1stHibernate" default="build" basedir=".">

<roperty name="base.dir" value="." />
<roperty name="src.dir" value="src" />
<roperty name="lib.dir" value="lib" />
<roperty name="build.dir" value="classes" />

<ath id="myclasspath">
<ileset dir="${lib.dir}">
<nclude name="**/*.jar" />
<fileset>
<athelement location="${build.dir}" />
<path>

<arget name="init">
<kdir dir="${build.dir}" />
<target>

<arget name="build" depends="init" description="compile the source files">
<avac classpathref="myclasspath" srcdir="${src.dir}" destdir="${build.dir}" />
<opy todir="${build.dir}" >
<ileset dir="${src.dir}" >
ā?<xclude name="**/*.java"/>
<fileset>
<copy>
<target>

<arget name="run" depends="build">
<ava classpathref="myclasspath" classname="Test" fork="true" />
<target>

<arget name="clean">
<elete includeEmptyDirs="true">
<ileset dir="${build.dir}" />
<delete>
<target>

<project>

　　配置Hibernate描述文件

　　Hibernate描述文件可以是一个properties或xml 文件，其中最重要的是定义数据库的连接。我这里列出的是一个XML格式的hibernate.cfg.xml描述文件。

<xml version="1.0" encoding="utf-8" ?>
<DOCTYPE hibernate-configuration
PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-2.0.dtd">

<ibernate-configuration>

<ession-factory name="java:/hibernate/HibernateFactory">

<roperty name="show_sql">rue<property>
<roperty name="connection.driver_class">
oracle.jdbc.driver.OracleDriver <-- 这里是Oracle 9i的JDBC driver class名 -->
<property>
<roperty name="connection.url">
jdbc:oracle:oci8:@hibernate_test <-- 这里是Oracle的hibernate_test数据库URL -->
<property>
<roperty name="connection.username">
你的数据库用户名
<property>
<roperty name="connection.password">
你的数据库密码
<property>
<roperty name="dialect">
net.sf.hibernate.dialect.Oracle9Dialect <-- 这里是Oracle 9i的Dialect -->
<property>

<apping resource="Customer.hbm.xml" /><-- 指定Customer的映射文件 -->

<session-factory>

<hibernate-configuration>

　　如果你用的不是Oracle 9i，可到C:\dev\<的Hibernate包所在目录>src\hibernate.properties文件里找到你的数据库，然后替换以上相对应的值。

　　开始运行

　　到c:\workspace\My1stHibernate下，运行ant run。如果你严格依照以上步骤，应该看到

run:
[java] log4j:WARN No appenders could be found for logger (net.sf.hibernate.cfg.Environment).
[java] log4j:WARN Please initialize the log4j system properly.
[java] Hibernate: insert into CUSTOMER (USERNAME, PASSWORD, CID) values (?, ?, ?)
BUILD SUCCESSFUL

　　到你的hibernate_test数据库看一下，在CUSTMOR表里新添了200条记录，但你没有写任何JDBC code。

　　以后如果你要更换数据库，只需要改变hibernate.cfg.xml描述文件里相应的值即可。

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:24 发表评论
]]>(转载)Tomcat全攻略http://www.blogjava.net/lijiezjn/articles/94135.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:23:00 GMThttp://www.blogjava.net/lijiezjn/articles/94135.html
随着java的流行，其在web上的应用也越来越广，tomcat作为一个开源的servlet容器，应用前景越来越广，本文将向你讲述tomcat的一些知识。
一：简介
tomcat 是jakarta项目中的一个重要的子项目，其被JavaWorld杂志的编辑选为2001年度最具创新的java产品 (Most  Innovative  Java  Product)，同时它又是sun公司官方推荐的servlet和jsp容器(具体可以见http://java.sun.com/products/jsp/tomcat/)，因此其越来越多的受到软件公司和开发人员的喜爱。servlet和jsp的最新规范都可以在tomcat的新版本中得到实现。

二：安装及配置
tomcat最新版本为4.0.1，这个版本用了一个新的servlet容器Catalina，完整的实现了servlet2.3和jsp1.2规范。注意安装之前你的系统必须安装了jdk1.2以上版本。

(一)：安装
1：windows平台
从tomcat网站下载jakarta-tomcat-4.0.1.exe，按照一般的windows程序安装步骤即可安装好tomcat,安装时它会自动寻找你的jdk和jre的位置。

2：linux平台
下载jakarta-tomcat-4.0.1.tar.gz，将其解压到一个目录。

(二)：配置
运行tomcat需要设置JAVA_HOME变量

set  JAVA_HOME=c:/jdk  (win98，在msdos方式下使用，或者放入autoexec.bat中)
export  JAVA_HOME=/usr/local/jdk  (linux下使用，放到/etc/bashrc或者/etc/profile中)


  



(三)：运行
设置完毕后就可以运行tomcat服务器了，进入tomcat的bin目录，win98下用startup启动tomcat，linux下用startup.sh，相应的关闭tomcat的命令为shutdown和shutdown.sh。

启动后可以在浏览器中输入http://localhost:8080/测试，由于tomcat本身具有web服务器的功能，因此我们不必安装apache，当然其也可以与apache集成到一起，下面会介绍。

下面你可以测试其自带的jsp和servlet示例。

三：应用

(一):目录结构
tomcat的目录结构如下：

目录名  简介  
bin  存放启动和关闭tomcat脚本  
conf  包含不同的配置文件,server.xml(Tomcat的主要配置文件)和web.xml  
work  存放jsp编译后产生的class文件  
webapp  存放应用程序示例，以后你要部署的应用程序也要放到此目录  
logs  存放日志文件  
lib/japser/common  这三个目录主要存放tomcat所需的jar文件  



(二)：server.xml配置简介
下面我们将讲述这个文件中的基本配置信息，更具体的配置信息见tomcat的文档

元素名  属性  解释  
server  port  指定一个端口，这个端口负责监听关闭tomcat的请求  
shutdown  指定向端口发送的命令字符串  
service  name  指定service的名字  
Connector
(表示客户端和service之间的连接)  port  指定服务器端要创建的端口号，并在这个断口监听来自客户端的请求  
minProcessors  服务器启动时创建的处理请求的线程数  
maxProcessors  最大可以创建的处理请求的线程数  
enableLookups  如果为true，则可以通过调用request.getRemoteHost()进行DNS查询来得到远程客户端的实际主机名，若为false则不进行DNS查询，而是返回其ip地址  
redirectPort  指定服务器正在处理http请求时收到了一个SSL传输请求后重定向的端口号  
acceptCount  指定当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理  
connectionTimeout  指定超时的时间数(以毫秒为单位)  
Engine
(表示指定service中的请求处理机，接收和处理来自Connector的请求)  defaultHost  指定缺省的处理请求的主机名，它至少与其中的一个host元素的name属性值是一样的  
Context
(表示一个web应用程序，通常为WAR文件，关于WAR的具体信息见servlet规范)  docBase  应用程序的路径或者是WAR文件存放的路径  
path  表示此web应用程序的url的前缀，这样请求的url为http://localhost:8080/path/****  
reloadable  这个属性非常重要，如果为true，则tomcat会自动检测应用程序的/WEB-INF/lib  和/WEB-INF/classes目录的变化，自动装载新的应用程序，我们可以在不重起tomcat的情况下改变应用程序  
host
(表示一个虚拟主机)
  name  指定主机名  
appBase  应用程序基本目录，即存放应用程序的目录  
unpackWARs  如果为true，则tomcat会自动将WAR文件解压，否则不解压，直接从WAR文件中运行应用程序  
Logger
(表示日志，调试和错误信息)
  className  指定logger使用的类名，此类必须实现org.apache.catalina.Logger  接口  
prefix  指定log文件的前缀  
suffix  指定log文件的后缀  
timestamp  如果为true，则log文件名中要加入时间，如下例:localhost_log.2001-10-04.txt  
Realm
(表示存放用户名，密码及role的数据库)
  className  指定Realm使用的类名，此类必须实现org.apache.catalina.Realm接口  
Valve
(功能与Logger差不多，其prefix和suffix属性解释和Logger  中的一样)
  className  指定Valve使用的类名，如用org.apache.catalina.valves.AccessLogValve类可以记录应用程序的访问信息
  
directory  指定log文件存放的位置  
pattern  有两个值，common方式记录远程主机名或ip地址，用户名，日期，第一行请求的字符串，HTTP响应代码，发送的字节数。combined方式比common方式记录的值更多  

注意：1：经过我测试，我设置Context  的path="",reloadable=true，然后放一个WAR文件到webapps目录，结果 tomcat不能检测出此文件(重起tomcat可以)，而把此文件解压，则tomcat会自动检测出这个新的应用程序。如果不能自动检测WAR文件，我们可以利用下面管理中讲的方法来部署应用程序。

2：默认的server.xml中，Realm元素只设置了一个className属性，但此文件中也包含几个通过JDBC连接到数据库进行验证的示例(被注释掉了)，通过Realm元素我们可以实现容器安全管理 (Container  Managed  Security)。

3：还有一些元素我们没有介绍，如Parameter，loader，你可以通过tomcat的文档获取这些元素的信息。

(三)：管理

1：配置
在进行具体的管理之前，我们先给tomcat添加一个用户，使这个用户有权限来进行管理。

打开conf目录下的tomcat-users.xml文件，在相应的位置添加下面一行：

  


  



注意：这一行的最后部分一定是/>,tomcat的文档掉了/符号，如果没有/符号的话，tomcat重起时将无法访问应用程序。通过logs/catalina.out文件你可以看到这个错误的详细信息。

然后重起tomcat，在浏览器中输入http://localhost:8080/manager/，会弹出对话框，输入上面的用户名和密码即可。

2：应用程序列表
在浏览器中输入http://localhost:8080/manager/list，浏览器将会显示如下的信息：

OK  -  Listed  applications  for  virtual  host  localhost
/ex:running:1
/examples:running:1
/webdav:running:0
/tomcat-docs:running:0
/manager:running:0
/:running:0

  



面的信息分别为应用程序的路径，当前状态(running  或者stopped)，与这个程序相连的session数。

3：重新装载应用程序
在浏览器中输入  http://localhost:8080/manager/reload?path=/examples，浏览器显示如下：

OK  -  Reloaded  application  at  context  path  /examples    


  



表示example应用程序装载成功，如果我们将server.xml的Context元素的reloadable属性设为true(见上面表格)，则没必要利用这种方式重新装载应用程序，因为tomcat会自动装载。

4：显示session信息
在浏览器中输入http://localhost:8080/manager/sessions?path=/examples，浏览器显示如下：

OK  -  Session  information  for  application  at  context  path  /examples  Default  maximum  session  inactive  interval  30  minutes    


  



5：启动和关闭应用程序
在浏览器中输入http://localhost:8080/manager/start?path=/examples和http://localhost:8080/manager/stop?path=/examples分别启动和关闭examples应用程序。

6：部署及撤销部署
WAR有两种组织方式，一种是按一定的目录结构组织文件，一种是一个后缀为WAR的压缩包，因此它的部署方式也有两种：
(1)：在浏览器中输入：http://localhost:8080/manager/install?path=/examples&war=file:/c:examples
就会将按目录结构组织的WAR部署

(2)：如果输入:http://localhost:8080/manager/install?path=/examples&war=jar:file:/c:examples.war!/
就会将按压缩包组织的WAR部署，注意此url后半部分一定要有!/号。

部署后就可以用  http://localhost:8080/examples访问了。

在浏览器中输入：http://localhost:8080/manager/remove?path=/examples
就会撤销刚才部署的应用程序。

(四)：与apache集成
虽然tomcat也可以作web服务器,但其处理静态html的速度比不上apache,且其作为web服务器的功能远不如apache,因此我们想把apache和tomcat集成起来。

我们以linux系统为例介绍.

从apache网站下载apache1.3.22源代码版本，然后使用如下命令配置安装apache：

mkdir  /usr/local/apache
tar  zxvf  apache.1.32.tar.gz
cd  apache.1.32
./configure  --prefix=/usr/local/apache  --enable-module=so  
make
make  install


  



注意configure命令指定目标安装目录，并且加入DSO(Dynamic  Shared  Object)支持，注意一定不要忘了这一个选项。

然后下载webapp模块，将解压后mod_webapp.so文件放入apache的libexec目录，编辑apache的conf目录下的httpd.conf，在这个文件的最后加入下面三行：

LoadModule  webapp_module  libexec/mod_webapp.so
WebAppConnection  warpConnection  warp  localhost:8008
WebAppDeploy  examples  warpConnection  /examples/  


  



第一行是加入webapp模块，如果编译apache时不增加DSO支持，则无法使用LoadModule指令，第二行指定tomcat与apache的连接，第三行指定部署那个应用，这两个指令使用格式如下：

WebAppConnection  [connection  name]  [provider]  [host:port]
WebAppDeploy  [application  name]  [connection  name]  [url  path]    


  



其中connection  name指定连接名，provider只能是warp，port端口与你的tomcat的配置文件server.xml最后几行指定的要保持一致。文件如下：

  

port="8008"  minProcessors="5"  maxProcessors="75"
enableLookups="true"
acceptCount="10"  debug="0"/>
******
nbsp; 


  



application  name与你在tomcat中部署的应用名一致，url  path指定访问这个应用的url。例如上面的例子可以通过http://localhost/examples/来访问tomcat中的examples应用。

(五)：中文问题
一般jsp的乱码问题可以通过在jsp中加入<%@  page  contentType="text/html;charset= GB2312"  %>来解决，至于servlet的乱码在可以使用servlet2.3中提供的 HttpServeletRequest.setCharacterEncoding函数。更详细的中文问题请见JSP/Servlet  中的汉字编码问题。

四：综述
tomcat作为一个servlet(jsp也被编译为servlet执行)容器，其应用前景是非常好的，如果与jboss结合起来，则可以实现sun的j2ee规范(用jboss作ejb服务器)。jboss的官方网站也提供集成了tomcat3.2*的 jboss以供下载。另外一个开源的应用服务器(enhydra)  也是基于tomcat的，其提供了更友好的管理界面，部署应用程序也更简单，功能也更强大。 /USER&NBSP;&NBSP;NAME="ZF"&NBSP;&NBSP;PASSWORD="ZF"&NBSP;&NBSP;ROLES="STANDARD,MANAGER">
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:23 发表评论
]]>(转载)初学jsp心得http://www.blogjava.net/lijiezjn/articles/94129.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:16:00 GMThttp://www.blogjava.net/lijiezjn/articles/94129.html

测试环境为 jdk1.2.2 jswdk-1.0 winnt4.0中文版。

1。java是大小写敏感的，用过其他编程语言的人最容易犯这个错误，尤其是刚上手的时候。我刚开始调试jsp的时50%以上的编译错误是都是因为这个。

2。java的调用过程都是要加括号的，一开始比较容易忽视，如title=request.getParameter("title").trim();

3。jsp中对应asp中的request.form()和request.querystring()的解决方法。
jsp 中取得参数没有form和queryString之分，都是通过request.getParameter("XXXX")来取得。虽然jsp也有 request.getQueryString()方法，但测试结果是 test.jsp?id=1&page=20 得到 id=1&page=20。
如果url和form有相同的参数名称呢？下面是一段测试代码：
<form method="POST" action="query.jsp?id=2">
<input type="text" name="id" value="1" size="60">
</form>
name都是id，结果是url的参数优先得到，jsp的这种处理方式和asp相比我觉的各有所长。

4。头疼的汉字处理问题。
在其他的文章里曾说到在中文NT环境下如下语句输出会得到乱码，
<%="你好"%> 及 out.print("你好");等。解决方法是只要对字符串变量进行编码就可以得到正确结果,如下代码可以得到正确的输出：
<% String title="你好";
byte[] tmpbyte=title.getBytes("ISO8859_1");
title=new String(tmpbyte);
out.print(title); %>
或者<%=title%>

关于sql语句汉字问题，例句为 select * from test where title='谁是傻瓜'
在jdbc-odbc驱动下连db2，不管是原句还是对sql语句进行编码后都死活通不过。
换了ibm的jdbc直接驱动后，对sql语句编码后程序可以通过。

这个问题的产生大概是中文NT的原因，在其他环境下可能就没汉字处理问题了，据说ibm的web sphere对中文支持的很好，这也给jsp的开发带来一定的通用性问题。据说对字符串编码是一种通用的解决方法，不过没有这么多环境来测试。

5。在asp中经常使用到字符串判断语句如 if state="真是傻瓜" then.....
在java中String变量不是一个简单的变量而是一个类实例，不同的方法会得到不同的结果
a.
String str1="我是傻瓜";
String str2="我是傻瓜"; (or String str2="我是"+"傻瓜"; )
if (str1==str2)
out.print("yes");
else
out.print("no");
结果是"yes"。
大概是编译优化，str1,str2指向同一个类实例；

b.
String str1,str2,str3;
str1="我是傻瓜";
str2="我是";
str3=str2+"傻瓜";
if (str1==str3)
out.print("yes");
else
out.print("no");
结果是"no"。

String str1=new String("我是傻瓜");
String str2=new String("我是傻瓜");
if (str1==str2)
out.print("yes");
else
out.print("no");
结果是"no"。

String str1=new String("我是傻瓜");
String str2=new String("我是傻瓜");
if (str1.compareTo(str2)==0)
out.print("yes");
else
out.print("no");
结果是"yes"。

所以在jsp中判断字符串要使用compareTo方法，用惯传统语言还真一下子适应不过来，熟悉java的朋友应该没这个问题。

6。如何判断数据库为空？
result = stmt.executeQuery(sql);
if (result.next())
......
result执行后游标出于一个未明的状态，不能进行状态判断，也不能取值，一定要next()一下才可以用。


7。在jsp中实现分页。
page是关键字，不能当变量。
conn.jsp
<%
String sDBDriver = "COM.ibm.db2.jdbc.app.DB2Driver";
String sConnStr = "jdbc:db2:faq";
Connection conn = null;
Statement stmt = null;
ResultSet rs=null;
try {
Class.forName(sDBDriver);
}
catch(java.lang.ClassNotFoundException e) {
out.print("faq(): " + e.getMessage());
}

try{
conn = DriverManager.getConnection(sConnStr,"wsdemo","wsdemo1");
stmt = conn.createStatement();
}catch(SQLException e){
out.print(e.toString());
}
%>

query.jsp

<%@ page language="java" import="java.sql.*" %>
<%@ page contentType="text/html; charset=gb2312" %>
<%@ include file="conn.jsp" %>
<%
.......
int pages=0;
int pagesize=10;
ResultSet result = null;
ResultSet rcount = null;

pages = new Integer(request.getParameter("pages")).intValue();

if (pages>0)
{

String sql=" state='我不傻'";
int count=0;
try {
rcount = stmt.executeQuery("SELECT count(id) as id from user where "+sql);

catch(SQLException ex) {
out.print("aq.executeQuery: " + ex.getMessage());
}
if(rcount.next())
count = rcount.getInt("id");
rcount.close();

if (count>0)
{
sql="select * from user where "+sql;
try {
result = stmt.executeQuery(sql);
}
catch(SQLException ex) {
out.print("aq.executeQuery: " + ex.getMessage());
}

int i;
String name;
// result.first();
// result.absolute((pages-1)*pagesize);
// 此方法jdbc2.0支持。编译通过，但执行不过，不知是不是跟驱动有关，只好用下面的笨办法。
for(i=1;i<=(pages-1)*pagesize;i++)
result.next();
for(i=1;i<=pagesize;i++) {
if (result.next()) {
name=result.getString("name");
out.print(name);
}
result.close();
int n= (int)(count/pagesize);
if (n*pagesize<count) n++;
if (n>1)
{
for(i=1;i<=n;i++)
out.print("<a href=query.jsp?pages="+i+">"+i+"&nbsp;</a>");
}
}
}
%>

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:16 发表评论
]]>(转载)初学Java注意什么？http://www.blogjava.net/lijiezjn/articles/94128.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:11:00 GMThttp://www.blogjava.net/lijiezjn/articles/94128.html
Java总有它的千般好处使你选择它，但这些随便翻翻书或在网上逛一圈就能找到答案。在本文中，笔者把自己学习Java的一些切身体会和过程写出来，供初学者做个参考。

我在学习Java的过程中主要围绕以下几个方面来学习：

1．时刻提醒自己Java是一种OOP语言工具，而不仅仅是编码，只有这样才能总体把握和运用Java。

2．在学习的过程中，最好能够了解Java的底层机制，而不是仅仅停留在表层，不是抄书上的例子运行出结果就可以。要注意，即便对一个简单的例子也要有耐心去琢磨、调试、改动。

3．在学习的过程中一定要动手做、写代码，而不是抱一本书看看就行。很多东西和体会必须自己动手才能真正属于自己，最好能参与一些实际的项目。

4．在学到一定阶段后，你开始希望用学过的东西做些什么。这时的你应该开始学习一些更多、更复杂的知识，比如J2EE平台的构建、EJB的开发等。对于这一部分，我建议最好找一本较薄的书先了解一个大概，心里有个总体的认识，对更多的技术术语做个初步掌握。我认为这个阶段看看《J2EE技术实践》很不错，它可以让你了解J2EE包含的各种技术和框架，同时提供很多实际的例子来加深对J2EE的整体了解。

学习Java的兴趣和决心起了很关键的作用。在有了上述基础后，我便开始一步一步地学习Java。


Java环境的搭建


要运行Java程序，必须安装JDK。JDK是整个Java的核心，其中包括了Java编译器、JVM、大量的Java工具以及Java基础API。

可以从http://Java.sun.com下载JDK，有1.4版本和1.31版本。我的学习环境中首先，采用的是1.31版本。

解压安装。然后，进行环境设置。

1.对于Windows平台要进行以下设置：

set PATH=YOUR_INSTALL_ DIR\bin; C:\Windows;C:\Windows\Command
set classpath=. ;YOUR_INSTALL_DIR\lib\tools.jar



2.对于Linux平台要编辑/etc/profile文件：

JAVA_HOME=your_install_dir/JDK/j2sdk
CLASSPATH=$JAVA_HOME/lib/tools.jar:$JAVA_HOME/lib/td.jar:$JAVA_HOME/jr  
-e/lib/rt.jar:.
PATH=$PATH:$JAVA_HOME/bin
export PATH PS1 USER LOGNAME MAIL HOSTNAME HISTSIZE HISTFILESIZE  
INPUTRC JAVA_HOME CLASSPATH RESIN_HOME



最后，在终端上输入Java看能不能找到这个命令，如果能找到安装就成功了。

下面介绍一下JDK的几个重要的命令：

◆Java执行工具，是启动JVM（虚拟机）并执行class（BYTE CODE）文件的命令；

◆javac 编译器，由.java文件生成.class文件；

◆jar Java压缩打包工具；

◆Javadoc 文档生成器。

最后就是JDK Documentation，这是JDK的联机帮助文档，是最有用和最重要的学习参考文档，应该多看。


开始写自己的代码


现在环境有了，应该写个简单的代码进行测试了。还是从经典的“hello word”开始。

1． 先用编辑器写一代码（我用的是Linux的vi）：

[stone@coremsg work]$ vi Hello.Java
  public class Hello{
        public static void main(String []argc){
                System.out.println("Hello Word!");
        }
  }



2． 编译：

[stone@coremsg work]$ Javac Hello.Java



3． 执行：

[stone@coremsg work]$ Java Hello
     Hello Word!



成功了！这就是我的第一个Java程序。从那时起我知道已开始走进Java的世界，接下来就靠自己的努力了。在这个过程中，笔者认为有几点需要注意。

学习一门新的语言，参考书是离不开的。我的建议是开始最好找一本篇幅较短的入门书来学习那些最简单、最基本的东西，包括学习Java语法等。同时，对一个最简单的程序也应该多去调试，多想想如果改动一下会出现什么结果？为什么必须那样写？多去想想这些问题然后去操作，会让你有更多的收获。这样反复地思考是很有用的。此外，在这一阶段还应该多看JDK的联机帮助，尽量多地掌握JDK提供的Java基本类库API。

在有一定基础、能够写一些简单的程序后，可以开始看《Thinking in Java》这本书。它比较完整地介绍了Java的语法、面向对象的特性、核心类库等。通过这一层次的学习能够加深对Java的理解和底层原理的运用，同时又可以完整地了解Java的整个体系。在这一阶段，应该重点学习Java的面向对象编程语言的特性，比如继承、构造器、抽象类、接口、方法的多态、重载、覆盖、Java的异常处理机制等，要对上述概念有非常清楚的了解。这样做的目的，是要让自己把这些技术应用到实践中进行合理的程序设计（比如，你会考虑一个类是用抽象还是接口来设计等）。这就要求必须在大量的实践中去应用和学习。这也是当初很多朋友给我的建议。


学习更多


如果要用Java来完成各种功能更强大的任务，那么就要学习语言以外的更多的东西。

1.Java Web编程

对于Java Web 编程来说，应该而且必须熟悉和掌握HTTP协议，可以参考 Stevens的《TCP/IP 详解》第三卷。Java Servlet技术提供了生成动态Web页面内容的能力，这在你的Java项目中是最基本的功能之一，所以必须学习。通过这一阶段的学习应该掌握 Servlet/JSP的Web编程。

2. J2EE的学习

J2EE包含的技术太多了。如果你想坐在桌子旁边抱着一大堆书来学习的话，效果不大的。我建议在开始这一阶段的学习的时候，可以按以下步骤来做，总的思想是“总体把握，各个击破”。

◆ 了解J2EE中的技术术语的含义。

我的感觉是J2EE标准中涉及到的各种技术很多，如果一开始就一个一个去学习的话是不现实的，也是没效果的。我的建议是，先对其中的技术有个大概的了解，比如EJB、JavaIDL、JTA等。可能你不知道怎么去写一个EJB，但是要知道什么是EJB、它能做什么，当有了这样的概念后，再去有目的地学习它就会快很多。我还要再重复一句——必须要在实践中动手去做才行。

◆ 了解J2EE中的设计模式，这样能帮助你对J2EE做个整体把握。

MVC开发模式被证明是有效的处理方法之一。它可以分离数据访问和数据表现。你可以开发一个有伸缩性的、便于扩展的控制器，来维护整个流程。通过这一层次的学习，当你面对一个项目的时候，应该首先把握它的总体架构的设计，以及决定采用J2EE标准中的哪些技术。

◆ 了解一些J2EE平台的典型案列，加深对这一技术的概念和理解。

平时可以多留意这方面，熟悉一些典型案例，分析它为什么要采用那个时间？那样做能达到什么样的目的？然后联系到自己身边的项目是否可以作为参考。

◆ 学习J2EE下的各种技术。

在有了前几阶段的学习后，可以自己搭建一个J2EE平台开始具体学习每一种技术。你可以参与公司相关项目进行学习，也可以自己搭建一个平台进行学习。这时候应该找点相关的书来一步一步学习，没有捷径可走。如果你不满足于这些，那么还应该更深入地学习UML、设计模式等方面的东西
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:11 发表评论
]]>(转载)全面认识JAVAhttp://www.blogjava.net/lijiezjn/articles/94127.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:10:00 GMThttp://www.blogjava.net/lijiezjn/articles/94127.html
以下是Java标准技术的一些要点：

一、Java的跨平台性，即一次编译到处运行

简单地说Java的跨平台性就是指，编译后的Java程序可直接在不同的平台上运行而不用重新编译，这一特性使得Java随着Web应用的普及而迅速普及起来。而Java的跨平台性是如何实现的呢？这就要理解Java虚拟机和字节码的概念。

　　实际上，编译后的Java代码并不是传统的二进制代码（如Windows下的.exe文件），而是Java字节码，这种字节码文件是不能直接在操作系统上执行的。要想在一个操作系统上运行一个Java程序必须有一个中间环节来负责将Java字节码解释成二进制码，这个中间环节就是Java虚拟机（简称 JVM)。由于目前大多数操作系统已经实现了JVM，所以Java轻松实现跨平台性。

　　二、面象对象技术

　　 Java全面支持面象对象技术，这体现在Class（类）是Java程序构成的基本单元，一个Java程序通常由许多Class组成，而且这些Class 还会有一定的继承关系，Java支持Class的单继承，从而使类之间的继承关系更明确。继承的结果产生类的多态性，类的多态本质上讲就是可以用父类的引用访问继承类的实现（子类对象），类的这种多态性最终形成了组件对象模型的基础，即通过接口（父类）访问实现（子类）。

　　三、Java中的I/O操作

　　Java中以字节流（InputStream和OutputStream)、节符流（Reader和Writer)来分别读写二进制数据和字符数据，使用非常简单有效。Java类库中的File类不仅提供文件操作而且还包含文件夹操作，如下面这几行代码可以列出C盘根目录下的所有文件：

File f=new File("c://";
String [] m_dir= f.list();
for(int i=0;i
System.out.println(m_dir);

四、Java中的图形及事件处理

可以用awt包或swing包的Java类来进行大部分的Java图形界面设计，下面的几行代码将产生一个200*200像素的窗体：

Frame f=new Frame("Welcome";
f.setSize(200,200);
f.setVisible(true);

默认情况下，Frame窗体的关闭按钮不起作用，这也是Java初学者迷惑的地方。为了使用户按下关闭按钮时能关闭Frame窗体，需要让这个窗体响应一个 WindowEvent事件，具体的做法就是给这个窗体添加一个事件监听器对象，这个事件监听器就是WindowListener接口的实现。在上面的代码中插入如下代码就可以关闭窗体：

f.addWindowListener(new WindowAdapter(){
??public void windowClosing(WindowEvent e){
System.exit(0);
??}
}

这里用到一个无名内部类，无名内部类是Java中内部类的一种灵活运用方式。

五、Java中线程及同步控制

线程概念的引入是为了实现并行处理，从而提高程序的效率。Java中的线程实现非常简单，可以用两种方式来创建线程，一种是实现Runnable接口，另一种是继承Thread类重写run()方法。两种方式唯一的不同就是前者保留了继承一个类的可能（因为Java只支持类的单继承，但接口没有此限制）。

　　永远都用start()方法来启动一个线程，线程类中的run()可以被直接调用，但决不是启动一个线程，二者有着本质的区别。

　　用同步控制关键字synchronized来保护线程敏感数据，synchronized块中的内容可以保证同一时刻只能被一个线程访问，所以其中的数据是线程安全的。

　　用Object类中的wait()和notify()方法可以实现线程间交互，但要记住wait()和notify()方法只有发生在同一个对象上才能真正实现线程间交互。被某一对象wait()方法阻塞的线程需要另外一个调用了同一对象notify()的线程干预才能恢复运行。notify()方法一次唤醒一个被wait()方法阻塞的线程，notifyAll()方法可以一次唤醒所有被wait()方法阻塞的线程。

　　六、Java本地方法（native方法）的实现

　　Java不是完美的，Java的不足除了体现在运行速度上要比传统的C++慢许多之外，Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。

　　可以将native方法比作Java程序同Ｃ程序的接口，其实现步骤：

　　１、在Java中声明native()方法，然后编译；
　　２、用javah产生一个.h文件；
　　３、写一个.cpp文件实现native导出方法，其中需要包含第二步产生的.h文件（注意其中又包含了JDK带的jni.h文件）；
　　４、将第三步的.cpp文件编译成动态链接库文件；
　　５、在Java中用System.loadLibrary()方法加载第四步产生的动态链接库文件，这个native()方法就可以在Java中被访问了。

　　上述所提及的一些Java技术具有一定的普遍性，它们基本上是在Java各个方面的运用中都需要掌握的术。实际上Java的运用非常广泛，而且每个方面都需要遵循不同的规范。以下是对Java应用的简要介绍。

（一）理解Java SDK的三个版本：

Java SDK Micro Edition (J2ME)

用于开发掌上电脑、手机等移动通信设备上使用的应用程序。并不是所有的移动设备都支持Java，只有具备J2ME运行环境（JVM+J2ME API)的设备才能运行Java程序。J2ME的集成开发工具（通常都有带有一些访真器）有 Sun 的J2ME Wireless Toolkit 、IBM的Visul Age Micro Edition 等。

Java SDK Standard Edition（J2SE)

主要用于开发一般台式机应用程序。我们平时所说的JDK就指J2SE，而我们学Java就是从学习J2SE开始的。

Java SDK Enterprise Edition (J2EE)

用于开发分布式的企业级大型应用程序。其中的核心是Entetprise Java Beans（EJB，分布式Java组件）的开发。

（二）Java小程序 （Applet)

Java 小程序是一个继承了Applet类并重写了init()、paint()、stop()等方法的的Java类，它被布署在Web服务器（如IIS）上，当客户端请求Web页时，浏览器从Web服务器上将其下载到本地客户端，然后，浏览器创建该Applet类的实例并调用其init()方法，从安全角度考虑，Applet没有访问本地文件的权限。由于Applet是被浏览器执行的，所以Applet不需要一个main()方法。实际上，除了Java Application之外，所有其它Java应用都不需要一个main()方法。

（三）服务器端Java小程序 （Servlet）

Servlet 也是一个Java类，和Applet形成对比，Servlet是运行于服务器端的Java小程序，而且Servlet需要一个单独的Web服务器（如 Tomcat）做容器。除此之外，Servlet中用到的一些类（如HttpServlet)并不包含在J2SE API中，所以需要将Servlet.jar（在Tomcat的common\lib文件夹下）加到环境变量中去。下面是一个简单的Servlet例子：

public class Myservlet extends HttpServlet{

??public void doGet(HttpServletRequest request,HttpServletResponse response)
{
??try{
response.setContentType("text/html";
PrintWriter out=response.getWriter();
out.println("");
out.println("");
out.println("Hello world");
out.println("");
out.println("");
??}catch(IOException e){}
}
}

将这个Class文件编译后放至Tomcat\webapps\examples\WEB-INF\classes下，然后在浏览器地址栏里输入http: //127.0.0.1:8080/examples/servlet/Myservlet即可看到 Hello world出现在浏览器中。

（四）Java Server Page （JSP）

同Servlet 相似的是，JSP运行于Web服务器端，并且也需要Tomcat之类的容器。不同的是，由于JSP是将Java代码嵌在html标记里（同ASP一样用 <% ...%>)，JSP的界面设计同后台开发人员的工作可以有效分离。可以想像让开发人员用Servlet写一个花捎的Web页面有多困难，所以 JSP+Servlet混合Web应用是比较理想的选择。

看起来JSP同ASP的实现机制大同小异，其实也存在着本质的区别。所有的 ASP页面都是解释运行的，而JSP页在第一次被请求时会被编译，再以后的客户请求都是直接运行服务器上的.class文件（在Tomcat的Work文件夹下），所以JSP要比ASP速度上快许多。

（五）Java Beans

Java Bean 是可复用的组件，对Java Bean并没有严格的规范，理论上讲，任何一个Java类都可以是一个Bean。但通常情况下，由于Java Bean是被容器所创建（如Tomcat)的，所以Java Bean应具有一个无参的构造器，另外，通常Java Bean还要实现Serializable接口用于实现Bean的持久性。

（六）Enterprise Java Beans （EJB）

Java Bean实际上相当于微软COM模型中的本地进程内COM组件，它是不能被跨进程访问的。Enterprise Java Bean 相当于DCOM，即分布式组件。它是基于Java的远程方法调用（RMI）技术的，所以EJB可以被远程访问（跨进程、跨计算机）。但EJB必须被布署在诸如Webspere、WebLogic这样的容器中，EJB客户从不直接访问真正的EJB组件，而是通过其容器访问。EJB容器是EJB组件的代理， EJB组件由容器所创建和管理。客户通过容器来访问真正的EJB组件。

这种模型很像COM+管理器，其实EJB容器正是起到COM+管理器的作用，只是EJB组件相对COM组件来说更易用、更安全。

总的说来，Java作为面象对象技术的一个代表，在当今商业应用中更容易开发出高效的、多层的分布式应用程序，而且，由于Java技术有很强的健壮性和易用性，加上同UML应用的结合，开发一个商业应用软件的周期会大大缩短，所以Java会有不错的前景。
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:10 发表评论
]]>(转载)Tomcat+JSP经典配置实例http://www.blogjava.net/lijiezjn/articles/94126.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:07:00 GMThttp://www.blogjava.net/lijiezjn/articles/94126.html
　　经常看到jsp的初学者问tomcat下如何配置jsp、servlet和bean的问题，于是总结了一下如何tomcat下配置jsp、servlet和ben，希望对那些初学者有所帮助。
　　
　　一、开发环境配置
　　
　　第一步：下载j2sdk和tomcat：到sun官方站（http://java.sun.com/j2se/1.5.0/download.jsp）下载j2sdk，注意下载版本为Windows Offline Installation的SDK，同时最好下载J2SE 1.5.0 Documentation，然后到tomcat官方站点（http: //jakarta.apache.org/site/downloads/downloads_tomcat-5.cgi）下载tomcat（下载最新 5.5.9版本的tomcat）；
　　
　　第二步：安装和配置你的j2sdk和tomcat：执行j2sdk和tomcat的安装程序，然后按默认设置进行安装即可。
　　
　　1.安装j2sdk以后，需要配置一下环境变量，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的j2sdk安装在c:\j2sdk1.5.0）：
　　
　　JAVA_HOME=c:\j2sdk1.5.0
　　classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;（.;一定不能少，因为它代表当前路径)
　　path=%JAVA_HOME%\bin
　　
　　接着可以写一个简单的java程序来测试J2SDK是否已安装成功：
　　
　　public class Test{
　　public static void main(String args[]){
　　System.out.println("This is a test program.");
　　}
　　}
　　
　　将上面的这段程序保存为文件名为Test.java的文件。
　　
　　然后打开命令提示符窗口，cd到你的Test.java所在目录，然后键入下面的命令
　　
　　javac Test.java
　　java Test
　　
　　此时如果看到打印出来This is a test program.的话说明安装成功了，如果没有打印出这句话，你需要仔细检查一下你的配置情况。
　　
　　2.安装Tomcat后，在我的电脑->属性->高级->环境变量->系统变量中添加以下环境变量(假定你的tomcat安装在c:\tomcat)：
　　
　　CATALINA_HOME=c:\tomcat
　　CATALINA_BASE=c:\tomcat
　　
　　然后修改环境变量中的classpath，把tomat安装目录下的common\lib下的(可以根据实际追加)servlet.jar追加到classpath中去，修改后的classpath如下：
　　
　　classpath=.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;%CATALINA_HOME%\common\lib\servlet.jar;
　　
　　接着可以启动tomcat，在IE中访问http://localhost:8080，如果看到tomcat的欢迎页面的话说明安装成功了。
　　
　　第三步：建立自己的jsp app目录
　　
　　1.到Tomcat的安装目录的webapps目录，可以看到ROOT，examples, tomcat-docs之类Tomcat自带的的目录；
　　2.在webapps目录下新建一个目录，起名叫myapp；
　　3.myapp下新建一个目录WEB-INF，注意，目录名称是区分大小写的；
　　4.WEB-INF下新建一个文件web.xml，内容如下：
　　
　　<?xml version="1.0" encoding="ISO-8859-1"?>
　　<!DOCTYPE web-app
　　PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
　　"http://java.sun.com/dtd/web-app_2_3.dtd">
　　<web-app>
　　<display-name>My Web Application</display-name>
　　<description>
　　A application for test.
　　</description>
　　</web-app>
　　
　　5.在myapp下新建一个测试的jsp页面，文件名为index.jsp，文件内容如下：
　　<html><body><center>
　　Now time is: <%=new java.util.Date()%>
　　</center></body></html>
　　
　　6.重启Tomcat
　　
　　7.打开浏览器，输入http://localhost:8080/myapp/index.jsp 看到当前时间的话说明就成功了。
　　
　　第四步：建立自己的Servlet：
　　
　　1.用你最熟悉的编辑器（建议使用有语法检查的java ide）新建一个servlet程序，文件名为Test.java，文件内容如下：
　　
　　package test;
　　import java.io.IOException;
　　import java.io.PrintWriter;
　　import javax.servlet.ServletException;
　　import javax.servlet.http.HttpServlet;
　　import javax.servlet.http.HttpServletRequest;
　　import javax.servlet.http.HttpServletResponse;
　　public class Test extends HttpServlet {
　　protected void doGet(HttpServletRequest request, HttpServletResponse response)
　　throws ServletException, IOException {
　　PrintWriter out=response.getWriter();
　　out.println("<html><body><h1>This is a servlet test.</h1></body></html>");
　　out.flush();
　　}
　　}
　　
　　2 .编译
　　将Test.java放在c:\test下，使用如下命令编译：
　　
　　C:\Test>javac Test.java
　　
　　然后在c:\Test下会产生一个编译后的servlet文件：Test.class
　　
　　3 .将结构test\Test.class剪切到%CATALINA_HOME%\webapps\myapp\WEB-INF\classes下，也就是剪切那个test目录到classes目录下，如果classes目录不存在，就新建一个。现在webapps\myapp\WEB-INF\classes下有test\Test.class的文件目录结构
　　
　　4 .修改webapps\myapp\WEB-INF\web.xml，添加servlet和servlet-mapping
　　
　　编辑后的web.xml如下所示，红色为添加的内容:
　　
　　<?xml version="1.0" encoding="ISO-8859-1"?>
　　<!DOCTYPE web-app
　　PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
　　"http://java.sun.com/dtd/web-app_2_3.dtd">
　　<web-app>
　　<display-name>My Web Application</display-name>
　　<description>
　　A application for test.
　　</description>
　　<servlet>
　　<servlet-name>Test</servlet-name>
　　<display-name>Test</display-name>
　　<description>A test Servlet</description>
　　<servlet-class>test.Test</servlet-class>
　　</servlet>
　　<servlet-mapping>
　　<servlet-name>Test</servlet-name>
　　<url-pattern>/Test</url-pattern>
　　</servlet-mapping>
　　</web-app>
　　
　　这段话中的servlet这一段声明了你要调用的Servlet，而servlet-mapping则是将声明的servlet"映射"到地址/Test上
　　
　　5 .好了，重启动Tomcat，启动浏览器，输入http://localhost:8080/myapp/Test 如果看到输出This is a servlet test.就说明编写的servlet成功了。
　　
　　注意：修改了web.xml以及新加了class，都要重启Tomcat
　　
　　第四步：建立自己的Bean：
　　
　　1.用你最熟悉的编辑器（建议使用有语法检查的java ide）新建一个java程序，文件名为TestBean.java，文件内容如下：
　　
　　package test;
　　public class TestBean{
　　private String name = null;
　　public TestBean(String strName_p){
　　this.name=strName_p;
　　}
　　public void setName(String strName_p){
　　this.name=strName_p;
　　}
　　public String getName(){
　　return this.name;
　　}
　　}
　　
　　2 .编译
　　
　　将TestBean.java放在c:\test下，使用如下命令编译：
　　
　　C:\Test>javac TestBean.java
　　
　　然后在c:\Test下会产生一个编译后的bean文件：TestBean.class
　　
　　3 .将TestBean.class文件剪切到 %CATALINA_HOME%\webapps\myapp\WEB-INF\classes\test下，
　　
　　4 .新建一个TestBean.jsp文件，文件内容为：
　　
　　<%@ page import="test.TestBean" %>
　　<html><body><center>
　　<%
　　TestBean testBean=new TestBean("This is a test java bean.");
　　%>
　　Java bean name is: <%=testBean.getName()%>
　　</center></body></html>
　　
　　5 .好了，重启Tomcat，启动浏览器，输入http://localhost:8080/myapp/TestBean.jsp 如果看到输出Java bean name is: This is a test java bean.就说明编写的Bean成功了。
　　
　　这样就完成了整个Tomcat下的jsp、servlet和javabean的配置。接下来需要做的事情就是多看书、多读别人的好代码，自己多动手写代码以增强自己在这方面开发的能力了。
　　
　　jvm应填写到
　　c:\j2sdk\bin
　　
　　给你一个简单的配置：：：：
　　
　　JSP环境配置心得
　　
　　首先要说的是，使用jdk+tomcat完全可以配置我们的jsp服务器，不再需要其实任何东东，有很多文章介绍了Apache，其实根本用不着，一般的学习调试tomcat完全可以胜任了。
　　
　　安装jdk后，tomcat在安装之前会自动找到jdk的安装路径，一路点击"下一步"，经过一段时间的文件复制，最后"close"，完成comcat的安装。
　　
　　您最好去下载一个版本较高的tomcat，比如4.1以上的，因为它不需要设置太多的系统变量，右击"我的电脑"，选择"属性"->"高级"- >"环境变量"->"系统变量"，新建一个TOMCAT_HOME，值设置成你的tomcat所在的路径，比如：D:\Program Files\Apache Group\Tomcat 5.5，配置完成。
　　
　　从开始菜单中找到tomcat选项，一般打开顺序是：开始->程序->Apache Tomcat 5.5，选择"Start Tomcat"，让jsp服务器开始运行，此时会打开一个类似Dos的窗口，会显示一些相关的信息。
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:07 发表评论
]]>(转载)Java学习之路：不走弯路，就是捷径http://www.blogjava.net/lijiezjn/articles/94125.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:06:00 GMThttp://www.blogjava.net/lijiezjn/articles/94125.html

0．引言

在ChinaITLAB导师制辅导中，笔者发现问得最多的问题莫过于"如何学习编程？Java该如何学习？"。类似的问题回答多了，难免会感觉厌烦，就萌生了写下本文的想法。到时候再有人问起类似的问题，我可以告诉他（她），请你去看看《Java学习之路》。拜读过台湾蔡学镛先生的《Java夜未眠》，有些文章如《Java学习之道》等让我们确实有共鸣，本文题目也由此而来。

软件开发之路是充满荆棘与挑战之路,也是充满希望之路。 Java学习也是如此，没有捷径可走。梦想像《天龙八部》中虚竹一样被无崖子醍醐灌顶而轻松获得一甲子功力，是很不现实的。每天仰天大叫"天神啊，请赐给我一本葵花宝典吧"，殊不知即使你获得了葵花宝典，除了受自宫其身之苦外，你也不一定成得了"东方不败"，倒是成"西方失败"的几率高一点。

"不走弯路，就是捷径"，佛经说的不无道理。

1．如何学习程序设计？

Java是一种平台，也是一种程序设计语言，如何学好程序设计不仅仅适用于Java，对C++等其他程序设计语言也一样管用。有编程高手认为，Java也好C也好没什么分别，拿来就用。为什么他们能达到如此境界？我想是因为编程语言之间有共通之处，领会了编程的精髓，自然能够做到一通百通。如何学习程序设计理所当然也有许多共通的地方。

1.1　培养兴趣

兴趣是能够让你坚持下去的动力。如果只是把写程序作为谋生的手段的话，你会活的很累，也太对不起自己了。多关心一些行业趣事，多想想盖茨。不是提倡天天做白日梦，但人要是没有了梦想，你觉得有味道吗？可能像许多深圳本地农民一样，打打麻将，喝喝功夫茶，拜拜财神爷；每个月就有几万十几万甚至更多的进帐，凭空多出个"食利阶层"。你认为，这样有味道吗？有空多到一些程序员论坛转转，你会发现，他们其实很乐观幽默，时不时会冒出智慧的火花。

1.2　慎选程序设计语言

男怕入错行，女怕嫁错郎。初学者选择程序设计语言需要谨慎对待。软件开发不仅仅是掌握一门编程语言了事，它还需要其他很多方面的背景知识。软件开发也不仅仅局限于某几个领域，而是已经渗透到了各行各业几乎每一个角落。

如果你对硬件比较感兴趣，你可以学习C语言/汇编语言，进入硬件开发领域。如果你对电信的行业知识及网络比较熟悉，你可以在C/C++等之上多花时间，以期进入电信软件开发领域。如果你对操作系统比较熟悉，你可以学习C/Linux等等,为Linux内核开发/驱动程序开发/嵌入式开发打基础。

如果你想介入到应用范围最广泛的应用软件开发（包括电子商务电子政务系统）的话，你可以选择J2EE或.NET，甚至LAMP组合。每个领域要求的背景知识不一样。做应用软件需要对数据库等很熟悉。总之，你需要根据自己的特点来选择合适你的编程语言。

1.3　要脚踏实地,快餐式的学习不可取

先分享一个故事。

有一个小朋友，他很喜欢研究生物学，很想知道那些蝴蝶如何从蛹壳里出来，变成蝴蝶便会飞。有一次，他走到草原上面看见一个蛹，便取了回家，然后看着，过了几天以后，这个蛹出了一条裂痕，看见里面的蝴蝶开始挣扎，想抓破蛹壳飞出来。这个过程达数小时之久，蝴蝶在蛹里面很辛苦地拼命挣扎，怎么也没法子走出来。这个小孩看着看着不忍心，就想不如让我帮帮它吧，便随手拿起剪刀在蛹上剪开，使蝴蝶破蛹而出。但蝴蝶出来以后，因为翅膀不够力，变得很臃肿，飞不起来。

这个故事给我们的启示是：欲速则不达。

浮躁是现代人最普遍的心态，能怪谁？也许是贫穷落后了这么多年的缘故，就像当年的大跃进一样，都想大步跨入共产主义社会。现在的软件公司、客户、政府、学校、培训机构等等到处弥漫着浮躁之气。就拿笔者比较熟悉的深圳IT培训行业来说吧，居然有的打广告宣称"参加培训，100%就业"，居然报名的学生不少，简直是藐视天下程序员。社会环境如是，我们不能改变，只能改变自己,闹市中的安宁，弥足珍贵。许多初学者C++/Java没开始学，立马使用 VC/JBuilder,会使用VC/JBuilder开发一个Hello World程序，就忙不迭的向世界宣告，"我会软件开发了"，简历上也大言不惭地写上"精通VC/Java"。结果到软件公司面试时要么被三两下打发走了，要么被驳的体无完肤，无地自容。到处碰壁之后才知道捧起《C++编程思想》《Java编程思想》仔细钻研，早知如此何必当初呀。

"你现在讲究简单方便，你以后的路就长了"，好象也是佛经中的劝戒。

1.4　多实践,快实践

彭端淑的《为学一首示子侄》中有穷和尚与富和尚的故事。

从前，四川边境有两个和尚，一个贫穷，一个有钱。一天，穷和尚对富和尚说："我打算去南海朝圣，你看怎么样？"富和尚说："这里离南海有几千里远，你靠什么去呢？"穷和尚说："我只要一个水钵，一个饭碗就够了。"富和尚为难地说："几年前我就打算买条船去南海，可至今没去成，你还是别去吧！ " 一年以后，富和尚还在为租赁船只筹钱，穷和尚却已经从南海朝圣回来了。

这个故事可解读为：任何事情，一旦考虑好了，就要马上上路，不要等到准备周全之后，再去干事情。假如事情准备考虑周全了再上路的话，别人恐怕捷足先登了。软件开发是一门工程学科，注重的就是实践，"君子动口不动手"对软件开发人员来讲根本就是错误的，他们提倡"动手至上"，但别害怕，他们大多温文尔雅，没有暴力倾向，虽然有时候蓬头垢面的一副"比尔盖茨"样。有前辈高人认为，学习编程的秘诀是：编程、编程、再编程，笔者深表赞同。不仅要多实践，而且要快实践。我们在看书的时候，不要等到你完全理解了才动手敲代码，而是应该在看书的同时敲代码，程序运行的各种情况可以让你更快更牢固的掌握知识点。

1.5　多参考程序代码

程序代码是软件开发最重要的成果之一，其中渗透了程序员的思想与灵魂。许多人被《仙剑奇侠传》中凄美的爱情故事感动,悲剧的结局更有一种缺憾美。为什么要以悲剧结尾？据说是因为写《仙剑奇侠传》的程序员失恋而安排了这样的结局，他把自己的感觉融入到游戏中，却让众多的仙剑迷扼腕叹息。

多多参考代码例子，对Java而言有参考文献[4.3],有API类的源代码(JDK安装目录下的src.zip文件)，也可以研究一些开源的软件或框架。

1.6　加强英文阅读能力

对学习编程来说，不要求英语, 但不能一点不会,。最起码像Java API文档(参考文献[4.4])这些东西还是要能看懂的,连猜带懵都可以；旁边再开启一个"金山词霸"。看多了就会越来越熟练。在学Java的同时学习英文，一箭双雕多好。另外好多软件需要到英文网站下载，你要能够找到它们，这些是最基本的要求。英语好对你学习有很大的帮助。口语好的话更有机会进入管理层，进而可以成为剥削程序员的"周扒皮"。

1.7　万不得已才请教别人

笔者在ChinaITLab网校的在线辅导系统中解决学生问题时发现，大部分的问题学生稍做思考就可以解决。请教别人之前，你应该先回答如下几个问题。

你是否在google中搜索了问题的解决办法？

你是否查看了Java API文档？

你是否查找过相关书籍？

你是否写代码测试过？

如果回答都是"是"的话，而且还没有找到解决办法，再问别人不迟。要知道独立思考的能力对你很重要。要知道程序员的时间是很宝贵的。

1.8　多读好书

书中自有颜如玉。比尔?盖茨是一个饱读群书的人。虽然没有读完大学，但九岁的时候比尔?盖茨就已经读完了所有的百科全书，所以他精通天文、历史、地理等等各类学科，可以说比尔?盖茨不仅是当今世界上金钱的首富，而且也可以称得上是知识的巨富。

笔者在给学生上课的时候经常会给他们推荐书籍，到后来学生实在忍无可忍开始抱怨，"天呐，这么多书到什么时候才能看完了"，"学软件开发，感觉上了贼船 "。这时候，我的回答一般是，"别着急，什么时候带你们去看看我的书房，到现在每月花在技术书籍上的钱400元，这在软件开发人员之中还只能够算是中等的 "，学生当场晕倒。（注：这一部分学生是刚学软件开发的）

对于在Java开发领域的好书在笔者另外一篇文章中会专门点评。该文章可作为本文的姊妹篇。

1.9　使用合适的工具

工欲善其事必先利其器。软件开发包含各种各样的活动，需求收集分析、建立用例模型、建立分析设计模型、编程实现、调试程序、自动化测试、持续集成等等，没有工具帮忙可以说是寸步难行。工具可以提高开发效率，使软件的质量更高BUG更少。组合称手的武器。到飞花摘叶皆可伤人的境界就很高了，无招胜有招，手中无剑心中有剑这样的境界几乎不可企及。在笔者另外一篇文章中会专门阐述如何选择合适的工具（该文章也可作为本文的姊妹篇）。

2．软件开发学习路线

两千多年的儒家思想孔孟之道，中庸的思想透入骨髓，既不冒进也不保守并非中庸之道，而是找寻学习软件开发的正确路线与规律。

从软件开发人员的生涯规划来讲，我们可以大致分为三个阶段，软件工程师→软件设计师→架构设计师或项目管理师。不想当元帅的士兵不是好士兵，不想当架构设计师或项目管理师的程序员也不是好的程序员。我们应该努力往上走。让我们先整理一下开发应用软件需要学习的主要技术。

A．基础理论知识，如操作系统、编译原理、数据结构与算法、计算机原理等，它们并非不重要。如不想成为计算机科学家的话，可以采取"用到的时候再来学"的原则。

B．一门编程语言，现在基本上都是面向对象的语言，Java/C++/C#等等。如果做WEB开发的话还要学习HTML/JavaScript等等。

C．一种方法学或者说思想，现在基本都是面向对象思想（OOA/OOD/设计模式）。由此而衍生的基于组件开发CBD/面向方面编程AOP等等。

D．一种关系型数据库，ORACLE/SqlServer/DB2/MySQL等等

E．一种提高生产率的IDE集成开发环境JBuilder/Eclipse/VS.NET等。

F．一种UML建模工具，用ROSE/VISIO/钢笔进行建模。

G．一种软件过程，RUP/XP/CMM等等，通过软件过程来组织软件开发的众多活动，使开发流程专业化规范化。当然还有其他的一些软件工程知识。

H．项目管理、体系结构、框架知识。

正确的路线应该是：B→C→E→F→G→H。

还需要补充几点：

1）．对于A与C要补充的是，我们应该在实践中逐步领悟编程理论与编程思想。新技术虽然不断涌现，更新速度令人眼花燎乱雾里看花；但万变不离其宗，编程理论与编程思想的变化却很慢。掌握了编程理论与编程思想你就会有拨云见日之感。面向对象的思想在目前来讲是相当关键的，是强势技术之一，在上面需要多投入时间，给你的回报也会让你惊喜。

2）．对于数据库来说是独立学习的，这个时机就由你来决定吧。

3）．编程语言作为学习软件开发的主线，而其余的作为辅线。

4）．软件工程师着重于B、C、E、D；软件设计师着重于B、C、E、D、F；架构设计师着重于C、F、H。

3．如何学习Java?

3.1 Java学习路线

3.1.1 基础语法及Java原理

基础语法和Java原理是地基，地基不牢靠，犹如沙地上建摩天大厦，是相当危险的。学习Java也是如此，必须要有扎实的基础，你才能在 J2EE、 J2ME领域游刃有余。参加SCJP（SUN公司认证的Java程序员）考试不失为一个好方法，原因之一是为了对得起你交的1200大洋考试费，你会更努力学习，原因之二是SCJP考试能够让你把基础打得很牢靠，它要求你跟JDK一样熟悉Java基础知识；但是你千万不要认为考过了SCJP就有多了不起，就能够获得软件公司的青睐，就能够获取高薪，这样的想法也是很危险的。获得"真正"的SCJP只能证明你的基础还过得去，但离实际开发还有很长的一段路要走。

3.1.2 OO思想的领悟

掌握了基础语法和Java程序运行原理后，我们就可以用Java语言实现面向对象的思想了。面向对象，是一种方法学;是独立于语言之外的编程思想;是CBD基于组件开发的基础;属于强势技术之一。当以后因工作需要转到别的面向对象语言的时候，你会感到特别的熟悉亲切，学起来像喝凉水这么简单。

使用面向对象的思想进行开发的基本过程是：

●调查收集需求。

●建立用例模型。

●从用例模型中识别分析类及类与类之间的静态动态关系，从而建立分析模型。

●细化分析模型到设计模型。

●用具体的技术去实现。

●测试、部署、总结。

3.1.3 基本API的学习

进行软件开发的时候，并不是什么功能都需要我们去实现，也就是经典名言所说的"不需要重新发明轮子"。我们可以利用现成的类、组件、框架来搭建我们的应用，如SUN公司编写好了众多类实现一些底层功能，以及我们下载过来的JAR文件中包含的类,我们可以调用类中的方法来完成某些功能或继承它。那么这些类中究竟提供了哪些方法给我们使用？方法的参数个数及类型是？类的构造器需不需要参数？总不可能SUN公司的工程师打国际长途甚至飘洋过海来告诉你他编写的类该如何使用吧。他们只能提供文档给我们查看，Java DOC文档（参考文献4.4）就是这样的文档，它可以说是程序员与程序员交流的文档。

基本API指的是实现了一些底层功能的类，通用性较强的API，如字符串处理/输入输出等等。我们又把它成为类库。熟悉API的方法一是多查Java DOC文档（参考文献4.4），二是使用JBuilder/Eclipse等IDE的代码提示功能。

3.1.4 特定API的学习

Java介入的领域很广泛，不同的领域有不同的API，没有人熟悉所有的API，对一般人而言只是熟悉工作中要用到的API。如果你做界面开发，那么你需要学习Swing/AWT/SWT等API；如果你进行网络游戏开发，你需要深入了解网络API/多媒体API/2D3D等；如果你做 WEB开发，就需要熟悉Servlet等API啦。总之，需要根据工作的需要或你的兴趣发展方向去选择学习特定的API。

3.1.5 开发工具的用法

在学习基础语法与基本的面向对象概念时，从锻炼语言熟练程度的角度考虑，我们推荐使用的工具是 Editplus/JCreator+JDK,这时候不要急于上手JBuilder/Eclipse等集成开发环境，以免过于关注IDE的强大功能而分散对Java技术本身的注意力。过了这一阶段你就可以开始熟悉IDE了。

程序员日常工作包括很多活动，编辑、编译及构建、调试、单元测试、版本控制、维持模型与代码同步、文档的更新等等，几乎每一项活动都有专门的工具，如果独立使用这些工具的话，你将会很痛苦，你需要在堆满工具的任务栏上不断的切换，效率很低下，也很容易出错。在JBuilder、 Eclipse等IDE中已经自动集成编辑器、编译器、调试器、单元测试工具 JUnit、自动构建工具ANT、版本控制工具CVS、DOC文档生成与更新等等，甚至可以把UML建模工具也集成进去，又提供了丰富的向导帮助生成框架代码，让我们的开发变得更轻松。应该说IDE发展的趋势就是集成软件开发中要用到的几乎所有工具。

从开发效率的角度考虑，使用IDE是必经之路，也是从一个学生到一个职业程序员转变的里程碑。

Java开发使用的IDE主要有Eclipse、JBuilder、JDeveloper、NetBeans等几种；而Eclipse、 JBuilder占有的市场份额是最大的。JBuilder在近几年来一直是Java集成开发环境中的霸主，它是由备受程序员尊敬的Borland公司开发，在硝烟弥漫的Java IDE大战中,以其快速的版本更新击败IBM的Visual Age for Java等而成就一番伟业。IBM在Visual Age for Java上已经无利可图之下，干脆将之贡献给开源社区，成为Eclipse的前身，真所谓"柳暗花明又一村"。浴火重生的Eclipse以其开放式的插件扩展机制、免费开源获得广大程序员（包括几乎所有的骨灰级程序员）的青睐，极具发展潜力。

3.1.6 学习软件工程

对小型项目而言，你可能认为软件工程没太大的必要。随着项目的复杂性越来越高，软件工程的必要性才会体现出来。参见"软件开发学习路线"小节。

3.2学习要点

确立的学习路线之后，我们还需要总结一下Java的学习要点，这些要点在前文多多少少提到过，只是笔者觉得这些地方特别要注意才对它们进行汇总，不要嫌我婆婆妈妈啊。

3.2.1勤查API文档

当程序员编写好某些类，觉得很有成就感,想把它贡献给各位苦难的同行。这时候你要使用"Javadoc"工具（包含在JDK中）生成标准的 Java DOC文档,供同行使用。J2SE/J2EE/J2ME的DOC文档是程序员与程序员交流的工具，几乎人手一份，除了菜鸟之外。J2SE DOC文档官方下载地址：http://Java.sun.com/j2se/1.5.0/download.jsp，你可以到google搜索CHM版本下载。也可以在线查看：http://Java.sun.com/j2se/1.5.0/docs/api/index.html。

对待DOC文档要像毛主席语录，早上起床念一遍，吃饭睡觉前念一遍。

当需要某项功能的时候，你应该先查相应的DOC文档看看有没有现成的实现，有的话就不必劳神费心了直接用就可以了，找不到的时候才考虑自己实现。使用步骤一般如下：

●找特定的包，包一般根据功能组织。

●找需要使用类，类命名规范的话我们由类的名字可猜出一二。

●选择构造器，大多数使用类的方式是创建对象。

●选择你需要的方法。

3.2.2 查书/google->写代码测试->查看源代码->请教别人

当我们遇到问题的时候该如何解决？

这时候不要急着问别人，太简单的问题，没经过思考的问题，别人会因此而瞧不起你。可以先找找书，到google中搜一下看看，绝大部分问题基本就解决了。而像"某些类/方法如何使用的问题"，DOC文档就是答案。对某些知识点有疑惑是，写代码测试一下，会给你留下深刻的印象。而有的问题，你可能需要直接看API的源代码验证你的想法。万不得已才去请教别人。

3.2.3学习开源软件的设计思想

Java领域有许多源代码开放的工具、组件、框架，JUnit、ANT、Tomcat、 Struts、Spring、Jive论坛、PetStore宠物店等等多如牛毛。这些可是前辈给我们留下的瑰宝呀。入宝山而空手归，你心甘吗？对这些工具、框架进行分析，领会其中的设计思想，有朝一日说不定你也能写一个XXX框架什么的，风光一把。分析开源软件其实是你提高技术、提高实战能力的便捷方法。

3.2.4 规范的重要性

没有规矩，不成方圆。这里的规范有两层含义。第一层含义是技术规范，多到 http://www.jcp.org下载JSRXXX规范，多读规范，这是最权威准确最新的教材。第二层含义是编程规范，如果你使用了大量的独特算法，富有个性的变量及方法的命名方式；同时，没给程序作注释，以显示你的编程功底是多么的深厚。这样的代码别人看起来像天书，要理解谈何容易，更不用说维护了，必然会被无情地扫入垃圾堆。Java编码规范到此查看或下载http://Java.sun.com/docs/codeconv/，中文的也有，啊，还要问我在哪，请参考3.2.2节。

3.2.5 不局限于Java

很不幸，很幸运，要学习的东西还有很多。不幸的是因为要学的东西太多且多变，没时间陪老婆家人或女朋友，导致身心疲惫，严重者甚至导致抑郁症。幸运的是别人要抢你饭碗绝非易事，他们或她们需要付出很多才能达成心愿。

Java不要孤立地去学习，需要综合学习数据结构、OOP、软件工程、UML、网络编程、数据库技术等知识，用横向纵向的比较联想的方式去学习会更有效。如学习Java集合的时候找数据结构的书看看；学JDBC的时候复习数据库技术；采取的依然是"需要的时候再学"的原则。

4．结束语

需要强调的是，学习软件开发确实有一定的难度，也很辛苦，需要付出很多努力，但千万不要半途而废。本文如果能对一直徘徊在Java神殿之外的朋友有所帮助的话，笔者也欣慰了。哈哈，怎么听起来老气横秋呀？没办法，在电脑的长期辐射之下，都快变成小老头了。最后奉劝各位程序员尤其是MM程序员，完成工作后赶快远离电脑，据《胡播乱报》报道，电脑辐射会在白皙的皮肤上面点缀一些小黑点，看起来鲜艳无比……

(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:06 发表评论
]]>(转载)成为编程高手的八大奥秘http://www.blogjava.net/lijiezjn/articles/94120.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:04:00 GMThttp://www.blogjava.net/lijiezjn/articles/94120.html

    教我的老师，是一个编程专家.第一看到他真的不能把他同专家联系在一起！呵呵！平常多跟他交流只后才发现老师平实的后面藏着许多我摸不透的东西！！以下的文章虽然不是我自己总结出来的！但是我想这也每一个想成为编程好手的人所要具备的！！

1、扎实的基础

数据结构、离散数学、编译原理，这些是所有计算机学科的基础，如果不掌握它们，很难写出高水平的程序。程序人人都会写，但当你发现写到一定程度很难再提高的时候，就应该想想是不是要回过头来学学这些最基本的理论。不要一开始就去学OOP，即使你再精通OOP，遇到一些基本算法的时候可能也会束手无策。因此多读一些计算机基础理论方面的书籍是非常有必要的。

2、丰富的想像力

不要拘泥于固定的思维方式，遇到问题的时候要多想几种解决问题的方案，试试别人从没想过的方法。丰富的想像力是建立在丰富的知识的基础上，除计算机以外，多涉猎其他的学科，比如天文、物理、数学等等。开阔的思维对程序员来说很重要。

3、最简单的是最好的

这也许是所有科学都遵循的一条准则，复杂的质能转换原理在爱因斯坦眼里不过是一个简单得不能再简单的公式：E=mc2。简单的方法更容易被人理解，更容易实现，也更容易维护。遇到问题时要优先考虑最简单的方案，只有简单方案不能满足要求时再考虑复杂的方案。

4、不钻牛角尖

当你遇到障碍的时候，不妨暂时远离电脑，看看窗外的风景，听听轻音乐，和朋友聊聊天。当我遇到难题的时候会去玩游戏，当负责游戏的那部分大脑细胞极度亢奋的时候，负责编程的那部分大脑细胞就得到了充分的休息。当重新开始工作的时候，我会发现那些难题现在竟然可以迎刃而解。

5、对答案的渴求

人类自然科学的发展史就是一个渴求得到答案的过程，即使只能知道答案的一小部分也值得我们去付出。只要你坚定信念，一定要找到问题的答案，你才会付出精力去探索，即使最后没有得到答案，在过程中你也会学到很多东西。

6、多与别人交流

三人行必有我师，也许在一次和别人不经意的谈话中，就可以迸出灵感的火花。多上上网，看看别人对同一问题的看法，会给你很大的启发。

7、良好的编程风格

注意养成良好的习惯，代码的缩进编排，变量的命名规则要始终保持一致。大家都知道如何排除代码中错误，却往往忽视了对注释的排错。注释是程序的一个重要组成部分，它可以使你的代码更容易理解，而如果代码已经清楚地表达了你的思想，就不必再加注释了，如果注释和代码不一致，那就更加糟糕。

8、韧性和毅力

这也许是“高手”和一般程序员最大的区别。高手们并不是天才，他们是在无数个日日夜夜中磨炼出来的。成功能给我们带来无比的喜悦，但过程却是无比的枯燥乏味。你不妨做个测试，找个10000以内的素数表，把它们全都抄下来，然后再检查三遍，如果能够不间断地完成这一工作，你就可以满足这一条。



张江宁的个人博客 2007-01-16 10:04 发表评论
]]>(转)菜鸟初学Java的备忘录之第一次接触http://www.blogjava.net/lijiezjn/articles/94118.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 02:02:00 GMThttp://www.blogjava.net/lijiezjn/articles/94118.html
　　虽然以前间或的也看了些书籍，但多是隔靴搔痒，上不了正席，绝不敢说自己懂Java。接触一门新的技术和初恋一样，都是第一次，但不同的是后者一般开始无比甜蜜，结局却很痛苦，而前者则往往开始很痛苦，越到后来却越是有味，简直是欲罢不能.现在我就正处于这个很痛苦的阶段，连一个最简单的 Helloworld都运行不出来，总是提示Excepion in thread "main" java.lan.NoClassDefFoundError. 只好上网去查，去搜.记性又不好，所以搜出来赶紧保存下来，常备无患。

　　一般来说安装完JDK之后，一定要按一下步骤配置，才可正确编译运行(假定jdk版本为1.4.0)。

　　1.将jdk1.4.0-安装在自己机器的某个盘符的根目录下，如：可安装在C:\jdk下。

　　***(以下出现的c:\jdk改为你自己安装JDK的目录)***

　　2.如果你的运行环境是win98，则在C盘根目录下，autoexec.bat文件中，加入下面两条语句：

set Path=%PATH%;c:\jdk\bin
set CLASSPATH=.;c:\jdk\lib\dt.jar;c:\jdk\lib\tools.jar保存后，重新启动机器，就完成了jdk1.4的安装。

　　3.如果你的运行环境是win2000的话，则需在“控制面板”的“系统”下，“高级”选项的“环境变量”中，添加两个用户变量。

　　其中一个用户变量的名称为“path”，值为“.;d:\j2sdk1.4.0_01\bin”，另一个用户变量的名称为"CLASSPATH"，值为 “.;d"\j2sdk1.4.0_01\lib\dt.jar;d:\j2sdk1.4.0_01\lib\tools.jar”，单击“确定”即可。即完成了jdk1.4.0的安装。

　　至于这样做的意义何在，我想应该是让Java系统在编译字节代码(.java)的时候需要一个什么东东的支持，如果你不告诉它这个东东放在哪个地方的话，它就犯傻了?!

　　看到屏幕上终于显示出Hello world对我来说意义重大.这是我近一年来写的第一个程序!再次踏上程序之路，简直有恍如隔世的感觉，已经快找不准我的位置了。还好原来学的一些关于C ++和面向对象的皮毛没忘光光，所以费点周折熟悉了JDK的环境之后，接下来的事情就好办多了，心里也踏实多了。

　　用String类直接定义字符串变量比起C中讨厌的指针，感觉确实好的多，用惯了Object Pascal的我，如果再回去数* *，真要疯掉不可。

　　数组的定义和C，C++好像略有不同，记不清了，先记下来再说

int[] number=new int[5]
String[] message=new String[5]

　　变量这一部分想起来要交待的也就这么多吧。虽然是菜鸟，但我也知道，总是如谭浩强般在语法上面死抠的人简直是白痴:大多数情况下，漂亮的程序根本不需要无谓的点缀，工工整整，思路清晰就可以了。

　　倒是对于Java程序的框架我倒想备忘一下，一个简单的java程序好像是应该是这样的框架：

class ProgramName
{
　public static void main(String【】 args)
　{
　　file&://程序的主体
　}

　public static int othermethod()
　{
　　file&://其它方法
　}
}

　　整个程序在一个大的类中，这个类的概念应该就跟pascal里面的单元差不多的。同pascal一样，文件名也要与单元名-在这里是类名-一样.Java对大小写要求的非常严格，我语法错了好几次都是因为这个.

　　Java程序就是由一个或者多个或者很多个方法在这样一个大类当中组成的.

　　在如上的代码中，定义方法的参数表示的意思分别为:

　　public表示此成员函数是公有的，可以被其他类直接调用 static表示main成员函数在ProgramName类的所有对象中是唯一的，Java将为其分配永久存储空间

　　关于Static，我想再延伸一下。有时候我们创建一个类，希望这个类的所有实例都公用一个变量，也就是说，所有这个类的对象都只有实例变量的一个 Copy.那么这样一个静态实例变量的内存就不能在创建类的实例的时候分配了，因为大家用的都是这么一个，不需要再重新分配.因此Java为其分配永久存储空间。

　　比如：

class Block{
　static int number=50
}

　　这样定义之后，所有Block类的实例，不管是Block1，还是Block2，它们都访问同一个number.这个number叫做类的变量，而不是实例变量.实际上静态变量又叫做类变量。

　　继续深入：用Static定义的静态成员函数或者静态变量，可以通过其所属类名来直接调用.为什么可以这样?因为既然这个类的所有对象都是使用的这一个变量，那么理所当然我不需要去从其中的任何一个对象去引用它，而只是通过类名引用就可以了嘛.这样不是可以方便的实现一些全局函数和全局变量吗?把所有全局的函数或者全局的变量都定义在一个静态类中，调用的时候直接通过这一个类名就可以方便的访问所有的全局变量和全局函数了。

　　定义所有程序都要访问的全局变量需要使用

public final static

　　另外碰到一个初学者经常会遇到的问题

non-static variable mainframe cannot be referenced from a static context

　　即在静态方法中不能引用非静态变量

　　为什么？

　　因为我们知道静态的方法可以在没有创建实例时使用，而申明为非静态的成员变量是一个对象属性，它只有在对象存在时引用，因此如果在对象未创建实例时我们在静态方法中调用了非静态成员方法自然是非法的，所以编译器会在这种时候给各错误.

　　简单说来，静态方法可以不用创建对象就调用，非静态方法必须有了对象的实例才能调用.因此想在静态方法中引用非静态方法是不可能的，因为它究竟引用的是哪个对象的非静态方法呢?编译器不可能给出答案，因为没有对象啊，所以要报错.

　　最后我们看看Think in Java里面的精辟阐述，这个问题我想就非常非常的清楚了

　　static关键字

　　通常，我们创建类时会指出那个类的对象的外观与行为。除非用new创建那个类的一个对象，否则实际上并未得到任何东西。只有执行了new后，才会正式生成数据存储空间，并可使用相应的方法。

　　但在两种特殊的情形下，上述方法并不堪用。一种情形是只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象。另一种情形是我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。为满足这两方面的要求，可使用 static（静态）关键字。一旦将什么东西设为static，数据或方法就不会同那个类的任何对象实例联系到一起。所以尽管从未创建那个类的一个对象，仍能调用一个static方法，或访问一些static数据。而在这之前，对于非static数据和方法，我们必须创建一个对象，并用那个对象访问数据或方法。这是由于非static数据和方法必须知道它们操作的具体对象。当然，在正式使用前，由于static方法不需要创建任何对象，所以它们不可简单地调用其他那些成员，同时不引用一个已命名的对象，从而直接访问非static成员或方法（因为非static成员和方法必须同一个特定的对象关联到一起）。

　　Whoops！现在应该回到主干上来了

　　void 表示方法返回的值的类型为空。如果返回特定的类型的话，则该方法实际上就是函数，否则就是一个过程而已.
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 10:02 发表评论
]]>(转载)真正的Java学习从入门到精通http://www.blogjava.net/lijiezjn/articles/94113.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 01:54:00 GMThttp://www.blogjava.net/lijiezjn/articles/94113.html
　　一、 工具篇JDK (Java Development Kit)
　　JDK是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库(rt.jar)。不论什么Java应用服务器实质都是内置了某个版本的JDK。因此掌握 JDK是学好Java的第一步。最主流的JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开发了自己的JDK，例如IBM公司开发的JDK，BEA公司的Jrocket，还有GNU组织开发的JDK等等。其中IBM的JDK包含的JVM（Java Virtual Machine）运行效率要比Sun JDK包含的JVM高出许多。而专门运行在x86平台的Jrocket在服务端运行效率也要比Sun JDK好很多。但不管怎么说，我们还是需要先把Sun JDK掌握好。
　　
　　1、 JDK的下载和安装
　　
　　JDK 又叫做J2SE（Java2 SDK Standard Edition），可以从Sun的Java网站上下载到，http://java.sun.com/j2se/downloads.html ，JDK当前最新的版本是J2SDK1.4.2，建议下载该版本的JDK，下载页面在这里：http: //java.sun.com/j2se/1.4.2/download.html。下载好的JDK是一个可执行安装程序，默认安装完毕后会在C:\ Program Files\Java\目录下安装一套JRE（供浏览器来使用），在C:\j2sdk1.4.2下安装一套JDK（也包括一套JRE）。然后我们需要在环境变量PATH的最前面增加java的路径C:\j2sdk1.4.2\bin。这样JDK就安装好了。
　　
　　2、 JDK的命令工具
　　
　　JDK的最重要命令行工具：
　　
　　java： 启动JVM执行class
　　javac： Java编译器
　　jar： Java打包工具
　　javadoc： Java文档生成器
　　
　　这些命令行必须要非常非常熟悉，对于每个参数都要很精通才行。对于这些命令的学习，JDK Documentation上有详细的文档。
　　
　　二、 JDK Documentation
　　Documentation在JDK的下载页面也有下载连接，建议同时下载Documentation。Documentation是最最重要的编程手册，涵盖了整个Java所有方面的内容的描述。可以这样说，学习Java编程，大部分时间都是花在看这个Documentation上面的。我是随身携带的，写Java代码的时候，随时查看，须臾不离手。
　　
　　三、 应用服务器(App Server)
　　App Server是运行Java企业组件的平台，构成了应用软件的主要运行环境。当前主流的App Server是BEA公司的Weblogic Server和IBM公司的Websphere以及免费的Jboss，选择其中一个进行学习就可以了，个人推荐Weblogic，因为它的体系结构更加干净，开发和部署更加方便，是Java企业软件开发人员首选的开发平台。下面简要介绍几种常用的App Server：
　　
　　1、 Tomcat
　　
　　Tomcat严格意义上并不是一个真正的App Server，它只是一个可以支持运行Serlvet/JSP的Web容器，不过Tomcat也扩展了一些App Server的功能，如JNDI，数据库连接池，用户事务处理等等。Tomcat被非常广泛的应用在中小规模的Java Web应用中，因此本文做一点下载、安装和配置Tomcat的介绍：
　　
　　Tomcat是Apache组织下Jakarta项目下的一个子项目，它的主网站是：http://jakarta.apache.org/tomcat/ ，Tomcat最新版本是Tomcat4.1.27，软件下载的连接是：http: //www.apache.org/dist/jakarta/tomcat-4/binaries/ 。
　　
　　下载Tomcat既可以直接下载zip包，也可以下载exe安装包（个人建议zip更干净些），不管哪种情况，下载完毕安装好以后（zip直接解压缩就可以了）。需要设置两个环境变量：
　　
　　JAVA_HOME=C:\j2sdk1.4.2
　　CATALINA_HOME=D:\tomcat4 (你的Tomcat安装目录)
　　
　　这样就安装好了，启动Tomcat运行CATALINA_HOME\bin\startup.bat，关闭Tomcat运行shutdown.bat脚本。Tomcat启动以后，默认使用8080端口，因此可以用浏览器访问http://localhost:8080来测试Tomcat是否正常启动。
　　
　　Tomcat提供了两个Web界面的管理工具，URL分别是：
　　
　　http://localhost:8080/admin/index.jsp
　　
　　http://localhost:8080/manager/html
　　
　　在启用这两个管理工具之前，先需要手工配置一下管理员用户和口令。用一个文本工具打开CATALINA_HOME\conf\tomcat-users.xml这个文件，加入如下几行：
　　
　　<role rolename="manager"/>
　　<role rolename="admin"/>
　　<user username="robbin" password="12345678" roles="admin,manager,tomcat"/>
　　
　　这样用户“robbin”就具备了超级管理员权限。重新启动Tomcat以后，你就可以使用该用户来登陆如上的两个管理工具，通过Web方式进行Tomcat的配置和管理了。
　　
　　2、 BEA Weblogic
　　
　　Weblogic可以到BEA的网站上免费注册之后下载到最新的Weblogic8.1企业版，License可以免费使用1年时间，其实这已经完全足够了。Weblogic的下载连接：http://commerce.bea.com/index.jsp，.../edocs.bea.com/ 。
　　
　　3、 IBM Webshpere
　　
　　Websphere同样可以下载到免费的试用版本，到IBM的developerWorks网站可以看到Websphere试用产品的下载和相关的 Websphere的资料，developerWorks中文网站的连接是：http://www- 900.ibm.com/developerWorks/cn/wsdd/ ，Websphere的下载连接：http://www7b.software.ibm.com/wsdd/...WASsupport.html 。
　　
　　4、 Jboss
　　
　　Jboss是免费开源的App Server，可以免费的从Jboss网站下载：http://www.jboss.org/index.html，然...n.com/idea.html
　　
　　四、 Java应用的运行环境
　　Java的应用可以简单分为以下几个方面：
　　
　　1、 Java的桌面应用
　　
　　桌面应用一般仅仅需要JRE的支持就足够了。
　　
　　2、 Java Web应用
　　
　　Java的Web应用至少需要安装JDK和一个web容器（例如Tomcat），以及一个多用户数据库，Web应用至少分为三层：
　　
　　Browser层：浏览器显示用户页面
　　
　　Web层：运行Servlet/JSP
　　
　　DB层：后端数据库，向Java程序提供数据访问服务
　　
　　3、 Java企业级应用
　　
　　企业级应用比较复杂，可以扩展到n层，最简单情况会分为4层：
　　
　　Browser层：浏览器显示用户页面
　　
　　Client层：Java客户端图形程序（或者嵌入式设备的程序）直接和Web层或者EJB层交互
　　
　　Web层：运行Servlet/JSP
　　
　　EJB层：运行EJB，完成业务逻辑运算
　　
　　DB层：后端数据库，向Java程序提供数据访问服务
　　
　　4、 Java嵌入式应用
　　
　　Java嵌入式应用是一个方兴未艾的领域，从事嵌入式开发，需要从Sun下载J2ME开发包，J2ME包含了嵌入式设备专用虚拟机KVM，和普通的JDK中包含的JVM有所不同。另外还需要到特定的嵌入式厂商那里下载模拟器。
　　
　　书籍篇
　　学习一门新的知识，不可能指望只看一本，或者两本书就能够完全掌握。需要有一个循序渐进的阅读过程。我推荐Oreilly出版的Java系列书籍。
　　
　　在这里我只想补充一点看法，很多人学习Java是从《Thinking in Java》这本书入手的，但是我认为这本书是不适合初学者的。我认为正确的使用这本书的方法应该是作为辅助的读物。《Thinking in Java》并不是在完整的介绍Java的整个体系，而是一种跳跃式的写作方法，是一种类似tips的方法来对Java很多知识点进行了深入的分析和解释。
　　
　　对于初学者来说，最好是找一本Java入门的书籍，但是比较完整的循序的介绍Java的语法，面向对象的特性，核心类库等等，在看这本书的同时，可以同步来看《Thinking in Java》，来加深对Java的理解和原理的运用，同时又可以完整的了解Java的整个体系。
　　
　　对于Java的入门书籍，蔡学镛推荐的是Oreilly的《Exploring Java, 2nd Edition》 或者《Java in a Nutshell,2nd Edition（针对C++背景）》，我并没有看过这两本书。其实我觉得电子工业出版社的《Java 2编程详解》或者《Java 2从入门到精通》就很不错。
　　
　　在所有的Java书籍当中，其实最最有用的，并不是O'reilly的 Java Serials，真正最最有用处是JDK的Documentation！几乎你想获得的所有的知识在Documentation里面全部都有，其中最主要的部分当然是Java基础类库的API文档，是按照package来组织的，对于每一个class都有详细的解释，它的继承关系，是否实现了某个接口，通常用在哪些场合，还可以查到它所有的public的属性和方法，每个属性的解释，意义，每个方法的用途，调用的参数，参数的意义，返回值的类型，以及方法可能抛出的异常等等。
　　
　　可以这样来说，所有关于Java编程方面的书籍其实都不过是在用比较通俗易懂的语言，和良好的组织方式来介绍Documentation里面的某个package里面包含的一些类的用法而已。所以万变不离其宗，如果你有足够的能力来直接通过 Documentation来学习Java的类库，那么基本上就不需要看其他的书籍了。除此之外，Documentation也是编程必备的手册，我的桌面上有三个Documentation的快捷方式，分别是J2SDK1.4.1的Documentation，Servlet2.3的 Documentation和J2SDKEE1.3.1的Documentation。有了这个三个Documentation，什么其他的书籍都不需要了。
　　
　　对于Java Web 编程来说，最核心的是要熟悉和掌握HTTP协议，这个就和Java无关了，在熟悉HTTP协议之后，就需要熟悉Java的实现HTTP协议的类库，也就是 Servlet API，所以最重要的东西就是Servlet API。当然对于初学者而言，直接通过Servlet API来学习Web编程有很大的难度，我推荐O'reilly的《Java Server Pages 》这本书来学习Web 编程。
　　
　　EJB的书籍当中，《Enterprise JavaBeans, 2nd Edition》是一本很不错的书， EJB的学习门槛是比较高，入门很难，但是这本书完全降低
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 09:54 发表评论
]]>(转载)新手入门：J2EE学习经验和流程http://www.blogjava.net/lijiezjn/articles/94109.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 01:39:00 GMThttp://www.blogjava.net/lijiezjn/articles/94109.html
　　在这里我谈谈我在学习j2ee流程，并谈到在此过程中领会的经验和教训。以便后来者少走弯路。
　　
　　Java发展到现在，按应用来分主要分为三大块：J2SE,J2ME和J2EE。这三块相互补充，应用范围不同。
　　
　　J2SE就是Java2的标准版，主要用于桌面应用软件的编程；
　　J2ME主要应用于嵌入是系统开发，如手机和PDA的编程；
　　J2EE是Java2的企业版，主要用于分布式的网络程序的开发，如电子商务网站和ERP系统。
　　
　　先学习j2SE
　　要学习j2EE就要先学习j2SE，刚开始学习j2se先建议不要使用IDE，然后渐渐的过渡到使用IDE开发，毕竟用它方便嘛。学习j2se推荐两本书，《java2核心技术一二卷》，《java编程思想》，《java与模式》。其中《java编程思想》要研读，精读。这一段时间是基本功学习，时间会很长，也可能很短，这要看学习者自身水平而定。
　　
　　不要被IDE纠缠
　　在学习java和j2ee过程中，你会遇到五花八门的IDE，不要被他们迷惑，学JAVA的时候，要学语言本身的东西，不要太在意IDE的附加功能，JAVA编程在不同IDE之间的转换是很容易的，过于的在意IDE的功能反而容易耽误对语言本身的理解。目前流行的IDE有jbuilder，eclipse和eclipse的加强版WSAD。用好其中一个就可以了，推荐从eclipse入手j2ee。因为Jbuilder更适合于写j2se程序。
　　
　　选择和学习服务器使用配置
　　
　　当你有了j2se和IDE的经验时，可以开始j2ee的学习了，web服务器：tomcat，勿庸置疑，tomcat为学习web服务首选。而应用服务器目前主要有三个：jboss、weblogic、websphere。有很多项目开始采用jboss，并且有大量的公司开始做websphere或 weblogic向jboss应用服务器的移植（节省成本），这里要说的是，学习tomcat和jboss我认为是首选，也是最容易上手的。学习服务器使用配置最好去询问有经验的人（有条件的话），因为他们或许一句话就能解决问题，你自己上网摸索可能要一两天（我就干过这种傻事），我们应该把主要时间放在学习原理和理论上，一项特定技术的使用永远代替不了一个人的知识和学问。
　　
　　学习web知识
　　如果你是在做电子商务网站等时，你可能要充当几个角色，这是你还要学习：
　　html，可能要用到dreamwave等IDE。
　　Javascript，学会简单的数据校验，数据联动显示等等
　　
　　J2eeAPI学习
　　学习j2eeAPI和学习服务器应该是一个迭代的过程。
　　先学习jsp和servlet编程，这方面的书很多，我建立看oreilly公司的两本《jsp设计》和《java servlet编程》，oreilly出的书总是那么优秀，不得不佩服。
　　学习jdbc数据库编程，j2ee项目大多都是MIS系统，访问数据库是核心。这本应属于j2se学习中，这里拿出来强调一下。
　　学习jndi api，它和学习ejb可以结合起来。
　　学习ejb api，推荐书《精通ejb》
　　经过上面的这些的学习，大概可以对付一般的应用了。
　　有人说跟着sun公司的《j2ee tutorial》一路学下来，当然也可以。
　　
　　学习ejb设计模式和看代码（最重要）
　　设计模式是练内功，其重要性可以这么说吧，如果你不会用设计模式的话，你将写出一堆使用了ejb的垃圾，有慢又是一堆bug，其结果不如不用ejb实现（ejb不等于j2ee）。
　　无论学习什么语言，都应该看大量代码，你看的代码量不到一定数量，是学不好j2ee的。
　　
　　目前有很多开源的工程可以作为教材：
　　jive论坛
　　petstore sun公司
　　dune sun公司
　　等等，研读一个，并把它用到自己的工程中来。
　　
　　J2ee其他学习
　　当你渐渐对j2ee了解到一定深度时，你要开始关注当前领域中的一些技术变化，J2ee是一块百家争鸣的领域，大家都在这里提出自己的解决方案，例如 structs，hiberate，ofbiz等等，学习这些东西要你的项目和目标而定，预先补充一下未尝不可，但不用涉及太深，毕竟学习原理和理论是最最重要的事。
　　
　　目前常见j2eeAPI
　　JavaServer Pages(JSP)技术1.2
　　Java Servlet技术2.3
　　JDBC API 2.0
　　Java XML处理API(JAXP)1.1
　　Enterprise JavaBeans技术2.0
　　Java消息服务(JMS)1.0
　　Java命名目录接口(JNDI)1.2
　　Java事务API(JTA) 1.0
　　JavaMail API 1.2
　　JavaBeans激活架构(JAF)1.0
　　J2EE连接器体系结构(JCA)1.0
　　Java认证和授权服务(JAAS)1.0
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 09:39 发表评论
]]>(转载)Java基础入门之 JDBC介绍http://www.blogjava.net/lijiezjn/articles/94107.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 01:25:00 GMThttp://www.blogjava.net/lijiezjn/articles/94107.html
　　JDBC是Java的开发者??Sun的Javasoft公司制定的Java数据库连接(Java Data Base Connectivity) 技术的简称，是为各种常用数据库提供无缝联接的技术。JDBC在Web和Internet应用程序中的作用和ODBC在Windows系列平台应用程序中的作用类似。ODBC(OpenData Base Connectivity)，称为开放式数据库互联技术，是由Microsoft公司倡导并得到业界普遍响应的一门数据库连接技术，如果读者有使用ODBC编程的经验，就会发现JDBC与ODBC很类似。JDBC现在可以连接的数据库包括：xbase、 Oracle、Sybase、Aceess以及Paradox等。 

JDBC的工作机制

　　如果用户是从事软件领域工作的，不可能没有听说过SQL(Structure Query Language：结构化查询语言)，它是一种标准化的关系型数据库访问语言。在SQL看来，数据库就是表的集合，其中包含了行和列。SQL标准虽然也还处在不断变革之中(任何一门标准如果已一成不变了，那只能说明这门学科已经停止发展了)，但其基本内容相对稳定。JDBC定义了Java语言同SQL数据之间的程序设计接口。
　　JDBC有一个非常独特的动态连接结构，它使得系统模块化。使用JDBC来完成对数据库的访问包括以下四个主要组件：Java的应用程序、JDBC驱动器管理器、驱动器和数据源。
　　JavaSoft公司开发了JDBC API，JDBC API是一个标准统一的SQL数据存取接口。　　JDBC在Internet中的作用与 ODBC在Windows系列中的作用类似。它为Java程序提供了一个统一缝地操作各种数据库的接口，程序员编程时，可以不关心它所要操作的数据库是哪个厂家的产品，从而提高了软件的通用性，而且在Internet上确实无法预料你的用户想访问什么类型的数据库。只要系统上安装了正确的驱动器组， JDBC应用程序就可以访问其相关的数据库。
用JDBC来实现访问数据库记录可以采用下面的几个步骤：
1、 通过驱动器管理器获取连接接口。
2、 获得Statement或它的子类。
3、 限制Statement中的参数。
4、 执行Statement。
5、 查看返回的行数是否超出范围。
6、 关闭Statement。
7、 处理其它的Statement
8、 关闭连接接口。

Java作为数据库前台 

　　在信息时代，数据库是用于收集和处理数据的工具，数据库形成了许多公司基础结构的基础。尽管数据库系统非常适合数据的存储和取得，但人类需要某种前台应有程序以查阅和使用存放的数据。
　　Java对建立数据库服务器前台应用程序的开发人员提供了几个好处。Java是“一旦写成，到处运行”的语言，即Java程序不经改变即可部署到任何运行Java虚拟机的计算机结构和操作系统。对于大公司，有一个公用开发平台好处很大，编程人员可以不再为大公司中的各个平台分别编程。Java也很吸引第三方开发者，单个Java程序即可满足大公司客户的需求。
　　建立公司系统中基于Java的应用程序和小程序的动力是巨大的。公司对于将结构和操作系统相关模型变成针对网络的模型相当有兴趣。Java代表着节约资源成本的长期战略。
　　对于开发人员，Java代表巨大的市场机会。大中型企业很少不用数据库进行业务工作的，大部分公司将数据库应用到业务的各个方面，从人事资源到前线客户销售。

JDBC API

　　JDBC API使开发者不必不断重写程序而可以建立数据库前台。尽管ANSI委员会有个标准组，但每个数据库系统厂家的系统连接和通讯方法仍然五花八门。
　　为了建立健全独立于平台的应用程序和基于Web的小程序，开发人员应考虑用Java开发前台连接办法。从外部看，第三方软件开发者通过专用办法，通过本地方法集成客户机方库或通过建立第三层和新协议来满足这种需求。
　　JavaSoft是Sun公司负责开发Java产品的业务单位，和数据库与数据库工具厂家一起建立独立于DBMS的机制，使开发人员不必考虑所用的特定数据库而编写客户机方应用程序。产生的JDBC API第一版是核心JDK 2的一部分。
　　JDBC向应用程序开发者提供了独立于数据库的统一的API。这个API提供了编写的标准和考虑所有不同应用程序设计的标准。其奥秘是一组由驱动程序实现的Java接口。驱动程序负责标准JDBC调用向支持的数据库所要的具体调用转变。
　　应用程序编写一次并移植到各种驱动程序上。应用程序不变，驱动程序则各不相同。驱动程序可以用于开发多层数据库设计的中间层，也称中间件(middleware)。
　　除了向开发者提供统一的独立于DBMS的框架外，JDBC还提供了让开发者保持数据库厂家提供的特定功能的办法。JDBC驱动程序必须支持 ANSI AQL-2项目层，但JDBC允许开发者直接将查询字符串传递到连接的驱动程序。这些字段可能是ANSI SQL也可能不是，或者根本不是 AQL。这些字符串的使用是基础驱动程序的事。
　　JDBC不是Mincrosoft的ODBC(开放式数据库连接)规范派生的，JDBC完全是用Java编写的，而ODBC是个C接口。但是，JDBC和ODBC都是基于X/开放SQL命令层接口(CLI)，相同的概念性基础使API工作进展更快，使API的接受更加容易。JavaSoft提供了将JDBC变成ODBC的JDBC-ODBC桥。这个用本地方法完成的版本很小很有效。
　　一般来说，JDBC API中有两层接口：应用程序层，开发人员用API通过SQL调用数据库和取得结果，驱动程序层，处理与具体驱动程序版本的所有通讯。
　　每个JDBC应用程序(或小程序)至少要有一个JDBC驱动程序，每个驱动程序是针对一种DBMS的。但驱动程序不必直接联到数据库。

利用JDBC代替CGI

　　迄今为止，通过Java访问数据库的唯一方法就是利用Java中的流调和访问Common Gateway Interface（CGI，公用网关接口）程序。通过Java调用CGI脚本其实是执行一个访问数据库并返回结果的独立程序。
　　使用这种方法速度很慢，而且会在应用程序中引入更多的错误。这是由于利用两种不同的开发语言开发程序，需要掌握两种不同的技术。使用JDBC，用户只要了解Java语言即可，而使用CGI，用户必须同时使用Java和另一种编程语言。
　　使用JDBC的另一个原因是它的速度比CGI方法更快。使用CGI方法通常要求计算机执行另一个独立的程序。这个独立的程序访问数据库，处理数据，并将结果返回给调用程序。这就需要多级处理，因而增加了等待时间和出错概率。
　　调用CGI脚本通常是通过Web服务器执行一个新的脚本，而执行JDBC的数据库命令只需要某种将SQL命令发送给数据库的服务器。这就大大缩短了执行 SQL语句的时间，CGI脚本必须独立地连接数据库，处理执行结构，而JDBC的解决方案使应用程序直接与数据库相连，执行各种操作。

JDBC的优点和缺点

　　JDBC API用于连接Java应用程序与各种关系数据库。这使得人们在建立客户/服务器应用程序时，通常把Java作为编程语言，把任何一种浏览器作为应用程序的友好界面，把Internet或Intranet作为网络主干，把有关的数据库作为数据库后端。以下是使用JDBC的优缺点。
　　优点如下：
　　1.JDBC API与ODBC十分相似，有利于用户理解。
　　2.JDBC使得编程人员从复杂的驱动器调用命令和函数中解脱出来，可以致力于应用程序中的关键地方。
　　3.JDBC支持不同的关系数据库，使得程序的可移植性大大加强。
　　4.用户可以使用JDBC-ODBC桥驱动器将JDBC函数调用转换为ODBC。
　　5.JDBC API是面向对象的，可以让用户把常用的方法封装为一个类，备后用。
　　缺点如下：
　　1.使用JDBC，访问数据记录的速度会受到一定程度的影响。
　　2.JDBC结构中包含了不同厂家的产品，这就给更改数据源带来了很大的麻烦。
(转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 09:25 发表评论
]]>(转载)Java入门知识http://www.blogjava.net/lijiezjn/articles/94103.html张江宁的个人博客张江宁的个人博客Tue, 16 Jan 2007 01:20:00 GMThttp://www.blogjava.net/lijiezjn/articles/94103.html What is Java? Why Java?                                                                                                 
  大家学习Java有各自的理由，基本上Java是一个比较好的面向对象语言，api丰富
  是当前比较主流的编程语言，J2SE/J2ME/J2EE在各个开发领域都发展良好
  Java不会取代其他开发语言或开发平台，如c/c++/c#或Delphi/.NET
  没有最好的语言，只有某种应用场合下相对合适的语言                                                                     

JRE                                                                                                                     
  Java 2 Runtime Environment, Java 运行时环境
  包括Java虚拟机(JVM),和必须的类库
  它是运行Java程序和网页Applet的必备环境
  它被包含在j2sdk中，也可以单独下载(约10M)
  下载地址： http://java.sun.com/getjava/download.html

JDK/SDK/J2SE                                                                                                            
  Java 2 Software Development Kit, Standard Edtion
  是开发Java的必备环境，包括编译器等工具和大量类库，一般IDE中也会自带
　下载地址：http://java.sun.com/j2se/downloads.html

J2EE                                                                                                                    
  Java 2 Platform, Enterprise Edition
  是Java在企业级应用的主要技术，也是目前Java最主要的应用场合
  包括JAXP、JAXR、JAX-RPC、SAAJ、JAAS、JavaMail、JMS、JSF、JSP/Servlet等
  开发J2EE,可以下载j2eesdk开发包，一般IDE中也会自带
  相关链接：http://java.sun.com/j2ee

J2ME                                                                                                                    
  Java 2 Platform, Macro Edition
  是Java应用于嵌入式系统(如手机)的主要技术
  相关链接：http://java.sun.com/j2me

开发方式                                                                                                                
  市面上的IDE(集成开发环境)可以极大的提高开发效率
  但如果你初学Java,我们推荐用JDK+Editplus或UltraEdit
  虽然简陋些,但却可以学的比较扎实
  过早的依赖IDE只会让你对Java API蜻蜓点水,一知半解.
  甚至都未能掌握Java的基本语法
  掌握了扎实的基础后，再选择一款IDE进行开发是很容易的

  学习或使用Java,多查javadoc是很重要的(推荐使用JavaDOCHelper,类似MSDN的界面)
  版上的不少问题,其实稍微查查便不是问题

设置环境变量                                                                                                            
　安装了JDK以后，要配置环境变量
  Windows 2000                                                                                                         
   　我的电脑->属性->高级->环境变量
   　添加以下环境变量(假定你的java安装在d:\Java\j2sdk1.4.2）
        变量名     值                  说明
        JAVA_HOME  d:\Java\j2sdk1.4.2
        CLASSPATH  .                   .表示当前目录，即搜索当前目录
        PATH       ...;%JAVA_HOME%\bin  ...表示原来的PATH值
     新开一个dos窗口，键入java和javac测试一下
  Linux                                                                                                                
     以下为RedHat,bash为例 不同发行版略有不同,环境变量的设置详见Unix/Linux版
     修改用户目录下的.bash_profile,如vi ~/.bash_profile
     JAVA_HOME=/usr/local/java/j2sdk1.4.2
     CLASSPATH=.
     PATH=$PATH:$JAVA_HOME/bin
     export JAVA_HOME CLASSPATH
     重新登陆，使这个设置生效，在终端输入java  javac测试一下

简单测试程序                                                                                                            
　代码:--------------------------------
　　public class Test{
　　　public static void main(String[] args){
　　　　System.out.println("Hello world!");
　　 }
　　}
　-------------------------------------
  用记事本等工具编写，保存成Test.java
  注意，
    如果你的windows设置'不显示已知扩展名'的话，
    很有可能被保存成Test.java.txt
  然后在命令行工具，cd到Test.java所在目录，执行
　　 javac Test.java
　　 java Test

关于Java的学习                                                                                                          
  入门Java，请看一本系统讲解Java的书籍
  这方面的书，市面上很多，大同小异，无所谓挑那本
  但尽量挑本面向高版本的讲解语法的书，千万不要选《VJ++入门到精通》之类
  推荐的书籍如 Java in a Nutshell, Java大学教程，Java核心技术，Java编程思想等
  系统学习Java的基本知识之余，一定要勤实践，自己给自己一些动手机会
  适度的记住一些常用api,不要过分依赖IDE的代码提示

开发工具                                                                                                                

 JBuilder
    业界最主流的IDE之一，是Java开发工具的大哥大
    目前最新版本 JBuilder 2005
    无论开发j2se、j2me、j2ee还是xml/webservice，都是一把利器
    Foundation Edition可免费下载，但功能较少
    网上有流传企业版，为避免不必要的麻烦，请谨慎使用(尤其在公司)
    相关链接：http://www.borland.com/products/jbuilder

 Eclipse
    新兴的Java IDE，免费、开放源代码、跨平台、功能强大、运行速度快
    同时可以通过开发新的插件扩展现有插件的功能，比如在现有的Java开发环境中加
    入Tomcat服务器插件。
    相关链接：http://www.eclipse.org

 Ant
    它是流行的Java build工具，"Everyone should use ant"
    Ant不是一个IDE,但却可以做很多IDE的事,如编译/打包/部署/单元测试/CVS等
    对于中等规模以上的项目，必定依赖很多类库和拥有复杂的包结构
    使用Ant处理这些是极佳的选择
    相关链接：http://ant.apache.org

JSP                                                                                                                     
 Java Server Page,一种Java Web开发的一项技术,和javascript没有什么关系.

Servlet                                                                                                                 
 先于jsp出现的动态网页技术,类似cgi,但使用多线程处理请求.

jsp/servlet与Java的关系                                                                                                 
 Servlet只是继承了HttpServlet的Java类,而jsp最终会被编译成Servlet并执行
 很多在开发web时遇到的问题,其实和jsp/servlet本身没什么关系，而是普通的Java问
题。 一个合格的jsp/servlet程序员首先应该是合格的Java程序员。
 建议在学习和使用jsp/servlet前,先打下坚实的Java基础

 以下问题不属于jsp/servlet范畴
  .常用API的使用,诸如"如何把int变为String" "如何得到当前时间" "如何创建线程"
  .JDBC的使用和相关注意事项,诸如"如何访问MySQL" "为什么我插入数据是乱码"
  .其他J2EE技术的使用,诸如"如何使用JavaMail" "如何访问EJB"

推荐书籍                                                                                                                
 如果可能,请阅读一本系统的书籍来指导你学习这项技术
 笔者只看过"JSP高级编程"(机械工业2001年,廖若雪)
 其他大型出版社出版的书都应该不错,如Wrox,O'Reilly,或者国内出版社
 挑书的时候最好选用jsp 1.2,servlet 2.3规范以上的书籍

Tomcat                                                                                                                  
 这个是个开放源代码的JSP/Servlet服务器,是jsp/servlet的参考实现,适合初学
 主页http://jakarta.apache.org/tomcat/
 Tomcat 4.1和Tomcat 5都是目前稳定版本,后者支持最新的jsp/servlet标准
 建议下载zip版的,解压缩,运行bin/starup.bat即可出现服务器启动的界面
 如果启动失败,请确定本机的Java环境已正确,参见JAVA_HOME和PATH的配置

 conf目录里是服务器的配置,webapps是部署网站的目录

自己写的java class应该放哪里                                                                                            
 假设你的index.jsp的位置是X:/test/index.jsp,  X:/test是你的项目目录
 Test.class的位置应该是X:/test/WEB-INF/classes/Test.class

项目中的lib应该放哪里                                                                                                   
 X:/test/WEB-INF/lib/myLib.jar

如何写个servlet                                                                                                         
package testservlet;

import java.io.*;
import javax.servlet.ServletException;
import javax.servlet.http.*;

public class FooServlet extends HttpServlet {
 protected void doGet(HttpServletRequest req, HttpServletResponse resp)
   throws ServletException, IOException {
      resp.getWriter().println("hi, I'm a servlet");
 }
}
编译这个类  javac -classpath servlet-api.jar FooServlet.java
其中这个jar可以从tomcat-5.0.19\common\lib\servlet-api.jar获得
编译后的class放在 X:/test/WEB-INF/classes/testservlet/FooServlet.class
其中testservlet你包的名字,应尽量写package,避免莫名其妙的麻烦

编译X:/test/WEB-INF/web.xml,修改为
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application
2.3//EN" "http://java.sun.com/dtd/web-app_2_3.dtd">
<web-app>
  <servlet>
    <servlet-name>test</servlet-name>
    <servlet-class>testservlet.FooServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>test<ervlet-name>
    <url-pattern>/foobar</url-pattern>
  </servlet-mapping>
</web-app>
把这个程序部署到服务器上,比如把X:/test/*复制到tomcat/webapps/test/*
打开浏览器访问 http://localhost:8080/test/foobar,顺利的话会看到一行文字

jsp显示的是乱码怎么办                                                                                                   
 jsp的中文问题以下几种  //不包括jdbc读写数据库的中文问题
 1. jsp中写了中文如<p>中文</p>, 却不能显示
       解决方法 在jsp第一行加入                                                                                        
          <%@ page contentType="text/html; charset=gb2312" %>

 2. 表单中写了一个中文,如<input type="text" name="a" value="中文">
    却不能接受到 <%System.out.println(request.getParameter("a"));%>
       解决方法 在jsp或servlet中处理参数前加一条                                                                       
          request.setCharacterEncoding("GB2312");

 3. http://host/a.jsp?name=中文  这样的url中的name取不到
       解决方法 应该使用java.net.URLEncoder类把这个字符串转成ascii                                                     

怎样实现文件上传                                                                                                        
 常见的Java文件上传api有
    Jakarta Commons FileUpload http://jakarta.apache.org/commons/fileupload/
    COS
    SmartUpload
 下载相关的文件,里面一般有demo的

JSTL和EL                                                                                                                
 分别是Java Standard Tag Lib和Expression Language
 可以大大简化常规的jsp开发,并让页面更简洁,而不是充斥着scriptlet (转载文章请保留出处：北天JAVA技术网(www.java114.com))

张江宁的个人博客 2007-01-16 09:20 发表评论
]]>