曾颖明的博客关于作者
来源：互联网 发布：福州市各县区经济数据 编辑：程序博客网 时间：2024/04/27 16:05
9条警世箴言
- • 学Java流程
- • J2EE之Eclipse+JBoss+MySQL开发环境设置全攻略
- • 玩转Java的CLASSPATH
- • JSP开发前设置篇
- • 图解MySQL数据库的安装和操作
- • 测试数据库连通:
- • MySQL安装与设置指南
- • Tomcat下JSP、Servlet和JavaBean环境的配置
- • 初学jsp
新博
曾颖明的博客
欢迎访问曾颖明的博客
文章
最智慧的169条警世箴言
1、每个意念都是一场祈祷。[詹姆士·雷德非]
2、医生知道的事如此的少，他们的收费却是如此的高。 [马克吐温]
3、复杂中带着简单的思考，是人和动物的分别。[皮雅]
4、对一般人而言，凡事要思考并不是什么麻烦的事。 [詹姆士．布莱斯]
5、成功不是全垒打，而要靠每天的、经常的打击出密集安打。[Robert J. Ringer]
6、了解面对逆境，远比如何接受顺境重要得多。[马丁·赛力格曼]
7、绝不测量山的高度─除非你已到达顶峰，那时你就会知道山有多低。 [哈马绍]
8、奋斗、寻觅、发现，而不屈服。 [诗人丁尼生]
9、所有口述手写的辞句中，最悲哀的就是本来可以… [美国诗人惠蒂尔]
10、啊！到达人生的尽头，才发现自己没活过。[梭罗]
11、好的木材并不在顺境中生长；风越强，树越壮。 [马里欧特]
12、爱不能单独存在，它的本身并无意义。爱必须付诸行动，行动才能使爱发挥功能。 [德蕾莎修女]
13、要能感觉存在，就需加强对美的感受力。[詹姆士·雷德非]
14、将爱的能量传送给别人，我们自己就会变成一条管道，吸纳来自上天的神圣能源。而那种玄秘体验是我们每个人都得以品尝的！ [詹姆士·雷德非]
15、我们都随时处于正在学习的过程。 [Don Shimoda]
16、人类心灵深处，有许多沉睡的力量；唤醒这些人们从未梦想过的力量，巧妙运用，便能彻底改变一生。[澳瑞森·梅伦]
17、凡是内心能够想到、相信的，都是可以达到的。 [Napoleon Hill]
18、一个客观的艺术不只是用来看的，而是活生生的。 但是你必须知道如何去靠近它，因此你必须要做静心。 [OSHO]
19、烦恼使我受着极大的影响……我一年多没有收到月俸，我和穷困挣扎；我在我的忧患中十分孤独，而且我的忧患是多么多，比艺术使我操心得更厉害！ [米开朗基罗]
20、有两种东西，我们对它们的思考愈是深沉和持久，它们所唤起的那种愈来愈大的惊奇和敬畏就会充溢我们的心灵，这就是繁星密布的苍穹和我心中的道德律。[康德]
21、我们的生活似乎在代替我们过日子，生活本身具有的奇异冲力，把我们带得晕头转向；到最后，我们会感觉对生命一点选择也没有，丝毫无法作主。[索甲仁波切]
22、对战士旅行者而言，选择其实不是去选择，而是优雅地接受无限的邀请。[唐望]
23、真正的艺术家从来不会去想到完美， 而他的动作是如此地全然，而完美就是来自于它。 [OSHO]
24、所有主体客体及人类文化活动之全部。 [杜威]
25、智者不只发现机会，更要创造机会。[培根]
26、若无胆量，永远不可能升到高位。 [赛鲁士]
27、前往伟大的颠峰之路，必定崎岖。 [赛尼嘉]
28、若不好到至极，就不算伟大。[威廉·莎士比亚]
29、没有人爬山只为爬到山腰。为何甘于平庸呢？[詹姆士·哈特]
30、世界进步的历史是由那些不愿向失败者俯首称臣的人写下来的。 [西祖]
31、输赢并不在乎外在的强弱─完全发挥你内在的特质才是重要。[道格拉斯·马洛]
32、只要你想象得到，你就能做到；只要你能梦见，你就能实现。 [威廉·雅瑟·渥德]
33、要使一件工作获得最大的成就，尊重自己的情绪是很重要的。[不知名]
34、写作就跟生活一样，是一趟发现之旅。[亨利·米勒]
35、一本好书是大师心灵的鲜血，可以一代一代地保存珍藏。 [强恩·米尔顿]
36、如果你是个作家，这是比当百万富豪更好的事，因为这一份神圣的工作。 [哈兰·爱里森]
37、成为一个成功者最重要的条件，就是每天精力充沛的努力工作，不虚掷光阴。 [威廉·戴恩·飞利浦]
38、人生成功的秘诀是，当机会来到时，立刻抓住它。[班杰明·戴瑞斯李]
39、不停的专心工作，就会成功。 [查尔斯·修瓦夫]
40、你要确实的掌握每一个问题的核心，将工作分段，并且适当的分配时间。[富兰克林]
41、每一年，我都更加相信生命的浪费是在于：我们没有献出爱，我们没有使用力量，我们表现出自私的谨慎，不去冒险，避开痛苦，也失去了快乐。 [约翰·B·塔布]
42、微笑，昂首阔步，作深呼吸，嘴里哼着歌儿。倘使你不会唱歌，吹吹口哨或用鼻子哼一哼也可。如此一来，你想让自己烦恼都不可能。[戴尔·卡内基]
43、、当一切毫无希望时，我看着切石工人在他的石头上，敲击了上百次，而不见任何裂痕出现。但在第一百零一次时，石头被劈成两半。我体会到，并非那一击，而是前面的敲打使它裂开。 [贾柯·瑞斯]
44、人生不是一支短短的蜡烛，而是一只由我们暂时拿着的火炬；我们一要把它燃得十分光明灿烂，然后交给下一代的人们。 [萧伯纳]
45、虚荣心很难说是一种恶行，然而一切恶行都围绕虚荣心而生，都不过是满足虚荣心的手段。 [柏格森]
46、习惯正一天天地把我们的生命变成某种定型的化石，我们的心灵正在失去自由，成为平静而没有***的时间之流的奴隶。 [托尔斯泰]
47、要及时把握梦想，因为梦想一死，生命就如一只羽翼受创的小鸟，无法飞翔。 [兰斯顿·休斯]
48、生活的艺术较像角力的艺术，而较不像跳舞的艺术；最重要的是：站稳脚步，为无法预见的攻击做准备。 [玛科斯·奥雷利阿斯]
49、在安详静谧的大自然里，确实还有些使人烦恼、怀疑、感到压迫的事。请你看看蔚蓝的天空和闪烁的星星吧!你的心将会平静下来。[约翰·纳森·爱德瓦兹]
50、对一个适度工作的人而言，快乐来自于工作，有如花朵结果前拥有彩色的花瓣。 [约翰·拉斯金]
51、没有比时间更容易浪费的,同时没有比时间更珍贵的了，因为没有时间我们几乎无法做任何事。[威廉·班]
52、人生真正的欢欣，就是在于你自认正在为一个伟大目标运用自己；而不是源于独自发光、自私渺小的忧烦躯壳，只知抱怨世界无法带给你快乐。 [萧伯纳]
53、有三个人是我的朋友
爱我的人、恨我的人、以及对我冷漠的人。爱我的人教我温柔；恨我的人教我谨慎；对我冷漠的人教我自立。[J·E·丁格]
54、过去的事已经一去不复返。聪明的人是考虑现在和未来，根本无暇去想过去的事。 [英国哲学家 培根]
55、 真正的发现之旅不只是为了寻找全新的景色，也为了拥有全新的眼光。 [马塞尔·普劳斯特]
56、这个世界总是充满美好的事物，然而能看到这些美好事物的人，事实上是少之又少。 [罗丹]
57、称赞不但对人的感情，而且对人的理智也发生巨大的作用，在这种令人愉快的影响之下，我觉得更加聪明了，各种想法，以异常的速度接连涌入我的脑际。 [托尔斯泰]
58、人生过程的景观一直在变化，向前跨进，就看到与初始不同的景观，再上前去，又是另一番新的气候。 [叔本华]
59、为何我们如此汲汲于名利，如果一个人和他的同伴保持不一样的速度，或许他耳中听到的是不同的旋律，让他随他所听到的旋律走，无论快慢或远近。 [梭罗]
60、我们最容易不吝惜的是时间，而我们应该最担心的也是时间；因为没有时间的话，我们在世界上什么也不能做。 [威廉·彭]
61、人类的悲剧，就是想延长自己的寿命。我们往往只憧憬地平线那端的神奇玫瑰园，而忘了去欣赏今天窗外正在盛开的玫瑰花。 [戴尔·卡内基]
62、休息并非无所事事，夏日炎炎时躺在树底下的草地，听着潺潺的水声，看着飘过的白云，亦非浪费时间。[约翰·罗伯克]
63、没有人会只因年龄而衰老，我们是因放弃我们的理想而衰老。年龄会使皮肤老化，而放弃热情却会使灵魂老化。[撒母耳·厄尔曼]
64、快乐和智能的区别在于：自认最快乐的人实际上就是最快乐的，但自认为最明智的人一般而言却是最愚蠢的。 [卡雷贝·C·科尔顿]
65、每个人皆有连自己都不清楚的潜在能力。无论是谁，在千钧一发之际，往往能轻易解决从前认为极不可能解决的事。 [戴尔·卡内基]
66、每天安静地坐十五分钟·倾听你的气息，感觉它，感觉你自己，并且试着什么都不想。 [艾瑞克·佛洛姆]
67、你知道何谓沮丧---就是你用一辈子工夫，在公司或任何领域里往上攀爬，却在抵达最高处的同时，发现自己爬错了墙头。 [坎伯]
68、「伟大」这个名词未必非出现在规模很大的事情不可；生活中微小之处，照样可以伟大。 [布鲁克斯]
69、人生的目的有二：先是获得你想要的；然后是享受你所获得的。只有最明智的人类做到第二点。 [罗根·皮沙尔·史密斯]
70、要经常听、时常想、时时学习，才是真正的生活方式。对任何事既不抱希望，也不肯学习的人，没有生存的资格。 [阿萨·赫尔帕斯爵士]
71、旅行的精神在于其自由，完全能够随心所欲地去思考、去感觉、去行动的自由。 [威廉·海兹利特]
72、昨天是张退票的支票，明天是张信用卡，只有今天才是现金；要善加利用。 [凯·里昂]
73、所有的财富都是建立在健康之上。浪费金钱是愚蠢的事，浪费健康则是二级的谋杀罪。[B·C·福比斯]
74、明知不可而为之的干劲可能会加速走向油尽灯枯的境地，努力挑战自己的极限固然是令人激奋的经验，但适度的休息绝不可少，否则迟早会崩溃。 [迈可·汉默]
75、进步不是一条笔直的过程，而是螺旋形的路径，时而前进，时而折回，停滞后又前进，有失有得，有付出也有收获。 [奥古斯汀]
76、无论那个时代，能量之所以能够带来奇迹，主要源于一股活力，而活力的核心元素乃是意志。无论何处，活力皆是所谓“人格力量”的原动力，也是让一切伟大行动得以持续的力量。[史迈尔斯]
77、有两种人是没有什么价值可言的：一种人无法做被吩咐去做的事，另一种人只能做被吩咐去做的事。[C·H·K·寇蒂斯]
78、 对于不会利用机会的人而言，机会就像波浪般奔向茫茫的大海，或是成为不会孵化的蛋。 [乔治桑]
79、未来不是固定在那里等你趋近的，而是要靠你创造。未来的路不会静待被发现，而是需要开拓，开路的过程，便同时改变了你和未来。 [约翰·夏尔]
80、一个人的年纪就像他的鞋子的大小那样不重要。如果他对生活的兴趣不受到伤害，如果他很慈悲，如果时间使他成熟而没有了偏见。[道格拉斯·米尔多]
81、何时种马铃薯
大凡宇宙万物，都存在着正、反两面，所以要养成由后面、里面，甚至是由相反的一面，来观看事物的态度。 [老子]
82、在寒冷中颤抖过的人倍觉太阳的温暖，经历过各种人生烦恼的人，才懂得生命的珍贵。 [怀特曼]
83、一般的伟人总是让身边的人感到渺小；但真正的伟人却能让身边的人认为自己很伟大。[G.K.Chesteron]
84、播下行为的种子，可以收成习惯之果；播下习惯的种子，可以收成性格之果；播下性格的种子，可以收成命运之果。 [英国小说家 芮德]
85、问题不在于：一个人能够轻蔑、藐视或批评什么，而是在于：他能够喜爱、看重以及欣赏什么。[约翰·鲁斯金]
86、过去，我曾经接触过世界上许多大人物，但我从没见过被人叱责之后，比被人称赞之后，更能把事情做好的人。 [查尔斯·休瓦夫]
87、忙碌的人只会受到一个恶魔的引诱，而懒惰的人则会受到一群恶魔的引诱。 [汤玛斯·富勒]
88、人们经常会信口说什么尚未找到自我，但是事实上，自我并不是被找出来的，它是被创造出来的。[汤玛斯·萨斯]
89、痛苦才是人生的原貌，我们人类最后的喜悦，就是回忆过去所经历的痛苦经验。 [阿尔夫雷德]
90、 人类会因累积的学习和经验，告诉自己这也不能做，那也不能做，让拒绝尝试变成自己的习惯，那正是创造力最大的致命伤。 [阿雷克斯·F·奥斯本]
91、勇气就是能够超越愤怒、悲惨、恐惧、不平，同时内心明确告诉自己生命是美好的，尽管多磨难，生命是有意义的。 [桃乐丝·汤普森]
92、顺应社会、听从父母与老师告诉你的事，是安全而简单的存活方式，但这不叫生活，要生活，就得自己去发现什么是真实。 [克里希那穆提]
93、你就是自己的情感、思想、行动和意愿的综合体，你有权利感受，你有权利选择，你更有保持自我的权利。 [维斯冠]
94、人家的窃窃私语与你何干。让人家去说长道短；要像一座卓立的塔，绝不因为暴风而倾斜。 [但丁]
95、我时常诧异，虽然每个人都是爱自己甚于爱他人，但他们重视别人的观点却甚于重视自己的判断。[马可]
96、没有德行的美貌，转眼即逝，可是在你的美貌中，有一颗美好的灵魂，所以你的美常在。 [莎士比亚]
97、人格像一棵树，而名声就像树影，我们往往以为树影就像树的样子，其实唯有树身才是真实的。 [林肯]
98、最近常常觉得疲倦吗？这次不要用咖啡提神。试着问自己，有什么事情让你感到心烦、力不从心、无法释怀？ [保罗·皮尔梭]
99、改变别人不容易，若要得到别人的好感，必须先改变自己，因为，这样才能心想事成。 [永崎一则]
100、每个人对幸福的认定标准不同，不必在乎别人是否赞同，重要的是自己满足与否。 [蒙特纽]
101、每个人都有自己的剧场，他集经理、演员、提词、编剧、换景、包厢侍者、看门人诸职于一身，此外还是观众。 [朱利叶斯·海尔]
102、如果我不为自己，那么，谁会为我·但如果我只为自己，那么，我生存有什么意义呢？ [吉列里]
103、经验、环境和遗传造就了你的面目，无论是好是坏，你都得耕耘自己的园地；无论是好是坏，你都得弹起生命中的琴弦。 [卡耐基]
104、不要过分的醉心于放任自由，一点也不加以限制的自由，它的害处与危险实在不少。 [克雷洛卡]
105、人并不是在有时间时才培养耐心；正确的观念应该是：由于人学会了有耐心，所以才拥有比足够还要多的时间。 [保罗·皮尔梭]
106、如果你生气了，请在面对爱人之前先面对镜子。看看自己，你喜欢现在这张脸吗？ [保罗·皮尔梭]
107、学习就像爬山。爬上这一座头，还有另一座更高的山，永无终点。 [永崎一则]
108、人是能用语言教鞭训练的动物。希望大家都能拥有将他人的话听成金玉良言的耳朵。 [永崎一则]
109、星期一的早上喜悦一下也无妨吧！在下个星期一到来之前，也还有一个礼拜的时间。 [艾雷娜·波特]
110、 打开窗户吧!别叫它遮蔽了碧蓝的天空；让花的阵阵幽香，飘进我的屋内；让太阳最初的光芒，洒遍我全身的每个角落。 [塔果卢]
111、对于自己的行动不要懊悔，也不要过于在意，人生一切都是实验，实验的次数愈多，对我们愈有利。 [爱默生]
112、世界上最广阔的是海洋，比海洋更广阔的是天空，比天空更广阔的是人的心灵。 [雨果]
113、横溢的天才，如沃土，如不加耕耘，即可能产生杂草，而不产生葡萄、橄榄供人享用。 [休谟]
114、个人离开社会，不可能得到幸福，正如植物离开土地而被扔到荒漠上不可能生存一样。 [列夫·托尔斯泰]
115、人就像藤萝，他的生存靠别的东西支持，他拥抱别人就从拥抱中得到了力量。 [蒲伯]
116、快乐可遇而不可求，我们最明亮的欢乐之火往往是由意想不到的火所点燃的。 [约克兰逊]
117、你所爱的人，他并不是全然完美，但是正因为他的五音不全，你才发现他的可爱之处。不完美，很好。所以你也该放轻松一点。
[保罗·皮尔梭]
118、与其猜测别人怎么认为你，不如多花点心思了解自己，人们往往因为追求了解自己而富有。 [蒙特纽]
119、你能真心诚意地帮助别人，别人也会来帮助你，这是我们人生中最好的一种报酬。 [爱默生]
120、世间的任何事物，追求时候的兴致总比享用时候的兴致浓烈。[莎士比亚]
121、喜欢作事的人，能因完成一件事而喜悦，这种人是最幸福的。然而改正缺点，补偿了错误，则是最高的幸福。 [哥德]
122、一个好的假期，是与对时间的观念比你更模糊的人一起度过。 [普力斯特里]
123、一个人钻研的愈多，他学习到的愈多，一个人学习到的愈多，他愈了解到他所知道的何其浅薄。 [威斯特]
124、人生只有一事算得是成功的──能够依照你自己的方式去生活。 [摩尔利]
125、世上的成功者愿意付出的远超过规定，同时还以欢喜的心去做。 [山缪．葛雷池]
126、决定你幸福或不幸福的，不在于你有什么，或你是谁，或你在什么地方，或你正在做什么，而是你怎么想。 [卡内基]
127、一句或两句体贴的话，对他人态度作宽大的了解，这些都可以减少对别人的伤害，保住他的面子。[卡内基]
128、人家说最好的好人，都是犯过错误的过来人；一个人往往因为有一点小小的缺点，将来会变得更好。 [莎士比亚]
129、学问是我们随身的财产，我们自己在什么地方，我们的学问也跟着我们在一起。 [莎士比亚]
130、阳光普照与暴风雨，不过是天空表情的不同而已，而不管命运是甘甜或苦涩，都应该使它成为最好的人生粮食。 [贺尔曼．荷生]
131、奉承有如轻吹的北风般令人心情愉快，但是，它却不是使帆张扬起来而触动船开航的一阵风。 [吉尔．鲁纳尔]
132、为何老是有人喜欢对他人恶言恶语·我想可能是大部份的人都误以为肯定了他人的优点，便会跟着减损了自己的光荣所成的。 [哥德]
133、一种方式只适合一种人，每个人都应该追求属于自己的方式；站在自己外围的人们，请小心，别摔倒了! [哥德]
134、名望一闪即逝，钱财振翅而飞，走红是个意外，久长唯有品格。 [无名]
135、休息并不是浪费生命，它能够让你在清醒的时候，做更多清醒、有效率的事。 [卡内基]
136、若想克服恐惧，不要只想到自己，设法去协助别人，恐惧便会消失。 [卡内基]
137、虽住在气候宜人的地方，也免不了受蚊蝇的滋扰，虽然享受着盛大的欢乐，也免不了受烦恼的缠绕。 [莎士比亚]
138、笑声有如音乐，在可以耳闻笑声的地方，人生的各种灾祸都遁逃无踪。 [杉达思]
139、不是自己出头的时候，就不要插嘴说话，什么事都想要插嘴的人，就是没有自信。 [易卜生]
140、我向来宁愿去相信每一个人的最好的一面 --- 这会省去很多的困扰。 [吉普林]
141、我从来没有遇到一个富有的人是快乐的，但是我很少遇到一个贫穷的人不想要变成一个富有的人。[马格瑞吉]
142、真正的友情就像良好的健康一样，不到丧失不会明暸它的价值。 [柯尔顿]
143、胜利者知道无快捷方式可达到高峰，他们一步一步地爬上山去，直升机对他们毫无用处。 [艾德勒]
144、进入一不同的新行业，必须对自己充满信心，在面对无情的打击和不公的命运时，你必须要能自持。 [苏菲亚罗兰]
145、 当批评减少而增多鼓励和夸奖时，人们所做的好事会增加，而不好的事会受到忽视而萎缩。 [卡内基]
146、要从工作中得到乐趣，首先不要让自己变成工作的奴隶，而要让自己变成工作的主人。无止境的日夜工作，正如无止境的追逐玩乐一样不可取。
[摘自乐在工作]
147、快乐是一种选择，我们可以在任何时间、任何地点和状况中做这种选择，因为每一项经验都可被建构出一种正面的意义，我们可以由任何人、事、物上汲取快乐。
[摘自 快乐的秘密]
148、常胜者，既不过份悲观，也不过份乐观。他的危机意识是用来化除危机；他的希望源自于知道未来永远有好转的可能。 [摘自 天天都成功]
149、爱情是一生的功课；宽容是永远的习题。觉悟－屠夫要放下的是刀；恋爱－情人要放下的是心。放心去爱，然后选择放心的携手相伴，或是离开.......
[摘自 爱是一生的功课]
150、每次大海退潮后，都会留下厚礼。看得见的是贝壳、小鱼、虾或是螃蟹；看不见的是懂得赠予与宽容的心 [摘自 希望之旅]
151、 左手拥抱了一堆东西、 右手拥抱了另一堆东西、但是地上还有一堆东西。我想伸手再取一些,结果所有的东西都洒满了一地.. [摘自一首古老的诗]
152、如果人生面对的最大苦难只是死亡，那还有什么可以害怕的呢？人生中没有解决不了的事，也没有无法面对的事。 [摘自电影 新不了情]
153、人生就像一盒巧克力，你永远不知道你会吃到什么口味，每天都要吃点苦的东西，以免忘记苦味。 [摘自电影 阿甘正传]
154、这是一个必须靠新一代领导人应付新问题、把握新机会的时代，因为新世界有待征服。 [约翰·甘乃迪]
155、逃避危险最后并不会比冒险犯难安全，怯懦者失败的机会和胆大的人一样多。 [海伦·凯勒]
156、人们最好在运筹帷幄时胆小一点，并想及所有不良后果；但在必须行动的时候，便要大胆敢为。 [西罗多得]
157、在研究过那些知名男女后，我发现，他们的成功是因为他们做手边诸事都用尽全力、以极度的热忱努力不懈。 [哈瑞·杜鲁门]
158、专家永远没有办法解决富足社会的饥馑问题，必须靠你我同心协力的行动。 [法兰西斯·摩尔·拉蓓]
159、你可能犯各种错误，但只要你豁达、坦诚，并且勇敢，你就不会对这世界有害。世界是属于年轻人的。 [温斯顿·丘吉尔]
160、有三件事使人生有意义-工作、意志与成功。意志开启通往成功之门，那是件宏伟且令人喜悦的事。经由工作我们通过一扇扇的门，直到最后，终能摘取成功的果实。 [路易斯·伯斯特]
161、只有在突破自我关切的瓶颈，进而关切全人类的福祉时，人生才算真正开始。 [马丁·路得·金]
162、适合某人穿的鞋，可能会让另一个穿来痛苦不堪；生活没有放诸四海皆准的良方。每个人都有他自成一格的生活模式。 [艾瑞克·强]
163、往前走，失败没有关系。但要败得有智能，败得优雅，败得有格调..... [汤姆·鲁宾斯]
164、一棵树长到它想长的高度后，它才知道怎样的空气适合它。 [亨利·大卫·梭罗]
165、就拥抱失败吧！寻找失败且学习爱上失败，可能是我们唯一的解脱方式。 [汤姆·鲁宾斯]
166、 无论真实的自我是如何奇怪或令人惊异，我们必须敢于作自己。 [梅·莎顿]
167、在争取正义的奋斗中，我们唯一的报赏只是一个机会。你不必指望你明天即将会有这个机会，而是必须努力不懈。 [佛烈德瑞克·道格拉斯]
168、和同伴格格不入的人，或许只是因为他听到的拍子不一样。何不就让这人随着他听到的乐声走，管他有无节奏，是否离谱呢。 [亨利·大卫·梭罗]
169、人类的进步既非自发也非必然﹍我们没有时间漠然或踌躇，现在就是振作起来积极行动的时刻。 [马丁路得·金]
- 作者： zengyingming 2006年08月9日, 星期三 17:09 回复（0） | 引用（0） 加入博采
学Java流程
《 Java2核心技术（第6版）卷I:基础知识 》（CORE JAVA）
初学Java的经典著作！通过它可以快速掌握Java编程，这本书也同样适合Java程序员用作参考书，因为它涵盖的范围非常广，包括从正则表达式到高性能I／O这样的主要新特性。
《 Java编程思想（第2版） 》（Thinking in Java）
这本书受到全球程序员的广泛认同，它的前两版曾多次荣获Software Development , JavaWorld等机构颁发的大奖，《 Java编程思想（第2版） 》在2003年《程序员》举办的年度评选活动中获得冠军。
这本书全面介绍了从Java的基础语法到最高级特性，并针对Java 1.4版做了更新。在内容上有广度，也有一定深度，不仅适合入门，也可供深入学习用，同时作者还着重阐释了面向对象设计的理念。
作者Eckel开放了这本书的电子版，很值得我们尊敬，树立了一个慈祥的教育家的形象，不过如果要系统学习的话最好买一本纸版，否则太累眼。
《 Java编程语言(第三版) 》（The Java Programming Language）
这本书由“Java之父”James Gosling亲自参与编写，完全覆盖了Java语言当前版本的特征和类库，可以作为Java语言的入门向导，也可作为高级Java开发及Java语言教学的参考用书。
《 Java技术手册（影印版） 》
用这本书也非常好！不过可惜的是目前还没有第四版的中文版。考虑到第三版中文版已经有不少时间，所以在这我们就不向大家推荐了。
个人建议：
初学编程：《 Java2核心技术（第6版）卷I:基础知识 》,如果英文好可看《 Java技术手册（影印版） 》
体会Java的思想：《 Java编程思想（第2版） 》
需要一本全面的参考手册：《 Java2核心技术（第6版）卷I:基础知识 》《 Java编程思想（第2版） 》《 Java编程语言(第三版) 》
提高篇：
《 Effective Java中文版 》
这本薄薄的小书不仅获得了2002年度Jolt大奖，还受到Java之父的推荐。它继承了《Effective C++》的名字和风格，Bloch为我们带来了57条极具实用价值的Java经验规则，书中每条规则都以简短、独立的小文章形式出现，这些小文章包含了详细而精确的建议，以及对语言中许多细微之处的深入分析，并通过例子代码加以进一步说明。这本书实践性很强，作者把开发中的经验和模式进行讲解，并举实例进行说明。中文版由潘爱民翻译，保证了译本的质量。
如果想对这本书了解更多可看下一本书Practical Java的评价
《 Practical Java中文版 》
这是本书译者之一刘永丹的推荐：
大家好！我是刘永丹，是本书的译者之一。
目前我的手上没有Practical Java的简体版，只有繁体版。大家比较关注的一个问题，是此书与Effective Java的关系，这也是我在翻译此书经常想到的问题。我想以这两本书的读者身份就这一点谈一些自己的体会。不是为了推销此书：），只是希望在大家选书的时候提供一些参考。
从原版出版的时间来看，Practical Java早于Effective Java，可以说是Java领域中Effective风格书籍的开山之作。此书之所以没有取名Effective Java，我猜测有两个原因：一个是Peter Haggar谦虚的性格，二是尽管编排体例模仿了Effective C++，但写作的角度与Effective C++稍有不同。可以说取名Practical Java是很贴切的，这个问题我后面会再说到。后来Joshua Bloch的Effective Java也采用了Effective的编排体例，可谓英雄所见略同，并获得了Jolt大奖，名头大大盖过了Practical Java。不过买书不应完全凭借名气和奖项，还是要考虑读者本身的实际需要。下面我就简单比较一下这两本书。
预期的读者。这两本书都不是面向初学者的，而是面向中级读者。但我的体会，二者还有些许差别。Effective Java秉承了Effective C++的一贯特色，专门挖掘有深度的专题，读者最好具有较好的编程基础和经验，例如对设计模式的了解。Practical Java则侧重对程序员的实践的指导，一旦有了Java的基础，几乎就可以阅读此书了，并从中直接借鉴经验。如果说刚入门的读者经验值为1，编程专家经验值为10，那么Effective Java比较适合4、5以上经验值的读者，而3、4经验值的读者就已经可以从Practical Java享受到阅读的快乐了。
覆盖的范围。这两本书的取材确有重复，大约有一半的比例！但是（我一定会说“但是”的，对吧？：）），二者阐述的角度不同。Effective Java重在内容的深度剖析，Practical Java则在说理的浅白上下足功夫，一个“深入”，一个“潜出”，实在是难分伯仲。我有一个体会，无论我怎样在一本书上用功，在第二遍阅读时还是会发现原来遗漏的思维死角，一个有效的方法是同时阅读同一专题、不同风格的两本书，互相印证。当然，我不想引诱每个读者同时买这两本书，个人视自己的情况和喜好来定。
写作的风格。这个问题主要凭借每个人的感觉了。我认为Effective Java比较严谨，举例子也中规中矩，可以放在案头，仔细研读。Practical Java则轻松自然，书中的例子非常容易理解，即可放在床头随意阅读，也可放在计算机旁，需要时参考。Practical Java还有一个令我喜爱的特点，将代码生成的bytecode展示出来，使许多问题一目了然。
那么，说了这么多，到底该买不买Practical Java呢？我有如下建议：
1 如果你阅读过了Effective Java，并且感到轻松自如，那么不必破费了（当然买来收藏也不错：）），倘若在阅读时有一知半解之处，Practical Java或许是不错的选择。
2 如果你是刚入门的Java程序员，有过一段时间的编程经历，先考虑Practical Java，再考虑Effective Java，这样的阅读经历会顺畅一些。
3 如果你还没有Java经验，但是有较好的C++背景，首选Practical Java，因为Effective Java对你的帮助不会那么直接。（怎么说来说去都是Practical Java，显然是“托”：））
4 如果你有丰富的计算机编程经验，比较宽阔的专业知识面，Effective Java更适合你。
尽管我是本书的译者，但更多时候我只是个读者，上面的内容只是建议，仅供参考。
《 深入Java虚拟机(原书第2版) 》（Inside the Java Virtual Machine）
看名字就知道了，这本书告诉你Java虚拟机为你做了什么，如果要成为高手，这是一条必经之路。不过，如果你的时间很宝贵，就没有必要看它了。
《 Java与模式 》
这本书是阎宏博士写的，这书像一块巨大的砖头，即可学习知识又可以用来当武器。这本书最大的特点就是它将中国传统文化与最流行的设计概念??“模式”相结合，熊节经理曾经说过：由于缺乏一种文化沉淀，中国人对“模式”的理解通常会有些困难。看了这本书就没有这个问题了，中国人写中国事，讲解模式的例子是中国人耳熟能详的孙悟空之类的，凭只要搞过几个月面向对象，看懂这些东西都不成问题！但要能融为自己的知识，实际应用到开发中去还需要自己的理解、经验。
- 作者： zengyingming 2006年08月8日, 星期二 12:13 回复（0） | 引用（0） 加入博采
J2EE之Eclipse+JBoss+MySQL开发环境设置全攻略
作为开发环境，如果采用经典配置：JBuilder+Weblogic+Oracle，自是得心应手，但价格是惊人的。此配置主要是针对大型或超大型应用，硬件要求也很高，针对国内以中小型应用为主的现况，不作推荐。
虽然国内开发者早已习惯，但笔者以为还是防患于未然，应尽早加入OpenSource行列，促进国内软件业的发展。
本文所推荐的Eclipse、JBoss、MySQL均是名气很高的开源软件，并且非常实用。
1、JDK：到http://java.sun.com下载，推荐使用J2SDK1.4.X
2、JBoss：到http://www.jboss.org下载，笔者使用jboss-3.0.4_tomcat-4.0.6
3、MySQL：到http://www.mysql.com下载，笔者使用mysql-4.0.13，另须下载MySQL Control Center(图形化管理工具)，到http://sourceforge.net/projects/mmmysql/下载MySQL的JDBC驱动程序，如mm.mysql-2.0.14-you-must-unjar-me.jar
4、Eclipse：到http://www.eclipse.org下载，最新版本为3.0M8，如果是新手推荐下载2.1.2和中文包(2.1.2_Translations)。到http://www.objectlearn.com/下载lomboz(此插件开发J2EE必需)，需要注意的是lomboz的版本必须与eclipse版本一致，否则不正常。
环境设置(以Windows 2000下D盘作根目录为例)：
1、JDK的安装配置在此不再说明。
2、将JBoss解压到D:/，将MySQL的JDBC驱程包中的mm.mysql-2.0.14-bin.jar解压到D:/jboss-3.0.4_tomcat-4.0.6/server/default/lib中，再将D:/jboss-3.0.4_tomcat-4.0.6/docs/examples/jca目录下的mysql-service.xml拷贝到D:/jboss-3.0.4_tomcat-4.0.6/server/default/deploy目录下，找到相应段落并作如下修改：
MySqlDS
jdbc:mysql://localhost:3306/test
org.gjt.mm.mysql.Driver
root
3、安装MySQL和MySQL Control Center，到mysql/bin目录中启动mysqld-nt.exe，即开启mysql服务。使用MySQL Control Center很方便地进行管理(类似SQL Server)。
4、将Eclipse(以3.0M8为例)解压到D:/，再将lomboz包中plugins目录中的内容解压到D:/Eclipse/plugins中，启动eclipse。(1)window--preferences--lomboz，设置JDK Tools.jar，Server Definitions--Server types:JBoss 3.0--Application Server Directory：D:/jboss-3.0.4_tomcat-4.0.6；Classpath Variable：D:/jboss-3.0.4_tomcat-4.0.6(2)window--Customize Perspective--Shortcuts--New--Java，勾选lomboz J2EE Wizards
- 作者： zengyingming 2006年08月1日, 星期二 16:08 回复（0） | 引用（0） 加入博采
玩转Java的CLASSPATH
【正文】和Java类路径（classpath）打交道的过程中，开发者偶尔会遇到麻烦。这是因为，类装载器实际装入的是哪一个类有时并不显而易见，当应用程序的classpath包含大量的类和目录时，情况尤其严重。本文将提供一个工具，它能够显示出被装入类文件的绝对路径名。
一、Classpath基础
Java虚拟机（JVM）借助类装载器装入应用程序使用的类，具体装入哪些类根据当时的需要决定。CLASSPATH环境变量告诉类装载器到哪里去寻找第三方提供的类和用户定义的类。另外，你也可以使用JVM命令行参数-classpath分别为应用程序指定类路径，在-classpath中指定的类路径覆盖CLASSPATH环境变量中指定的值。
类路径中的内容可以是：文件的目录（包含不在包里面的类），包的根目录（包含已打包的类），包含类的档案文件（比如.zip文件或者.jar文件）。在Unix家族的系统上，类路径的各个项目由冒号分隔，在MS Windows系统上，它们由分号分隔。
类装载器以委托层次的形式组织，每一个类装载器有一个父类装载器。当一个类装载器被要求装载某个类时，它在尝试自己寻找类之前会把请求先委托给它的父类装载器。系统类装载器，即由安装在系统上的JDK或JRE提供的默认类装载器，通过CLASSPATH环境变量或者-classpath这个JVM命令行参数装入第三方提供的类或者用户定义的类。系统类装载器委托扩展类装载器装入使用Java Extension机制的类。扩展类装载器委托自举类装载器（bootstrap class loader）装入核心JDK类。
你可以自己开发特殊的类装载器，定制JVM如何动态地装入类。例如，大多数Servlet引擎使用定制的类装载器，动态地装入那些在classpath指定的目录内发生变化的类。
必须特别注意的是（也是令人吃惊的是），类装载器装入类的次序就是类在classpath中出现的次序。类装载器从classpath的第一项开始，依次检查每一个设定的目录和压缩文件，尝试找出待装入的类文件。当类装载器第一次找到具有指定名字的类时，它就把该类装入，classpath中所有余下的项目都被忽略。
看起来很简单，对吧？
二、可能出现的问题
不管他们是否愿意承认，初学者和富有经验的Java开发者都一样，他们都曾经在某些时候（通常是在那些最糟糕的情形下）被冗长、复杂的classpath欺骗。应用程序所依赖的第三方类和用户定义类的数量逐渐增长，classpath也逐渐成了一个堆积所有可能的目录和档案文件名的地方。此时，类装载器首先装载的究竟是哪一个类也就不再显而易见。如果classpath中包含重复的类入口，这个问题尤其突出。前面已经提到，类装载器总是装载第一个它在classpath中找到的具有合适名字的类，从实际效果看，它“隐藏”了其他具有合适名字但在classpath中优先级较低的类。
如果不小心，你很容易掉进这个classpath的陷阱。当你结束了一天漫长的工作，最后为了让应用程序使用最好、最新的类，你把一个目录加入到了classpath，但与此同时，你却忘记了：在classpath的另一个具有更高优先级的目录下，存放着该类的另一个版本！
三、一个简单的classpath工具
优先级问题是扁平路径声明方法与生俱来固有的问题，但它不是只有Java的classpath才有的问题。要解决这个问题，你只需站到富有传奇色彩的软件巨构的肩膀上：Unix操作系统有一个which命令，在命令参数中指定一个名字，which就会显示出当这个名字作为命令执行时执行文件的路径名。实际上，which命令是分析PATH变量，然后找出命令第一次出现的位置。对于Java的类路径管理来说，这应该也是一个好工具。在它的启发之下，我着手设计了一个Java工具JWhich。这个工具要求指定一个Java类的名字，然后根据classpath的指引，找出类装载器即将装载的类所在位置的绝对路径。
下面是一个JWhich的使用实例。它显示出当Java类装载器装载com.clarkware.ejb.ShoppingCartBean类时，该类第一次出现位置的绝对路径名，查找结果显示该类在某个目录下：
> java JWhich com.clarkware.ejb.ShoppingCartBean
Class 'com.clarkware.ejb.ShoppingCartBean' found in '/home/mclark/classes/com/clarkware/ejb/ShoppingCartBean.class'
下面是第二个JWhich的使用实例。它显示出当Java类装载器装载javax.servlet.http.HttpServlet类时，该类第一次出现位置的绝对路径名，查找结果显示该类在某个档案文件中：
> java JWhich javax.servlet.http.HttpServlet
Class 'javax.servlet.http.HttpServlet' found in 'file:/home/mclark/lib/servlet.jar!/javax/servlet/http/HttpServlet.class'
四、JWhich的工作过程
要精确地测定classpath中哪一个类先被装载，你必须深入到类装载器的思考方法。事实上，具体实现的时候并没有听起来这么复杂——你只需直接询问类装载器就可以了！
1: public class JWhich {
2:
3: /**
4: * 根据当前的classpath设置，
5: * 显示出包含指定类的类文件所在
6: * 位置的绝对路径
7: *
8: * @param className <类的名字>
9: */
10: public static void which(String className) {
11:
12: if (!className.startsWith("/")) {
13: className = "/" + className;
14: }
15: className = className.replace('.', '/');
16: className = className + ".class";
17:
18: java.net.URL classUrl =
19: new JWhich().getClass().getResource(className);
20:
21: if (classUrl != null) {
22: System.out.println("/nClass '" + className +
23: "' found in /n'" + classUrl.getFile() + "'");
24: } else {
25: System.out.println("/nClass '" + className +
26: "' not found in /n'" +
27: System.getProperty("java.class.path") + "'");
28: }
29: }
30:
31: public static void main(String args[]) {
32: if (args.length > 0) {
33: JWhich.which(args[0]);
34: } else {
35: System.err.println("Usage: java JWhich <classname>");
36: }
37: }
38: }
首先，你必须稍微调整一下类的名字以便类装载器能够接受（12-16行）。在类的名字前面加上一个“/”表示要求类装载器对classpath中的类名字进行逐字精确匹配，而不是尝试隐含地加上调用类的包名字前缀。把所有“.”转换为“/”的目的是，按照类装载器的要求，把类名字格式化成一个合法的URL资源名。
接下来，程序向类装载器查询资源，这个资源的名字必须和经过适当格式化的类名字匹配（18-19行）。每一个Class对象维护着一个对装载它的ClassLoader对象的引用，所以这里是向装载JWhich类的类装载器查询。Class.getResource()方法实际上委托装入该类的类装载器，返回一个用于读取类文件资源的URL；或者，当指定的类名字不能在当前的classpath中找到时，Class.getResource()方法返回null。
最后，如果当前的classpath中能够找到指定的类，则程序显示包含该类的类文件所在位置的绝对路径名（21-24行）。作为一种调试辅助手段，如果当前classpath中不能找到指定的类，则程序获取java.class.path系统属性并显示当前的classpath（24-28行）。
很容易想象，在使用Servlet引擎classpath的Java Servlet中，或者在使用EJB服务器classpath的EJB组件中，上面这段简单的代码是如何运作。例如，如果JWhich类是由Servlet引擎的定制类装载器装入，那么程序将用Servlet引擎的类装载器去寻找指定的类。如果Servlet引擎的类装载器不能找到类文件，它将委托它的父类装载器。一般地，当JWhich被某个类装载器装入时，它能够找出当前类装载器以及所有其父类装载器所装入的所有类。
【结束语】如果需要是所有发明之母，那么帮助我们管理Java类路径的工具可以说迟到了很长时间。Java新闻组和邮件列表中充塞着许多有关classpath的问题，现在JWhich为我们提供了一个简单却强大的工具，帮助我们在任何环境中彻底玩转Java类路径。
- 作者： zengyingming 2006年07月31日, 星期一 14:31 回复（0） | 引用（0） 加入博采
JSP开发前设置篇
j2sdk-1_4_0_01-windows-i586.exe -----JSDK JAVA开发工具包
jakarta-tomcat-5.0.18.zip -----TOMCAT5 服务器
jcpro300.zip -----JCREATOR3.0 JAVA编译工具
j2sdk是必须的，另外两个可自选，听说Eclipse加Lomboz也不错（Eclipse是IDE，
即集成开发环境，Lomboz是它的一个插件，据说调试JSP比较方便)
我的安装目录(可自定义)：
C:/j2sdk1.4.0_01
C:/tomcat5
具体设置(win2000 pro)：
JSDK & tomcat
我的电脑/属性/高级/环境变量
系统变量Path
变量值加入C:/j2sdk1.4.0_01/bin;C:/tomcat5/bin （此句前面加;结束前一语句）
新建一个系统变量，变量名CLASSPATH
变量值C:/tomcat5/common/lib;.;C:/j2sdk1.4.0_01/lib;.
(别忘了后面要加.喔!!)
tomcat
编辑C:/tomcat5/bin/startup.bat
加入
set java_home=C:/j2sdk1.4.0_01
set tomcat_home=c:/tomcat5
set CATALINA_HOME=c:/tomcat5
JCreator
菜单Configure/options
点左边菜单JDK Profiles
双击j2sdk1.4.0_01（无就新建一个）
Home path为JSDK路径
Classes为类文件包
点ADD，ADD PATH为添加目录路径，ADD ARCHIVE为添加文件
以下为要添加的文件：
C:/j2sdk1.4.0_01/jre/lib/rt.jar
C:/j2sdk1.4.0_01/lib/dt.jar
C:/j2sdk1.4.0_01/lib/tools.jar
C:/j2sdk1.4.0_01/jre/lib/ext/dnsns.jar
C:/j2sdk1.4.0_01/jre/lib/ext/ldapsec.jar
C:/j2sdk1.4.0_01/jre/lib/ext/localedata.jar
C:/j2sdk1.4.0_01/jre/lib/ext/sunjce_provider.jar
C:/tomcat5/common/lib/jsp-api.jar
C:/tomcat5/common/lib/servlet-api.jar
一般来说，你第一次装完运行JCreator，它会要你设置一些东西，一般它自己
会找到J2SDK目录，帮你添加以上这些东西（只是JCREATOR的设置喔），不过
TOMCAT那两个JAR文件要自己添加的！另外，在很多书上说的jsp.jar和servlet.jar
就是我上面添加那两个文件，可能因为版本不同，所以名字改了吧：）
OK！做完以上设置，基本的设置已完成，自己试一下吧！
www.99126.cn
- 作者： zengyingming 2006年07月31日, 星期一 14:29 回复（0） | 引用（0） 加入博采
图解MySQL数据库的安装和操作
一、MySQL下载与安装
1、下载介绍
MySQL相信大家一定听说过，如果不知道它是干什么的，可以去google一下。
MySQL的大本营：http://www.mysql.com/
MySQL的下载地址：http://dev.mysql.com/downloads/ 因为要从这个地址下载不少东东，所以详细分析一下这个网页。 
· 关于镜像网站，没有大陆的，有香港和台湾的。选择它，是为了加快下载速度，不过也不是绝对的，我经常就从北美的镜像下载，速度反而更快些。
· MySQL数据库服务器 这里我选择MySQL 4.1版本。版本太低，许多新特性用不上；太高，测试还没有完善，容易出Bug。这里选择它推荐的。
点击这个链接，进入下载页面，可以看到，当前版本是4.1.8。找到“Windows downloads”，如图，因为我使用的是Windows平台。这里我选择“Without installer (unzip in C:/)”这个版本，因为我喜欢不需要安装的软件，用的不高兴，随时可以直接删除，当然需要自己配置一下才能使用。
点击“Pick a mirror”,进入一个页面，那里的表格可以不填，直接选择一个链接下载它就可以了。下载后的文件名是“mysql-4.1.8-win-noinstall.zip”，大小是35.2M。
· 关于“Graphical clients” 图形界面的客户端，选择一个吧，可以进行图形化操作，何乐而不为？只不过以前我一直用“MySQL Control Center”的，现在却不开发了。选择“MySQL Administrator”吧，下载后的文件名是“mysql-administrator-1.0.19-win-noinstall.zip”（这里我选择的是不需要安装版本），大小是4.5M。
同样也选择“MySQL Query Browser”，它是来查询的。下载后的文件名是“mysql-query-browser-1.1.5-win-noinstall.zip”（不需要安装版本），大小是4.5M。
关于这方面的软件比较多，如：MySQL-Front，EMS MySQL Manager等，比较好用，不过它们是要Money的。
· “Application Programming Interfaces (APIs) ” 应用程序接口 由于我主要是面向Java应用，所以这里就选择“MySQL Connector/J ”，版本选择“MySQL Connector/J 3.0”，因为它是“Procdution”版本。下载后的文件名是“mysql-connector-java-3.0.16-ga.zip”，大小是1.2M。
2、安装MySQL
· 找到下载后的mysql-4.1.8-win-noinstall.zip，解压到D盘，是一个“mysql-4.1.8-win”文件夹，这里我把它改名为“mysql”，因为我不喜欢带版本号。即这时是“D:/mysql”目录，这个目录下有一个“data”目录，这里就是存放数据的地方。为了方便备份和升级，最好把它放在其它地方。这里我在D盘新建一个目录“mysql-data”，然后把“D:/mysql”目录下的“data”子目录剪切到“D:/mysql-data”目录中。
·新建一个“my.ini”文件，注意后缀名是“ini”。内容如下：
E:/WINDOWS/my.ini
[WinMySQLAdmin]
Server=D:/mysql/bin/mysqld-nt.exe
[mysqld]
basedir=D:/mysql
datadir=D:/mysql-data/data
上面“Server”指向MySQL的执行主程序，“basedir”指向MySQL的安装目录，“datadir”指向MySQL的数据存放目录（因为我改变了它，所以需要特别指定）。
然后把这个文件移动到Windows的系统安装目录下，我这里是“E:/WINDOWS”。
· 打开MS-DOS窗口，切换到“D:/mysql/bin”目录；或者把“D:/mysql/bin”添加到“环境变量”的“Path”变量中，这样可以避免切换到“D:/mysql/bin”目录。
·加入到Windows XP的服务中：
D:/mysql/bin> mysqld-nt -install
（这时打开“控制面板”->管理工具->服务：可以看到服务列表中存在“MySQL”服务，如果不希望它自动执行，可以改为手动，不用它的时候可以节省点内存）
· 启动和停止mysql服务
D:/mysql/bin>net start mysql
D:/mysql/bin>net stop mysql
· 移出mysql服务
mysqld-nt --remove
（如果你不再需要MySQL了，先停止MySQL服务，然后再移出MySQL服务，最后删除MySQL安装目录即可）
二、基本操作
1、准备工作
在D盘建立一个mysql-software的目录，把刚才下载的 mysql-administrator-1.0.19-win-noinstall.zip 复制到这个子目录中，解压，得到一个 MySQL Administrator 1.0 的目录。
同样如此操作 mysql-query-browser-1.1.5-win-noinstall.zip，得到一个 MySQL Query Browser 1.1 的目录。
2、启动服务：
·双击D:/mysql-software/MySQL Administrator 1.0 目录下的 MySQLSystemTrayMonitor.exe，这时会在任务栏右侧出现一个图标。点击“Start Instance”,运行MySQL。
· 然后双击 D:/mysql-software/MySQL Administrator 1.0 目录中的 MySQLAdministrator.exe，或者直接点击上面右键菜单中的“MySQL Administrator ”：
· 创建一个连接名，可以随便填，这里是“mxj”，用户名：root，密码空着。这是因为mysql默认有一个没有密码的root帐号。点击“OK”，出现管理窗口：
这没什么好说的，英文也很简单。只谈谈上面勾选的两项。
3、更改密码
好了，我的root帐号的密码设置为：javamxj 最后，点击“Apply Change”。
4、初始的数据库
上图可以看到，初始有两个数据库，mysql库中含有各种配置信息，不要在这个库中进行表操作。
test库初始是空的。另外，建立表时，不要和mysql库中的表名取名相同，以免冲突。
5、数据创建与查询（兼谈谈字符编码）
·现在来到查询浏览器，还是右击右下角“MySQL System Tray Monitor”图标，从中选择“MySQL Query Browser”，因为已经更改过root的密码，所以要填入新密码。
· 进入主界面，右击test数据库，创建一个新表。
· 如下简单创建一个表
· 切换到“Table Options”：
如果了解数据库的话，这些应该是很熟悉的，不多说了。注意字符设置默认是“Latin1”（保存改变，再次切换到这一栏，就能看到了）。
· 填入一些测试数据：
· 关闭“MySQL Query Browser”，再重新打开它，切换到testtable表，看到了没有？刚才输入的中文变成了“？？？？？？”，为什么呢？ 再次切换到“Table Options”：
知道为什么了吧，原来默认字符是“latin1”，因为MySQL是瑞典一家公司的产品。中国人看来要努力了！
6、解决方法：
· 停止MySql服务，关闭所有与MySql相关的程序，打开Windows的系统安装目录下的 my.ini 文件，如下修改：
E:/WINDOWS/my.ini
[WinMySQLAdmin]
Server=D:/mysql/bin/mysqld-nt.exe
[mysqld]
basedir=D:/mysql
datadir=D:/mysql-data/data
default-character-set=gbk
[client]
default-character-set=gbk
添加的两条语句的含义是在客户端和服务端都使用GBK字符集进行编码。
保存后，重新激活 MySql 服务，打开“MySQL Query Browser”，再次创建一个表，输入中文，一切OK！
- 作者： zengyingming 2006年07月28日, 星期五 17:06 回复（0） | 引用（0） 加入博采
测试数据库连通:
安装并初始化MYSQL后我们还要测试是否能够正常连接该数据库。
第一步:通过“开始->运行->输入cmd”进入命令行模式。
第二步:使用cd/退到C盘根目录，然后使用cd usr,cd mysql,cd bin三个命令进入c:/usr/mysql/bin目录。(如图12)
图12：进入c:/usr/mysql/bin目录
第三步:输入mysql -h xxzxcompaq连接此MYSQL数据库，名称xxzxcompaq实际上就是计算机名称，当然我们也可以用IP地址或localhost来替代，出现Welcome to the MySQL monitor. Commands end with ; or /g.
Your MySQL connection id is 459 to server version: 3.22.20a-log
Type 'help' for help.
mysql>
说明我们已经正常连接到数据库上。(如图13)
图13：正常连接数据库
小提示:
当要登录到网上其他数据库时需要使用诸如MySQL -h host -u user -p password的命令，-h后的host为对方主机名或IP地址，-u后为数据库用户名，-p后跟密码。
第四步:在mysql>提示符中输入?可以查看可用命令。(如图14)
图14：查看可用命令
第五步:输入connect test将连接默认数据库。(如图15)
图15：连接默认数据库
四、启动MYSQL数据库:
安装完MYSQL数据库后我们有多种方法启动他。
方法一:系统默认启动
因为安装完MYSQL后该数据库将以服务的形式存在，所以在每次启动系统时都会自动启动MYSQL数据库。
方法二:命令启动法
手工运行bin目录中的winmysqladmin程序也可以实现启动MYSQL数据库的目的。(如图16)
图16：使用winmysqladmin程序启动MYSQL数据库
五、总结:
至此我们完成了MYSQL数据库的安装，初始化与连通调试工作，接下来就可以根据企业实际来建立数据库建立各种表了。相信稳定高效的MYSQL数据库会为企业业务提供良好的支持。
- 作者： zengyingming 2006年07月28日, 星期五 16:56 回复（0） | 引用（0） 加入博采
MySQL安装与设置指南
MySQL安装与设置指南
1、安装向导欢迎界面
2、选择安装类型
Typical（典型）、Complete（完全）、Custom（自定义）
选择“Custom”安装
3、自定义安装
默认情况下MySQL将会被安装到C:/Program Files/MySQL/MySQL Server 4.1/文件夹里面。
可以点“Change”更改路径。
4、准备开始安装
Install——开始安装
5、创建MySQL.com帐号的界面，如果是首次使用MySQL，选“Create anew free MySQL.com accout”。
6、输入带“*”号需要填写的信息
7、出现预览你刚才填的信息的界面
8、安装完成界面
注意：这里有个配置向导的选项（Configure the MySQL Server now），建议勾选立即配置你的MySQL。
9、配置类型选择页面。选“Detailed configuration”（详细配置）。
10、进入服务类型选择页面。选“Developer Machine”（开发者机器），这样占用系统的资源不会很多。
11、数据库用法选择页面。选择“Multifunctional Database”。
12、选择InnoDB数据存放位置页面。
不用更改设置，直接放在Installation Path安装目录里即可
13、选择MySQL的同时联接数。
选择“Manual Setting”，设置根据自己需要，酌情设置。
14、配置MySQL在TCP/IP通讯环境中的端口。
选择默认的3306端口即可。
15、选择MySQL中的字符设置。
注意，这里的选择将会影响你是否能在MySQL中使用中文。选择gb2312字符集以便支持简体中文，繁体中文选big5。
16、设置Windows服务选项。
注意，“Install As Windows Service”一定要勾选，这是将MySQL作为Windows的服务运行。“Service Name”就用默认的“MySQL”或者你喜欢的服务名（推荐用默认的“MySQL”）。下面的“Launch the MySQL Server automatically”一定要勾选，这样Windows启动时，MySQL就会自动启动服务，要不然就要手工启动MySQL。出现10061错误，原因在这里。
17、设置根帐号root的登录密码。
“Modify Security Settings”是设置根帐号的密码，输入你设定的密码即可。“Create An Anonymous Account”是创建一个匿名帐号，这样会导致未经授权的用户非法访问你的数据库，有安全隐患，建议不要勾选。
18、MySQL配置向导将依据你上面的所有设定配置MySQL，以便MySQL的运行符合你的需要。
点“Execute”开始配置，当出现“Service started successfully”时，说明你的配置完成，MySQL服务启动成功。
点“Finish”完成，整个MySQL的配置完成，剩下的就是用MySQL客户端连接MySQL服务器，然后使用了。
19、检查
在Windows XP下安装完MySQL后，它就已经自动启动服务了，并且在开始菜单中有其客户端的快捷方式连接。
20、通过Windows的服务管理器查看。
“开始”－“运行”，输入“services.msc”，回车。弹出Windows的服务管理器，然后就可以看见服务名为“mysql”的服务项了，其右边标明“已启动”。
21、开启和关闭
开始”－“运行”，输入“cmd”， XP命令提示符界面
启动mysql服务：输入“net start mysql”
停止mysql服务：输入“net stop mysql”
（注意，这里是输入的MySQL服务的名字。如果你的MySQL服务的名字是DB或其它名字，你应该输入“net start DB”或其它名）。
- 作者： zengyingming 2006年07月28日, 星期五 16:37 回复（0） | 引用（0） 加入博采
Tomcat下JSP、Servlet和JavaBean环境的配置
一、开发环境配置
第一步：下载j2sdk和tomcat：到sun官方站（http://java.sun.com/）下载j2sdk，注意下载版本，同时最好下载J2SE Documentation，然后到tomcat官方站点（http://jakarta.apache.org/）下载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
然后修改环境变量中的classpath，把tomat安装目录下的common/lib下的(可以根据实际追加)servlet.jar追加到classpath中去，修改后的classpath如下：
classpath=.;%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar;%CATALINA_HOME%/common/lib/servlet-api.jar;
接着可以启动tomcat，在IE中访问http://localhost:8080，如果看到tomcat的欢迎页面的话说明安装成功了。
PS:
版本问题： j2sdk1.4.2_08＋Tomcat 5.0一切正常，jdk1.5.0_04＋Tomcat 5.5好像不能通过，Tomcat 5.5启动不了。还发现一种情况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的窗口，会显示一些相关的信息。
如果您使用代理上网，一定要先撤掉代理，不然您的jsp程序永远也得不到执行。如果不是代理的，这一步就跳过了。
打开浏览器，在地址栏中输入：http://localhost:8080，如果看到有老虎（我也不知道是老虎还是猫）的画面，恭喜您，您成功了一半。
先来享受一下成功的喜悦吧，请输入下面的代码：
<html>
<head>
<title>First Page</title>
</head>
<body>
<H3>Today is: h
<%= new java.util.Date() %>
</H3>
</body>
</html>
将该程序保存为:First.jsp，放到Tomcat的ROOT目录下，然后在浏览器的地址栏中输入：http://localhost:8080/First.jsp，(First.jsp跟我们保存的文件名的大小写要一致)回车，如果不出意外，应该可以看到形如Today is: h Fri Apr 11 08:32:38 CST 2003 的结果。
注意：ROOT是tomcat的默认虚拟目录，如果要改成自己的虚拟目录怎么办呢？请继续往下看吧。
要改成自己的虚拟目录，就要请出server.xml来了，该文件是一个配置文件，在Tomcat/conf目录下，使用任何文本编辑软件都能打开它，我们先找到下面一句：
<Connector className="org.apache.coyote.tomcat4.CoyoteConnector"
port="8080" minProcessors="5" maxProcessors="75"
enableLookups="true" redirectPort="8443"
acceptCount="100" debug="0" connectionTimeout="20000"
useURIValidationHack="false" disableUploadTimeout="true" />
这里的port="8080"就是端口，我们完全可以用别的端口来代替，但不能是被系统占用的端口（0--1023），这里简单提一下。
下面我们再往下找，会发现以下的语句：
</Context>
</Host>
我们就应该找到这两个语句，如果不懂E文，您就认定这两个语句好了。然后我们将该语句更改如下：
</Context>
<Context path="/myjsp" debug="0" docBase="e:/myjsp" reloadable="true">
</Context>
</Host>
这里的path="/myjsp"就是我们就配置的虚拟目录了，以后在地址栏中输入http://localhost:8080/myjsp即可。而docBase="e:/myjsp" 则是机器本地路径，他们通过这个语句形成一个映射关系，其它照抄。
将上面的First.jsp文件放到e:/myjsp目录下，输入http://localhost:8080/myjsp/First.jsp，是不是有一种喜上眉梢的感觉？
在论坛里我见得最多的就是很多人不知道javaBean文件放到哪里，老实说开始我也不知道，更令人不解的是，十个人有九种不同的说法，这更让我们茫然。其实这问题也不是我们想像的那么复杂，我们以一个例子说明：
先建立一个java程序，代码如下：
package hall;
public class SimpleBean {
private String message = "No message specified";
public String getMessage() {
return(message);
}
public void setMessage(String message) {
this.message = message;
}
}
保存为SimpleBean.java，编译后会生成一个包，其实就相当于一个目录，也就是SimpleBean.class会存放在hall目录中，暂且保存起来，将来备用。
再输入以下代码：
<HTML>
<HEAD>
<TITLE>Reusing JavaBeans in JSP</TITLE>
</HEAD>
<BODY>
<CENTER>
<TABLE BORDER=5>
<TR><TH CLASS="TITLE">
Reusing JavaBeans in JSP</TABLE>
</CENTER>
<P>
<jsp:useBean id="test" class="hall.SimpleBean" />
<jsp:setProperty name="test" property="message" value="Hello WWW" />
<H1>Message: <I>
<jsp:getProperty name="test" property="message" />
</I></H1>
</BODY>
保存在我们刚才建立的虚拟目录e:/myjsp下面，并命名为：BeanTest.jsp。
现在我们应该将hall（包）目录放在哪儿呢？别急，我们先在e:/myjsp下建立一个文件夹WEB-INF，然后再在WEB-INF下建立一个classes文件夹，最后将hall目录放到classes下，当然，hall下的字节码文件SimpleBean.class也一并要移过来，而SimpleBean.java就和BeanTest.jsp放到同一目录吧（可以不需要放的，自己试试）。
好了，大功告成了，重新启动机器（如果您试了好多次都不行，这一步一定要做），在浏览器中输入：http://localhost:8080/myjsp/BeanTest.jsp，您看到了什么？呵，别告诉我您什么都没看到，那肯定是您设置的问题了。
好了，文章写完了，我也只是一只菜鸟，所以有写的不准备的地方请多多指教。祝您jsp之旅一路顺风！！！
Java学习 - 技术文章中心
初学者问的诸如：《怎样配置环境变量》《怎样运行Servlet》啊？这样的问题太多了，现在我写一个初学者入门必读，以便对初学者有指导作用！
首先是下载工具：
我建议初学者用Editplus＋JDK，我觉得如果用例如JB，Eclipse，JCreator，虽然刚开始的时候比较方便，但是确使初学者门不知道怎样配置环境变量，
从而难以达到知其然，知其所以然的地步
可以通过如下地址下载：
Editplus(最新版本是v2.11)：http://count.skycn.com/softdown.php?id=3641&url=http://sc-http.skycn.net/down/epp211a_cn.exe(要照注册码就自己找吧，网上很多的）
JDK(最新版本是Java2sdk1_5_0)：http://192.18.97.54/ECom/EComTicketServlet/BEGIN30AA3B63E5C2F61C8C26F84B78970A98/-2147483648/926882595/1/627578/627410/926882595/2ts+/westCoastFSEND/jdk-1.5.0_04-oth-JPR/jdk-1.5.0_04-oth-JPR:3/jdk-1_5_0_04-windows-i586-p.exe（这是For Windows）
然后就是安装JDK，我是把它装到从c:/JDK目录下面：
然后就是CLASSPATH的问题了：
正如操作系统利用PATH来搜索可执行程序一样，Java运行环境也会遍历CLASSPATH来查找类，即便是HelloWorld这样简单的程序，JVM也会遍历
CLASSPATH定义的每一个路径，直到找到相应的文件为止。
相信大家用的系统不是2k就是XP，然后就应当如下设置Path：
我的电脑->属性->高级->环境变量
然后在环境变量的Path后面追加: C:/JDK/bin;.;C:/JDK/lib
也可以这样配置:C:/JDK/bin;.;C:/JDK/lib/dt.jar;C:/JDK/lib/tools.jar
★记住:环境变量中的 . 切记不能少，它表示当前路径，如果少掉出现的错误等会就说！
dt.jar是关于运行环境的类库，tools.jar是关于一些工具的类库
如果没有配置:C:/JDK/bin，则会出现 " javac´ 不是内部或外部命令，也不是可运行的程序或批处理文件。"这样的错误。
然后下面就该写程序了：
首先是(HelloWorld.java),打开Editplus，新建一个Java文件，请照着如下输入，要一字不漏，并且分清大小写：
public class HelloWorld{
public static void main(String[] args){
System.out.println("Hello,World!");
}
}
然后把这个文件保存(ctrl + s)到HelloWorld.java,记住大小写一定要分清，是HelloWorld.java不是helloworld.java或者其它的
下面就该运行了，开始->运行->cmd
在控制台中把目录切换到当前目录：
javac HelloWorld.java
java HelloWorld
你就会在控制台上看见输出的Hello,World!(没出来？我把电脑吃了：）)
javac是编译命令，它把HelloWorld.java编译成HelloWorld.class
java就是解释命令，JVM把HelloWorld.class解释执行.
在这个时候：
1。如果出现Exception in thread "main" java.lang.NoClassDefFoundError: HelloWorld
那就是你在环境变量中没有加上那个.(dot)
2。如果出现Exception in thread "main" java.lang.NoSuchMethodError: main
或者HelloWorld.java:1: Public class helloworld must be defined in a file called
"HelloWorld.java".
那就是你没有分清大小写的写入这个HelloWorld，或者保存得时候没有保存为HelloWorld.java
这个名字一定要跟public class的名字一样
对于环境变量的问题就说到这里，下面我先所说怎么在Editplus里面编译和运行，在Tools－>参数设置->配置用户工具
1.添加工具（添加应用程序）
菜单文字：Compile Java Program
程序：C:/JDK/bin/javac.exe
参数：文件名称
初始目录：文件目录
2.添加工具（添加应用程序）
菜单文字：Run Java Program
程序：C:/JDK/bin/java.exe
参数：文件名称（不含扩展名）
初始目录：文件目录
工具组名称可以随便添，比如Debug Java Program
然后在Tools的下拉菜单中，你就会看见Compile Java Program以及Run Java Program这两个选项，以后你就可以利用ctrl + 1编译和ctrl ＋2运行程序了
下面就讨论Servlet的运行：
首先要运行Servlet，则需要JSP/Servlet container，我建议初学者用Tomcat
Tomcat（最新版本5.5）：http://apache.justdn.org/jakarta/tomcat-5/v5.5.9/bin/jakarta-tomcat-5.5.9.exe然后把这个压缩包解压到：
C:/Tomcat
然后再配置环境变量：
添加三个系统变量：
JAVA_HOME: C:/JDK
TOMCAT_HOME: C:/Tomcat
CLASSPATH: %JAVA_HOME%/lib;%TOMCAT_HOME%/lib
Tomcat的环境变量就配置完毕了，下面检验Tomcat是否能够运行：
在控制台中转到C:/Tomcat/bin这个目录，运行startup，然后回出现一个窗口，连跳一大串东西，最后表示Server已经运行
在浏览器中输入http://localhost:8080，出现欢迎界面，则表示Tomcat没问题了
然后和上面一样，写入你的第一个Servlet
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloWorld extends HttpServlet
{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException
{
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<html><head><title>");
out.println("This is my first Servlet");
out.println("</title></head><body>");
out.println("<h1>Hello,World!</h1>");
out.println("</body></html>");
}
}
然后照样用javac HelloWorld.java来编译这个文件，如果出现无法import javax.servlet.*
那么就是应该把C:/Tomcat/common/lib里面的servlet.jar（根据实际来看）文件拷贝到C:/JDK/jre/lib/ext中，再次编译，就没有问题了！
然后在Tomcat目录里面的C:/Tomcat/webapps/ROOT里面按如下的文件结构：
ROOT/index.html
ROOT/welcom.jsp
ROOT/WEB-INF/lib/MyServlet.jar（如果你的servlet的.class打成了.jar文件，则放在lib下面)
ROOT/WEB-INF/classes/HelloWorld.class(把上面生成的HelloWorld.class文件放在这个里面)
然后在浏览器中输入http://localhost:8080/servlet/HelloWorld,于是Server众望所归的报错了:Error 404--Not Found
怎么回事呢？
Servlet必须使用C:/Tomcat/webapps/ROOT/WEB-INF这个目录下面的web.xml文件进行注册，用EP打开这个web.xml文件，
在里面加入
<servlet>
<servlet-name>HelloWorld</servlet-name>
<servlet-class>HelloWorld</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>HelloWorld</servlet-name>
<url-pattern>/servlet/helloworld</url-pattern>
</servlet-mapping>
这样的结构
<servlet>
<servlet-name>HelloWorld</servlet-name>
<servlet-class>HelloWorld</servlet-class>
</servlet>
表示指定包含的servlet类.
而以下的结构
<servlet-mapping>
<servlet-name>HelloWorld</servlet-name>
<url-pattern>/servlet/HelloWorld</url-pattern>
</servlet-mapping>
表示指定HelloServlet应当映射到哪一种URL模式。
在修改web.xml完毕过后，重新启动Server，然后再输入http://localhost:8080/servlet/HelloWorld，那么偌大一个Hello,World!等着你呢，恭喜你
- 作者： zengyingming 2006年07月28日, 星期五 14:47 回复（0） | 引用（0） 加入博采
初学jsp
测试环境为 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+/" </a>/");
}
}
}
%>
数据库怎么连接，怎么老出错啊？所以我集中的在这写篇文章供大家参考，其实这种把数据库逻辑全部放在jsp里未必是好的做法，但是有利于初学者学习，所以我就这样做了，当大家学到一定程度的时候，可以考虑用MVC的模式开发。在练习这些代码的时候，你一定将jdbc的驱动程序放到服务器的类路径里，然后要在数据库里建一个表test,有两个字段比如为test1，test2，可以用下面SQL建
create table test(test1 varchar(20),test2 varchar(20)
然后向这个表写入一条测试纪录
那么现在开始我们的jsp和数据库之旅吧。
一、jsp连接Oracle8/8i/9i数据库（用thin模式）
testoracle.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("oracle.jdbc.driver.OracleDriver").newInstance();
String url="jdbc:oracle:thin:@localhost:1521:orcl";
//orcl为你的数据库的SID
String user="scott";
String password="tiger";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
二、jsp连接Sql Server7.0/2000数据库
testsqlserver.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver").newInstance();
String url="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=pubs";
//pubs为你的数据库的
String user="sa";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
三、jsp连接DB2数据库
testdb2.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.ibm.db2.jdbc.app.DB2Driver ").newInstance();
String url="jdbc:db2://localhost:5000/sample";
//sample为你的数据库名
String user="admin";
String password="";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
四、jsp连接Informix数据库
testinformix.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.informix.jdbc.IfxDriver").newInstance();
String url =
"jdbc:informix-sqli://123.45.67.89:1533/testDB:INFORMIXSERVER=myserver;
user=testuser;password=testpassword";
//testDB为你的数据库名
Connection conn= DriverManager.getConnection(url);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
五、jsp连接Sybase数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("com.sybase.jdbc.SybDriver").newInstance();
String url =" jdbc:sybase:Tds:localhost:5007/tsdata";
//tsdata为你的数据库名
Properties sysProps = System.getProperties();
SysProps.put("user","userid");
SysProps.put("password","user_password");
Connection conn= DriverManager.getConnection(url, SysProps);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
六、jsp连接MySQL数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("org.gjt.mm.mysql.Driver").newInstance();
String url ="jdbc:mysql://localhost/softforum?user=soft&password=soft1234&useUnicode=true&characterEncoding=8859_1"
//testDB为你的数据库名
Connection conn= DriverManager.getConnection(url);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
七、jsp连接PostgreSQL数据库
testmysql.jsp如下：
<%@ page contentType="text/html;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<html>
<body>
<%Class.forName("org.postgresql.Driver").newInstance();
String url ="jdbc:postgresql://localhost/soft"
//soft为你的数据库名
String user="myuser";
String password="mypassword";
Connection conn= DriverManager.getConnection(url,user,password);
Statement stmt=conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE);
String sql="select * from test";
ResultSet rs=stmt.executeQuery(sql);
while(rs.next()) {%>
您的第一个字段内容为：<%=rs.getString(1)%>
您的第二个字段内容为：<%=rs.getString(2)%>
<%}%>
<%out.print("数据库操作成功，恭喜你");%>
<%rs.close();
stmt.close();
conn.close();
%>
</body>
</html>
在jsp中使用smartupload组件上传文件
jsp对上传文件的支持不象php中支持的那么好，直接做成了函数，也不象asp中要通过组件才能实现。jsp中可以通过javabean来实现。但是我们没有必要自己去写一个上载的bean，在网上已经有了很多成型的技术，smartupload就是其中的一个。但是smartupload是将文件先读到服务器的内存中，所以上传太大的文件（超过100兆）有可能会出问题，也算是一个美中不足吧：）
先说一下提交的页面，smartupload组件要求用字节流的方式来提交<FORM action="upload.jsp" encType=multipart/form-data method=post>。下面就是个例子upload.htm：
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- saved from url=(0057)http://localhost:8080/jspsmartfile/jsp/uploadTemplate.jsp -->
<HTML><HEAD>
<META content="text/html; charset=gb2312" http-equiv=Content-Type>
<META content="MSHTML 5.00.2920.0" name=GENERATOR></HEAD>
<BODY bgColor=#e6e6e6><BR>
<FORM action="upload.jsp" encType=multipart/form-data method=post>
<TABLE>
<TBODY>
<TR>
<TD><FONT color=#000000 face=helv,helvetica size=1> File
: </FONT> <INPUT size=60 type=file name="file"></TD></TR>
<TR>
<TR>
<TD><FONT color=#000000 face=helv,helvetica size=1> File
: </FONT> <INPUT size=60 type=file name="file1"></TD></TR>
<TR>
<TD><FONT color=#000000 face=helv,helvetica size=1> File
: </FONT> <INPUT size=60 type=text name="text"></TD></TR>
<TR>
<TD
align=right><INPUT type=submit value=Send name="send"></TD></TR></TBODY></TABLE></FORM></BODY></HTML>
再来看一下接收的页面 ，我们把文件上传到服务器以后就直接把它再存入数据库中：upload.jsp
<%@ page contentType="text/hml;charset=gb2312"%>
<%@ page import="java.sql.*"%>
<%@ page import="com.jspsmart.upload.*" %>
<%@ page import="DBstep.iDBManager2000.*"%>
<%
//实例化上载bean
com.jspsmart.upload.SmartUpload mySmartUpload=new com.jspsmart.upload.SmartUpload();
//初始化
mySmartUpload.initialize(pageContext);
//设置上载的最大值
mySmartUpload.setMaxFileSize(500 * 1024*1024);
//上载文件
mySmartUpload.upload();
//循环取得所有上载的文件
for (int i=0;i<mySmartUpload.getFiles().getCount();i++){
//取得上载的文件
com.jspsmart.upload.File myFile = mySmartUpload.getFiles().getFile(i);
if (!myFile.isMissing())
{
//取得上载的文件的文件名
String myFileName=myFile.getFileName();
//取得不带后缀的文件名
String suffix=myFileName.substring(0,myFileName.lastIndexOf('.'));
//取得后缀名
String ext= mySmartUpload.getFiles().getFile(0).getFileExt();
//取得文件的大小
int fileSize=myFile.getSize();
//保存路径
String aa=getServletContext().getRealPath("/")+"jsp//";
String trace=aa+myFileName;
//取得别的参数
String explain=(String)mySmartUpload.getRequest().getParameter("text");
String send=(String)mySmartUpload.getRequest().getParameter("send");
//将文件保存在服务器端
myFile.saveAs(trace,mySmartUpload.SAVE_PHYSICAL);
//下面的是将上载的文件保存到数据库中
//将文件读到流中
java.io.File file = new java.io.File(trace);
java.io.FileInputStream fis = new java.io.FileInputStream(file);
out.println(file.length());
//打开数据库
ResultSet result=null;
String mSql=null;
PreparedStatement prestmt=null;
DBstep.iDBManager2000 DbaObj=new DBstep.iDBManager2000();
DbaObj.OpenConnection();
//将文件写到数据库中
mSql="insert into marklist (markname,password,marksize,markdate,MarkBody) values (?,?,?,?,?)";
prestmt =DbaObj.Conn.prepareStatement(mSql);
prestmt.setString(1, "aaa1");
prestmt.setString(2, "0000");
prestmt.setInt(3, fileSize);
prestmt.setString(4, DbaObj.GetDateTime());
prestmt.setBinaryStream(5,fis,(int)file.length());
DbaObj.Conn.setAutoCommit(true) ;
prestmt.executeUpdate();
DbaObj.Conn.commit();
out.println(("上载成功！！！").toString());
}
else
{ out.println(("上载失败！！！").toString()); }
}//与前面的if对应
%>
再说一下下载，下载分两种情况1。从数据库直接下载2。从服务器上下载
先说从数据库直接下载的情形：就是把输入流从数据库里读出来，然后转存为文件
<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.sql.*"%>
<%@ page import="java.io.*" %>
<%@ page import="DBstep.iDBManager2000.*"%>
<%
int bytesum=0;
int byteread=0;
//打开数据库
ResultSet result=null;
String Sql=null;
PreparedStatement prestmt=null;
DBstep.iDBManager2000 DbaObj=new DBstep.iDBManager2000();
DbaObj.OpenConnection();
//取得数据库中的数据
Sql="select * from t_local_zhongzhuan ";
result=DbaObj.ExecuteQuery(Sql);
result.next();
//将数据库中的数据读到流中
InputStream inStream=result.getBinaryStream("content");
FileOutputStream fs=new FileOutputStream( "c:/dffdsafd.doc");
byte[] buffer =new byte[1444];
int length;
while ((byteread=inStream.read(buffer))!=-1)
{
out.println("<DT><B>"+byteread+"</B></DT>");
bytesum+=byteread;
System.out.println(bytesum);
fs.write(buffer,0,byteread);
}
%>
再说从服务器上下载的情形：
<%@ page contentType="text/html; charset=gb2312" %>
<%@ page import="java.io.*" %>
<%
String fileName = "zsc104.swf".toString();
f//读到流中
InputStream inStream=new FileInputStream("c:/zsc104.swf");
//设置输出的格式
response.reset();
response.setContentType("bin");
response.addHeader("Content-Disposition","attachment; filename=/"" + fileName + "/"");
//循环取出流中的数据
byte[] b = new byte[100];
int len;
while((len=inStream.read(b)) >0)
response.getOutputStream().write(b,0,len);
inStream.close();
%>
缩略图实现，将图片(jpg,gif,bmp等等)真实的变成想要的大小
import java.io.*;
import java.util.*;
import com.sun.image.codec.jpeg.*;
import java.awt.image.*;
import java.awt.*;
import java.net.*;
import java.applet.*;
import java.sql.*;
//缩略图类，
//本java类能将jpg图片文件，进行等比或非等比的大小转换。
//具体使用方法
//s_pic(大图片路径,生成小图片路径,大图片文件名,生成小图片文名,生成小图片宽度,生成小图片高度,是否等比缩放(默认为true))
public class Small_pic{
String InputDir; //输入图路径
String OutputDir; //输出图路径
String InputFileName; //输入图文件名
String OutputFileName; //输出图文件名
int OutputWidth=80; //默认输出图片宽
int OutputHeight=80; //默认输出图片高
int rate=0;
boolean proportion=true; //是否等比缩放标记(默认为等比缩放)
public Small_pic(){
//初始化变量
InputDir="";
OutputDir="";
InputFileName="";
OutputFileName="";
OutputWidth=80;
OutputHeight=80;
rate=0;
}
public void setInputDir(String InputDir){
this.InputDir=InputDir;
}
public void setOutputDir(String OutputDir){
this.OutputDir=OutputDir;
}
public void setInputFileName(String InputFileName){
this.InputFileName=InputFileName;
}
public void setOutputFileName(String OutputFileName){
this.OutputFileName=OutputFileName;
}
public void setOutputWidth(int OutputWidth){
this.OutputWidth=OutputWidth;
}
public void setOutputHeight(int OutputHeight){
this.OutputHeight=OutputHeight;
}
public void setW_H(int width,int height){
this.OutputWidth=width;
this.OutputHeight=height;
}
public String s_pic(){
BufferedImage image;
String NewFileName;
//建立输出文件对象
File file = new File(OutputDir+OutputFileName);
FileOutputStream tempout =null;
try{
tempout= new FileOutputStream(file);
}catch(Exception ex){
System.out.println(ex.toString());
}
Image img=null;
Toolkit tk=Toolkit.getDefaultToolkit();
Applet app=new Applet();
MediaTracker mt = new MediaTracker(app);
try {
img=tk.getImage(InputDir+InputFileName);
mt.addImage(img, 0);
mt.waitForID(0);
}catch(Exception e) {
e.printStackTrace();
}
if(img.getWidth(null)==-1){
System.out.println(" can't read,retry!"+"<BR>");
return "no";
}else{
int new_w;
int new_h;
if (this.proportion==true) //判断是否是等比缩放.
{
//为等比缩放计算输出的图片宽度及高度
double rate1=((double)img.getWidth(null))/(double)OutputWidth+0.1;
double rate2=((double)img.getHeight(null))/(double)OutputHeight+0.1;
double rate=rate1>rate2?rate1:rate2;
new_w=(int)(((double)img.getWidth(null))/rate);
new_h=(int)(((double)img.getHeight(null))/rate);
}
else{
new_w=OutputWidth; //输出的图片宽度
new_h=OutputHeight; //输出的图片高度
}
BufferedImage buffImg = new BufferedImage(new_w,new_h,BufferedImage.TYPE_INT_RGB);
Graphics g = buffImg.createGraphics();
g.setColor(Color.white);
g.fillRect(0,0,new_w,new_h);
g.drawImage(img,0,0,new_w,new_h,null);
g.dispose();
JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(tempout);
try{
encoder.encode(buffImg);
tempout.close();
}catch(IOException ex){
System.out.println(ex.toString());
}
}
return "ok";
}
public String s_pic(String InputDir,String OutputDir,String InputFileName,String OutputFileName){
//输入图路径
this.InputDir=InputDir;
//输出图路径
this.OutputDir=OutputDir;
//输入图文件名
this.InputFileName=InputFileName;
//输出图文件名
this.OutputFileName=OutputFileName;
return s_pic();
}
public String s_pic(String InputDir,String OutputDir,String InputFileName,String OutputFileName,int width,int height,boolean gp){
//输入图路径
this.InputDir=InputDir;
//输出图路径
this.OutputDir=OutputDir;
//输入图文件名
this.InputFileName=InputFileName;
//输出图文件名
this.OutputFileName=OutputFileName
//设置图片长宽
setW_H(width,height);
//是否是等比缩放 标记
this.proportion=gp;
return s_pic();
}
public static void main(String [] a)
{
//s_pic(大图片路径,生成小图片路径,大图片文件名,生成小图片文名,生成小图片宽度,生成小图片高度)
Small_pic mypic =new Small_pic();
System.out.println(
mypic.s_pic("E://JAVA//J2EEDatum//王亮jsp资料//缩图例子//personal//",
"E://JAVA//J2EEDatum//酒剑仙jsp资料//缩图例子//personal//",
"1.jpg","new1.jpg",80,80,true)
);
}
在JSP中使用JavaMail
Java中文站
你希望在jsp中建立一个邮件发送收取工具吗？下面将介绍的就是在jsp中建立一个邮件发送收取工具。在这篇文章中你可以了解到JavaMail API的一些要点以及如何在JSP中使用它。本文中还包括了在JSP中使用JavaMail的实例。JavaMail是JSP应用软件中相当强大的API。
阅读这篇文章需要对JSP、JavaBeans和JavaMail有一定的初步了解。当然，有关于JavaMail的知识你可以通过阅读这篇文章来获得。如果你对于以上三项一无所知，但你所使用的服务器支持JSP和JavaMail的话，你可以仅仅通过复制/粘贴来使用它们。
什么是JavaMail
JavaMail是Sun发布的用来处理email的API。它可以方便地执行一些常用的邮件传输。
虽然JavaMail是Sun的API之一，但它目前还没有被加在标准的java开发工具包中（Java Development Kit），这就意味着你在使用前必须另外下载JavaMail文件。除此以外，你还需要有Sun的JavaBeans Activation Framework （JAF）。JavaBeans Activation Framework的运行很复杂，在这里简单的说就是JavaMail的运行必须得依赖于它的支持。在Windows 2000下使用需要指定这些文件的路径，在其它的操作系统上也类似。
接下来要讲解的是这篇指南的最难理解的部分。
这篇指南包括三部分：HTML表格、关于JavaMail、JavaMail和JSP的结合。
第一部分：HTML表格
第一部分提供了一个最基本的基于HTML的email发送收取程序的例子。第二部分则讲述JavaMail的工作原理。第三部分则介绍将JavaMail加入JSP，创建一个基本的email发送收取程序。
划分组件
JSP最重要的特性是能将整个网页划分成一些细小的组件。这里使用的组件包括：
●一个用来将email的信息发送给JSP的HTML表格；
●一个JSP页面用来处理和发送信件。
第一步，就是创建一个HTML表格用来给JSP页面发送信息。你可以将以下的HTML代码复制到你的电脑上：
用来发送email的HTML源代码
<HTML>
<BODY>
<FORM action="sendmail.jsp" method="post">
<TABLE align="center">
<TR>
<TD width="50%">
To:<BR><INPUT name="to" size="25">
</TD>
<TD width="50%">
From:<BR><INPUT name="from" size="25">
</TD>
</TR>
<TR>
<TD colspan="2">
Subject:<BR><INPUT name="subject" size="50">
</TD>
</TR>
<TR>
<TD colspan="2">
<P>Message:<BR><TEXTAREA name="text" rows=25 cols=85></TEXTAREA></P>
</TD>
</TR>
</TABLE>
<INPUT type="submit" name="cb_submit" value=" Send ">
<INPUT type="reset" name="cb_reset" value=" Clear ">
</FORM>
</BODY>
</HTML>
以上这段程序将创建一个包含email基本信息（例如：收件地址、发送地址、主题和内容）的文件。当然你可以根据你自己的需要来决定这个文件包含那些信息。
这个HTML文件的使用有两点要求：第一点是生成的文件必须发送给接下来将介绍的程序使用。在这个例子中就是sendmail.jsp，但在你使用时，必须用这个文件在系统里的URL来代替它；第二点是必须有空间来允许用户发送email。
第二部分将对JavaMail的特征进行一些分析，为在第三部分创建JSP程序作准备。所以接下来我们将学习JavaMail。
第二部分：关于JavaMail
文档的使用
下载的JavaMail API中带的文档是很有用的。你可以在JavaMail下的/docs/javadocs/index.html找到它。第二部分主要将分析邮件程序的组件。你可以通过阅读文档来获得更多这方面的信息。
组件发送邮件需要使用JavaMail，它使对邮件的操作变得简单易用。
</FONT>属性对象
JavaMail需要创建一个格式为"mail.smtp.host"的文件用来发送信息。
Properties props = new Properties ();
props.put("mail.smtp.host", "smtp.jspinsider.com"); 对话对象
所有的基于JavaMail的程序都至少需要一个或全部的对话目标。
Session sendMailSession;
sendMailSession = Session.getInstance(props, null);
传输
邮件的传输只有送出或受到两种状态。JavaMail将这两种不同状态描述为传输和储存。传输将送出邮件，而储存将收取邮件。
Transport transport;
transport = sendMailSession.getTransport("smtp");
使用JavaMail能为我们节约大量的时间。JavaMail能代替所有的SMTP的工作。
注意：JavaMail并不能完全的支持所有的邮件发送收取工作。它目前仅支持IMAP、SMTP和POP3，除此以外你只有等待新的JavaMail版本或自己开发协议。
信息对象
信息对象将把你所发送的邮件真实的反映出来。
Message newMessage = new MimeMessage(sendMailSession);
这就是我们所需要的全部四个对象。下一步将是如何将对象加入到JSP中。
第三部分：JavaMail和JSP的结合
创建JSP
下面我们将开始将他们结合在一起。最重要的一点是要确认根据页面指示分类。还要记得在邮件上标注java.util.date。
<%@ page
import= " javax.mail.*, javax.mail.internet.*, javax.activation.*, java.util.*"
%>
其次，创建邮件发送的确认信息。确认信息可以是任意的，一般常用"你的邮件已经发送出去了（Your mail has been sent）。"
信息是如何创建和发送的
我们在第二部分里已经讨论过信息对象的创建。我们下面将对信息进行操作。这就和设置信息对象的属性一样简单。你可以通过下面的程序来实现这项操作。
newMessage.setFrom(new InternetAddress(request.getParameter("from")));
newMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(request.getParameter("to")));
newMessage.setSubject(request.getParameter("subject"));
newMessage.setSentDate(new Date());
newMessage.setText(request.getParameter("text"));
现在将开始发送信息。通过JavaMail来实现它非常简单。
transport.send(newMessage);
将所有的组件结合在一起
现在所有的组件都已经齐全了。现在将它们都放在JSP里面。要注意每一个错误信息，并将它反馈给用户。代码如下，你可以通过复制它们直接使用：
Sample JSP email Utility Using JavaMail
<%@ page
import=" javax.mail.*, javax.mail.internet.*, javax.activation.*,java.util.*"
%>
<html>
<head>
<TITLE>JSP meets JavaMail, what a sweet combo.</TITLE>
</HEAD>
<BODY>
<%
try{
Properties props = new Properties();
Session sendMailSession;
Store store;
Transport transport;
sendMailSession = Session.getInstance(props, null);
props.put("mail.smtp.host", "smtp.jspinsider.com");
Message newMessage = new MimeMessage(sendMailSession);
newMessage.setFrom(new InternetAddress(request.getParameter("from")));
newMessage.setRecipient(Message.RecipientType.TO, new InternetAddress(request.getParameter("to")));
newMessage.setSubject(request.getParameter("subject"));
newMessage.setSentDate(new Date());
newMessage.setText(request.getParameter("text"));
transport = sendMailSession.getTransport("smtp");
transport.send(newMessage);
%>
<P>Your mail has been sent.</P>
<%
}
catch(MessagingException m)
{
out.println(m.toString());
}
%>
</BODY>
</HTML>
你会很快体会到JavaMail的方便之处，JSP和JavaMail将是未来的希望。
package uploadfile;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import java.io.FileOutputStream;
import java.io.*;
import java.util.Hashtable;
import java.util.*;
public class FileUploadBean {
private String savePath=null; //文件上传保存的路径
private String contentType=""; //内容类型
private String charEncode=null; //字符编码
private String bounary=""; //分界线
private String fileName=null; //本地文件名字
private Hashtable dic=new Hashtable(); //用于保存"元素名--元素值"对
private int totalSize=0; //上传文件总大小
private String path=""; //保存文件的路径
private String newFileName=""; //存入随机产生的文件名
///////////////////////////////////////////////////
//设置文件上传保存的路径
public void setSavePath(String s) {
s=path+s;
savePath=s;
System.out.println("上传路径："+savePath);
}
///////////////////////////////////////////////////
//取文件上传保存的路径
public String getSavePath() {
return savePath;
}
////////////////////////////////////////////////////
//设置文件名字,也可以为它命名,暂时先用它原来的名字
public void setFileName(String s) {
int pos=s.indexOf("/"; filename=/"");
if (pos>0) {
s=s.substring(pos+13,s.length()-3); //去 " 和 crlf
pos=s.lastIndexOf("//");
if (pos<0)
pos=s.lastIndexOf("/");
if (pos<0)
fileName=s;
fileName=s.substring(pos+1);
}
}
////////////////////////////////////////////////////
//取得文件名
public String getFileName() {
System.out.println("得到文件名"+newFileName);
return newFileName;
}
///////////////////////////
//以时间为种子数产生新文件名
public String getNewFileName() {
int pos=0; //.的位置
long seed=0; //随机种子数
String ext=""; //存入文件扩展名
System.out.println("upload file name："+fileName);
pos=fileName.lastIndexOf(".");
ext=fileName.substring(pos); //得到扩展名
seed=new Date().getTime();
Random rand=new Random(seed);//以时间为种子产生随机数作为文件名
newFileName=Long.toString(Math.abs(rand.nextInt()))+ext; //生成文件名
System.out.println("new file name:"+newFileName);
return newFileName;
}
//////////////////////////////////////////////////////
//设置字符的编码方式
public void setCharEncode(HttpServletRequest req) {
charEncode=req.getCharacterEncoding();
}
/////////////////////////////////////////////////
//设置得ContentType
public void setBoundary(HttpServletRequest req) {
//传递的参数值类似"multipart/form-data; boundary=---------------------------7d21441a30013c"
//传过来的分界线比实际显示在上传数据中的要多两个"--"
boundary=req.getContentType();
//System.out.println("boundary"+boundary);
int pos=boundary.indexOf("boundary=");
//加上这两个"--"
boundary="--"+boundary.substring(pos+9);
}
////////////////////////////////////////////////////
//取得ContentType
public String getBoundary(){
//返回值类似"-----------------------------7d21441a30013c"
return boundary;
}
/////////////////////////////////////////////
//设置ContentType
public void setContentType(String s) {
int pos =s.indexOf(": ");
if (pos!=-1)
contentType=s.substring(pos+2);
}
////////////////////////////////////////////
//取得ContentType
public String getContentType() {
return contentType;
}
/////////////////////////////////////////////
//初始化
public void init(HttpServletRequest req) {
setCharEncode(req);
setBoundary(req);
}
////////////////////////////////////////////////////
//取哈希表中的数据
public String getFieldValue(String s) {
String temp="";
if(dic.containsKey(s)) //判断表中是否存在s键,不判断则返回nullpointerException
{
temp=(String)dic.get(s);
temp=temp.trim();
}else
temp="";
return temp;
}
////////////////////////////////////////////////
////用指定的编码方式生成字符串
public String newLine(byte oneLine[],int sp,int i,String charEncode)
throws java.io.UnsupportedEncodingException {
sp=0; // start position
String lineStr=null;
if (charEncode!=null) {
return lineStr=new String(oneLine,sp,i,charEncode); //用指定的编码方式生成字符串
}
else {
return lineStr=new String(oneLine,sp,i);
}
}
///////////////////////////////////////////////
//得到上传文件的大小
public int getTotalSize() {
return totalSize/1000;
}
///////////////////////////////////////
//删除指定路径的文件
public boolean delFiles(String fn) //fn为要删除的文件名，不包括路径
{
try
{
File file=new File(savePath+fn);
System.out.println(savePath+fn);
if(file.exists())
{
file.delete();
System.out.println(file.getPath()+"delete file successfully!");
return true;
}else
{
System.out.println("the file is not existed!");
return true;
}
}catch(Exception e)
{
System.out.println(e.toString());
return false;
}
}
////////////////////////////////////////////////
//文件列表
public String[] listFiles(String fp)
{
String[] lf=null;
try{
savePath=path+fp;
File file=new File(savePath);
lf=file.list(new DirFilter());
for(int i=0;i<lf.length;i++)
System.out.println(lf[i]);
}catch(Exception e){ e.printStackTrace();}
return lf;
}
/////////////////////////////////////////////////
//开始上传文件
public boolean doUpload(HttpServletRequest req)
throws java.io.IOException {
String fieldValue=""; //表单元素值
String fieldName=""; //表单元名称
int pos=-1; //临时变量,用于记录位置
int pos2=-1; //临时变量,用于记录位置
String lineStr=null; //用oneLine[]生成的每行字符串
byte oneLine[] =new byte[4096]; //用于每次读取的数据
FileOutputStream fos=null; //文件输出流
init(req); //初始化
ServletInputStream sis=req.getInputStream();
int i=sis.readLine(oneLine,0,oneLine.length); //返回实际读取的字符数,并把数据写到oneLine中
while (i!=-1) {
lineStr=newLine(oneLine,0,i,charEncode); //生成字符串
if (lineStr.indexOf(getBoundary()+"--")>=0)
break;
if (lineStr.startsWith("Content-Disposition: form-data; name=/"")) {
//分离数据,因为表单元素也一并上传,还有其它数据,对我们有用的只是
//文件的内容,表单元素及表单元素对应的值
if (lineStr.indexOf("/"; filename=/"")>=0) { //是文件输入域
//设置文件名
setFileName(lineStr);
if (!fileName.equals("")) { //如果文件名为空则跳过
//提取表单元素名称及表单元素对应的值
pos=lineStr.indexOf("name=/"");
pos2=lineStr.indexOf("/"; filename=/"");
//表单元素名字
fieldName=lineStr.substring(pos+6,pos2);
//表单元素值
fieldValue=lineStr.substring(pos2+13,lineStr.length()-3);
//加入哈希表中
dic.put(fieldName,fieldValue);
sis.readLine(oneLine,0,oneLine.length); //读取的数据类似"Content-Type: text/plain"
sis.readLine(oneLine,0,oneLine.length); //空行
//建立文件输出
fos=new FileOutputStream(new File(getSavePath(),getNewFileName()));
//开始读上传文件数据
i=sis.readLine(oneLine,0,oneLine.length);
while(i!=-1) {
totalSize=i+totalSize;
lineStr=newLine(oneLine,0,i,charEncode);
if (lineStr.indexOf(getBoundary())>=0)
break; //表明这个文件区的数据读取完毕
fos.write(oneLine,0,i);
i=sis.readLine(oneLine,0,oneLine.length);
}//end while
fos.close();
}//end if (!getFileName().equals(""))
}
else { //非文件输入域
pos=lineStr.indexOf("name=/"");
//表单元素名字
fieldName=lineStr.substring(pos+6,lineStr.length()-3);
//读空行
sis.readLine(oneLine,0,oneLine.length);
//这行含有元素值,如里元素值为空,则这行也是空行,也要读的
String temp="";
i=sis.readLine(oneLine,0,oneLine.length);
while(i!=-1)
{
temp=newLine(oneLine,0,i,charEncode);
if (temp.indexOf(getBoundary())>=0)
break;
fieldValue=fieldValue+temp;
i=sis.readLine(oneLine,0,oneLine.length);
}
//加入哈希表中
dic.put(fieldName,fieldValue);
fieldValue="";
}
}
i=sis.readLine(oneLine,0,oneLine.length);
}//end while
sis.close();
return true;
} //end doUpload
//////////////////////////
//清空Hashtable
public void clearDic() {
dic.clear();
if (dic.isEmpty()) {
System.out.println("empty");
}
else {
Sstem.out.println("not empty");
}
}
//////////////////////////////////
//测试用的主函数
public static void main(String args[])
{
String[] fileList=null;
try{
FileUploadBean fub=new FileUploadBean();
fileList=fub.listFiles("/avatars/");
for(int i=0;i<fileList.length;i++)
System.out.println(fileList[i]);
}catch(Exception e){ e.printStackTrace();}
}
}
///////////////////////////////////
////文件目录过滤内部类
class DirFilter implements FilenameFilter {
public boolean accept(File dir, String name) { //dir为目录名，name 为包含路径的文件名
File f = new File(dir,name); //生成文件对象
if(f.isDirectory())
return false;
return true;
}
}
相关类说明篇
㈠ File类
这个类包装了一个上传文件的所有信息。通过它，可以得到上传文件的文件名、文件大小、扩展名、文件数据等信息。
File类主要提供以下方法：
1、saveAs作用：将文件换名另存。
原型：
public void saveAs(java.lang.String destFilePathName)
或
public void saveAs(java.lang.String destFilePathName, int optionSaveAs)
其中，destFilePathName是另存的文件名，optionSaveAs是另存的选项，该选项有三个值，分别是SAVEAS_PHYSICAL,SAVEAS_VIRTUAL，SAVEAS_AUTO。SAVEAS_PHYSICAL表明以操作系统的根目录为文件根目录另存文件，SAVEAS_VIRTUAL表明以Web应用程序的根目录为文件根目录另存文件，SAVEAS_AUTO则表示让组件决定，当Web应用程序的根目录存在另存文件的目录时，它会选择SAVEAS_VIRTUAL，否则会选择SAVEAS_PHYSICAL。
例如，saveAs("/upload/sample.zip",SAVEAS_PHYSICAL)执行后若Web服务器安装在C盘，则另存的文件名实际是c:/upload/sample.zip。而saveAs("/upload/sample.zip",SAVEAS_VIRTUAL)执行后若Web应用程序的根目录是webapps/jspsmartupload，则另存的文件名实际是webapps/jspsmartupload/upload/sample.zip。saveAs("/upload/sample.zip",SAVEAS_AUTO)执行时若Web应用程序根目录下存在upload目录，则其效果同saveAs("/upload/sample.zip",SAVEAS_VIRTUAL)，否则同saveAs("/upload/sample.zip",SAVEAS_PHYSICAL)。
建议：对于Web程序的开发来说，最好使用SAVEAS_VIRTUAL，以便移植。
2、isMissing
作用：这个方法用于判断用户是否选择了文件，也即对应的表单项是否有值。选择了文件时，它返回false。未选文件时，它返回true。
原型：public boolean isMissing()
3、getFieldName
作用：取HTML表单中对应于此上传文件的表单项的名字。
原型：public String getFieldName()
4、getFileName
作用：取文件名（不含目录信息）
原型：public String getFileName()
5、getFilePathName
作用：取文件全名（带目录）
原型：public String getFilePathName
6、getFileExt
作用：取文件扩展名（后缀）
原型：public String getFileExt()
7、getSize
作用：取文件长度（以字节计）
原型：public int getSize()
8、getBinaryData
作用：取文件数据中指定位移处的一个字节，用于检测文件等处理。
原型：public byte getBinaryData(int index)。其中，index表示位移，其值在0到getSize()-1之间。
㈡ Files类
这个类表示所有上传文件的集合，通过它可以得到上传文件的数目、大小等信息。有以下方法：
1、getCount
作用：取得上传文件的数目。
原型：public int getCount()
2、getFile
作用：取得指定位移处的文件对象File（这是com.jspsmart.upload.File，不是java.io.File，注意区分）。
原型：public File getFile(int index)。其中，index为指定位移，其值在0到getCount()-1之间。
3、getSize
作用：取得上传文件的总长度，可用于限制一次性上传的数据量大小。
原型：public long getSize()
4、getCollection
作用：将所有上传文件对象以Collection的形式返回，以便其它应用程序引用，浏览上传文件信息。
原型：public Collection getCollection()
5、getEnumeration
作用：将所有上传文件对象以Enumeration（枚举）的形式返回，以便其它应用程序浏览上传文件信息。
原型：public Enumeration getEnumeration()
㈢ Request类
这个类的功能等同于JSP内置的对象request。只所以提供这个类，是因为对于文件上传表单，通过request对象无法获得表单项的值，必须通过jspSmartUpload组件提供的Request对象来获取。该类提供如下方法：
1、getParameter
作用：获取指定参数之值。当参数不存在时，返回值为null。
原型：public String getParameter(String name)。其中，name为参数的名字。
2、getParameterValues
作用：当一个参数可以有多个值时，用此方法来取其值。它返回的是一个字符串数组。当参数不存在时，返回值为null。
原型：public String[] getParameterValues(String name)。其中，name为参数的名字。
3、getParameterNames
作用：取得Request对象中所有参数的名字，用于遍历所有参数。它返回的是一个枚举型的对象。
原型：public Enumeration getParameterNames()
</FONT>
㈣ SmartUpload类这个类完成上传下载工作。
A．上传与下载共用的方法：
只有一个：initialize。
作用：执行上传下载的初始化工作，必须第一个执行。
原型：有多个，主要使用下面这个：
public final void initialize(javax.servlet.jsp.PageContext pageContext)
其中，pageContext为JSP页面内置对象（页面上下文）。
B．上传文件使用的方法：
1、upload
作用：上传文件数据。对于上传操作，第一步执行initialize方法，第二步就要执行这个方法。
原型：public void upload()
2、save
作用：将全部上传文件保存到指定目录下，并返回保存的文件个数。
原型：public int save(String destPathName)
和public int save(String destPathName,int option)
其中，destPathName为文件保存目录，option为保存选项，它有三个值，分别是SAVE_PHYSICAL,SAVE_VIRTUAL和SAVE_AUTO。（同File类的saveAs方法的选项之值类似）SAVE_PHYSICAL指示组件将文件保存到以操作系统根目录为文件根目录的目录下，SAVE_VIRTUAL指示组件将文件保存到以Web应用程序根目录为文件根目录的目录下，而SAVE_AUTO则表示由组件自动选择。
注：save(destPathName)作用等同于save(destPathName,SAVE_AUTO)。
3、getSize
作用：取上传文件数据的总长度
原型：public int getSize()
4、getFiles
作用：取全部上传文件，以Files对象形式返回，可以利用Files类的操作方法来获得上传文件的数目等信息。
原型：public Files getFiles()
5、getRequest
作用：取得Request对象，以便由此对象获得上传表单参数之值。
原型：public Request getRequest()
6、setAllowedFilesList
作用：设定允许上传带有指定扩展名的文件，当上传过程中有文件名不允许时，组件将抛出异常。
原型：public void setAllowedFilesList(String allowedFilesList)
其中，allowedFilesList为允许上传的文件扩展名列表，各个扩展名之间以逗号分隔。如果想允许上传那些没有扩展名的文件，可以用两个逗号表示。例如：setAllowedFilesList("doc,txt,,")将允许上传带doc和txt扩展名的文件以及没有扩展名的文件。
7、setDeniedFilesList
作用：用于限制上传那些带有指定扩展名的文件。若有文件扩展名被限制，则上传时组件将抛出异常。
原型：public void setDeniedFilesList(String deniedFilesList)
其中，deniedFilesList为禁止上传的文件扩展名列表，各个扩展名之间以逗号分隔。如果想禁止上传那些没有扩展名的文件，可以用两个逗号来表示。例如：setDeniedFilesList("exe,bat,,")将禁止上传带exe和bat扩展名的文件以及没有扩展名的文件。
8、setMaxFileSize
作用：设定每个文件允许上传的最大长度。
原型：public void setMaxFileSize(long maxFileSize)
其中，maxFileSize为为每个文件允许上传的最大长度，当文件超出此长度时，将不被上传。
9、setTotalMaxFileSize
作用：设定允许上传的文件的总长度，用于限制一次性上传的数据量大小。
原型：public void setTotalMaxFileSize(long totalMaxFileSize)
其中，totalMaxFileSize为允许上传的文件的总长度。
</FONT>
有些网站 动网， 上传图片后加给加上自己的字（是在图片上加的）
请问在JSP里如何实现？？
//添加水印,filePath 源图片路径， watermark 水印图片路径
public static boolean createMark(String filePath,String watermark) {
ImageIcon imgIcon=new ImageIcon(filePath);
Image theImg =imgIcon.getImage();
ImageIcon waterIcon=new ImageIcon(watermark);
Image waterImg =waterIcon.getImage();
int width=theImg.getWidth(null);
int height= theImg.getHeight(null);
BufferedImage bimage = new BufferedImage(width,height, BufferedImage.TYPE_INT_RGB);
Graphics2D g=bimage.creatGraphics( );
g.setColor(Color.red);
g.setBackground(Color.white);
g.drawImage(theImg, 0, 0, null );
g.drawImage(waterImg, 100, 100, null );
g.drawString("12233",10,10); //添加文字
g.dispose();
try{
FileOutputStream out=new FileOutputStream(filePath);
JPEGImageEncoder encoder =JPEGCodec.createJPEGEncoder(out);
JPEGEncodeParam param = encoder.getDefaultJPEGEncodeParam(bimage);
param.setQuality(50f, true);
encoder.encode(bimage, param);
out.close();
}catch(Exception e){ return false; }
return true;
}
/////////////////范例////////////////////
package package;
import java.io.*;
import javax.servlet.ServletException;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
public class upload
{
private static String newline = "/n";
private String uploadDirectory;
private String ContentType;
private String CharacterEncoding;
public upload()
{
uploadDirectory = ".";
ContentType = "";
CharacterEncoding = "";
}
private String getFileName(String s)
{
int i = s.lastIndexOf("//");
if(i < 0 || i >= s.length() - 1)
{
i = s.lastIndexOf("/");
if(i < 0 || i >= s.length() - 1)
return s;
}
return s.substring(i + 1);
}
public void setUploadDirectory(String s)
{
uploadDirectory = s;
}
public void setContentType(String s)
{
ContentType = s;
int i;
if((i = ContentType.indexOf("boundary=")) != -1)
{
ContentType = ContentType.substring(i + 9);
ContentType = "--" + ContentType;
}
}
public void setCharacterEncoding(String s)
{
CharacterEncoding = s;
}
public String uploadFile(HttpServletRequest httpservletrequest)
throws ServletException, IOException
{
String s = null;
setCharacterEncoding(httpservletrequest.getCharacterEncoding());
setContentType(httpservletrequest.getContentType());
s = uploadFile(httpservletrequest.getInputStream());
return s;
}
public String uploadFile(ServletInputStream servletinputstream)
throws ServletException, IOException
{
String s = null;
String s1 = null;
byte abyte0[] = new byte[4096];
byte abyte1[] = new byte[4096];
int ai[] = new int[1];
int ai1[] = new int[1];
String s2;
while((s2 = readLine(abyte0, ai, servletinputstream, CharacterEncoding)) != null)
{
int i = s2.indexOf("filename=");
if(i >= 0)
{
s2 = s2.substring(i + 10);
if((i = s2.indexOf("/"")) > 0)
s2 = s2.substring(0, i);
break;
}
}
s1 = s2;
if(s1 != null && !s1.equals("/""))
{
s1 = getFileName(s1);
String s3 = readLine(abyte0, ai, servletinputstream, CharacterEncoding);
if(s3.indexOf("Content-Type") >= 0)
readLine(abyte0, ai, servletinputstream, CharacterEncoding);
File file = new File(uploadDirectory, s1);
FileOutputStream fileoutputstream = new FileOutputStream(file);
while((s3 = readLine(abyte0, ai, servletinputstream, CharacterEncoding)) != null)
{
if(s3.indexOf(ContentType) == 0 && abyte0[0] == 45)
break;
if(s != null)
{
fileoutputstream.write(abyte1, 0, ai1[0]);
fileoutputstream.flush();
}
s = readLine(abyte1, ai1, servletinputstream, CharacterEncoding);
if(s == null || s.indexOf(ContentType) == 0 && abyte1[0] == 45)
break;
fileoutputstream.write(abyte0, 0, ai[0]);
fileoutputstream.flush();
}
byte byte0;
if(newline.length() == 1)
byte0 = 2;
else
byte0 = 1;
if(s != null && abyte1[0] != 45 && ai1[0] > newline.length() * byte0)
fileoutputstream.write(abyte1, 0, ai1[0] - newline.length() * byte0);
if(s3 != null && abyte0[0] != 45 && ai[0] > newline.length() * byte0)
fileoutputstream.write(abyte0, 0, ai[0] - newline.length() * byte0);
fileoutputstream.close();
}
return s1;
}
private String readLine(byte abyte0[], int ai[], ServletInputStream servletinputstream, String s)
{
ai[0] = servletinputstream.readLine(abyte0, 0, abyte0.length);
if(ai[0] == -1)
return null;
break MISSING_BLOCK_LABEL_27;
Object obj;
obj;
return null;
if(s == null)
return new String(abyte0, 0, ai[0]);
return new String(abyte0, 0, ai[0], s);
obj;
return null;
}
}
JSP页：
<%@page contentType="text/html;charset=gb2312" import="package.upload"%>
<%
String Dir = "c:/dir/upload";
String fn="";
upload upload = new upload();
upload.setUploadDirectory(Dir);
fn=upload.uploadFile(request);
%>
随机图片名称
<%
mySmartUpload.initialize(pageContext);
mySmartUpload.service(request,response);
mySmartUpload.upload();
String fn=mySmartUpload.getFiles().getFile(0).getFileName();
mySmartUpload.save("upload/"); //文件保存的目录为upload
out.println("已经成功上传了文件，请查看<a href=upload/"+fn+">这里</a>");
%>
上面的程序可以上传图片，不过只能上传gif或者JPG图片。
而且保存图片在upload文件夹下面，要想GIF或Jpg图片的名称变为年+月+日+随机数.gif或年+月+日+随机数.jpg
只允许上传jpg或gif图片，在客户端用javaScript控制要好些。
变图片名称可用如下代码：自己看看就明白了。:
//得到实际路径
String realPath = this.masRequest.getRequest().getRealPath("/");
String userPhotoPath = realPath + "images//UserPhoto//";
userPhotoPath = MasString.replace(userPhotoPath,"//","////");
if (!file.getFileName().trim().equals(""))
{
//根据系统时间生成文件名
Date nowTime = new Date();
emp_Photo = userPhotoPath + String.valueOf(nowTime.getTime()) +"."+ file.getFileExt();
file.saveAs(emp_Photo);
System.out.println("file.saveAs() = " + "OK!!!");
- 作者： zengyingming 2006年07月28日, 星期五 14:44 回复（0） | 引用（0） 加入博采
- 曾颖明的博客关于作者
- 曾颖明的博客关于作者
- ShaderlabVS 作者的博客
- swool作者rango的博客
- 博客作者应该学习的15个国外博客
- 关于作者
- 关于作者
- 关于作者
- 关于作者
- 关于大学的任务(作者：梦幻尤里)
- 关于stardict作者胡正的提议
- 关于如何更改myeclipse的作者问题
- systemd作者博客
- 博客以及作者说明
- 我的职场十年----作者:谢耘 (转贴---博客中国)
- codes51竟然抓取CSDN博客中作者的文章篡改
- 关于我的博客
- 关于我的博客
- oracle8+hibernate
- dwrutil
- SecondLife 架构剖析
- 如何选择光源[机器视觉系列]
- Don’t repeat the DAO!
- 曾颖明的博客关于作者
- 曾颖明的博客关于作者
- 浏览器对象
- JSP内置对象
- 用java模拟球随机运动
- JavaScript内置对象
- 作用域scope概念
- 光学镜头概述及分类[机器视觉系列]
- asp中session具体是什么
