/**
 * 
 */
package com.cignacmb.jdk8.features.dfa;

import java.util.ArrayList;
import java.util.List;

import junit.framework.TestCase;
import net.sf.json.JSONArray;

import org.apache.commons.lang3.StringUtils;

import com.sun.istack.internal.logging.Logger;

/**
 * 参考：http://blog.csdn.net/chenssy/article/details/26961957 
 * 也可考虑使用：if (text.toLowerCase().contains(key))
 * @author cheney
 * @date 2015年8月8日 下午1:12:21
 */
public class DFATest2 extends TestCase {
	
	private Logger logger = Logger.getLogger(getClass());
	
	public void test2(){
		List<String> keyWordList = this.getKeyWordList();
		
		long start1 = System.currentTimeMillis();
		Node sensitiveWordNode = this.addSensitiveWordToHashMap(keyWordList);
		long end1 = System.currentTimeMillis();
		logger.info("生成敏感词库耗时：" + (end1 - start1));
		
//		logger.info(JSONObject.fromObject(sensitiveWordNode).toString());
		
		long start2, end2;
		List<String> checkSensitiveWordList = this.getCheckSensitiveWordList();
		for (String text : checkSensitiveWordList) {
			start2 = System.currentTimeMillis();
			List<String> sensitiveWordContains = this.checkSensitiveWord(text.toLowerCase(), sensitiveWordNode);
			end2 = System.currentTimeMillis();
			logger.info("deal word: " + text);
			logger.info("包含的敏感词条: " + JSONArray.fromObject(sensitiveWordContains));
			logger.info("匹配耗时：" + (end2 - start2));
		}
	}

	public void test3(){
		List<String> keyWordList = this.getKeyWordList();
		List<String> checkSensitiveWordList = this.getCheckSensitiveWordList();
		
		List<String> sensitiveWordContains = null;
		long start, end, start1, end1;
		start = System.currentTimeMillis();
		for (String text : checkSensitiveWordList) {
			start1 = System.currentTimeMillis();
			sensitiveWordContains = new ArrayList<String>();
			for (String key : keyWordList) {
				if (text.toLowerCase().contains(key)) {
					sensitiveWordContains.add(key);
				}
			}
			end1 = System.currentTimeMillis();
			logger.info("deal word: " + text);
			logger.info("包含的敏感词条: " + JSONArray.fromObject(sensitiveWordContains));
			logger.info("匹配耗时：" + (end1 - start1));
		}
		end = System.currentTimeMillis();
		logger.info("匹配总耗时：" + (end - start));
	}
	
	/**
	 * 从数据库中提取配置的敏感词条
	 * @return
	 */
	private List<String> getKeyWordList(){
		List<String> keyWordList = new ArrayList<String>();
		keyWordList.add("中国");
		keyWordList.add("中间人");
		keyWordList.add("中国人民");
		keyWordList.add("中国男人");
		keyWordList.add("五星红旗");
		keyWordList.add("?");
		keyWordList.add("test");
		keyWordList.add("？");
		keyWordList.add("ces");
		return keyWordList;
	}
	
	/**
	 * 需判断是否包含第三词条的文本
	 * @return
	 */
	private List<String> getCheckSensitiveWordList(){
		List<String> keyWordList = new ArrayList<String>();
		keyWordList.add("中国政府网是政府面向社会的窗口是公众与政府互动的渠道,是中国国务院和国务院各部门,以及各省、自治区、直辖市人民政府在国际互联网上发布政府信息和提供在线服务的综");
		keyWordList.add("地fd?sf");
		keyWordList.add("wdfTESTsdf");
		keyWordList.add("df？不舒服");
		return keyWordList;
	}
	
	/**
	 * 构建敏感词库
	 * @param keyWordList 从数据库中提取配置的敏感词条
	 * @return
	 */
	private Node addSensitiveWordToHashMap(List<String> keyWordList) {
		if (null == keyWordList) {
			return null;
		}
		// 虚拟敏感词库空节点
		Node rootNode = new Node();
		
		Node curNode = null;
		String nodeValue = null;
		Node tempNode = null;
		for (String key : keyWordList) {
			if (StringUtils.isBlank(key)) {
				continue;
			}
			curNode = rootNode;
			for (int i = 0; i < key.length(); i++) {
				nodeValue = String.valueOf(key.charAt(i));
				tempNode = null;
				if (i == key.length() - 1) {
					tempNode = new Node(String.valueOf(nodeValue), true);
				} else {
					tempNode = new Node(String.valueOf(nodeValue));
				}
				curNode = curNode.addChild(tempNode);
			}
		}
		return rootNode;
	}
	
	/**
	 * 检查文字中是否包含敏感词条
	 * @param text
	 * @param sensitiveWordMap
	 * @return
	 *   返回文本中包含的所有第三词条
	 */
	private List<String> checkSensitiveWord(String text, Node node){
		if (StringUtils.isBlank(text)) {
			return null;
		}
		List<String> sensitiveWordContains = new ArrayList<String>();
		for (int i = 0; i < text.length(); i++) {
			for (Node node2 : node.getChildren()) {
				if (String.valueOf(text.charAt(i)).equals(node2.getValue())) {
					if (node2.isEnd()) {
						sensitiveWordContains.add(node2.getWord());
					} else if(text.length() > 1) {
						sensitiveWordContains.addAll(this.check(text.substring(i + 1), node.getChildren()));
					}
				}
			}
		}
		return sensitiveWordContains;
	}
	
	private List<String> check(String text, List<Node> list){
		List<String> sensitiveWordContains = new ArrayList<String>();
		List<Node> tempNodeList = list;
		for (Node node : tempNodeList) {
			logger.info(String.format("char/node value = %s/ %s", String.valueOf(text.charAt(0)), node.getValue()));
			if (String.valueOf(text.charAt(0)).equals(node.getValue())) {
				if (node.isEnd()) {
					sensitiveWordContains.add(node.getWord());
				} else {
					if (text.length() > 1) {
						sensitiveWordContains.addAll(check(text.substring(1), node.getChildren()));
					}
				}
			}
		}
		return sensitiveWordContains;
	}
}

/**
 * 
 */
package com.cignacmb.jdk8.features.dfa;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import junit.framework.TestCase;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import org.apache.commons.lang3.StringUtils;

import com.sun.istack.internal.logging.Logger;

/**
 * 参考：http://blog.csdn.net/chenssy/article/details/26961957
 * @author cheney
 * @date 2015年8月8日 上午10:37:33
 */
public class DFATest extends TestCase {
	
	private Logger logger = Logger.getLogger(getClass());
	
	public void test1(){
		List<String> keyWordList = this.getKeyWordList();
		
		long start1 = System.currentTimeMillis();
		Map<String, Node> sensitiveWordMap = this.addSensitiveWordToHashMap(keyWordList);
		long end1 = System.currentTimeMillis();
		logger.info("生成敏感词库耗时：" + (end1 - start1));
		
		logger.info(JSONObject.fromObject(sensitiveWordMap).toString());
		
		List<String> checkSensitiveWordList = this.getCheckSensitiveWordList();
		
		long start2, end2;
		for (String text : checkSensitiveWordList) {
			start2 = System.currentTimeMillis();
			List<String> sensitiveWordContains = this.checkSensitiveWord(text.toLowerCase(), sensitiveWordMap);
			end2 = System.currentTimeMillis();
			logger.info("deal word: " + text);
			logger.info("包含的敏感词条: " + JSONArray.fromObject(sensitiveWordContains));
			logger.info("匹配耗时：" + (end2 - start2));
		}
	}
	
	/**
	 * 从数据库中提取配置的敏感词条
	 * @return
	 */
	private List<String> getKeyWordList(){
		List<String> keyWordList = new ArrayList<String>();
		keyWordList.add("中国");
		keyWordList.add("中间人");
		keyWordList.add("中国人民");
		keyWordList.add("中国男人");
		keyWordList.add("五星红旗");
		keyWordList.add("?");
		keyWordList.add("test");
		keyWordList.add("？");
		keyWordList.add("ces");
		return keyWordList;
	}
	
	/**
	 * 需判断是否包含第三词条的文本
	 * @return
	 */
	private List<String> getCheckSensitiveWordList(){
		List<String> keyWordList = new ArrayList<String>();
		keyWordList.add("中国政府网是政府面向社会的窗口是公众与政府互动的渠道,是中fs国国务院和国务院各部门,以及各省、自治区、直辖市人民政府在国际互联网上发布政府信息和提供在线服务的综");
		keyWordList.add("地fd?sf");
		keyWordList.add("wdfTESTsdf");
		keyWordList.add("df？不舒服");
		return keyWordList;
	}
	
	/**
	 * 构建敏感词库
	 * @param keyWordList 从数据库中提取配置的敏感词条
	 * @return
	 */
	private Map<String, Node> addSensitiveWordToHashMap(List<String> keyWordList) {
		if (null == keyWordList) {
			return null;
		}
		// 初始化敏感词容器，减少扩容操作
		Map<String, Node> sensitiveWordMap = new HashMap<String, Node>(keyWordList.size());
		
		Node firstFloorNode = null;
		for (String key : keyWordList) {
			if (StringUtils.isBlank(key)) {
				continue;
			}
			char firstFloorKeyChar = key.charAt(0);
			String firstFloorKey = String.valueOf(firstFloorKeyChar);
			firstFloorNode = sensitiveWordMap.get(firstFloorKey);
			if(null == firstFloorNode){
				firstFloorNode = new Node(firstFloorKey);
			}
			
			if (key.length() == 1) {
				firstFloorNode.setEnd(true);
			} else {
				Node curNode = firstFloorNode;
				for (int i = 1; i < key.length(); i++) {
					Node node = null;
					if (i == key.length() - 1) {
						node = new Node(String.valueOf(key.charAt(i)), true);
					} else {
						node = new Node(String.valueOf(key.charAt(i)));
					}
					curNode = curNode.addChild(node);
				}
			}
			sensitiveWordMap.put(firstFloorKey, firstFloorNode);
		}
		return sensitiveWordMap;
	}
	
	/**
	 * 检查文字中是否包含敏感词条
	 * @param text
	 * @param sensitiveWordMap
	 * @return
	 *   返回文本中包含的所有第三词条
	 */
	private List<String> checkSensitiveWord(String text, Map<String, Node> sensitiveWordMap){
		List<String> sensitiveWordContains = null;
		if (StringUtils.isBlank(text)) {
			return sensitiveWordContains;
		}
		sensitiveWordContains = new ArrayList<String>();
		for (int i = 0; i < text.length(); i++) {
			String key = String.valueOf(text.charAt(i));
			Node node = sensitiveWordMap.get(key);
			if (null == node) {
				continue;
			}
			if(node.isEnd()){
				// 已匹配上
//				logger.info("1-已匹配上敏感词条: " + node.getWord());
				sensitiveWordContains.add(node.getWord());
				break;
			}
			sensitiveWordContains.addAll(this.check(text.substring(i+1), node.getChildren()));
		}
		return sensitiveWordContains;
	}
	
	private List<String> check(String text, List<Node> list){
		List<String> sensitiveWordContains = new ArrayList<String>();
		List<Node> tempNodeList = list;
		for (Node node : tempNodeList) {
			if (String.valueOf(text.charAt(0)).equals(node.getValue())) {
				if (node.isEnd()) {
					sensitiveWordContains.add(node.getWord());
					// return sensitiveWordContains;
				} else {
					if (text.length() > 1) {
						sensitiveWordContains.addAll(check(text.substring(1), node.getChildren()));
					}
				}
			}
		}
		return sensitiveWordContains;
	}
}



/******************************************************************************************/

/**
 * 
 */
package com.cignacmb.jdk8.features.dfa;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.StringUtils;

/**
 * @author cheney
 * @date 2015年8月8日 上午11:41:02
 */
public class Node {

	private String value = null;
	private boolean end = false;
	private List<Node> children = new ArrayList<Node>();
	/**
	 * 到当前节点时，敏感词条内容
	 */
	private StringBuffer buffer = new StringBuffer();

	public Node() {
	}

	public Node(String value) {
		this.value = value;
	}

	public Node(String value, boolean end) {
		this.value = value;
		this.end = end;
	}

	public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}

	public boolean isEnd() {
		return end;
	}

	public void setEnd(boolean end) {
		this.end = end;
	}

	public List<Node> getChildren() {
		return children;
	}

	public StringBuffer getBuffer() {
		if (StringUtils.isBlank(this.buffer.toString())) {
			if (StringUtils.isNotBlank(this.getValue())) {
				buffer.append(this.getValue());
			}
		}
		return buffer;
	}

	public void setBuffer(StringBuffer buffer) {
		this.buffer = buffer;
	}
	
	public String getWord() {
		if (StringUtils.isBlank(this.buffer.toString())) {
			if (StringUtils.isNotBlank(this.getValue())) {
				buffer.append(this.getValue());
			}
		}
		return this.buffer.toString();
	}

	/**
	 * @param child
	 * @return
	 *  返回当前添加的节点
	 */
	public Node addChild(Node child) {
		for (int i = 0; i < children.size(); i++) {
			if (children.get(i).getValue().equals(child.getValue())) {
				if (child.isEnd()) {
					children.get(i).setEnd(true);
				}
				return children.get(i);
			}
		}
		StringBuffer bufferTemp = new StringBuffer();
		bufferTemp.append(this.getBuffer());
		bufferTemp.append(child.getValue());
		child.setBuffer(bufferTemp);
		this.children.add(child);
		return child;
	}

}

' 产品定义平台基础数据格式转换
Sub transferData()
    Dim orgDataSheetName As String, newDataSheetName As String
    orgDataSheetName = "女性"
    newDataSheetName = "sheet_2"
    
    Dim newSheetStartRow As Integer
    newSheetStartRow = 1
    
    ActiveWorkbook.Worksheets.Add(after:=ActiveWorkbook.Worksheets(ActiveWorkbook.Worksheets.Count)).Name = newDataSheetName
    
    Set factorsRange = Worksheets(orgDataSheetName).Range("B6:B43")
    ' 保单年度
    Set ContYearRange = Worksheets(orgDataSheetName).Range("C5:L5")
    
    Dim i
    Dim factorsRangeRows, factorsRangeCols
    factorsRangeRows = factorsRange.Rows.Count
    factorsRangeCols = factorsRange.Columns.Count
    
    Dim ContYearRangeCols
    ContYearRangeCols = ContYearRange.Columns.Count
        
    For i = 1 To factorsRangeRows
        ' 复制左侧因子
        Worksheets(orgDataSheetName).Select
        Range(Cells(i + factorsRange.Row - 1, factorsRange.Column), Cells(i + factorsRange.Row - 1, factorsRangeCols + factorsRange.Column - 1)).Select
        Selection.Copy
        
        Worksheets(newDataSheetName).Select
        Range(Cells(newSheetStartRow, 1), Cells(newSheetStartRow + ContYearRangeCols - 1, factorsRangeCols)).Select

        Selection.PasteSpecial Paste:=xlPasteValues, Operation:=xlNone, SkipBlanks _
            :=False, Transpose:=False
        
        ' 复制保单年度，需转置
        Worksheets(orgDataSheetName).Select
        ContYearRange.Select
        Selection.Copy
        
        Worksheets(newDataSheetName).Select
        Range(Cells(newSheetStartRow, factorsRangeCols + 1), Cells(newSheetStartRow + ContYearRangeCols - 1, factorsRangeCols + 1)).Select
        Selection.PasteSpecial Paste:=xlPasteAll, Operation:=xlNone, SkipBlanks:= _
            False, Transpose:=True
        
        ' 复制费率，需转置
        Worksheets(orgDataSheetName).Select
        Range(Cells(ContYearRange.Row + i, ContYearRange.Column), Cells(ContYearRange.Row + i, ContYearRange.Column + ContYearRange.Columns.Count - 1)).Select
        Selection.Copy
        
        Worksheets(newDataSheetName).Select
        Range(Cells(newSheetStartRow, factorsRangeCols + 2), Cells(newSheetStartRow + ContYearRangeCols - 1, factorsRangeCols + 2)).Select
        Selection.PasteSpecial Paste:=xlPasteAll, Operation:=xlNone, SkipBlanks:= _
            False, Transpose:=True
        
        newSheetStartRow = newSheetStartRow + ContYearRangeCols
    Next
    
