PS.只針對社招人員

   若您或您的朋友有這方面的意向,請?zhí)峁┖啔v到:yaominxi@huawei.com

一.JAVA電子書

http://www.java-cn.com/book/　

優(yōu)點：書籍量大，經(jīng)常更新，教育網(wǎng)下載速度超快

不足：每天只能下載4本

1.1. 背景

在應用程序中添加日志記錄總的來說基于三個目的：監(jiān)視代碼中變量的變化情況，周期性的記錄到文件中供其他應用進行統(tǒng)計分析工作；跟蹤代碼運行時軌跡，作為日后審計的依據(jù)；擔當集成開發(fā)環(huán)境中的調(diào)試器的作用，向文件或控制臺打印代碼的調(diào)試信息。

最普通的做法就是在代碼中嵌入許多的打印語句，這些打印語句可以輸出到控制臺或文件中，比較好的做法就是構(gòu)造一個日志操作類來封裝此類操作，而不是讓一系列的打印語句充斥了代碼的主體。

1.2. Log4j簡介

在強調(diào)可重用組件開發(fā)的今天，除了自己從頭到尾開發(fā)一個可重用的日志操作類外，Apache為我們提供了一個強有力的日志操作包-Log4j。

Log4j是Apache的一個開放源代碼項目，通過使用Log4j，我們可以控制日志信息輸送的目的地是控制臺、文件、GUI組件、甚至是套接口服務(wù)器、NT的事件記錄器、UNIX Syslog守護進程等；我們也可以控制每一條日志的輸出格式；通過定義每一條日志信息的級別，我們能夠更加細致地控制日志的生成過程。最令人感興趣的就是，這些可以通過一個配置文件來靈活地進行配置，而不需要修改應用的代碼。

此外，通過Log4j其他語言接口，您可以在C、C++、.Net、PL/SQL程序中使用Log4j，其語法和用法與在Java程序中一樣，使得多語言分布式系統(tǒng)得到一個統(tǒng)一一致的日志組件模塊。而且，通過使用各種第三方擴展，您可以很方便地將Log4j集成到J2EE、JINI甚至是SNMP應用中。

本文介紹的Log4j版本是1.2.3。作者試圖通過一個簡單的客戶/服務(wù)器Java程序例子對比使用與不使用Log4j 1.2.3的差別，并詳細講解了在實踐中最常使用Log4j的方法和步驟。在強調(diào)可重用組件開發(fā)的今天，相信Log4j將會給廣大的設(shè)計開發(fā)人員帶來方便。加入到Log4j的隊伍來吧！

2. 一個簡單的例子

我們先來看一個簡單的例子，它是一個用Java實現(xiàn)的客戶/服務(wù)器網(wǎng)絡(luò)程序。剛開始我們不使用Log4j，而是使用了一系列的打印語句，然后我們將使用Log4j來實現(xiàn)它的日志功能。這樣，大家就可以清楚地比較出前后兩個代碼的差別。

2.1. 不使用Log4j

2.1.1. 客戶程序

package log4j ;

import java.io.* ;
import java.net.* ;

/**
 *
 * <p> Client Without Log4j </p>
 * <p> Description: a sample with log4j</p>
 * @version 1.0
 */
public class ClientWithoutLog4j {

    /**
     *
     * @param args
     */
    public static void main ( String args [] ) {

        String welcome = null;
        String response = null;
        BufferedReader reader = null;
        PrintWriter writer = null;
        InputStream in = null;
        OutputStream out = null;
        Socket client = null;

        try {
            client = new Socket ( "localhost", 8001 ) ;
            System.out.println ( "info: Client socket: " + client ) ;
            in = client.getInputStream () ;
            out = client.getOutputStream () ;
        } catch ( IOException e ) {
            System.out.println ( "error: IOException : " + e ) ;
            System.exit ( 0 ) ;
        }

        try{
            reader = new BufferedReader( new InputStreamReader ( in ) ) ;
            writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;

            welcome = reader.readLine () ;
            System.out.println ( "debug: Server says: '" + welcome + "'" ) ;

            System.out.println ( "debug: HELLO" ) ;
            writer.println ( "HELLO" ) ;
            response = reader.readLine () ;
            System.out.println ( "debug: Server responds: '" + response + "'") ;

            System.out.println ( "debug: HELP" ) ;
            writer.println ( "HELP" ) ;
            response = reader.readLine () ;
            System.out.println ( "debug: Server responds: '" + response + "'" ) ;

            System.out.println ( "debug: QUIT" ) ;
            writer.println ( "QUIT" ) ;
        } catch ( IOException e ) {
            System.out.println ( "warn: IOException in client.in.readln()" ) ;
            System.out.println ( e ) ;
        }
        try{
            Thread.sleep ( 2000 ) ;
        } catch ( Exception ignored ) {}
    }
}

2.1.2. 服務(wù)器程序

package log4j ;

import java.util.* ;
import java.io.* ;
import java.net.* ;

/**
 *
 * <p> Server Without Log4j </p>
 * <p> Description: a sample with log4j</p>
 * @version 1.0
 */
public class ServerWithoutLog4j {

    final static int SERVER_PORT = 8001 ; // this server's port

