posts - 14, comments - 8, trackbacks - 0

2006年4月12日

用"window.showModalDialog()"實(shí)現(xiàn)DIV模式彈出窗口

1、test.html 測(cè)試頁
<html>
<head>
   <title>測(cè)試頁面</title>
   <style>
     .list {
       border-top:1 solid #8A2BE2;
       border-left:1 solid #8A2BE2;
       border-right:1 solid #8A2BE2;
     }
     .list td {
       border-bottom: 1 solid #8A2BE2;
     }
   </style>
   <script>
      function $(el) {
        return document.getElementById(el);
      }
      function showWin(param) {
        window.showModalDialog("dailog.htm", param, "dialogWidth:" +param.width +"px;dialogHeight:"+param.height+"px;center:yes;help:no;scroll:no;status:no;resizable:no");
      }

      function TB(tbid) {
        this.tb = typeof(tbid) == "string"? $(tbid): tbid;
        this.getValue = function(rowIndex, cellIndex){
          var trs = this.tb.rows[rowIndex];
          var _td = trs.cells[cellIndex];
          return _td.innerText;
        }
        this.setValue = function(rowIndex, cellIndex, value) {
          var _tr = this.tb.rows[rowIndex];
          var _td = _tr.cells[cellIndex];
          _td.innerText = value;
        }

        /********獲取行索引********/
        this.findRowIndex = function(eventSrc) {
          var _tr = eventSrc; //eventSrc事件源,必須在TD里獲事件源是TD或TR本身
          while(_tr.tagName != "TR") {
            _tr = _tr.parentNode;
          }
          var trs = this.tb.rows;
          for(var i = 0; i < trs.length; i++){
            if(_tr == trs[i]) return i;
          }
        }
      }

      function edit() {
        var tb = new TB("data");
        rIndex = tb.findRowIndex(event.srcElement);
        $("updateRowIndex").value = rIndex;
        $("userName").value = tb.getValue(rIndex, 1); //獲得姓名
        $("sex").value = tb.getValue(rIndex, 2); //獲得性別
        $("age").value = tb.getValue(rIndex, 3); //獲得年齡
         showWin({title:"修改用戶信息", width:390, height:230, _div:"openWin",parent:window});
      }

      function saveAndUpdateView(){
        var updateRowIndex = $("updateRowIndex").value;
        var tb = new TB($f("data")); //$f()在dailog.html定義,獲到的table是父窗口中的table
        tb.setValue(updateRowIndex, 1, $("userName").value);
        tb.setValue(updateRowIndex, 2, $("sex").value);
        tb.setValue(updateRowIndex, 3, $("age").value);
        close();
      }
   </script>

</head>
<body>
<p style="margin-top:60px">
   <center>
     <table id="data" class="list" width="460px">
       <tr>
         <td>編號(hào)</td>
         <td>用戶名</td>
         <td>性別</td>
         <td>年齡</td>
         <td>操作</td>
       </tr>
       <tr>
         <td>1</td>
         <td>李永勝</td>
         <td>男</td>
         <td>27</td>
         <td><span style="background:#FAEBD7;cursor:hand" onclick="edit();"> 修改 </span></td>
       </tr>
        <tr>
         <td>2</td>
         <td>林兄</td>
         <td>男</td>
         <td>27</td>
         <td><span style="background:#FAEBD7;cursor:hand" onclick="edit();"> 修改 </span></td>
       </tr>
        <tr>
         <td>3</td>
         <td>葉兄</td>
         <td>男</td>
         <td>23</td>
         <td><span style="background:#FAEBD7;cursor:hand" onclick="edit();"> 修改 </span></td>
       </tr>
     </table>
   </center>
</p>


<div id="openWin" style="display:none;">
    <form>
      <fieldSet>
        <legend>修改用戶</legend>
        <table>
          <tr>
            <td>用戶名</td><td><input type="text" id="userName"/></td>
          </tr>
          <tr>
            <td>性別</td><td><input type="text" id="sex"/></td>
          </tr>
          <tr>
            <td>年齡</td><td><input type="text" id="age"/></td>
          </tr>
        </table>
      </fieldSet>
      <input type="hidden" id="updateRowIndex"/>
    </form>
    <span style="background:#FAEBD7;cursor:hand" onclick="saveAndUpdateView();"> 修改 </span>
</div>
</body>
</html>

2、dailog.html 窗口原型

<html>
<head>
   <script>
     var param = window.dialogArguments; //傳過來的模式對(duì)話框窗口參數(shù)
     document.title = param.title; //窗口標(biāo)題,必須在窗口創(chuàng)建前實(shí)現(xiàn)s

   /********將父窗口的js加載進(jìn)來********/
     var scripts = param.parent.document.scripts;
     var _head = document.getElementsByTagName("head")[0];
     for(var n = 0; n < scripts.length; n++) {
       if(scripts[n].src) {
         var _script = newEl("script");
         _script.src = scripts[n].src;
         bind(_head, _script);
       }else{//加載直接在html文檔中寫的script
         var _script = newEl("script");
         _script.text = scripts[n].text;
          bind(_head, _script);
       }
     }

     /*******根據(jù)ID獲得父窗口的元素*********/
     function $f(el) {
       return param.parent.document.getElementById(el);
     }

    /***********創(chuàng)建一個(gè)HTML元素*******/
     function newEl(tagName) {
       return document.createElement(tagName);
     }
     /***********追加元素***************/
     function bind(ower, child) {
       ower.appendChild(child);
     }
     /*******在瀏覽器完成對(duì)象的裝載后立即觸發(fā)*********/
     window.onload = function() {
       var winDiv;
       if(typeof(param._div) == "string") {
         winDiv = param.parent.document.getElementById(param._div); //父窗口window對(duì)象,因?yàn)閜aram._div對(duì)象在父窗口
       }else{//直接傳對(duì)象過來
         winDiv = param._div;
       }
       $("mainDiv").innerHTML = winDiv.innerHTML; //將DIV內(nèi)容在彈出窗口中渲染
    }
   </script>
</head>
<body>
<center>
<div id="mainDiv" style="margin-top:20px;width:90%"></div>
</center>
</body>
</html>

posted @ 2008-05-05 10:43 虎嘯龍吟閱讀(1918) | 評(píng)論 (0) | 編輯收藏

得到準(zhǔn)確的在線人數(shù)統(tǒng)計(jì)－減少搜索引擎的干擾

轉(zhuǎn)自http://www.aygfsteel.com/flyffa/archive/2006/12/14/87722.html

基本方法：

基本的方法，網(wǎng)上到處都是，在 java 中就是在 web.xml 注冊(cè)一個(gè) Listener ，如下：

<listener-class>xp.web.SessionCounter</listener-class>

</listener>

SessionCounter.java 實(shí)現(xiàn) javax.servlet.http.HttpSessionListener 接口，分別在 sessionCreated 方法和 sessionDestroyed 方法中處理 session 數(shù)目。

這樣的方法有一定的問題：

1 、對(duì)于真正從網(wǎng)頁訪問的和搜索引擎的 spider 無法區(qū)分。

2 、當(dāng) Tomcat 重啟時(shí)，加載了上次持久化的 session 時(shí)，無法準(zhǔn)確計(jì)算在線數(shù)。

第二個(gè)問題我們可以不予考慮，這是 tomcat 容器實(shí)現(xiàn)不標(biāo)準(zhǔn)的問題，我們要解決的是的第一個(gè)問題，如何知道你的訪問的是真實(shí)的。

用 js 繞過搜索引擎 ：

做過 pv 統(tǒng)計(jì)的都知道，可以用 script 的方式得到你真實(shí)的 pageView 數(shù)目，我們現(xiàn)在要做的就是這樣的一件事情，我們?cè)谒械捻撁娑技尤胍欢卧挘?/span>

document.write ("<iframe src='/sessionCountServlet' width=0 height=0 frameborder=no border=0 MARGINWIDTH=0 MARGINHEIGHT=0 SCROLLING=no></iframe>");

</script>

然后我們寫上一個(gè) servlet 來記錄這些真正的訪問者。

import java.io.*;

import javax.servlet.*;

import javax.servlet.http.*;

public class SessionCounterServlet extends HttpServlet {

public SessionCounterServlet() {

super();

}

public void doGet(HttpServletRequest request,

HttpServletResponse response) throws IOException,

ServletException {

process(request, response);

}

public void doPost(HttpServletRequest request,

HttpServletResponse response) throws IOException,

ServletException {

process(request, response);

}

public void process(HttpServletRequest request,

HttpServletResponse response) throws IOException,

ServletException {

SessionCounter.put(request.getSession().getId());

}

我們可以看到這個(gè) servlet 只是做了一件事情，在 process 里面做了 SessionCounter.put(request.getSession().getId()); 這個(gè)動(dòng)作。

我們來看看我們的 SessionCounter 做了些什么：

import javax.servlet.http.*;

import java.util.Hashtable;

public class SessionCounter implements HttpSessionListener {

public SessionCounter() {

}

public static Hashtable m_real = new Hashtable();

private static long count = 0;

public void sessionCreated(HttpSessionEvent e) {

count++;

}

public void sessionDestroyed(HttpSessionEvent e) {

if (count > 0) {

count--;

}

m_real.remove(e.getSession().getId());

}

public static long getSessionCount() {

return count;

}

public static void put(String sessionId){

m_real.put(sessionId,"1");

}

public static int getRealCount(){

return m_real.size();

}

我們記錄了一個(gè)靜態(tài)的 hash 表來記錄激活狀態(tài)的 sessionid ，并在 session 銷毀的時(shí)候?qū)⑦@個(gè) sessionid 置為空。

怎么把 servlet 配置到 web 應(yīng)用中我就不羅唆了。

posted @ 2008-04-21 11:37 虎嘯龍吟閱讀(309) | 評(píng)論 (0) | 編輯收藏

JPA中的實(shí)體層次設(shè)計(jì)

這部分的內(nèi)容基本與Hibernate一致.JPA同樣支持3種類型的繼承形式:

1.Single Table Strategy ,單表策略,一張表包含基類與子類的所有數(shù)據(jù),很多情況下都是采用這樣的冗余設(shè)計(jì),通過一個(gè)discriminator來區(qū)分

2.Table Per Class Strategy ,每個(gè)子類對(duì)應(yīng)一張表,每張表都擁有基類的屬性

3.Join Strategy ,仍然是每個(gè)子類對(duì)應(yīng)一張表，但此表中不包含基類的屬性,僅僅是此子類的擴(kuò)展屬性,共享基類的屬性

以一個(gè)例子來說明3種情況:

一.單表策略

比如Pet作為基類,Cat和Dog繼承此類并擁有自己的擴(kuò)展屬性,如:

package com.denny_blue.ejb3.inheritance;

import java.io.Serializable;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "animal_type", discriminatorType = DiscriminatorType.STRING)
public class Pet implements Serializable {
private int id;

private String name;

private double weight;

public Pet() {
}

@Id
@GeneratedValue(strategy = GenerationType.AUTO)
public int getId() {
return id;
}

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

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public double getWeight() {
return weight;
}

public void setWeight(double weight) {
this.weight = weight;
}

}

Pet類值的注意的就是通過@Inheritance(strategy = InheritanceType.SINGLE_TABLE)確定采用單表策略,通過@DiscriminatorColumn確定了標(biāo)志值的字段和類型，我想熟悉hibernate的朋友對(duì)這些都應(yīng)該很熟悉.然后是兩個(gè)子類:

//Cat.java

package com.denny_blue.ejb3.inheritance;

import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorType;
import javax.persistence.DiscriminatorValue;
import javax.persistence.Entity;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue("cat")
public class Cat extends Pet {
private String HairBall;

public String getHairBall() {
return HairBall;
}

public void setHairBall(String hairBall) {
HairBall = hairBall;
}

}

//Dog.java

package com.denny_blue.ejb3.inheritance;

@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(discriminatorType=DiscriminatorType.STRING)
@DiscriminatorValue("dog")
public class Dog extends Pet {
private String trick;

public String getTrick() {
return trick;
}

public void setTrick(String trick) {
this.trick = trick;
}

}

兩個(gè)子類最值的關(guān)注的就是@DiscriminatorValue注釋,比如Cat的此值為cat,意味著當(dāng)Cat類型的Entity存入數(shù)據(jù)庫(kù)時(shí),JPA將自動(dòng)把cat的值賦給animal_type字段,Dog的值則為dog,由此就可以在同一張表中區(qū)分開兩個(gè)不同的子類.

二.Table per Class

采用Table Per Class策略的話，每個(gè)子類都將單獨(dú)建表，并且都獨(dú)立擁有基類中的所有屬性,互相之間不共享,在我們的例子中所要進(jìn)行的修改很小,像這樣:

//基類

