SqlMapConfigParser

package com.ibatis.sqlmap.engine.builder.xml;

import com.ibatis.common.resources.*;
import com.ibatis.common.xml.*;
import com.ibatis.sqlmap.client.*;
import com.ibatis.sqlmap.engine.config.*;
import com.ibatis.sqlmap.engine.transaction.*;
import com.ibatis.sqlmap.engine.datasource.*;
import com.ibatis.sqlmap.engine.mapping.result.*;
import org.w3c.dom.Node;

import java.io.*;
import java.util.Properties;

//璇ョ被涓昏鏄鐞嗚В鏋怱QL Map閰嶇疆鏂囦欢
public class SqlMapConfigParser {

// parser鍙橀噺鏄В鏋怷ML鐨勬牳蹇�
protected final NodeletParser parser = new NodeletParser();

// state鍙橀噺鍏呭綋涓�釜涓棿鍙橀噺鐨勫鍣紝鎴栬�鏄竴涓厤缃俊鎭殑闂ㄦ埛
private XmlParserState state = new XmlParserState();

private boolean usingStreams = false;

public SqlMapConfigParser() {

// 楠岃瘉dtd鏂囦欢锛岃缃獙璇佸弬鏁�
parser.setValidation(true);
parser.setEntityResolver(new SqlMapClasspathEntityResolver());

//杩涜鍒濆鍖栫殑璧嬪�澶勭悊
addSqlMapConfigNodelets();
addGlobalPropNodelets();
addSettingsNodelets();
addTypeAliasNodelets();
addTypeHandlerNodelets();
addTransactionManagerNodelets();
addSqlMapNodelets();
addResultObjectFactoryNodelets();

}

public SqlMapClient parse(Reader reader, Properties props) {
if (props != null)
state.setGlobalProps(props);
return parse(reader);
}

//鍩轰簬瀛楃妯″紡瑙ｆ瀽XML閰嶇疆鏂囦欢
public SqlMapClient parse(Reader reader) {
try {
usingStreams = false;

parser.parse(reader);
return state.getConfig().getClient();
} catch (Exception e) {
throw new RuntimeException("Error occurred.  Cause: " + e, e);
}
}

public SqlMapClient parse(InputStream inputStream, Properties props) {
if (props != null)
state.setGlobalProps(props);
return parse(inputStream);
}

    // 鍩轰簬瀛楄妭妯″紡瑙ｆ瀽XML閰嶇疆鏂囦欢
public SqlMapClient parse(InputStream inputStream) {
try {
usingStreams = true;

parser.parse(inputStream);
return state.getConfig().getClient();
} catch (Exception e) {
throw new RuntimeException("Error occurred.  Cause: " + e, e);
}
}

// 澶勭悊sqlMapConfig鏍硅妭鐐逛俊鎭紝琛ㄦ槑鍏跺凡缁忕粨鏉�
private void addSqlMapConfigNodelets() {
parser.addNodelet("/sqlMapConfig/end()", new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().finalizeSqlMapConfig();
}
});
}

// 澶勭悊鑺傜偣/sqlMapConfig/properties淇℃伅锛屼骇鐢熶竴涓叏灞�殑Properties
private void addGlobalPropNodelets() {
parser.addNodelet("/sqlMapConfig/properties", new Nodelet() {
public void process(Node node) throws Exception {
// 鑾峰緱/sqlMapConfig/properties鑺傜偣涓嬬殑鍏ㄩ儴灞炴�鍊硷紝骞舵妸杩欎簺灞炴�鍊艰祴鍊肩粰Properties绫诲瀷鐨勫彉閲廰ttributes
Properties attributes = NodeletUtils.parseAttributes(node,
state.getGlobalProps());
String resource = attributes.getProperty("resource");
String url = attributes.getProperty("url");

// 鐢眘tate鍙橀噺浣滀负涓棿浣撲紶閫掍俊鎭�
state.setGlobalProperties(resource, url);
}
});
}


