红黑树（Red Black Tree）

package com.zjy.mybatis.test;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Map.Entry;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import javassist.ClassPool;

import javassist.CtClass;

import javassist.CtMethod;

import javassist.CtNewMethod;

import com.zjy.jdbc.util.DBUtil;

public class MyBatisReflectUtil {

private static MyBatisConfig config;

static {

try {

String configXml = "/mybatisConfig.xml";

config = MyBatisParseUtil.parse(configXml);

} catch (Exception e) {

e.printStackTrace();

}

}

public static Map<String, Object> convert(Object obj) throws Exception {

List<Class> list = new ArrayList<Class>();

list.add(Integer.class);

list.add(Double.class);

list.add(Float.class);

list.add(String.class);

list.add(int.class);

list.add(float.class);

list.add(double.class);

Class clazz = obj.getClass();

Map<String, Object> result = new HashMap<String, Object>();

if (list.contains(obj.getClass())) {

result.put("$1", obj);

} else {

Field[] fields = clazz.getDeclaredFields();

for (Field field : fields) {

String name = field.getName();

field.setAccessible(true);

Object value = field.get(obj);

result.put(name, value);

}

}

return result;

}

public static Object getMapper(String type) throws Exception {

ClassPool pool = ClassPool.getDefault();

// String type="com.zjy.mybatis.model.Customer";

String proxyPuffix = "$Proxy_";

String proxyType = type + proxyPuffix;

CtClass interfaceClazz = pool.get(type);

CtClass implClazz = pool.makeClass(proxyType);

implClazz.addInterface(interfaceClazz);

Class mapperInterface = Class.forName(type);

Method methods[] = mapperInterface.getDeclaredMethods();

String mapperClazzName = mapperInterface.getName();

for (Method method : methods) {

String methodName = method.getName();

if ( methodName.equals("query")) {

continue;

}

CtMethod cm = interfaceClazz.getDeclaredMethod(method.getName());

CtMethod methodImpl = CtNewMethod.copy(cm, implClazz, null);

StringBuilder body =new StringBuilder("{");

Map<String, MapperConfig> mapperConfigs = config.getMapperConfig();

MapperConfig cfg = mapperConfigs.get(type);

Map<String, Sql> map = cfg.getSqls();

Sql sql=map.get(methodName);

if(sql.getSqlType().equals("select")){

String resultType=sql.getResultType();

body.append("return ("+resultType+")");

}

body.append(MyBatisReflectUtil.class.getName()+ ".executeById(\"" + mapperClazzName + "\",\""+ methodName + "\",$1);");;

body.append("}");

System.out.println(body.toString());

methodImpl.setBody(body.toString());

implClazz.addMethod(methodImpl);

}

Class clazz = implClazz.toClass();

return clazz.newInstance();

}

public static Object executeById(String nameSpace, String id, int param) {

return executeById(nameSpace, id, Integer.valueOf(param));

}

public static Object executeById(String nameSpace, String id, Object param) {

try {

Map<String, MapperConfig> mapperConfigs = config.getMapperConfig();

MapperConfig cfg = mapperConfigs.get(nameSpace);

Map<String, Sql> map = cfg.getSqls();

Sql sql=map.get(id);

String executeSql = sql.getSql();

Map<String, Object> properties = MyBatisReflectUtil.convert(param);

if(sql.getSqlType().equals("select")){

String resultMapName=sql.getResultMap();

ResultMap resultMap=cfg.getResultMap().get(resultMapName);

return executeQuery(sql, resultMap, properties);

}else{

return execute(executeSql, properties);

}

} catch (Exception e) {

throw new IllegalArgumentException(e);

}

}

public static Object executeQuery(Sql sql, ResultMap map,Map<String, Object> properties)

throws Exception {

String reg = "\\#\\{([^\\}]*)\\}";

Pattern pattern = Pattern.compile(reg);

String querySql=sql.getSql();

Matcher matcher = pattern.matcher(querySql);

int i = 0;

List<ParameterPosition> list = new ArrayList<ParameterPosition>();

while (matcher.find()) {

String text = matcher.group(1);

ParameterPosition position = new ParameterPosition();

position.setIndex(i);

position.setName(text);

i = i + 1;

list.add(position);

}

querySql = querySql.replaceAll("\\#\\{([^\\}]*)\\}", "?");

Object paramterValues[] = new Object[list.size()];

for (int t = 0; t < list.size(); t++) {

ParameterPosition position = list.get(t);

int index = position.getIndex();

String name = position.getName();

if (properties.containsKey("$1")) {

paramterValues[index] = properties.get("$1");

} else {

paramterValues[index] = properties.get(name);

}

}

List<Map<String,Object>> resultSet=DBUtil.preExecuteQuery(querySql, paramterValues);

if(resultSet.size()==1){

String resultType=sql.getResultType();

Class resultClass=Class.forName(resultType);

Object result=resultClass.newInstance();

Map<String,Object> values=resultSet.get(0);

for(Entry<String,String> entry:map.getResultMap().entrySet()){

String property=entry.getKey();

String column=entry.getValue();

Field field=resultClass.getDeclaredField(property);

field.setAccessible(true);

field.set(result, values.get(column));

}

return result;

}

throw new IllegalArgumentException("返回多个值,暂时不支持!!");

}

public static boolean execute(String sql, Map<String, Object> properties)

throws Exception {

String reg = "\\#\\{([^\\}]*)\\}";

Pattern pattern = Pattern.compile(reg);

Matcher matcher = pattern.matcher(sql);

int i = 0;

List<ParameterPosition> list = new ArrayList<ParameterPosition>();

while (matcher.find()) {

String text = matcher.group(1);

ParameterPosition position = new ParameterPosition();

position.setIndex(i);

position.setName(text);

i = i + 1;

list.add(position);

}

sql = sql.replaceAll("\\#\\{([^\\}]*)\\}", "?");

Object paramterValues[] = new Object[list.size()];

for (int t = 0; t < list.size(); t++) {

ParameterPosition position = list.get(t);

int index = position.getIndex();

String name = position.getName();

if (properties.containsKey("$1")) {

paramterValues[index] = properties.get("$1");

} else {

paramterValues[index] = properties.get(name);

}

}

return DBUtil.preExecute(sql, paramterValues);

}

}

