Log4j由三个重要的组件构成：日志信息的优先级，日志信息的输出目的地，日志信息的输出格式。日志信息的优先级从高到低有ERROR、WARN、INFO、DEBUG，分别用来指定这条日志信息的重要程度；日志信息的输出目的地指定了日志将打印到控制台还是文件中；而输出格式则控制了日志信息的显示内容。

　　一、定义配置文件

　　其实您也可以完全不使用配置文件，而是在代码中配置Log4j环境。但是，使用配置文件将使您的应用程序更加灵活。Log4j支持两种配置文件格式，一种是XML格式的文件，一种是Java特性文件（键=值）。下面我们介绍使用Java特性文件做为配置文件的方法：

　　1.配置根Logger，其语法为：

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

　　其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。比如在这里定义了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（每天产生一个日志文件），
　　org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
　　org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

　　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（包含日志产生的时间、线程、类别等等信息）

　　Log4J采用类似C语言中的printf函数的打印格式格式化日志信息，打印参数如下： %m 输出代码中指定的消息

　　%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
　　%r 输出自应用启动到输出该log信息耗费的毫秒数
　　%c 输出所属的类目，通常就是所在类的全名
　　%t 输出产生该日志事件的线程名
　　%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n”
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似：2002年10月18日 22：10：28，921
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

　　二、在代码中使用Log4j

　　1.得到记录器

　　使用Log4j，第一步就是获取日志记录器，这个记录器将负责控制日志信息。其语法为：

　　public static Logger getLogger( String name)

　　通过指定的名字获得记录器，如果必要的话，则为这个名字创建一个新的记录器。Name一般取本类的名字，比如：

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

　　2.读取配置文件

　　当获得了日志记录器之后，第二步将配置Log4j环境，其语法为：

　　BasicConfigurator.configure ()： 自动快速地使用缺省Log4j环境。
　　PropertyConfigurator.configure ( String configFilename) ：读取使用Java的特性文件编写的配置文件。
　　DOMConfigurator.configure ( String filename ) ：读取XML形式的配置文件。

　　3.插入记录信息（格式化日志信息）

　　当上两个必要步骤执行完毕，您就可以轻松地使用不同优先级别的日志记录语句插入到您想记录日志的任何地方，其语法如下：

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

作者：佚名    来自：未知

　　一、J2ME中需要的Java基础知识

　　现在有大部分人，都是从零开始学J2ME的，学习J2ME的时候，总是从Java基础开始学习，而且现在讲Java基础的书籍中都是以J2SE来讲基础，这就给学习造成了一些不必要的麻烦，下面将J2ME中用到的和不需要的Java基础知识做一个简单的说明。

　　J2ME中使用到的Java基础知识：

　　 1、Java语法基础：包括基本数据类型、关键字、运算符等等

　　 2、面向对象的思想：类和对象的概念，继承和多态等等。

　　 3、异常处理

　　 4、多线程

　　J2ME中没有用到的Java基础知识：

　　 1、JDK中javac和java命令的使用

　　 2、Java基础中的很多类在J2ME中没有，或者类中的方法做了大量的精简。所以建议在J2ME中熟悉类库。

　　 3、Applet、AWT、Swing这些知识在J2ME中根本使用不到。

　　简单说这么多，希望学J2ME的朋友们能少走一些弯路，不足之处希望大家积极指正和补充。

　　二、J2ME中暂时无法完成的功能

　　列一些J2ME中暂时无法完成的功能，希望大家能积极补充：

　　 1、在手机中不更改代码实现移植，主要指游戏。

　　 2、动态修改按钮文字。

　　 3、在Canvas上接受中文输入。

　　 4、操作本地资源、例如地址本、已收短信息等。

　　 5、制作破坏性的手机病毒。

　　 6、其他等待大家来补充。

　　三、J2ME的跨平台性

　　J2ME技术源于Java，所以也具有JVM的优势，可以在支持Java的平台上进行移植，但是现在的J2ME技术在跨平台上却做的很糟糕，我们来简单看一下原因：

　　1、手机的屏幕尺寸不一：

　　这个主要在界面制作上。如果你使用的是高级用户界面，比如你做的是应用开发或者用户登陆、用户注册这样的通用功能时，一般没有什么问题。

　　如果你使用的是低级用户界面，比如你做的是游戏，那么你就需要考虑这个问题了。