@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Pet implements Serializable {
private int id;

private String name;

private double weight;

........

//子類:不需要任何設(shè)置

@Entity
public class Dog extends Pet {
private String trick;

.......

三.Join策略

每個(gè)子類同樣獨(dú)立建表,基類也獨(dú)立建表，只不過所有的子類的表中只有擴(kuò)展屬性,他們共享基類的表,在我們的例子中修改下即可:

//基類

@Entity
@Inheritance(strategy = InheritanceType.JOINED)
public class Pet implements Serializable {
private int id;

private String name;

private double weight;

........

//子類

@Entity

@Inheritance(strategy = InheritanceType.JOINED)
public class Dog extends Pet {
private String trick;

.......

這部分的內(nèi)容實(shí)在沒什么新意,與hibernate完全一致.JAVA EE5向spring和hibernate借鑒了太多東西.
{}

posted @ 2008-04-21 11:20 虎嘯龍吟閱讀(324) | 評(píng)論 (0) | 編輯收藏

oracle語句優(yōu)化大全

Oracle sql 性能優(yōu)化調(diào)整
　　1. 選用適合的ORACLE優(yōu)化器
　　ORACLE的優(yōu)化器共有3種：
　　a. RULE (基于規(guī)則)
　　b. COST (基于成本)
　　c. CHOOSE (選擇性)
　　設(shè)置缺省的優(yōu)化器，可以通過對(duì)init.ora文件中OPTIMIZER_MODE參數(shù)的各種聲明，如RULE，COST，CHOOSE，ALL_ROWS，F(xiàn)IRST_ROWS . 你當(dāng)然也在SQL句級(jí)或是會(huì)話(session)級(jí)對(duì)其進(jìn)行覆蓋。
　　為了使用基于成本的優(yōu)化器(CBO， Cost-Based Optimizer) ，你必須經(jīng)常運(yùn)行analyze 命令，以增加數(shù)據(jù)庫(kù)中的對(duì)象統(tǒng)計(jì)信息(object statistics)的準(zhǔn)確性。
　　如果數(shù)據(jù)庫(kù)的優(yōu)化器模式設(shè)置為選擇性(CHOOSE)，那么實(shí)際的優(yōu)化器模式將和是否運(yùn)行過analyze命令有關(guān)。如果table已經(jīng)被analyze過，優(yōu)化器模式將自動(dòng)成為CBO ，反之，數(shù)據(jù)庫(kù)將采用RULE形式的優(yōu)化器。
　　在缺省情況下，ORACLE采用CHOOSE優(yōu)化器，為了避免那些不必要的全表掃描(full table scan) ，你必須盡量避免使用CHOOSE優(yōu)化器，而直接采用基于規(guī)則或者基于成本的優(yōu)化器。
　　2. 訪問Table的方式ORACLE 采用兩種訪問表中記錄的方式
　　a. 全表掃描
　　全表掃描就是順序地訪問表中每條記錄。 ORACLE采用一次讀入多個(gè)數(shù)據(jù)塊(database block)的方式優(yōu)化全表掃描。
　　b. 通過ROWID訪問表
　　你可以采用基于ROWID的訪問方式情況，提高訪問表的效率， ROWID包含了表中記錄的物理位置信息……ORACLE采用索引(INDEX)實(shí)現(xiàn)了數(shù)據(jù)和存放數(shù)據(jù)的物理位置(ROWID)之間的聯(lián)系。通常索引提供了快速訪問ROWID的方法，因此那些基于索引列的查詢就可以得到性能上的提高。
　　3. 共享SQL語句
　　為了不重復(fù)解析相同的SQL語句，在第一次解析之后， ORACLE將SQL語句存放在內(nèi)存中。這塊位于系統(tǒng)全局區(qū)域SGA(system global area)的共享池(shared buffer pool)中的內(nèi)存可以被所有的數(shù)據(jù)庫(kù)用戶共享。因此，當(dāng)你執(zhí)行一個(gè)SQL語句(有時(shí)被稱為一個(gè)游標(biāo))時(shí)，如果它和之前的執(zhí)行過的語句完全相同， ORACLE就能很快獲得已經(jīng)被解析的語句以及最好的執(zhí)行路徑。 ORACLE的這個(gè)功能大大地提高了SQL的執(zhí)行性能并節(jié)省了內(nèi)存的使用。
可惜的是ORACLE只對(duì)簡(jiǎn)單的表提供高速緩沖(cache buffering) ，這個(gè)功能并不適用于多表連接查詢。數(shù)據(jù)庫(kù)管理員必須在init.ora中為這個(gè)區(qū)域設(shè)置合適的參數(shù)，當(dāng)這個(gè)內(nèi)存區(qū)域越大，就可以保留更多的語句，當(dāng)然被共享的可能性也就越大了。當(dāng)你向ORACLE 提交一個(gè)SQL語句，ORACLE會(huì)首先在這塊內(nèi)存中查找相同的語句。
　　這里需要注明的是，ORACLE對(duì)兩者采取的是一種嚴(yán)格匹配，要達(dá)成共享，SQL語句必須完全相同(包括空格，換行等)。
　　共享的語句必須滿足三個(gè)條件：
　　A. 字符級(jí)的比較：
　　當(dāng)前被執(zhí)行的語句和共享池中的語句必須完全相同。
　　例如：
　　SELECT * FROM EMP;
　　和下列每一個(gè)都不同
　　SELECT * from EMP;
　　Select * From Emp;
　　SELECT * FROM EMP;
　　B. 兩個(gè)語句所指的對(duì)象必須完全相同：
　　例如：
　　用戶　　對(duì)象名　　　　如何訪問
　　Jack　　　sal_limit　　 private synonym
　　Work_city　　 public synonym
　　Plant_detail　　public synonym
　　Jill　　　 sal_limit　　private synonym
　　Work_city　　 public synonym
　　Plant_detail　　table owner
　　考慮一下下列SQL語句能否在這兩個(gè)用戶之間共享。
　　C. 兩個(gè)SQL語句中必須使用相同的名字的綁定變量(bind variables)
　　例如：第一組的兩個(gè)SQL語句是相同的(可以共享)，而第二組中的兩個(gè)語句是不同的(即使在運(yùn)行時(shí)，賦于不同的綁定變量相同的值)
　　a.
　　selectpin，namefrompeoplewherepin=：blk1.pin;
　　selectpin，namefrompeoplewherepin=：blk1.pin;
b.
　　selectpin，namefrompeoplewherepin=：blk1.ot_ind;
　　selectpin，namefrompeoplewherepin=：blk1.ov_ind;
　　4. 選擇最有效率的表名順序(只在基于規(guī)則的優(yōu)化器中有效)
　　ORACLE的解析器按照從右到左的順序處理FROM子句中的表名，因此FROM子句中寫在最后的表(基礎(chǔ)表 driving table)將被最先處理。在FROM子句中包含多個(gè)表的情況下，你必須選擇記錄條數(shù)最少的表作為基礎(chǔ)表。當(dāng)ORACLE處理多個(gè)表時(shí)，會(huì)運(yùn)用排序及合并的方式連接它們。首先，掃描第一個(gè)表(FROM子句中最后的那個(gè)表)并對(duì)記錄進(jìn)行派序，然后掃描第二個(gè)表(FROM子句中最后第二個(gè)表)，最后將所有從第二個(gè)表中檢索出的記錄與第一個(gè)表中合適記錄進(jìn)行合并。
　　例如：
　　表 TAB1 16，384 條記錄
　　表 TAB2 1 條記錄
　　選擇TAB2作為基礎(chǔ)表 (最好的方法)
　　select count(*) from tab1，tab2 執(zhí)行時(shí)間0.96秒
　　選擇TAB2作為基礎(chǔ)表 (不佳的方法)
　　select count(*) from tab2，tab1 執(zhí)行時(shí)間26.09秒
　　如果有3個(gè)以上的表連接查詢，那就需要選擇交叉表(intersection table)作為基礎(chǔ)表，交叉表是指那個(gè)被其他表所引用的表。
　　例如： EMP表描述了LOCATION表和CATEGORY表的交集。
SELECT *
FROM LOCATION L ,
　　 CATEGORY C,
　　 EMP E
WHERE E.EMP_NO BETWEEN 1000 AND 2000
AND E.CAT_NO = C.CAT_NO
AND E.LOCN = L.LOCN
　　將比下列SQL更有效率
SELECT *
FROM EMP E ,
LOCATION L ,
　　 CATEGORY C
WHERE E.CAT_NO = C.CAT_NO
AND E.LOCN = L.LOCN
AND E.EMP_NO BETWEEN 1000 AND 2000
1. WHERE子句中的連接順序。
　　ORACLE采用自下而上的順序解析WHERE子句，根據(jù)這個(gè)原理，表之間的連接必須寫在其他WHERE條件之前，那些可以過濾掉最大數(shù)量記錄的條件必須寫在WHERE子句的末尾。
　　例如：
　　(低效，執(zhí)行時(shí)間156.3秒)
　　SELECT…
　　FROMEMPE
　　WHERESAL>50000
　　ANDJOB=‘MANAGER’
　　AND25<(SELECTCOUNT(*)FROMEMP
　　WHEREMGR=E.EMPNO);
　　(高效,執(zhí)行時(shí)間10.6秒)
　　SELECT…
　　FROMEMPE
　　WHERE25<(SELECTCOUNT(*)FROMEMP
　　WHEREMGR=E.EMPNO)
　　ANDSAL>50000
　　ANDJOB=‘MANAGER’;
　　2. SELECT子句中避免使用 ‘ * ’
　　當(dāng)你想在SELECT子句中列出所有的COLUMN時(shí)，使用動(dòng)態(tài)SQL列引用 ‘*’ 是一個(gè)方便的方法。不幸的是，這是一個(gè)非常低效的方法。實(shí)際上，ORACLE在解析的過程中，會(huì)將‘*’ 依次轉(zhuǎn)換成所有的列名，這個(gè)工作是通過查詢數(shù)據(jù)字典完成的，這意味著將耗費(fèi)更多的時(shí)間。
　　3. 減少訪問數(shù)據(jù)庫(kù)的次數(shù)
　　當(dāng)執(zhí)行每條SQL語句時(shí)， ORACLE在內(nèi)部執(zhí)行了許多工作：解析SQL語句，估算索引的利用率，綁定變量，讀數(shù)據(jù)塊等等。由此可見，減少訪問數(shù)據(jù)庫(kù)的次數(shù) ，就能實(shí)際上減少ORACLE的工作量。
　　例如，以下有三種方法可以檢索出雇員號(hào)等于0342或0291的職員。
　　方法1 (最低效)
　　SELECTEMP_NAME,SALARY,GRADE
　　FROMEMP
　　WHEREEMP_NO=342;
　　SELECTEMP_NAME,SALARY,GRADE
　　FROMEMP
　　WHEREEMP_NO=291;
　　方法2 (次低效)
　　DECLARE
　　CURSORC1(E_NONUMBER)IS
　　SELECTEMP_NAME,SALARY,GRADE
　　FROMEMP
　　WHEREEMP_NO=E_NO;
　　BEGIN
　　OPENC1(342);
　　FETCHC1INTO…,..,..;
　　OPENC1(291);
　　FETCHC1INTO…,..,..;
　　CLOSEC1;
　　END;
　　方法3 (高效)
以下是引用片段：
　　SELECTA.EMP_NAME,A.SALARY,A.GRADE,
　　B.EMP_NAME,B.SALARY,B.GRADE
　　FROMEMPA,EMPB
　　WHEREA.EMP_NO=342
　　ANDB.EMP_NO=291;
　　注意：
　　在SQL*Plus ， SQL*Forms和Pro*C中重新設(shè)置ARRAYSIZE參數(shù)，可以增加每次數(shù)據(jù)庫(kù)訪問的檢索數(shù)據(jù)量，建議值為200.
　　4. 使用DECODE函數(shù)來減少處理時(shí)間
　　使用DECODE函數(shù)可以避免重復(fù)掃描相同記錄或重復(fù)連接相同的表。
　　例如：
　　SELECTCOUNT(*)，SUM(SAL)
　　FROM　EMP
　　WHEREDEPT_NO=0020
　　ANDENAMELIKE　‘SMITH%’;
　　SELECTCOUNT(*)，SUM(SAL)
　　FROM　EMP
　　WHEREDEPT_NO=0030
　　ANDENAMELIKE　‘SMITH%’;
　　你可以用DECODE函數(shù)高效地得到相同結(jié)果
　　SELECTCOUNT(DECODE(DEPT_NO,0020,’X’,NULL))D0020_COUNT,
　　COUNT(DECODE(DEPT_NO,0030,’X’,NULL))D0030_COUNT,
　　SUM(DECODE(DEPT_NO,0020,SAL,NULL))D0020_SAL,
　　SUM(DECODE(DEPT_NO,0030,SAL,NULL))D0030_SAL
　　FROMEMPWHEREENAMELIKE‘SMITH%’;
　　類似的，DECODE函數(shù)也可以運(yùn)用于GROUP BY 和ORDER BY子句中。
　　5. 整合簡(jiǎn)單，無關(guān)聯(lián)的數(shù)據(jù)庫(kù)訪問
　　如果你有幾個(gè)簡(jiǎn)單的數(shù)據(jù)庫(kù)查詢語句，你可以把它們整合到一個(gè)查詢中(即使它們之間沒有關(guān)系)
　　例如：
　　SELECTNAME
　　FROMEMP
　　WHEREEMP_NO=1234;
　　SELECTNAME
　　FROMDPT
　　WHEREDPT_NO=10;
　　SELECTNAME
　　FROMCAT
　　WHERECAT_TYPE=‘RD’;
　　上面的3個(gè)查詢可以被合并成一個(gè)：
　　SELECTE.NAME,D.NAME,C.NAME
　　FROMCATC,DPTD,EMPE,DUALX
　　WHERENVL(‘X’,X.DUMMY)=NVL(‘X’,E.ROWID(+))
　　ANDNVL(‘X’,X.DUMMY)=NVL(‘X’,D.ROWID(+))
　　ANDNVL(‘X’,X.DUMMY)=NVL(‘X’,C.ROWID(+))
　　ANDE.EMP_NO(+)=1234
　　ANDD.DEPT_NO(+)=10
　　ANDC.CAT_TYPE(+)=‘RD’;

1. 刪除重復(fù)記錄
　　最高效的刪除重復(fù)記錄方法 ( 因?yàn)槭褂昧薘OWID)
DELETE FROM EMP E
WHERE E.ROWID > (SELECT MIN(X.ROWID)
　　　　　　　FROM EMP X
　　　　　　　WHERE X.EMP_NO = E.EMP_NO);
　　2. 用TRUNCATE替代DELETE
　　當(dāng)刪除表中的記錄時(shí)，在通常情況下，回滾段(rollback segments ) 用來存放可以被恢復(fù)的信息。如果你沒有COMMIT事務(wù)，ORACLE會(huì)將數(shù)據(jù)恢復(fù)到刪除之前的狀態(tài)(準(zhǔn)確地說是恢復(fù)到執(zhí)行刪除命令之前的狀況)
　　而當(dāng)運(yùn)用TRUNCATE時(shí)，回滾段不再存放任何可被恢復(fù)的信息。當(dāng)命令運(yùn)行后，數(shù)據(jù)不能被恢復(fù)。因此很少的資源被調(diào)用，執(zhí)行時(shí)間也會(huì)很短。
　　(譯者按： TRUNCATE只在刪除全表適用，TRUNCATE是DDL不是DML)
　　３. 盡量多使用COMMIT
　　只要有可能，在程序中盡量多使用COMMIT，這樣程序的性能得到提高，需求也會(huì)因?yàn)镃OMMIT所釋放的資源而減少：COMMIT所釋放的資源：
　　a. 回滾段上用于恢復(fù)數(shù)據(jù)的信息。
　　b. 被程序語句獲得的鎖
　　c. redo log buffer 中的空間
　　d. ORACLE為管理上述3種資源中的內(nèi)部花費(fèi)
　　(譯者按：在使用COMMIT時(shí)必須要注意到事務(wù)的完整性，現(xiàn)實(shí)中效率和事務(wù)完整性往往是魚和熊掌不可得兼)
　　４. 計(jì)算記錄條數(shù)
　　和一般的觀點(diǎn)相反， count(*) 比count(1)稍快，當(dāng)然如果可以通過索引檢索，對(duì)索引列的計(jì)數(shù)仍舊是最快的。例如 COUNT(EMPNO)
　　(譯者按：在CSDN論壇中，曾經(jīng)對(duì)此有過相當(dāng)熱烈的討論，作者的觀點(diǎn)并不十分準(zhǔn)確，通過實(shí)際的測(cè)試，上述三種方法并沒有顯著的性能差別)
　　５. 用Where子句替換HAVING子句
　　避免使用HAVING子句， HAVING 只會(huì)在檢索出所有記錄之后才對(duì)結(jié)果集進(jìn)行過濾。這個(gè)處理需要排序，總計(jì)等操作。如果能通過WHERE子句限制記錄的數(shù)目，那就能減少這方面的開銷。
　　例如：
　　低效
　　SELECTREGION，AVG(LOG_SIZE)
　　FROMLOCATION
　　GROUPBYREGION
　　HAVINGREGIONREGION!=‘SYDNEY’
　　ANDREGION!=‘PERTH’
　　高效
　　SELECTREGION，AVG(LOG_SIZE)
　　FROMLOCATION
　　WHEREREGIONREGION!=‘SYDNEY’
　　ANDREGION!=‘PERTH’
　　GROUPBYREGION
　　(譯者按： HAVING 中的條件一般用于對(duì)一些集合函數(shù)的比較，如COUNT() 等等。除此而外，一般的條件應(yīng)該寫在WHERE子句中)
　　6. 減少對(duì)表的查詢
　　在含有子查詢的SQL語句中，要特別注意減少對(duì)表的查詢。
　　例如：
　　低效
　　SELECTTAB_NAME
　　FROMTABLES
　　WHERETAB_NAME=(SELECTTAB_NAME
　　FROMTAB_COLUMNS
　　WHEREVERSION=604)
　　AND　DB_VER=(SELECTDB_VER
　　FROMTAB_COLUMNS
　　WHEREVERSION=604)
　　高效
　　SELECTTAB_NAME
　　FROMTABLES
　　WHERE(TAB_NAME,DB_VER)
　　=(SELECTTAB_NAME,DB_VER)
　　FROMTAB_COLUMNS
　　WHEREVERSION=604)
　　Update 多個(gè)Column 例子：
　　低效：
　　UPDATEEMP
　　SETEMP_CAT=(SELECTMAX(CATEGORY)FROMEMP_CATEGORIES)

1. 使用表的別名(Alias)
　　當(dāng)在SQL語句中連接多個(gè)表時(shí)，請(qǐng)使用表的別名并把別名前綴于每個(gè)Column上。這樣一來，就可以減少解析的時(shí)間并減少那些由Column歧義引起的語法錯(cuò)誤。
　　(Column歧義指的是由于SQL中不同的表具有相同的Column名，當(dāng)SQL語句中出現(xiàn)這個(gè)Column時(shí)，SQL解析器無法判斷這個(gè)Column的歸屬)
　　2. 用EXISTS替代IN
　　在許多基于基礎(chǔ)表的查詢中，為了滿足一個(gè)條件，往往需要對(duì)另一個(gè)表進(jìn)行聯(lián)接。在這種情況下，使用EXISTS(或NOT EXISTS)通常將提高查詢的效率。
　　低效：
　　SELECT*
　　FROMEMP(基礎(chǔ)表)
　　WHEREEMPNO>0
　　ANDDEPTNOIN(SELECTDEPTNO
　　FROMDEPT
　　WHERELOC=‘MELB’)
　　高效：
　　SELECT*
　　FROMEMP(基礎(chǔ)表)
　　WHEREEMPNO>0
　　ANDEXISTS(SELECT‘X’
　　FROMDEPT
　　WHEREDEPT.DEPTNO=EMP.DEPTNO
　　ANDLOC=‘MELB’)
　　(相對(duì)來說，用NOT EXISTS替換NOT IN 將更顯著地提高效率，下面將指出)
　　3. 用NOT EXISTS替代NOT IN
　　在子查詢中，NOT IN子句將執(zhí)行一個(gè)內(nèi)部的排序和合并。無論在哪種情況下，NOT IN都是最低效的 (因?yàn)樗鼘?duì)子查詢中的表執(zhí)行了一個(gè)全表遍歷)。為了避免使用NOT IN ，我們可以把它改寫成外連接(Outer Joins)或NOT EXISTS.
　　例如：
　　SELECT…
　　FROMEMP
　　WHEREDEPT_NONOTIN(SELECTDEPT_NO
　　FROMDEPT
　　WHEREDEPT_CAT=’A’);
　　為了提高效率。改寫為：
　　(方法一：高效)
　　SELECT….
　　FROMEMPA,DEPTB
　　WHEREA.DEPT_NO=B.DEPT(+)
　　ANDB.DEPT_NOISNULL
　　ANDB.DEPT_CAT(+)=‘A’