    /**
     *
     * @param args
     */
    public static void main ( String args [] ) {
        String clientRequest = null;
        BufferedReader reader = null;
        PrintWriter writer = null;
        ServerSocket server = null;
        Socket socket = null;
        InputStream in = null;
        OutputStream out = null;

        try {
            server = new ServerSocket ( SERVER_PORT ) ;
            System.out.println ( "info: ServerSocket before accept: " + server ) ;
            System.out.println ( "info: Java server without log4j, on-line!" ) ;

            // wait for client's connection
            socket = server.accept () ;
            System.out.println ( "info: ServerSocket after accept: " + server )  ;

            in = socket.getInputStream () ;
            out = socket.getOutputStream () ;

        } catch ( IOException e ) {
            System.out.println( "error: Server constructor IOException: " + e ) ;
            System.exit ( 0 ) ;
        }
        reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
        writer = new PrintWriter ( new OutputStreamWriter ( out ) , true ) ;

        // send welcome string to client
        writer.println ( "Java server without log4j, " + new Date () ) ;

        while ( true ) {
            try {
                // read from client
                clientRequest = reader.readLine () ;
                System.out.println ( "debug: Client says: " + clientRequest ) ;
                if ( clientRequest.startsWith ( "HELP" ) ) {
                    System.out.println ( "debug: OK!" ) ;
                    writer.println ( "Vocabulary: HELP QUIT" ) ;
                }
                else {
                    if ( clientRequest.startsWith ( "QUIT" ) ) {
                        System.out.println ( "debug: OK!" ) ;
                        System.exit ( 0 ) ;
                    }
                    else{
                        System.out.println ( "warn: Command '" + 
      clientRequest + "' not understood." ) ;
                        writer.println ( "Command '" + clientRequest 
      + "' not understood." ) ;
                    }
                }
            } catch ( IOException e ) {
                System.out.println ( "error: IOException in Server " + e ) ;
                System.exit ( 0 ) ;
            }
        }
    }
}

2.2. 遷移到Log4j

2.2.1. 客戶程序

package log4j ;

import java.io.* ;
import java.net.* ;

// add for log4j: import some package
import org.apache.log4j.PropertyConfigurator ;
import org.apache.log4j.Logger ;
import org.apache.log4j.Level ;

/**
 *
 * <p> Client With Log4j </p>
 * <p> Description: a sample with log4j</p>
 * @version 1.0
 */
public class ClientWithLog4j {

    /*
    add for log4j: class Logger is the central class in the log4j package.
    we can do most logging operations by Logger except configuration.
    getLogger(...): retrieve a logger by name, if not then create for it.
    */
    static Logger logger = Logger.getLogger 
 ( ClientWithLog4j.class.getName () ) ;

    /**
     *
     * @param args : configuration file name
     */
    public static void main ( String args [] ) {

        String welcome = null ;
        String response = null ;
        BufferedReader reader = null ;
        PrintWriter writer = null ;
        InputStream in = null ;
        OutputStream out = null ;
        Socket client = null ;

        /*
        add for log4j: class BasicConfigurator can quickly configure the package.
        print the information to console.
        */
        PropertyConfigurator.configure ( "ClientWithLog4j.properties" ) ;

        // add for log4j: set the level
//        logger.setLevel ( ( Level ) Level.DEBUG ) ;

        try{
            client = new Socket( "localhost" , 8001 ) ;

            // add for log4j: log a message with the info level
            logger.info ( "Client socket: " + client ) ;

            in = client.getInputStream () ;
            out = client.getOutputStream () ;
        } catch ( IOException e ) {

            // add for log4j: log a message with the error level
            logger.error ( "IOException : " + e ) ;

            System.exit ( 0 ) ;
        }

        try{
            reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
            writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;

            welcome = reader.readLine () ;

            // add for log4j: log a message with the debug level
            logger.debug ( "Server says: '" + welcome + "'" ) ;

            // add for log4j: log a message with the debug level
            logger.debug ( "HELLO" ) ;

            writer.println ( "HELLO" ) ;
            response = reader.readLine () ;

            // add for log4j: log a message with the debug level
            logger.debug ( "Server responds: '" + response + "'" ) ;

            // add for log4j: log a message with the debug level
            logger.debug ( "HELP" ) ;

            writer.println ( "HELP" ) ;
            response = reader.readLine () ;

            // add for log4j: log a message with the debug level
            logger.debug ( "Server responds: '" + response + "'") ;

            // add for log4j: log a message with the debug level
            logger.debug ( "QUIT" ) ;

            writer.println ( "QUIT" ) ;
        } catch ( IOException e ) {

            // add for log4j: log a message with the warn level
            logger.warn ( "IOException in client.in.readln()" ) ;

            System.out.println ( e ) ;
        }
        try {
            Thread.sleep ( 2000 ) ;
        } catch ( Exception ignored ) {}
    }
}

2.2.2. 服務(wù)器程序

package log4j;

import java.util.* ;
import java.io.* ;
import java.net.* ;

// add for log4j: import some package
import org.apache.log4j.PropertyConfigurator ;
import org.apache.log4j.Logger ;
import org.apache.log4j.Level ;

/**
 *
 * <p> Server With Log4j </p>
 * <p> Description: a sample with log4j</p>
 * @version 1.0
 */
public class ServerWithLog4j {

    final static int SERVER_PORT = 8001 ; // this server's port

    /*
    add for log4j: class Logger is the central class in the log4j package.
    we can do most logging operations by Logger except configuration.
    getLogger(...): retrieve a logger by name, if not then create for it.
    */
    static Logger logger = Logger.getLogger 
 ( ServerWithLog4j.class.getName () ) ;

    /**
     *
     * @param args
     */
    public static void main ( String args[]) {
        String clientRequest = null ;
        BufferedReader reader = null ;
        PrintWriter writer = null ;
        ServerSocket server = null ;
        Socket socket = null ;

        InputStream in = null ;
        OutputStream out = null ;

        /*
        add for log4j: class BasicConfigurator can quickly configure the package.
        print the information to console.
        */
        PropertyConfigurator.configure ( "ServerWithLog4j.properties" ) ;

        // add for log4j: set the level
//        logger.setLevel ( ( Level ) Level.DEBUG ) ;

        try{
            server = new ServerSocket ( SERVER_PORT ) ;

            // add for log4j: log a message with the info level
            logger.info ( "ServerSocket before accept: " + server ) ;

            // add for log4j: log a message with the info level
            logger.info ( "Java server with log4j, on-line!" ) ;

            // wait for client's connection
            socket = server.accept() ;

            // add for log4j: log a message with the info level
            logger.info ( "ServerSocket after accept: " + server ) ;

            in = socket.getInputStream() ;
            out = socket.getOutputStream() ;

        } catch ( IOException e ) {

            // add for log4j: log a message with the error level
            logger.error ( "Server constructor IOException: " + e ) ;
            System.exit ( 0 ) ;
        }
        reader = new BufferedReader ( new InputStreamReader ( in ) ) ;
        writer = new PrintWriter ( new OutputStreamWriter ( out ), true ) ;

        // send welcome string to client
        writer.println ( "Java server with log4j, " + new Date () ) ;

        while ( true ) {
            try {
                // read from client
                clientRequest = reader.readLine () ;

                // add for log4j: log a message with the debug level
                logger.debug ( "Client says: " + clientRequest ) ;

                if ( clientRequest.startsWith ( "HELP" ) ) {

                    // add for log4j: log a message with the debug level
                    logger.debug ( "OK!" ) ;

                    writer.println ( "Vocabulary: HELP QUIT" ) ;
                }
                else {
                    if ( clientRequest.startsWith ( "QUIT" ) ) {

                        // add for log4j: log a message with the debug level
                        logger.debug ( "OK!" ) ;

                        System.exit ( 0 ) ;
                    }
                    else {

                        // add for log4j: log a message with the warn level
                        logger.warn ( "Command '" 
      + clientRequest + "' not understood." ) ;

                        writer.println ( "Command '"
      + clientRequest + "' not understood." ) ;
                    }
                }
            } catch ( IOException e ) {

                // add for log4j: log a message with the error level
                logger.error( "IOException in Server " + e ) ;

                System.exit ( 0 ) ;
            }
        }
    }
}