　　2、厂商的扩展API不统一：

　　例如Nokia的扩展API类库UI系列，在别的手机上或者没有实现，或者包名不同等等。

　　3、手机平台上实现的bug：

　　例如Nokia的7650在实现双缓冲上有bug，那么在这种机型上运行的软件就不能使用双缓冲。其他NOKIA上的一些bug，可以参看：http://blog.csdn.net/Mailbomb/archive/2005/03/24/329123.aspx

　　4、手机性能问题。

　　不同手机的可用内存、最大jar文件都有要求，例如Nokia S40的大部分手机支持的最大jar文件为64K，最大可用内容为210K。

　　所以现在的手机软件，特别是游戏都提供支持的机型列表，也才有了手机游戏移植人员的存在。

　　四、学习J2ME可以从事的工作种类

　　现在J2ME技术可以说相当的火暴，这里介绍一些学好了J2ME之后可以从事的工作的种类：

　　1、J2ME游戏开发人员

　　根据游戏策划或者文档要求，在某种特定的机型(以Nokia S40或S60居多)开发游戏程序。这是现在大部分J2ME程序员从事的工作。

　　需要熟练掌握：高级用户界面、低级用户界面、线程，如果是网络游戏，还需要熟练网络编程。

　　2、J2ME应用开发人员

　　现在的移动应用还不是很多，但是还是出现了一些，特别是移动定位以及移动商务相关的内容。需要熟练掌握：高级用户界面、线程和网络编程。

　　3、J2ME游戏移植人员

　　参照源代码，将可以在一个平台上可以运行的游戏移植到其他平台上去。例如将Nokia S40的游戏移植到S60上，或者索爱的T618等等。主要是控制屏幕坐标，有些可能需要替换一些API。

　　需要熟悉各平台之间的差异以及相关的技术参数，比如屏幕大小、最大jar文件尺寸等等。

　　五、J2ME程序设计的几个原则

　　1、使用面向对象编程。

　　虽然使用面向过程编程可以减小文件的尺寸，但是为了以后维护的方便和利于扩展，还是要使用面向对象编程。

　　2、使用MVC模式

　　将模型、界面和控制分离。现在很多的程序将三者合一，但是如果你做的程序比较大的话，还是建议你进行分离。

　　3、自动存储用户设定

　　使用RMS来存储用户的信息，例如存储用户上次输入的用户名、密码、用户对于系统的设定等，这样不仅可以减少用户的输入，而且对用户友好。很多程序甚至做了自动登陆等。

　　4、一些系统设置允许用户关闭。如背景音乐、背景灯显示等。

　　5、将低级用户界面的绘制动作放在一个独立的线程里面去。

　　6、在需要大量时间才能完成的工作时，给用户一个等待界面。

　　六、从模拟器到真机测试

　　对于J2ME开发者来说，模拟器给我们带来了很多方便，比如可以在模拟器中调试程序以及很方便的察看程序的效果，但是模拟器也给我们带来了一些问题，比如模拟器实现的bug等等，所以进行真机测试是必须的。

　　1、为什么要进行真机测试？

　　因为模拟器程序可能存在bug，以及真机的性能有限，所以必须进行真机测试。

　　2、如何将程序传输到机器中？

　　将程序传输到机器中有如下方式：

　　 a)　OTA下载
　　 b)　使用数据线传输
　　 c)　红外传输
　　 d)　蓝牙

　　你可以根据条件，选择合适的方式。

　　3、 真机测试主要测什么？

　　真机测试的内容很多，主要测试以下几个方面：

　　 a)　程序的功能
　　 b)　程序的操作性，是否易操作
　　 c)　程序的大小,比如Nokia S40系列的手机大部分接受的最大文件尺寸为64K
　　 d)　程序运行速度，速度是否可以忍受。

　　七、从WTK到厂商SDK

　　对于J2ME爱好者来说，基本上大家都是从SUN的WTK(J2ME Wireless Toolkit)开始的，但是对于实际应用来说，仅仅使用WTK是远远不够的，所以在学习过程中，必须完成从WTK到SDK的跨越。

　　1、厂商SDK的下载地址？

　　·Nokia
　　Nokia不愧为手机行业的老大，对于j2me的支持也是一流的，有专门的网站提供SDK和各种文档说明。
　　网址是：http://forum.nokia.com.cn/sch/index.html