End Sub

Bean Validation技术实现对Javabean的校验
http://henu-zhangyang.iteye.com/blog/2231893

Spring3.1 对Bean Validation规范的新支持(方法级别验证)
http://jinnianshilongnian.iteye.com/blog/1495594

Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC
http://jinnianshilongnian.iteye.com/blog/1990081

'******************************************************************************
'* 在pd中，shift+ctrl+X，打开脚本运行

'* File:     pdm2excel.txt

'* Title:    pdm export to excel

'* Purpose:  To export the tables and columns to Excel

'* Model:    Physical Data Model

'* Objects:  Table, Column, View

'* Author:   ziyan

'* Created:  2012-05-03

'* Version:  1.0

'******************************************************************************

Option Explicit

   Dim rowsNum

   rowsNum = 0

'-----------------------------------------------------------------------------

' Main function

'-----------------------------------------------------------------------------

' Get the current active model

Dim Model

Set Model = ActiveModel

If (Model Is Nothing) Or (Not Model.IsKindOf(PdPDM.cls_Model)) Then

  MsgBox "The current model is not an PDM model."

Else

 ' Get the tables collection

 '创建EXCEL APP

 dim beginrow

 DIM EXCEL, SHEET

 set EXCEL = CREATEOBJECT("Excel.Application")

 EXCEL.workbooks.add(-4167)'添加工作表

 EXCEL.workbooks(1).sheets(1).name ="test"

 set sheet = EXCEL.workbooks(1).sheets("test")

 

 ShowProperties Model, SHEET

 EXCEL.visible = true

 '设置列宽和自动换行

 sheet.Columns(1).ColumnWidth = 20 

 sheet.Columns(2).ColumnWidth = 40 

 sheet.Columns(4).ColumnWidth = 20 

 sheet.Columns(5).ColumnWidth = 20 

 sheet.Columns(6).ColumnWidth = 15 

 sheet.Columns(1).WrapText =true

 sheet.Columns(2).WrapText =true

 sheet.Columns(4).WrapText =true

 End If

'-----------------------------------------------------------------------------

' Show properties of tables

'-----------------------------------------------------------------------------

Sub ShowProperties(mdl, sheet)

   ' Show tables of the current model/package

   rowsNum=0

   beginrow = rowsNum+1

   ' For each table

   output "begin"

   Dim tab

   For Each tab In mdl.tables

      ShowTable tab,sheet

   Next

   if mdl.tables.count > 0 then

        sheet.Range("A" & beginrow + 1 & ":A" & rowsNum).Rows.Group

   end if

   output "end"

End Sub

'-----------------------------------------------------------------------------

' Show table properties

'-----------------------------------------------------------------------------

Sub ShowTable(tab, sheet)

   If IsObject(tab) Then

     Dim rangFlag

     rowsNum = rowsNum + 1

      ' Show properties

      Output "================================"

      sheet.cells(rowsNum, 1) = "实体名"

      sheet.cells(rowsNum, 2) =tab.name

      sheet.cells(rowsNum, 3) = ""

      sheet.cells(rowsNum, 4) = "表名"

      sheet.cells(rowsNum, 5) = tab.code

      sheet.Range(sheet.cells(rowsNum, 5),sheet.cells(rowsNum, 6)).Merge

      rowsNum = rowsNum + 1

      sheet.cells(rowsNum, 1) = "属性名"

      sheet.cells(rowsNum, 2) = "说明"

      sheet.cells(rowsNum, 3) = ""

      sheet.cells(rowsNum, 4) = "字段中文名"

      sheet.cells(rowsNum, 5) = "字段名"

      sheet.cells(rowsNum, 6) = "字段类型"

      '设置边框

      sheet.Range(sheet.cells(rowsNum-1, 1),sheet.cells(rowsNum, 2)).Borders.LineStyle = "1"

      sheet.Range(sheet.cells(rowsNum-1, 4),sheet.cells(rowsNum, 6)).Borders.LineStyle = "1"

Dim col ' running column

Dim colsNum

colsNum = 0

      for each col in tab.columns

        rowsNum = rowsNum + 1

        colsNum = colsNum + 1

      sheet.cells(rowsNum, 1) = col.name

      sheet.cells(rowsNum, 2) = col.comment

        sheet.cells(rowsNum, 3) = ""

      sheet.cells(rowsNum, 4) = col.name

      sheet.cells(rowsNum, 5) = col.code

      sheet.cells(rowsNum, 6) = col.datatype

      next

      sheet.Range(sheet.cells(rowsNum-colsNum+1,1),sheet.cells(rowsNum,2)).Borders.LineStyle = "2"       

      sheet.Range(sheet.cells(rowsNum-colsNum+1,4),sheet.cells(rowsNum,6)).Borders.LineStyle = "2"

      rowsNum = rowsNum + 1

      

      Output "FullDescription: "       + tab.Name

   End If

End Sub

.dotx,application/vnd.openxmlformats-officedocument.wordprocessingml.template 
.docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document 
.xlsx,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet 
.pptx,application/vnd.openxmlformats-officedocument.presentationml.presentation 

.doc,application/msword
.dot,application/msword 
.xls,application/vnd.ms-excel

示例参考：
http://blog.csdn.net/zclandzzq/article/details/7055552

此方式依赖客户端，若客户端安装版本跟设置的不一致，则会提示下载。

一、服务器先转换为PDF，再转换为SWF，最后通过网页加载Flash预览

微软方：利用Office2007以上版本的一个PDF插件SaveAsPDFandXPS.exe可以导出PDF文件，然后再利用免费的swftools.exe工具生成swf格式的Flash文件，网页中加载flexpaper免费开源工具（有广告）实现Flash文件的预览。
优点：
1、有效的保护的源文件及文件的复制，不可复制也是缺点。
2、源码是自己的，版权有保证。
缺点：
1、服务器上必须安装Office软件。
2、导出PDF文件本身是个打印过程，Excel页面格式未设置，会出现一张表格打印出多页来，阅读体验大大下降。
3、转换过程非常耗费资源，低配的CPU几乎能跑满，服务器卡死。转换时间也非常漫长，这个时间主要是卡在了转换PDF上面。
4、转换完成服务器会遗留大量Excel、Word进程无法正常退出，有一些折中的解决办法，可以在网上搜索。
5、设置非常麻烦，本身微软官方的说法Office软件是客户端程序，在与IIS交互的时候本身就未设计。所以很多程序员把精力浪费在了调试程序上面。有两点在调试的时候需要注意。一个是在web.config中设置 <identity impersonate="true" userName="administrator" password="你的服务器管理员密码" />，一个是在Office软件的设置中设置跟桌面交互。
6、严重浪费磁盘空间，一个文件还需要一个PDF文件、一个SWF文件，是否每次都转换，纠结是要硬盘空间呢还是要CPU的资源。
参考链接：
http://www.cnblogs.com/expectszc/archive/2012/04/04/2432149.html 
http://www.cnblogs.com/liuning8023/archive/2013/03/04/2943482.html 
http://www.cxyclub.cn/n/29549/ 
非微软方：没有微软的Office软件可安装，只能用第三方的openoffice（开源、免费）来转换PDF文件，其它方面都一样，优缺点一样
参考链接：
http://blog.csdn.net/z69183787/article/details/17468039 
二、Office文档直接转换为SWF，通过网页加载Flash预览

利用flashpaper直接转换为SWF文件（虚拟打印机），然后利用flexpaper预览Flash文件。
flashpaper是Macromedia的一款产品，随着被Adobe公司收购，Macromedia对于这款软件早就放弃了，国内尚无人在程序中调试成功过。
参考链接：
http://www.dzwebs.net/1149.html 
三、office转Html、pdf转图片在线预览文件Html文件

利用DCOM配置直接操作Office文件，读取文件内容，导出Html文件
优点：
实践证明此方法不科学。
缺点：
1、服务器上必须安装Office软件。
2、配置麻烦，正如微软所说，读取Office不是这么干的。
3、转换的文件格式均丢失。
4、仅限于IIS服务器，利用ASP.net（C#）。
参考链接：
http://www.cnblogs.com/tangbinblog/archive/2012/11/29/2794110.html 
四、第三方ActiveX浏览器控件

如科瀚的SOAOffice中间件、卓正软件的pageoffice控件、WebOffice控件、国外的Office Viewer ActiveX Control
优点：
可在线编辑等。
缺点：
1、客户端需安装控件。
2、付费。
3、在Html5、CSS3以及桌面向浏览器转换的大潮流下，控件已是昨日黄花。
参考链接：
http://www.kehansoft.com/soaoffice/index.htm 
http://www.zhuozhengsoft.com/ 
http://www.officectrl.com/ 
http://www.anydraw.com/ 
五、微软的Office365

微软新出的在线文档，与Google文档抗衡，估计没谷歌文档，微软也懒得出这个
优点：
微软自家的东西原生态呈现。
缺点：
加载文件较多，各种图片、文字、样式、JQuery等，页面臃肿，加载速度慢，不适合手机预览
需要微软的批量许可（即授权），硬件投入方面：架设一台单独的服务器（可以是虚拟机），配置过低能安装，但无法运行，另外还需一台域服务器。而这两台机器上均不能安装其它程序，比如SQLServer，在Office365服务器上每次重启IIS会重置，也就是说你不能有任何其它网站。其主要是用来与SharePoint搭配使用。
参考链接：
http://technet.microsoft.com/zh-cn/library/jj219456(v=office.15).aspx 
六、第三方成熟的服务

如OfficeWeb365
优点：
1、OfficeWeb365采用适合中文排版的纯Html、CSS技术。
2、接口简单，适合PHP、JSP、ASP.net等所有的对接，省心省力。
3、费用低廉，节省投入。
4、不用关心客户端是否安装了Office软件，不用在客户端部署。
5、手机在线预览2页Word文档只有3K大小，且格式保留，领先全球的中文在线预览技术。
6、支持国产的金山WPS，这在国内尚属首列。
缺点：
1、OfficeWeb365只能查看不能编辑，目前在线编辑版的正在开发。
参考链接：
http://www.officeweb365.com 
七、在浏览器中直接打开

通过设置MiME类型，告诉浏览器这是Office文件，浏览器直接调用本地Office或PDF软件打开
优点：
1、不用编程，不用第三方服务，直截了当。
2、很多用户安装了Adobe的PDF预览软件，同时在浏览器上也直接安装了插件，浏览器可直接查看PDF文件。
缺点
你永远不知道客户机器上是否安装了Office软件，虽然几乎都安装了，但直接调用Office软件，客户体验大大下降，更何况还有个讨厌的迅雷一直在监视你的浏览器，不给你打开的机会，当然这些都是你无法预知的。
八、其它

如金山快写、一些网盘的预览
参考链接：
http://w.wps.cn/ 

public class POITest extends TestCase {

	String path = "D:\\code\\cigna\\lis\\sorcecode\\ui\\banktest\\PMLE001（招商信诺永享康健两全保险）\\RATE_PMLE001_PMLE001298_1.xlsx";
	
	public void testXSSFSaxAPI() throws IOException, OpenXML4JException,
			SAXException {
		OPCPackage pkg = OPCPackage.open(path);
		XSSFReader r = new XSSFReader(pkg);
		SharedStringsTable sst = r.getSharedStringsTable();

		XMLReader parser = XMLReaderFactory
				.createXMLReader("org.apache.xerces.parsers.SAXParser");
		RateCVDataHandler handler = new RateCVDataHandler(sst);
		parser.setContentHandler(handler);

		Iterator<InputStream> sheets = r.getSheetsData();
		while (sheets.hasNext()) {
			System.out.println("Processing new sheet:\n");
			InputStream sheet = sheets.next();
			InputSource sheetSource = new InputSource(sheet);
			parser.parse(sheetSource);
			sheet.close();
//			System.out.println("");
			break;
		}
		List<List<String>> rows = handler.getRows();
		if (null == rows) {
			System.out.println("null ....");
		} else {
			for (List<String> list : rows) {
				for (String string : list) {
					System.out.print(string + "\t");
				}
				System.out.println();
			}
		}
	}

}


/*********************************************************************/
/*********************************************************************/
/*********************************************************************/
/**
 * 
 */
package com.cignacmb.productdef.converter;

import java.util.LinkedList;
import java.util.List;

import org.apache.poi.xssf.model.SharedStringsTable;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

/**
 * 参考：<br>
 * 解决POI读取Excel内存溢出的问题<br>
 * http://blog.csdn.net/lishengbo/article/details/40711769<br>
 * <br>
 * The New Halloween Document<br>
 * http://poi.apache.org/spreadsheet/how-to.html#xssf_sax_api<br>
 * @author c1panx
 * @ 2015年6月25日  下午4:43:33
 */
public class RateCVDataHandler extends DefaultHandler {

	private SharedStringsTable sst;
	private boolean nextIsString;
	private String lastContents;
	
	/** 临时保留行记录 */
	private List<String> record = null;
	/** 所有记录 */
	private List<List<String>> rows = null;

	public RateCVDataHandler(SharedStringsTable sst){
		this.sst = sst;
		record = new LinkedList<String>();
		rows = new LinkedList<List<String>>();
	}

	public void startElement(String uri, String localName, String name,
			Attributes attributes) throws SAXException {
		// c => cell
		if (name.equals("c")) {
			String cellType = attributes.getValue("t");
			if ("s".equals(cellType)) {
				nextIsString = true;
			} else {
				nextIsString = false;
			}
		}
		// Clear contents cache
		lastContents = "";
	}
	
	public void endElement(String uri, String localName, String name)
			throws SAXException {
		if(nextIsString) {
			int idx = Integer.parseInt(lastContents);
			lastContents = new XSSFRichTextString(sst.getEntryAt(idx)).toString();
			nextIsString = false;
		}
		// v => contents of a cell
		// Output after we've seen the string contents
		if(name.equals("v")) {
//			System.out.print(lastContents + "\t");
			record.add(lastContents);
		}
		if ("row".equals(name)) {
			rows.add(record);
			record = new LinkedList<String>();
//			System.out.println();
		}
	}
	
	public void characters(char[] ch, int start, int length)
			throws SAXException {
		lastContents += new String(ch, start, length);
	}
	
	public List<List<String>> getRows() {
		return rows;
	}
}

	public void testXStreamDBTypeMapContext(){
		DBTypeMapContext typeMapContext = new DBTypeMapContext();
		typeMapContext.setDbtype("oracle");
		
		List<DBTypeMapModel> list = new ArrayList<DBTypeMapModel>();
		for (int i = 0; i < 4; i++) {
			DBTypeMapModel dbTypeMapModel = new DBTypeMapModel();
			dbTypeMapModel.setJdbcType("CHAR");
			dbTypeMapModel.setJavaType("java.lang.String");
			dbTypeMapModel.setPattern("fdafd");
			list.add(dbTypeMapModel);
		}
		typeMapContext.setList(list);
		
		List<DBTypeMapContext> contextList = new ArrayList<DBTypeMapContext>();
		contextList.add(typeMapContext);
		
		XStream xStream = new XStream();
		xStream.registerConverter(new DBTypeMapContextConverter());
		xStream.alias("typemap", List.class);
		xStream.alias("context", DBTypeMapContext.class);
		
		System.out.println(xStream.toXML(contextList));

		Object obj = xStream.fromXML(getClass().getResourceAsStream("/system-config/dbtype-map.xml"));
		System.out.println(obj);
		
		@SuppressWarnings("unchecked")
		List<DBTypeMapContext> contextList2 = (List<DBTypeMapContext>) obj;
		System.out.println(xStream.toXML(contextList2));
	}


/***********************************************************************************
 * 
 **********************************************************************************/
package com.cignacmb.productdef.converter;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.apache.log4j.Logger;

import com.cignacmb.productdef.model.DBTypeMapContext;
import com.cignacmb.productdef.model.DBTypeMapModel;
import com.thoughtworks.xstream.converters.Converter;
import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;

