zhuixinjian 努力，成就自我！ http://zhuixinjian.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 一个JSP多级菜单 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/144495  发表时间: 2007年11月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

js 代码
  1. //******************************************   
  2.   
  3. //【转载】：http://blog.csdn.net/kanjing/archive/2004/08/06/67561.aspx   
  4.   
  5. //******************************************   
  6.   
  7. 做网页时，为了节约空间和美观，时常会用到多级的菜单，这里是一个JavaScript和Html混编的一个多级树型菜单的全部代码   
  8.   
  9. <%@ page contentType="text/html; charset=gb2312" language="java" import="java.sql.*" errorPage="error.jsp" %>    
  10. <html>    
  11. <head>    
  12. <title>多级树型菜单</title>    
  13. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />    
  14. <script language="JavaScript1.2">    
  15. var head="photos/display:''"    
  16. img1=new Image()    
  17. img1.src="photos/fold.gif"    
  18. img2=new Image()    
  19. img2.src="photos/open.gif"    
  20. function change(){    
  21.   if(!document.all)    
  22.      return    
  23.   if (event.srcElement.id=="foldheader") {    
  24.      var srcIndex = event.srcElement.sourceIndex    
  25.      var nested = document.all[srcIndex+1]    
  26.      if (nested.style.display=="none") {    
  27.         nested.style.display=''    
  28.         event.srcElement.style.liststyleImage="url(photos/open.gif)"    
  29.      }    
  30.      else {    
  31.         nested.style.display="none"    
  32.         event.srcElement.style.liststyleImage="url(photos/fold.gif)"    
  33.      }    
  34.   }    
  35. }    
  36. document.onclick=change    
  37. //-->    
  38. </script>    
  39. <script language="JavaScript" type="text/javascript">    
  40. <!--    
  41.    var popup = null;    
  42.    function inputorderid() {      
  43.        popup = window.open('jspInputOrderid.jsp', '请输入订单编号','width=200,height=150,resizable=0,scrollbars=no');    
  44.    }    
  45.    function account() {     
  46.        popup = window.open('jspAccountReceivable.jsp', '请选择客户名称','width=200,height=200,resizable=0,scrollbars=no');    
  47.    }    
  48. function oppaccount(){    
  49. popup = window.open('jspOppAccount.jsp', '请选择机会类型','width=200,height=200,resizable=0,scrollbars=no');    
  50. }    
  51. function accountcust(){     
  52. popup = window.open('jspAccountCust.jsp', '请选择客户地域','width=262,height=150,resizable=0,scrollbars=no');    
  53. }    
  54. function OrderAccount(){    
  55. popup = window.open('jspAccountOrder.jsp', '请选择客户及订单有效日期范围','width=200,height=200,resizable=0,scrollbars=no');    
  56.   
  57. }    
  58. //-->    
  59. </script>    
  60. <style type="text/css">    
  61.   
  62. li {    
  63. font-family: "宋体", "新宋体";    
  64. font-size: 9pt;    
  65. line-height: 13pt;    
  66. margin-right: 5px;    
  67. cursor: hand;    
  68. }   
  69. #foldheader{    
  70. cursor:hand;    
  71. list-style-image:url(photos/fold.gif);    
  72. font-family: "宋体", "新宋体";    
  73. font-size: 10pt;    
  74. }   
  75. #foldinglist{    
  76. list-style-image:url(photos/list.gif);    
  77. font-family: "宋体", "新宋体";    
  78. font-size: 9pt;    
  79. }    
  80. BODY {    
  81. SCROLLBAR-FACE-COLOR: #6699CC;    
  82. SCROLLBAR-HIGHLIGHT-COLOR: #A6C4E1;    
  83. SCROLLBAR-SHADOW-COLOR: #A6C4E1;    
  84. SCROLLBAR-3DLIGHT-COLOR: #A6C4E1;    
  85. SCROLLBAR-ARROW-COLOR:  #A6C4E1;    
  86. SCROLLBAR-TRACK-COLOR: #A6C4E1;    
  87. SCROLLBAR-DARKSHADOW-COLOR: #A6C4E1;    
  88. }    
  89.   
  90. A        { text-decoration:none; }    
  91. A:link       { text-decoration:none;  color: #000066;  }    
  92. A:visited    { text-decoration:none;  color: #000033;  }    
  93. A:hover      {    
  94. text-decoration:underline;    
  95. color: #FF0000;    
  96. }    
  97. </style>    
  98. </head>    
  99. <body bgcolor="#CBDCED" leftmargin="3" topmargin="0">    
  100. <table width="100%" height="33" border="0" cellpadding="0" cellspacing="0">    
  101.  <tr>    
  102.    <td></td>    
  103.  </tr>    
  104. </table>    
  105. <table width="100%" cellpadding="0" cellspacing="0" frame="void" align="left">    
  106.  <tr>    
  107.    <td>    
  108. <fieldset style="width:100%" align="left">    
  109.      <legend><a href="" target="_blank"><font size="2"> JETCRM B/S2003 </font></a></legend>    
  110.      <dl class="pt12normal">    
  111.  <li id="foldheader"> 客户管理</li>    
  112.  <ul id="foldinglist">    
  113.    <li id="foldheader"> 客户管理</li>    
  114.    <dl id="foldinglist" style="display:none">    
  115.      <li><a href="customer_add.jsp" target="mainFrame"> 新建客户</a></li>    
  116.      <li><a href="customer_query.jsp" target="mainFrame"> 客户查询</a></li>    
  117.    <li><a href="menu.jsp#" onClick="accountcust()"> 客户统计</a></li>    
  118.    </dl>    
  119.    <li id="foldheader"> 联系人管理</li>    
  120.    <dl id="foldinglist" style="display:none">    
  121.      <li><a href="contact_add.jsp" target="mainFrame" class=black> 新建联系人</a></li>    
  122.      <li><a href="contact_query.jsp" target="mainFrame" class=black> 联系人查询</a></li>    
  123.    </dl>    
  124.    <li id="foldheader"> 竞争对手管理</li>    
  125.    <dl id="foldinglist" style="display:none">    
  126.      <li><a href="adversary_add.jsp" target="mainFrame" class=black> 新建竞争对手</a></li>    
  127.      <li><a href="adversary_query.jsp" target="mainFrame" class=black> 竞争对手查询</a></li>    
  128.    </dl>    
  129.  </ul>    
  130.  <li id="foldheader">服务管理</li>    
  131.  <ul id="foldinglist" style="display:none">    
  132.  <li id="foldheader">联系历史</li>    
  133.  <dl id="foldinglist" style="display:none">    
  134.  <li><a href="ContactHistory_add.jsp" target="mainFrame" class=black>新建联系记录</a></li>    
  135.      <li><a href="ContactHistory_list.jsp" target="mainFrame" class="balck">浏览联系记录</a></li>    
  136.    </dl>    
  137.    <li> 邮件发送</li>    
  138.    <li id="foldheader">服务请求记录</li>    
  139.    <dl id="foldinglist" style="display:none">    
  140.            <li><a href="jsprequester_add.jsp" target="mainFrame" class=black>新建服务请求</a></li>    
  141.            <li><a href="showRequesterlist.jsp" target="mainFrame" class="balck">服务请求浏览</a></li>    
  142.    </dl>    
  143.    <li id="foldheader">客户投诉</li>    
  144.    <dl id="foldinglist" style="display:none">    
  145.      <li><a href="jspFeedback_add.jsp" target="mainFrame">新建投诉记录</a></li>    
  146.      <li><a href="feedback_list.jsp" target="mainFrame">投诉查询</a></li>    
  147.      <li>投诉统计</li>    
  148.    </dl>    
  149.  </ul>    
  150.  <li id="foldheader">销售管理</li>    
  151.  <ul id="foldinglist">    
  152.    <li id="foldheader"> 机会管理</li>    
  153.    <dl id="foldinglist" style="display:none">    
  154.      <li><a href="jspOppMan.jsp" target="mainFrame">新建机会</a></li>    
  155.      <li><a href="jspOppQuery.jsp" target="mainFrame">机会查询</a></li>    
  156.      <li><a href="menu.jsp#" onClick="oppaccount()">机会统计</a></li>    
  157.    </dl>    
  158.    <li id="foldheader">定单管理</li>    
  159.    <dl id="foldinglist" style="display:none">    
  160.      <li><a href="jspNewOrder.jsp" target="mainFrame">新建定单</a></li>    
  161.      <li><a href="jspOrderQry.jsp" target="mainFrame">定单查询</a></li>    
  162.      <li><a href="jspFufilOrder.jsp" target="mainFrame">订单履行</a></li>    
  163.      <li><a href="jspFufilOrder.jsp" target="mainFrame">订单履行</a></li>    
  164.       <li><a href="menu.jsp#" onClick="OrderAccount">订单额统计</a></li>    
  165.      <li><a href="menu.jsp#" onClick=" inputorderid()">履行或结案</a></li>    
  166.      <li><a href="menu.jsp#" onClick=" account()">应收款统计</a></li>    
  167.    </dl>    
  168.    <li id="foldheader">报价管理</li>    
  169.    <dl id="foldinglist" style="display:none">    
  170.      <li><a href="jspQuote_add.jsp" target="mainFrame">新建报价单</a></li>    
  171.      <li><a href="jspQuote_list.jsp" target="mainFrame">浏览报价单</a></li>    
  172.    </dl>    
  173.  </ul>    
  174.  <li id="foldheader">系统管理</li>    
  175.  <ul id="foldinglist">    
  176.    <li>权限管理</li>    
  177.      <li><a href="jspBaseDataInsert.jsp" target="mainFrame">基础数据设置</a></li>    
  178.  <li><a href="jspSetEmployee.jsp" target="mainFrame">员工管理</a></li>    
  179.  <li><a href="jsppurview_set.jsp" target="mainFrame">权限设置</a></li>    
  180.  </ul>    
  181.        <li id="foldheader"><a href="#" target="mainFrame">重新登录</a></li>    
  182. </dl>    
  183. </fieldset>    
  184.  </td>    
  185.  </tr>    
  186.  <tr>    
  187.    <td> </td>    
  188.  </tr>    
  189. </table>    
  190. </body>    
  191. </html>  

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Wed, 28 Nov 2007 14:09:35 +0800 http://zhuixinjian.javaeye.com/blog/144495 http://zhuixinjian.javaeye.com/blog/144495 恋爱秘籍！！！ zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/106190  发表时间: 2007年07月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

追MM如猎，且为活猎，而后悦之，而后驯之。
下猎如饿虎之扑食也，扑之，MM必惊，惊则逃，愤而追，必伤矣。
中猎如老叟之垂钓也。以饵诱之，投其所好，然提钩之时，恐有不愿。
上猎如蜘蛛之结网也。与MM之亲友结网，MM自难避之，而后可近之，进而悦之。
然，上上之猎，乃不猎之猎，以天地之势拥之，以春风之姿抚之，MM遇之，如鱼之投渊，鸟之投林，何其畅矣。缘之所致，自然而然。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 27 Jul 2007 18:45:02 +0800 http://zhuixinjian.javaeye.com/blog/106190 http://zhuixinjian.javaeye.com/blog/106190 恋爱笔记二 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/103729  发表时间: 2007年07月21日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最近迷上《重庆森林》中一段音乐《California Dreaming》，很能让人在烦躁的心情中沉静下来。
聊天，轻松，愉快，我爱上了这种感觉。
可她不愿意来北京，理由是北京的气候不好。她说，在生存压力相同的情况下，气候很重要。
她分析问题总是有一条致命伤，如同对待我们的感情，距离是个致命伤一样。那么我该如何解决应对？
我想我要做的不是求她来北京，这样只会使我在众多的候选人中一落千丈。我要想办法让她爱上北京的气候！对，就是这样。那么就想想怎么实施吧。
请她来北京旅游，我想她对北京的气候应该是被误导性的，北京的气候还是很好的，至少比武汉的夏天凉快，冬天暖和，也正是这样的气候能让这里的人全身心的投入工作。那么什么时候请她来玩呢？我有两个休假时间，一个是马上到来的8月，可能有换休的时间（连续加班5个月，可怜。），但是这个时间是不适合邀请她来北京玩的，虽然她愿意让我接近她，但是一切还是进度有点快了。我或许可以用这个时间回去看看她，在家乡玩玩（有4年没看看家乡的变化了）。那么10.1吧，这是个很好的机会，到9月再修订具体的计划。记住：计划永远没有变化快！
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 21 Jul 2007 10:57:45 +0800 http://zhuixinjian.javaeye.com/blog/103729 http://zhuixinjian.javaeye.com/blog/103729 林肯个人传记 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/103721  发表时间: 2007年07月21日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

1818年(9岁)，母亲去世。

　　1831年(22岁)，经商失败。

　　1832年(23岁)，竞选州议员落选。

　　同年(23岁)，工作丢了。想就读法学院，但未获入学资格。

　　1833年(24岁)，向朋友借钱经商。

　　同年年底(24岁)，再次破产。接下来，他花了16年时间才把债还清。

　　1834年(25岁)，再次竞选州议员，这次赢了。

　　1835年(26岁)，订婚后即将结婚时，未婚妻死了。

　　1836年(27岁)，精神完全崩溃，卧病在床六个月。

　　1838年(29岁)，争取成为州议员的发言人——没有成功。

　　1840年(31岁)，争取成为选举人——落选了。

　　1843年(34岁)，参加国会大选——又落选了。

　　1846年(37岁)，再次参加国会大选——这回当选了。前往华盛顿特区，表现可圈可点。

　　1848年(39岁)，寻求国会议员连任，失败。

　　1849年(40岁)，想在自己州内担任土地局长的工作，遭到拒绝。

　　1854年(45岁)，竞选美国参议员，落选。

　　1856年(47岁)，在共和party内争取副总统的提名——得票不足100张。

　　1860年(51岁)，当选美国总统。成为美国历史上最伟大的总统之一。

　　生下来就一无所有的林肯，终其一生都在面对挫败。他曾经绝望至极，但从没有放弃人生这场跳高比赛。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 21 Jul 2007 10:16:18 +0800 http://zhuixinjian.javaeye.com/blog/103721 http://zhuixinjian.javaeye.com/blog/103721 恋爱笔记一 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/103300  发表时间: 2007年07月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

昨天和她谈了谈，感觉还好，只是遇到一个很难的问题，那就是两人之间的距离问题。我在北京，她在湖北荆州，我曾想过双休过去看看她，可是计算下，真是时间太仓促！就算我周五晚上8：47坐Z11\Z12 周六早上7.14到武汉，然后能坐上到荆州的车，那么12：00以前赶到荆州，那么我在周日的下午又得赶回来。时间太紧张了！

怎么办，我该怎样处理这件事情，还有一年她就毕业了，我等一年？只有这么办了。
一年啊，说长不长，说短也不短，长的足够发生任何可能发生的事，短的也不过12个月，一晃而已！

想一想她分析问题时的冷静，真的让人害怕！

其实我又何必想那么多，珍惜此刻！

我将担忧说成居安思危，她说那是古时形容国家，我答，国家只是个大一些的家。她笑！
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 20 Jul 2007 18:42:32 +0800 http://zhuixinjian.javaeye.com/blog/103300 http://zhuixinjian.javaeye.com/blog/103300 心之轨迹 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/102902  发表时间: 2007年07月19日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

xombat 写到
有些事情是不能分析出来的,那就是感情.
我回答：
这句给我狠狠的敲了一下。
当我认真的去分析她说的每一句话的时候，得出很多让人很头疼的答案，有的欣喜，有的痛苦，有的疑惑不解，有的却一目了然。可实际上那只是她随口而出，或许不带心机，或许隐藏秘密。猜来猜去，只会让自己进入无尽的死循环。可恋爱不就是这种感觉吗？
xombat 又写到
以前我也那样,我想知道她的话里有什么含义,心里想的是什么,然后贴心的关心她,所以就对她的每句话都很在意,但是我竟然最后被形容为'很敏感'
恋爱有很多方式,这种方式叫自找苦吃.
抛出异常的爱 写到
每个人都不可能作回自己
不可能天真如前，不可能再次初恋，不可能总是享受惊奇。
人生是自己的人生。
所有的选择都有必然性。
不要把人生的柱子上划上不相关的一条条的时间底线。
不要把不相关的事连系在一起。

可最后我被zhangzhaofeng的这段话给敲醒了！
喜欢就喜欢
直到自己不喜欢为止
我是这么想的
难得喜欢 难得随心
做人要随心 随性
年龄又不大 何必 太成熟

这几天心里都不舒服，一遍一遍的遍历自己的感觉，来确定自己是不是由于空虚寂寞想去寻找安慰。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 19 Jul 2007 18:07:20 +0800 http://zhuixinjian.javaeye.com/blog/102902 http://zhuixinjian.javaeye.com/blog/102902 Spring的核心机制依赖注入简介(2) zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/53462  发表时间: 2007年02月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

从配置文件中，可以看到Spring管理bean的灵巧性。bean与bean之间的依赖关系放在配置文件里组织，而不是写在代码里。通过配置文件的指 定，Spring能精确地为每个bean注入属性。因此，配置文件里的bean的class元素，不能仅仅是接口，而必须是真正的实现类。

Spring会自动接管每个bean定义里的property元素定义。Spring会在执行无参数的构造器后、创建默认的bean实例后，调用对应的 setter方法为程序注入属性值。property定义的属性值将不再由该bean来主动创建、管理，而改为被动接收Spring的注入。

每个bean的id属性是该bean的惟一标识，程序通过id属性访问bean，bean与bean的依赖关系也通过id属性完成。

下面看主程序部分:
java 代码
 
  1. public class BeanTest  
  2. {  
  3. 　//主方法，程序的入口  
  4. 　public static void main(String[] args)throws Exception  
  5. 　{  
  6. 　　//因为是独立的应用程序，显式地实例化Spring的上下文。  
  7. 　　ApplicationContext ctx = new FileSystemXmlApplicationContext("bean.xml");  
  8. 　　//通过Person bean的id来获取bean实例，面向接口编程，因此  
  9. 　　//此处强制类型转换为接口类型  
  10. 　　Person p = (Person)ctx.getBean("chinese");  
  11. 　　//直接执行Person的userAxe()方法。  
  12. 　　p.useAxe();  
  13. 　}  
  14. }  
程序的执行结果如下:

石斧砍柴好慢

主程序调用Person的useAxe()方法时，该方法的方法体内需要使用Axe的实例，但程序里没有任何地方将特定的Person实例和Axe实例耦合在一起。或者说，程序里没有为Person实例传入Axe的实例，Axe实例由Spring在运行期间动态注入。

Person实例不仅不需要了解Axe实例的具体实现，甚至无须了解Axe的创建过程。程序在运行到需要Axe实例的时候，Spring创建了Axe实 例，然后注入给需要Axe实例的调用者。Person实例运行到需要Axe实例的地方，自然就产生了Axe实例，用来供Person实例使用。

调用者不仅无须关心被调用者的实现过程，连工厂定位都可以省略(真是按需分配啊!)。下面也给出使用Ant编译和运行该应用的简单脚本:
xml 代码
 
  1. ＜?xml version="1.0"?＞  
  2. ＜!-- 定义编译该项目的基本信息-->  
  3. ＜PROJECT name="spring" default="." basedir="."＞  
  4. ＜!-- 定义编译和运行该项目时所需的库文件 --＞  
  5. ＜PATH id=classpath＞  
  6. 　＜!-- 该路径下存放spring.jar和其他第三方类库 --＞  
  7. 　＜FILESET dir=..\..\lib＞  
  8. 　　＜INCLUDE name="*.jar" /＞  
  9. 　＜/FILESET＞  
  10. 　＜!-- 同时还需要引用已经编译过的class文件--＞  
  11. 　＜PATHELEMENT path="." /＞  
  12. ＜/PATH＞  
  13. ＜!-- 编译全部的java文件--＞  
  14. ＜TARGET description="Compile all source code" name="compile"＞  
  15. ＜!-- 指定编译后的class文件的存放位置 --＞  
  16. ＜JAVAC debug="true" destdir="."＞  
  17. 　deprecation="false" optimize="false" failonerror="true"＞  
  18. 　＜!-- 指定需要编译的源文件的存放位置 --＞  
  19. 　＜SRC path="." /＞  
  20. 　＜!-- 指定编译这些java文件需要的类库位置--＞  
  21. 　＜CLASSPATH refid="classpath" /＞  
  22. ＜/JAVAC＞  
  23. ＜/TARGET＞  
  24. ＜!-- 运行特定的主程序 --＞  
  25. ＜TARGET description="run the main class" name="run" depends="compile"＞  
  26. ＜!-- 指定运行的主程序:lee.BeanTest。--＞  
  27. ＜JAVA failonerror="true" fork="yes" classname="lee.BeanTest"＞  
  28. 　＜!-- 指定运行这些java文件需要的类库位置--＞  
  29. 　＜CLASSPATH refid="classpath" /＞  
  30. ＜/JAVA＞  
  31. ＜/TARGET＞  
  32. ＜/PROJECT＞  
如果需要改写Axe的实现类。或者说，提供另一个实现类给Person实例使用。Person接口、Chinese类都无须改变。只需提供另一个Axe的实现，然后对配置文件进行简单的修改即可。

Axe的另一个实现如下:
java 代码
 
  1. //Axe的另一个实现类 SteelAxe  
  2. public class SteelAxe implements Axe  
  3. {  
  4. 　//默认构造器  
  5. 　public SteelAxe()  
  6. 　{}  
  7. 　//实现Axe接口的chop方法  
  8. 　public String chop()  
  9. 　{  
  10. 　　return "钢斧砍柴真快";  
  11. 　}  
  12. }  
然后，修改原来的Spring配置文件，在其中增加如下一行:
xml 代码
 
  1. ＜!-- 定义一个steelAxe bean--＞  
  2. ＜BEAN class=lee.SteelAxe id=steelAxe />  
该行重新定义了一个Axe的实现:SteelAxe。然后修改chinese bean的配置，将原来传入stoneAxe的地方改为传入steelAxe。也就是将
java 代码
 
  1. ＜REF local="”stoneAxe”/"＞  
改成
java 代码
 
  1. ＜REF local="”steelAxe”/"＞  
此时再次执行程序，将得到如下结果:

钢斧砍柴真快

Person与Axe之间没有任何代码耦合关系，bean与bean之间的依赖关系由Spring管理。采用setter方法为目标bean注入属性的方式，称为设值注入。

业务对象的更换变得相当简单，对象与对象之间的依赖关系从代码里分离出来，通过配置文件动态管理。

构造注入

所谓构造注入，指通过构造函数来完成依赖关系的设定，而不是通过setter方法。对前面代码Chinese类做简单的修改，修改后的代码如下:
java 代码
 
  1. //Chinese实现Person接口  
  2. public class Chinese implements Person  
  3. {  
  4. 　//面向Axe接口编程，而不是具体的实现类  
  5. 　private Axe axe;  
  6. 　//默认的构造器  
  7. 　public Chinese()  
  8. 　{}  
  9. 　//构造注入所需的带参数的构造器  
  10. 　public Chinse(Axe axe)  
  11. 　{  
  12. 　　this.axe = axe;  
  13. 　}  
  14. 　//实现Person接口的useAxe方法  
  15. 　public void useAxe()  
  16. 　{  
  17. 　　System.out.println(axe.chop());  
  18. 　}  
  19. }  
       此时无须Chinese类里的setAxe方法，构造Person实例时，Spring为Person实例注入所依赖的Axe实例。构造注入的配置文件也需做简单的修改，修改后的配置文件如下:    
xml 代码
 
  1. ＜!-- 下面是标准的XML文件头 --＞  
  2. ＜xml version="1.0" encoding="gb2312"?＞  
  3. ＜!-- 下面一行定义Spring的XML配置文件的dtd --＞  
  4. 　"http://www.springframework.org/dtd/spring-beans.dtd"＞  
  5. ＜!-- 以上三行对所有的Spring配置文件都是相同的 --＞  
  6. ＜!-- Spring配置文件的根元素 --＞  
  7. ＜BEANS＞  
  8. 　＜!—定义第一个bean，该bean的id是chinese, class指定该bean实例的实现类 --＞  
  9. 　＜BEAN class=lee.Chinese id=chinese>  
  10. ＜/BEAN＞  
  11. ＜!-- 定义stoneAxe bean --＞  
  12. ＜BEAN class=lee.SteelAxe id=steelAxe />  
  13. ＜/BEANS＞  
执行效果与使用steelAxe设值注入时的执行效果完全一样。区别在于:创建Person实例中Axe属性的时机不同——设值注入是现创建一个默认的bean实例，然后调用对应的构造方法注入依赖关系。而构造注入则在创建bean实例时，已经完成了依赖关系的
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 09 Feb 2007 10:39:41 +0800 http://zhuixinjian.javaeye.com/blog/53462 http://zhuixinjian.javaeye.com/blog/53462 Spring的核心机制依赖注入简介 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/53460  发表时间: 2007年02月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Spring能有效地组织J2EE应用各层的对象。不管是控制层的Action对象，还是业务层的Service对象，还是持久层的DAO对象，都可在 Spring的管理下有机地协调、运行。Spring将各层的对象以松耦合的方式组织在一起，Action对象无须关心Service对象的具体实现， Service对象无须关心持久层对象的具体实现，各层对象的调用完全面向接口。当系统需要重构时，代码的改写量将大大减少。

上面所说的一切都得宜于Spring的核心机制，依赖注入。依赖注入让bean与bean之间以配置文件组织在一起，而不是以硬编码的方式耦合在一起。理解依赖注入

依赖注入(Dependency Injection)和控制反转(Inversion of Control)是同一个概念。具体含义是:当某个角色(可能是一个Java实例，调用者)需要另一个角色(另一个Java实例，被调用者)的协助时，在 传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在Spring里，创建被调用者的工作不再由调用者来完成，因此称为控制反转;创建被调用者 实例的工作通常由Spring容器来完成，然后注入调用者，因此也称为依赖注入。

不管是依赖注入，还是控制反转，都说明Spring采用动态、灵活的方式来管理各种对象。对象与对象之间的具体实现互相透明。在理解依赖注入之前，看如下这个问题在各种社会形态里如何解决:一个人(Java实例，调用者)需要一把斧子(Java实例，被调用者)。

(1)原始社会里，几乎没有社会分工。需要斧子的人(调用者)只能自己去磨一把斧子(被调用者)。对应的情形为:Java程序里的调用者自己创建被调用者。

(2)进入工业社会，工厂出现。斧子不再由普通人完成，而在工厂里被生产出来，此时需要斧子的人(调用者)找到工厂，购买斧子，无须关心斧子的制造过程。对应Java程序的简单工厂的设计模式。

(3)进入“按需分配”社会，需要斧子的人不需要找到工厂，坐在家里发出一个简单指令:需要斧子。斧子就自然出现在他面前。对应Spring的依赖注入。

第一种情况下，Java实例的调用者创建被调用的Java实例，必然要求被调用的Java类出现在调用者的代码里。无法实现二者之间的松耦合。

第二种情况下，调用者无须关心被调用者具体实现过程，只需要找到符合某种标准(接口)的实例，即可使用。此时调用的代码面向接口编程，可以让调用者和被调用者解耦，这也是工厂模式大量使用的原因。但调用者需要自己定位工厂，调用者与特定工厂耦合在一起。

第三种情况下，调用者无须自己定位工厂，程序运行到需要被调用者时，系统自动提供被调用者实例。事实上，调用者和被调用者都处于Spring的管理下，二者之间的依赖关系由Spring提供。

所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助时，无须在代码中创建被调用者，而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间依赖关系的管理。依赖注入通常有两种:

·设值注入。

·构造注入。

设值注入
          设值注入是指通过setter方法传入被调用者的实例。这种注入方式简单、直观，因而在Spring的依赖注入里大量使用。看下面代码，
是Person的接口
java 代码
 
  1. //定义Person接口  
  2. public interface Person  
  3. {  
  4. 　//Person接口里定义一个使用斧子的方法  
  5. 　public void useAxe();  
  6. }  
然后是Axe的接口
java 代码
 
  1. //定义Axe接口  
  2.   
  3. public interface Axe  
  4. {  
  5. 　//Axe接口里有个砍的方法  
  6. 　public void chop();  
  7. }  

Person的实现类
java 代码
 
  1. //Chinese实现Person接口  
  2.   
  3. public class Chinese implements Person  
  4. {  
  5. 　//面向Axe接口编程，而不是具体的实现类  
  6. 　private Axe axe;  
  7. 　//默认的构造器  
  8. 　public Chinese()  
  9. 　{}  
  10. 　//设值注入所需的setter方法  
  11. 　public void setAxe(Axe axe)  
  12. 　{  
  13. 　　this.axe = axe;  
  14. 　}  
  15. 　//实现Person接口的useAxe方法  
  16. 　public void useAxe()  
  17. 　{  
  18. 　　System.out.println(axe.chop());  
  19. 　}  
  20. }  
Axe的第一个实现类
java 代码
 
  1. //Axe的第一个实现类 StoneAxe  
  2.   
  3. public class StoneAxe implements Axe  
  4. {  
  5. 　//默认构造器  
  6. 　public StoneAxe()  
  7. 　{}  
  8. 　//实现Axe接口的chop方法  
  9. 　public String chop()  
  10. 　{  
  11. 　　return "石斧砍柴好慢";  
  12. 　}  
  13. } 
下面采用Spring的配置文件将Person实例和Axe实例组织在一起。配置文件如下所示:
xml 代码
 
  1. ＜!-- 下面是标准的XML文件头 --＞  
  2. ＜?xml version="1.0" encoding="gb2312"?＞  
  3. ＜!-- 下面一行定义Spring的XML配置文件的dtd --＞  
  4. "http://www.springframework.org/dtd/spring-beans.dtd"＞  
  5. ＜!-- 以上三行对所有的Spring配置文件都是相同的 --＞  
  6. ＜!-- Spring配置文件的根元素 --＞  
  7. ＜BEANS＞  
  8. 　＜!—定义第一bean，该bean的id是chinese, class指定该bean实例的实现类 --＞  
  9. 　＜BEAN class=lee.Chinese id=chinese＞  
  10. 　＜!-- property元素用来指定需要容器注入的属性，axe属性需要容器注入此处是设值注入，因此Chinese类必须拥有setAxe方法 --＞  
  11. ＜property name="axe"＞  
  12. ＜!-- 此处将另一个bean的引用注入给chinese bean --＞  
  13. ＜REF local="”stoneAxe”/"＞  
  14. ＜/property＞  
  15. ＜/BEAN＞  
  16. ＜!-- 定义stoneAxe bean --＞  
  17. ＜BEAN class=lee.StoneAxe id=stoneAxe /＞  
  18. ＜/BEANS＞  

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 09 Feb 2007 10:32:17 +0800 http://zhuixinjian.javaeye.com/blog/53460 http://zhuixinjian.javaeye.com/blog/53460 数据库连接池技术浅析 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/51750  发表时间: 2007年02月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一般情况下，在使用开发基于数据库的WEB程序时，传统的模式基本是按以下步骤：
1． 在主程序（如Servlet、Beans）中建立数据库连接。
2． 进行SQL操作，取出数据。
3． 断开数据库连接。
使用这种模式开发，存在很多问题。首先，我们要为每一次WEB请求（例如察看某一篇文章的内容）建立一次数据库连接，对于一次或几次操作来讲，或许你觉察 不到系统的开销，但是，对于WEB程序来讲，即使在某一较短的时间段内，其操作请求数也远远不是一两次，而是数十上百次（想想全世界的网友都有可能在您的 网页上查找资料），在这种情况下，系统开销是相当大的。事实上，在一个基于数据库的WEB系统中，建立数据库连接的操作将是系统中代价最大的操作之一。很 多时候，可能您的网站速度瓶颈就在于此。
其次，使用传统的模式，你必须去管理每一个连接，确保他们能被正确关闭，如果出现程序异常而导致某些连接未能关闭，将导致数据库系统中的内存泄露，最终我们将不得不重启数据库。
针对以上问题，我们首先想到可以采用一个全局的Connection对象，创建后就不关闭，以后程序一直使用它，这样就不存在每次创建、关闭连接的问题 了。但是，同一个连接使用次数过多，将会导致连接的不稳定，进而会导致WEB SERVER的频频重启。故而，这种方法也不可取。实际上，我们可以使用连接池技术来解决上述问题。首先，介绍一下连接池技术的基本原理。顾名思义，连接 池最基本的思想就是预先建立一些连接放置于内存对象中以备使用：

如图所示，当程序中需要建立数据库连接时，只须从内存中取一个来用而不用新建。同样，使用完毕后，只需放回内存即可。而连接的建立、断开都有连接池自身来 管理。同时，我们还可以通过设置连接池的参数来控制连接池中的连接数、每个连接的最大使用次数等等。通过使用连接池，将大大提高程序效率，同时，我们可以 通过其自身的管理机制来监视数据库连接的数量、使用情况等。下面我们以一个名为ConnectionPool的连接池为例来看看连接池的实现。先看看 ConnectionPool的基本属性：
m_ConnectionPoolSize：连接池中连接数量下限
m_ConnectionPoolMax：连接池中连接数量上限
m_ConnectionUseCount：一个连接的最大使用次数
m_ConnectionTimeout：一个连接的最长空闲时间
m_MaxConnections = -1：同一时间的最大连接数
m_timer：定时器
这些属性定义了连接池与其中的每个连接的有效状态值。连接池的自我管理，实际上就是通过定时的对每个连接的状态、连接的数量进行判断而进行相应操作。其管理流程如下：

通过上图，我们可以定义出ConnectionPool要完成管理所需要的基本接口：
public class ConnectionPool implements TimerListener{
public boolean initialize() //连接池初始化
public void destroy() //连接池的销毁
public synchronized java.sql.Connection getConnection() //取一个连接
public synchronized void close() //关闭一个连接
private synchronized void removeFromPool() //把一个连接从连接池中删除
private synchronized void fillPool() //维护连接池大小
public synchronized void TimerEvent() //定时器事件处理函数
}
通过这几个接口，已经可以完成连接池的基本管理。在TimeEvent（）函数中完成连接池的状态检验工作，fillPool()时连接池至少保持最小连接数。因为我们要保存每一个连接的状态，所以还需要一个数据库连接对象：
class ConnectionObject{
public java.sql.Connection con; public boolean inUse; //是否被使用标志
public long lastAccess; //最近一次开始使用时间
public int useCount; //被使用次数
}
加入了ConnectionObject对象后，在ConnectionPool中操作的应该只是ConnectionObject,而其他进程需要的只 是ConnectionObject的con属性，因此我们再加入一个类，作为其他进程获得与返回连接的接口： CLASS Conn{
GetConnection(); //从连接池中取出一个有效连接
CloseConnection(); //返回连接，此时并没有关闭连接，只是放回了连接池
DestroyPool(); //销毁连接池
}
最后我们的整个系统总的架构如下：

通过上面的介绍，我们可以看出，连接池技术的关键就是其自身的管理机制，以上的管理流程只是本人一点见解，关键是想向大家介绍一种思路，在此基础上，您可以进一步完善连接池技术为您所用。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 02 Feb 2007 08:37:28 +0800 http://zhuixinjian.javaeye.com/blog/51750 http://zhuixinjian.javaeye.com/blog/51750 JSP内置对象 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/51672  发表时间: 2007年02月01日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

内置对象是不需要声明，直接可以在JSP中使用的对象，JSP有以下几种内置对象：

request request表示HttpServletRequest对象。它包含了有关浏览器请求的信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法。

response response表示HttpServletResponse对象，并提供了几个用于设置送回 浏览器的响应的方法（如cookies,头信息等）

out out 对象是javax.jsp.JspWriter的一个实例，并提供了几个方法使你能用于向浏览器回送输出结果。

pageContext pageContext表示一个javax.servlet.jsp.PageContext对象。它是用于方便存取各种范围的名字空间、servlet相关的对象的API，并且包装了通用的servlet相关功能的方法。

session session表示一个请求的javax.servlet.http.HttpSession对象。Session可以存贮用户的状态信息

application applicaton 表示一个javax.servle.ServletContext对象。这有助于查找有关servlet引擎和servlet环境的信息

config config表示一个javax.servlet.ServletConfig对象。该对象用于存取servlet实例的初始化参数。

page page表示从该页面产生的一个servlet实例。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Thu, 01 Feb 2007 21:37:39 +0800 http://zhuixinjian.javaeye.com/blog/51672 http://zhuixinjian.javaeye.com/blog/51672 向数据库加入大量数据 zhuixinjian 作者: zhuixinjian  链接：http://zhuixinjian.javaeye.com/blog/46809  发表时间: 2007年01月13日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

InitSystemData
java 代码
 
  1. package com.bjsxt.oa.manager.impl;   
  2.   
  3. import java.io.BufferedReader;   
  4. import java.io.InputStream;   
  5. import java.io.InputStreamReader;   
  6. import java.text.SimpleDateFormat;   
  7. import java.util.List;   
  8.   
  9. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;   
  10.   
  11. import com.bjsxt.oa.manager.AclManager;   
  12. import com.bjsxt.oa.manager.DataDictionaryManager;   
  13. import com.bjsxt.oa.manager.InitSystemData;   
  14. import com.bjsxt.oa.manager.ModuleManager;   
  15. import com.bjsxt.oa.manager.PartyManager;   
  16. import com.bjsxt.oa.manager.PersonManager;   
  17. import com.bjsxt.oa.manager.RoleManager;   
  18. import com.bjsxt.oa.manager.UserManager;   
  19. import com.bjsxt.oa.model.DataDictionary;   
  20. import com.bjsxt.oa.model.Module;   
  21. import com.bjsxt.oa.model.Party;   
  22. import com.bjsxt.oa.model.Person;   
  23. import com.bjsxt.oa.model.Role;   
  24. import com.bjsxt.oa.model.User;   
  25.   
  26. public class InitSystemDataImpl extends HibernateDaoSupport implements InitSystemData{   
  27.   
  28.     static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");   
  29.        
  30.     private ModuleManager moduleManager;   
  31.     private RoleManager roleManager;   
  32.     private AclManager aclManager;   
  33.     private PersonManager personManager;   
  34.     private PartyManager partyManager;   
  35.     private UserManager userManager;   
  36.     private DataDictionaryManager dataDictionaryManager;   
  37.   
  38.     public void addInitSystemData(){   
  39.         addInitModuleData();   
  40.         addInitRoleData();   
  41.         addInitPartyData();   
  42.         addInitPersonData();   
  43.         addInitDictionaryData();   
  44.     }   
  45.        
  46.     //初始化模块信息   
  47.     public void addInitModuleData(){   
  48.         try {   
  49.             InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("module.txt");   
  50.                
  51.             BufferedReader reader = new BufferedReader(new InputStreamReader(is));   
  52.             String line = null;   
  53.             Module parent = null;   
  54.             int order = 1;   
  55.             while((line = reader.readLine()) != null){   
  56.                 if(line.trim().equals("")){   
  57.                     continue;   
  58.                 }   
  59.                    
  60.                 //submodule   
  61.                 if(line.startsWith("\t")){   
  62.                     String[] ss = line.trim().split(",");   
  63.                     Module sub = new Module();   
  64.                     sub.setName(ss[0].trim());   
  65.                     sub.setSn(ss[1].trim());   
  66.                     sub.setUrl(ss[2].trim());   
  67.                     sub.setOrderNo(order++);   
  68.                     moduleManager.addModule(sub, parent.getId());   
  69.                 }else{ //parentmodule   
  70.                     String[] ss = line.trim().split(",");   
  71.                     parent = new Module();   
  72.                     parent.setName(ss[0].trim());   
  73.                     parent.setSn(ss[1].trim());   
  74.                     parent.setOrderNo(order++);   
  75.                     moduleManager.addModule(parent, 0);   
  76.                 }   
  77.             }   
  78.         } catch (Exception e) {   
  79.             e.printStackTrace();   
  80.             throw new RuntimeException(e);   
  81.         }   
  82.     }   
  83.        
  84.     //初始化角色信息以及角色的访问权限   
  85.     public void addInitRoleData(){   
  86.         try {   
  87.             InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("role.txt");   
  88.                
  89.             BufferedReader reader = new BufferedReader(new InputStreamReader(is));   
  90.             String line = null;   
  91.             while((line = reader.readLine()) != null){   
  92.                 if(line.trim().equals("")){   
  93.                     continue;   
  94.                 }   
  95.                 String[] ss = line.trim().split(":");   
  96.                    
  97.                 Role role = new Role();   
  98.                 role.setName(ss[0].trim());   
  99.                 roleManager.addRole(role);   
  100.                    
  101.                 //获取被分配的模块列表   
  102.                 String moduleString = ss[1].trim();   
  103.                 String[] moduleNames = moduleString.split(",");   
  104.                 int[] moduleIds = new int[moduleNames.length];   
  105.                 for(int i=0; i
  106.                     List list = getHibernateTemplate().find("from Module where name = ?",moduleNames[i]);   
  107.                     if(list.isEmpty()){   
  108.                         throw new RuntimeException("找不到相应模块["+moduleNames[i]+"]");   
  109.                     }   
  110.                     if(list.size() > 1){   
  111.                         throw new RuntimeException("存在同名模块["+moduleNames[i]+"]");   
  112.                     }   
  113.                     Module m = (Module)list.get(0);   
  114.                     moduleIds[i] = m.getId();   
  115.                 }   
  116.                 aclManager.addAcls(role.getId(), moduleIds);   
  117.             }   
  118.         } catch (Exception e) {   
  119.             e.printStackTrace();   
  120.             throw new RuntimeException(e);   
  121.         }   
  122.     }   
  123.        
  124.     //初始化机构信息   
  125.     public void addInitPartyData(){   
  126.         try {   
  127.             InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("party.txt");   
  128.                
  129.             BufferedReader reader = new BufferedReader(new InputStreamReader(is));   
  130.             String line = null;   
  131.             Party parent = null;   
  132.             Party sub = null;   
  133.             while((line = reader.readLine()) != null){   
  134.                 if(line.trim().equals("")){   
  135.                     continue;   
  136.                 }   
  137.                 String name = line.trim();   
  138.                 //第三级机构信息   
  139.                 if(line.startsWith("\t\t")){   
  140.                     Party subsub = new Party();   
  141.                     subsub.setName(name);   
  142.                     subsub.setParent(sub);   
  143.                     getHibernateTemplate().save(subsub);   
  144.                     subsub.setSn(sub.getSn()+"_"+subsub.getId()); //设置SN的值   
  145.                     getHibernateTemplate().update(subsub);   
  146.                 }   
  147.                 //第二级机构信息   
  148.                 else if(line.startsWith("\t")){   
  149.                     sub = new Party();   
  150.                     sub.setName(name);   
  151.                     sub.setParent(parent);   
  152.                     getHibernateTemplate().save(sub);   
  153.                     sub.setSn(parent.getSn()+"_"+sub.getId());   
  154.                     getHibernateTemplate().update(sub);   
  155.                 }else{ //parentmodule   
  156.                     parent = new Party();   
  157.                     parent.setName(name);   
  158.                     getHibernateTemplate().save(parent);   
  159.                     parent.setSn(parent.getId()+"");   
  160.                     getHibernateTemplate().update(parent);   
  161.                 }   
  162.             }   
  163.         } catch (Exception e) {   
  164.             e.printStackTrace();   
  165.             throw new RuntimeException(e);   
  166.         }   
  167.     }   
  168.        
  169.     //初始化人员信息   
  170.     public void addInitPersonData(){   
  171.         try {   
  172.             InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream("person.txt");   
  173.                
  174.             BufferedReader reader = new BufferedReader(new InputStreamReader(is));   
  175.             String line = null;   
  176.             while((line = reader.readLine()) != null){   
  177.                 if(line.trim().equals("")){   
  178.                     continue;   
  179.                 }   
  180.                 String[] ss = line.trim().split(",");   
  181.                 String personName = ss[0];   
  182.                 String userAccount = ss[1];   
  183.                 String partyName = ss[2]; //从index==3起，是用户具有的角色   
  184.                    
  185.                 //根据名称获取机构信息   
  186.                 Party party = null;   
  187.                 List list = getHibernateTemplate().find("from Party where name = ?",partyName);   
  188.                 if(list.isEmpty() || list.size() > 1){   
  189.                     throw new RuntimeException("机构不存在或机构名称重复！");   
  190.                 }   
  191.                 party = (Party)list.get(0);   
  192.                    
  193.                 //根据角色名称，获取角色的ID列表   
  194.                 int roleslength = ss.length - 3;   
  195.                 int[] roleIds = new int[roleslength];   
  196.                 for(int i=0; i
  197.                     String roleName = ss[3 + i];   
  198.                     List rolelist = getHibernateTemplate().find("from Role where name = ?",roleName);   
  199.                     if(rolelist.isEmpty() || rolelist.size() > 1){   
  200.                         throw new RuntimeException("无法找到被分配的角色名称或角色名称