　　·Siemens
　　Siemens对于J2ME的支持也不错，它提供了SDK，模拟器需要独立安装。下载地址如下：
　　https://communication-market.siemens.de/portal/main.aspx?LangID=0&MainMenuID=2&LeftID=2&pid=1&cid=0&tid=3000&xid=0

　　·SonyEricsson
　　SonyEricsson SDK以及自己的模拟器，下载地址为：
　　http://developer.sonyericsson.com/site/global/docstools/java/p_java.jsp
　　http://mobilityworld.ericsson.com.cn/development/download_hit.asp

　　·Motorola
　　Motorola提供了专门的SDK，内部包含模拟器，下载地址为：
　　http://www.motocoder.com/motorola/pcsHome.jsp

　　·SamSung
　　SamSung也提供了专门的SDK和模拟器，下载地址为：
　　http://developer.samsungmobile.com/eng/front_zone/bbs/bbs_main.jsp?p_menu_id=1500

　　·NEC：
　　NEC也提供了集成模拟器的SDK，下载地址为：
　　http://www.nec-mfriend.com/cn

　　2、厂商SDK和WTK有什么不同？

　　厂商SDK最简单的理解就是在WTK的基础上增加了自己的模拟器和自己的扩展API。也就是说，你在使用厂商的SDK时，可以使用厂商的扩展类库，例如Nokia的UI类库，和厂商自己的模拟器而已。每个厂商的扩展API都不多，而且不尽相同。

　　3、如何使用？

　　有些厂商SDK的使用都和WTK相同，例如SamSung。Nokia提供了独立的界面来开发，但是这个界面在实际开发中使用不多。

　　4、厂商SDK的问题

　　厂商SDK实现过程中，有一些bug，而且和真机实现不一致。例如NOKIA的混音播放问题等等。

　　八、在J2ME中获得手机IMEI的方法

　　IMEI是Internation mobile entity identification的简称，在手机中输入*#06#可以显示该数字，长度为15位，全球唯一，永远不会冲突，所以可以作为识别用户的一个标志。

　　下面是在J2ME中获得IMEI的方法：

　　1、MOTO系列的手机可以通过读取系统的IMEI属性获得，代码如下：

　　 String imei = System.getProperty("IMEI");

　　2、SIEMENS系列的手机可以通过读取系统的com.siemens.IMEI属性获得，代码如下：

　　 String imei = System.getProperty("com.siemens.IMEI");

　　九、J2ME网络连接中显示问题的解决办法

　　在网络编程中，有些时候会出现一些在没有接收到网络数据就显示界面的，造成界面显示不符合要求（例如公告显示，会先显示公告的背景图片再显示公告信息），这里提一个简单的解决办法给大家：

　　解决这种情况的方法分成三个步骤：

　　1、在需要显示的界面中，调用发送网络数据的方法。每次显示时调用该构造方法，不调用Display的setCurrent方法显示。

　　2、显示等待界面(例如进度条等)，给用户提示，在进行网络连接。

　　3、在处理网络反馈的数据完以后，调用Display的setCurrent方法显示显示当前界面。

双面提供　时时整理 问题： String s1="111+222+333"; System.out.println(s1.split("+").length); //输出时提示错误： java.util.regex.PatternSyntaxException: Dangling meta character '+' near index 问题出现在加号附近，查询相关的资料显示，+、*、|、\等符号在正则表达示中有相应的不同意义。 正则表达式的基本用法 zt