/**
 * XStream  DBTypeMapContext自定义转换器
 * @author c1panx
 * @ 2015年6月19日  下午5:33:32
 */
public class DBTypeMapContextConverter implements Converter {
	
	private Logger logger = Logger.getLogger(getClass());

	@Override
	@SuppressWarnings("rawtypes")
	public boolean canConvert(Class clazz) {
		return clazz.equals(DBTypeMapContext.class);
	}

	@Override
	public void marshal(Object obj, HierarchicalStreamWriter writer,
			MarshallingContext context) {
		logger.debug("Object obj: " + obj);
		if (obj instanceof DBTypeMapContext == false) {
			return;
		}
		DBTypeMapContext typeMapContext = (DBTypeMapContext) obj;
		writer.addAttribute("dbtype", typeMapContext.getDbtype());
		
		List<DBTypeMapModel> list = typeMapContext.getList();
		if (null != list) {
			for (DBTypeMapModel dbTypeMapModel : list) {
				writer.startNode("item");
				writer.addAttribute("jdbcType", dbTypeMapModel.getJdbcType());
				writer.addAttribute("javaType", dbTypeMapModel.getJavaType());
				if (StringUtils.isNotBlank(dbTypeMapModel.getPattern())) {
					writer.addAttribute("pattern", dbTypeMapModel.getPattern());
				}
				writer.endNode();
			}
		}
	}

	@Override
	public Object unmarshal(HierarchicalStreamReader reader,
			UnmarshallingContext context) {
		logger.debug("start unmarshal ... ");
		DBTypeMapContext typeMapContext = new DBTypeMapContext();
		typeMapContext.setDbtype(trim(reader.getAttribute("dbtype")));

		List<DBTypeMapModel> list = new ArrayList<DBTypeMapModel>();
		while (reader.hasMoreChildren()) {
			reader.moveDown();
			DBTypeMapModel typeMapModel = new DBTypeMapModel();
			typeMapModel.setJdbcType(trim(reader.getAttribute("jdbcType")));
			typeMapModel.setJavaType(trim(reader.getAttribute("javaType")));
			typeMapModel.setPattern(trim(reader.getAttribute("pattern")));
			list.add(typeMapModel);
			reader.moveUp();
		}
		typeMapContext.setList(list);
		logger.debug("end unmarshal ... ");
		return typeMapContext;
	}
	
	private String trim(String value) {
		return null == value ? null : value.trim();
	}
	
}




/***********************************************************************************
 * 
 **********************************************************************************/
package com.cignacmb.productdef.model;

import java.util.List;

import org.apache.commons.lang3.StringUtils;

/**
 * jdbcType && javaType映射关系上下文件，针对特定类型的数据库
 * @author c1panx
 * @ 2015年6月19日  下午5:20:17
 */
public class DBTypeMapContext {

	private String dbtype;
	private List<DBTypeMapModel> list;

	public String getDbtype() {
		return dbtype;
	}

	public void setDbtype(String dbtype) {
		this.dbtype = dbtype;
	}

	public List<DBTypeMapModel> getList() {
		return list;
	}

	public void setList(List<DBTypeMapModel> list) {
		this.list = list;
	}
	
	public DBTypeMapModel getTypeMap(String jdbcType) {
		if (StringUtils.isBlank(jdbcType) || null == list) {
			return null;
		}
		for (DBTypeMapModel dbTypeMapModel : list) {
			if (jdbcType.equalsIgnoreCase(dbTypeMapModel.getJdbcType())) {
				return dbTypeMapModel;
			}
		}
		return null;
	}

}


/***********************************************************************************
 * 
 **********************************************************************************/
package com.cignacmb.productdef.model;


/**
 * jdbcType && javaType映射关系
 * @author c1panx
 * @ 2015年6月19日  下午5:12:37
 */
public class DBTypeMapModel {

	private String jdbcType;
	private String javaType;
	private String pattern;

	public String getJdbcType() {
		return jdbcType;
	}

	public void setJdbcType(String jdbcType) {
		this.jdbcType = jdbcType;
	}

	public String getJavaType() {
		return javaType;
	}

	public void setJavaType(String javaType) {
		this.javaType = javaType;
	}

	public String getPattern() {
		return pattern;
	}

	public void setPattern(String pattern) {
		this.pattern = pattern;
	}

}


/***********************************************************************************
 * dbtype-map.xml
 **********************************************************************************/
<?xml version="1.0" encoding="UTF-8"?>
<typemap>
	<context dbtype="oracle">
		<item jdbcType="CHAR" javaType="java.lang.String" pattern="123"/>
		<item jdbcType="VARCHAR2" javaType="java.lang.String" pattern="dfaf"/>
	</context>
</typemap>

USE [quote_cn]
GO

/****** Object:  StoredProcedure [dbo].[OutputData]    Script Date: 06/18/2015 09:52:25 ******/
SET ANSI_NULLS ON
GO

SET QUOTED_IDENTIFIER ON
GO

/**
 * 参数：表名
 * 输出：指定表下所有记录的insert语句
 */
CREATE PROCEDURE [dbo].[OutputData]     
@tablename   sysname     
AS     
declare    @column   varchar(1000)     
declare    @columndata   varchar(1000)     
declare    @sql   varchar(4000)     
declare    @xtype   tinyint     
declare    @name   sysname     
declare    @objectId   int     
declare    @objectname   sysname     
declare    @ident   int     

set    nocount    on     
set    @objectId=object_id(@tablename)     
if @objectId   is    null    --   判断对象是否存在     
   begin     
      print @tablename + '对象不存在'     
      return     
    end      set @objectname=rtrim(object_name(@objectId))     
if @objectname is null or charindex(@objectname,@tablename)=0
    begin     
      print @tablename + '对象不在当前数据库中'      
      return     
    end        if OBJECTPROPERTY(@objectId,'IsTable')   <   >   1   --   判断对象是否是表     
    begin     
      print @tablename + '对象不是表'     
      return     
    end        select    @ident=status&0x80   from    syscolumns   where    id=@objectid   and    status&0x80=0x80          if @ident is    not    null     
    print    'SET   IDENTITY_INSERT   '+ @TableName + '   ON'     --定义游标，循环取数据并生成Insert语句
declare syscolumns_cursor cursor for 
    select    c.name,c.xtype   from    syscolumns   c     
      where    c.id=@objectid     
      order    by    c.colid     --打开游标
open    syscolumns_cursor     
set @column=''     
set @columndata=''     
fetch    next    from    syscolumns_cursor   into    @name,@xtype     
while    @@fetch_status   <> -1     
    begin     
    if    @@fetch_status   <> -2     
      begin     
      if    @xtype   not    in(189,34,35,99,98)   --timestamp不需处理，image,text,ntext,sql_variant 暂时不处理     
        begin     
        set    @column=@column + 
          case    when    len(@column)=0   then ''  
                 else    ','
                 end + @name     
        set    @columndata = @columndata + 
          case    when    len(@columndata)=0   then    ''   
                 else    ','','','
                 end + 
          case    when @xtype   in(167,175) then    '''''''''+'+@name+'+'''''''''                --varchar,char     
                 when    @xtype   in(231,239)   then    '''N''''''+'+@name+'+'''''''''             --nvarchar,nchar     
                 when    @xtype=61   then    '''''''''+convert(char(23),'+@name+',121)+'''''''''   --datetime     
                 when    @xtype=58   then    '''''''''+convert(char(16),'+@name+',120)+'''''''''   --smalldatetime     
                   when    @xtype=36   then    '''''''''+convert(char(36),'+@name+')+'''''''''       --uniqueidentifier     
                 else    @name   
                 end     
        end     
      end     
    fetch    next    from    syscolumns_cursor   into    @name,@xtype     
    end     
close    syscolumns_cursor     
deallocate    syscolumns_cursor          set @sql='set   nocount   on   select   ''insert   '+@tablename+'('+@column+')   values(''as  ''--'','+@columndata+','')''   from   '+@tablename         print    '--'+@sql     
exec(@sql)         
if    @ident   is    not    null     
print 'SET   IDENTITY_INSERT   '+@TableName+'   OFF'

GO

/** 
 * 依赖样式：icon-help（easyui icon.css中） 
 * .icon-help{ 
 *  background:url('icons/help.png') no-repeat center center; 
 * } 
 */
(function($) {  
    $.fn.extend({  
        /** 
         * 制作帮助信息<br>
         * 基于保单范围内，也可是其他指定范围，在指定控件位置后（以内嵌方式）显示帮助图标，鼠标移入后显示帮助信息<br>
         * 页面布局动态变化时，容易出现错位现象，通过setInterval()监控重新设置位置
         * @param json
         */  
        helptip: function(json){
        	var pairs = {};
        	for(var key in json){
        		var $target = $(this).find("input[name='" + key + "']").parent();
        		var $helpTip = $("<div name='_helptips' class='icon-help'> </div>");
        		$("body").append($helpTip);
        		$helpTip.css({
        			cursor: 'pointer',
        			position: 'absolute',
        			display: 'none',
        			height: 22,
        			width: 18
        		});
        		$target.width($target.width() - $helpTip.width());
        		
        		$helpTip.tooltip({
        			position : 'right',
        			content : '<span style="color:#fff">' + json[key].description + '</span>',
        			onShow : function() {
        				$(this).tooltip('tip').css({
        					backgroundColor : '#666',
        					borderColor : '#666'
        				});
        			}
        		});
        		pairs[key] = {target:$target, helpTip:$helpTip};
        	}
        	setInterval(function(){
        		for(var key in pairs){
        			if(pairs[key].target.is(":visible")){
            			pairs[key].helpTip.show('fast').offset({
            				left:pairs[key].target.offset().left + pairs[key].target.width() + 4,
            				top: pairs[key].target.offset().top
            			});
        			} else {
        				pairs[key].helpTip.hide();
        			}
        		}
        	}, 100);
        }
    });
})(jQuery);


// 调用示例
$(document).ready(function(){
	var helpTipsJSON = {
			risktype:{name:"", description:"L--寿险 A--意外险 H--健康险"},
			riskprop:{name:"", description:"L--长险(Long)、M--一年期险(Middle)、S--极短期险(Short)"},
	};
	$("#defLMRiskInfoFm").helptip(helpTipsJSON);
});

/*
依赖的样式
.flow-right-menu{
	position: fixed;
	z-index: 1000;
}
.flow-right-menu-btn{
	background: url("./flow-right-menu-show.png") no-repeat;
	width: 48px;
	height: 48px;
	margin-left: 1em;
	margin-bottom: -2.6em;
	z-index: 2000;
}
.flow-right-menu-btn:HOVER{
	cursor: pointer;
}
.flow-right-menu li{
	border: 1px solid #95B8E7;
	border-left: 6px solid #95B8E7;
	color: #0E2D5F;
	line-height: 1.5em;
	list-style-type: circle;
	padding: .5em 1em;
}
.flow-right-menu li:HOVER{
	border: 1px solid #FF9900;
	border-left: 4px solid #FF9900;
	border-right: 1px solid #FF9900;
	background-color: #FFFFCE;
	color: #0080FF;
	cursor: pointer;
}
.flow-right-menu li.selected{
	border: 1px solid #F8FE01;
	border-left: 4px solid #F8FE01;
	border-right: 1px solid #F8FE01;
	background-color: #FF9900;
	color: #fff;
}
*/



/**
 * 右侧浮动菜单插件
 * @param $
 */
(function($){
	$.flowmenu = function(options, param){
		if(null == options || options == undefined) options = "open";
		if (typeof options != 'string'){
			param = options;
			options = "open";
		}
		var method = $.flowmenu.methods[options];
		return method ? method(param) : null;
	},
	$.flowmenu.methods = {
		/**
		 * 显示右侧浮动菜单，且默认第一个菜单选中
		 * @param param
		 *    参数示例：
		 *    [{name:'', text: '', callback: null}]
		 *    name: 菜单唯一标识
		 *    text: 显示的菜单名
		 *    callback: 菜单点击回调函数，若当前即为显示的菜单项，则不会执行回调动作
		 * @returns
		 */
		open: function(param){
			var $containerDiv = $(".flow-right-menu");
			if($containerDiv.length > 0) return $containerDiv;
			
			$containerDiv = $("<div/>").addClass("flow-right-menu");
			$("body").append($containerDiv);
			
			$("<div/>").addClass("flow-right-menu-btn").appendTo($containerDiv).bind("click", function(ev){
				var w = $(window).width();
				var sw = $containerDiv.width();
				if($(".flow-right-menu ul").is(":visible")){
					$(".flow-right-menu ul").slideUp('fast', function(){
						var l = $(window).width() - $containerDiv.width() * 1/3;
						$(".flow-right-menu").animate({left: l});
					});
				} else {
					var l = sw > w ? w : (w - sw - 2);
					$(".flow-right-menu").animate({left: l}, function(){
						$(".flow-right-menu ul").slideDown('fast');
					});
				}
			});
			
			var $ul = $("<ul/>").appendTo($containerDiv);
			if(null == param || param == undefined){
			} else {
				for (var int = 0; int < param.length; int++) {
					var menuJSON = param[int];
					var $li = $("<li/>").attr({
						name : menuJSON.name
					}).html(menuJSON.text).appendTo($ul);
					if(menuJSON.callback){
						$li.bind("click", {fn: menuJSON.callback}, function(ev){
							if("selected" == $(this).attr("class")){
								return;
							}
							$.flowmenu("select", $(this).attr("name"));
							ev.data.fn();
						})
					}
				}
				$ul.find("li:first").addClass("selected");
			}
			
			var sh = $containerDiv.height();
			var sw = $containerDiv.width();
			$containerDiv.width(sw);
			function _resize(){
				var w = $(window).width(), h = $(window).height();
				var t = sh > h ? 0 : (h - sh) / 4;
				if($(".flow-right-menu ul").is(":visible")){
					var l = sw > w ? w : (w - sw - 2);
		    		$containerDiv.css({left: l, top: t});
				} else {
					var l = w - sw * 1/3;
		    		$containerDiv.css({left: l, top: t});
				}
			}
			_resize();
			$(window).bind('resize', function(){
				_resize();
			})
			return $containerDiv;
		},
		/**
		 * 设置指定菜单被选中
		 * @param param 菜单唯一标识
		 * @returns
		 */
		select: function(param){
			$(".flow-right-menu li").removeClass("selected");
			$(".flow-right-menu li[name=" + param + "]").addClass("selected");
		}
	}
})(jQuery);

// 调用示例
$(document).ready(function(){
	var menuJSONArray = [
	    {name:'easyui_1', text: 'easyui_1', callback: function(){alert('easyui_1');}},
	    {name:'easyui_2', text: 'easyui_2', callback: function(){alert('easyui_2');}},
	    {name:'easyui_3', text: 'easyui_3', callback: function(){alert('easyui_3');}},
	    {name:'easyui_4', text: 'easyui_4', callback: function(){alert('easyui_4');}},
	    {name:'easyui_5', text: 'easyui_5', callback: function(){alert('easyui_5');}},
	    {name:'easyui_0', text: 'easyui_0', callback: function(){alert('easyui_0');}}
	];
	// 右侧浮动菜单
	$.flowmenu(menuJSONArray);
//	$.flowmenu("open", menuJSONArray);
	$.flowmenu("select", "easyui_3");
});

<dependency>
	<groupId>commons-beanutils</groupId>
	<artifactId>commons-beanutils</artifactId>
	<version>1.8.3</version>
</dependency>


BeanUtils包的使用
http://www.cnblogs.com/H_Razor/archive/2011/03/01/1967620.html



spring的BeanUtils.copyProperties用法
http://blog.csdn.net/shimiso/article/details/5644584
BeanUtils所花费的时间要超过取数 据、将其复制到对应的 value对象（通过手动调用get和set方法），以及通过串行化将其返回到远程的客户机的时间总和。所以要小心使用这种威力！

DozerBeanMapper + 对象转Map方法
http://uule.iteye.com/blog/2084016


