Each of the following statements (and any synonyms for them) implicitly end a transaction, as if you had done a COMMIT before executing the statement:

• ALTER TABLE, BEGIN, CREATE INDEX, DROP INDEX, DROP TABLE, LOAD MASTER DATA, LOCK TABLES, LOAD DATA INFILE, RENAME TABLE, SET AUTOCOMMIT=1 (if the value is not already 1), START TRANSACTION, UNLOCK TABLES.

  The BEGIN statement differs from the use of the BEGIN keyword that starts a BEGIN ... END compound statement. The latter does not cause an implicit commit. See Section 21.2.7, “BEGIN ... END Compound Statement Syntax”.

• Beginning with MySQL 5.0.8, CREATE TABLE, CREATE DATABASE DROP DATABASE, and TRUNCATE TABLE cause an implicit commit.

  Beginning with MySQL 5.0.13, ALTER FUNCTION, ALTER PROCEDURE, CREATE FUNCTION, CREATE PROCEDURE, DROP FUNCTION, and DROP PROCEDURE cause an implicit commit.

  Beginning with MySQL 5.0.15, ALTER VIEW, CREATE TRIGGER, CREATE USER, CREATE VIEW, DROP TRIGGER, DROP USER, DROP VIEW, and RENAME USER cause an implicit commit.

• UNLOCK TABLES commits a transaction only if any tables currently have been locked with LOCK TABLES. This does not occur for UNLOCK TABLES following FLUSH TABLES WITH READ LOCK because the latter statement does not acquire table-level locks.

• The CREATE TABLE statement in InnoDB is processed as a single transaction. This means that a ROLLBACK from the user does not undo CREATE TABLE statements the user made during that transaction.

• CREATE TABLE and DROP TABLE do not commit a transaction if the TEMPORARY keyword is used. (This does not apply to other operations on temporary tables such as CREATE INDEX, which do cause a commit.) However, although no implicit commit occurs, neither can the statement be rolled back. Therefore, use of such statements will violate transaction atomicity: For example, if you use CREATE TEMPORARY TABLE and then roll back the transaction, the table remains in existence.

• In MySQL 5.0.25 and earlier, LOAD DATA INFILE caused an implicit commit for all storage engines. Beginning with MySQL 5.0.26, it causes an implicit commit only for tables using the NDB storage engine. For more information, see Bug#11151.

Transactions cannot be nested. This is a consequence of the implicit COMMIT performed for any current transaction when you issue a START TRANSACTION statement or one of its synonyms.

Statements that cause an implicit commit cannot be used in an XA transaction while the transaction is in an ACTIVE state.

关键字: ajax post 中文 乱码

在使用jsp开始时，一不小心就会出现中文乱码的情况。通常可以使用如下方法解决：
第一种解决方法：
从jsp到servlet统一使用utf-8编码.全部使用utf-8编码能省去很多麻烦，但一点不足是utf-8编码对汉字是使用3-4个字节，会加大网络传输量。
第二种方法：
1.jsp页面使用GBK
2.使用servlet过滤器设置request.setCharacterEncoding("GBK");google一下就能找到很多怎么使用过滤器转换编码。
以上两种方法能解决大部分的乱码问题，特别是第一种方法，能解决使用ajax提交时的中文乱码问题。如果采用第二种方法，那么在使用ajax提交表单时仍然会有中文乱码。这是因为ajax方式提交时js使用的是utf-8的编码，过滤器使用gbk进行转码就不正确了，应该使用utf-8进行转码。要解决这个问题，网上也有很多个版本，其中一个是我曾经采用的在客户端使用encodeURI，然后再在服务器端进行URLDecoder.decode，这种方案在偶尔处理一下中文是可行的，但是如果页面有大量数据录入，那么这种方案是不可行的。有没有好的解决方法呢？在经过新一轮的google之后，还是找到了方法。参考http://www.javaeye.com/topic/157698?page=1。原理就是根据httpheader中的内容来区分是ajax方式请求还是普通的请求。在jquery1.2.6中，ajaxSettings默认设置contentType为"application/x-www-form-urlencoded"，在ajax方法中设置xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");，我们只要在servlet中根据这两个参数值来判断是不是通过xmlhttprequest发起的请求。这里值得一提的是jquery在提交form时对参数进行了encodeURIComponent调用，参见param方法

Java代码

1. jQuery.each( a, function(){   
2.                 s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );   
3.             }); 

jQuery.each( a, function(){
				s.push( encodeURIComponent(this.name) + "=" + encodeURIComponent( this.value ) );
			});

Java代码

1. package com.ajax.demo.action;   
3. import java.io.IOException;   
5. import javax.servlet.Filter;   
6. import javax.servlet.FilterChain;   
7. import javax.servlet.FilterConfig;   
8. import javax.servlet.ServletException;   
9. import javax.servlet.ServletRequest;   
10. import javax.servlet.ServletResponse;   
11. import javax.servlet.http.HttpServletRequest;   
12. import javax.servlet.http.HttpServletResponse;   
14. public class AjaxPostFilter implements Filter {   
16. private static final String IE_CONTENT_TYPE = "application/x-www-form-urlencoded";   
17. private static final String FF_AJAX_CONTENT_TYPE = "application/x-www-form-urlencoded; charset=UTF-8";   
18. private static final String XMLHTTP_REQUEST = "XMLHttpRequest";   
19. private static final String AJAX_CHARACTER_ENCODING_UTF8 = "UTF-8";   
21. public void destroy() {   
22. // TODO Auto-generated method stub
24.     }   
26. public void doFilter(ServletRequest servletRequest,   
27.             ServletResponse servletResponse, FilterChain filterChain)   
28. throws IOException, ServletException {   
29.         HttpServletRequest request = (HttpServletRequest) servletRequest;   
30.         HttpServletResponse response = (HttpServletResponse) servletResponse;   
31.         String requestedWith = request.getHeader("x-requested-with");   
32.         String type = request.getContentType();   
33. if (XMLHTTP_REQUEST.equals(requestedWith)&& (FF_AJAX_CONTENT_TYPE.equals(type)   
34.                 ||IE_CONTENT_TYPE.equals(type))) {   
35.             request.setCharacterEncoding(AJAX_CHARACTER_ENCODING_UTF8);   
36.             response.setCharacterEncoding(AJAX_CHARACTER_ENCODING_UTF8);   
37. //          request.getParameterMap();
38.         }   
39.         filterChain.doFilter(request, response);   
41.     }   
43. public void init(FilterConfig arg0) throws ServletException {   
44. // TODO Auto-generated method stub
46.     }   
48. } 

package com.ajax.demo.action;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AjaxPostFilter implements Filter {

	private static final String IE_CONTENT_TYPE = "application/x-www-form-urlencoded";
	private static final String FF_AJAX_CONTENT_TYPE = "application/x-www-form-urlencoded; charset=UTF-8";
	private static final String XMLHTTP_REQUEST = "XMLHttpRequest";
	private static final String AJAX_CHARACTER_ENCODING_UTF8 = "UTF-8";

	public void destroy() {
		// TODO Auto-generated method stub

	}

	public void doFilter(ServletRequest servletRequest,
			ServletResponse servletResponse, FilterChain filterChain)
			throws IOException, ServletException {
		HttpServletRequest request = (HttpServletRequest) servletRequest;
		HttpServletResponse response = (HttpServletResponse) servletResponse;
		String requestedWith = request.getHeader("x-requested-with");
		String type = request.getContentType();
		if (XMLHTTP_REQUEST.equals(requestedWith)&& (FF_AJAX_CONTENT_TYPE.equals(type)
				||IE_CONTENT_TYPE.equals(type))) {
			request.setCharacterEncoding(AJAX_CHARACTER_ENCODING_UTF8);
			response.setCharacterEncoding(AJAX_CHARACTER_ENCODING_UTF8);
//			request.getParameterMap();
		}
		filterChain.doFilter(request, response);

	}

	public void init(FilterConfig arg0) throws ServletException {
		// TODO Auto-generated method stub

	}

}

Java代码

1. <filter>   
2.         <filter-name>ajaxEncodeFilter</filter-name>   
3.         <filter-class>com.ajax.demo.action.AjaxPostFilter</filter-class>   
4.     </filter>   
5.     <filter-mapping>   
6.         <filter-name>ajaxEncodeFilter</filter-name>   
7.         <url-pattern>*.do</url-pattern>   
8.     </filter-mapping>   
9.     <filter-mapping>   
10.         <filter-name>ajaxEncodeFilter</filter-name>   
11.         <url-pattern>*.jsp</url-pattern>   
12.     </filter-mapping> 

