if (someCondition) {
 System.out.println("some information.");
}

package org.javaresearch.log4j;
import org.apache.log4j.*;
public class TestLog4J {
 static Logger log = Logger.getLogger(TestLog4J.class.getName());
 public static void main(String args[]) {
  BasicConfigurator.configure();
  // logging的各种方法
  cat.debug("Start of main()");
  cat.info("Just testing a log message with priority set to INFO");
  cat.warn("Just testing a log message with priority set to WARN");
  cat.error("Just testing a log message with priority set to ERROR");
  cat.fatal("Just testing a log message with priority set to FATAL");
  // 另一种不方便的格式
  cat.log(Priority.DEBUG, "Testing a log message use a alternate form");
  log.debug("End of main().");
 }
}

0 [main] DEBUG TestLog4J  - Start of main()
10 [main] INFO TestLog4J  - Just testing a log message with priority set to INFO
20 [main] WARN TestLog4J  - Just testing a log message with priority set to WARN
30 [main] ERROR TestLog4J  - Just testing a log message with priority set to ERROR
30 [main] FATAL TestLog4J  - Just testing a log message with priority set to FATAL
40 [main] DEBUG TestLog4J  - Testing a log message use a alternate form
50 [main] DEBUG TestLog4J  - End of main().

log4j.rootLogger=DEBUG, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern= "%-4r [%t] %-5p %c %x - %m%n

20 [main] WARN TestLog4J  - Just testing a log message with priority set to WARN
30 [main] ERROR TestLog4J  - Just testing a log message with priority set to ERROR
30 [main] FATAL TestLog4J  - Just testing a log message with priority set to FATAL

package org.apache.log4j;
public class Logger {
 //创建和恢复方法
 public static Logger getRootLogger();
 public static Logger getLogger(String name);
 public static Logger getLogger(Class clazz);
 // 打印方法
 public void debug(Object message);
 public void info(Object message);
 public void warn(Object message);
 public void error(Object message);
 public void fatal(Object message);
 // 常用打印方法
 public void log(Level l, Object message);
}

Logger logger = Logger.getLogger(JavaLoggingExample.class.getName());

static Logger root = Logger.getRootLogger();
static Logger log1 = Logger.getLogger("org");
static Logger log2 = Logger.getLogger("org.javaresearch");
static Logger log3 = Logger.getLogger("org.javaresearch.log4j.TestLog4J");

DEBUG  <  INFO  <  WARN  <  ERROR  <  FATAL

// 得到一个logger 实例 "com.foo"
Logger  logger = Logger.getLogger("com.foo")
// 现在设置logger的级别，但正常情况是不需要刻意设置lgger级别的，因为它已经在配置文件中完成了
logger.setLevel(Level.INFO);
Logger barlogger = Logger.getLogger("com.foo.Bar");
//因为 WARN >= INFO，这个请求是可以实现的
logger.warn("Low fuel level.");
// 因为DEBUG < INFO，所以这个请求是无法实现的
logger.debug("Starting search for nearest gas station.");
// logger实例"com.foo.Bar"将从"com.foo"继承级别，这样，因为INFO >= 
INFO，所以可以实现下面的请求
barlogger.info("Located nearest gas station.");
//因为DEBUG < INFO，这个请求是不能实现的 
barlogger.debug("Exiting gas station search");

性能

在记录一些日志信息时，会一定程度地影响系统的运行效率，这时日志工具是否高效就是一个关键。Log4J的首要设计目标就是高效，一些关键组件都重写过很多次以不断提高性能。根据Log4J项目小组的报告，在AMD Duron 800MHz ＋ JDK1.3.1的环境下，Log4J判断一条日志语句是否需要输出仅需要5纳秒。实际的日志语句执行的也非常快速，从使用SimpleLayout的21微秒（几乎与System.out.println一样快），到使用TTCCLayout的37微秒不等。

嵌套诊断环境NDC