/**
dozer与maven的集成
<dependency>  
    <groupId>net.sf.dozer</groupId>  
    <artifactId>dozer</artifactId>  
    <version>5.0</version>  
</dependency> 

dozer spring
<bean id="beanMapper" class="org.dozer.spring.DozerBeanMapperFactoryBean">
    <property name="mappingFiles" value="classpath*:com/cignacmb/dozer/dozer-*.xml" />
</bean>

dozer-bean-mappings.xml
<?xml version="1.0" encoding="UTF-8"?>
<mappings xmlns="http://dozer.sourceforge.net" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://dozer.sourceforge.net  
          http://dozer.sourceforge.net/schema/beanmapping.xsd">
	<mapping>
		<class-a>com.cignacmb.productdef.dozer.User</class-a>
		<class-b>com.cignacmb.productdef.dozer.Customer</class-b>
		<field>
			<a>userId</a>
			<b>customerId</b>
		</field>
		<field>
			<a>userName</a>
			<b>customerName</b>
		</field>
	</mapping>
</mappings>  
 */

public class DozerTest extends AbstractJUnit4Test {

	@Resource
	private DozerBeanMapper beanMapper;
	
	@Test
	public void testMap() {
		User user = new User(1, "user1");
		Customer customer = beanMapper.map(user, Customer.class);
		System.out.println("@> CustomerId = " + customer.getCustomerId());
		System.out.println("@> CustomerName = " + customer.getCustomerName());
		Assert.assertEquals(customer.getCustomerId(), 1);
		Assert.assertEquals(customer.getCustomerName(), "user1");
	}
}

Java 语言的 XML 验证 API
http://www.ibm.com/developerworks/cn/xml/x-javaxmlvalidapi.html

Java通过XML Schema校验XML
http://lavasoft.blog.51cto.com/62575/97597/

JSONObject tJSON = JSONObject.fromObject(model, getJsonConfig());

public static JsonConfig getJsonConfig(){
	JsonConfig jsonConfig = new JsonConfig();  
	jsonConfig.registerJsonValueProcessor(java.sql.Date.class, new JsonSQLDateValueProcessor());
	jsonConfig.registerJsonValueProcessor(java.util.Date.class, new JsonUtilDateValueProcessor());
	return jsonConfig;
}

/**************************************************************************************/ 

/**
 * 
 */
package com.cignacmb.productdef.converter;

import java.text.SimpleDateFormat;
import java.util.Locale;

import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;

import com.cignacmb.productdef.util.Tools;

/**
 * java.sql.Date转JSON对象时日期转换<br>
 * 如将Date转换为“yyyy-MM-dd”格式
 * @author c1panx
 * @ 2015年5月28日  下午5:56:25
 */
public class JsonSQLDateValueProcessor implements JsonValueProcessor {

	private String format = "yyyy-MM-dd";

	public JsonSQLDateValueProcessor() {
		super();
	}

	public JsonSQLDateValueProcessor(String format) {
		super();
		this.format = format;
	}

	@Override
	public Object processArrayValue(Object paramObject,
			JsonConfig paramJsonConfig) {
		return process(paramObject);
	}

	@Override
	public Object processObjectValue(String paramString, Object paramObject,
			JsonConfig paramJsonConfig) {
		return process(paramObject);
	}

	private Object process(Object value) {
		if (null == value) {
			return "";
		}
		if (value instanceof java.sql.Date) {
			java.sql.Date sqlDate = (java.sql.Date) value;
			java.util.Date date = Tools.sqlDateToUtilDate(sqlDate);

			SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
			return sdf.format(date);
		}
		return value;
	}
}

/**************************************************************************************/ 

/**
 * 
 */
package com.cignacmb.productdef.converter;

import java.text.SimpleDateFormat;
import java.util.Locale;

import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;

/**
 * java.util.Date转JSON对象时日期转换<br>
 * 如将Date转换为“yyyy-MM-dd ”格式
 * @author c1panx
 * @ 2015年5月28日  下午5:56:25
 */
public class JsonUtilDateValueProcessor implements JsonValueProcessor {

	private String format = "yyyy-MM-dd HH:mm:ss";

	public JsonUtilDateValueProcessor() {
		super();
	}

	public JsonUtilDateValueProcessor(String format) {
		super();
		this.format = format;
	}

	@Override
	public Object processArrayValue(Object paramObject,
			JsonConfig paramJsonConfig) {
		return process(paramObject);
	}

	@Override
	public Object processObjectValue(String paramString, Object paramObject,
			JsonConfig paramJsonConfig) {
		return process(paramObject);
	}

	private Object process(Object value) {
		if (null == value) {
			return null;
		}
		if (value instanceof java.util.Date) {
			java.util.Date date = (java.util.Date) value;
			SimpleDateFormat sdf = new SimpleDateFormat(format, Locale.CHINA);
			return sdf.format(date);
		}
		return value;
	}
}

/*
 * Spring表单的initBinder：绑定表单复杂属性：
 * http://blog.sina.com.cn/s/blog_65dcacbb0100hwa8.html
 *
 * spring mvc使用@InitBinder 标签对表单数据绑定：
 * http://blog.csdn.net/axin66ok/article/details/17938095
 */

/**
 * @author c1panx
 * @ 2015年5月26日  上午11:34:50
 */
public class BaseController {
	
	/**
	 * 自定义springMVC的属性编辑器主要有两种方式：<br>
	 * 一种是使用@InitBinder标签在运行期注册一个属性编辑器，这种编辑器只在当前Controller里面有效；<br>
	 * 还有一种是实现自己的 WebBindingInitializer，然后定义一个 AnnotationMethodHandlerAdapter的bean，在此bean里面进行注册 ，这种属性编辑器是全局的。
	 * <br>
	 * 本类采用方式一 <br>
	 * 默认返回日期格式：yyyy-MM-dd，其他特殊情况时可继承重写
	 * <hr>
	 * <a href="http://haohaoxuexi.iteye.com/blog/1190065">springMVC自定义属性编辑器</a> <br>
	 * <a href="http://blog.csdn.net/whumr1/article/details/8056285">spring mvc绑定对象String转Date</a>
	 * <br>
	 * @param request
	 * @param binder
	 * @throws Exception
	 */
	@InitBinder
	protected void initBinder(HttpServletRequest request,
			ServletRequestDataBinder binder) throws Exception {
		// 对于需要转换为Date类型的属性，使用DateEditor进行处理
		binder.registerCustomEditor(java.util.Date.class, new DateUtilEditor());
		binder.registerCustomEditor(java.sql.Date.class, new DateSQLEditor());
	}
}


/**************************************************************************************/


/**
 * 
 */
package com.cignacmb.productdef.mvc.editor;

import java.beans.PropertyEditorSupport;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;

import com.cignacmb.productdef.common.Constants;

/**
 * springMVC的属性编辑器 —— 日期编辑器 java.util.Date类型
 * @author c1panx
 * @ 2015年5月26日  上午11:11:15
 */
public class DateUtilEditor extends PropertyEditorSupport {

	private static final DateFormat DATEFORMAT = new SimpleDateFormat("yyyy-MM-dd");
//	private static final DateFormat TIMEFORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

	private boolean allowEmpty = true;
	private DateFormat dateFormat;

	public DateUtilEditor() {
		this.dateFormat = DATEFORMAT;
	}
	
	public DateUtilEditor(boolean allowEmpty) {
		this.allowEmpty = allowEmpty;
	}
	
	public DateUtilEditor(DateFormat dateFormat) {
		this.dateFormat = dateFormat;
	}
	
	public DateUtilEditor(DateFormat dateFormat, boolean allowEmpty) {
		this.dateFormat = dateFormat;
		this.allowEmpty = allowEmpty;
	}

	@Override
	public String getAsText() {
		if (dateFormat == null) {
			dateFormat = DATEFORMAT;
		}
		Date date = (Date) getValue();
		return null == date ? null : dateFormat.format(date);
	}

	@Override
	public void setAsText(String text) throws IllegalArgumentException {
		if (this.allowEmpty && StringUtils.isBlank(text)) {
			// Treat empty String as null value.
			setValue(null);
		} else {
			try {
				// 常用日期格式字符串转换成日期对象
				Date date = DateUtils.parseDate(text, Constants.DatePattern);
				setValue(date);
			} catch (ParseException e) {
				throw new IllegalArgumentException("Could not parse date: "
						+ e.getMessage(), e);
			}
		}
	}

}


/**************************************************************************************/


/**
 * 
 */
package com.cignacmb.productdef.mvc.editor;

import java.beans.PropertyEditorSupport;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;

import com.cignacmb.productdef.common.Constants;
import com.cignacmb.productdef.util.Tools;

/**
 * springMVC的属性编辑器 —— 日期编辑器 java.sql.Date类型
 * @author c1panx
 * @ 2015年5月26日  上午11:11:15
 */
public class DateSQLEditor extends PropertyEditorSupport {

	private static final DateFormat DATEFORMAT = new SimpleDateFormat("yyyy-MM-dd");

	private boolean allowEmpty = true;

	public DateSQLEditor() {
	}
	
	public DateSQLEditor(boolean allowEmpty) {
		this.allowEmpty = allowEmpty;
	}
	
	@Override
	public String getAsText() {
		java.sql.Date sqlDate = (java.sql.Date) getValue();
		java.util.Date utilDate = Tools.sqlDateToUtilDate(sqlDate);
		return null == utilDate ? "" : DATEFORMAT.format(utilDate);
	}

	@Override
	public void setAsText(String text) throws IllegalArgumentException {
		if (this.allowEmpty && StringUtils.isBlank(text)) {
			// Treat empty String as null value.
			setValue(null);
		} else {
			try {
				// 常用日期格式字符串转换成日期对象
				Date date = DateUtils.parseDate(text, Constants.DatePattern);
				setValue(Tools.utilDateToSqlDate(date));
			} catch (ParseException e) {
				throw new IllegalArgumentException("Could not parse date: "
						+ e.getMessage(), e);
			}
		}
	}

}

/*
 *  Copyright 2005 The Apache Software Foundation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.mybatis.generator.internal.types;

import java.math.BigDecimal;
import java.sql.Types;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.mybatis.generator.api.IntrospectedColumn;
import org.mybatis.generator.api.JavaTypeResolver;
import org.mybatis.generator.api.dom.java.FullyQualifiedJavaType;
import org.mybatis.generator.config.Context;
import org.mybatis.generator.config.PropertyRegistry;
import org.mybatis.generator.internal.util.StringUtility;

/**
 * 新核心系统中数据库中的Date只包含年月日信息，时间保存至对应的time字段<br>
 * mybatis generator默认映射至java.util.Date<br>
 * 针对新核心，需重新映射至java.sql.Date<br>
 * 在xml中设置配置开关:<br>
 * property name="sqldate" value="true" <br>
 * true: 表示使用java.sql.date,
 * 其他情况使用java.util.Date
 * @author Jeff Butler
 */
public class JavaTypeResolverDefaultImpl implements JavaTypeResolver {

    protected List<String> warnings;

    protected Properties properties;

    protected Context context;

    protected boolean forceBigDecimals;

    protected Map<Integer, JdbcTypeInformation> typeMap;
    
    public JavaTypeResolverDefaultImpl() {
        super();
        properties = new Properties();
        typeMap = new HashMap<Integer, JdbcTypeInformation>();

        typeMap.put(Types.ARRAY, new JdbcTypeInformation("ARRAY", //$NON-NLS-1$
                new FullyQualifiedJavaType(Object.class.getName())));
        typeMap.put(Types.BIGINT, new JdbcTypeInformation("BIGINT", //$NON-NLS-1$
                new FullyQualifiedJavaType(Long.class.getName())));
        typeMap.put(Types.BINARY, new JdbcTypeInformation("BINARY", //$NON-NLS-1$
                new FullyQualifiedJavaType("byte[]"))); //$NON-NLS-1$
        typeMap.put(Types.BIT, new JdbcTypeInformation("BIT", //$NON-NLS-1$
                new FullyQualifiedJavaType(Boolean.class.getName())));
        typeMap.put(Types.BLOB, new JdbcTypeInformation("BLOB", //$NON-NLS-1$
                new FullyQualifiedJavaType("byte[]"))); //$NON-NLS-1$
        typeMap.put(Types.BOOLEAN, new JdbcTypeInformation("BOOLEAN", //$NON-NLS-1$
                new FullyQualifiedJavaType(Boolean.class.getName())));
        typeMap.put(Types.CHAR, new JdbcTypeInformation("CHAR", //$NON-NLS-1$
                new FullyQualifiedJavaType(String.class.getName())));
        typeMap.put(Types.CLOB, new JdbcTypeInformation("CLOB", //$NON-NLS-1$
                new FullyQualifiedJavaType(String.class.getName())));
        typeMap.put(Types.DATALINK, new JdbcTypeInformation("DATALINK", //$NON-NLS-1$
                new FullyQualifiedJavaType(Object.class.getName())));
        typeMap.put(Types.DATE, new JdbcTypeInformation("DATE", //$NON-NLS-1$
                new FullyQualifiedJavaType(Date.class.getName())));
        typeMap.put(Types.DISTINCT, new JdbcTypeInformation("DISTINCT", //$NON-NLS-1$
                new FullyQualifiedJavaType(Object.class.getName())));
        typeMap.put(Types.DOUBLE, new JdbcTypeInformation("DOUBLE", //$NON-NLS-1$
                new FullyQualifiedJavaType(Double.class.getName())));
        typeMap.put(Types.FLOAT, new JdbcTypeInformation("FLOAT", //$NON-NLS-1$
                new FullyQualifiedJavaType(Double.class.getName())));
        typeMap.put(Types.INTEGER, new JdbcTypeInformation("INTEGER", //$NON-NLS-1$
                new FullyQualifiedJavaType(Integer.class.getName())));
        typeMap.put(Types.JAVA_OBJECT, new JdbcTypeInformation("JAVA_OBJECT", //$NON-NLS-1$
                new FullyQualifiedJavaType(Object.class.getName())));
        typeMap.put(Jdbc4Types.LONGNVARCHAR, new JdbcTypeInformation("LONGNVARCHAR", //$NON-NLS-1$
                new FullyQualifiedJavaType(String.class.getName())));
        typeMap.put(Types.LONGVARBINARY, new JdbcTypeInformation(
                "LONGVARBINARY", //$NON-NLS-1$
                new FullyQualifiedJavaType("byte[]"))); //$NON-NLS-1$
        typeMap.put(Types.LONGVARCHAR, new JdbcTypeInformation("LONGVARCHAR", //$NON-NLS-1$
                new FullyQualifiedJavaType(String.class.getName())));
        typeMap.put(Jdbc4Types.NCHAR, new JdbcTypeInformation("NCHAR", //$NON-NLS-1$
                new FullyQualifiedJavaType(String.class.getName())));
        typeMap.put(Jdbc4Types.NCLOB, new JdbcTypeInformation("NCLOB", //$NON-NLS-1$
                new FullyQualifiedJavaType(String.class.getName())));
        typeMap.put(Jdbc4Types.NVARCHAR, new JdbcTypeInformation("NVARCHAR", //$NON-NLS-1$
                new FullyQualifiedJavaType(String.class.getName())));
        typeMap.put(Types.NULL, new JdbcTypeInformation("NULL", //$NON-NLS-1$
                new FullyQualifiedJavaType(Object.class.getName())));
        typeMap.put(Types.OTHER, new JdbcTypeInformation("OTHER", //$NON-NLS-1$
                new FullyQualifiedJavaType(Object.class.getName())));
        typeMap.put(Types.REAL, new JdbcTypeInformation("REAL", //$NON-NLS-1$
                new FullyQualifiedJavaType(Float.class.getName())));
        typeMap.put(Types.REF, new JdbcTypeInformation("REF", //$NON-NLS-1$
                new FullyQualifiedJavaType(Object.class.getName())));
        typeMap.put(Types.SMALLINT, new JdbcTypeInformation("SMALLINT", //$NON-NLS-1$
                new FullyQualifiedJavaType(Short.class.getName())));
        typeMap.put(Types.STRUCT, new JdbcTypeInformation("STRUCT", //$NON-NLS-1$
                new FullyQualifiedJavaType(Object.class.getName())));
        typeMap.put(Types.TIME, new JdbcTypeInformation("TIME", //$NON-NLS-1$
                new FullyQualifiedJavaType(Date.class.getName())));
        typeMap.put(Types.TIMESTAMP, new JdbcTypeInformation("TIMESTAMP", //$NON-NLS-1$
                new FullyQualifiedJavaType(Date.class.getName())));
        typeMap.put(Types.TINYINT, new JdbcTypeInformation("TINYINT", //$NON-NLS-1$
                new FullyQualifiedJavaType(Byte.class.getName())));
        typeMap.put(Types.VARBINARY, new JdbcTypeInformation("VARBINARY", //$NON-NLS-1$
                new FullyQualifiedJavaType("byte[]"))); //$NON-NLS-1$
        typeMap.put(Types.VARCHAR, new JdbcTypeInformation("VARCHAR", //$NON-NLS-1$
                new FullyQualifiedJavaType(String.class.getName())));
        
    }