2.2.3. 配置文件

2.2.3.1. 客戶程序配置文件

log4j.rootLogger=INFO, A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender

log4j.appender.A1.layout=org.apache.log4j.PatternLayout

log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n

2.2.3.2. 服務(wù)器程序配置文件

log4j.rootLogger=INFO, A1

log4j.appender.A1=org.apache.log4j.ConsoleAppender

log4j.appender.A1.layout=org.apache.log4j.PatternLayout

log4j.appender.A1.layout.ConversionPattern=%-4r %-5p [%t] %37c %3x - %m%n

2.3. 比較

比較這兩個應用可以看出，采用Log4j進行日志操作的整個過程相當簡單明了，與直接使用System.out.println語句進行日志信息輸出的方式相比，基本上沒有增加代碼量，同時能夠清楚地理解每一條日志信息的重要程度。通過控制配置文件，我們還可以靈活地修改日志信息的格式，輸出目的地等等方面，而單純依靠System.out.println語句，顯然需要做更多的工作。

下面我們將以前面使用Log4j的應用作為例子，詳細講解使用Log4j的主要步驟。

3. Log4j基本使用方法

Log4j由三個重要的組件構(gòu)成：日志信息的優(yōu)先級，日志信息的輸出目的地，日志信息的輸出格式。日志信息的優(yōu)先級從高到低有ERROR、WARN、INFO、DEBUG，分別用來指定這條日志信息的重要程度；日志信息的輸出目的地指定了日志將打印到控制臺還是文件中；而輸出格式則控制了日志信息的顯示內(nèi)容。

3.1.定義配置文件

其實您也可以完全不使用配置文件，而是在代碼中配置Log4j環(huán)境。但是，使用配置文件將使您的應用程序更加靈活。

Log4j支持兩種配置文件格式，一種是XML格式的文件，一種是Java特性文件（鍵=值）。下面我們介紹使用Java特性文件做為配置文件的方法：

1. 配置根Logger，其語法為：
   

   log4j.rootLogger = [ level ] , appenderName, appenderName, …
   

   其中，level 是日志記錄的優(yōu)先級，分為OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定義的級別。Log4j建議只使用四個級別，優(yōu)先級從高到低分別是ERROR、WARN、INFO、DEBUG。通過在這里定義的級別，您可以控制到應用程序中相應級別的日志信息的開關(guān)。比如在這里定義了INFO級別，則應用程序中所有DEBUG級別的日志信息將不被打印出來。
   appenderName就是指定日志信息輸出到哪個地方。您可以同時指定多個輸出目的地。
   
2. 配置日志信息輸出目的地Appender，其語法為
   

   log4j.appender.appenderName = fully.qualified.name.of.appender.class
   log4j.appender.appenderName.option1 = value1
   …
   log4j.appender.appenderName.option = valueN
   

   其中，Log4j提供的appender有以下幾種：
   org.apache.log4j.ConsoleAppender（控制臺），
   org.apache.log4j.FileAppender（文件），
   org.apache.log4j.DailyRollingFileAppender（每天產(chǎn)生一個日志文件），org.apache.log4j.RollingFileAppender（文件大小到達指定尺寸的時候產(chǎn)生一個新的文件），
   org.apache.log4j.WriterAppender（將日志信息以流格式發(fā)送到任意指定的地方）
   
3. 配置日志信息的格式（布局），其語法為：
   

   log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
   log4j.appender.appenderName.layout.option1 = value1
   …
   log4j.appender.appenderName.layout.option = valueN
   

   其中，Log4j提供的layout有以下幾種：
   org.apache.log4j.HTMLLayout（以HTML表格形式布局），
   org.apache.log4j.PatternLayout（可以靈活地指定布局模式），
   org.apache.log4j.SimpleLayout（包含日志信息的級別和信息字符串），
   org.apache.log4j.TTCCLayout（包含日志產(chǎn)生的時間、線程、類別等等信息）
   

3.2.在代碼中使用Log4j

下面將講述在程序代碼中怎樣使用Log4j。

3.2.1.得到記錄器

使用Log4j，第一步就是獲取日志記錄器，這個記錄器將負責控制日志信息。其語法為：

public static Logger getLogger( String name)，

static Logger logger = Logger.getLogger ( ServerWithLog4j.class.getName () ) ;

3.2.2.讀取配置文件

當獲得了日志記錄器之后，第二步將配置Log4j環(huán)境，其語法為：
BasicConfigurator.configure ()： 自動快速地使用缺省Log4j環(huán)境。
PropertyConfigurator.configure ( String configFilename) ：讀取使用Java的特性文件編寫的配置文件。
DOMConfigurator.configure ( String filename ) ：讀取XML形式的配置文件。

3.2.3.插入記錄信息（格式化日志信息）