<filter>
		<filter-name>ajaxEncodeFilter</filter-name>
		<filter-class>com.ajax.demo.action.AjaxPostFilter</filter-class>
	</filter>
	<filter-mapping>
		<filter-name>ajaxEncodeFilter</filter-name>
		<url-pattern>*.do</url-pattern>
	</filter-mapping>
	<filter-mapping>
		<filter-name>ajaxEncodeFilter</filter-name>
		<url-pattern>*.jsp</url-pattern>
	</filter-mapping>

Java代码

1. success:function showResponse(responseText, statusText)  {    
2. //这里name为input text id,如果"aa"在前，那么name的值会改为aa+返回的结果
3.                     $('#name').val("aa"+responseText);   
4. //如果改成$('#name').val(responseText+"aa")，那么name的值仍然是//responseText,“aa”没有加到后面去，不知道是什么原因

success:function showResponse(responseText, statusText)  { 
//这里name为input text id,如果"aa"在前，那么name的值会改为aa+返回的结果
    				$('#name').val("aa"+responseText);
//如果改成$('#name').val(responseText+"aa")，那么name的值仍然是//responseText,“aa”没有加到后面去，不知道是什么原因
} 

参考：http://jasin2008.javaeye.com/blog/312854

修改ifcfg-eth0文件内容：

[root@yourmachine ~]# vi /etc/sysconfig/network-scripts/ifcfg-eth0

DEVICE=eth0
ONBOOT=yes
BOOTPROTO=static
IPADDR=10.130.40.69
NETMASK=255.255.255.0
GATEWAY=10.130.40.1

修改resolv.conf：

[root@yourmachine ~]# vi /etc/resolv.conf

nameserver 10.130.1.1
nameserver 10.130.1.9
nameserver 202.106.196.115

重新启动网络配置
/etc/init.d/network restart

先决条件

为了让你的版本库使用HTTP网络，你基本上需要两个包里的四个部分。你需要Apache httpd2.0和包括的mod_dav DAV模块，Subversion和与之一同分发的mod_dav_svn文件系统提供者模块，如果你有了这些组件，网络化你的版本库将非常简单，如：

• 配置好httpd 2.0，并且使用mod_dav启动，

• 为mod_dav安装mod_dav_svn插件，它会使用Subversion的库访问版本库，并且

• 配置你的httpd.conf来输出（或者说暴露）版本库。

你可以通过从源代码编译httpd和Subversion来完成前两个项目，也可以通过你的系统上的已经编译好的二进制包来安装。最新的使用Apache HTTP的Subversion的编译方法和Apache的配置方式可以看Subversion源代码树根目录的INSTALL文件。

基本的 Apache 配置

一旦你安装了必须的组件，剩下的工作就是在httpd.conf里配置Apache，使用LoadModule来加载mod_dav_svn模块，这个指示必须先与其它Subversion相关的其它配置出现，如果你的Apache使用缺省布局安装，你的mod_dav_svn模块一定在Apache安装目录（通常是在/usr/local/apache2）的modules子目录，LoadModule指示的语法很简单，影射一个名字到它的共享库的物理位置：

LoadModule dav_svn_module     modules/mod_dav_svn.so

注意，如果mod_dav是作为共享对象编译（而不是静态链接到httpd程序），你需要为它使用LoadModule语句，一定确定它在mod_dav_svn之前：

LoadModule dav_module         modules/mod_dav.so
LoadModule dav_svn_module     modules/mod_dav_svn.so

基本HTTP认证

最简单的客户端认证方式是通过HTTP基本认证机制，简单的使用用户名和密码来验证一个用户所自称的身份，Apache提供了一个htpasswd工具来管理可接受的用户名和密码，这些就是你希望赋予Subversion特别权限的用户，让我们给Sally和Harry赋予提交权限，首先，我们需要添加他们到密码文件。

$ ### First time: use -c to create the file
$ ### Use -m to use MD5 encryption of the password, which is more secure
$ htpasswd -cm /etc/svn-auth-file harry
New password: *****
Re-type new password: *****
Adding password for user harry
$ htpasswd -m /etc/svn-auth-file sally
New password: *******
Re-type new password: *******
Adding password for user sally
$

下一步，你需要在httpd.conf的Location区里添加一些指示来告诉Apache如何来使用这些密码文件，AuthType指示指定系统使用的认证类型，这种情况下，我们需要指定Basic认证系统，AuthName是你提供给认证域一个任意名称，大多数浏览器会在向用户询问名称和密码的弹出窗口里显示这个名称，最终，使用AuthUserFile指示来指定使用htpasswd创建的密码文件的位置。

添加完这三个指示，你的<Location>区块一定像这个样子：

<Location /svn>
  DAV svn
  SVNParentPath /usr/local/svn
  AuthType Basic
  AuthName "Subversion repository"
  AuthUserFile /etc/svn-auth-file
</Location>

这个<Location>区块还没有结束，还不能做任何有用的事情，它只是告诉Apache当需要授权时，要去向Subversion客户端索要用户名和密码。我们这里遗漏的，是一些告诉Apache什么样客户端需要授权的指示。哪里需要授权，Apache就会在哪里要求认证，最简单的方式是保护所有的请求，添加Require valid-user来告诉Apache任何请求需要认证的用户：

<Location /svn>
  DAV svn
  SVNParentPath /usr/local/svn
  AuthType Basic
  AuthName "Subversion repository"
  AuthUserFile /etc/svn-auth-file
  Require valid-user
</Location>

授权选项

此刻，你已经配置了认证，但是没有配置授权，Apache可以要求用户认证并且确定身份，但是并没有说明这个身份的怎样允许和限制，这个部分描述了两种控制访问版本库的策略。

整体访问控制

最简单的访问控制形式是授权特定用户为只读版本库访问或者是读/写访问版本库。

你可以通过在<Location>区块添加Require valid-user指示来限制所有的版本库操作，使用我们前面的例子，这意味着只有客户端只可以是harry或者sally，而且他们必须提供正确的用户名及对应密码，这样允许对Subversion版本库做任何事：

<Location /svn>
  DAV svn
  SVNParentPath /usr/local/svn

  # how to authenticate a user
  AuthType Basic
  AuthName "Subversion repository"
  AuthUserFile /path/to/users/file

  # only authenticated users may access the repository
  Require valid-user
</Location>

有时候，你不需要这样严密，举个例子，Subversion自己在http://svn.collab.net/repos/svn的源代码允许全世界的人执行版本库的只读操作（例如检出我们的工作拷贝和使用浏览器浏览版本库），但是限定只有认证用户可以执行写操作。为了执行特定的限制，你可以使用Limit和LimitExcept配置指示，就像Location指示，这个区块有开始和结束标签，你需要在<Location>中添加这个指示。

在Limit和LimitExcept中使用的参数是可以被这个区块影响的HTTP请求类型，举个例子，如果你希望禁止所有的版本库访问，只是保留当前支持的只读操作，你可以使用LimitExcept指示，并且使用GET，PROPFIND，OPTIONS和REPORT请求类型参数，然后前面提到过的Require valid-user指示将会在<LimitExcept>区块中而不是在<Location>区块。

<Location /svn>
  DAV svn
  SVNParentPath /usr/local/svn

  # how to authenticate a user
  AuthType Basic
  AuthName "Subversion repository"
  AuthUserFile /path/to/users/file

  # For any operations other than these, require an authenticated user.
  <LimitExcept GET PROPFIND OPTIONS REPORT>
    Require valid-user
  </LimitExcept>
</Location>

这里只是一些简单的例子，想看关于Apache访问控制Require指示的更深入信息，可以查看Apache文档中的教程集http://httpd.apache.org/docs-2.0/misc/tutorials.html中的Security部分。

每目录访问控制

也可以使用Apache的httpd模块mod_authz_svn更加细致的设置访问权限，这个模块收集客户端传递过来的不同的晦涩的URL信息，询问mod_dav_svn来解码，然后根据在配置文件定义的访问政策来裁决请求。

如果你从源代码创建Subversion，mod_authz_svn会自动附加到mod_dav_svn，许多二进制分发版本也会自动安装，为了验证它是安装正确，确定它是在httpd.conf的LoadModule指示中的mod_dav_svn后面：

LoadModule dav_module         modules/mod_dav.so
LoadModule dav_svn_module     modules/mod_dav_svn.so
LoadModule authz_svn_module   modules/mod_authz_svn.so

为了激活这个模块，你需要配置你的Location区块的AuthzSVNAccessFile指示，指定保存路径中的版本库访问政策的文件。（一会儿我们将会讨论这个文件的格式。）

Apache非常的灵活，你可以从三种模式里选择一种来配置你的区块，作为开始，你选择一种基本的配置模式。（下面的例子非常简单；见Apache自己的文档中的认证和授权选项来查看更多的细节。）

最简单的区块是允许任何人可以访问，在这个场景里，Apache决不会发送认证请求，所有的用户作为“匿名”对待。

例 6.1. 匿名访问的配置实例。

<Location /repos>
  DAV svn
  SVNParentPath /usr/local/svn

  # our access control policy
  AuthzSVNAccessFile /path/to/access/file
</Location>
          

在另一个极端，你可以配置为拒绝所有人的认证，所有客户端必须提供证明自己身份的证书，你通过Require valid-user指示来阻止无条件的认证，并且定义一种认证的手段。

例 6.2. 一个认证访问的配置实例。

<Location /repos>
  DAV svn
  SVNParentPath /usr/local/svn

  # our access control policy
  AuthzSVNAccessFile /path/to/access/file

  # only authenticated users may access the repository
  Require valid-user

  # how to authenticate a user
  AuthType Basic
  AuthName "Subversion repository"
  AuthUserFile /path/to/users/file
</Location>

Apache和svnserve都可以给用户赋予（或拒绝）访问许可，通常是对整个版本库：一个用户可以读版本库（或不），而且他可以写版本库（或不）。如果可能，也可以定义细粒度的访问规则。一组用户可以有版本库的一个目录的读写权限，但是没有其它的；另一个目录可以是只对一少部分用户可读。

两种服务器都使用同样的文件格式描述路径为基础的规则，如果是Apache，需要加载mod_authz_svn模块，然后添加AuthzSVNAccessFile指示（在文件httpd.conf中）指明你的规则文件。（完全解释可以看“每目录访问控制”一节。）如果你在使用svnserve，你需要让你的authz-db变量（在svnserve.conf中）指向规则文件。

当你的服务器知道去查找规则文件时，就是需要定义规则的时候了。

访问文件的语法与svnserve.conf和运行中配置文件非常相似，以（#）开头的行会被忽略，在它的简单形式里，每一小节命名一个版本库和一个里面的路径，认证用户名是在每个小节中的选项名，每个选项的值描述了用户访问版本库的级别：r（只读）或者rw（读写），如果用户没有提到，访问是不允许的。

具体一点：这个小节的名称是[repos-name:path]或者[path]的形式，如果你使用SVNParentPath指示，指定版本库的名字是很重要的，如果你漏掉了他们，[/some/dir]部分就会与/some/dir的所有版本库匹配，如果你使用SVNPath指示，因此在你的小节中只是定义路径也很好—毕竟只有一个版本库。

[calc:/branches/calc/bug-142]
harry = rw
sally = r

在第一个例子里，用户harry对calc版本库中/branches/calc/bug-142具备完全的读写权利，但是用户sally只有读权利，任何其他用户禁止访问这个目录。

当然，访问控制是父目录传递给子目录的，这意味着我们可以为Sally指定一个子目录的不同访问策略：

[calc:/branches/calc/bug-142]
harry = rw
sally = r

# give sally write access only to the 'testing' subdir
[calc:/branches/calc/bug-142/testing]
sally = rw

现在Sally可以读取分支的testing子目录，但对其他部分还是只可以读，同时，Harry对整个分支还继续有完全的读写权限。

也可以通过继承规则明确的的拒绝某人的访问，只需要设置用户名参数为空：

[calc:/branches/calc/bug-142]
harry = rw
sally = r

[calc:/branches/calc/bug-142/secret]
harry =

在这个例子里，Harry对bug-142目录树有完全的读写权限，但是对其中的secret子目录没有任何访问权利。

需要记住的是最详细的的路径会被匹配，服务器首先找到匹配自己的目录，然后父目录，然后父目录的父目录，就这样继续下去，更具体的路径控制会覆盖所有继承下来的访问控制。

缺省情况下，没有人对版本库有任何访问，这意味着如果你已经从一个空文件开始，你会希望给所有用户对版本库根目录具备读权限，你可以使用星号（*）实现，用来代表“所有用户”：

[/]
* = r

这是一个普通的设置；注意在小节名中没有提到版本库名称，这让所有版本库对所有的用户可读。当所有用户对版本库有了读权利，你可以赋予特定用户对特定子目录的rw权限。

星号（*）参数需要在这里详细强调：这是匹配匿名用户的唯一模式，如果你已经配置了你的Location区块允许匿名和认证用户的混合访问，所有用户作为Apache匿名用户开始访问，mod_authz_svn会在要访问路径的定义中查找*值；如果找不到，Apache就会要求真实的客户端认证。

访问文件也允许你定义一组的用户，很像Unix的/etc/group文件：

[groups]
calc-developers = harry, sally, joe
paint-developers = frank, sally, jane
everyone = harry, sally, joe, frank, sally, jane

组可以被赋予通用户一样的访问权限，使用“at”（@）前缀来加以区别：

[calc:/projects/calc]
@calc-developers = rw

[paint:/projects/paint]
@paint-developers = rw
jane = r

组中也可以定义为包含其它的组：

[groups]
calc-developers = harry, sally, joe
paint-developers = frank, sally, jane
everyone = @calc-developers, @paint-developers

参考：

• 使用Subversion进行版本控制

在Apache, PHP, MySQL的体系架构中，MySQL对于性能的影响最大，也是关键的核心部分。对于Discuz!论坛程序也是如此，MySQL的设置是否合理优化，直接影响到论坛的速度和承载量！同时，MySQL也是优化难度最大的一个部分，不但需要理解一些MySQL专业知识，同时还需要长时间的观察统计并且根据经验进行判断，然后设置合理的参数。

下面我们了解一下MySQL优化的一些基础，MySQL的优化我分为两个部分，一是服务器物理硬件的优化；二是MySQL自身(my.cnf)的优化。

(1) 服务器硬件对MySQL性能的影响

a) 磁盘寻道能力（磁盘I/O）,以目前高转速SCSI硬盘(7200转/秒)为例，这种硬盘理论上每秒寻道7200次，这是物理特性决定的，没有办法改变。MySQL每秒钟都在进行大量、复杂的查询操作，对磁盘的读写量可想而知。所以，通常认为磁盘I/O是制约MySQL性能的最大因素之一，对于日均访问量在100万PV以上的Discuz!论坛，由于磁盘I/O的制约，MySQL的性能会非常低下！解决这一制约因素可以考虑以下几种解决方案：