    public void addConfigurationProperties(Properties properties) {
        this.properties.putAll(properties);
        forceBigDecimals = StringUtility
                .isTrue(properties
                        .getProperty(PropertyRegistry.TYPE_RESOLVER_FORCE_BIG_DECIMALS));
    }

    public FullyQualifiedJavaType calculateJavaType(
            IntrospectedColumn introspectedColumn) {
        FullyQualifiedJavaType answer;
        JdbcTypeInformation jdbcTypeInformation = typeMap
                .get(introspectedColumn.getJdbcType());

        if (jdbcTypeInformation == null) {
            switch (introspectedColumn.getJdbcType()) {
            case Types.DECIMAL:
            case Types.NUMERIC:
                if (introspectedColumn.getScale() > 0
                        || introspectedColumn.getLength() > 18
                        || forceBigDecimals) {
                    answer = new FullyQualifiedJavaType(BigDecimal.class
                            .getName());
                } else if (introspectedColumn.getLength() > 9) {
                    answer = new FullyQualifiedJavaType(Long.class.getName());
                } else if (introspectedColumn.getLength() > 4) {
                    answer = new FullyQualifiedJavaType(Integer.class.getName());
                } else {
                    answer = new FullyQualifiedJavaType(Short.class.getName());
                }
                break;

            default:
                answer = null;
                break;
            }
        } else {
            answer = jdbcTypeInformation.getFullyQualifiedJavaType();
        }

        return answer;
    }

    public String calculateJdbcTypeName(IntrospectedColumn introspectedColumn) {
        String answer;
        JdbcTypeInformation jdbcTypeInformation = typeMap
                .get(introspectedColumn.getJdbcType());

        if (jdbcTypeInformation == null) {
            switch (introspectedColumn.getJdbcType()) {
            case Types.DECIMAL:
                answer = "DECIMAL"; //$NON-NLS-1$
                break;
            case Types.NUMERIC:
                answer = "NUMERIC"; //$NON-NLS-1$
                break;
            default:
                answer = null;
                break;
            }
        } else {
            answer = jdbcTypeInformation.getJdbcTypeName();
        }

        return answer;
    }

    public void setWarnings(List<String> warnings) {
        this.warnings = warnings;
    }

    public void setContext(Context context) {
        this.context = context;
        // TODO add
        String sqldate = context.getProperty("sqldate");
        System.out.println("sqldate = " + sqldate);
		if ("true".equalsIgnoreCase(sqldate)) {
			typeMap.put(Types.DATE, new JdbcTypeInformation("DATE",
					new FullyQualifiedJavaType(java.sql.Date.class.getName())));
			typeMap.put(Types.TIME, new JdbcTypeInformation("TIME",
					new FullyQualifiedJavaType(java.sql.Date.class.getName())));
			typeMap.put(Types.TIMESTAMP, new JdbcTypeInformation("TIMESTAMP",
					new FullyQualifiedJavaType(java.sql.Date.class.getName())));
		}
    }

    public static class JdbcTypeInformation {
        private String jdbcTypeName;

        private FullyQualifiedJavaType fullyQualifiedJavaType;

        public JdbcTypeInformation(String jdbcTypeName,
                FullyQualifiedJavaType fullyQualifiedJavaType) {
            this.jdbcTypeName = jdbcTypeName;
            this.fullyQualifiedJavaType = fullyQualifiedJavaType;
        }

        public String getJdbcTypeName() {
            return jdbcTypeName;
        }

        public FullyQualifiedJavaType getFullyQualifiedJavaType() {
            return fullyQualifiedJavaType;
        }
    }
}

/**
 * form扩展
 * @param $
 */
$.extend($.fn.form.methods, {
	/**
	 * getData 获取数据接口
	 * http://www.easyui.info/archives/138.html
	 * 用法示例：
	 * $("#formID").form("getData");
	 * $("#formID").form("getData", true);
	 * @param jq
	 * @param params 设置为true的话，会把string型"true"和"false"字符串值转化为boolean型。不区分大小写。
	 */
	getData: function(jq, params){
		var oRet = {};
		var formArray = jq.serializeArray();
		for(var i in formArray){
			var v = formArray[i].value;
			if (params){
				v = (v.toLocaleLowerCase() == "true" || v.toLocaleLowerCase() == "false") ? v.toLocaleLowerCase() == "true" : v;
			}
			if (typeof(oRet[formArray[i].name]) == 'undefined') {
				oRet[formArray[i].name] = v;
			} else {
				oRet[formArray[i].name] += "," + v;
			}
		}
		return oRet;
	},
	/**
	 * 获取指定控件值
	 * 用法示例：
	 * $("#formID").form("getValue");
	 * @param jq
	 * @param name 控件的name属性值
	 * @param value 设置的value值
	 */
	getValue : function(jq, name){
		var data = jq.form("getData");
		return data[name];
	},
	/**
	 * 设置指定控件值
	 * 用法示例：
	 * $("#formID").form("setValue", {name: "email", value: "test@qq.com"});
	 * @param jq
	 * @param params 控件的name/value属性键值对
	 */
	setValue : function(jq, params) {
		var json = {name: '', value: ''};
		$.extend(true, json, params);
		return jq.each(function() {
			var data = $(this).form("getData");
			data[json.name] = json.value;
			$(this).form("load", data);
		});
	},
	/**
	 * 是否禁用，针对form表单中所有的input[文本框、复选框、单选框],select[下拉选],多行文本框[textarea]
	 * 参考：http://caizi12.iteye.com/blog/1734143
	 * 用法示例：
	 * $("#form").form("disabled"); 同 $("#form").form("disabled", true);
	 * $("#form").form("disabled", false);
	 * @param jq
	 * @param flag：true-禁用；false-取消禁用；
	 *             不定义时，默认为true-禁用
	 */
	disabled: function(jq, flag){
		flag = null == flag || flag == undefined?true:flag;
		jq.form("readonly", flag);
		jq.find(":input").attr("disabled",flag);
	},
	/**
	 * 是否只读，针对form表单中所有的input[文本框、复选框、单选框],select[下拉选],多行文本框[textarea]
	 * 用法示例：
	 * $("#form").form("readonly"); 同 $("#form").form("readonly", true);
	 * $("#form").form("readonly", false);
	 * @param jq
	 * @param flag：true-只读；false-取消只读；
	 *             不定义时，默认为true-只读
	 */
	readonly: function(jq, flag){
		flag = null == flag || flag == undefined?true:flag;
		jq.find(":input").attr("readonly",flag);
		
//		jq.find(":text").attr("readonly",flag);
//		jq.find("textarea").attr("disabled",flag);
//		jq.find("select").attr("disabled",flag);
		jq.find(":radio").attr("disabled",flag);
		jq.find(":checkbox").attr("disabled",flag);
		
		// 禁用jquery easyui中的下拉选（使用input生成的combox）
		jq.find(".easyui-combobox").combobox('readonly', flag);
		
		// 禁用jquery easyui中的下拉选（使用select生成的combox）
//		jq.find("select[class='combobox-f combo-f']").each(function() {
//			if (this.id) {
//				$("#" + this.id).combobox(attr);
//			}
//		});  
	      
	    // 禁用jquery easyui中的日期组件dataBox
		jq.find(".easyui-datebox").datebox('readonly', flag);
	}
});

jsplumb
http://jsplumb.org/jquery/demo.html


Qunee for HTML5
http://qunee.com/

/**
 * 解决重复遮罩问题
 * loading效果，且可以重复加载而互不干扰
 * 依赖于css样式：
 * .window-loading-img{
 * 		background: center no-repeat url("../jeasyui/themes/images/loading.gif");
 * 		width: 20px;
 * }
 * 其中loading.gif使用的是easyui中的图片；
 * 使用示例：
 * var l = $.loading(); // 创建loading
 * l.loadend(); // 移除指定的loading效果
 * $.loadend();  // 移除一个loading
 * $.loadendAll();  // 移除所有loading效果
 * @param $
 */
(function($) {
	$.extend(jQuery, {
		/**
		 * @return 返回jQuery对象，与loadend()结合，可针对单个异步ajax请求处理
		 */
		loading: function(){
			var $count = $("<div class='-window-loading-count'/>");
			$('body').append($count);
			if($(".-window-loading-content").length > 0){
				$(".-window-loading-content").show();
				return $count;
			}
			var $mask = $("<div class='-window-loading-mask'/>").css({
				background: '#ccc',
				display: 'block',
				opacity: '0.40',
				overflow: 'hidden',
				position: 'absolute',
				left: '0px',
				top: '0px',
				width: '100%',
				'z-index': 8100
			});
			var $shadow = $("<div class='-window-loading-shadow'/>").css({
				background: '#fff',
				display: 'block',
				border: '1px solid #ccc',
				'box-shadow': '2px 2px 3px #cccccc',
				overflow: 'hidden',
				position: 'absolute',
				'z-index': 8110
			});
			var html = '<table><tr><td style="height:2em; width: .5em;"></td>';
			html += '<td class="window-loading-img"></td>';
			html += '<td style="padding-right: .5em;">正在加载，请等待...</td>';
			html += '</tr></table>';
			$shadow.append($(html));
			var $loading = $("<div class='-window-loading-content'/>").append($mask).append($shadow);
			$('body').append($loading);
			
			var shadow_h = $shadow.height();
			var shadow_w = $shadow.width();

			_resizeLoading();
			$(window).bind('resize', function(){
				_resizeLoading();
			});
			function _resizeLoading(){
				$(".-window-loading-mask").height(0);
				var h = $(window).height();
				h = h > $(document).height() ? h : $(document).height();
				$(".-window-loading-mask").height(h);

				var l = ($(window).width() - shadow_w) * 1/2;
				var t = ($(window).height() - shadow_h) * 1/3;
				$(".-window-loading-shadow").offset({left: l, top: t});
			}
			return $count;
		},
		/**
		 * 移除所有loading效果
		 */
		loadendAll: function(){
			$(".-window-loading-content").hide();
			$(".-window-loading-count").remove();
		},
		/**
		 * 随机移除一个loading
		 */
		loadend: function(){
			var $count = $(".-window-loading-count");
			if($count.length > 0){
				$($count[0]).loadend();
			}
		}
	});
	$.fn.extend({
		/**
		 * 移除指定的loading
		 */
		loadend: function(){
			$(this).remove();
			var $count = $(".-window-loading-count");
			if(null == $count || $count == undefined || $count.length == 0){
				$(".-window-loading-content").hide();
			}
		}
	});
})(jQuery);

/**
 * 设置全局 AJAX 默认选项
 */
$.ajaxSetup({
	beforeSend: function(XMLHttpRequest){
		$.loading();
	},
	complete: function(XMLHttpRequest, textStatus){
		$.loadend();
	}
})

/**
 * loading效果，且可以重复加载而互不干扰
 * 依赖于css样式：
 * .window-loading-img{
 * 		background: center no-repeat url("../jeasyui/themes/images/loading.gif");
 * 		width: 20px;
 * }
 * 其中loading.gif使用的是easyui中的图片；
 * 使用示例：
 * var l = $.loading();	// 创建loading
 * l.hideloading();	// 移除指定的loading效果
 * $.loadendAll();	// 移除所有loading效果
 * @param $
 */
(function($) {
	$.extend(jQuery, {
		/**
		 * @return 返回jQuery对象，与loadend()结合，可针对单个异步ajax请求处理
		 */
		loading: function(){
			var $mask = $("<div class='-window-loading-mask'/>").css({
				background: '#ccc',
				display: 'block',
				opacity: '0.20',
				overflow: 'hidden',
				position: 'absolute',
				left: '0px',
				top: '0px',
				width: '100%',
				'z-index': 8100
			});
			var $shadow = $("<div class='-window-loading-shadow'/>").css({
				background: '#fff',
				display: 'block',
				border: '1px solid #ccc',
				'box-shadow': '2px 2px 3px #cccccc',
				overflow: 'hidden',
				position: 'absolute',
				'z-index': 8110
			});
			var html = '<table><tr><td style="height:2em; width: .5em;"></td>';
			html += '<td class="window-loading-img"></td>';
			html += '<td style="padding-right: .5em;">正在加载，请等待...</td>';
			html += '</tr></table>';
			$shadow.append($(html));
			var $loading = $("<div class='-window-loading-content'/>").append($mask).append($shadow);
			$('body').append($loading);
			
			var shadow_h = $shadow.height();
			var shadow_w = $shadow.width();

			_resizeLoading();
			$(window).bind('resize', function(){
				_resizeLoading();
			});
			function _resizeLoading(){
				$(".-window-loading-mask").height(0);
				var h = $(window).height();
				h = h > $(document).height() ? h : $(document).height();
				$(".-window-loading-mask").height(h);

				var l = ($(window).width() - shadow_w) * 1/2;
				var t = ($(window).height() - shadow_h) * 1/3;
				$(".-window-loading-shadow").offset({left: l, top: t});
			}
			return $loading;
		},
		/**
		 * 移除所有loading效果
		 */
		loadendAll: function(){
			$(".-window-loading-content").remove();
		}
	});
	$.fn.extend({
		/**
		 * 移除指定的loading
		 */
		loadend: function(){
			$(this).remove();
		}
	});
})(jQuery);

/*
 *  Copyright 2005 The Apache Software Foundation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.mybatis.generator.internal.db;

import static org.mybatis.generator.internal.util.JavaBeansUtil.getCamelCaseString;
import static org.mybatis.generator.internal.util.JavaBeansUtil.getValidPropertyName;
import static org.mybatis.generator.internal.util.StringUtility.composeFullyQualifiedTableName;
import static org.mybatis.generator.internal.util.StringUtility.isTrue;
import static org.mybatis.generator.internal.util.StringUtility.stringContainsSQLWildcard;
import static org.mybatis.generator.internal.util.StringUtility.stringContainsSpace;
import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;
import static org.mybatis.generator.internal.util.messages.Messages.getString;

import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.commons.lang.StringUtils;
import org.mybatis.generator.api.FullyQualifiedTable;
import org.mybatis.generator.api.IntrospectedColumn;
import org.mybatis.generator.api.IntrospectedTable;
import org.mybatis.generator.api.JavaTypeResolver;
import org.mybatis.generator.api.dom.java.FullyQualifiedJavaType;
import org.mybatis.generator.config.ColumnOverride;
import org.mybatis.generator.config.Context;
import org.mybatis.generator.config.GeneratedKey;
import org.mybatis.generator.config.PropertyRegistry;
import org.mybatis.generator.config.TableConfiguration;
import org.mybatis.generator.internal.ObjectFactory;
import org.mybatis.generator.logging.Log;
import org.mybatis.generator.logging.LogFactory;

/**
 * <a href="http://blog.csdn.net/isea533/article/details/42102297">MyBatis Generator 详解</a><br>
 * table 元素：schema:数据库的schema,可以使用SQL通配符匹配。如果设置了该值，生成SQL的表名会变成如schema.tableName的形式。
 * <br>
 * 因此重写本类，在table 元素中不配置schema时，采用content中的property配置。
 * context节点中配置示例：
 * <property name="schema" value="lis_dev"/>
 * @author Jeff Butler
 */
public class DatabaseIntrospector {