當上兩個必要步驟執(zhí)行完畢，您就可以輕松地使用不同優(yōu)先級別的日志記錄語句插入到您想記錄日志的任何地方，其語法如下：

Logger.debug ( Object message ) ;
Logger.info ( Object message ) ;
Logger.warn ( Object message ) ;
Logger.error ( Object message ) ;

4. 參考資料

如果您想更深入地了解Log4j，請經(jīng)常訪問下面提及的相關(guān)鏈接。
Log4j項目主頁------------------------------------------------------http://www.log4j.org/
Log4j FAQ -------------------------------------------------------http://www-900.ibm.com/developerWorks/cn/java/l-log4j/www.log4j.org/log4j/faq.html

1 適合讀者
本文針對有一定的web基礎(chǔ)，webwork基礎(chǔ)，對spring有一定的了解。

http://www.springframework.org/ 站點可以了解更多關(guān)于spring的詳細信息. Spring是一個很好的AOP框架，能提供自動的事務(wù)管理。

http://www.opensymphony.com/webwork/ 站點可以了解更多的webwork . Webwork是一個很好的 MVC 框架，以下簡單介紹，webwork 和 spring 的融合，以用戶注冊為例。

2 整合步驟
2 .1使用 SpringObjectFactory
dev.java.net上的 xwork-optional 包括了對 xwork-spring 的支持，可以下載些包。包中只有4個類，可以根據(jù)具體情況使用。我在例子中使用了SpringObjectFactory類和SpringObjectFactoryListener 類，并安照webwork的文件在web.xml加入了，以下節(jié)點

<!-- This needs to be after Spring ContextLoaderListener -->

<listener>

<listener-class>com.opensymphony.xwork.spring.SpringObjectFactoryListener</listener-class>

</listener>

但在實際工作中不能使用，回為在SpringObjectFactoryListener類中寫的，加載些類必須要先加載org.springframework.web.context.ContextLoaderListener類，由于些類在web.xml配置如下，后于listener的執(zhí)行。

<servlet>

<servlet-name>spring</servlet-name>

<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>

<load-on-startup>0</load-on-startup>

</servlet>

ContextLoaderServlet 的作用是加載 spring配置信息（在int方法中），SpringObjectFactoryListener 的作用是設(shè)置 XWork 和 Webwork 的環(huán)境，使這能從spring 中加載數(shù)據(jù)和信息（在contextInitialized(ServletContextEvent event)方法中，當啟動web應用程序是調(diào)用）.

要使ContextLoaderServlet比SpringObjectFactoryListener類更早執(zhí)行，我使用的方法是重載ContextLoaderServlet，在中子類的int方法中設(shè)置XWork 和 Webwork 的環(huán)境，去掉SpringObjectFactoryListener 監(jiān)聽器，并整改web.xml中的spring配置，如下：

<servlet>

<servlet-name>spring</servlet-name>

<servlet-class>spring.server.ContextLoaderServletServer</servlet-class>

<load-on-startup>0</load-on-startup>

</servlet>

2 .2 配置webwork
在webwork.xml中增加如下節(jié)點

<action name="registerSupport-spring" class="registerSupportBean" >

<result name="success" type="dispatcher">

<param name="location">/register-result.jsp</param>

</result>

<result name="input" type="dispatcher">

<param name="location">/registerSupport.jsp</param>

</result>

<interceptor-ref name="validationWorkflowStack"/>

</action>

其中的registerSupportBean在spring中配置

2 .3 配置spring
在spring中加入action 配置如下

<!-- action -->

<bean name="registerSupportBean" class="spring.action.RegisterActionSupport"

singleton="false" >

<property name="userBean">

<ref bean="userBean"/>

</property>

</bean>

些處的registerSupportBean 即為在webwork中要調(diào)用的類名。

匹配中文字符的正則表達式： [\u4e00-\u9fa5]

匹配雙字節(jié)字符(包括漢字在內(nèi))：[^\x00-\xff]

應用：計算字符串的長度（一個雙字節(jié)字符長度計2，ASCII字符計1）

String.prototype.len=function(){return this.replace([^\x00-\xff]/g,"aa").length;}

匹配空行的正則表達式：\n[\s| ]*\r

匹配HTML標記的正則表達式：/<(.*)>.*<\/\1>|<(.*) \/>/

匹配首尾空格的正則表達式：(^\s*)|(\s*$)

應用：javascript中沒有像vbscript那樣的trim函數(shù)，我們就可以利用這個表達式來實現(xiàn)，如下：

String.prototype.trim = function()
{
return this.replace(/(^\s*)|(\s*$)/g, "");
}

利用正則表達式分解和轉(zhuǎn)換IP地址：

下面是利用正則表達式匹配IP地址，并將IP地址轉(zhuǎn)換成對應數(shù)值的Javascript程序：

function IP2V(ip)
{
re=/(\d+)\.(\d+)\.(\d+)\.(\d+)/g //匹配IP地址的正則表達式
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}

不過上面的程序如果不用正則表達式，而直接用split函數(shù)來分解可能更簡單，程序如下：

var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是："+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

匹配Email地址的正則表達式：\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*

匹配網(wǎng)址URL的正則表達式：http://([\w-]+\.)+[\w-]+(/[\w- ./?%&=]*)?

利用正則表達式去除字串中重復的字符的算法程序：[注：此程序不正確，原因見本貼回復]