1、“.”为通配符，表示任何一个字符，例如：“a.c”可以匹配“anc”、“abc”、“acc”； 2、“[]”，在[]内可以指定要求匹配的字符，例如：“a[nbc]c”可以匹配“anc”、“abc”、“acc； 但不可以匹配“ancc”,a到z可以写成[a-z],0到9可以写成[0-9]; 3、数量限定符号，表示匹配次数（或者叫做长度）的符号： 包括：“*”——0次或者多次       “+”——1次或者多次       “?”——0次或者1次       “{n}”——匹配n次，n为整数       “{n,m}”——匹配从n到m之间的某个数的次数；n和m都是整数；       “{n,}”——匹配n到无穷次之间任意次数；       “{,m}”——匹配0到m之间任意次数； 他们放到匹配格式的后面： 例如： 电话号码：024－84820482，02484820482(假设前面3或者4位，后面7或者8位，并且中间的减号可有可无) 都是符合规定的，那么可以用如下格式来匹配：[0-9]{3,4} \-? [0-9]{7,8}； 注意：“\”为转义字符，因为“-”在正则表达式用有代表一个范围的意义，例如：前面所说的[0-9]， 所以它需要转义字符“\”进行转义才可使用； 4、“^”为否符号，表示不想匹配的符号，例如：[^z][a-z]+可以匹配所有除“z”开头的以外的所有字 符串（长度大于2，因为“+”表示大于等于1的次数，从第二位开始都是小写英文字符）； 如果^放到[]的外边则表示以[]开头的字符串；^[az][a-z]+表示a或者z开头的长度大于等于2的英文字符串； 5、“|”或运算符，例如：a[n|bc|cb]c可以匹配“abcc”,“anc”,“acbc”； 6、“$”以它前面的字符结尾的；例如：ab+$就可以被“abb”，“ab”匹配； 7、一些简单表示方法： \d表示[0-9];\D表示[^0-9];\w表示[A-Z0-9];\W表示[^A-Z0-9];\s表示[\t\n\r\f],就是空格字符包括tab，空格等等;\S表示[^\t\n\r\f]，就是非空格字符; 明白了这些以后，我们再返回头看看它们如何被运用呢？一般来讲只需要加[]、或是\\即可。 举例来讲： String s1="111+222+333"; System.out.println(s1.split("[+]").length); 或是 String s1="111+222+333"; System.out.println(s1.split("\\+").length); 其他用法类同。

　　在上图中，我们将应用层放在了持久层的上部，实际上在传统的项目中，应用层充当着持久层的一个客户端角色。但对于一些简单的项目来说，应用层和持久层并没有区分得那么清楚，这也没什么，在这种情况下你可以将应用层和持久层合并成了一层。

　　在上图中，Hibernate的接口大致可以分为以下几种类型：

　　· 一些被用户的应用程序调用的，用来完成基本的创建、读取、更新、删除操作以及查询操作的接口。这些接口是Hibernate实现用户程序的商业逻辑的主要接口，它们包括Session、Transaction和Query。

　　· Hibernate用来读取诸如映射表这类配置文件的接口，典型的代表有Configuration类。

　　· 回调(Callback)接口。它允许应用程序能对一些事件的发生作出相应的操作，例如Interceptor、Lifecycle和Validatable都是这一类接口。

　　· 一些可以用来扩展Hibernate的映射机制的接口，例如UserType、CompositeUserType和IdentifierGenerator。这些接口可由用户程序来实现（如果有必要）。

　　Hibernate使用了J2EE架构中的如下技术：JDBC、JTA、JNDI。其中JDBC是一个支持关系数据库操作的一个基础层；它与JNDI和JTA一起结合，使得Hibernate可以方便地集成到J2EE应用服务器中去。

　　在这里，我们不会详细地去讨论Hibernate API接口中的所有方法，我们只简要讲一下每个主要接口的功能，如果你想了解得更多的话，你可以在Hibernate的源码包中的net.sf.hibernate子包中去查看这些接口的源代码。下面我们依次讲一下所有的主要接口：

　　核心接口

　　以下5个核心接口几乎在任何实际开发中都会用到。通过这些接口，你不仅可以存储和获得持久对象，并且能够进行事务控制。

　　Session接口

　　Session接口对于Hibernate 开发人员来说是一个最重要的接口。然而在Hibernate中，实例化的Session是一个轻量级的类，创建和销毁它都不会占用很多资源。这在实际项目中确实很重要，因为在客户程序中，可能会不断地创建以及销毁Session对象，如果Session的开销太大，会给系统带来不良影响。但值得注意的是Session对象是非线程安全的，因此在你的设计中，最好是一个线程只创建一个Session对象。

　　在Hibernate的设计者的头脑中，他们将session看作介于数据连接与事务管理一种中间接口。我们可以将session想象成一个持久对象的缓冲区，Hibernate能检测到这些持久对象的改变，并及时刷新数据库。我们有时也称Session是一个持久层管理器，因为它包含这一些持久层相关的操作，诸如存储持久对象至数据库，以及从数据库从获得它们。请注意，Hibernate 的session不同于JSP应用中的HttpSession。当我们使用session这个术语时，我们指的是Hibernate中的session，而我们以后会将HttpSesion对象称为用户session。

　　SessionFactory 接口