    private DatabaseMetaData databaseMetaData;
    private JavaTypeResolver javaTypeResolver;
    private List<String> warnings;
    private Context context;
    private Log logger;

    public DatabaseIntrospector(Context context,
            DatabaseMetaData databaseMetaData,
            JavaTypeResolver javaTypeResolver, List<String> warnings) {
        super();
        this.context = context;
        this.databaseMetaData = databaseMetaData;
        this.javaTypeResolver = javaTypeResolver;
        this.warnings = warnings;
        logger = LogFactory.getLog(getClass());
    }

    private void calculatePrimaryKey(FullyQualifiedTable table,
            IntrospectedTable introspectedTable) {
        ResultSet rs = null;

        try {
            rs = databaseMetaData.getPrimaryKeys(
                    table.getIntrospectedCatalog(), table
                            .getIntrospectedSchema(), table
                            .getIntrospectedTableName());
        } catch (SQLException e) {
            closeResultSet(rs);
            warnings.add(getString("Warning.15")); //$NON-NLS-1$
            return;
        }

        try {
            // keep primary columns in key sequence order
            Map<Short, String> keyColumns = new TreeMap<Short, String>();
            while (rs.next()) {
                String columnName = rs.getString("COLUMN_NAME"); //$NON-NLS-1$
                short keySeq = rs.getShort("KEY_SEQ"); //$NON-NLS-1$
                keyColumns.put(keySeq, columnName);
            }
            
            for (String columnName : keyColumns.values()) {
                introspectedTable.addPrimaryKeyColumn(columnName);
            }
        } catch (SQLException e) {
            // ignore the primary key if there's any error
        } finally {
            closeResultSet(rs);
        }
    }

    private void closeResultSet(ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                // ignore
                ;
            }
        }
    }

    private void reportIntrospectionWarnings(
            IntrospectedTable introspectedTable,
            TableConfiguration tableConfiguration, FullyQualifiedTable table) {
        // make sure that every column listed in column overrides
        // actually exists in the table
        for (ColumnOverride columnOverride : tableConfiguration
                .getColumnOverrides()) {
            if (introspectedTable.getColumn(columnOverride.getColumnName()) == null) {
                warnings.add(getString("Warning.3", //$NON-NLS-1$
                        columnOverride.getColumnName(), table.toString()));
            }
        }

        // make sure that every column listed in ignored columns
        // actually exists in the table
        for (String string : tableConfiguration.getIgnoredColumnsInError()) {
            warnings.add(getString("Warning.4", //$NON-NLS-1$
                    string, table.toString()));
        }

        GeneratedKey generatedKey = tableConfiguration.getGeneratedKey();
        if (generatedKey != null
                && introspectedTable.getColumn(generatedKey.getColumn()) == null) {
            if (generatedKey.isIdentity()) {
                warnings.add(getString("Warning.5", //$NON-NLS-1$
                        generatedKey.getColumn(), table.toString()));
            } else {
                warnings.add(getString("Warning.6", //$NON-NLS-1$
                        generatedKey.getColumn(), table.toString()));
            }
        }
    }

    /**
     * Returns a List<IntrospectedTable> that matches the specified table
     * configuration.
     * 
     * @param tc
     * @return a list of introspected tables
     * @throws SQLException
     */
    public List<IntrospectedTable> introspectTables(TableConfiguration tc)
            throws SQLException {

        // get the raw columns from the DB
        Map<ActualTableName, List<IntrospectedColumn>> columns = getColumns(tc);

        if (columns.isEmpty()) {
            warnings.add(getString("Warning.19", tc.getCatalog(), //$NON-NLS-1$
                    tc.getSchema(), tc.getTableName()));
            return null;
        }

        removeIgnoredColumns(tc, columns);
        calculateExtraColumnInformation(tc, columns);
        applyColumnOverrides(tc, columns);
        calculateIdentityColumns(tc, columns);

        List<IntrospectedTable> introspectedTables = calculateIntrospectedTables(
                tc, columns);

        // now introspectedTables has all the columns from all the
        // tables in the configuration. Do some validation...

        Iterator<IntrospectedTable> iter = introspectedTables.iterator();
        while (iter.hasNext()) {
            IntrospectedTable introspectedTable = iter.next();

            if (!introspectedTable.hasAnyColumns()) {
                // add warning that the table has no columns, remove from the
                // list
                String warning = getString(
                                "Warning.1", introspectedTable.getFullyQualifiedTable().toString()); //$NON-NLS-1$
                warnings.add(warning);
                iter.remove();
            } else if (!introspectedTable.hasPrimaryKeyColumns()
                    && !introspectedTable.hasBaseColumns()) {
                // add warning that the table has only BLOB columns, remove from
                // the list
                String warning = getString(
                                "Warning.18", introspectedTable.getFullyQualifiedTable().toString()); //$NON-NLS-1$ 
                warnings.add(warning);
                iter.remove();
            } else {
                // now make sure that all columns called out in the
                // configuration
                // actually exist
                reportIntrospectionWarnings(introspectedTable, tc,
                        introspectedTable.getFullyQualifiedTable());
            }
        }

        return introspectedTables;
    }

    /**
     * @param tc
     * @param columns
     */
    private void removeIgnoredColumns(TableConfiguration tc,
            Map<ActualTableName, List<IntrospectedColumn>> columns) {
        for (Map.Entry<ActualTableName, List<IntrospectedColumn>> entry : columns
                .entrySet()) {
            Iterator<IntrospectedColumn> tableColumns = (entry.getValue())
                    .iterator();
            while (tableColumns.hasNext()) {
                IntrospectedColumn introspectedColumn = tableColumns.next();
                if (tc
                        .isColumnIgnored(introspectedColumn
                                .getActualColumnName())) {
                    tableColumns.remove();
                    if (logger.isDebugEnabled()) {
                        logger.debug(getString("Tracing.3", //$NON-NLS-1$
                                introspectedColumn.getActualColumnName(), entry
                                        .getKey().toString()));
                    }
                }
            }
        }
    }

    private void calculateExtraColumnInformation(TableConfiguration tc,
            Map<ActualTableName, List<IntrospectedColumn>> columns) {
        StringBuilder sb = new StringBuilder();
        Pattern pattern = null;
        String replaceString = null;
        if (tc.getColumnRenamingRule() != null) {
            pattern = Pattern.compile(tc.getColumnRenamingRule()
                    .getSearchString());
            replaceString = tc.getColumnRenamingRule().getReplaceString();
            replaceString = replaceString == null ? "" : replaceString; //$NON-NLS-1$
        }

        for (Map.Entry<ActualTableName, List<IntrospectedColumn>> entry : columns
                .entrySet()) {
            for (IntrospectedColumn introspectedColumn : entry.getValue()) {
                String calculatedColumnName;
                if (pattern == null) {
                    calculatedColumnName = introspectedColumn
                            .getActualColumnName();
                } else {
                    Matcher matcher = pattern.matcher(introspectedColumn
                            .getActualColumnName());
                    calculatedColumnName = matcher.replaceAll(replaceString);
                }

                if (isTrue(tc
                        .getProperty(PropertyRegistry.TABLE_USE_ACTUAL_COLUMN_NAMES))) {
                    introspectedColumn.setJavaProperty(
                            getValidPropertyName(calculatedColumnName));
                } else if (isTrue(tc
                                .getProperty(PropertyRegistry.TABLE_USE_COMPOUND_PROPERTY_NAMES))) {
                    sb.setLength(0);
                    sb.append(calculatedColumnName);
                    sb.append('_');
                    sb.append(getCamelCaseString(
                            introspectedColumn.getRemarks(), true));
                    introspectedColumn.setJavaProperty(
                            getValidPropertyName(sb.toString()));
                } else {
                    introspectedColumn.setJavaProperty(
                            getCamelCaseString(calculatedColumnName, false));
                }

                FullyQualifiedJavaType fullyQualifiedJavaType = javaTypeResolver
                        .calculateJavaType(introspectedColumn);

                if (fullyQualifiedJavaType != null) {
                    introspectedColumn
                            .setFullyQualifiedJavaType(fullyQualifiedJavaType);
                    introspectedColumn.setJdbcTypeName(javaTypeResolver
                            .calculateJdbcTypeName(introspectedColumn));
                } else {
                    // type cannot be resolved. Check for ignored or overridden
                    boolean warn = true;
                    if (tc.isColumnIgnored(introspectedColumn
                            .getActualColumnName())) {
                        warn = false;
                    }

                    ColumnOverride co = tc.getColumnOverride(introspectedColumn
                            .getActualColumnName());
                    if (co != null) {
                        if (stringHasValue(co.getJavaType())
                                && stringHasValue(co.getJavaType())) {
                            warn = false;
                        }
                    }

                    // if the type is not supported, then we'll report a warning
                    if (warn) {
                        introspectedColumn
                                .setFullyQualifiedJavaType(FullyQualifiedJavaType
                                        .getObjectInstance());
                        introspectedColumn.setJdbcTypeName("OTHER"); //$NON-NLS-1$

                        String warning = getString("Warning.14", //$NON-NLS-1$
                                Integer.toString(introspectedColumn.getJdbcType()),
                                entry.getKey().toString(),
                                introspectedColumn.getActualColumnName());

                        warnings.add(warning);
                    }
                }

                if (context.autoDelimitKeywords()) {
                    if (SqlReservedWords.containsWord(introspectedColumn
                            .getActualColumnName())) {
                        introspectedColumn.setColumnNameDelimited(true);
                    }
                }

                if (tc.isAllColumnDelimitingEnabled()) {
                    introspectedColumn.setColumnNameDelimited(true);
                }
            }
        }
    }

    private void calculateIdentityColumns(TableConfiguration tc,
            Map<ActualTableName, List<IntrospectedColumn>> columns) {
        GeneratedKey gk = tc.getGeneratedKey();
        if (gk == null) {
            // no generated key, then no identity or sequence columns
            return;
        }
        
        for (Map.Entry<ActualTableName, List<IntrospectedColumn>> entry : columns
                .entrySet()) {
            for (IntrospectedColumn introspectedColumn : entry.getValue()) {
                if (isMatchedColumn(introspectedColumn, gk)) {
                    if (gk.isIdentity() || gk.isJdbcStandard()) {
                        introspectedColumn.setIdentity(true);
                        introspectedColumn.setSequenceColumn(false);
                    } else {
                        introspectedColumn.setIdentity(false);
                        introspectedColumn.setSequenceColumn(true);
                    }
                }
            }
        }
    }
    
    private boolean isMatchedColumn(IntrospectedColumn introspectedColumn, GeneratedKey gk) {
        if (introspectedColumn.isColumnNameDelimited()) {
            return introspectedColumn.getActualColumnName().equals(gk.getColumn());
        } else {
            return introspectedColumn.getActualColumnName().equalsIgnoreCase(gk.getColumn());
        }
    }

    private void applyColumnOverrides(TableConfiguration tc,
            Map<ActualTableName, List<IntrospectedColumn>> columns) {
        for (Map.Entry<ActualTableName, List<IntrospectedColumn>> entry : columns
                .entrySet()) {
            for (IntrospectedColumn introspectedColumn : entry.getValue()) {
                ColumnOverride columnOverride = tc
                        .getColumnOverride(introspectedColumn
                                .getActualColumnName());

                if (columnOverride != null) {
                    if (logger.isDebugEnabled()) {
                        logger.debug(getString("Tracing.4", //$NON-NLS-1$
                                introspectedColumn.getActualColumnName(), entry
                                        .getKey().toString()));
                    }

                    if (stringHasValue(columnOverride
                            .getJavaProperty())) {
                        introspectedColumn.setJavaProperty(columnOverride
                                .getJavaProperty());
                    }

                    if (stringHasValue(columnOverride
                            .getJavaType())) {
                        introspectedColumn
                                .setFullyQualifiedJavaType(new FullyQualifiedJavaType(
                                        columnOverride.getJavaType()));
                    }

                    if (stringHasValue(columnOverride
                            .getJdbcType())) {
                        introspectedColumn.setJdbcTypeName(columnOverride
                                .getJdbcType());
                    }

                    if (stringHasValue(columnOverride
                            .getTypeHandler())) {
                        introspectedColumn.setTypeHandler(columnOverride
                                .getTypeHandler());
                    }

                    if (columnOverride.isColumnNameDelimited()) {
                        introspectedColumn.setColumnNameDelimited(true);
                    }

                    introspectedColumn.setProperties(columnOverride
                            .getProperties());
                }
            }
        }
    }

    /**
     * This method returns a Map<ActualTableName, List<ColumnDefinitions>> of
     * columns returned from the database introspection.
     * 
     * @param tc
     * @return introspected columns
     * @throws SQLException
     */
    private Map<ActualTableName, List<IntrospectedColumn>> getColumns(
            TableConfiguration tc) throws SQLException {
        String localCatalog;
        String localSchema;
        String localTableName;
        
        // TODO
		String schema = context.getProperty("schema");
		if (StringUtils.isBlank(schema)) {
			schema = null;
		}

        boolean delimitIdentifiers = tc.isDelimitIdentifiers()
                || stringContainsSpace(tc.getCatalog())
                || stringContainsSpace(tc.getSchema())
                || stringContainsSpace(tc.getTableName());

        if (delimitIdentifiers) {
            localCatalog = tc.getCatalog();
            localSchema = tc.getSchema();
            localTableName = tc.getTableName();
        } else if (databaseMetaData.storesLowerCaseIdentifiers()) {
            localCatalog = tc.getCatalog() == null ? null : tc.getCatalog()
                    .toLowerCase();
            localSchema = tc.getSchema() == null ? null : tc.getSchema()
                    .toLowerCase();
            localTableName = tc.getTableName() == null ? null : tc
                    .getTableName().toLowerCase();
            // TODO add
			schema = null == schema ? null : schema.toLowerCase();
        } else if (databaseMetaData.storesUpperCaseIdentifiers()) {
            localCatalog = tc.getCatalog() == null ? null : tc.getCatalog()
                    .toUpperCase();
            localSchema = tc.getSchema() == null ? null : tc.getSchema()
                    .toUpperCase();
            localTableName = tc.getTableName() == null ? null : tc
                    .getTableName().toUpperCase();
            // TODO add
			schema = null == schema ? null : schema.toUpperCase();
        } else {
            localCatalog = tc.getCatalog();
            localSchema = tc.getSchema();
            localTableName = tc.getTableName();
        }

        if (tc.isWildcardEscapingEnabled()) {
            String escapeString = databaseMetaData.getSearchStringEscape();

            StringBuilder sb = new StringBuilder();
            StringTokenizer st;
            if (localSchema != null) {
                st = new StringTokenizer(localSchema, "_%", true); //$NON-NLS-1$
                while (st.hasMoreTokens()) {
                    String token = st.nextToken();
                    if (token.equals("_") //$NON-NLS-1$
                            || token.equals("%")) { //$NON-NLS-1$
                        sb.append(escapeString);
                    }
                    sb.append(token);
                }
                localSchema = sb.toString();
            }

            sb.setLength(0);
            st = new StringTokenizer(localTableName, "_%", true); //$NON-NLS-1$
            while (st.hasMoreTokens()) {
                String token = st.nextToken();
                if (token.equals("_") //$NON-NLS-1$
                        || token.equals("%")) { //$NON-NLS-1$
                    sb.append(escapeString);
                }
                sb.append(token);
            }
            localTableName = sb.toString();
        }

        Map<ActualTableName, List<IntrospectedColumn>> answer = new HashMap<ActualTableName, List<IntrospectedColumn>>();

        if (logger.isDebugEnabled()) {
            String fullTableName = composeFullyQualifiedTableName(localCatalog, localSchema,
                            localTableName, '.');
            logger.debug(getString("Tracing.1", fullTableName)); //$NON-NLS-1$
        }

//        ResultSet rs = databaseMetaData.getColumns(localCatalog, localSchema,
//                localTableName, null);
        // TODO edit
		String tSchema = StringUtils.isNotBlank(localSchema) ? localSchema : schema;
        ResultSet rs = databaseMetaData.getColumns(localCatalog, tSchema, localTableName, null);

        while (rs.next()) {
            IntrospectedColumn introspectedColumn = ObjectFactory
                    .createIntrospectedColumn(context);

            introspectedColumn.setTableAlias(tc.getAlias());
            introspectedColumn.setJdbcType(rs.getInt("DATA_TYPE")); //$NON-NLS-1$
            introspectedColumn.setLength(rs.getInt("COLUMN_SIZE")); //$NON-NLS-1$
            introspectedColumn.setActualColumnName(rs.getString("COLUMN_NAME")); //$NON-NLS-1$
            introspectedColumn
                    .setNullable(rs.getInt("NULLABLE") == DatabaseMetaData.columnNullable); //$NON-NLS-1$
            introspectedColumn.setScale(rs.getInt("DECIMAL_DIGITS")); //$NON-NLS-1$
            introspectedColumn.setRemarks(rs.getString("REMARKS")); //$NON-NLS-1$
            introspectedColumn.setDefaultValue(rs.getString("COLUMN_DEF")); //$NON-NLS-1$

            ActualTableName atn = new ActualTableName(
                    rs.getString("TABLE_CAT"), //$NON-NLS-1$
                    rs.getString("TABLE_SCHEM"), //$NON-NLS-1$
                    rs.getString("TABLE_NAME")); //$NON-NLS-1$

            List<IntrospectedColumn> columns = answer.get(atn);
            if (columns == null) {
                columns = new ArrayList<IntrospectedColumn>();
                answer.put(atn, columns);
            }

            columns.add(introspectedColumn);

            if (logger.isDebugEnabled()) {
                logger.debug(getString(
                        "Tracing.2", //$NON-NLS-1$
                        introspectedColumn.getActualColumnName(), Integer
                                .toString(introspectedColumn.getJdbcType()),
                        atn.toString()));
            }
        }

        closeResultSet(rs);

        if (answer.size() > 1
                && !stringContainsSQLWildcard(localSchema)
                && !stringContainsSQLWildcard(localTableName)) {
            // issue a warning if there is more than one table and
            // no wildcards were used
            ActualTableName inputAtn = new ActualTableName(tc.getCatalog(), tc
                    .getSchema(), tc.getTableName());

            StringBuilder sb = new StringBuilder();
            boolean comma = false;
            for (ActualTableName atn : answer.keySet()) {
                if (comma) {
                    sb.append(',');
                } else {
                    comma = true;
                }
                sb.append(atn.toString());
            }

            warnings.add(getString("Warning.25", //$NON-NLS-1$
                    inputAtn.toString(), sb.toString()));
        }

        return answer;
    }

    private List<IntrospectedTable> calculateIntrospectedTables(
            TableConfiguration tc,
            Map<ActualTableName, List<IntrospectedColumn>> columns) {
        boolean delimitIdentifiers = tc.isDelimitIdentifiers()
                || stringContainsSpace(tc.getCatalog())
                || stringContainsSpace(tc.getSchema())
                || stringContainsSpace(tc.getTableName());

        List<IntrospectedTable> answer = new ArrayList<IntrospectedTable>();

        for (Map.Entry<ActualTableName, List<IntrospectedColumn>> entry : columns
                .entrySet()) {
            ActualTableName atn = entry.getKey();

            // we only use the returned catalog and schema if something was
            // actually
            // specified on the table configuration. If something was returned
            // from the DB for these fields, but nothing was specified on the
            // table
            // configuration, then some sort of DB default is being returned
            // and we don't want that in our SQL
            FullyQualifiedTable table = new FullyQualifiedTable(
                    stringHasValue(tc.getCatalog()) ? atn
                            .getCatalog() : null,
                    stringHasValue(tc.getSchema()) ? atn
                            .getSchema() : null,
                    atn.getTableName(),
                    tc.getDomainObjectName(),
                    tc.getAlias(),
                    isTrue(tc.getProperty(PropertyRegistry.TABLE_IGNORE_QUALIFIERS_AT_RUNTIME)),
                    tc.getProperty(PropertyRegistry.TABLE_RUNTIME_CATALOG),
                    tc.getProperty(PropertyRegistry.TABLE_RUNTIME_SCHEMA),
                    tc.getProperty(PropertyRegistry.TABLE_RUNTIME_TABLE_NAME),
                    delimitIdentifiers, context);

            IntrospectedTable introspectedTable = ObjectFactory
                    .createIntrospectedTable(tc, table, context);

            for (IntrospectedColumn introspectedColumn : entry.getValue()) {
                introspectedTable.addColumn(introspectedColumn);
            }

            calculatePrimaryKey(table, introspectedTable);

            answer.add(introspectedTable);
        }

        return answer;
    }
}