var s="abacabefgeeii"
var s1=s.replace(/(.).*\1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
alert(s1+s2) //結(jié)果為：abcefgi

我原來在CSDN上發(fā)貼尋求一個表達式來實現(xiàn)去除重復字符的方法，最終沒有找到，這是我能想到的最簡單的實現(xiàn)方法。思路是使用后向引用取出包括重復的字符，再以重復的字符建立第二個表達式，取到不重復的字符，兩者串連。這個方法對于字符順序有要求的字符串可能不適用。

得用正則表達式從URL地址中提取文件名的javascript程序，如下結(jié)果為page1

s="http://www.9499.net/page1.htm"
s=s.replace(/(.*\/){0,}([^\.]+).*/ig,"$2")
alert(s)

利用正則表達式限制網(wǎng)頁表單里的文本框輸入內(nèi)容：

用正則表達式限制只能輸入中文：onkeyup="value=value.replace(/[^\u4E00-\u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\u4E00-\u9FA5]/g,''))"

用正則表達式限制只能輸入全角字符： onkeyup="value=value.replace(/[^\uFF00-\uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\uFF00-\uFFFF]/g,''))"

用正則表達式限制只能輸入數(shù)字：onkeyup="value=value.replace(/[^\d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

用正則表達式限制只能輸入數(shù)字和英文：onkeyup="value=value.replace(/[\W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^\d]/g,''))"

正則表達式，正規(guī)表達式，正則表達式匹配，正則表達式語法，模式匹配，正規(guī)表達式匹配 javascript正則表達式 ASP正則表達式 ASP.NET正則表達式 C#正則表達式 JSP正則表達式 PHP正則表達式 VB.NET正則表達式 VBSCript正則表達式編程 delphi正則表達式 jscript

正則表達式 regular expression
正則表達式 RegExp
模式 pattern
匹配 Match
.NET命名空間： System.Text.RegularExpression

補充：
^\d+$　　//匹配非負整數(shù)（正整數(shù) + 0）
^[0-9]*[1-9][0-9]*$　　//匹配正整數(shù)
^((-\d+)|(0+))$　　//匹配非正整數(shù)（負整數(shù) + 0）
^-[0-9]*[1-9][0-9]*$　　//匹配負整數(shù)
^-?\d+$　　　　//匹配整數(shù)
^\d+(\.\d+)?$　　//匹配非負浮點數(shù)（正浮點數(shù) + 0）
^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$　　//匹配正浮點數(shù)
^((-\d+(\.\d+)?)|(0+(\.0+)?))$　　//匹配非正浮點數(shù)（負浮點數(shù) + 0）
^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$　　//匹配負浮點數(shù)
^(-?\d+)(\.\d+)?$　　//匹配浮點數(shù)
^[A-Za-z]+$　　//匹配由26個英文字母組成的字符串
^[A-Z]+$　　//匹配由26個英文字母的大寫組成的字符串
^[a-z]+$　　//匹配由26個英文字母的小寫組成的字符串
^[A-Za-z0-9]+$　　//匹配由數(shù)字和26個英文字母組成的字符串
^\w+$　　//匹配由數(shù)字、26個英文字母或者下劃線組成的字符串
^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$　　　　//匹配email地址
^[a-zA-z]+://匹配(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$　　//匹配url

利用正則表達式去除字串中重復的字符的算法程序：

var s="abacabefgeeii"
var s1=s.replace(/(.).*\1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
alert(s1+s2) //結(jié)果為：abcefgi
===============================
如果var s = "abacabefggeeii"
結(jié)果就不對了，結(jié)果為：abeicfgg
正則表達式的能力有限

RE: totoro
謝謝你的指點，這個javascript正則表達式程序算法確實有問題，我會試著找更好的辦法!!!

/a/ /7/ /M/

"a" "7" "M"

/a7M/

"a7M"

/a.c/

"a.c"

/filename\.ext/

"filename\.ext"

/Chapter [12345]/

"Chapter [12345]"

/Chapter [1-5]/

"Chapter [1-5]"

/Chapter [^12345]/

"Chapter [^12345]"

/Chapter [^1-5]/

"Chapter [^1-5]"

/[A-Za-z0-9]/

"[A-Za-z0-9]"

　　推薦：

　　Hibernate中文手冊》作者認為要學Hibernate看這個就足夠了，里面幾乎包括了所有的細節(jié)，不過可能不太適合快速入門。

　　地址：http://www.hibernate.org/hib_docs/v3/reference/zh-%20cn/html_single/

　　關(guān)于struts的資料就很多了，這里推薦一個可以下載一些入門教程的網(wǎng)站。

　　地址：http://www.wnetw.com/jclub/index.jsp

　　強烈建議入門的朋友先了解一下基本的原理！否則本文可能對你沒有任何幫助。

　　相關(guān)工具下載：（注意版本）

　　mysql5.0 http://www.mysql.org/
　　eclipse 3.1.1 http://www.eclipse.org/
　　myeclipse4.0.3 http://www.myeclipseide.com/
　　tomcat5.5

　　安裝：

　　關(guān)于tomcat和mysql的安裝就不多說了，需要注意的是最好保證你的 jdk是1.5的版本，并配置好你的環(huán)境變量，不然可能會遇到一些問題。

　　把eclipse解開，再去安裝剛下載的myeclipse，在安裝的時候需要把路徑指定到剛才解開的eclipse上，由于myeclipse是個收費軟件，所以需要注冊。不過一般按照Chinese的習慣，去google一個注冊碼就可以了:}

　　開發(fā)環(huán)境部署：

　　好了，現(xiàn)在保證你的mysql和tomcat服務(wù)能夠正常啟動，myeclipse能夠正常打開（如果不能，可以去找一下相關(guān)的說明或者給作者留言）。下面我們就要開始真正的開始部署一個傳說中的tomcat+struts+hibernate+mysql結(jié)構(gòu)的工程了！（faint!前言就寫的我好累）

　　首先，在myeclipse里新建一個工程。在左邊的Package Exporler面版里點右鍵選擇new->project…

　　在跳出菜單里選擇MyEclipse->J2EE Projects->Web Project。

　　點擊next后進入如下畫面：

　　工程名為：test

　　結(jié)束后點擊Finish。

　　好了，如果成功的話你就會在 Package Exporler里看到一個新的test工程！現(xiàn)在我們先配置一下數(shù)據(jù)庫方面的東西。首先在你的mysql 里建立一個數(shù)據(jù)庫webases，再在里面新建一個表admin，里面三個字段分別為id,name,password其中id為自動取值的主鍵（mysql具體的操作可以自己找資料，不是本文涉及范圍）。

　　再回到myeclipse ，選中window->Open Perspective->Other…

　　可以看到現(xiàn)在跳出一個名為Select Perspective的菜單，在里面選中MyEclipse Databases Exporler，可以看到現(xiàn)在到了下面的頁面。

　　最后選擇Finish。

　　再新建一個一個success.jsp的頁面，

　　在剛才struts- config.xml文件里右鍵選擇addAdmin選擇Properties，在菜單里選擇Forwords，再點add，如下圖填寫

　　最后，（汗，好累啊-_-!）打開addAdmin.jsp修改成如下：

<%@ page contentType="text/html; charset=utf-8"%>
<%@ page language="java"%>
<%@ taglib uri="<%@ taglib uri="

<script language = "javascript">
<!--
function check(){
if (loginForm.userName.value == "" || loginForm.password.value == ""){
alert("請輸入完整的信息！");
loginForm.userName.focus();
return false;
}
}
//-->
</script>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html:html>
<head>
<html:base />

<title>login.jsp</title>
<link href="css/webcss.css" rel="stylesheet" type="text/css">

<meta http-equiv="pragma" content="no- cache">
<meta http-equiv="cache-control" content="no- cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http- equiv="description" content="This is my page">
</head>

<body>
<center>
<p>&nbsp;</p>
<p>&nbsp;</p>
<table width="300" border="0" cellpadding="0" cellspacing="0">
<html:form action="/addAdmin" focus="name" method="GET">
<tr align="center" valign="middle">
<td colspan="2" class="typt_normal">新增管理員</td>
</tr>
<tr>
<td width="100" align="center" valign="middle" class="typt_normal">名稱： </td>
<td width="200" align="left"><html:text property="name" styleClass="text_s"/><html:errors property="addAdmin.err.name"/></td>
</tr>
<tr>
<td width="100" align="center" valign="middle" class="typt_normal">密碼： </td>
<td width="200" align="left"><html:password property="password" styleClass="text_s"/></td>
</tr>
<tr>
<td colspan="2" align="center" valign="middle"><html:submit value="提交" onclick="return check ();"/><html:reset value="重置"></html:reset></td>
</tr>
</html:form>
</table>
</center>
</body>

</html:html>

　　其中可以看到如何在struts的標簽中使用javascript的方法。

　　配置好myeclipse于tomcat的連接。在window->Preferences做如下設(shè)定：

　　現(xiàn)在打開瀏覽器，輸入

　　http://127.0.0.1:8080/test/addAdmin.jsp就可以看到你的jsp頁面了！

一、前言

J2EE和.NET是目前企業(yè)級運用的兩大陣營，誰優(yōu)誰劣各有說法。筆者是做J2EE方向的，覺得J2EE比起.NET最大的優(yōu)勢就是其經(jīng)過長實踐發(fā)展總結(jié)出來的大量模式和大量先進的框架。這些框架許多都是開源的——開源也是J2EE陣營的另一優(yōu)勢。本篇文章的主角就是目前J2EE web應用中最流行的兩大開源框架——Hibernate和Struts。

二、相關(guān)概念與工具介紹

下面我將分別對本文“三大主角”所涉及到相關(guān)概念進行說明。

Hibernate及相關(guān)知識介紹
Hibernate：
中文意思是"冬眠“，呵呵，不知道設(shè)計者為何用這個名字。它是一個開源的ORM框架（關(guān)于ORM下文還會講解），它是通過對JDBC API進行封裝從而實現(xiàn)對java對象持久化的。有人可能要問：JDBC其實不難操作，為什么還要封裝它哪？其實答案很簡單，因為現(xiàn)在通用的數(shù)據(jù)庫都是關(guān)系數(shù)據(jù)庫，我們通過JDBC操作無法做到OOP，所以Hibernate將JDBC封裝起來，并且提供了一套OO化的Hibernate API供頂層操作。Hibernate現(xiàn)在幾乎已經(jīng)成為ORM的公認標準了（剛推出的EJB 3.0標準中使用的ORM事實上就是Hibernate）

ORM：
這里解釋下ORM。ORM是一種模式（關(guān)于模式，筆者之前在這里發(fā)表過一篇介紹工廠模式的文章，讀者可以看看），它的英文是Object-Relation Mapping，中譯為對象-關(guān)系映射，它指的是“在單個組建中負責所有實體域?qū)ο蟮某志没?，封裝數(shù)據(jù)訪問細節(jié)”（注：此定義來自《精通Hibernate：java對象持久化技術(shù)詳解》，孫衛(wèi)琴，電子工業(yè)出版社）。筆者的覺得很容易理解：把關(guān)系數(shù)據(jù)庫對象化。