1. 用EXPLAIN PLAN 分析SQL語句

　　EXPLAIN PLAN 是一個(gè)很好的分析SQL語句的工具，它甚至可以在不執(zhí)行SQL的情況下分析語句。通過分析，我們就可以知道ORACLE是怎么樣連接表，使用什么方式掃描表(索引掃描或全表掃描)以及使用到的索引名稱。

　　你需要按照從里到外，從上到下的次序解讀分析的結(jié)果。 EXPLAIN PLAN分析的結(jié)果是用縮進(jìn)的格式排列的，最內(nèi)部的操作將被最先解讀，如果兩個(gè)操作處于同一層中，帶有最小操作號(hào)的將被首先執(zhí)行。

　　NESTED LOOP是少數(shù)不按照上述規(guī)則處理的操作，正確的執(zhí)行路徑是檢查對(duì)NESTED LOOP提供數(shù)據(jù)的操作，其中操作號(hào)最小的將被最先處理。

　　通過實(shí)踐，感到還是用SQLPLUS中的SET TRACE 功能比較方便。

　　舉例：

SQL> list
1 SELECT *
2 FROM dept, emp
　3* WHERE emp.deptno = dept.deptno
SQL> set autotrace traceonly /*traceonly 可以不顯示執(zhí)行結(jié)果*/
SQL> /
14 rows selected.
Execution Plan
----------------------------------------------------------
　0　　 SELECT STATEMENT Optimizer=CHOOSE
　1　　0　NESTED LOOPS
　2　　1　　TABLE ACCESS (FULL) OF 'EMP'
　3　　1　　TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'
　4　　3　　　INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)
Statistics
----------------------------------------------------------
　　　　0 recursive calls
　　　　2 db block gets
　　　 30 consistent gets
　　　　0 physical reads
　　　　0 redo size
　　　2598 bytes sent via SQL*Net to client
　　　503 bytes received via SQL*Net from client
　　　　2 SQL*Net roundtrips to/from client
　　　　0 sorts (memory)
　　　　0 sorts (disk)
　　　 14 rows processed

通過以上分析，可以得出實(shí)際的執(zhí)行步驟是：

　　1. TABLE ACCESS (FULL) OF 'EMP'

　　2. INDEX (UNIQUE SCAN) OF 'PK_DEPT' (UNIQUE)

　　3. TABLE ACCESS (BY INDEX ROWID) OF 'DEPT'

　　4. NESTED LOOPS (JOINING 1 AND 3)

　　注：目前許多第三方的工具如TOAD和ORACLE本身提供的工具如OMS的SQL Analyze都提供了極其方便的EXPLAIN PLAN工具。也許喜歡圖形化界面的朋友們可以選用它們。

　　2. 用索引提高效率

　　索引是表的一個(gè)概念部分，用來提高檢索數(shù)據(jù)的效率。實(shí)際上，ORACLE使用了一個(gè)復(fù)雜的自平衡B-tree結(jié)構(gòu)。通常，通過索引查詢數(shù)據(jù)比全表掃描要快。當(dāng)ORACLE找出執(zhí)行查詢和Update語句的最佳路徑時(shí)， ORACLE優(yōu)化器將使用索引。同樣在聯(lián)結(jié)多個(gè)表時(shí)使用索引也可以提高效率。另一個(gè)使用索引的好處是，它提供了主鍵(primary key)的唯一性驗(yàn)證。

　　除了那些LONG或LONG RAW數(shù)據(jù)類型，你可以索引幾乎所有的列。通常，在大型表中使用索引特別有效。當(dāng)然，你也會(huì)發(fā)現(xiàn)，在掃描小表時(shí)，使用索引同樣能提高效率。

　　雖然使用索引能得到查詢效率的提高，但是我們也必須注意到它的代價(jià)。索引需要空間來存儲(chǔ)，也需要定期維護(hù)，每當(dāng)有記錄在表中增減或索引列被修改時(shí)，索引本身也會(huì)被修改。這意味著每條記錄的INSERT ， DELETE ， UPDATE將為此多付出4 ， 5 次的磁盤I/O . 因?yàn)樗饕枰~外的存儲(chǔ)空間和處理，那些不必要的索引反而會(huì)使查詢反應(yīng)時(shí)間變慢。

　　定期的重構(gòu)索引是有必要的。

　　ALTER INDEX REBUILD

　　3. 索引的操作

　　ORACLE對(duì)索引有兩種訪問模式。

　　索引唯一掃描 ( INDEX UNIQUE SCAN)

　　大多數(shù)情況下，優(yōu)化器通過WHERE子句訪問INDEX.

表LODGING有兩個(gè)索引：建立在LODGING列上的唯一性索引LODGING_PK和建立在MANAGER列上的非唯一性索引LODGING$MANAGER.

　　SELECT*
　　FROMLODGING
　　WHERELODGING=‘ROSEHILL’;

　　在內(nèi)部，上述SQL將被分成兩步執(zhí)行，首先， LODGING_PK 索引將通過索引唯一掃描的方式被訪問，獲得相對(duì)應(yīng)的ROWID，通過ROWID訪問表的方式執(zhí)行下一步檢索。

　　如果被檢索返回的列包括在INDEX列中，ORACLE將不執(zhí)行第二步的處理(通過ROWID訪問表)。因?yàn)闄z索數(shù)據(jù)保存在索引中，單單訪問索引就可以完全滿足查詢結(jié)果。

　　下面SQL只需要INDEX UNIQUE SCAN 操作。

　　SELECTLODGING
　　FROMLODGING
　　WHERELODGING=‘ROSEHILL’;

　　索引范圍查詢(INDEX RANGE SCAN)

　　適用于兩種情況：

　　1. 基于一個(gè)范圍的檢索

　　2. 基于非唯一性索引的檢索

　　例1：

　　SELECT LODGING FROM LODGING WHERE LODGING LIKE ‘M%’;