使用RAID-0+1磁盘阵列，注意不要尝试使用RAID-5，MySQL在RAID-5磁盘阵列上的效率不会像你期待的那样快； 抛弃传统的硬盘，使用速度更快的闪存式存储设备。经过Discuz!公司技术工程的测试，使用闪存式存储设备可比传统硬盘速度高出6－10倍左右。

b) CPU 对于MySQL应用，推荐使用S.M.P.架构的多路对称CPU，例如：可以使用两颗Intel Xeon 3.6GHz的CPU。

c) 物理内存对于一台使用MySQL的Database Server来说，服务器内存建议不要小于2GB，推荐使用4GB以上的物理内存。

(2) MySQL自身因素当解决了上述服务器硬件制约因素后，让我们看看MySQL自身的优化是如何操作的。对MySQL自身的优化主要是对其配置文件my.cnf中的各项参数进行优化调整。下面我们介绍一些对性能影响较大的参数。

由于my.cnf文件的优化设置是与服务器硬件配置息息相关的，因而我们指定一个假想的服务器硬件环境：

CPU: 2颗Intel Xeon 2.4GHz

内存: 4GB DDR

硬盘: SCSI 73GB

下面，我们根据以上硬件配置结合一份已经优化好的my.cnf进行说明：

# vi /etc/my.cnf

以下只列出my.cnf文件中[mysqld]段落中的内容，其他段落内容对MySQL运行性能影响甚微，因而姑且忽略。

  [mysqld]
  port = 3306
  serverid = 1 
  socket = /tmp/mysql.sock
  skip-locking
  # 避免MySQL的外部锁定，减少出错几率增强稳定性。
  skip-name-resolve

禁止MySQL对外部连接进行DNS解析，使用这一选项可以消除MySQL进行DNS解析的时间。但需要注意，如果开启该选项，则所有远程主机连接授权都要使用IP地址方式，否则MySQL将无法正常处理连接请求！

back_log = 384