Struts及相關(guān)知識介紹
Struts：
Struts是由著名的Apache基金會開發(fā)的開源項目。中譯為“框架”，顧名思義，它就是一種MVC框架。眾所周知，MVC是一種業(yè)務(wù)邏輯與表示分離的模式，在java web上的應用十分廣泛。以前MVC的主要表現(xiàn)形式是JSP Model2，也就是JSP+Servlet+Javabean的應用，而近年來Struts的應用越來越廣泛，目前已經(jīng)是最流行的MVC框架了。

MVC：
Model-View-Controller，中譯為模型-視圖-控制器。MVC不是真正意義上的軟件設(shè)計模式，而更是一種解決方案，它把軟件系統(tǒng)的所有業(yè)務(wù)邏輯方面的編程交給了Model，把所有UI視圖的設(shè)計和編程交給了View，再用Controller控制器控制Model并生成相應的View，從而真正實現(xiàn)了業(yè)務(wù)邏輯與用戶界面的分離。


Eclipse介紹
Eclipse是由IBM公司開發(fā)出來，后來又免費捐獻出來的開源工具，是一套主要用于Java開發(fā)的IDE（Eclipse通過添加某些插件可以實現(xiàn)對UML、C++等的開發(fā)）。Eclipse具有強大的擴展功能，加上其開源的特性，導致許多愛好者和公司為其開發(fā)了非常優(yōu)秀的插件，Myeclipse就是其中之一。Myeclipse是面向J2EE開發(fā)者的Eclipse插件，功能強大，好用。本文的實例就是基于Eclipse+Myeclipse環(huán)境下開發(fā)出來的。