/*
 *  Copyright 2009 The Apache Software Foundation
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.mybatis.generator.codegen.mybatis3;

import java.util.ArrayList;
import java.util.List;

import org.mybatis.generator.api.GeneratedJavaFile;
import org.mybatis.generator.api.GeneratedXmlFile;
import org.mybatis.generator.api.IntrospectedTable;
import org.mybatis.generator.api.ProgressCallback;
import org.mybatis.generator.api.dom.java.CompilationUnit;
import org.mybatis.generator.api.dom.xml.Document;
import org.mybatis.generator.codegen.AbstractGenerator;
import org.mybatis.generator.codegen.AbstractJavaClientGenerator;
import org.mybatis.generator.codegen.AbstractJavaGenerator;
import org.mybatis.generator.codegen.AbstractXmlGenerator;
import org.mybatis.generator.codegen.mybatis3.javamapper.AnnotatedClientGenerator;
import org.mybatis.generator.codegen.mybatis3.javamapper.JavaMapperGenerator;
import org.mybatis.generator.codegen.mybatis3.javamapper.MixedClientGenerator;
import org.mybatis.generator.codegen.mybatis3.model.BaseRecordGenerator;
import org.mybatis.generator.codegen.mybatis3.model.ExampleGenerator;
import org.mybatis.generator.codegen.mybatis3.model.PrimaryKeyGenerator;
import org.mybatis.generator.codegen.mybatis3.model.RecordWithBLOBsGenerator;
import org.mybatis.generator.codegen.mybatis3.xmlmapper.XMLMapperGenerator;
import org.mybatis.generator.config.PropertyRegistry;
import org.mybatis.generator.internal.ObjectFactory;

/**
 * 重写，以支持mergeable属性<br>
 * 可不用重新打包jar，直接在工程中按此包结构重写即可
 * @author Jeff Butler
 * 
 */
public class IntrospectedTableMyBatis3Impl extends IntrospectedTable {
    protected List<AbstractJavaGenerator> javaModelGenerators;
    protected List<AbstractJavaGenerator> clientGenerators;
    protected AbstractXmlGenerator xmlMapperGenerator;

    public IntrospectedTableMyBatis3Impl() {
        super(TargetRuntime.MYBATIS3);
        javaModelGenerators = new ArrayList<AbstractJavaGenerator>();
        clientGenerators = new ArrayList<AbstractJavaGenerator>();
    }

    @Override
    public void calculateGenerators(List<String> warnings,
            ProgressCallback progressCallback) {
        calculateJavaModelGenerators(warnings, progressCallback);
        
        AbstractJavaClientGenerator javaClientGenerator =
            calculateClientGenerators(warnings, progressCallback);
            
        calculateXmlMapperGenerator(javaClientGenerator, warnings, progressCallback);
    }

    protected void calculateXmlMapperGenerator(AbstractJavaClientGenerator javaClientGenerator, 
            List<String> warnings,
            ProgressCallback progressCallback) {
        if (javaClientGenerator == null) {
            if (context.getSqlMapGeneratorConfiguration() != null) {
                xmlMapperGenerator = new XMLMapperGenerator();
            }
        } else {
            xmlMapperGenerator = javaClientGenerator.getMatchedXMLGenerator();
        }
        
        initializeAbstractGenerator(xmlMapperGenerator, warnings,
                progressCallback);
    }

    /**
     * 
     * @param warnings
     * @param progressCallback
     * @return true if an XML generator is required
     */
    protected AbstractJavaClientGenerator calculateClientGenerators(List<String> warnings,
            ProgressCallback progressCallback) {
        if (!rules.generateJavaClient()) {
            return null;
        }
        
        AbstractJavaClientGenerator javaGenerator = createJavaClientGenerator();
        if (javaGenerator == null) {
            return null;
        }

        initializeAbstractGenerator(javaGenerator, warnings, progressCallback);
        clientGenerators.add(javaGenerator);
        
        return javaGenerator;
    }
    
    protected AbstractJavaClientGenerator createJavaClientGenerator() {
        if (context.getJavaClientGeneratorConfiguration() == null) {
            return null;
        }
        
        String type = context.getJavaClientGeneratorConfiguration()
                .getConfigurationType();

        AbstractJavaClientGenerator javaGenerator;
        if ("XMLMAPPER".equalsIgnoreCase(type)) { //$NON-NLS-1$
            javaGenerator = new JavaMapperGenerator();
        } else if ("MIXEDMAPPER".equalsIgnoreCase(type)) { //$NON-NLS-1$
            javaGenerator = new MixedClientGenerator();
        } else if ("ANNOTATEDMAPPER".equalsIgnoreCase(type)) { //$NON-NLS-1$
            javaGenerator = new AnnotatedClientGenerator();
        } else if ("MAPPER".equalsIgnoreCase(type)) { //$NON-NLS-1$
            javaGenerator = new JavaMapperGenerator();
        } else {
            javaGenerator = (AbstractJavaClientGenerator) ObjectFactory
                    .createInternalObject(type);
        }
        
        return javaGenerator;
    }

    protected void calculateJavaModelGenerators(List<String> warnings,
            ProgressCallback progressCallback) {
        if (getRules().generateExampleClass()) {
            AbstractJavaGenerator javaGenerator = new ExampleGenerator();
            initializeAbstractGenerator(javaGenerator, warnings,
                    progressCallback);
            javaModelGenerators.add(javaGenerator);
        }

        if (getRules().generatePrimaryKeyClass()) {
            AbstractJavaGenerator javaGenerator = new PrimaryKeyGenerator();
            initializeAbstractGenerator(javaGenerator, warnings,
                    progressCallback);
            javaModelGenerators.add(javaGenerator);
        }

        if (getRules().generateBaseRecordClass()) {
            AbstractJavaGenerator javaGenerator = new BaseRecordGenerator();
            initializeAbstractGenerator(javaGenerator, warnings,
                    progressCallback);
            javaModelGenerators.add(javaGenerator);
        }

        if (getRules().generateRecordWithBLOBsClass()) {
            AbstractJavaGenerator javaGenerator = new RecordWithBLOBsGenerator();
            initializeAbstractGenerator(javaGenerator, warnings,
                    progressCallback);
            javaModelGenerators.add(javaGenerator);
        }
    }

    protected void initializeAbstractGenerator(
            AbstractGenerator abstractGenerator, List<String> warnings,
            ProgressCallback progressCallback) {
        if (abstractGenerator == null) {
            return;
        }
        
        abstractGenerator.setContext(context);
        abstractGenerator.setIntrospectedTable(this);
        abstractGenerator.setProgressCallback(progressCallback);
        abstractGenerator.setWarnings(warnings);
    }

    @Override
    public List<GeneratedJavaFile> getGeneratedJavaFiles() {
        List<GeneratedJavaFile> answer = new ArrayList<GeneratedJavaFile>();

        for (AbstractJavaGenerator javaGenerator : javaModelGenerators) {
            List<CompilationUnit> compilationUnits = javaGenerator
                    .getCompilationUnits();
            for (CompilationUnit compilationUnit : compilationUnits) {
                GeneratedJavaFile gjf = new GeneratedJavaFile(compilationUnit,
                        context.getJavaModelGeneratorConfiguration()
                                .getTargetProject(),
                                context.getProperty(PropertyRegistry.CONTEXT_JAVA_FILE_ENCODING),
                                context.getJavaFormatter());
                answer.add(gjf);
            }
        }

        for (AbstractJavaGenerator javaGenerator : clientGenerators) {
            List<CompilationUnit> compilationUnits = javaGenerator
                    .getCompilationUnits();
            for (CompilationUnit compilationUnit : compilationUnits) {
                GeneratedJavaFile gjf = new GeneratedJavaFile(compilationUnit,
                        context.getJavaClientGeneratorConfiguration()
                                .getTargetProject(),
                                context.getProperty(PropertyRegistry.CONTEXT_JAVA_FILE_ENCODING),
                                context.getJavaFormatter());
                answer.add(gjf);
            }
        }

        return answer;
    }

    @Override
    public List<GeneratedXmlFile> getGeneratedXmlFiles() {
        List<GeneratedXmlFile> answer = new ArrayList<GeneratedXmlFile>();

        if (xmlMapperGenerator != null) {
            Document document = xmlMapperGenerator.getDocument();
			/**
			 * 原来中的 GeneratedXmlFile 保留；将其中构造函数中的true 修改为 ： false; 设置
			 * isMergeable = false； 在生成 xml文件的时候，将不是合并，而是直接覆盖；
			 */
            
//            GeneratedXmlFile gxf = new GeneratedXmlFile(document,
//                getMyBatis3XmlMapperFileName(), getMyBatis3XmlMapperPackage(),
//                context.getSqlMapGeneratorConfiguration().getTargetProject(),
//                true, context.getXmlFormatter());
			String tmp = context.getProperty("mergeable");
			boolean mergeable = false;
			if ("true".equalsIgnoreCase(tmp)) {
				mergeable = true;
			}
			GeneratedXmlFile gxf = new GeneratedXmlFile(document,
					getMyBatis3XmlMapperFileName(),
					getMyBatis3XmlMapperPackage(), context
							.getSqlMapGeneratorConfiguration()
							.getTargetProject(), mergeable,
					context.getXmlFormatter());
            if (context.getPlugins().sqlMapGenerated(gxf, this)) {
                answer.add(gxf);
            }
        }

        return answer;
    }

    @Override
    public int getGenerationSteps() {
        return javaModelGenerators.size() + clientGenerators.size() +
            (xmlMapperGenerator == null ? 0 : 1);
    }

    @Override
    public boolean isJava5Targeted() {
        return true;
    }

    @Override
    public boolean requiresXMLGenerator() {
        AbstractJavaClientGenerator javaClientGenerator =
            createJavaClientGenerator();
        
        if (javaClientGenerator == null) {
            return false;
        } else {
            return javaClientGenerator.requiresXMLGenerator();
        }
    }
}

<!--
MyBatis Generator中文文档:http://blog.csdn.net/isea533/article/details/42102297
使用Mybatis的Generator可能导致的一个错误: http://www.tuicool.com/articles/MN7bAbF
mybatis-generator重新生成代码时的SQL映射文件覆盖: http://my.oschina.net/u/140938/blog/220006
-->

<!--
maven 依赖
<dependency>
	<groupId>org.mybatis.generator</groupId>
	<artifactId>mybatis-generator-core</artifactId>
	<version>1.3.2</version>
	<scope>test</scope>
</dependency>
-->

<!-- XML示例 -->
<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration> 
	<properties resource="system-config/dev.properties"/>
<!-- 配置mysql 驱动jar包路径.用了绝对路径 -->
<!-- 	<classPathEntry -->
<!-- 	<classPathEntry  location="D:\Maven2\repository\net\sourceforge\jtds\jtds\1.3.0\jtds-1.3.0.jar"/> -->
<!-- 	<classPathEntry  location="D:\maven\repository\com\microsoft\sqlserver\sqljdbc4\4.2.0\sqljdbc4-4.2.0.jar"/>  -->
	<!-- 为了防止生成的代码中有很多注释，比较难看，加入下面的配置控制 -->
	<context id="lis_tables" targetRuntime="MyBatis3" defaultModelType="flat">
		<property name="mergeable" value="false"/> 
		<property name="schema" value="lis_dev"/>
		<property name="sqldate" value="true"/>
		<commentGenerator>
			<!-- 去除自动生成的注释 -->
			<property name="suppressAllComments" value="true" />
			<!-- 阻止生成的注释包含时间戳 -->
			<property name="suppressDate" value="true" />
		</commentGenerator> 
		<!-- 注释控制完毕 --> 
		<!-- 数据库连接 -->
		<jdbcConnection driverClass="${lis.jdbc.driverClassName}"
			connectionURL="${lis.jdbc.url}"
			userId="${lis.jdbc.username}" password="${lis.jdbc.password}">
		</jdbcConnection>