指定MySQL可能的连接数量。当MySQL主线程在很短的时间内接收到非常多的连接请求，该参数生效，主线程花费很短的时间检查连接并且启动一个新线程。

back_log参数的值指出在MySQL暂时停止响应新请求之前的短时间内多少个请求可以被存在堆栈中。 如果系统在一个短时间内有很多连接，则需要增大该参数的值，该参数值指定到来的TCP/IP连接的侦听队列的大小。不同的操作系统在这个队列大小上有它自己的限制。

试图设定back_log高于你的操作系统的限制将是无效的。默认值为50。对于Linux系统推荐设置为小于512的整数。

     key_buffer_size = 256M
  # key_buffer_size指定用于索引的缓冲区大小，增加它可得到更好的索引处理性能。
    对于内存在4GB左右的服务器该参数可设置为256M或384M。
  注意：该参数值设置的过大反而会是服务器整体效率降低！ 
     max_allowed_packet = 4M
    thread_stack = 256K
    table_cache = 128K
    sort_buffer_size = 6M

查询排序时所能使用的缓冲区大小。注意：该参数对应的分配内存是每连接独占！如果有100个连接，那么实际分配的总共排序缓冲区大小为100 × 6 ＝ 600MB。所以，对于内存在4GB左右的服务器推荐设置为6-8M。

 read_buffer_size = 4M

读查询操作所能使用的缓冲区大小。和sort_buffer_size一样，该参数对应的分配内存也是每连接独享！

join_buffer_size = 8M

联合查询操作所能使用的缓冲区大小，和sort_buffer_size一样，该参数对应的分配内存也是每连接独享！

     myisam_sort_buffer_size = 64M
    table_cache = 512
    thread_cache_size = 64
    query_cache_size = 64M

指定MySQL查询缓冲区的大小。可以通过在MySQL控制台执行以下命令观察：

 # > SHOW VARIABLES LIKE '%query_cache%';
 # > SHOW STATUS LIKE 'Qcache%';
 # 如果Qcache_lowmem_prunes的值非常大，则表明经常出现缓冲不够的情况；

如果Qcache_hits的值非常大，则表明查询缓冲使用非常频繁，如果该值较小反而会影响效率，那么可以考虑不用查询缓冲；Qcache_free_blocks，如果该值非常大，则表明缓冲区中碎片很多。

     tmp_table_size = 256M
    max_connections = 768

指定MySQL允许的最大连接进程数。如果在访问论坛时经常出现Too Many Connections的错误提 示，则需要增大该参数值。

     max_connect_errors = 10000000
    wait_timeout = 10

指定一个请求的最大连接时间，对于4GB左右内存的服务器可以设置为5-10。

     thread_concurrency = 8

该参数取值为服务器逻辑CPU数量×2，在本例中，服务器有2颗物理CPU，而每颗物理CPU又支持H.T超线程，所以实际取值为4 × 2 ＝ 8

    skip-networking

开启该选项可以彻底关闭MySQL的TCP/IP连接方式，如果WEB服务器是以远程连接的方式访问MySQL数据库服务器则不要开启该选项！否则将无法正常连接！

参考：http://kb.discuz.net/index.php?title=MySQL%E4%BC%98%E5%8C%96%E5%AE%9E%E4%BE%8B

Use this Typesafe Enumeration class in your domain model as a simple property type (e.g. of the Comment class in a forum):

public class Rating implements Serializable {

    private String name;

    public static final Rating EXCELLENT = new Rating("Excellent");
    public static final Rating OK = new Rating("OK");
    public static final Rating LOW = new Rating("Low");
    private static final Map INSTANCES = new HashMap();

    static {
        INSTANCES.put(EXCELLENT.toString(), EXCELLENT);
        INSTANCES.put(OK.toString(), OK);
        INSTANCES.put(LOW.toString(), LOW);
    }

    private Rating(String name) {
        this.name=name;
    }

    public String toString() {
        return name;
    }

    private Object readResolve() {
        return getInstance(name);
    }

    public static Rating getInstance(String name) {
        return (Rating)INSTANCES.get(name);
    }
}

Next, write the Hibernate custom mapping type:

public class RatingUserType implements UserType {

    private static final int[] SQL_TYPES = {Types.VARCHAR};

    public int[] sqlTypes() { return SQL_TYPES; }
    public Class returnedClass() { return Rating.class; }
    public boolean equals(Object x, Object y) { return x == y; }
    public Object deepCopy(Object value) { return value; }
    public boolean isMutable() { return false; }

    public Object nullSafeGet(ResultSet resultSet,
                              String[] names,
                              Object owner)
            throws HibernateException, SQLException {

      String name = resultSet.getString(names[0]);
      return resultSet.wasNull() ? null : Rating.getInstance(name);
    }

    public void nullSafeSet(PreparedStatement statement,
                            Object value,
                            int index)
            throws HibernateException, SQLException {

        if (value == null) {
            statement.setNull(index, Types.VARCHAR);
        } else {
            statement.setString(index, value.toString());
        }
    }
}

Finally, in your mapping files, bind it all together:

<hibernate-mapping package="org.hibernate.auction.model">

<class name="Comment"
       table="COMMENTS"
       lazy="true">

    <!-- Common id property. -->
    <id name="id"
        type="long"
        column="COMMENT_ID"
        unsaved-value="null">
        <generator class="native"/>
    </id>

    <!-- Simple property. -->
    <property
        name="rating"
        column="RATING"
        type="org.hibernate.auction.persistence.RatingUserType"
        not-null="true"
        update="false"/>
...
</class>
</hibernate-mapping>

You may also use your Rating enumerated type in Hibernate queries:

Query q = session.createQuery("from Comment c where c.rating = :rating");
q.setParameter("rating",
               Rating.LOW,
               Hibernate.custom(RatingUserType.class));

This is all there is to know about it. You may enhance this strategy with a generic UserType implementation, that knows how to persist different Typesafe Enumerations, this is described here.

The examples and domain model you have just seen can be found in Hibernate in Action.

Christian

Reference:  1. http://www.hibernate.org/172.html

在项目中常遇到用数字表示一种意思的字段，例如：type ，1 表示正常状态，0表示冻结状态；这是一类典型的问题，即枚举类型的映射和表示。在Hibernate2.1版本中提供了enum的接口类型来处理这类问题，参考这个讨论：

http://forum.javaeye.com/viewtopic.php?t=8114&postdays=0&postorder=asc&highlight=enum&start=0

但是在Hibernate3中取消了enum类型的支持，Hibernate官方推荐使用UserType接口。不过使用UserType接口实际上会比较复杂，下面我将使用一个简单的案例来讲解使用UserType接口来解决这类问题的办法：

package com.javaeye.simple.domain;

import java.io.Serializable;

public class UserTitle implements Serializable {

    private int title;

    public static final UserTitle EMPLOYEE = new UserTitle(0);

    public static final UserTitle MANAGER = new UserTitle(1);

    public static final UserTitle DIRECTOR = new UserTitle(2);

    public static final UserTitle CEO = new UserTitle(3);

    private UserTitle(int title) {
        this.title = title;
    }

    public int toInt() {
        return title;
    }

    public static UserTitle fromInt(int title) {
        switch (title) {
        case 0:
            return EMPLOYEE;
        case 1:
            return MANAGER;
        case 2:
            return DIRECTOR;
        case 3:
            return CEO;
        default:
            throw new RuntimeException("Unknown Status");
        }
    }

    public String toString() {
        switch (title) {
        case 0:
            return "雇员";
        case 1:
            return "经理";
        case 2:
            return "总监";
        case 3:
            return "CEO";
        default:
            throw new RuntimeException("Unknown Status");
        }
    }

}

注意，我们需要一个UserTitleType的类，实现UserType接口，定义一个User对象的UserTitle属性是如何向数据库持久化的：

package com.javaeye.simple.domain;

import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Types;
import java.sql.SQLException;

import org.hibernate.HibernateException;
import org.hibernate.usertype.UserType;

public class UserTitleType implements UserType {

    public int[] sqlTypes() {
        int[] types = {Types.INTEGER};       
        return types;
    }

    public Class returnedClass() {
        return UserTitle.class;
    }

    public boolean equals(Object x, Object y) throws HibernateException {
        return x == y;
    }

    public int hashCode(Object x) throws HibernateException {
        return x.hashCode();
    }

    public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws HibernateException, SQLException {
        int title = rs.getInt(names[0]);
        return rs.wasNull() ? null : UserTitle.fromInt(title);
    }