創(chuàng)建/運行本文實例除了安裝以上工具和插件外還需要安裝一個Web容器，本文使用的是Jboss，筆者可以自行選擇使用Tomcat或Weblogic等，這些對運行本文實例影響不大。

本文選擇的數(shù)據(jù)庫是SQLServer2000，關(guān)于Mysql、Oracle等其他數(shù)據(jù)庫的操作方法類似。

關(guān)于Eclipse下載和安裝方法本文不做介紹，請讀者自行在網(wǎng)上查找相關(guān)方法。

三、實例需求與總體設(shè)計
1、需求定義
由于本文的目的是介紹在Eclipse IDE下開發(fā)Struts+Hibernate的具體方法，而不是介紹項目開發(fā)/軟件設(shè)計的技巧，所以本文實例需求非常簡單。

本文實例是一個web留言簿，可以讓匿名用戶發(fā)表一些留言信息，并保存至數(shù)據(jù)庫。做過web開發(fā)的朋友肯定做過這類實例，非常經(jīng)典。由于實例簡單并且容易理解，所以筆者也省去畫用例圖說明的步驟。

2、總體設(shè)計
本實例按傳統(tǒng)J2EE web項目的設(shè)計方法，分為5層架構(gòu)，自底向上分別是：數(shù)據(jù)庫層 -> ORM層（Hibernate層） -> 業(yè)務(wù)邏輯層 -> 控制層（Struts Action） -> 視圖表示層。

數(shù)據(jù)庫的DDL語句如下：


四、持久化層與業(yè)務(wù)層實踐（Hibernate實踐）
好，戲肉開始。

1、先打開Eclipse。點擊“新建項目”－>“Web Project”，出現(xiàn)如下窗口，在窗口中Project Name填入“Memo”作為項目名：

?

2、點擊“窗口”－>“打開透視圖”－>“其他”，出現(xiàn)如下窗口，雙擊“Myeclipse Database Explorer”，切換到如下視圖：

3、在“DB Browser”控制面板點擊“new”，新建一個數(shù)據(jù)庫連接。在彈出的窗口中點擊“new driver”新建一個數(shù)據(jù)庫連接驅(qū)動。如下圖：

4、上一步后回到以下視圖，在列表中選擇上一步創(chuàng)建的驅(qū)動，填入相關(guān)數(shù)據(jù)庫資料，點擊確定即可。（此步驟前必須已經(jīng)打開數(shù)據(jù)庫，最后已經(jīng)按照本實例的DDL創(chuàng)建了庫和表）

5、完成上一步后出現(xiàn)以下視圖。點擊“memo”的右鍵，點擊“open connetion”－>“確定”。如果上述步驟成功的話這里會連接到數(shù)據(jù)庫，并顯示相關(guān)的數(shù)據(jù)庫結(jié)構(gòu)。

成功后如下圖：

6、點擊“窗口”－>“打開透視圖”－>“其他”－>“Myeclipse”切換到項目控制視圖。在項目名上點擊右鍵－>“myeclipse”－>“Add Hibernate capabilites”，出現(xiàn)以下視圖，并按下圖填入相關(guān)信息：

點下一步后出現(xiàn)如下框圖，按圖片上內(nèi)容填寫：

提交后出現(xiàn)以下視圖，按圖片內(nèi)容填寫：

7、在項目名上點擊右鍵－>“myeclipse”－>“Add Struts capabilites”，出現(xiàn)下面視圖，按圖中內(nèi)容天下：

8、點擊“窗口”－>“打開透視圖”－>“其他”，出現(xiàn)如下窗口，雙擊“Myeclipse Database Explorer”，切換到數(shù)據(jù)庫管理視圖，找到我們?yōu)楸敬螌嵗齽?chuàng)建的表格，點右鍵－>“create hibernate mapping”后出現(xiàn)下圖，按圖上內(nèi)容填寫：

9、至此Hibernate的創(chuàng)建工作已經(jīng)完成，如下圖，接下來我們寫個DAO工廠類來操作Hibernate API。

點擊com.woden包，新建個類，如下圖：

輸入以下代碼：

以上只有一個插入方法，如果讀者需要更多方法可以在DAO中自行添加。

至此，數(shù)據(jù)庫層、ORM層和業(yè)務(wù)層的代碼已經(jīng)完成。

五、控制層與表示層實踐（Struts實踐）

1、新建一個welcome.jsp文件，作為實例的首頁。具體方法是在“webroot”文件夾圖標點右鍵－>new－>“jsp”，接下來填寫的東西很簡單就不用介紹了吧。

2、在上一步驟的第7步中已經(jīng)在myeclipse中導入了struts，我們下面就可以開始編輯設(shè)置我們的struts實例。打開webboot目錄下WEB-INF中的struts配置文件“struts-config.xml”，如下圖：

3、在屏幕空白處點右鍵－>“new”－>“new form,action and jsp”，會出現(xiàn)如下視圖，按下圖提示填寫內(nèi)容：

這里記得點擊“jsp”標簽條，出現(xiàn)以下界面，按下圖設(shè)置：

4、上一步驟設(shè)置了form，點擊下一步看到如下視圖，按下圖設(shè)置，具體步驟是：點擊“foward”標簽－>“add”－>name填“success”，path選擇“welcome.jsp”，其他不用填－>確定。

5、上一步驟點擊了“完成”后出現(xiàn)下圖：

6、這一步驟是設(shè)置資源文件，為了struts的國際化和錯誤提示做準備。找到項目文件夾中src（源文件夾），找到ApplicationResourse.properties，雙擊打開，如下圖所示配置：（注：這里筆者安裝了一個免費的ascii轉(zhuǎn)unicode的插件）

如果讀者沒有安裝ascii自動轉(zhuǎn)unicode組建，可以直接copy我轉(zhuǎn)換后的資源文件內(nèi)容：

7、下面打開com.woden.form.MemoForm.java文件，輸入以下代碼：

8、上面已經(jīng)寫出了ActionForm的代碼，具體代碼筆者在這里不解釋，我想看過struts基礎(chǔ)的朋友都應該很清楚了，下面貼處Action的代碼：