　　WHERE子句條件包括一系列值， ORACLE將通過索引范圍查詢的方式查詢LODGING_PK . 由于索引范圍查詢將返回一組值，它的效率就要比索引唯一掃描低一些。

　　例2：

　　SELECTLODGING
　　FROMLODGING
　　WHEREMANAGER=‘BILLGATES’;

　　這個(gè)SQL的執(zhí)行分兩步， LODGING$MANAGER的索引范圍查詢(得到所有符合條件記錄的ROWID) 和下一步同過ROWID訪問表得到LODGING列的值。由于LODGING$MANAGER是一個(gè)非唯一性的索引，數(shù)據(jù)庫(kù)不能對(duì)它執(zhí)行索引唯一掃描。

　　由于SQL返回LODGING列，而它并不存在于LODGING$MANAGER索引中，所以在索引范圍查詢后會(huì)執(zhí)行一個(gè)通過ROWID訪問表的操作。

　　WHERE子句中，如果索引列所對(duì)應(yīng)的值的第一個(gè)字符由通配符(WILDCARD)開始，索引將不被采用。在這種情況下，ORACLE將使用全表掃描。

　　SELECTLODGING
　　FROMLODGING
　　WHEREMANAGERLIKE‘%HANMAN’;

1. 基礎(chǔ)表的選擇

　　基礎(chǔ)表(Driving Table)是指被最先訪問的表(通常以全表掃描的方式被訪問)。根據(jù)優(yōu)化器的不同， SQL語句中基礎(chǔ)表的選擇是不一樣的。

　　如果你使用的是CBO (COST BASED OPTIMIZER)，優(yōu)化器會(huì)檢查SQL語句中的每個(gè)表的物理大小，索引的狀態(tài)，然后選用花費(fèi)最低的執(zhí)行路徑。

　　如果你用RBO (RULE BASED OPTIMIZER) ，并且所有的連接條件都有索引對(duì)應(yīng)，在這種情況下，基礎(chǔ)表就是FROM 子句中列在最后的那個(gè)表。

　　舉例：

　　SELECTA.NAME，B.MANAGER
　　FROM　WORKERA，
　　LODGINGB
　　WHERE　A.LODGING=B.LODING;

　　由于LODGING表的LODING列上有一個(gè)索引，而且WORKER表中沒有相比較的索引， WORKER表將被作為查詢中的基礎(chǔ)表。

　　2. 多個(gè)平等的索引

　　當(dāng)SQL語句的執(zhí)行路徑可以使用分布在多個(gè)表上的多個(gè)索引時(shí)， ORACLE會(huì)同時(shí)使用多個(gè)索引并在運(yùn)行時(shí)對(duì)它們的記錄進(jìn)行合并，檢索出僅對(duì)全部索引有效的記錄。

　　在ORACLE選擇執(zhí)行路徑時(shí)，唯一性索引的等級(jí)高于非唯一性索引。然而這個(gè)規(guī)則只有當(dāng)WHERE子句中索引列和常量比較才有效。如果索引列和其他表的索引類相比較。這種子句在優(yōu)化器中的等級(jí)是非常低的。

　　如果不同表中兩個(gè)想同等級(jí)的索引將被引用， FROM子句中表的順序?qū)Q定哪個(gè)會(huì)被率先使用。 FROM子句中最后的表的索引將有最高的優(yōu)先級(jí)。

　　如果相同表中兩個(gè)想同等級(jí)的索引將被引用， WHERE子句中最先被引用的索引將有最高的優(yōu)先級(jí)。

　　舉例：

　　DEPTNO上有一個(gè)非唯一性索引，EMP_CAT也有一個(gè)非唯一性索引。

　　SELECTENAME，
　　FROMEMP
　　WHEREDEPT_NO=20
　　ANDEMP_CAT=‘A’;
這里，DEPTNO索引將被最先檢索，然后同EMP_CAT索引檢索出的記錄進(jìn)行合并。執(zhí)行路徑如下：
　　TABLEACCESSBYROWIDONEMP
　　AND-EQUAL
　　INDEXRANGESCANONDEPT_IDX
　　INDEXRANGESCANONCAT_IDX
　　3. 等式比較和范圍比較
　　當(dāng)WHERE子句中有索引列， ORACLE不能合并它們，ORACLE將用范圍比較。
　　舉例：
　　DEPTNO上有一個(gè)非唯一性索引，EMP_CAT也有一個(gè)非唯一性索引。
　　SELECTENAME
　　FROMEMP
　　WHEREDEPTNO>20
　　ANDEMP_CAT=‘A’;
　　這里只有EMP_CAT索引被用到，然后所有的記錄將逐條與DEPTNO條件進(jìn)行比較。執(zhí)行路徑如下：
　　TABLEACCESSBYROWIDONEMP
　　INDEXRANGESCANONCAT_IDX
　　4. 不明確的索引等級(jí)
　　當(dāng)ORACLE無法判斷索引的等級(jí)高低差別，優(yōu)化器將只使用一個(gè)索引，它就是在WHERE子句中被列在最前面的。
　　舉例：
　　DEPTNO上有一個(gè)非唯一性索引，EMP_CAT也有一個(gè)非唯一性索引。
　　SELECTENAME
　　FROMEMP
　　WHEREDEPTNO>20
　　ANDEMP_CAT>‘A’;
　　這里， ORACLE只用到了DEPT_NO索引。執(zhí)行路徑如下：
　　TABLEACCESSBYROWIDONEMP
　　INDEXRANGESCANONDEPT_IDX
　　譯者按：我們來試一下以下這種情況：
　SQL> select index_name， uniqueness from user_indexes where table_name = 'EMP'；
　　INDEX_NAME　　　　　　　　　　 UNIQUENES
　　------------------------------ ---------
　　EMPNO　　　　　　　　　　　　　UNIQUE
　　EMPTYPE　　　　　　　　　　　　NONUNIQUE
　　SQL> select * from emp where empno >= 2 and emp_type = 'A' ；
　　no rows selected
　　Execution Plan
　　----------------------------------------------------------
　　0　　　SELECT STATEMENT Optimizer=CHOOSE
　　1　　0　 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
　　2　　1　　 INDEX （RANGE SCAN） OF 'EMPTYPE' （NON-UNIQUE
　　雖然EMPNO是唯一性索引，但是由于它所做的是范圍比較，等級(jí)要比非唯一性索引的等式比較低!
　　5. 強(qiáng)制索引失效
　　如果兩個(gè)或以上索引具有相同的等級(jí)，你可以強(qiáng)制命令ORACLE優(yōu)化器使用其中的一個(gè)(通過它，檢索出的記錄數(shù)量少) .
　　舉例：
　　SELECTENAME
　　FROMEMP
　　WHEREEMPNO=7935
　　ANDDEPTNO+0=10/*DEPTNO上的索引將失效*/
　　ANDEMP_TYPE||‘’=‘A’/*EMP_TYPE上的索引將失效*/
　　這是一種相當(dāng)直接的提高查詢效率的辦法。但是你必須謹(jǐn)慎考慮這種策略，一般來說，只有在你希望單獨(dú)優(yōu)化幾個(gè)SQL時(shí)才能采用它。
　　這里有一個(gè)例子關(guān)于何時(shí)采用這種策略，
　　假設(shè)在EMP表的EMP_TYPE列上有一個(gè)非唯一性的索引而EMP_CLASS上沒有索引。
　　SELECTENAME
　　FROMEMP
　　WHEREEMP_TYPE=‘A’
　　ANDEMP_CLASS=‘X’;
　　優(yōu)化器會(huì)注意到EMP_TYPE上的索引并使用它。這是目前唯一的選擇。如果，一段時(shí)間以后，另一個(gè)非唯一性建立在EMP_CLASS上，優(yōu)化器必須對(duì)兩個(gè)索引進(jìn)行選擇，在通常情況下，優(yōu)化器將使用兩個(gè)索引并在他們的結(jié)果集合上執(zhí)行排序及合并。然而，如果其中一個(gè)索引(EMP_TYPE)接近于唯一性而另一個(gè)索引(EMP_CLASS)上有幾千個(gè)重復(fù)的值。排序及合并就會(huì)成為一種不必要的負(fù)擔(dān)。在這種情況下，你希望使優(yōu)化器屏蔽掉EMP_CLASS索引。
　　用下面的方案就可以解決問題。
　　SELECTENAME
　　FROMEMP
　　WHEREEMP_TYPE=‘A’
　　ANDEMP_CLASS||‘’=‘X’;

1. 避免在索引列上使用計(jì)算

　　WHERE子句中，如果索引列是函數(shù)的一部分。優(yōu)化器將不使用索引而使用全表掃描。

　　舉例：

　　低效：

　　SELECT…
　　FROMDEPT
　　WHERESAL*12>25000;

　　高效：

　　SELECT…
　　FROMDEPT
　　WHERESAL>25000/12;

　　：這是一個(gè)非常實(shí)用的規(guī)則，請(qǐng)務(wù)必牢記

　　2. 自動(dòng)選擇索引

　　如果表中有兩個(gè)以上(包括兩個(gè))索引，其中有一個(gè)唯一性索引，而其他是非唯一性。

　　在這種情況下，ORACLE將使用唯一性索引而完全忽略非唯一性索引。

　　舉例：

　　SELECTENAME
　　FROMEMP
　　WHEREEMPNO=2326
　　ANDDEPTNO=20;

　　這里，只有EMPNO上的索引是唯一性的，所以EMPNO索引將用來檢索記錄。

　　TABLEACCESSBYROWIDONEMP
　　INDEXUNIQUESCANONEMP_NO_IDX

　　3. 避免在索引列上使用NOT

　　通常，我們要避免在索引列上使用NOT， NOT會(huì)產(chǎn)生在和在索引列上使用函數(shù)相同的影響。當(dāng)ORACLE“遇到”NOT，他就會(huì)停止使用索引轉(zhuǎn)而執(zhí)行全表掃描。

　　舉例：

　　低效： (這里，不使用索引)

　　SELECT…
　　FROMDEPT
　　WHEREDEPT_CODENOT=0;

　　高效： (這里，使用了索引)

　　SELECT…
　　FROMDEPT
　　WHEREDEPT_CODE>0;

　　需要注意的是，在某些時(shí)候， ORACLE優(yōu)化器會(huì)自動(dòng)將NOT轉(zhuǎn)化成相對(duì)應(yīng)的關(guān)系操作符。

　　NOT > to <=

　　NOT >= to <

　　NOT < to >=

　　NOT <= to >

　　：在這個(gè)例子中，作者犯了一些錯(cuò)誤。例子中的低效率SQL是不能被執(zhí)行的。

　　我做了一些測(cè)試：

SQL> select * from emp where NOT empno > 1；
　no rows selected
　Execution Plan
　----------------------------------------------------------
　　0　　　SELECT STATEMENT Optimizer=CHOOSE
　1　　0　 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
　2　　1　　 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）
　　SQL> select * from emp where empno <= 1；
　no rows selected
　Execution Plan
　----------------------------------------------------------
　　0　　　SELECT STATEMENT Optimizer=CHOOSE
　1　　0　 TABLE ACCESS （BY INDEX ROWID） OF 'EMP'
　2　　1　　 INDEX （RANGE SCAN） OF 'EMPNO' （UNIQUE）

　　兩者的效率完全一樣，也許這符合作者關(guān)于“ 在某些時(shí)候， ORACLE優(yōu)化器會(huì)自動(dòng)將NOT轉(zhuǎn)化成相對(duì)應(yīng)的關(guān)系操作符” 的觀點(diǎn)。

　　4. 用>=替代>

　　如果DEPTNO上有一個(gè)索引，

　　高效：

　　SELECT*
　　FROMEMP
　　WHEREDEPTNO>=4

　　低效：

　　SELECT*
　　FROMEMP
　　WHEREDEPTNO>3

　　兩者的區(qū)別在于，前者DBMS將直接跳到第一個(gè)DEPT等于4的記錄而后者將首先定位到DEPTNO=3的記錄并且向前掃描到第一個(gè)DEPT大于3的記錄。

1. 避免在索引列上使用計(jì)算

　　WHERE子句中，如果索引列是函數(shù)的一部分。優(yōu)化器將不使用索引而使用全表掃描。

　　舉例：

　　低效：

　　SELECT…
　　FROMDEPT
　　WHERESAL*12>25000;

　　高效：

　　SELECT…
　　FROMDEPT
　　WHERESAL>25000/12;

　　：這是一個(gè)非常實(shí)用的規(guī)則，請(qǐng)務(wù)必牢記

　　2. 自動(dòng)選擇索引

　　如果表中有兩個(gè)以上(包括兩個(gè))索引，其中有一個(gè)唯一性索引，而其他是非唯一性。

　　在這種情況下，ORACLE將使用唯一性索引而完全忽略非唯一性索引。

　　舉例：

　　SELECTENAME
　　FROMEMP
　　WHEREEMPNO=2326
　　ANDDEPTNO=20;

　　這里，只有EMPNO上的索引是唯一性的，所以EMPNO索引將用來檢索記錄。

　　TABLEACCESSBYROWIDONEMP
　　INDEXUNIQUESCANONEMP_NO_IDX