　　这里用到了一个设计模式――工厂模式，用户程序从工厂类SessionFactory中取得Session的实例。

　　令你感到奇怪的是SessionFactory并不是轻量级的！实际上它的设计者的意图是让它能在整个应用中共享。典型地来说，一个项目通常只需要一个SessionFactory就够了，但是当你的项目要操作多个数据库时，那你必须为每个数据库指定一个SessionFactory。
SessionFactory在Hibernate中实际起到了一个缓冲区的作用，它缓冲了Hibernate自动生成的SQL语句和一些其它的映射数据，还缓冲了一些将来有可能重复利用的数据。

　　Configuration 接口

　　Configuration接口的作用是对Hibernate进行配置，以及对它进行启动。在Hibernate的启动过程中，Configuration类的实例首先定位映射文档的位置，读取这些配置，然后创建一个SessionFactory对象。

　　虽然Configuration接口在整个Hibernate项目中只扮演着一个很小的角色，但它是启动hibernate时你所遇到的每一个对象。

　　Transaction 接口

　　Transaction接口是一个可选的API，你可以选择不使用这个接口，取而代之的是Hibernate的设计者自己写的底层事务处理代码。 Transaction接口是对实际事务实现的一个抽象，这些实现包括JDBC的事务、JTA中的UserTransaction、甚至可以是CORBA事务。之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移值。

　　Query和Criteria接口

　　Query接口让你方便地对数据库及持久对象进行查询，它可以有两种表达方式：HQL语言或本地数据库的SQL语句。Query经常被用来绑定查询参数、限制查询记录数量，并最终执行查询操作。

　　Criteria接口与Query接口非常类似，它允许你创建并执行面向对象的标准化查询。

　　值得注意的是Query接口也是轻量级的，它不能在Session之外使用。

　　Callback 接口

　　当一些有用的事件发生时――例如持久对象的载入、存储、删除时，Callback接口会通知Hibernate去接收一个通知消息。一般而言，Callback接口在用户程序中并不是必须的，但你要在你的项目中创建审计日志时，你可能会用到它。

“Hello World”	“Hello world”示例程序让您对Hibernate有一个简单的认识。
理解Hibernate的架构	介绍Hibernate接口的主要功能。
核心接口	Hibernate有5个核心接口，通过这几个接口开发人员可以存储和获得持久对象，并且能够进行事务控制
一个重要的术语：Type	Type是Hibernate发明者发明的一个术语，它在整个构架中是一个非常基础、有着强大功能的元素，一个Type对象能将一个Java类型映射到数据库中一个表的字段中去。
策略接口	Hibernate与某些其它开源软件不同的还有一点――高度的可扩展性，这通过它的内置策略机制来实现。
基础配置	Hibernate可以配置成可在任何Java环境中运行，一般说来，它通常被用在2－3层的C/S模式的项目中，并被部署在服务端。
创建一个SessionFactory对象	要创建一个SessionFactory对象，必须在Hibernate初始化时创建一个Configuration类的实例，并将已写好的映射文件交由它处理。

　　“Hello World”

　　Hibernate应用程序定义了一些持久类，并且定义了这些类与数据库表格的映射关系。在我们这个“Hello world”示例程序中包含了一个类和一个映射文件。让我们看看这个简单的持久类包含有一些什么？映射文件是怎样定义的？另外，我们该怎样用Hibernate来操作这个持久类。

　　我们这个简单示例程序的目的是将一些持久类存储在数据库中，然后从数据库取出来，并将其信息正文显示给用户。其中Message正是一个简单的持久类：，它包含我们要显示的信息，其源代码如下：

　　列表1　Message.Java　一个简单的持久类

package hello; public class Message { 　private Long id; 　private String text; 　private Message nextMessage; 　private Message() {} 　public Message(String text) { 　　this.text = text; 　} 　public Long getId() { 　　return id; 　} 　private void setId(Long id) { 　　this.id = id; 　} 　public String getText() { 　　return text; 　} 　public void setText(String text) { 　　this.text = text; 　} 　public Message getNextMessage() { 　　return nextMessage; 　} 　public void setNextMessage(Message nextMessage) { 　　this.nextMessage = nextMessage; 　} }