//澶勭悊鑺傜偣/sqlMapConfig/settings淇℃伅锛屼骇鐢熷叏灞�彉閲�
private void addSettingsNodelets() {
parser.addNodelet("/sqlMapConfig/settings", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node,
state.getGlobalProps());
SqlMapConfiguration config = state.getConfig();

String classInfoCacheEnabledAttr = attributes
.getProperty("classInfoCacheEnabled");
boolean classInfoCacheEnabled = (classInfoCacheEnabledAttr == null || "true"
.equals(classInfoCacheEnabledAttr));
config.setClassInfoCacheEnabled(classInfoCacheEnabled);

String lazyLoadingEnabledAttr = attributes
.getProperty("lazyLoadingEnabled");
boolean lazyLoadingEnabled = (lazyLoadingEnabledAttr == null || "true"
.equals(lazyLoadingEnabledAttr));
config.setLazyLoadingEnabled(lazyLoadingEnabled);

String statementCachingEnabledAttr = attributes
.getProperty("statementCachingEnabled");
boolean statementCachingEnabled = (statementCachingEnabledAttr == null || "true"
.equals(statementCachingEnabledAttr));
config.setStatementCachingEnabled(statementCachingEnabled);

String cacheModelsEnabledAttr = attributes
.getProperty("cacheModelsEnabled");
boolean cacheModelsEnabled = (cacheModelsEnabledAttr == null || "true"
.equals(cacheModelsEnabledAttr));
config.setCacheModelsEnabled(cacheModelsEnabled);

String enhancementEnabledAttr = attributes
.getProperty("enhancementEnabled");
boolean enhancementEnabled = (enhancementEnabledAttr == null || "true"
.equals(enhancementEnabledAttr));
config.setEnhancementEnabled(enhancementEnabled);

String useColumnLabelAttr = attributes
.getProperty("useColumnLabel");
boolean useColumnLabel = (useColumnLabelAttr == null || "true"
.equals(useColumnLabelAttr));
config.setUseColumnLabel(useColumnLabel);

String forceMultipleResultSetSupportAttr = attributes
.getProperty("forceMultipleResultSetSupport");
boolean forceMultipleResultSetSupport = "true"
.equals(forceMultipleResultSetSupportAttr);
config
.setForceMultipleResultSetSupport(forceMultipleResultSetSupport);

String defaultTimeoutAttr = attributes
.getProperty("defaultStatementTimeout");
Integer defaultTimeout = defaultTimeoutAttr == null ? null
: Integer.valueOf(defaultTimeoutAttr);
config.setDefaultStatementTimeout(defaultTimeout);

String useStatementNamespacesAttr = attributes
.getProperty("useStatementNamespaces");
boolean useStatementNamespaces = "true"
.equals(useStatementNamespacesAttr);
state.setUseStatementNamespaces(useStatementNamespaces);
}
});
}


    // 澶勭悊鑺傜偣/sqlMapConfig/typeAlias淇℃伅锛屽鐞嗗埆鍚嶏紙typeAlias锛夎浆鍖�
private void addTypeAliasNodelets() {
parser.addNodelet("/sqlMapConfig/typeAlias", new Nodelet() {
public void process(Node node) throws Exception {
Properties prop = NodeletUtils.parseAttributes(node, state
.getGlobalProps());
String alias = prop.getProperty("alias");
String type = prop.getProperty("type");
//鑾峰彇鍒悕鍙婂叾瀵瑰簲鐨凜lass绫诲瀷锛屾敞鍐屽埌TypeHandlerFactory宸ュ巶瀵硅薄涓�
state.getConfig().getTypeHandlerFactory().putTypeAlias(alias,
type);
}
});
}

    // 澶勭悊鑺傜偣/sqlMapConfig/typeHandler淇℃伅锛屽鍔犳柊鐨刯dbcType