　　3. 避免在索引列上使用NOT

　　舉例：

　　低效： (這里，不使用索引)

　　SELECT…
　　FROMDEPT
　　WHEREDEPT_CODENOT=0;

　　高效： (這里，使用了索引)

　　SELECT…
　　FROMDEPT
　　WHEREDEPT_CODE>0;

　　需要注意的是，在某些時(shí)候， ORACLE優(yōu)化器會(huì)自動(dòng)將NOT轉(zhuǎn)化成相對(duì)應(yīng)的關(guān)系操作符。

　　NOT > to <=

　　NOT >= to <

　　NOT < to >=

　　NOT <= to >

　　：在這個(gè)例子中，作者犯了一些錯(cuò)誤。例子中的低效率SQL是不能被執(zhí)行的。

　　我做了一些測(cè)試：

　　4. 用>=替代>

　　如果DEPTNO上有一個(gè)索引，

　　高效：

　　SELECT*
　　FROMEMP
　　WHEREDEPTNO>=4

　　低效：

　　SELECT*
　　FROMEMP
　　WHEREDEPTNO>3

　　兩者的區(qū)別在于，前者DBMS將直接跳到第一個(gè)DEPT等于4的記錄而后者將首先定位到DEPTNO=3的記錄并且向前掃描到第一個(gè)DEPT大于3的記錄。

{http://blog.chinaunix.net/u/20483/showart_546882.html}

posted @ 2008-04-20 11:33 虎嘯龍吟閱讀(938) | 評(píng)論 (0) | 編輯收藏

用JavaScript實(shí)現(xiàn)本地緩存

http://blog.chinaunix.net/u/21684/showart.php?id=537094

posted @ 2008-04-20 11:10 虎嘯龍吟閱讀(350) | 評(píng)論 (0) | 編輯收藏

ext中namespace命名規(guī)則

http://www.aygfsteel.com/zhangchao/archive/2008/03/19/187372.html

posted @ 2008-03-20 09:11 虎嘯龍吟閱讀(305) | 評(píng)論 (0) | 編輯收藏

帶checkBox下拉樹

http://www.smellcode.cn/index.php/javascript/jiyuext20dehanyoucheckboxdetree/

posted @ 2008-03-20 09:08 虎嘯龍吟閱讀(420) | 評(píng)論 (0) | 編輯收藏

JFreeChart圖

http://www.aygfsteel.com/amigoxie/archive/2008/02/20/180779.html

posted @ 2008-03-17 20:14 虎嘯龍吟閱讀(196) | 評(píng)論 (0) | 編輯收藏

一片關(guān)于JMS的文章

http://www.aygfsteel.com/pdw2009/archive/2006/05/10/45461.html

posted @ 2008-03-09 15:15 虎嘯龍吟閱讀(184) | 評(píng)論 (0) | 編輯收藏

源碼分析:HashMap

HashMap是Java新Collection Framework中用來代替HashTable的一個(gè)實(shí)現(xiàn)，HashMap和HashTable的區(qū)別是： HashMap是未經(jīng)同步的，而且允許null值。HashTable繼承Dictionary，而且使用了Enumeration，所以被建議不要使用。
HashMap的聲明如下：
public class HashMap extends AbstractMap implements Map, Cloneable,Serializable
有關(guān)AbstractMap：http://blog.csdn.net/treeroot/archive/2004/09/20/110343.aspx
有關(guān)Map：http://blog.csdn.net/treeroot/archive/2004/09/20/110331.aspx
有關(guān)Cloneable：http://blog.csdn.net/treeroot/archive/2004/09/07/96936.aspx
這個(gè)類比較復(fù)雜，這里只是重點(diǎn)分析了幾個(gè)方法，特別是后面涉及到很多內(nèi)部類都沒有解釋
不過都比較簡(jiǎn)單。

static final int DEFAULT_INITIAL_CAPACITY = 16; 默認(rèn)初始化大小

static final int MAXIMUM_CAPACITY = 1 << 30; 最大初始化大小

static final float DEFAULT_LOAD_FACTOR = 0.75f; 默認(rèn)加載因子

transient Entry[] table; 一個(gè)Entry類型的數(shù)組，數(shù)組的長(zhǎng)度為2的指數(shù)。

transient int size; 映射的個(gè)數(shù)

int threshold; 下一次擴(kuò)容時(shí)的值

final float loadFactor; 加載因子

transient volatile int modCount; 修改次數(shù)

public HashMap(int initialCapacity, float loadFactor) {
　　 if (initialCapacity < 0)
　　　　 throw new IllegalArgumentException("Illegal initial capacity: " +initialCapacity);
　　 if (initialCapacity > MAXIMUM_CAPACITY)
　　　　 initialCapacity = MAXIMUM_CAPACITY;
　　 if (loadFactor <= 0 || Float.isNaN(loadFactor))
　　　　 throw new IllegalArgumentException("Illegal load factor: " +loadFactor);
　　 int capacity = 1;
　　 while (capacity < initialCapacity)
　　　　 capacity <<= 1;
　　 this.loadFactor = loadFactor;
　　 threshold = (int)(capacity * loadFactor);
　　 table = new Entry[capacity];
　　 init();
}

public HashMap(int initialCapacity) {
　　 this(initialCapacity, DEFAULT_LOAD_FACTOR);
}

public HashMap() {
　　 this.loadFactor = DEFAULT_LOAD_FACTOR;
　　 threshold = (int)(DEFAULT_INITIAL_CAPACITY);
　　　　　　注意：這里應(yīng)該是一個(gè)失誤！應(yīng)該是：threshold =(int)(DEFAULT_INITIAL_CAPACITY * loadFactor);
　　 table = new Entry[DEFAULT_INITIAL_CAPACITY];
　　　init();
}

public HashMap(Map m) {
　　 this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　DEFAULT_LOAD_FACTOR);
　　 putAllForCreate(m);
}

void init() {}

static final Object NULL_KEY = new Object();

static Object maskNull(Object key){
　　 return (key == null ? NULL_KEY : key);
}

static Object unmaskNull(Object key) {
　　 return (key == NULL_KEY ? null : key);
}

static int hash(Object x) {
　　 int h = x.hashCode();
　　 h += ~(h << 9);
　　 h ^= (h >>> 14);
　　 h += (h << 4);
　　 h ^= (h >>> 10);
return h;
}
在HashTable中沒有這個(gè)方法，也就是說HashTable中是直接用對(duì)象的hashCode值，但是HashMap做了改進(jìn) 用這個(gè)算法來獲得哈希值。

static boolean eq(Object x, Object y) {
　　return x == y || x.equals(y);
}

static int indexFor(int h, int length) {
　　 return h & (length-1);
}
根據(jù)哈希值和數(shù)組的長(zhǎng)度來返回該hash值在數(shù)組中的位置，只是簡(jiǎn)單的與關(guān)系。

public int size() {
　　 return size;
}

public boolean isEmpty() {
　　return size == 0;
}

public Object get(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry e = table[i];
　　 while (true) {
　　　　 if (e == null) return e;
　　　　 if (e.hash == hash && eq(k, e.key)) return e.value;
　　　　 e = e.next;
　　 }
}
這個(gè)方法是獲取數(shù)據(jù)的方法，首先獲得哈希值，這里把null值掩飾了，并且hash值經(jīng)過函數(shù)hash()修正。然后計(jì)算該哈希值在數(shù)組中的索引值。如果該索引處的引用為null，表示HashMap中不存在這個(gè)映射。否則的話遍歷整個(gè)鏈表，這里找到了就返回,如果沒有找到就遍歷到鏈表末尾，返回null。這里的比較是這樣的：e.hash==hash && eq(k,e.key) 也就是說如果hash不同就肯定認(rèn)為不相等，eq就被短路了，只有在 hash相同的情況下才調(diào)用equals方法。現(xiàn)在我們?cè)撁靼譕bject中說的如果兩個(gè)對(duì)象equals返回true，他們的 hashCode應(yīng)該相同的道理了吧。假如兩個(gè)對(duì)象調(diào)用equals返回true，但是hashCode不一樣，那么在HashMap 里就認(rèn)為他們不相等。

public boolean containsKey(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry e = table[i];
　　 while (e != null) {
　　　　 if (e.hash == hash && eq(k, e.key)) return true;
　　　　 e = e.next;
　　 }
　　return false;
}
這個(gè)方法比上面的簡(jiǎn)單，先找到哈希位置，再遍歷整個(gè)鏈表，如果找到就返回true。

Entry getEntry(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry e = table[i];
　　 while (e != null && !(e.hash == hash && eq(k, e.key)))
　　　　 e = e.next;
　　 return e;
}
這個(gè)方法根據(jù)key值返回Entry節(jié)點(diǎn)，也是先獲得索引位置，再遍歷鏈表，如果沒有找到返回的是null。

public Object put(Object key, Object value) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 for (Entry e = table[i]; e != null; e = e.next) {
　　　　 if (e.hash == hash && eq(k, e.key)) {
　　　　　　 Object oldValue = e.value;
　　　　　　 e.value = value;
　　　　　　 e.recordAccess(this);
　　　　　　 return oldValue;
　　　　 }
　　 }
　　 modCount++;
　　 addEntry(hash, k, value, i);
　　 return null;
}
首先獲得hash索引位置，如果該位置的引用為null，那么直接插入一個(gè)映射，返回null。如果此處的引用不是null，必須遍歷鏈表，如果找到一個(gè)相同的key，那么就更新該value，同時(shí)返回原來的value值。如果遍歷完了沒有找到，說明該key值不存在，還是插入一個(gè)映射。如果hash值足夠離散的話，也就是說該索引沒有被使用的話，那么不不用遍歷鏈表了。相反，如果hash值不離散，極端的說如果是常數(shù)的話，所有的映射都會(huì)在這一個(gè)鏈表上，效率會(huì)極其低下。這里舉一個(gè)最簡(jiǎn)單的例子，寫兩
個(gè)不同的類作為key插入到HashMap中，效率會(huì)遠(yuǎn)遠(yuǎn)不同。
class Good{
　　int i;
　　public Good(int i){
　　　this.i=i;
　　}
　　public boolean equals(Object o){
　　　return (o instanceof Good) && (this.i==((Good)o).i)
　　}
　　public int hashCode(){
　　　return i;
　　}
}
class Bad{
　　int i;
　　public Good(int i){
　　　　this.i=i;
　　}
　　public boolean equals(Object o){
　　　　return (o instanceof Good) && (this.i==((Good)o).i)
　　}
　　public int hashCode(){
　　　return 0;
　　}
}
執(zhí)行代碼：
Map m1=new HashMap();
Map m2=new HashMap();
for(int i=0;i<100;i++){
　　m1.put(new Good(i),new Integer(i)); //這里效率非常高
}
for(int i=0;i<100;i++){
　　m2.put(new Bad(i),new Integer(i)); //這里幾乎要崩潰
}
上面的是兩個(gè)非常極端的例子，執(zhí)行一下就知道差別有多大。

private void putForCreate(Object key, Object value) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 for (Entry e = table[i]; e != null; e = e.next) {
　　　　 if (e.hash == hash && eq(k, e.key)) {
　　　　　　　 e.value = value;
　　　　　　　 return;
　　　　 }
　　 }
　　 createEntry(hash, k, value, i);
}

void putAllForCreate(Map m) {
　　 for (Iterator i = m.entrySet().iterator(); i.hasNext(); ) {
　　　　 Map.Entry e = (Map.Entry) i.next();
　　　　 putForCreate(e.getKey(), e.getValue());
　　 }
}
上面的兩個(gè)方法是被構(gòu)造函數(shù)和clone方法調(diào)用的。

void resize(int newCapacity) {
　　 Entry[] oldTable = table;
　　 int oldCapacity = oldTable.length;
　　 if (size < threshold || oldCapacity > newCapacity)
　　　　 return;
　　 Entry[] newTable = new Entry[newCapacity];
　　 transfer(newTable);
　　 table = newTable;
　　 threshold = (int)(newCapacity * loadFactor);
}
這個(gè)方法在需要的時(shí)候重新分配空間，相當(dāng)于ArrayList的ensureCapacity方法，不過這個(gè)更加復(fù)雜。

void transfer(Entry[] newTable) {
　　 Entry[] src = table;
　　 int newCapacity = newTable.length;
　　 for (int j = 0; j < src.length; j++) {
　　　　 Entry e = src[j];
　　　　 if (e != null) {
　　　　　　 src[j] = null;
　　　　　　 do {
　　　　　　　　　 Entry next = e.next;
　　　　　　　　　 int i = indexFor(e.hash, newCapacity);
　　　　　　　　　 e.next = newTable[i];
　　　　　　　　　 newTable[i] = e;
　　　　　　　　　 e = next;
　　　　　　 } while (e != null);
　　　　 }
　　 }
}
遍歷原來的數(shù)組，如果該Entry不是null的話，說明有映射，然后遍歷這個(gè)鏈表，把所有的映射插入到新的數(shù)組中，注意這里要從新計(jì)算索引位置。