在多用户并发的环境下，通常是由不同的线程分别处理不同的客户端请求。此时要在日志信息中区分出不同的客户端，你可以为每一个线程生成一个Logger，从而从一堆日志信息中区分出哪些信息是属于哪个线程的，但这种方式并不高效。Log4J巧妙地使用了Neil Harrison提出的“NDC（嵌套诊断环境）”机制来解决这个问题。Log4J为同一类别的线程生成一个Logger，多个线程共享使用，而它仅在日志信息中添加能够区分不同线程的信息。NDC是什么？举例来说，如果一个Servlet接到并发请求时，为每一个客户端创建一个新的线程，然后分配一个用于保存该请求上下文的NDC堆栈。该上下文可能是发出请求的主机名、IP地址或其它任何可以用于标识该请求的信息。这样，由于不同的客户端处理线程具有不同的NDC堆栈，即使这个Servlet同时生成多个线程处理不同的请求，这些日志信息仍然可以区分出来，就好像Log4J为每一个线程都单独生成了一个Logger实例一样。在Log4J中是通过org.apache.log4j.NDC实现这种机制的。使用NDC的方法也很简单，步骤如下：

1. 在进入一个环境时调用NDC.push(String)，然后创建一个NDC；

2. 所做的日志操作输出中包括了NDC的信息；

3. 离开该环境时调用NDC.pop方法；

4. 当从一个线程中退出时调用NDC.remove方法，以便释放资源。

下面是一个模拟记录来自不同客户端请求事件的例子，代码如下：