private void addTypeHandlerNodelets() {
parser.addNodelet("/sqlMapConfig/typeHandler", new Nodelet() {
public void process(Node node) throws Exception {
Properties prop = NodeletUtils.parseAttributes(node, state
.getGlobalProps());
String jdbcType = prop.getProperty("jdbcType");
String javaType = prop.getProperty("javaType");
String callback = prop.getProperty("callback");

javaType = state.getConfig().getTypeHandlerFactory()
.resolveAlias(javaType);
callback = state.getConfig().getTypeHandlerFactory()
.resolveAlias(callback);

state.getConfig().newTypeHandler(
Resources.classForName(javaType), jdbcType,
Resources.instantiate(callback));
}
});
}

    // 澶勭悊鑺傜偣/sqlMapConfig/transactionManager淇℃伅锛屽寘鎷瑃ransactionManager鍜宒ataSource
private void addTransactionManagerNodelets() {
        // 澶勭悊鑺傜偣/sqlMapConfig/transactionManager/property鐨勪俊鎭紝杞寲鍒皌ransactionManager瀵硅薄鐨勭浉鍏冲睘鎬т腑
parser.addNodelet("/sqlMapConfig/transactionManager/property",
new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(
node, state.getGlobalProps());
String name = attributes.getProperty("name");
String value = NodeletUtils.parsePropertyTokens(
attributes.getProperty("value"), state
.getGlobalProps());
state.getTxProps().setProperty(name, value);
}
});

        // 澶勭悊鑺傜偣/sqlMapConfig/transactionManager/锛岀敓鎴恡ransactionManager瀵硅薄骞惰繘琛岀粨鏉熷鐞�
parser.addNodelet("/sqlMapConfig/transactionManager/end()",
new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(
node, state.getGlobalProps());
String type = attributes.getProperty("type");
boolean commitRequired = "true".equals(attributes
.getProperty("commitRequired"));

state.getConfig().getErrorContext().setActivity(
"configuring the transaction manager");
type = state.getConfig().getTypeHandlerFactory()
.resolveAlias(type);
TransactionManager txManager;
try {
state.getConfig().getErrorContext().setMoreInfo(
"Check the transaction manager type or class.");
TransactionConfig config = (TransactionConfig) Resources
.instantiate(type);
config.setDataSource(state.getDataSource());
state
.getConfig()
.getErrorContext()
.setMoreInfo(
"Check the transactio nmanager properties or configuration.");
config.setProperties(state.getTxProps());
config.setForceCommit(commitRequired);
config.setDataSource(state.getDataSource());
state.getConfig().getErrorContext().setMoreInfo(
null);
txManager = new TransactionManager(config);
} catch (Exception e) {
if (e instanceof SqlMapException) {
throw (SqlMapException) e;
} else {
throw new SqlMapException(
"Error initializing TransactionManager.  Could not instantiate TransactionConfig.  Cause: "
+ e, e);
}
}
state.getConfig().setTransactionManager(txManager);
}
});


         // 澶勭悊鑺傜偣/sqlMapConfig/transactionManager/dataSource/property锛屽鐞哾ataSource鑺傜偣鐨刾roperty鍐呭
parser.addNodelet(
"/sqlMapConfig/transactionManager/dataSource/property",
new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(
node, state.getGlobalProps());
String name = attributes.getProperty("name");
String value = NodeletUtils.parsePropertyTokens(
attributes.getProperty("value"), state
.getGlobalProps());
state.getDsProps().setProperty(name, value);
}
});

        // 澶勭悊鑺傜偣/sqlMapConfig/transactionManager/dataSource/end()锛屽姩鎬佸疄渚嬪寲dataSource瀵硅薄锛岀劧鍚庤繘琛屽睘鎬у垵濮嬪寲