public void putAll(Map t) {
　　 int n = t.size();
　　 if (n == 0)
　　　　 return;
　　 if (n >= threshold) {
　　　　 n = (int)(n / loadFactor + 1);
　　　　 if (n > MAXIMUM_CAPACITY)
　　　　　　 n = MAXIMUM_CAPACITY;
　　　　 int capacity = table.length;
　　　　 while (capacity < n) capacity <<= 1;
　　　　　　 resize(capacity);
　　 }
　　 for (Iterator i = t.entrySet().iterator(); i.hasNext(); ) {
　　　　 Map.Entry e = (Map.Entry) i.next();
　　　　 put(e.getKey(), e.getValue());
　　 }
}
這個(gè)方法先確定是否需要擴(kuò)大空間，然后循環(huán)調(diào)用put方法。

public Object remove(Object key) {
　　 Entry e = removeEntryForKey(key);
　　 return (e == null ? e : e.value);
}

Entry removeEntryForKey(Object key) {
　　 Object k = maskNull(key);
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry prev = table[i];
　　 Entry e = prev;
　　 while (e != null) { 　如果e==null表示不存在
　　　　 Entry next = e.next;
　　　　 if (e.hash == hash && eq(k, e.key)) {
　　　　　　 modCount++;
　　　　　　 size--;
　　　　　　 if (prev == e)
　　　　　　　　table[i] = next; 鏈表的第一個(gè)元素就是要?jiǎng)h除的，這里最好加一句 e.next=null.
　　　　　　 else
　　　　　　　　 prev.next = next; 存在擔(dān)不是鏈表的第一個(gè)元素，這里最好加一句 e.next=null.
　　　　　　 e.recordRemoval(this);
　　　　　　 return e;
　　　　 }
　　　　 prev = e;
　　　　 e = next;
　　 }
　　return e;　　　這里其實(shí)就是return null;
}
這個(gè)方法其實(shí)也不復(fù)雜，也是遍歷鏈表，這里建議加一句e.next=null,可以改為
if(prev==e)
　　table[i]=next;
else
　　prev.next=next;
e.next=null; 這一句是多加的，可以提高效率。
這里簡(jiǎn)單說明我的看法：
因?yàn)閑是被刪除的節(jié)點(diǎn)，刪除它其實(shí)就是指向它的指針指向它的后面一個(gè)節(jié)點(diǎn)。所以e可以作為GC回收的對(duì)象。
可以e還有一個(gè)next指針指向我們的數(shù)據(jù)，如果e沒有被回收。而且此時(shí)e.next指向的節(jié)點(diǎn)也變?yōu)闆]用的了，但是
卻有一個(gè)它的引用(e.next),所以雖然e的下一個(gè)節(jié)點(diǎn)沒用了，但是卻不能作為GC回收的對(duì)象，除非e先被回收。
雖然不一定會(huì)引起很大的問題，但是至少會(huì)影響GC的回收效率。就像數(shù)據(jù)庫(kù)中的外鍵引用一樣，刪除起來很麻煩呀。

Entry removeMapping(Object o) {
　　 if (!(o instanceof Map.Entry))
　　　　 return null;
　　 Map.Entry entry = (Map.Entry)o;
　　 Object k = maskNull(entry.getKey());
　　 int hash = hash(k);
　　 int i = indexFor(hash, table.length);
　　 Entry prev = table[i];
　　 Entry e = prev;
　　 while (e != null) {
　　　　 Entry next = e.next;
　　　　if (e.hash == hash && e.equals(entry)) {
　　　　　　 modCount++;
　　　　　　 size--;
　　　　　　if (prev == e)
　　　　　　　　 table[i] = next;
　　　　　　 else
　　　　　　　　 prev.next = next;
　　　　　　 e.recordRemoval(this);
　　　　　　 return e;
　　　　　 }
　　　　　 prev = e;
　　　　　 e = next;
　　 }
　　 return e;
}
這個(gè)方法和上面的一樣。

public void clear() {
　　 modCount++;
　　 Entry tab[] = table;
　　 for (int i = 0; i < tab.length; i++)
　　　　 tab[i] = null;
　　 size = 0;
}
同樣可以改進(jìn)

public boolean containsValue(Object value) {
　　 if (value == null)
　　　　 return containsNullValue();
　　 Entry tab[] = table;
　　 for (int i = 0; i < tab.length ; i++)
　　　　 for (Entry e = tab[i] ; e != null ; e = e.next)
　　　　　　 if (value.equals(e.value)) return true;
　　 return false;
}

private boolean containsNullValue() {
　　 Entry tab[] = table;
　　 for (int i = 0; i < tab.length ; i++)
　　　　 for (Entry e = tab[i] ; e != null ; e = e.next)
　　　　　　 if (e.value == null) return true;
　　 return false;
}

public Object clone() {
　　 HashMap result = null;
　　 try {
　　　　 result = (HashMap)super.clone();
　　 }
　　 catch (CloneNotSupportedException e) { // assert false; }
　　 result.table = new Entry[table.length];
　　 result.entrySet = null;
　　 result.modCount = 0;
　　 result.size = 0;
　　 result.init();
　　 result.putAllForCreate(this);
　　 return result;
}

static class Entry implements Map.Entry {
　　 final Object key;
　　 Object value;
　　 final int hash;
　　 Entry next;
　　 Entry(int h, Object k, Object v, Entry n) {
　　　　 value = v;
　　　　 next = n;
　　　　 key = k;
　　　　 hash = h;
　　 }
　　 public Object getKey() {
　　　　 return unmaskNull(key);
　　 }
　　　public Object getValue() {
　　　　 return value;
　　 }
　　　public Object setValue(Object newValue) {
　　　　　 Object oldValue = value;
　　　　　 value = newValue;
　　　　　 return oldValue;
　　 }
　　　public boolean equals(Object o) {
　　　　 if (!(o instanceof Map.Entry)) return false;
　　　　 Map.Entry e = (Map.Entry)o;
　　　　 Object k1 = getKey();
　　　　 Object k2 = e.getKey();
　　　　 if (k1 == k2 || (k1 != null && k1.equals(k2))) {
　　　　　　 Object v1 = getValue();
　　　　　　 Object v2 = e.getValue();
　　　　　　 if (v1 == v2 || (v1 != null && v1.equals(v2))) return true;
　　　　 }
　　　　 return false;
　　　 }
　　　 public int hashCode() {
　　　　　 return (key==NULL_KEY ? 0 : key.hashCode()) ^ (value==null ? 0 : value.hashCode());
　　　 }
　　　 public String toString() {
　　　　　 return getKey() + "=" + getValue();
　　　 }
　　　 void recordAccess(HashMap m) { }
　　　 void recordRemoval(HashMap m) { }
}
一個(gè)靜態(tài)內(nèi)部類

void addEntry(int hash, Object key, Object value, int bucketIndex) {
　　　 table[bucketIndex] = new Entry(hash, key, value, table[bucketIndex]);
　　　 if (size++ >= threshold)
　　　　　 resize(2 * table.length);
}
注意這個(gè)方法，插入連表的頭。
可以寫成這樣更好理解：
Entry oldHead=table[bucketIndex];
Entry newHead = new Entry(hash,key,value,oldHead);
table[bucketIndex]=newHead;

void createEntry(int hash, Object key, Object value, int bucketIndex) {
　　 table[bucketIndex] = new Entry(hash, key, value, table[bucketIndex]);
　　 size++;
}

private abstract class HashIterator implements Iterator {
　　 Entry next;
　　 int expectedModCount;
　　 int index;
　　 Entry current;
　　 HashIterator() {
　　　　 expectedModCount = modCount;
　　　　 Entry[] t = table;
　　　　 int i = t.length;
　　　　 Entry n = null;
　　　　 if (size != 0) {
　　　　　　 while (i > 0 && (n = t[--i]) == null) ;
　　　　 }
　　　　 next = n;
　　　　 index = i;
　　 }
　　 public boolean hasNext() {
　　　　 return next != null;
　　 }
　　 Entry nextEntry() {
　　　　 if (modCount != expectedModCount)
　　　　　　 throw new ConcurrentModificationException();
　　　　 Entry e = next;
　　　　if (e == null)
　　　　　　 throw new NoSuchElementException();
　　　　 Entry n = e.next;
　　　　 Entry[] t = table;
　　　　 int i = index;
　　　　 while (n == null && i > 0)
　　　　　　　 n = t[--i]; index = i;
　　　　 next = n;
　　　　 return current = e;
　　 }
　　 public void remove() {
　　　　 if (current == null)
　　　　　　 throw new IllegalStateException();
　　　　 if (modCount != expectedModCount)
　　　　　　 throw new ConcurrentModificationException();
　　　　 Object k = current.key;
　　　　 current = null;
　　　　 HashMap.this.removeEntryForKey(k);
　　　　 expectedModCount = modCount;
　　 }
}

private class ValueIterator extends HashIterator {
　　 public Object next() {
　　　　 return nextEntry().value;
　　 }
}

private class KeyIterator extends HashIterator {
　　 public Object next() {
　　　　 return nextEntry().getKey();
　　 }
}

private class EntryIterator extends HashIterator {
　　 public Object next() {
　　　　 return nextEntry();
　　 }
}

Iterator newKeyIterator() {
　　 return new KeyIterator();
}

Iterator newValueIterator() {
　　 return new ValueIterator();
}

Iterator newEntryIterator() { 　
　　return new EntryIterator();
}

private transient Set entrySet = null;

public Set keySet() {
　　 Set ks = keySet;
　　 return (ks != null ? ks : (keySet = new KeySet()));
}

private class KeySet extends AbstractSet {
　　 public Iterator iterator() {
　　　　 return newKeyIterator();
　　 }
　　 public int size() {
　　　　 return size;
　　 }
　　 public boolean contains(Object o) {
　　　　 return containsKey(o);
　　 }
　　 public boolean remove(Object o) {
　　　　 return HashMap.this.removeEntryForKey(o) != null;
　　 }
　　 public void clear() {
　　　　 HashMap.this.clear();
　　 }
}

public Collection values() {
　　 Collection vs = values; return (vs != null ? vs : (values = new Values()));
}

private class Values extends AbstractCollection {
　　 public Iterator iterator() {
　　　　 return newValueIterator();
　　 }
　　 public int size() {
　　　　 return size;
　　 }
　　 public boolean contains(Object o) {
　　　　 return containsValue(o);
　　 }
　　 public void clear() {
　　　　 HashMap.this.clear();
　　 }
}

public Set entrySet() {
　　 Set es = entrySet;
　　 return (es != null ? es : (entrySet = new EntrySet()));
}

private class EntrySet extends AbstractSet {
　　 public Iterator iterator() {
　　　　 return newEntryIterator();
　　 }
　　 public boolean contains(Object o) {
　　　　 if (!(o instanceof Map.Entry))
　　　　　　 return false;
　　　　 Map.Entry e = (Map.Entry)o;
　　　　 Entry candidate = getEntry(e.getKey());
　　　　 return candidate != null && candidate.equals(e);
　　 }
　　 public boolean remove(Object o) {
　　　　 return removeMapping(o) != null;
　　 }
　　 public int size() {
　　　　 return size;
　　 }
　　 public void clear() {
　　　　 HashMap.this.clear();
　　 }
}

private void writeObject(java.io.ObjectOutputStream s) throws IOException {
　　 s.defaultWriteObject();
　　 s.writeInt(table.length);
　　 s.writeInt(size);
　　 for (Iterator i = entrySet().iterator(); i.hasNext(); ) {
　　　　 Map.Entry e = (Map.Entry) i.next();
　　　　 s.writeObject(e.getKey());
　　　　 s.writeObject(e.getValue());
　　 }
}

private static final long serialVersionUID = 362498820763181265L;

private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
　　 s.defaultReadObject();
　　 int numBuckets = s.readInt();
　　 table = new Entry[numBuckets];
　　 init();
　　 size = s.readInt(); for (int i=0;
　　 for (int i=0; i<size; i++) {
　　　　　Object key = s.readObject();
　　　　　Object value = s.readObject();　
　　　　　putForCreate(key, value);
　　　}
}

int capacity() {
　 return table.length;
}
float loadFactor() {
　　 return loadFactor;
}

作者Blog： http://blog.csdn.net/treeroot/

posted @ 2006-07-09 11:38 虎嘯龍吟閱讀(514) | 評(píng)論 (3) | 編輯收藏

Spring MVC框架的高級(jí)配置(轉(zhuǎn)貼自：dev2dev)

Spring MVC框架的高級(jí)配置

時(shí)間：2006-06-08
作者：Dejan Bosanac
瀏覽次數(shù)： 701
本文關(guān)鍵字：Spring,?configuration,?source control,?CVS,?subversion,?配置,?源代碼控制

　　本文將為您提供關(guān)于Spring MVC框架的配置技巧，以幫助管理基于Spring的web應(yīng)用程序的多個(gè)實(shí)例。本配置管理主題常被學(xué)術(shù)界所忽略，但是，這對(duì)于現(xiàn)實(shí)的web開發(fā)尤為重要。本主題并不直接關(guān)聯(lián)任何具體的技術(shù)，因此，我們將從最基本的概念開始對(duì)這個(gè)問題進(jìn)行說明。下面，我們將根據(jù)Spring MVC框架，為基于本技術(shù)開發(fā)的項(xiàng)目提供一系列的解決方案。

Spring配置

　　人們經(jīng)常會(huì)在一臺(tái)以上的主機(jī)上配置一種Web應(yīng)用程序。例如，在生產(chǎn)中，一個(gè)網(wǎng)站可能只有一個(gè)實(shí)例。除了此實(shí)例外，開發(fā)人員可以在用于開發(fā)的機(jī)器上配置其他的（開發(fā)）實(shí)例。也可以在公司（機(jī)構(gòu)）內(nèi)部的本地開發(fā)服務(wù)器上維護(hù)其他應(yīng)用程序裝置，這將讓您受益匪淺。該實(shí)例的目的是使Web設(shè)計(jì)者可以獲得有質(zhì)量保證的材料，并為需要為應(yīng)用程序提供文件資料的人提供準(zhǔn)入。

　　大家都知道，即使是最簡(jiǎn)單的場(chǎng)景，也需要安裝、配置和維護(hù)三個(gè)實(shí)例。而對(duì)于位于不同地理位置的團(tuán)隊(duì)來說，要從事這樣的項(xiàng)目便更加困難。對(duì)于任何不是特別簡(jiǎn)單的Web應(yīng)用程序項(xiàng)目，都需要多名開發(fā)人員來安裝項(xiàng)目裝置和本地設(shè)置以及運(yùn)行單元測(cè)試的裝置等。

　　很多組織都將自己開發(fā)的產(chǎn)品作為Web應(yīng)用程序。我們可以在很多產(chǎn)品中發(fā)現(xiàn)這種情況，例如電子商務(wù)系統(tǒng)、內(nèi)容管理系統(tǒng)（CMS），以及博客發(fā)布平臺(tái)等。這類產(chǎn)品可在多個(gè)服務(wù)器中進(jìn)行部署。對(duì)于成功的多用途W(wǎng)eb應(yīng)用程序來說，他們的開發(fā)人員必須要保證他們的應(yīng)用程序便于安裝，并且能夠與其他Web應(yīng)用程序完美集成。經(jīng)過上述討論之后，我們應(yīng)該明了，作為本文主題的應(yīng)用程序配置是通用Web應(yīng)用程序項(xiàng)目開發(fā)人員所需要解決的重要問題之一。

　　諸如CVS或Subversion之類的版本控制系統(tǒng)是開發(fā)組織使用的一種標(biāo)準(zhǔn)工具。這種工具代表了一些組織的中心源代碼版本庫(kù)，它們被用于保持源代碼的有序。用戶可以跟蹤應(yīng)用程序源代碼的變化，顯示不同版本的區(qū)別，并可以確定項(xiàng)目分支。而且，它們使得在應(yīng)用程序部署中進(jìn)行部分更新成為可能。

　　很明顯，版本控制系統(tǒng)軟件是跟蹤源代碼所必需的，它對(duì)于解決應(yīng)用程序配置問題有非常大的幫助。在本文中，我們將不會(huì)把重點(diǎn)放在版本控制系統(tǒng)上，因?yàn)檫@方面已經(jīng)有很多相關(guān)的材料了。在此，我們將關(guān)注版本控制問題中的一個(gè)小話題：如何使Web應(yīng)用程序的配置更加便捷（尤其是使用Spring MVC框架編寫的Web應(yīng)用程序）。