    public void nullSafeSet(PreparedStatement st, Object value, int index) throws HibernateException, SQLException {
        if (value == null) {
            st.setNull(index, Types.INTEGER);
        } else {
            st.setInt(index, ((UserTitle) value).toInt());
        }
    }

    public Object deepCopy(Object value) throws HibernateException {
        return value;
    }

    public boolean isMutable() {
        return false;
    }

    public Serializable disassemble(Object value) throws HibernateException {
        return (Serializable) deepCopy(value);
    }

    public Object assemble(Serializable cached, Object owner) throws HibernateException {
        return deepCopy(cached);
    }

    public Object replace(Object original, Object target, Object owner) throws HibernateException {
        return deepCopy(original);
    }

}

注意nullSafeGet和nullSafeSet方法的代码，是如何实现UserTitle的字符串值和数据库中保存数字进行转换的。
最后是映射文件：

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.javaeye.simple.domain">

    <class name="User">
        <id name="id" unsaved-value="null">
            <generator class="native"/>
        </id>
        <property name="username"/>
        <property name="password"/>
        <property name="gender"/>
        <property name="age"/>
        <property name="department"/>
        <property name="mail"/>
        <property name="birthday"/>
        <property name="title" type="com.javaeye.simple.domain.UserTitleType">
        </property>
    </class>
</hibernate-mapping>

指明title属性是用户自定义的某类型。

在Java程序中指定user的title属性：
user.setTitle(UserTitle.MANAGER);
session.save(user);
在页面输出：
<% user.getTitle() %>
就可以打印出中文字符串表示。

参考：
1. http://www.javaeye.com/topic/15849
2. http://www.hibernate.org/172.html

1. deeptree.jsp中定义css为deeptree.css，并定义<div id="deeptree" class="deeptree" CfgXMLSrc="deeptreeconfig.xml">
2. deeptree.css中定义了class=deeptree的behavior为：url(deeptree.htc)
3. deeptree.htc中包含对deeptree的树操作和XML操作和其它页面行为操作的定义。其初始化数据来自deeptreeconfig.xml.使用了deeptree.xsl来处理树相关的操作。
4. 树的信息来自于TreeRoot.xml和Tree688.xml等这样的数据源。

参考：1. Deeptree下载

主要类图：

主要流程：
ConfigureCommandLine从Configuration中读取选择的default和local的属性，如果在控制台输入新的值，则替换为新值。最后写下这些local参数。  

应用：1．限制输入数字

<input style="ime-mode : disabled"  onKeyPress="if ((event.keyCode<48 || event.keyCode>57)) event.returnValue=false">

参考：1. Keycode对照表

Configuration

• Download and Install JSSE (if needed).

Note that JSSE is bundled with Sun's JDK 1.4 and later, so if you're using JDK 1.4 and later, you can skip this step.

• Prepare the Certificate Keystore

Tomcat currently operates with JKS, PKCS11 or PKCS12 format keystores. The JKS format is Java's standard "Java KeyStore" format, and is the format created by the keytool command-line utility. This tool is included in the JDK.

To create a new keystore from scratch, containing a single self-signed Certificate, execute the following from a terminal command line:

%JAVA_HOME%\bin\keytool -genkey -alias tomcat -keyalg RSA

This command will create a new file, in the home directory of the user under which you run it, named ".keystore".

To specify a different location or filename, add the -keystore parameter, followed by the complete pathname to your 
keystore file, to the keytool command shown above.

%JAVA_HOME%\bin\keytool -genkey -alias tomcat -keyalg RSA -keystore \path\to\my\keystore

You MUST use the same password here as was used for the keystore password itself.

Note: your private key password and keystore password should be the same. If they differ, you will get an error along the lines of java.io.IOException: Cannot recover key, as documented in Bugzilla 38217, which contains further references for this issue.

• Edit the Tomcat Configuration File

The final step is to configure your secure socket in the $CATALINA_HOME/conf/server.xml file, where $CATALINA_HOME represents the directory into which you installed Tomcat 5. An example <Connector> element for an SSL connector is included in the default server.xml file installed with Tomcat. It will look something like this:

<-- Define a SSL Coyote HTTP/1.1 Connector on port 8443 -->
<!--
<Connector 
           port="8443" minProcessors="5" maxProcessors="75"
           enableLookups="true" disableUploadTimeout="true"
           acceptCount="100" debug="0" scheme="https" secure="true";
           clientAuth="false" sslProtocol="TLS"/>
-->

You will need to remove the comment tags around it.Then, you can customize the specified attributes as necessary.If you change the port number here, you should also change the value specified for the redirectPort attribute on the non-SSL connector.

Attribute	Description
keystoreFile	Add this attribute if the keystore file you created is not in the default place that Tomcat expects (a file named .keystore in the user home directory under which Tomcat is running). You can specify an absolute pathname, or a relative pathname that is resolved against the $CATALINA_BASE environment variable.
keystorePass	Add this element if you used a different keystore (and Certificate) password than the one Tomcat expects (changeit).
...	...

After completing these configuration changes, you must restart Tomcat as you normally do, and you should be in business. You should be able to access any web application supported by Tomcat via SSL.

Reference:

The Apache Tomcat 5.5 Servlet/JSP Container SSL Configuration HOW-TO

此配置适用于Resin2.x和Resin3.x版本。运行时需要在每个project目录下放置一个resin.conf文件，由于Resin2.x和Resin3.x版本的配置文件不同，所以需要两个文件，resin.conf文件用于启动resin2.x，resin30.conf用于启动resin3.x。

以下说明以配置Resin2.1.16版本为例，具体步骤如下：
1、打开“window->Preferences->Java->Build Path->Classpath Variables”，添加classpath variables，将基配置到Resin的安装目录。比如在我的机器上配置为：Resin_2.1.16 －D:/Program/JavaSoft/resin-2.1.16。最好同时配置一个JDK_TOOLS，指定到java_home下的lib/tools.jar文件上，否则可能会在控制台输出时中文显示成乱码。
2、运行菜单“Run->Run...”，在弹出的窗口中添加一个Java Application的运行项目。
3、项目名称随便添写，只要能区分出不同的应用就可以了。如：resin_2.1.16。在Project一项置为空，如果已经有内容了则将其删除，这要才能保证在每个项目中都可以运行。
4、设置项目的启动类（Main Class），Resin2.x为com.caucho.server.http.HttpServer，Resin3.x为com.caucho.server.http.ResinServer。
5、配置Arguments，在Program arguments中填写-conf "${project_loc}\resin.conf"，（如果配置Resin3.x则填写-conf "${project_loc}\resin30.conf"）。
6、在VM arguments中为空（如果是Resin3.x则填写-Djava.util.logging.manager=com.caucho.log.LogManagerImpl）
7、指定Working directory为resin的安装目录。
8、配置JRE，保持默认配置即可，如果是resin3.x版本可能需要jre5.0。
9、配置classpath，选择Bootstrap Entries，点击Advanced，选择Add ClasspathVariables，选择Resin_2.1.16，点击Extend，将lib目录下的所有jar文件选中，添加到启动项目中，然后将JDK_TOOLS也加到启动项目中。
10、保存配置。在项目的根目录下放置resin.conf，在eclipse的Run菜单中将Resin_2.1.16加入到收藏中，选择项目或是项目中的某个文件，然后运行Resin_2.1.16即可。

安装Oracle 9i，其安装缺省包含了XDB。在启动数据库后，Oracle XDB的http服务将会自动占用了8080端口，使用下面方法修改XDB的http和ftp服务端口：

1.使用dbms_xdb包修改端口设置

使用sys登录sqlplus

sqlplus sys/syspassword as sysdba

执行如下的脚本:

============================ 
-- Change the HTTP/WEBDAV port from 8080 to 8081 
call dbms_xdb.cfg_update(updateXML( 
dbms_xdb.cfg_get() 
, '/xdbconfig/sysconfig/protocolconfig/httpconfig/http-port/text()' 
, 8081)) 
/ 
-- Change the FTP port from 2100 to 2111 
call dbms_xdb.cfg_update(updateXML( 
dbms_xdb.cfg_get() 
, '/xdbconfig/sysconfig/protocolconfig/ftpconfig/ftp-port/text()' 
, 2111)) 
/ 
COMMIT; 
EXEC dbms_xdb.cfg_refresh;

参考
1. 轻松解决Oracle XDB的8080端口冲突问题

CONNECT BY Example

The following hierarchical query uses the CONNECT BY clause to define the relationship between employees and managers:

SELECT employee_id, last_name, manager_id
   FROM employees
   CONNECT BY PRIOR employee_id = manager_id;