<!-- 		<jdbcConnection driverClass="com.mysql.jdbc.Driver" -->
<!-- 			connectionURL="jdbc:mysql://localhost:3306/cignacmb" -->
<!-- 			userId="root" password="root"> -->
<!-- 		</jdbcConnection> -->
		<!-- com.microsoft.sqlserver.jdbc.SQLServerDriver -->
<!-- 		<jdbcConnection driverClass="net.sourceforge.jtds.jdbc.Driver" -->
<!-- 			connectionURL="jdbc:jtds:sqlserver://SD-20120429CJGQ;DatabaseName=cignacmb" -->
<!-- 			userId="lg_dev" password="lg_dev"> -->
<!-- 		</jdbcConnection> -->
<!-- 		<jdbcConnection driverClass="oracle.jdbc.driver.OracleDriver" -->
<!-- 			connectionURL="jdbc:oracle:thin:@10.141.141.131:1521:gis" -->
<!-- 			userId="lis_dev" password="lis_dev"> -->
<!-- 		</jdbcConnection> -->
		<javaTypeResolver>
			<property name="forceBigDecimals" value="false" />
		</javaTypeResolver> 
		
		<!-- 数据表对应的model 层 -->
		<javaModelGenerator targetPackage="com.cignacmb.productdef.lis.model.pub"
			targetProject="src/main/java">
<!-- 			<property name="constructorBased" value="true" /> -->
			<property name="enableSubPackages" value="false" />
			<property name="trimStrings" value="true" />
		</javaModelGenerator> 
		
		<!-- sql mapper 映射配置文件 -->
		<sqlMapGenerator targetPackage="com.cignacmb.productdef.lis.mapper.pub"
			targetProject="src/main/resources">
			<property name="enableSubPackages" value="false" />
		</sqlMapGenerator> 
		
		<!-- 在ibatis2 中是dao层，但在mybatis3中，其实就是mapper接口 -->
		<javaClientGenerator type="XMLMAPPER"
			targetPackage="com.cignacmb.productdef.lis.mapper.pub" 
			targetProject="src/main/java">
		</javaClientGenerator> 
		
		<!-- 要对那些数据表进行生成操作，必须要有一个. -->
		<table tableName="pd_lmrisk" domainObjectName="PDLMRiskModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>
		<table tableName="pd_lmriskapp" domainObjectName="PDLMRiskAppModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>
		<table tableName="pd_lmriskpay" domainObjectName="PDLMRiskPayModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>
		<table tableName="pd_lmriskrela" domainObjectName="PDLMRiskRelaModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>

		<table tableName="pd_lmriskduty" domainObjectName="PDLMRiskDutyModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>
		<table tableName="pd_lmduty" domainObjectName="PDLMDutyModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>
		<table tableName="pd_lmdutypay" domainObjectName="PDLMDutyPayModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>
		<table tableName="pd_lmdutyget" domainObjectName="PDLMDutyGetModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>

		<table tableName="ldmaxno" domainObjectName="LDMaxNoModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>
		<table tableName="pd_basefield" domainObjectName="PDBaseFieldModel" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/>

	</context>
</generatorConfiguration>

<!-- java调用 -->
	public static void main(String[] args) {
		Logger logger = Logger.getLogger(GenMain.class);
		long startTime = System.currentTimeMillis();
		
		logger.info("start ...");
		List<String> warnings = new ArrayList<String>();
		boolean overwrite = true;
		String genCfg = "/mbgConfiguration.xml";
		File configFile = new File(GenMain.class.getResource(genCfg).getFile());
		ConfigurationParser cp = new ConfigurationParser(warnings);
		DefaultShellCallback callback = new DefaultShellCallback(overwrite);
		try {
			Configuration config = cp.parseConfiguration(configFile);
			MyBatisGenerator myBatisGenerator = new MyBatisGenerator(config,
					callback, warnings);
			myBatisGenerator.generate(null);
		} catch (InvalidConfigurationException e) {
			logger.error(e.getMessage(), e);
		} catch (SQLException e) {
			logger.error(e.getMessage(), e);
		} catch (IOException e) {
			logger.error(e.getMessage(), e);
		} catch (InterruptedException e) {
			logger.error(e.getMessage(), e);
		} catch (XMLParserException e) {
			logger.error(e.getMessage(), e);
		}
		logger.info("end ... >> " + (System.currentTimeMillis() - startTime));
	}

<!-- web.xml 可解决post乱码问题 -->
	<!-- 编码格式 -->
	<filter>
        <filter-name>encodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
         <init-param>
      		<param-name>forceEncoding</param-name>
      		<param-value>true</param-value>
    	</init-param>
    </filter>
    <filter-mapping>
        <filter-name>encodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

<!-- jsp-config 用来说明包含的页面默认按照什么编码格式包含。web-app 标签的version必须是2.4的 -->
	<jsp-config>
		<jsp-property-group>
			<url-pattern>*.jsp</url-pattern>
			<el-ignored>true</el-ignored>
			<page-encoding>UTF-8</page-encoding>
			<scripting-invalid>false</scripting-invalid>
			<include-prelude></include-prelude>
			<include-coda></include-coda>
		</jsp-property-group>
	</jsp-config>

<!-- 如果get方式乱码，一般是将tomcat中conf目录下server.xml文件中加入： -->
<Connector port="8080" maxHttpHeaderSize="8192"
	maxThreads="150" minSpareThreads="25" maxSpareThreads="75"
	enableLookups="false" redirectPort="8443" acceptCount="100"
	connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="UTF-8" />

/**
 * 单元格单击编辑，及禁用单元格单击编辑扩展
 * EasyUI中文站 1.4.2 - jQuery EasyUI 
 * http://92ui.net/index.aspx 
 * 需再扩展：
 * 移除焦点后自动提交
 * 
 * 调用示例：
 * $("#dg").datagrid('enableCellEditing');
 * $("#dg").datagrid('disabledCellEditing');
 */
$.extend($.fn.datagrid.methods, {
    editCell : function(jq, param) {  
        return jq.each(function() {  
            var opts = $(this).datagrid('options');  
            var fields = $(this).datagrid('getColumnFields', true).concat(  
                    $(this).datagrid('getColumnFields'));  
            for (var i = 0; i < fields.length; i++) {  
                var col = $(this).datagrid('getColumnOption', fields[i]);  
                col.editor1 = col.editor;  
                if (fields[i] != param.field) {  
                    col.editor = null;  
                }  
            }  
            $(this).datagrid('beginEdit', param.index);  
            var ed = $(this).datagrid('getEditor', param);  
            if (ed) {  
                if ($(ed.target).hasClass('textbox-f')) {  
                    $(ed.target).textbox('textbox').focus();  
                } else {  
                    $(ed.target).focus();  
                }  
            }  
            for (var i = 0; i < fields.length; i++) {  
                var col = $(this).datagrid('getColumnOption', fields[i]);  
                col.editor = col.editor1;  
            }  
        });  
    },
    /**
     * 开启单元格单击编辑
     */
    enableCellEditing : function(jq) {  
        return jq.each(function() {  
            var dg = $(this);  
            var opts = dg.datagrid('options');  
            opts.oldOnClickCell = opts.onClickCell;  
            opts.onClickCell = function(index, field) {  
                if (opts.editIndex != undefined) {  
                    if (dg.datagrid('validateRow', opts.editIndex)) {  
                        dg.datagrid('endEdit', opts.editIndex);  
                        opts.editIndex = undefined;  
                    } else {  
                        return;  
                    }  
                }  
                dg.datagrid('selectRow', index).datagrid('editCell', {  
                    index : index,  
                    field : field  
                });  
                opts.editIndex = index;  
                opts.oldOnClickCell.call(this, index, field);  
            }  
        });  
    },
    /**
     * 禁用单元格单击编辑
     */
    disabledCellEditing: function(jq){
    	
    }
});

/**
 * 将DIV层里的所有元素按Name/Value的形式转换成JSON对象<br>
 * @param div
 * @return
 */
function divIntegrateToJSON(div){
	var json = {};
	var $paras = $("#" + div).find(":input[type=checkbox]");
	var inputArray = new Array();
	$.each($paras, function(){
		if($(this).attr("checked") == true){
			var exist = false;
			for ( var int = 0; int < inputArray.length; int++) {
				if(inputArray[int][0] == $.trim($(this).attr("name"))){
					inputArray[int][1][inputArray[int][1].length] = $.trim($(this).val());
					exist = true;
				}
			}
			if(!exist){
				var tempArray = new Array();
				tempArray[0] = $.trim($(this).attr("name"));
				tempArray[1] = new Array();
				tempArray[1][0] = $.trim($(this).val());
				inputArray[inputArray.length] = tempArray;
			}
		}
	});
	for ( var int = 0; int < inputArray.length; int++) {
		$.extend(json, eval("({" + inputArray[int][0] + ":inputArray[int][1]})"));
	}

	var $parasRadio = $("#" + div).find(":input[type=radio]");
	$.each($parasRadio, function(){
		if($(this).attr("checked") == true){
			$.extend(json, eval("({" + $.trim($(this).attr("name")) + ":'" + $.trim($(this).val()) + "'})"));
		}
	});
	
	$paras = $("#" + div).find(":input").not($paras).not($parasRadio);
	$.each($paras, function(i){
		if($.trim($(this).attr("name")) != "" && $.trim($(this).val()) != ""){
			$.extend(json, eval("({" + $.trim($(this).attr("name")) + ":'" + $.trim($(this).val()) + "'})"));
		}
	});
	return json;
};



$.fn.extend({
	/** 返回对象的Name/Value形式的JSON对象 */
	nvJson: function(){
		var key = $.trim($(this).attr("name"));
		var value = $.trim($(this).val());
		if(key != "" && value != ""){
			return $.parseJSON("{\"" + key + "\":\"" + value + "\"}");
		}else{
			return {};
		}
	}
});


/**
 * 页面数据加载<br>
 * 针对jQuery Mobile
 */
$.fn.extend({
	loadByAction: function(json){
		var deConfig = {
				url: "../pageLoadAction",	// Action地址
				dataSQLID: null,	// 数据查询脚本，以数组形式指定多个脚本
				dataSouce: DataSource.LMES, // 指定数据库：lmes-E服务系统，slis-核心，flexcc-咨诉系统
				paras: {}	// 查询参数
		};
		var config = {};
		$.extend(true, config, deConfig, json);
		if(null == config.url){
			alert('url is null');
		}
		var paraJSON = {};
		$.extend(true, paraJSON, config.paras, {dataSouce: config.dataSouce});
		$.extend(true, paraJSON, {dataSQLID: config.dataSQLID});
		var result = getAjaxData(config.url, paraJSON);
		if(result["_state"] == "SUCCESS"){
			$(this).loadByData(result["_data"]);
		}else{
			alert("页面数据加载异常");
		}
	},
	loadByData: function(data){
		if(null == data || undefined == data) return;
		if($.isJSON(data) == false) return;
		for(var key in data){
			var $ele = $("input[name=" + key.toLowerCase() + "]");
			if(null == $ele || $ele.length == 0) continue;
			if($ele.length == 1) $ele.val(data[key]);
			else{
				// 针对radio、checkbox处理
				// TODO
			}
		}
	}
});

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>JSON eval</title>
</head>
<body>
<script type="text/javascript" src="../../lib/jeasyui/jquery.min.js"></script>
<script type="text/javascript">
var json = {"k1":"123", "k2":"属性操作", "k3":"fda"};
// 有大小写区分
console.log(eval("json.k1"));
console.log(eval("json.K1"));	// undefined 
console.log(eval("json.k2"));
console.log(eval("jSon.k2"));	// SCRIPT5009: “jSon”未定义 
</script>
</body>
</html>

/**
<dependency>
	<groupId>org.mvel</groupId>
	<artifactId>mvel2</artifactId>
	<version>2.2.4.Final</version>
</dependency>
 */

import java.lang.reflect.Field;
import java.text.ParseException;
import java.util.Date;

import junit.framework.TestCase;

import org.apache.commons.lang3.time.DateUtils;
import org.mvel2.MVEL;

/**
 * @author c1panx
 * @ 2015年5月19日  上午11:46:38
 */
public class MVELTest extends TestCase {

	// 常用日期格式
	private final String[] pattern = new String[] { "yyyy-MM", "yyyyMM",
			"yyyy/MM", "yyyyMMdd", "yyyy-MM-dd", "yyyy/MM/dd",
			"yyyyMMddHHmmss", "yyyy-MM-dd HH:mm:ss", "yyyy/MM/dd HH:mm:ss",
			"yyyy-MM-dd HH:mm:ss.SSS" };
	
	public void testEval(){
		/**
		 *  1. MVEL属性区分大小写
		 *  2. 不存在的属性会抛异常
		 *  3. String可强制转换成数字
		 */
		MVELTestBean bean = new MVELTestBean();
		this.setFiledValue(bean, "id", "123");
		this.setFiledValue(bean, "name", "法是基");
//		this.setFiledValue(bean, "makedate", new Date());
		this.setFiledValue(bean, "makedate", "2015-05-19");
		this.setFiledValue(bean, "modifyDate", "法是基");

		System.out.println("result name: " + MVEL.eval("name", bean));
		System.out.println("result: " + MVEL.eval("name == null", bean));
		System.out.println("result id: " + this.getFiledValue(bean, "ID"));
		System.out.println("result makedate: " + this.getFiledValue(bean, "makedate"));
		System.out.println("@>> " + bean.toString());
	}
	
	/**
	 * 1. property与属性大小写不一致问题；
	 * 2. 日期字符串自动换成Date；
	 * @param obj  对象
	 * @param property 属性名
	 * @param value 设置成的值
	 */
	private void setFiledValue(Object obj, String property, Object value){
		if (null == obj) {
			return;
		}
		Field[] fields= obj.getClass().getDeclaredFields();
		if (null == fields) {
			return;
		}
		for (Field field : fields) {
			String fieldName = field.getName();
			if (fieldName.equalsIgnoreCase(property)) {
				// 日期字符串处理
				if (field.getType() == Date.class && null != value
						&& value.getClass() == String.class) {
					// 字符串转日期
					try {
						value = DateUtils.parseDate((String)value, pattern);
					} catch (ParseException e) {
						e.printStackTrace();
					}
				}
				MVEL.setProperty(obj, fieldName, value);
				break;
			}
		}
	}
	
	/**
	 * 获取属性值
	 * @param obj 对象
	 * @param property 属性名，不区分大小写
	 * @return
	 */
	private Object getFiledValue(Object obj, String property) {
		if (null == obj) {
			return null;
		}
		// 需考虑父类属性
		Field[] fields = obj.getClass().getDeclaredFields();
		if (null == fields) {
			return null;
		}
		for (Field field : fields) {
			String fieldName = field.getName();
			if (fieldName.equalsIgnoreCase(property)) {
				return MVEL.eval(fieldName, obj);
			}
		}
		return null;
	}
}



/**
 * @author c1panx
 * @ 2015年5月19日  上午11:46:54
 */
class MVELTestBean implements Serializable {

	private static final long serialVersionUID = 1L;
	private final SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

	private Integer id;
	private String name;
	private Date makeDate;

	public Integer getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public Date getMakeDate() {
		return makeDate;
	}

	public void setMakeDate(Date makeDate) {
		this.makeDate = makeDate;
	}

	public String toString(){
		StringBuffer buffer = new StringBuffer();
		buffer.append(this.getClass().getSimpleName());
		buffer.append("{");
		buffer.append("id=" + this.id);
		buffer.append(", name=" + this.name);
		if(null == this.makeDate){
			buffer.append(", makeDate=" + null);
		} else {
			buffer.append(", makeDate=" + sdf.format(this.makeDate));	
		}
		buffer.append("}");
		return buffer.toString();
	}
}