　　問題是：我們?cè)诖擞懻摰氖且环N什么樣的配置？任何Web應(yīng)用程序都需要一些資源，這些資源通常都是其所運(yùn)行的服務(wù)器所特有的，例如數(shù)據(jù)庫(kù)URL、發(fā)送電子郵件的SMTP服務(wù)器，以及包含專用軟件文件的文件夾等。這樣的設(shè)置應(yīng)該集中，從而使應(yīng)用程序配置更加簡(jiǎn)單。

　　但是，這只是這個(gè)問題最簡(jiǎn)單的一種版本。有時(shí)候，在應(yīng)用程序開發(fā)中需要更加復(fù)雜的配置。這意味著，必須將各次部署中的不同Bean連接起來，而這會(huì)使問題更加復(fù)雜。

　　這些應(yīng)用程序配置問題的解決方案有諸多優(yōu)勢(shì)，包括：簡(jiǎn)化應(yīng)用程序的安裝和配置過程，使源代碼版本控制更加簡(jiǎn)便，減少源代碼版本庫(kù)中的沖突現(xiàn)象。下面，我們將通過示例詳細(xì)討論這個(gè)話題。

問題

　　我們首先來演示一下上文所提到的最簡(jiǎn)單的版本。在這一場(chǎng)景中，我們希望在應(yīng)用程序部署中改變的是簡(jiǎn)單的配置參數(shù)，例如鏈接、密碼等。如果您曾經(jīng)使用Spring MVC框架開發(fā)過Web應(yīng)用程序，那么您應(yīng)該知道這里將用到的兩個(gè)配置文件：

/WEB-INF/applicationContext.xml，它讓您可以配置Bean，或者顯示應(yīng)用程序上下文。通過這個(gè)文件，您可以定義自己的業(yè)務(wù)邏輯Bean、資源以及其他可以與Web端口相關(guān)聯(lián)的所有Bean。
/WEB-INF/[servlet-name]-servlet.xml，它被用于配置Web層、視圖解析器、控制器、校驗(yàn)器以及其他所有MVC框架中必需的Bean。[servlet-name]指的是在web.xml部署描述符中定義的Spring dispatcher servlet的名稱。

　　那么問題在哪兒呢？問題就出在applicationContext.xml中將包括一些特定于主機(jī)的Bean定義。其中，最明顯的一個(gè)示例就是包含了JDBC連接信息的bean，但是任何一種稍微復(fù)雜些的應(yīng)用程序都有十幾個(gè)類似的Bean。看一下下面的示例：

<bean id="dataSource" 
 class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name="driverClassName">
       <value>org.postgresql.Driver</value>
   </property>
   <property name="url">
       <value>jdbc:postgresql://localhost/test</value>
   </property>
   <property name="username">
       <value>postgres</value>
   </property>
   <property name="password">
       <value></value>
   </property>
</bean>

　　這個(gè)解決方案的問題在于對(duì)applicationContext.xml文件的維護(hù)。對(duì)于初學(xué)者來說，設(shè)想一下，項(xiàng)目放在源代碼版本控制系統(tǒng)中，例如CVS。下面，假設(shè)您希望在網(wǎng)站中添加新的功能，那么就需要在應(yīng)用程序上下文定義中添加額外的Bean定義。問題是如何在生產(chǎn)服務(wù)器上體現(xiàn)這些改變。

　　通常情況下，應(yīng)用程序的本地實(shí)例不會(huì)與活動(dòng)站點(diǎn)使用同樣的數(shù)據(jù)庫(kù)，因此applicationContext.xml文件將包括讓您能夠訪問本地?cái)?shù)據(jù)庫(kù)的設(shè)置。當(dāng)您想提交在源代碼版本庫(kù)中的改變時(shí)，就需要注意這些特定于主機(jī)屬性的同步性。版本庫(kù)中的文件最終可能使用本地設(shè)置中的配置。如果想在生產(chǎn)服務(wù)器上更新配置，就必須手動(dòng)同步這些屬性的值。這是非常枯燥的任務(wù)，而且還非常容易出錯(cuò)。

　　對(duì)于應(yīng)用程序的每個(gè)實(shí)例來說，這個(gè)問題更加重要。假如有三位開發(fā)人員正在使用代碼段基址，而且他們使用的是本地的數(shù)據(jù)庫(kù)。當(dāng)您提交更改的時(shí)候，他們每個(gè)人在本地服務(wù)器上更新源代碼的時(shí)候都必須非常謹(jǐn)慎。他們會(huì)手動(dòng)同步這些更改，然后提交他們的工作。這樣一來，版本控制系統(tǒng)對(duì)于這些配置文件來說已經(jīng)毫無用處。如果曾經(jīng)使用過Spring MVC，那么您應(yīng)該知道applicationContext.xml是應(yīng)用程序中的關(guān)鍵組件，因?yàn)槭撬鼘⑺械臇|西粘合在一起。所以，我們需要一種機(jī)制來幫助使應(yīng)用程序中各項(xiàng)保持有序，這點(diǎn)非常重要。

　　正如前面所提到的，這是您可能遇到的較簡(jiǎn)單的配置問題。更難的問題出現(xiàn)在當(dāng)需要在不同服務(wù)器中進(jìn)行不同的Bean連接的時(shí)候。這類問題常會(huì)出現(xiàn)在日常軟件開發(fā)任務(wù)中。例如，假如您的產(chǎn)品有一個(gè)客戶身份驗(yàn)證模塊，可以對(duì)來自關(guān)系數(shù)據(jù)庫(kù)或LDAP服務(wù)器中的用戶進(jìn)行身份驗(yàn)證。自然，這一身份驗(yàn)證模塊可以使用抽象了特定版本庫(kù)的Bean進(jìn)行配置。如果您想改變不同應(yīng)用程序部署中驗(yàn)證用戶的方式，就需要在applicationContext.xml文件中進(jìn)行不同的Bean連接。這種配置問題常見于在部署中有可配置特性的所有應(yīng)用程序。

　　在下文中，我們將討論這兩種配置問題。首先我們會(huì)關(guān)注同步的Bean屬性問題及其解決方案，接下來，我們會(huì)討論更加復(fù)雜的同步Bean連接問題。

解決方案

同步Bean屬性

　　這個(gè)問題的一種可行的解決方案是將所有特定于主機(jī)的參數(shù)都放到普通的Java屬性文件中，使用Spring的PropertyPlaceHolderConfigurer類，將這些參數(shù)寫入Bean屬性中。

　　使用這一解決方案，我們可以生成如下的屬性文件（/WEB-INF/jdbc.properties）：

jdbc.driver=org.postgresql.Driver
jdbc.url=jdbc:postgresql://localhost/test
jdbc.user=postgres
jdbc.password=

　　我們的Bean配置如下：

<bean id="propertyConfigurer" 
 class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location">
       <value>/WEB-INF/jdbc.properties</value>
    </property>
</bean>

<bean id="dataSource" 
 class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName">
         <value>${jdbc.driver}</value>
    </property>
    <property name="url">
         <value>${jdbc.url}</value>
    </property>
    <property name="username">
         <value>${jdbc.user}</value>
    </property>
    <property name="password">
         <value>${jdbc.password}</value>
    </property>
</bean>

　　如上所述，我們定義了一個(gè)PropertyPlaceholderConfigurer類的實(shí)例，并將其位置屬性設(shè)置為我們的屬性文件。該類被實(shí)現(xiàn)為Bean工廠的后處理器，并將使用定義在文件中的屬性來代替所有的占位符（${...}value）。

　　利用這種技術(shù)，我們可以從applicationContext.xml中移除所有特定于主機(jī)的配置屬性。通過這種方式，我們可以自由地為該文件添加新的Bean，而不必?fù)?dān)心特定于主機(jī)屬性的同步性。這樣可以簡(jiǎn)化生產(chǎn)部署和維護(hù)。

同步性連接

　　上面的技術(shù)解決了第一個(gè)問題，可是如果您計(jì)劃修改不同應(yīng)用程序部署之間的Bean連接，這一技術(shù)便不很適合。針對(duì)這一問題的一個(gè)解決方案便是額外創(chuàng)建一個(gè)名為applicationContext-[hostname].xml 的XML定義文件。其中[hostname]是部署應(yīng)用程序的主機(jī)的名稱。例如，在本地的機(jī)器上，這個(gè)文件通常名為applicationContext-localhost.xml，而在部署時(shí)，它可能更名為applicationContext-somehost.com.xml。

　　可以猜測(cè)，這一文件必須包括特定于某一主機(jī)的所有配置Bean。在本文中，我們將假設(shè)dataSource bean定義將位于這類文件中，而不是通用的applicationContext.xml定義。當(dāng)然，這種機(jī)制與前者并非沖突，但是為了更加簡(jiǎn)單明了，我們將只關(guān)注這種方法。

　　既然我們已經(jīng)有了特定的配置，下面我們就來討論一下如何將其整合到整個(gè)Spring MVC配置概念中。要達(dá)到這一目的，可以有許多方法，我們將詳細(xì)地一一說明。但首先，我們應(yīng)該注意到，由于有些Bean可能位于獨(dú)立的配置文件中，因此在applicationContext.xml中，所有對(duì)它們的局部引用都必須更換成全局名稱。

　　例如，如下引用：

 <property name="someProperty">
   <ref local="someBean"/>
 </property>

　　應(yīng)更改為：

 <property name="someProperty">
   <ref bean="someBean"/>
 </property>

　　在這之后，我們有很多可以添加額外的資源以用于配置的方式。其中最明顯的就是使用<import>標(biāo)簽將這一額外資源包含在applicationContext.xml配置文件中。使用時(shí)，要將該標(biāo)簽放在applicationContext.xml文件開頭。例如：

<import resource="applicationContext-somehost.com.xml"/>

　　現(xiàn)在，在獨(dú)立的XML定義文件和普通的應(yīng)用程序上下文定義文件中的所有通用Bean定義都有了特定于主機(jī)的連接。由于大多數(shù)的Bean都不是特定于主機(jī)的，因此我們可以像處理Web應(yīng)用程序中的其他資源一樣自由地處理applicationContext.xml文件，并可以通過合適的版本控制系統(tǒng)與其進(jìn)行同步。