START WITH Examples

The next example adds a START WITH clause to specify a root row for the hierarchy and an ORDER BY clause using the SIBLINGS keyword to preserve ordering within the hierarchy:

SELECT last_name, employee_id, manager_id, LEVEL
      FROM employees
      START WITH employee_id = 100
      CONNECT BY PRIOR employee_id = manager_id
      ORDER SIBLINGS BY last_name;

String.prototype 的扩展:

strip: function() {
  return this.replace(/^\s+/, '').replace(/\s+$/, '');
},

Introduction to Ajax
new Ajax.Request('/some_url', { method:'get' });

<html>
    <head>
        <script type="text/javascript">
            function Department(name){
                this.name=name;
                this.persons=new Array();
                this.add=function(person){
                    this.persons.push(person);
                };   
                this.indexOf=function(person){
                    var i;
                    for(i=this.persons.length-1;i>=0;i--){
                        if(this.persons[i]==person) break;   
                    }
                    return i;
                };           
                this.remove=function(person){
                    var i=this.indexOf(person);
                    if(i >= 0){           
                        this.persons.splice(i,1);
                    }
                };
                this.isAllAssigned=function(){
                    return this.persons.length==0;   
                };
            }   
            function Person(name,department){
                this.name=name;
                this.department=department;               
                this.department.add(this);
                this.setAssigned=function(assigned) {
                    if (assigned) {
                        this.department.remove(this);
                    }
                };
            }                   
            function Team(){
                this.departments=new Array();
                this.addAll=function(departments){
                    this.departments=this.departments.concat(departments);
                };
                this.add=function(department){
                    this.departments.push(department);
                };   
                this.size=function(){
                    return this.departments.length;
                }
                this.indexOf=function(department){
                    var i;
                    for(i=this.departments.length-1;i>=0;i--){
                        if(this.departments[i]==department){
                            break;   
                        }   
                    }
                    return i;
                };
                this.remove=function(department){
                    var i=this.indexOf(department);
                    if(i>=0){
                        this.departments.splice(i,1);
                    }
                };
            }
            function Partner(A,B){
                this.A=A;
                this.B=B;
            }
            function PartnerMaker(){
                this.team=new Team();
                this.partners=new Array();
                this.init=function(){
                    var tech=new Department("TECH");
                    new Person('H',tech);
                    new Person('Y',tech);
                    new Person('F',tech);
                    var market = new Department("MARKET");
                    new Person('L',market);
                    new Person('D',market);
                    var edu = new Department("EDU");
                    new Person('F',edu);
                    new Person('Z',edu);
                    new Person('S',edu);
                    new Person('W',edu);
                    var hr = new Department("HR");
                    new Person('Z,hr);                   
                    new Person('W',hr);
                    new Person('Z',hr);
                    var web = new Department("WEB");
                    new Person('Q',web);                   
                    new Person('R',web);
                    var sys = new Department("SYS");
                    new Person("Z",sys);
                    var lesson = new Department("LESSON");
                    new Person("G",lesson);
                    var departments=[tech,market,edu,hr,web,sys,lesson];
                    this.team.addAll(departments);
                };
                this.randomDepartmentNum=function(){                   
                    if(this.team.size()==1){
                        return 0;
                    }
                    var i =    Math.floor(Math.random()*this.team.size());
                    return i;
                };
                this.randomPersonNum=function(persons){
                    if(persons.length==1){
                        return 0;
                    }
                    var i = Math.floor(Math.random()*persons.length);
                    return i;
                };
                this.remainPersons=function(exclusiveDepNum){
                    var persons = new Array();
                    for(var i=0;i<this.team.size();i++){
                        if(i==exclusiveDepNum) continue;
                        persons = persons.concat(this.team.departments[i].persons);   
                    }   
                    return persons;
                };
                this.assignPartners=function(){           
                    while(this.team.size() > 1){                   
                        var depNum = this.randomDepartmentNum();
                        var depA = this.team.departments[depNum];
                        var aNum = this.randomPersonNum(depA.persons);
                        var personA=depA.persons[aNum];
                        var others = this.remainPersons(depNum);
                        var bNum = this.randomPersonNum(others);
                        var personB=others[bNum];
                        var partner = new Partner(personA, personB);
                        this.partners.push(partner);
                        personA.setAssigned(true);
                        personB.setAssigned(true);           
                        if (personA.department.isAllAssigned()) {
                            this.team.remove(personA.department);
                        }
                        if (personB.department.isAllAssigned()) {
                            this.team.remove(personB.department);
                        }
                    }
                };
                this.alertPartners=function() {
                    for (var i = 0; i < this.partners.length; i++) {
                        var a = this.partners[i].A;
                        var b = this.partners[i].B;
                        alert("Partner["+i+"]="+a.name+"@"+ a.department.name+","+b.name+"@"+b.department.name);
                    }
                    for (var j = 0; j < this.team.departments.length; j++) {
                        var dep = this.team.departments[j];
                        for (var k = 0; k < dep.persons.length; k++) {
                            var p = dep.persons[k];
                            alert("落单学员：" + p.name + "@" + p.department.name);
                        }
                    }
                };   
                this.printPartners=function() {
                    var tbody=document.getElementById("TBODY_0");
                    tbody.removeNode(true);
                    tbody = document.createElement("TBODY");
                    tbody.id="TBODY_0";
                    document.getElementById("TABLE_0").appendChild(tbody);
                    for (var i = 0; i < this.partners.length; i++) {
                        var a = this.partners[i].A;
                        var b = this.partners[i].B;
                        var tr = createTR();
                        var td1 = createTD(a.name+"@"+ a.department.name);
                        var td2 = createTD(b.name+"@"+b.department.name);
                        tr.appendChild(td1);
                        tr.appendChild(td2);
                        tbody.appendChild(tr);
                    }
                    for (var j = 0; j < this.team.departments.length; j++) {
                        var dep = this.team.departments[j];
                        for (var k = 0; k < dep.persons.length; k++) {
                            var p = dep.persons[k];
                            var tr = createTR();
                            var td = createTD("落单学员：" + p.name + "@" + p.department.name);
                            tr.appendChild(td);
                            tbody.appendChild(tr);
                        }
                    }
                };               
            }
            function createTR(){
                var tr = document.createElement("TR");
                return tr;
            }
            function createTD(innerText){
                var td = document.createElement("TD");   
                td.innerText=innerText;
                return td;
            }           
            var buttonText=[" 再来一次 "," 事不过三 "," 你逗我玩啊？ "," 最后一次！ "," 周末休息 :) "];
            var textIndex=0;
            function main(elem){               
                if(!elem){
                    var btn = document.getElementById("BUTTON_0");
                    btn.disabled=false;
                    textIndex=0;
                    btn.value=" 听天由命 ";
                    return;
                }
                elem.value=buttonText[textIndex++];
                if(textIndex==buttonText.length){
                    elem.disabled=true;   
                    setTimeout("main()",2000);                   
                }
                var maker = new PartnerMaker();
                maker.init();
                maker.assignPartners();
                //maker.alertPartners();
                maker.printPartners();
            }
            function doCheat(){
                alert("嘿嘿，C老师不容许！");   
            }
        </script>                   
    </head>
    <body align="center">       
        <table>
            <tr>
                <td width="75%" valign="top">
                    <table width="100%" border="1" cellpadding="0" cellspacing="0" id="TABLE_0">
                        <thead>
                            <tr><th colspan="2">“一帮一 对对红”随机分组情况</th></tr>
                            <tr><th>甲</td><td>乙</th></tr>
                        </thead>
                        <tbody id="TBODY_0">
                        </tbody>
                    </table>
                </td>
                <td>
                    <img src="http://upload.wikimedia.org/wikipedia/en/d/de/Amaryllis_fl.jpg"/>   
                </td>
            </tr>
        </table>
        <input type="button" id="BUTTON_0" value=" 听天由命 " onClick="main(this)"/> <input type="button" value=" 我要作弊 " onClick="doCheat()"/>
    </body>
</html>

一. 项目中涉及到编写单点登录（SSO）服务。主要涉及两个场景：

1. 用户在第一个Web应用登录时，保存加密过的用户的认证信息到Cookie中。其中Cookie中token的格式为： username + ":"+Md5Hex(username + ":"+ password + ":" + key)，并使用Base64进行编码。
2. 用户在访问另一个Web应用资源时，这时通过获取Cookie中的token信息来实现自动登录。

二、相关的活动图：

• 第2个场景

三、参考

1. 编写你自己的单点登录（SSO）服务，王昱, http://blog.csdn.net/javachannel/archive/2006/05/24/752437.aspx 
2. HTTP State Management Mechanism, RFC2109, http://www.faqs.org/rfcs/rfc2109.html

耿立宏
（中国科学院计算机网络信息中心，北京100080）

一．引言

ORACLE数据库字符集，即Oracle全球化支持(Globalization Support)，或即国家语言支持（NLS）其作用是用本国语言和格式来存储、处理和检索数据。利用全球化支持，ORACLE为用户提供自己熟悉的数据库母语环境，诸如日期格式、数字格式和存储序列等。Oracle可以支持多种语言及字符集，其中oracle8i支持48种语言、76个国家地域、229种字符集，而oracle9i则支持57种语言、88个国家地域、235种字符集。由于oracle字符集种类多，且在存储、检索、迁移oracle数据时多个环节与字符集的设置密切相关，因此在实际的应用中，数据库开发和管理人员经常会遇到有关oracle字符集方面的问题。本文通过以下几个方面阐述，对oracle字符集做简要分析

二．字符集基本知识

2.1字符集
    实质就是按照一定的字符编码方案，对一组特定的符号，分别赋予不同数值编码的集合。Oracle数据库最早支持的编码方案是US7ASCII。
    Oracle的字符集命名遵循以下命名规则:
    <Language><bit size><encoding>
    即:  <语言><比特位数><编码>
    比如: ZHS16GBK表示采用GBK编码格式、16位（两个字节）简体中文字符集

2.2字符编码方案
2.2.1 单字节编码
    （1）单字节7位字符集，可以定义128个字符，最常用的字符集为US7ASCII
    （2）单字节8位字符集，可以定义256个字符，适合于欧洲大部分国家
    例如：WE8ISO8859P1(西欧、8位、ISO标准8859P1编码)
2.2.2 多字节编码
    （1）变长多字节编码
    某些字符用一个字节表示，其它字符用两个或多个字符表示，变长多字节编码常用于对亚洲语言的支持，   例如日语、汉语、印地语等
    例如：AL32UTF8（其中AL代表ALL,指适用于所有语言）、zhs16cgb231280
    （2）定长多字节编码
    每一个字符都使用固定长度字节的编码方案，目前oracle唯一支持的定长多字节编码是AF16UTF16，也是仅用于国家字符集
2.2.3 unicode编码
    Unicode是一个涵盖了目前全世界使用的所有已知字符的单一编码方案，也就是说Unicode为每一个字符提供唯一的编码。UTF-16是unicode的16位编码方式，是一种定长多字节编码，用2个字节表示一个unicode字符，AF16UTF16是UTF-16编码字符集。
    UTF-8是unicode的8位编码方式，是一种变长多字节编码，这种编码可以用1、2、3个字节表示一个unicode字符，AL32UTF8，UTF8、UTFE是UTF-8编码字符集

2.3 字符集超级
    当一种字符集（字符集A）的编码数值包含所有另一种字符集（字符集B）的编码数值，并且两种字符集相同编码数值代表相同的字符时，则字符集A是字符集B的超级，或称字符集B是字符集A的子集。
    Oracle8i和oracle9i官方文档资料中备有子集-超级对照表（subset-superset pairs），例如：WE8ISO8859P1是WE8MSWIN1252的子集。由于US7ASCII是最早的Oracle数据库编码格式，因此有许多字符集是US7ASCII的超集，例如WE8ISO8859P1、ZHS16CGB231280、ZHS16GBK都是US7ASCII的超集。

2.4 数据库字符集（oracle服务器端字符集）
    数据库字符集在创建数据库时指定，在创建后通常不能更改。在创建数据库时，可以指定字符集(CHARACTER SET)和国家字符集(NATIONAL CHARACTER SET)。
2.4.1字符集
    (1)用来存储CHAR, VARCHAR2, CLOB, LONG等类型数据
    (2)用来标示诸如表名、列名以及PL/SQL变量等
    (3)用来存储SQL和PL/SQL程序单元等
2.4.2国家字符集：
    (1)用以存储NCHAR, NVARCHAR2, NCLOB等类型数据
    (2)国家字符集实质上是为oracle选择的附加字符集，主要作用是为了增强oracle的字符处理能力，因为NCHAR数据类型可以提供对亚洲使用定长多字节编码的支持，而数据库字符集则不能。国家字符集在oracle9i中进行了重新定义，只能在unicode编码中的AF16UTF16和UTF8中选择，默认值是AF16UTF16
2.4.3查询字符集参数
    可以查询以下数据字典或视图查看字符集设置情况
    nls_database_parameters、props$、v$nls_parameters
    查询结果中NLS_CHARACTERSET表示字符集，NLS_NCHAR_CHARACTERSET表示国家字符集
2.4.4修改数据库字符集
    按照上文所说，数据库字符集在创建后原则上不能更改。如果需要修改字符集，通常需要导出数据库数据，重建数据库，再导入数据库数据的方式来转换，或通过ALTER DATABASE CHARACTER SET语句修改字符集，但创建数据库后修改字符集是有限制的，只有新的字符集是当前字符集的超集时才能修改数据库字符集，例如UTF8是US7ASCII的超集，修改数据库字符集可使用ALTER DATABASE CHARACTER SET UTF8。

2.5 客户端字符集（NLS_LANG参数）
2.5.1客户端字符集含义
    客户端字符集定义了客户端字符数据的编码方式，任何发自或发往客户端的字符数据均使用客户端定义的字符集编码,客户端可以看作是能与数据库直接连接的各种应用，例如sqlplus,exp/imp等。客户端字符集是通过设置NLS_LANG参数来设定的。
2.5.2 NLS_LANG参数格式
    NLS_LANG=<language>_<territory>.<client character set>
    Language:显示oracle消息,校验，日期命名
    Territory：指定默认日期、数字、货币等格式
    Client character set：指定客户端将使用的字符集
    例如：NLS_LANG=AMERICAN_AMERICA.US7ASCII 
    AMERICAN是语言，AMERICA是地区，US7ASCII是客户端字符集
2.5.3客户端字符集设置方法
     1)UNIX环境
         $NLS_LANG=“simplified chinese”_china.zhs16gbk
         $export NLS_LANG
         编辑oracle用户的profile文件
    2)Windows环境
         编辑注册表
         Regedit.exe---HKEY_LOCAL_MACHINE---SOFTWARE---ORACLE—HOME0