　　Message类有三个属性：Message的id 、消息正文、以及一个指向下一条消息的指针。其中id属性让我们的应用程序能够唯一的识别这条消息，通常它等同于数据库中的主键，如果多个Message类的实例对象拥有相同的id，那它们代表数据库某个表的同一个记录。在这里我们选择了长整型作为我们的id值，但这不是必需的。Hibernate允许我们使用任意的类型来作为对象的id值，在后面我们会对此作详细描述。

　　你可能注意到Message类的代码类似于JavaBean的代码风格，并且它有一个没有参数的构造函数，在我们以后的代码中我将继续使用这种风格来编写持久类的代码。

　　Hibernate会自动管理Message类的实例，并通过内部机制使其持久化，但实际上Message对象并没有实现任何关于Hibernate的类或接口，因此我们也可以将它作为一个普通的Java类来使用：

Message message = new Message("Hello World"); System.out.println( message.getText() );

　　以上这段代码正是我们所期望的结果：它打印“hello world”到屏幕上。但这并不是我们的最终目标；实际上Hibernate与诸如EJB容器这样的环境在持久层实现的方式上有很大的不同。我们的持久类(Message类)可以用在与容器无关的环境中，不像EJB必须要有EJB容器才能执行。为了能更清楚地表现这点，以下代码将我们的一个新消息保存到数据库中去：

Session session = getSessionFactory().openSession(); Transaction tx = session.beginTransaction(); Message message = new Message("Hello World"); session.save(message); tx.commit(); session.close();

　　以上这段代码调用了Hibernate的Session和Transaction接口（关于getSessionFactory()方法我们将会马上提到）。它相当于我们执行了以下SQL语句：

insert into MESSAGES (MESSAGE_ID, MESSAGE_TEXT, NEXT_MESSAGE_ID) values (1, 'Hello World', null)

　　在以上的SQL语句中，MESSAGE_ID字段到底被初始化成了什么值呢？由于我们并没有在先前的代码中为message对象的id属性赋与初始值，那它是否为null呢？实际上Hibernate对id属性作了特殊处理：由于它是一个对象的唯一标识，因此当我们进行save()调用时，Hibernate会为它自动赋予一个唯一的值（我们将在后面内容中讲述它是如何生成这个值的）。

　　我们假设你已经在数据库中创建了一个名为MESSAGE的表，那么既然前面这段代码让我们将Message对象存入了数据库中，那么现在我们就要将它们一一取出来。下面这段代码将按照字母顺序，将数据库中的所有Message对象取出来，并将它们的消息正文打印到屏幕上：

Session newSession = getSessionFactory().openSession(); Transaction newTransaction = newSession.beginTransaction(); List messages =newSession.find("from Message as m order by m.text asc"); System.out.println( messages.size() + " message(s) found:" ); for ( Iterator iter = messages.iterator(); iter.hasNext(); ) { 　Message message = (Message) iter.next(); 　System.out.println( message.getText() ); } newTransaction.commit(); newSession.close();

　　在以上这段代码中，你可能被find()方法的这个参数困扰着："from Message as m order by m.text asc"，其实它是Hibernate自己定义的查询语言，全称叫Hibernate Query Language(HQL)。通俗地讲HQL与SQL的关系差不多就是方言与普通话之间的关系，咋一看，你会觉得它有点类似于SQL语句。其实在find()调用时，Hibernate会将这段HQL语言翻译成如下的SQL语句：

select m.MESSAGE_ID, m.MESSAGE_TEXT, m.NEXT_MESSAGE_ID from MESSAGES m order by m.MESSAGE_TEXT asc

　　以下就是运行结果：

1 message(s) found: Hello World

　　如果你以前没有ORM（对象－关系映射）的开发经验，那你可能想在代码的某个地方去寻找这段SQL语句，但在Hibernate中你可能会失望：它根本不存在！所有就SQL语句都是Hibernate动态生成的。

　　也许你会觉得还缺点什么，对！仅凭以上代码Hibernate是无法将我们的Message类持久化的。我们还需要一些更多的信息，这就是映射定义表！这个表在Hibernate中是以XML格式来体现的，它定义了Message类的属性是怎样与数据库中的MESSAGES表的字段进行一一对应的，列表2是这个示例程序的映射配置文件清单：

　　列表2：示例程序的对象－关系映射表