　　但是，上述方法也有一定的弊端。如果您想保留不同XML文件的不同配置，就仍然必須擔(dān)心applicationContext.xml的同步性，因?yàn)橘Y源的名稱必須根據(jù)不同服務(wù)器進(jìn)行更改。雖然與原有的解決方案相比有了很大提高，只需更改文件名，但是這還是需要開發(fā)人員的手動(dòng)協(xié)助。

　　由于與applicationContext.xml相比，主機(jī)配置不需如此頻繁地進(jìn)行更改，因此下一步便是將主機(jī)配置移動(dòng)到web.xml文件中（如果可能的話）。幸運(yùn)的是，我們有一個(gè)可用的解決方案。看一下下面關(guān)于web.xml配置的片斷：

<listener>
   <listener-class>
    org.springframework.web.context.ContextLoaderListener
   </listener-class>
  </listener>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
    /WEB-INF/applicationContext.xml 
       /WEB-INF/applicationContext-somehost.com.xml
    </param-value>
  </context-param>

　　正如您所看到的，除了web.xml文件中常有的ContextLoaderListener之外，我們還添加了contextConfigLocation上下文參數(shù)配置。這一參數(shù)用于指示框架查找這些配置文件的位置。如果這一參數(shù)被省略，則Spring就只能到applicationContext.xml中查找。這里我們也定義了特定于主機(jī)的配置文件來使用。

　　利用這種方法，我們將所有特定于主機(jī)的配置從applicationContext.xml文件中移除，這樣便減輕了其在不同應(yīng)用程序部署中的同步性。

　　如果這種方法成為您的新習(xí)慣，您還可以使其更加靈活。通過遵守下列指令，也可以將特定于主機(jī)的配置從web.xml文件中移除。

　　為此，需要?jiǎng)?chuàng)建特定于我們的應(yīng)用程序上下文的類：

package net.nighttale.spring.util;

import java.net.InetAddress;

import org.springframework.web.context.support.XmlWebApplicationContext;

public class PerHostXmlWebApplicationContext 
 extends XmlWebApplicationContext {
        
    protected String[] getDefaultConfigLocations() {
            String hostname = "localhost";
            try {
                hostname = InetAddress.getLocalHost().getHostName();
            } catch (Exception e) {
            }
            
            String perHostConfiguration = DEFAULT_CONFIG_LOCATION_PREFIX 
                 + "applicationContext-" 
                 + hostname 
                 + DEFAULT_CONFIG_LOCATION_SUFFIX
                 ;
    
            logger.debug(
                 "Adding per host configuration file: " 
                 + perHostConfiguration
                 );
            
            if (getNamespace() != null) {
                    return new String[] {
              DEFAULT_CONFIG_LOCATION_PREFIX 
                + getNamespace() 
                + DEFAULT_CONFIG_LOCATION_SUFFIX
             , perHostConfiguration};
            }
            else {
                    return new String[] {
             DEFAULT_CONFIG_LOCATION
              , perHostConfiguration};
            }
    }
}

　　這個(gè)類拓展了Spring中常被作為默認(rèn)值使用的XmlWebApplicationContext。XmlWebApplicationContext類將Web應(yīng)用程序的配置從XML定義文件中復(fù)制過來。默認(rèn)情況下，它可以配置來自applicationContext.xml和[servlet-name]-servlet.xml文件中的應(yīng)用程序。這個(gè)類執(zhí)行的惟一一項(xiàng)額外任務(wù)便是獲取它所在的主機(jī)名稱，并將applicationContext-[hostname].xml文件添加到配置文件列表中。

　　為了使用這個(gè)類，我們需要對(duì)其進(jìn)行編譯，將其包含在類途徑中，并指示Spring框架使用它。前兩步非常簡(jiǎn)單，我們就不在此贅述。我們可以指示Sping通過contextClass上下文參數(shù)來使用它。除了web.xml文件中的原有配置，我們還可以添加下列內(nèi)容：

<context-param>
   <param-name>contextClass</param-name>
  <param-value>
   net.nighttale.spring.util.PerHostXmlWebApplicationContext
  </param-value>
</context-param>

　　如果我們使用這一配置片斷，將會(huì)有三個(gè)文件被用于初始化這個(gè)框架：[servlet-name]-servlet.xml、applicationContext-[hostname].xml以及applicationContext.xml。

　　正如您所看到的，applicationContext.xml和web.xml文件已經(jīng)完全擺脫了任何特定的配置細(xì)節(jié)，而且您也不必?fù)?dān)心會(huì)在更新應(yīng)用程序時(shí)破壞配置。

　　但是，這種方法有一個(gè)不足之處。因?yàn)椋徽撌欠駮?huì)使用，都需要在應(yīng)用程序部署中有第三個(gè)配置文件。在這種情況下，便不需要特定于主機(jī)的配置。例如：

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" 
    "http://www.springframework.org/dtd/spring-beans.dtd">

<beans></beans>

　　最后，需要知道應(yīng)用程序上下文類需要查找的特定主機(jī)名。檢查主機(jī)名稱的最簡(jiǎn)單的方法是在機(jī)器上運(yùn)行下列代碼：

System.out.println(InetAddress.getLocalHost().getHostName())

　　可以將其作為Java代碼執(zhí)行，也可在喜歡使用的腳本語言（如BeanShell或Groovy）中作為一個(gè)具有Java風(fēng)格語法的腳本執(zhí)行。在獲取了主機(jī)的名稱之后，應(yīng)該創(chuàng)建一個(gè)默認(rèn)的/WEB-INF/applicationContext-[hostname].xml空文件夾（如我們上面所定義的），然后便可以開始了。

結(jié)束語

　　在本文中，我們提供了一系列的配置技巧，讓您在使用Spring MVC框架完成日常工作的時(shí)候更加輕松。如果您希望知道如何維護(hù)各種Web應(yīng)用程序部署，可以試著找出最適合您的開發(fā)過程的解決方案。您的生活會(huì)更為輕松。

posted @ 2006-07-09 11:18 虎嘯龍吟閱讀(307) | 評(píng)論 (0) | 編輯收藏

最近買了Spring in Action 中文版。

???????? 最近，買了本Spring入門書：spring In Action 。大致瀏覽了下感覺還不錯(cuò)。就是入門了點(diǎn)。Manning的書還是不錯(cuò)的，我雖然不像哪些只看Manning書的人那樣專注于Manning,但懷著崇敬的心情和激情通覽了一遍。又一次接受了IOC 、DI、AOP等Spring核心概念。先就IOC和DI談一點(diǎn)我的看法。

IOC（DI）：其實(shí)這個(gè)Spring架構(gòu)核心的概念沒有這么復(fù)雜，更不像有些書上描述的那樣晦澀。java程序員都知道：java程序中的每個(gè)業(yè)務(wù)邏輯至少需要兩個(gè)或以上的對(duì)象來協(xié)作完成，通常，每個(gè)對(duì)象在使用他的合作對(duì)象時(shí)，自己均要使用像new object（）這樣的語法來完成合作對(duì)象的申請(qǐng)工作。你會(huì)發(fā)現(xiàn)：對(duì)象間的耦合度高了。而IOC的思想是：Spring容器來實(shí)現(xiàn)這些相互依賴對(duì)象的創(chuàng)建、協(xié)調(diào)工作。對(duì)象只需要關(guān)系業(yè)務(wù)邏輯本身就可以了。從這方面來說，對(duì)象如何得到他的協(xié)作對(duì)象的責(zé)任被反轉(zhuǎn)了（IOC、DI）。

這是我對(duì)Spring的IOC的體會(huì)。DI其實(shí)就是IOC的另外一種說法。DI是由Martin Fowler 在2004年初的一篇論文中首次提出的。他總結(jié)：控制的什么被反轉(zhuǎn)了？就是：獲得依賴對(duì)象的方式反轉(zhuǎn)了。

如果對(duì)這一核心概念還不理解：這里引用一個(gè)叫Bromon的blog上找到的淺顯易懂的答案：

IoC與DI

　　首先想說說IoC（Inversion of Control，控制倒轉(zhuǎn)）。這是spring的核心，貫穿始終。所謂IoC，對(duì)于spring框架來說，就是由spring來負(fù)責(zé)控制對(duì)象的生命周期和對(duì)象間的關(guān)系。這是什么意思呢，舉個(gè)簡(jiǎn)單的例子，我們是如何找女朋友的？常見的情況是，我們到處去看哪里有長(zhǎng)得漂亮身材又好的mm，然后打聽她們的興趣愛好、qq號(hào)、電話號(hào)、ip號(hào)、iq號(hào)………，想辦法認(rèn)識(shí)她們，投其所好送其所要，然后嘿嘿……這個(gè)過程是復(fù)雜深?yuàn)W的，我們必須自己設(shè)計(jì)和面對(duì)每個(gè)環(huán)節(jié)。傳統(tǒng)的程序開發(fā)也是如此，在一個(gè)對(duì)象中，如果要使用另外的對(duì)象，就必須得到它（自己new一個(gè)，或者從JNDI中查詢一個(gè)），使用完之后還要將對(duì)象銷毀（比如Connection等），對(duì)象始終會(huì)和其他的接口或類藕合起來。

　　那么IoC是如何做的呢？有點(diǎn)像通過婚介找女朋友，在我和女朋友之間引入了一個(gè)第三者：婚姻介紹所。婚介管理了很多男男女女的資料，我可以向婚介提出一個(gè)列表，告訴它我想找個(gè)什么樣的女朋友，比如長(zhǎng)得像李嘉欣，身材像林熙雷，唱歌像周杰倫，速度像卡洛斯，技術(shù)像齊達(dá)內(nèi)之類的，然后婚介就會(huì)按照我們的要求，提供一個(gè)mm，我們只需要去和她談戀愛、結(jié)婚就行了。簡(jiǎn)單明了，如果婚介給我們的人選不符合要求，我們就會(huì)拋出異常。整個(gè)過程不再由我自己控制，而是有婚介這樣一個(gè)類似容器的機(jī)構(gòu)來控制。Spring所倡導(dǎo)的開發(fā)方式就是如此，所有的類都會(huì)在spring容器中登記，告訴spring你是個(gè)什么東西，你需要什么東西，然后spring會(huì)在系統(tǒng)運(yùn)行到適當(dāng)?shù)臅r(shí)候，把你要的東西主動(dòng)給你，同時(shí)也把你交給其他需要你的東西。所有的類的創(chuàng)建、銷毀都由 spring來控制，也就是說控制對(duì)象生存周期的不再是引用它的對(duì)象，而是spring。對(duì)于某個(gè)具體的對(duì)象而言，以前是它控制其他對(duì)象，現(xiàn)在是所有對(duì)象都被spring控制，所以這叫控制反轉(zhuǎn)。如果你還不明白的話，我決定放棄。

IoC的一個(gè)重點(diǎn)是在系統(tǒng)運(yùn)行中，動(dòng)態(tài)的向某個(gè)對(duì)象提供它所需要的其他對(duì)象。這一點(diǎn)是通過DI（Dependency Injection，依賴注入）來實(shí)現(xiàn)的。比如對(duì)象A需要操作數(shù)據(jù)庫(kù)，以前我們總是要在A中自己編寫代碼來獲得一個(gè)Connection對(duì)象，有了 spring我們就只需要告訴spring，A中需要一個(gè)Connection，至于這個(gè)Connection怎么構(gòu)造，何時(shí)構(gòu)造，A不需要知道。在系統(tǒng)運(yùn)行時(shí)，spring會(huì)在適當(dāng)?shù)臅r(shí)候制造一個(gè)Connection，然后像打針一樣，注射到A當(dāng)中，這樣就完成了對(duì)各個(gè)對(duì)象之間關(guān)系的控制。A需要依賴 Connection才能正常運(yùn)行，而這個(gè)Connection是由spring注入到A中的，依賴注入的名字就這么來的。那么DI是如何實(shí)現(xiàn)的呢？ Java 1.3之后一個(gè)重要特征是反射（reflection），它允許程序在運(yùn)行的時(shí)候動(dòng)態(tài)的生成對(duì)象、執(zhí)行對(duì)象的方法、改變對(duì)象的屬性，spring就是通過反射來實(shí)現(xiàn)注入的。關(guān)于反射的相關(guān)資料請(qǐng)查閱java doc。

如果還不明白，放棄java吧！

posted @ 2006-04-12 10:34 虎嘯龍吟閱讀(889) | 評(píng)論 (5) | 編輯收藏

2006年4月

日

一

二

三

四

五

六

常用鏈接

留言簿(1)

隨筆分類

extJs

隨筆檔案

文章檔案

相冊(cè)

友情鏈接

struts2系列教程
VMware中用NAT方式實(shí)現(xiàn)FreeBsd/Linux上網(wǎng)
工作流和權(quán)限
緩存
花非花
好的java技術(shù)blog
設(shè)計(jì)模式

基本方法：

Spring配置

問題

解決方案

同步Bean屬性

同步性連接

結(jié)束語

常用鏈接

留言簿(1)

隨筆分類

隨筆檔案

文章檔案

相冊(cè)

友情鏈接

搜索

最新評(píng)論

閱讀排行榜

評(píng)論排行榜