2.5.4 NLS参数查询
    Oracle提供若干NLS参数定制数据库和用户机以适应本地格式，例如有NLS_LANGUAGE,NLS_DATE_FORMAT,NLS_CALENDER等，可以通过查询以下数据字典或v$视图查看。
    NLS_DATABASE_PARAMETERS--显示数据库当前NLS参数取值，包括数据库字符集取值
    NLS_SESSION_PARAMETERS--显示由NLS_LANG 设置的参数，或经过alter session 改变后的参数值（不包括由NLS_LANG 设置的客户端字符集）
    NLS_INSTANCE_PARAMETE--显示由参数文件init<SID>.ora 定义的参数V$NLS_PARAMETERS--显示数据库当前NLS参数取值
2.5.5修改NLS参数
    使用下列方法可以修改NLS参数
    （1）修改实例启动时使用的初始化参数文件
    （2）修改环境变量NLS_LANG
    （3）使用ALTER SESSION语句，在oracle会话中修改
    （4）使用某些SQL函数
    NLS作用优先级别：Sql function>alter session>环境变量或注册表>参数文件>数据库默认参数

三．导入/导出与字符集转换

3.1 EXP/IMP
    Export 和 Import 是一对读写Oracle数据的工具。Export 将 Oracle 数据库中的数据输出到操作系统文件中, Import 把这些文件中的数据读到Oracle 数据库中，由于使用exp/imp进行数据迁移时，数据从源数据库到目标数据库的过程中有四个环节涉及到字符集，如果这四个环节的字符集不一致，将会发生字符集转换。

EXP                       

IMP                       

    四个字符集是
   （1）源数据库字符集
   （2）Export过程中用户会话字符集（通过NLS_LANG设定）
   （3）Import过程中用户会话字符集（通过NLS_LANG设定）
   （4）目标数据库字符集

3.2导出的转换过程
    在Export过程中，如果源数据库字符集与Export用户会话字符集不一致，会发生字符集转换，并在导出文件的头部几个字节中存储Export用户会话字符集的ID号。在这个转换过程中可能发生数据的丢失。