9、最后編輯下幾個相關(guān)jsp文件的內(nèi)容，分別如下：

至此，本實例完成。

六、發(fā)布與運行
1、在項目文件點右鍵－>“myeclipse”－>“Add and remove project deployment”，如下圖：

2、點擊圖標，選擇“Jboss”－>“start”（注：這里如果用的是tomcat也類似操作，關(guān)于服務(wù)器配置的方法這里不祥談，請讀者自行在網(wǎng)上查找相關(guān)資料），會發(fā)現(xiàn)控制臺會輸出類似如下信息：

打開瀏覽器，輸入：http://localhost:8080/ 后如果出現(xiàn)下圖證明啟動成功：

3、輸入網(wǎng)址：http://localhost:8080/Memo/addmemo.jsp ，會看到效果圖如下圖：

4、按照正常流程和非正常流程分別留言一次，呵呵，效果出來沒有？如果沒有出現(xiàn)預期效果請檢查前面步驟。

七、寫在最后

在本文最后，筆者再次強調(diào)，本文的目的是介紹Eclipse IDE關(guān)于創(chuàng)建Struts+Hibernate應用的方法，而不是介紹j2ee框架的概念和運用，更不是介紹java設(shè)計與模式。本文對IDE的配置、服務(wù)器配置的方法也沒做詳細介紹，因為這都不是本文重點。對以上知識想了解多點的讀者可以google一下。

本文的實例只是一個入門，強調(diào)的是一種方法，而不是強調(diào)功能，所以本文的實例只有一個簡單的錄入功能。在看完本文后讀者可以添加更多的功能（我想，當這一架構(gòu)搭建起來后，添加功能已經(jīng)是相當容易的事情了）。

內(nèi)容摘要：

作者： 車東 http://www.chedong.com/tech/default.html

ANT的基本概念：Java的Makefile

當一個代碼項目大了以后，每次重新編譯，打包，測試等都會變得非常復雜而且重復，因此c語言中有make腳本來幫助這些工作的批量完成。在Java中應用是平臺無關(guān)性的，當然不會用平臺相關(guān)的make腳本來完成這些批處理任務(wù)了，ANT本身就是這樣一個流程腳本引擎，用于自動化調(diào)用程序完成項目的編譯，打包，測試等。除了基于JAVA是平臺無關(guān)的外，腳本的格式是基于XML的，比make腳本來說還要好維護一些。

每個ant腳本（缺省叫build.xml）中設(shè)置了一系列任務(wù)(target)：比如對于一個一般的項目可能需要有以下任務(wù)。

• 任務(wù)1：usage 打印本腳本的幫助信息（缺?。?/span>
• 任務(wù)2：clean <-- init 清空初始化環(huán)境
• 任務(wù)3：javadoc <-- build <-- init 生成JAVADOC
• 任務(wù)4：jar <-- build <-- init 生成JAR
• 任務(wù)5：all <-- jar + javadoc <-- build <-- init 完成以上所有任務(wù)：jar javadoc

ANT的安裝

ANT的使用

• 測試任務(wù)：JUnit測試
• 代碼風格檢查任務(wù)：CheckStyle，Jalopy等
• 郵件警報任務(wù)：可以把以上這些任務(wù)的輸出警告發(fā)送到制定的用戶列表中，這個任務(wù)可以設(shè)置每天自動運行。

public interface UserDAO {

public abstract boolean isValidUser(String username, String password);

}

UserDAOImp.java

import java.util.List;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.test.Hibernate.SessionFactory;

public class UserDAOImp extends HibernateDaoSupport implements UserDAO {

private SessionFactory sessionFactory;

private static String hql = "from User u where u.username=? ";

public boolean isValidUser(String username, String password) {

List userList = this.getHibernateTemplate().find(hql, username);

if (userList.size() > 0) {

return true;

}

return false;

}

}

修改LoginAction.java文件，使用userDao的方法來進行用戶驗證

package com.test.struts.action;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.validator.DynaValidatorForm;

import com.test.UserDAO;

public class LoginAction extends Action {

private UserDAO userDAO;

public UserDAO getUserDAO() {
return userDAO;
}

public void setUserDAO(UserDAO userDAO) {
this.userDAO = userDAO;
}

public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
DynaValidatorForm loginForm = (DynaValidatorForm) form;
// TODO Auto-generated method stub
String username = (String) loginForm.get("username");
String password = (String) loginForm.get("password");
loginForm.set("password", null);
if (userDAO.isValidUser(username,password)) {
return mapping.findForward("indexGo");
} else {
return mapping.getInputForward();
}
}

}
綠色字體為修改部份

現(xiàn)在剩下最后的spring配置了

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

<beans>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName">
<value>com.mysql.jdbc.Driver</value>
</property>
<property name="url">
<value>jdbc:mysql://localhost/test</value>
</property>
<property name="username">
<value>root</value>
</property>
<property name="password">
<value>root</value>
</property>
</bean>

<!-- 配置sessionFactory, 注意這里引入的包的不同 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref local="dataSource" />
</property>
<property name="mappingResources">
<list>
<value>com/test/Hibernate/User.hbm.xml</value>
</list>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
<prop key="hibernate.show_sql">true</prop>
</props>
</property>
</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>

<bean id="userDAO" class="com.test.UserDAOImp">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>

<bean id="userDAOProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager">
<ref bean="transactionManager" />
</property>
<property name="target">
<ref local="userDAO" />
</property>
<property name="transactionAttributes">
<props>
<prop key="insert*">PROPAGATION_REQUIRED</prop>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="is*">PROPAGATION_REQUIRED,readOnly</prop>
</props>
</property>
</bean>

<bean name="/login" class="com.test.struts.action.LoginAction" singleton="false">
<property name="userDAO">
<ref bean="userDAOProxy" />
</property>
</bean>
</beans>

現(xiàn)在可以進行測試了！

在編寫代碼有配置內(nèi)容時一定要注意 hibernate 和 hibernate3 ，這兩個包的名字就只差一個字，千萬不要有錯，否則找錯誤可是很難的。