import org.apache.log4j.Logger; import org.apache.log4j.NDC; public class TestNDC { static Logger log = Logger.getLogger(TestNDC.class.getName()); public static void main(String[] args) { log.info("Make sure %x is in your layout pattern!"); // 从客户端获得IP地址的例子 String[] ips = {"192.168.0.10","192.168.0.27"}; for (int i = 0; i<ips.length ; i++) // 模拟一个运行方法 { // 将IP放进 NDC中 NDC.push(ips[i]); log.info("A NEW client connected, who's ip should appear in this log message."); NDC.pop(); } NDC.remove(); log.info("Finished."); } }

注意配置文件中的布局格式中一定要加上%x。系统输出如下：

INFO - Make sure %x is in your layout pattern! INFO 192.168.0.10 - A NEW client connected, who's ip should appear in this log message. INFO 192.168.0.27 - A NEW client connected, who's ip should appear in this log message. INFO - Finished.

使用Log4J还是JDK logging API

从JDK 1.4.0开始，引入了java.util.logging包。虽然Log4J小组曾竭力游说JCP（Java Community Process）采用Log4J作为JDK 1.4的“标准”日志API，虽然最终因Sun的日志API规范的负责人Graham Hamilton的一句“Merlin的开发已经到了最后阶段，这时不允许再对主要API做出改变”而没有被采纳，但Log4J还是对新的日志API产生了重要影响。那么，我们到底应该采用Log4J还是java.util.logging包呢？下面仅对两者做一简单的比较。

1. Log4J更加成熟，从1999年10月开始至今已经有3年的时间，并且已经在许多项目中有着成熟的应用。而JDK中的logging包是在1.4之后才引入的，并且不能运行于JDK 1.3之前的版本。Log4J则可以良好地运行于JDK 1.1之后的所有版本。

2. Log4J已经被移植到多种环境下，包括log4c（C）、log4cpp（C++）、log4perl（Perl）、log4net（.net）等。在这些环境下，可以感受到几乎一致的配置和使用方式。这是JDK中的logging API所不能比拟的。

3. Log4J还具有更加强力的格式化系统，可以使记录输出时实现简单的模式。但是，它不会增加类而导致格式化工具的扩展。众多的附加程序和处理器使得Log4J数据包成为一个绝佳的选择，所有你所需要的都可能加以实现。

4. Log4J在性能上做了最大的优化。

Logging API对于简单的使用是足够的，但它缺少了许多Log4J所具有的功能。所以，如果你需要一个强力的logging机制，就应坚持使用Log4J；而如果只是需要一些简单的控制或文件记录，那么可以使用已经内建在JDK之中的logging API。

虽然Log4J和JDK logging API是一种竞争关系，但在logging API还在JCP中讨论（JSR47）时，两者之间就已经开始相互影响了。

FAQ

1. 如何让Log4J使用指定的配置文件

在启动你的应用时植入系统属性。例如，可以把上面的log4j.properties文件放到\properties的相对路径下，并改名为log.properties，此时如果让Log4J能够找到这个配置文件并正确地初始化，需要这样运行程序：

D:\..\java -Dlog4j.configuration=. \properties\log.properties YourAppName

为什么一定要使用系统属性，而不在配置文件中指定呢？很显然，如果把它写入配置文件，那么，Log4J读到它时已经迟了。

2. 如何查看到Log4J的配置过程

可以类似1中的那样，设置系统属性log4j.debug=true，从而打开Log4J的Verbose模式，此时会输出Log4J的初始化过程，这样就会对Log4J的启动有一个更详细的了解。下面是Log4J启动信息的一个示例：

log4j: Trying to find [log4j.xml] using context classloader sun.misc.Launcher$AppClassLoader@92e78c. log4j: Trying to find [log4j.xml] using sun.misc.Launcher$ExtClassLoader@9fbe93class loader. log4j: Trying to find [log4j.xml] using ClassLoader.getSystemResource(). log4j: Trying to find [log4j.properties] using context classloader sun.misc.Launcher$AppClassLoader@92e78c. log4j: Using URL [file:/D:/java/logging/src/log4j.properties] for automatic log4j configuration. log4j: Reading configuration from URL file:/E:/java/logging/src/log4j.properties log4j: Parsing for [root] with value=[DEBUG, A1]. log4j: Level token is [DEBUG]. log4j: Category root set to DEBUG log4j: Parsing appender named "A1". log4j: Parsing layout options for "A1". log4j: Setting property [conversionPattern] to [%d %l %-5p %c [%t] - %m%n]. log4j: End of parsing for "A1". log4j: Parsed "A1" options. log4j: Finished configuring. ...... // 下面就是应用的日志信息，省略。

主流版本控制工具介绍
    现在，有很多优秀的版本控制工具供我们选择，下面就五种主流的版本控制工具做简单的介绍。
Starteam
    是一个集合了版本控制、构建管理（Build Management）和缺陷跟踪系统为一体的软件，并且具有强大的图形界面，易学易用；但管理复杂、维护困难。2002年底被Borland公司收购。
PVCS Version Manager
     是美国的MERANT公司软件配置管理工具PVCS 家族中的一个组成部分，它能够实现源代码、可执行文件、应用文件、图形文件和文档的版本管理；它能安全地支持软件并行开发，对多个软件版本的变更进行有效的控制管理。
ClearCase(CC)
    是ROSE构件的一部分，目前最牛的配置管理工具，主要应用于复杂的产品发放、分布式团队合作、并行的开发和维护任务。可以控制word, excel,powerpoint，visio等文件格式，对于不认识的格式可以自己定义一种类型来标识。
Visual SourceSafe（VSS）
    简单易用、方便高效、与Windows操作系统及微软开发工具高度集成。
CVS（Concurrent Versions System）
    是开发源码的并发版本系统,它是目前最流行的面向软件开发人员的源代码版本管理解决方案。它可用于各种平台，包括 Linux 、Unix和 Windows NT/2000/XP等等。
    前面三种是重量级的商业版本控制工具，更适合庞大的团队和项目，并且价格不菲。Visual SourceSafe是微软的产品，当然只能用在windows平台并与微软的开发工具无缝集成。CVS免费开源，并且几乎所有开源项目都是使用CVS进行版本管理，无疑，它是我们Java开发者最优选择。

CVS的历史、功能、基本概念的介绍

历史
    CVS 诞生于 1986 年，当时作为一组 shell 脚本而出现；1989年3月，Brian Berlinor用C语言重新设计并编写了CVS的代码；1993年前后，Jim Kingdon最终将CVS设计成基于网络的平台，开发者们能从Internet任何地方获得程序源代码。截至目前最新版本是2004年12月13日发布的1.12.11。

功能介绍
一、 代码统一管理，保存所有代码文件更改的历史记录。对代码进行集中统一管理，可以方便查看新增或删除的文件，能够跟踪所有代码改动痕迹。可以随意恢复到以前任意一个历史版本。并避免了因为版本不同引入的深层BUG。
二、 完善的冲突解决方案，可以方便的解决文件冲突问题，而不需要借助其它的文件比较工具和手工的粘贴复制。
三、 代码权限的管理。可以为不同的用户设置不同的权限。可以设置访问用户的密码、只读、修改等权限，而且通过CVS ROOT目录下的脚本，提供了相应功能扩充的接口，不但可以完成精细的权限控制，还能完成更加个性化的功能。
四、 支持方便的版本发布和分支功能。

基本概念
资源库（Repository）
CVS的资源库存储全部的版本控制下的文件copy，通常不容许直接访问，只能通过cvs命令，获得一份本地copy，改动后再check in（commit）回资源库。而资源库通常为与工作目录分离的。CVS通过多种方式访问资源库。每种方法有不同目录表示形式。
版本（Revision）
每一个文件的各个版本都不相同，形如1.1, 1.2.1,一般1.1是该文件的第一个revision，后面的一个将自动增加最右面的一个整数，比如1.2, 1.3, 1.4...有时候会出现1.3.2.2，原因见后。revision总是偶数个数字。一般情况下将revision看作时CVS自己内部的一个编号，而tag则可以标志用户的特定信息。
标签（Tag）
用符号化的表示方法标志文件特定revision的信息。通常不需要对某一个孤立的文件作tag，而是对所有文件同时作一个tag，以后用户可以仅向特定tag的文件提交或者checkout。另外一个作用是在发布软件的时候表示哪些文件及其哪个版本是可用的；各文件不同revision可以包括在一个tag中。如果命名一个已存在的tag默认将不会覆盖原来的；
分支（Branch）
当用户修改一个branch时不会对另外的branch产生任何影响。可以在适当的时候通过合并的方法将两个版本合起来；branch总是在当前revision后面加上一个偶数整数（从2开始，到0结束），所以branch总是奇数个数字，比如1.2后面branch为1.2.2，该分支下revision可能为1.2.2.1,1.2.2.2,...
冲突（Conflct）
完全是纯文本的冲突，不包含逻辑上的矛盾。一般是一份文件，A做了改动，B在A提交之前也做了改动，这样最后谁commit就会出现冲突，需要手工解决冲突再提交。

CVS与eclipse集成开发
  前面对CVS的历史、功能、概论等理论知识做了介绍。下面我们将使用最流行的Java IDE Eclipse中内置的CVS工具，以一个完整开发流程，介绍实际环境中CVS的正确使用。关于CVS系统的安装，不是本文的内容，您可以从附录的链接中获取安装的介绍资料。

常用的CVS控制命令
Check Out（检出）
把源文件从cvs源代码仓库中取出，缺省的版本是最新的版本，你也可以选择指定的版本。在每次更改源代码之前，需要Check Out最新的版本，再起基础之上对源代码进行修改。将代码目录checkout到指定目录下，所有文件都是read-write。
Check In（检入）
把源代码加入到cvs源代码仓库中，每一个添加进代码库中的文件的版本是 1.1。以后每次修改文件重新ci以后，此文件的版本递增为1.2 ，1.3.……。在每次对源代码修改之后，需要Check In，提交最新版本的源代码。
Synchronize with Repository(与资源库同步，简称同步)
使本地更改与资源库同步，它会列出本地和资源库之间不同的所有文件。
Add to Version Control
将新的文件加入到版本控制之中。
Add to .cvsIgnore
将文件设置到版本控制之外，这样该文件或目录中的文件的更改在CVS中不可见，即使同步也无法发现。

CVS正确使用步骤
一、 同步（Synchronize）
就是将本地更改与服务器同步，同步之后可以清晰的看到上一捡出（Check Out）版本之后本地、服务器上的最新改动。这是非常有用的，特别是敏捷开发，强调集体拥有代码。有了同步功能，你可以全局把握项目的代码，可以很方便的跟踪公共模块代码的任何改动。
具体操作：在Eclipse的资源视图（Resource Perspective）或者Java视图（Java Perspective）中，选中要同步的目录，点击右键选择"Synchronize with Repository",之后它将显示同步的视图。如下图：
 
(图一、CVS同步视图)
同步之后，它有四种Mode可以选择，见上图绿色框框里按钮。从做到右分别为：
Incoming Mode：表示修改是来自服务器，对应于更新（update）操作。
Outgoing Mode：表示修改是来自本地，对应提交（commit）操作。
Incoming/ Outgoing Mode：本地和服务器修改都在该模式（Mode）中显示。
Conflicts Mode：显示本地和服务器修改的冲突文件。
二、 更新（update）
比较简单，选择Incoming Mode，再选中要更新的文件，右键选择update操作。
三、 解决冲突并合并(solve conflct and merge)
如果有冲突文件，冲突文件不能更新。你必须先解决冲突再操作。选中冲突的文件，再点右键选择"Open in Compare Editor"，用比较工具打开该文件。如下图：

（图二、CVS比较器视图）

比较器（Compare）视图，左边版本底的是本地文件（Local File），右边是远程服务器文件（Remote File）。使用"Select Next Change"按钮（绿框中的第一箭头向下按钮），逐一查看不同点。如果不同点标识为黑色框框，则不用管它。如果是蓝色框框，则需要手工调整。如上图，不同点是蓝色框框，将鼠标放到两个不同点的中间小方框中，则凸出一个向右的按钮，并显示提示信息"Copy Current Change from Right to Left"，意思是将右边服务器的不同点覆盖到左边的本地文件。点中此按钮。重复这样的操作，将所有服务器上的更改拷贝到本地。
如果有一行代码，本地和服务器都同时做了修改。这时，修改点则显示红色框框。这时，你就必须手工做正确的修改。全部修改完成，保存本地文件。
此时，如果修改点没有了蓝色的框框，就可以开始做合并（merge）操作了。操作也很简单，选择该文件，点击右键，选择"Mark as merged"。
注意：必须确保没有蓝色框框，即完全拷贝了服务器的修改才可以做合并（merge）操作，否则会覆盖服务器上的代码。
四、 提交（commit）
更新服务器代码，解决冲突之后，首先要查看本地文件修改之后是否有错误。如果有，当然首先解决错误，再提交。

附录：
http://www.8848software.com/scmchina/scmtools.htm 由很多版本控制工具的文档链接。
http://www.perforce.com/perforce/reviews.html Infrastructure Group对Perforce 和Clearcase, CVS, PVCS,Visual SourceSafe (VSS)几种CM工具进行了定量和定性的比较. 对于定性的比较，内容涉及工具支持的方法和环境；对于定量的比较，包括在不同的项目规模上，执行不同的活动所需要的时间。

---------------------------

讨论摘录：

单就功能来说，Subversion 比起 CVS 还是要多了一些东西的，有些还是不错的；至于“市场”，还是要看需求，现在已经有一些开元软件在使用 Subversion 了。

觉得 WinCVS 不好用的，可以试试 TortoiseCVS，这是一个完全与资源管理器集成的 CVS 工具，比较符合 Windows 使用者的思路，很容易上手；主页是 http://tortoisecvs.sourceforge.net。

对于 Subversion，也有相似的工具 TortoiseSVN，使用方法几乎完全相同，主页是http://tortoisesvn.tigris.org。

同样，网站上也提供了其他关于软件配置管理工具的部分学习资料下载：
参考：http://www.askguoyu.com

    在 iBATIS SQL Maps 的世界里也存在 one-to-many、many-to-one 的关系，想必你已经对这些概念驾轻就熟了。好！还是每个 People 对应多条 AutoInfo 信息。

    本系列文章第一部分提到过 iBATIS SQL Maps 的映射文件个数可以人为设定，但是，把一组有共性的操作放在一起是首选策略。下面我们看看为张三首次买车所生成的映射文件是怎样的：

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE sqlMap     PUBLIC "-//iBATIS.com//DTD SQL Map 2.0//EN"     "http://www.ibatis.com/dtd/sql-map-2.dtd"> <sqlMap namespace="AutoMag">   <insert id="insertPeople" parameterClass="bo.People">     <![CDATA[       insert into people (name, address) values (#name#, #address#)     ]]>       <selectKey resultClass="java.lang.Integer" keyProperty="id">     <![CDATA[           select last_insert_id();     ]]>       </selectKey>   </insert>     <insert id="insertAutoInfo" parameterClass="bo.AutoInfo">     <![CDATA[       insert into auto_info (license_plate, owner_no) VALUES (#licensePlate#, #ownerNo.id#)     ]]>   </insert> </sqlMap>

 

sqlMap

sqlMap 元素拥有属性 namespace="…"，定义了该 XML 文件命名空间。如果你在配置文件 SqlMapConfig.xml 中指定了 settings 元素的属性 useStatementNamespaces="true"，那么就可以按照命名空间的方式访问 Mapped statement，比如 namespace=" AutoMag"，相应 Java 代码：sqlMap.insert("AutoMag.insertPeople",people)。这样做是为了防止不同映射文件中出现同名 Mapped statement 而产生冲突。什么是 Mapped statement ？

Mapped statement

iBATIS SQL Maps 的核心概念就是 Mapped statement！Mapped Statement 可以使用任意的 SQL 语句，利用 POJO、原始变量及其 Wrapper Class 作为输入（parameter class）和输出（result class）。

Mapped Statement 包含以下几种类型：

insert 对应数据库的 insert 操作，该操作返回本次操作插入记录的主键值。

select 对应数据库的 select 操作，该操作返回特定的 POJO 或 对象。

update 对应数据库的 update 操作，该操作返回被更新的记录个数。

delete 对应数据库的 delete 操作，该操作返回被删除的记录个数。

procedure 对应数据库存储过程。

statement 类型最为通用，可以代替以上所有的类型。但由于缺乏操作直观性故不推荐。

insert id="insertPeople" parameterClass="bo.People"

定义了 insert 类型的 Mapped Statement。属性 id="insertPeople" 定义操作名称，parameterClass="bo.People" 定义传入参数为 People 对象实例，框架可确保其属性持久化到数据库相应字段中。由于 SQL 语句会包含“<>”这样的符号，容易和 XML 产生冲突，放进 <![CDATA[……]]> 区域就可避免。insert into people (name, address) values (#name#, #address#)，是一条普通的 SQL 语句，“#name#、#address#”利用 Java 反射机制访问 People 对象实例的相应属性。

selectKey resultClass="java.lang.Integer" keyProperty="id"

iBATIS SQL Maps 通过 <insert> 元素的子元素 < selectKey> 来支持主键自动生成。 resultClass="java.lang.Integer" 定义返回对象为 int 的 Wrapper Class。keyProperty="id" 定义了主键名称。本例是 MySQL 主键生成方式，参考官方文档，MySQL 的主键生成无需人为来控制，也就是说可不使用 <selectKey> 而由数据库自动处理。但我测试发现，在执行 insert 操作以后，程序没有返回本次操作插入记录的主键值。在官方论坛上也有很多用户提出这样的疑惑，作者的答复是：这和 JDBC Driver 有关系。不可能把驱动一一测试吧？一劳永逸的办法是使用 <selectKey> 元素。以下是 Oracle 和 SQL Server 主键生成方法：

< !- Oracle -> <insert id="insertProduct-ORACLE" parameterClass="com.domain.Product">   <selectKey resultClass="int" keyProperty="id" >     SELECT STOCKIDSEQUENCE.NEXTVAL AS ID FROM DUAL   </selectKey>   insert into PRODUCT (PRD_ID,PRD_DESCRIPTION) values (#id#,#description#) </insert> <!- Microsoft SQL Server -> <insert id="insertProduct-MS-SQL" parameterClass="com.domain.Product">   insert into PRODUCT (PRD_DESCRIPTION) values (#description#)   <selectKey resultClass="int" keyProperty="id" >   SELECT @@IDENTITY AS ID   </selectKey> </insert>

 

insert into auto_info (license_plate, owner_no) VALUES (#licensePlate#, #ownerNo.id#)

在插入了 people 记录后，要为 auto_info 插入记录。基本原则和之前遇到过的一样，只是”owner_no”这个字段值由 AutoInfo 对象属性”ownerNo”获得，该属性类型为 People。这是由于我沿用了 Hibernate 产生的 POJO，如果你愿意，完全可以把”ownerNo”替换为 Integer 类型。

编程中几个关键对象

    com.ibatis.common.resources.Resources 对象负责从 XML 得到 java.io.Reader 抽象类的实例，供工厂方法调用。

com.ibatis.sqlmap.client.SqlMapClientBuilder 构造 SqlMapClient 实例。

    com.ibatis.sqlmap.client.SqlMapClient 是 iBATIS SQL Maps 核心组件，可以说我们的编程工作都是围绕着它展开。

形成的 one-to-many 保存如下：

package test; import java.io.Reader; import com.ibatis.sqlmap.client.*; import com.ibatis.common.resources.*; import bo.*; public class AutoMag {  private Reader reader;  private SqlMapClient sqlMap;  private String resource = "SqlMapConfig.xml";    public void insertPeople() throws Exception{   try{    reader = Resources.getResourceAsReader(resource);       sqlMap=SqlMapClientBuilder.buildSqlMapClient(reader);       sqlMap.startTransaction();             People people=new People();       people.setName("张三");       people.setAddress("中国");             sqlMap.insert("insertPeople",people);             AutoInfo autoInfo=new AutoInfo();             autoInfo.setLicensePlate("A00001");             autoInfo.setOwnerNo(people);                  sqlMap.insert("insertAutoInfo",autoInfo);             sqlMap.commitTransaction();   }finally{    sqlMap.endTransaction();   }  } }

 

程序和 Hibernate 写法差不多，我感觉甚至比 Hibernate 更简单。我可以显示的进行 insert 操作，符合传统 JDBC 编程习惯。iBATIS SQL Maps 支持自动事务处理，可以不用写明 startTransaction、commitTransaction。但如果 People insert 操作成功，而 AutoInfo insert 操作失败，就破坏了两次 insert 操作的原子性。最后 endTransaction 包含异常情况下的回滚事务和关闭连接池连接两种功能。


（请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://blog.csdn.net/rosen）

前段时间写了些 Hibernate 方面的系列文章，网友们反映还不错。在接下来的时间里，我将会引入另外一种 O/R Mapping 解决方案——iBATIS，本系列将沿用 Hibernate 系列文章的风格。

什么是 iBATIS ？

    和众多的 SourceForge 开源项目一样，iBATIS 曾经也是其中的一员。在2004年11月3日成功地成为了 Apache Incubator 下的子项目。 iBATIS 包括 for Java 和 for .NET 两个版本，for Java 版提供了SQL Maps 和 DAO 框架，for .NET 只提供了 SQL Maps 框架。从现在开始我们只对 for Java 版的SQL Maps 展开讨论。

你可以在 http://www.ibatis.com 下载 iBATIS for Java，目前最新版本是2.0.9，压缩包里已经包含了 SQL Maps(ibatis-sqlmap-2.jar) 和 DAO 框架(ibatis-dao-2.jar)。

为什么选择 iBATIS ？

    也许各位看官已在各种不同的技术资料上了解到它的优势。但是对于我来说，选择它的理由只有一个——“利用原有资源”。Hibernate 的却优秀，但是用来整合原有系统，它却很难胜任。例如，以前在进行数据建模时使用了复合主键、跨越多表产生的几十甚至上百行的查询语句、利用原有存储过程… … 当面临这一系列问题时 Hibernate 就显得力不从心了，要想使用 Hibernate就只能改造原有系统！

当我面临系统整合问题时（整合的要求很简单：只需要保留原有系统查询部分），iBATIS 进入了我的视线。原有系统中除 SQL语句需要小小的修改外，数据表、查询结果都不需要改变！也不用像 Hibernate 那样映射出众多的配置文件、POJO，一下子清爽了很多。BTW：Hibernate 这种做法没有错！只是我只需要查询功能，仅仅是取我所好而已，避免了杀鸡用牛刀。

目前，系统整合已经结束，花了一个月时间。如果使用 Hibernate，恐怕我现在还在为怎么设计数据表、怎样下HQL而和同事争论。

开始另一次 O/R Mapping 之旅

    上次 O/R Mapping 之旅的 BO、数据表还可以重用，只是把数据库迁移到了 MySQL。打开 Eclipse，新建一个 Resin 项目。把 ibatis-sqlmap-2.jar 和 ibatis-common-2.jar 拷贝到 lib 目录下，再导入项目。和 Hibernate 自动配置、自动映射相比，iBATIS 的一切都是手工完成的。

    在 src 下建立配置文件 SqlMapConfig.xml，数据库链接、连接池、SqlMap 映射文件… … 这些都要靠它了。官方参考手册对怎样进行设置有很详细的描述，我只对要用到的地方进行粗略说明。

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE sqlMapConfig     PUBLIC "-//iBATIS.com//DTD SQL Map Config 2.0//EN"     "http://www.ibatis.com/dtd/sql-map-config-2.dtd"> <sqlMapConfig>   <settings     cacheModelsEnabled="true"     enhancementEnabled="true"     lazyLoadingEnabled="true"     errorTracingEnabled="false"     maxRequests="32"     maxSessions="10"     maxTransactions="5"     useStatementNamespaces="false"     />   <transactionManager type="JDBC">     <dataSource type="SIMPLE">       <property name="JDBC.Driver" value="org.gjt.mm.mysql.Driver"/>       <property name="JDBC.ConnectionURL" value="jdbc:mysql://localhost/new_db?useUnicode=true"/>       <property name="JDBC.Username" value="root"/>       <property name="JDBC.Password" value=""/>       <property name="JDBC.DefaultAutoCommit" value="true"/>       <property name="Pool.MaximumActiveConnections" value="10"/>       <property name="Pool.MaximumIdleConnections" value="5"/>       <property name="Pool.MaximumCheckoutTime" value="120000"/>       <property name="Pool.TimeToWait" value="500"/>       <property name="Pool.PingQuery" value="select 1 from ACCOUNT"/>       <property name="Pool.PingEnabled" value="false"/>       <property name="Pool.PingConnectionsOlderThan" value="1"/>       <property name="Pool.PingConnectionsNotUsedFor" value="1"/>       <property name="Pool.QuietMode" value="true"/>     </dataSource>   </transactionManager>   <sqlMap resource="bo/mapping/AutoMag.xml"/> </sqlMapConfig>

transactionManager 元素定义了 iBATIS 事务管理器。type 可选项包括： 

JDBC：通过传统 JDBC 来管理事务。

JTA：使用一个 JTA 全局事务，使 iBATIS 的事务包括在更大的事务范围内（跨数据库Session的），这个更大的事务范围可能包括了其他的数据库和事务资源。这个配置需要一个 UserTransaction 属性，以便从 JNDI 获得一个 UserTransaction。 

EXTERNAL：调用 iBATIS 以外的其他事务管理器来管理事务。

dataSource 元素是 transactionManager 的一部分。type 可选项包括：

    SIMPLE：SIMPLE 是 iBATIS 内置的 dataSource 实现，其中实现了一个简单的数据库连接池，当无容器提供 DataSource 服务时可以使用该选项，对应 iBATIS 实现类为com.ibatis.sqlmap.engine.datasource.SimpleDataSourceFactory。

?    DBCP:基于 Apache DBCP 连接池 API 实现的 DataSource，当无容器提供 DataSource 服务时，可以使用该选项，对应 iBATIS 实现类为 com.ibatis.sqlmap.engine.datasource.DbcpDataSourceFactory。

?JNDI：使用 J2EE 容器提供的 DataSource 实现，DataSource 将通过指定的 JNDI Name 从容器中获取。对应 iBATIS 实现类为 com.ibatis.sqlmap.engine.datasource.JndiDataSourceFactory。

    注意！每种 dataSource 元素的 property 都有不同的地方，不能光把 type 名字改了了事。

sqlMap 元素定义了映射文件的存放位置，配置文件中可包含多个 sqlMap 元素，比如：

<sqlMap resource="mapping/AutoMag1.xml"/> <sqlMap resource="bo/mapping/AutoMag2.xml"/> <sqlMap url="file:///c:/eclipse/workspace/iBATISTest/src/bo/ AutoMag2.xml "/> … …

你也许已发现，我只定义了单个映射文件。不错，和 Hibernate 的一个表一个映射文件不同，iBATIS 的映射文件个数可以人为控制，颗粒度自己掌握。

    光有 BO 和配置文件还不行，还要为本次测试创建测试类 AutoMag.java。完整的布局如下所示：

                                        

    以下为 iBATIS SQL Maps 工作流程，对于理解概念很有帮助。大意是 1、你可以把 JavaBean、Map 类型、原始变量（或者它们的Wrapper Class）、XML 数据作为传入对象；2、通过配置文件载入映射文件；3、利用框架翻译成 JDBC 来访问数据库；4、执行结果可以是 JavaBean、Map 类型、原始变量（或者它们的Wrapper Class）、XML 数据。
                       
       

（请注意！引用、转贴本文应注明原作者：Rosen Jiang 以及出处：http://blog.csdn.net/rosen）