package com.zjy.mybatis.test;

import java.util.Map;

public class MapperConfig {

private String nameSpace;

private Map<String, Sql> upddateSqls;

private Map<String,ResultMap> resultMap;

public String getNameSpace() {

return nameSpace;

}

public void setNameSpace(String nameSpace) {

this.nameSpace = nameSpace;

}

public Map<String, Sql> getSqls() {

return upddateSqls;

}

public void setSqls(Map<String, Sql> updateSqls) {

this.upddateSqls = updateSqls;

}

public Map<String, ResultMap> getResultMap() {

return resultMap;

}

public void setResultMap(Map<String, ResultMap> resultMap) {

this.resultMap = resultMap;

}

}

package com.zjy.mybatis.test;

import java.util.Map;

public class MyBatisConfig {

private Map<String, String> dataSourceConfig;

private Map<String, MapperConfig> mapperConfig;

public Map<String, String> getDataSourceConfig() {

return dataSourceConfig;

}

public void setDataSourceConfig(Map<String, String> dataSourceConfig) {

this.dataSourceConfig = dataSourceConfig;

}

public Map<String, MapperConfig> getMapperConfig() {

return mapperConfig;

}

public void setMapperConfig(Map<String, MapperConfig> mapperConfig) {

this.mapperConfig = mapperConfig;

}

}

package com.zjy.mybatis.test;

import java.io.InputStream;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.dom4j.Document;

import org.dom4j.Element;

import org.dom4j.io.SAXReader;