parser.addNodelet("/sqlMapConfig/transactionManager/dataSource/end()",
new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().getErrorContext().setActivity(
"configuring the data source");

Properties attributes = NodeletUtils.parseAttributes(
node, state.getGlobalProps());

String type = attributes.getProperty("type");
Properties props = state.getDsProps();

type = state.getConfig().getTypeHandlerFactory()
.resolveAlias(type);
try {
state.getConfig().getErrorContext().setMoreInfo(
"Check the data source type or class.");
DataSourceFactory dsFactory = (DataSourceFactory) Resources
.instantiate(type);
state.getConfig().getErrorContext().setMoreInfo(
"Check the data source properties or configuration.");
dsFactory.initialize(props);
state.setDataSource(dsFactory.getDataSource());
state.getConfig().getErrorContext().setMoreInfo(
null);
} catch (Exception e) {
if (e instanceof SqlMapException) {
throw (SqlMapException) e;
} else {
throw new SqlMapException(
"Error initializing DataSource.  Could not instantiate DataSourceFactory.  Cause: "
+ e, e);
}
}
}
});
}


    //澶勭悊鑺傜偣/sqlMapConfig/sqlMap锛屽幓鑾峰彇sqlMap鐨勬槧灏勬枃浠讹紝鐒跺悗瀵瑰悇涓槧灏勬枃浠惰繘琛岃鍙栧鐞�
protected void addSqlMapNodelets() {
parser.addNodelet("/sqlMapConfig/sqlMap", new Nodelet() {
public void process(Node node) throws Exception {
state.getConfig().getErrorContext().setActivity(
"loading the SQL Map resource");

Properties attributes = NodeletUtils.parseAttributes(node,
state.getGlobalProps());

String resource = attributes.getProperty("resource");
String url = attributes.getProperty("url");

if (usingStreams) {
//閲囩敤瀛楄妭娴佹ā寮忔潵璇诲彇鏂囦欢
InputStream inputStream = null;
if (resource != null) {
state.getConfig().getErrorContext().setResource(
resource);
inputStream = Resources.getResourceAsStream(resource);
} else if (url != null) {
state.getConfig().getErrorContext().setResource(url);
inputStream = Resources.getUrlAsStream(url);
} else {
throw new SqlMapException(
"The <sqlMap> element requires either a resource or a url attribute.");
}

new SqlMapParser(state).parse(inputStream);
} else {
                     // 閲囩敤瀛楃娴佹ā寮忔潵璇诲彇鏂囦欢
Reader reader = null;
if (resource != null) {
state.getConfig().getErrorContext().setResource(
resource);
reader = Resources.getResourceAsReader(resource);
} else if (url != null) {
state.getConfig().getErrorContext().setResource(url);
reader = Resources.getUrlAsReader(url);
} else {
throw new SqlMapException(
"The <sqlMap> element requires either a resource or a url attribute.");
}

new SqlMapParser(state).parse(reader);
}
}
});
}

    // 澶勭悊鑺傜偣/sqlMapConfig/resultObjectFactory锛屽垵濮嬪寲鏂扮殑resultObjectFactory
private void addResultObjectFactoryNodelets() {
parser.addNodelet("/sqlMapConfig/resultObjectFactory", new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(node,
state.getGlobalProps());
String type = attributes.getProperty("type");

state.getConfig().getErrorContext().setActivity(
"configuring the Result Object Factory");
ResultObjectFactory rof;
try {
rof = (ResultObjectFactory) Resources.instantiate(type);
state.getConfig().setResultObjectFactory(rof);
} catch (Exception e) {
throw new SqlMapException(
"Error instantiating resultObjectFactory: " + type,
e);
}

}
});
parser.addNodelet("/sqlMapConfig/resultObjectFactory/property",
new Nodelet() {
public void process(Node node) throws Exception {
Properties attributes = NodeletUtils.parseAttributes(
node, state.getGlobalProps());
String name = attributes.getProperty("name");
String value = NodeletUtils.parsePropertyTokens(
attributes.getProperty("value"), state
.getGlobalProps());
state.getConfig().getDelegate()
.getResultObjectFactory().setProperty(name,
value);
}
});
}

}