＜?xml version="1.0"?＞ ＜!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd"＞ ＜hibernate-mapping＞ ＜class name="hello.Message" table="MESSAGES"＞ 　＜id name="id" column="MESSAGE_ID"＞ 　　＜generator class="increment"/＞ 　＜/id＞ 　＜property name="text" column="MESSAGE_TEXT"/＞ 　＜many-to-one name="nextMessage" cascade="all" column="NEXT_MESSAGE_ID"/＞ ＜/class＞ ＜/hibernate-mapping＞

　　以上这个文档告诉Hibernate怎样将Message类映射到MESSAGES表中，其中Message类的id属性与表的MESSAGE_ID字段对应，text属性与表的MESSAGE_TEXT字段对应，nextMessage属性是一个多对一的关系，它与表中的NEXT_MESSAGE_ID相对应。

　　相对于有些开源项目来说，Hibernate的配置文件其实是很容易理解的。你可以轻松地修改与维护它。只要你定义好了持久类与数据库中表字段的对应关系就行了，Hibernate会自动帮你生成SQL语句来对Message对象进行插入、更新、删除、查找工作，你可以不写一句SQL语句，甚至不需要懂得SQL语言！

　　现在让我们做一个新的试验，我们先取出第一个Message对象，然后修改它的消息正文，最后我们再生成一个新的Message对象，并将它作为第一个Message对象的下一条消息，其代码如下：

　　列表3　更新一条消息

Session session = getSessionFactory().openSession(); Transaction tx = session.beginTransaction(); // 1 is the generated id of the first message Message message =(Message) session.load( Message.class, new Long(1) ); message.setText("Greetings Earthling"); Message nextMessage = new Message("Take me to your leader (please)"); message.setNextMessage( nextMessage ); tx.commit(); session.close();

　　以上这段代码在调用时，Hibernate内部自动生成如下的SQL语句：

select m.MESSAGE_ID, m.MESSAGE_TEXT, m.NEXT_MESSAGE_ID from MESSAGES m where m.MESSAGE_ID = 1 insert into MESSAGES (MESSAGE_ID, MESSAGE_TEXT, NEXT_MESSAGE_ID) values (2, 'Take me to your leader (please)', null) update MESSAGES set MESSAGE_TEXT = 'Greetings Earthling', NEXT_MESSAGE_ID = 2 where MESSAGE_ID = 1

　　当第一个Message对象的text属性和nextMessage被程序修改时，请注意Hibernate是如何检测到这种变化，并如何在数据库中自动对它更新的。这实际上是Hibernate的一个很有价值的特色，我们把它称为“自动脏数据检测”，Hibernate的这个特色使得当我们修改一个持久对象的属性后，不必显式地通知Hibernate去将它在数据库中进行更新。同样的，当第一个Message对象调用setNextMessage()方法将第二个Message对象作为它的下一条消息的引用时，第二条消息会无需调用save()方法，便可以自动地保存在数据库中。这种特色被称为“级联保存”，它也免去了我们显式地对第二个Message对象调用save()方法之苦。

　　如果我们再运行先前的那段将数据库中所有的Message对象都打印出来的代码，那它的运行结果如下：

2 message(s) found: Greetings Earthling Take me to your leader (please)

　　“Hello world”示例程序现在介绍完毕。我们总算对Hibernate有了一个简单的认识，下面我们将回过头来，对Hibernate的主要API调用作一下简要的介绍：

robbin讲的肯定比我好的多，自己去精华版看看。

我所给的只是我当初刚开始接触hibernate时候很想要的一个简单例子和设置方法。

一直没有找到，所以现在放到这里给大家看看，（只给想要入门的一个直观的感应，呵呵）

首先当然要新建一个项目

然后在Project Properties->Paths->Required Libraries->add->new 这里定义hibernate的类库 把hibernate的lib下面的所有jar包进去 当然还有hibernate2.jar也要

然后一路ok下去就可以了。

再来就是hibernate.properties

从hibernate的src下面找到

把它拷到你项目的src目录下

（什么，你的项目没有src目录，新建一个随便的类就有src目录了）

这样一个JB下面的hibernate的开发环境就好了

然后在hibernate.properties里面设置你的数据库连接

默认是HypersonicSQL

嗯 接下来的是你最想要做的事情了 其实很简单

新建一个类Message.java

代码如下

package hello;

import java.io.Serializable;

/**
 * @author getdown
 * @version 1.0
 */

public class Message implements Serializable {
  private Long id;
  private String text;
  //定义一个简单链表 指向另外的一个Message
  private Message nextMessage;
  public Message() {}