public class MyBatisParseUtil {

public static Map<String, String> getDataSourceConfig(String configXml)

throws Exception {

// String configXml = "/mybatisConfig.xml";

SAXReader reader = new SAXReader();

if (!configXml.startsWith("/")) {

configXml = "/" + configXml;

}

Document document = reader.read(MyBatisMaker.class

.getResource(configXml));

List<Element> list = document

.selectNodes("/configuration/environments/environment/dataSource/property");

Map<String, String> config = new HashMap<String, String>();

for (Element node : list) {

String name = node.attributeValue("name");

String value = node.attributeValue("value");

config.put(name, value);

}

return config;

}

public static List<String> getMapperResources(String configXml)

throws Exception {

SAXReader reader = new SAXReader();

Document document = reader.read(MyBatisMaker.class

.getResource(configXml));

List<Element> list = document

.selectNodes("/configuration/mappers/mapper");

List<String> result = new ArrayList<String>();

for (Element node : list) {

String resource = node.attributeValue("resource");

result.add(resource);

}

return result;

}

public static MapperConfig parseMapper(String configXml) throws Exception {

SAXReader reader = new SAXReader();

if (!configXml.startsWith("/")) {

configXml = "/" + configXml;

}

InputStream inputStream = System.class.getResourceAsStream(configXml);

Document document = reader.read(inputStream);

Element root = document.getRootElement();

String mapperType = root.attributeValue("namespace");

List<String> expresses = new ArrayList<String>();

expresses.add("/mapper/insert");

expresses.add("/mapper/update");

expresses.add("/mapper/delete");

expresses.add("/mapper/select");

Map<String, Sql> sqls = new HashMap<String, Sql>();

for (String str : expresses) {

List<Element> elements = root.selectNodes(str);

for (Element ele : elements) {

String id = ele.attributeValue("id");

String parameterType = ele.attributeValue("parameterType");

String resultType = ele.attributeValue("resultType");

String resultMap = ele.attributeValue("resultMap");

String sqlText = ele.getText();

Sql sql = new Sql();

sql.setId(id);

sql.setParameterType(parameterType);

sql.setResultMap(resultMap);

sql.setResultType(resultType);

sql.setSql(sqlText);

String tagName=ele.getName();

sql.setSqlType(tagName);

sqls.put(sql.getId(), sql);

}

}

Map<String,ResultMap> resultMapList=parseResultMap(configXml);

MapperConfig result = new MapperConfig();

result.setNameSpace(mapperType);

result.setSqls(sqls);

result.setResultMap(resultMapList);

return result;

}

public static Map<String,ResultMap> parseResultMap(String configXml)throws Exception{

InputStream inputStream = System.class.getResourceAsStream(configXml);

SAXReader reader=new SAXReader();

Document document = reader.read(inputStream);

List<String> mapExpress=new ArrayList<String>();

mapExpress.add("id");

mapExpress.add("result");

List<Element> resultMapList=document.selectNodes("mapper/resultMap");

Map<String,ResultMap> result=new HashMap<String, ResultMap>();

for(Element resultEle:resultMapList){

String id=resultEle.attributeValue("id");

String type=resultEle.attributeValue("type");

ResultMap resultMap=new ResultMap();

resultMap.setId(id);

resultMap.setType(type);

Map<String,String> propertyMap=new HashMap<String, String>();

for(String express:mapExpress){

List<Element> elements=resultEle.selectNodes(express);

for(Element ele:elements){

String property=ele.attributeValue("property");

String column=ele.attributeValue("column");

propertyMap.put(property, column);

}

resultMap.setPropertyMap(propertyMap);

}

result.put(resultMap.getId(), resultMap);

}

return result;

}

public static MyBatisConfig parse(String configXml) throws Exception {

// String configXml = "/mybatisConfig.xml";

Map<String, String> dataSourceConfig = getDataSourceConfig(configXml);

List<String> resource = getMapperResources(configXml);

Map<String, MapperConfig> mappers = new HashMap<String, MapperConfig>();

for (String str : resource) {

MapperConfig config = parseMapper(str);

mappers.put(config.getNameSpace(), config);

}

MyBatisConfig myBatis = new MyBatisConfig();

myBatis.setDataSourceConfig(dataSourceConfig);

myBatis.setMapperConfig(mappers);

return myBatis;

}

}
本文出自 “体系架构” 博客，请务必保留此出处http://zhengjingyu.blog.51cto.com/3418943/636985