例:如果源数据库使用ZHS16GBK，而Export用户会话字符集使用US7ASCII，由于ZHS16GBK是16位字符集,而US7ASCII是7位字符集，这个转换过程中，中文字符在US7ASCII中不能够找到对等的字符，所以所有中文字符都会丢失而变成“?? ”形式，这样转换后生成的Dmp文件已经发生了数据丢失。
因此如果想正确导出源数据库数据，则Export过程中用户会话字符集应等于源数据库字符集或是源数据库字符集的超集

3.3导入的转换过程
    （1）确定导出数据库字符集环境
    通过读取导出文件头，可以获得导出文件的字符集设置
    （2）确定导入session的字符集，即导入Session使用的NLS_LANG环境变量
    （3）IMP读取导出文件
    读取导出文件字符集ID，和导入进程的NLS_LANG进行比较
    （4）如果导出文件字符集和导入Session字符集相同，那么在这一步骤内就不需要转换，如果不同，就需要把数据转换为导入Session使用的字符集。可以看出，导入数据到数据库过程中发生两次字符集转换
    第一次:导入文件字符集与导入Session使用的字符集之间的转换，如果这个转换过程不能正确完成，Import向目标数据库的导入过程也就不能完成。
    第二次:导入Session字符集与数据库字符集之间的转换。
    然而,oracle8i的这种转换只能在单字节字符集之间进行,oracle8i导入Session不支持多字节字符集之间的转换，因此为了避免第一次转换，导入Session使用的NLS_LANG与导出文件字符集相同，第二次转换（通过SQL*Net）支持任何两种字符集。以上情况在Oracle9i中略有不同

四．乱码问题

    oracle在数据存储、迁移过程中经常发生字符乱码问题，归根到底是由于字符集使用不当引起。下面以使用客户端sqlplus向数据库插入数据和导入/导出（EXP/IMP）过程为例，说明乱码产生的原因。

4.1使用客户端sqlplus向数据库存储数据
    这个过程存在3个字符集设置
    （1）客户端应用字符集
    （2）客户端NLS_LANG参数设置
    （3）服务器端数据库字符集(Character Set)设置
    客户端应用sqlplus中能够显示什么样的字符取决于客户端操作系统语言环境(客户端应用字符集)，但在应用中录入这些字符后，这些字符能否在数据库中正常存储，还与另外两个字符集设置紧密相关，其中客户端NLS_LANG参数主要用于字符数据传输过程中的转换判断。常见的乱码大致有两种情形：
    （1）汉字变成问号“？”；
当从字符集A 转换成字符集B时，如果转换字符之间不存在对应关系，NLS_LANG使用替代字符“？”替代无法映射的字符
    （2）汉字变成未知字符（虽然有些是汉字，但与原字符含义不同）
转换存在对应关系，但字符集A 中的字符编码与字符集B 中的字符编码代表不同含义

4.2发生乱码原因
    乱码产生是由于几个字符集之间转换不匹配造成，分以下几种情况：
    （注：字符集之间如果不存在子集、超集对应关系时的情况不予考虑，因为这种情况下字符集之间转换必产生乱码）   
    1）服务器端数据库字符集与客户端应用字符集相同，与客户端NLS_LANG参数设置不同
    如果客户端NLS_LANG字符集是其它两种字符集的子集，转换过程将出现乱码。
    解决方法：将三种字符集设置成同一字符集，或NLS_LANG字符集是其它两种字符集的超集
    2）服务器端数据库字符集与客户端NLS_LANG参数设置相同，与客户端应用字符集不同
    如果客户端应用字符集是其它两种字符集的超集时，转换过程将出现乱码，但对于单字节编码存储中文问题，可参看本文第5章节的分析
    3）客户端应用字符集、客户端NLS_LANG参数设置、服务器端数据库字符集互不相同
    此种情况较为复杂，但三种字符集之间只要有不能转换的字符，则必产生乱码

4.3导入/导出过程出现乱码原因
    这个过程存在4个字符集设置，在3.1章节中已分析
   （1）源数据库字符集
   （2）EXP过程中NLS_LANG参数
   （3）IMP过程中NLS_LANG参数
   （4）目标数据库字符集
    出现乱码原因
    1）当源数据库字符集不等于EXP过程中NLS_LANG参数，且源数据库字符集是EXP过程中NLS_LANG的子集，才能保证导出文件正确，其他情况则导出文件字符乱码
    2）EXP过程中NLS_LANG字符集不等于IMP过程中NLS_LANG字符集，且EXP过程中NLS_LANG字符集是IMP过程中NLS_LANG字符集的子级, 才能保证第一次转换正常，否则第一次转换中出现乱码。
    3）如果第一次转换正常，IMP过程中NLS_LANG字符集是目标数据库字符集的子集或相同，才能保证第二次转换正常，否则则第二次转换中出现乱码

五．单字节编码存储中文问题

由于历史的原因，早期的oracle没有中文字符集（如oracle6、oracle7、oracle7.1）,但有的用户从那时起就使用数据库了，并用US7ASCII字符集存储了中文，或是有的用户在创建数据库时，不考虑清楚，随意选择一个默认的字符集，如WE8ISO8859P1或US7ASCII，而这两个字符集都没有汉字编码，虽然有些时候选用这种字符集好象也能正常使用，但用这种字符集存储汉字信息从原则上说就是错误的，它会给数据库的使用与维护带来一系列的麻烦。
    正常情况下，要将汉字存入数据库，数据库字符集必须支持中文，而将数据库字符集设置为US7ASCII等单字节字符集是不合适的。US7ASCII字符集只定义了128个符号，并不支持汉字。另外，如果在SQL*PLUS中能够输入中文，操作系统缺省应该是支持中文的，但如果在NLS_LANG中的字符集设置为US7ASCII，显然也是不正确的，它没有反映客户端的实际情况。但在实际应用中汉字显示却是正确的，这主要是因为Oracle检查数据库与客户端的字符集设置是同样的，那么数据在客户与数据库之间的存取过程中将不发生任何转换，但是这实际上导致了数据库标识的字符集与实际存入的内容是不相符的。而在SELECT的过程中，Oracle同样检查发现数据库与客户端的字符集设置是相同的，所以它也将存入的内容原封不动地传送到客户端，而客户端操作系统识别出这是汉字编码所以能够正确显示。
    在这个例子中，数据库与客户端都没有设置成中文字符集，但却能正常显示中文，从应用的角度看好象没问题。然而这里面却存在着极大的隐患，比如在应用length或substr等字符串函数时，就可能得到意外的结果。
    对于早期使用US7ASCII字符集数据库的数据迁移到oracle8i/9i中（使用zhs16gbk），由于原始数据已经按照US7ASCII格式存储，对于这种情况，可以通过使用Oracle8i的导出工具，设置导出字符集为US7ASCII，导出后使用UltraEdit等工具打开dmp文件，修改第二、三字符，修改 0001 为0354,这样就可以将US7ASCII字符集的数据正确导入到ZHS16GBK的数据库中。

六．结束语

    为了避免在数据库迁移过程中由于字符集不同导致的数据损失，oracle提供了字符集扫描工具（character set scanner），通过这个工具我们可以测试在数据迁移过程中由于字符集转换可能带来的问题，然后根据测试结果，确定数据迁移过程中最佳字符集解决方案。

参考文献
[1]Biju Thomas , Bob Bryla《oracle9i DBA基础I 学习指南》电子工业出版社 2002
[2]网站 http://www.itpub.net

********************************************************************************

原文：http://www.csdb.cn/viewPaper.jsp?tipid=1148536745101

关于Unicode参考：http://fangyuncn.spaces.live.com/blog/cns!29C7193178944F5A!176.entry

• http://vssplugin.sourceforge.net/ 
• http://www.mediafire.com/?4i1tx0dbxm1 , patch for eclipse3.3

•  nocache: Set to "true" if you want the controller to add HTTP headers for defeating caching to every response from this module. [false]

• 方式：实现org.apache.struts.action.PlugIn接口.
• 例如：使用ConvertUtils.register(new SqlDateConverter(null), Date.class);对模块注册自己的Convert. 注意在PlugIn的destroy()时，要恢复原有设置。

4. 项目质量要求

4.1 页面：

• 查询条件保持。
• 提交不成功时，保持所填写内容。
• 避免重复提交

5.  遇到的问题及解决：

5.1 AJAX中文问题：
使用：
    res.setContentType("text/html; charset=UTF-8");
    PrintWriter out = res.getWriter();

5.2 定时器
使用：org.springframework.scheduling.timer包解决.

5.3 两个日期之间的天数
使用：(Date.getTime()-Date.getTime())/(24*60*60*1000)