  public Message(Long id) {
    this.id = id;
  }

  public Message(String text) {
    this.text = text;
  }

  public Message(Long id, String text) {
    this.id = id;
    this.text = text;
  }

  public Long getId() {
    return id;
  }

  private void setId(Long id) {
    this.id = id;
  }

  public String getText() {
    return text;
  }

  public void setText(String text) {
    this.text = text;
  }

  public Message getNextMessage() {
    return nextMessage;
  }

  public void setNextMessage(Message nextMessage) {
    this.nextMessage = nextMessage;
  }

}

接下来是这个类对应的hibernate的配置文件 Message.hbm.xml

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping>
    <!--定义类和表的对应-->
    <class
        name="hello.Message"
        table="Messages"
    >
    <!--定义ID字段和生成ID的策略 这里采用identity-->
    <id    name="id"
        column="MESSAGE_ID"
    >
    <generator class="identity"/>
    </id>
        <!--定义里面的text字段-->
    <property
        name="text"
                type="string">
                <!--定义text字段在数据库里面生成的方法-->
        <column
            name="TEXT"
            length="100"
                        not-null="true"
                />
    </property>
       <!--定义对象关联之间的对应关系和关联的字段-->
    <many-to-one
        name="nextMessage"
        cascade="all"
        column="NEXT_MESSAGE_ID"
    />
    </class>
</hibernate-mapping>

然后就是测试类

package hello;

import net.sf.hibernate.cfg.Configuration;
import net.sf.hibernate.SessionFactory;
import net.sf.hibernate.tool.hbm2ddl.SchemaExport;
import net.sf.hibernate.Session;
import net.sf.hibernate.Query;
import net.sf.hibernate.Hibernate;
import net.sf.hibernate.type.LongType;
import net.sf.hibernate.Transaction;



/**
 * @author getdown
 * @version 1.0
 */

public class Hello {
  public Hello() {
  }

  public static void main(String[] args) throws Exception {
    Configuration cfg = new Configuration().addClass(Message.class);

    /** 顾名思义 构建表。。。第一次运行的时候运行下面语句可以在数据库生成表
     * 之后可以把下面这句去掉
     * */
//    new SchemaExport(cfg).create(true, true);

    //先生成sessionFactory
    SessionFactory sessions = cfg.buildSessionFactory();
    //再从sessionFactory得到一个session
    Session session = sessions.openSession();
    //启动事务
   Transaction tx = session.beginTransaction();

    //开始对数据库的操作
    /*----对数据库的创建操作--------*/
    Message message = new Message("helloWorld");
    //创建一条记录

    session.save(message);
    //存入记录
   session.flush();
    //提交事务
    tx.commit();


    /*---对数据库的查询操作---------------*/
//    Message message = new Message();
//    Query q = session.createQuery("from Message as message where message.id=1");
//    message = (Message) q.list().get(0);
//    message.getNextMessage().setText("helloNext");
//    session.flush();
//    session.close();
//    Long id = new Long(1);
//    Message message = (Message) session.find("from Message as message where 
message.id=?", id, Hibernate.LONG).get(0);
//    System.out.println(message.getText());


//    /*-------事务的处理----------------*/
//    try {
//      Message message = new Message("hello");
//      session.save(message);
//      session.flush();
//      message = new Message("hello");
//      session.save(message);
//      session.flush();
//      tx.commit();
//    }
//    catch (HibernateException ex) {
//      tx.rollback();
//    }

    /*-------添加1000条记录时间--------------*/
//    long start = System.currentTimeMillis();
//    for(int i = 0; i < 1000; i ++) {
//      Message message = new Message("hello");
//      session.save(message);
//      session.flush();
//    }
//    tx.commit();
//    long end = System.currentTimeMillis();
//    System.out.println("添加1000条记录时间－－－" + (end-start)/1000 + "s");



    session.close();


  }

}

ok了 运行一下Hello看看出来什么吧

怎么样 比起CMP的持久 hibernate的持久是不是显得很轻量级。。

还可以试试看hibernate的性能 把Hello.java的最后一段注释去掉运行看看

当然hibernate最重要的还是它的原理，还有很多很好的，很有趣的功能和O/RM设计思想等着你自己发掘。

多看看它自己的文档，可以学到很多东西，它的文档真的非常好。