import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

public class Configuration {
    private DataSource dataSource;

    public DataSource getDataSource() {
        return dataSource;
    }

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Map<String, MappedStatement> getMappedStatementMap() {
        return mappedStatementMap;
    }

    public void setMappedStatementMap(Map<String, MappedStatement> mappedStatementMap) {
        this.mappedStatementMap = mappedStatementMap;
    }

    //key statementId  value:封裝好的 mappedStatement
    Map<String,MappedStatement> mappedStatementMap = new HashMap<>();
}

public class   MappedStatement {

    //id標(biāo)識(shí)
    private String id;
    // 返回值類型
    private String resultType;
    // 參數(shù)值類型
    private String paramterType;
    // sql語句
    private String sql;

public String getId() {
        return id;
    }

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

    public String getResultType() {
        return resultType;
    }

    public void setResultType(String resultType) {
        this.resultType = resultType;
    }

    public String getParamterType() {
        return paramterType;
    }

    public void setParamterType(String paramterType) {
        this.paramterType = paramterType;
    }

    public String getSql() {
        return sql;
    }

    public void setSql(String sql) {
        this.sql = sql;
    }

}

package com.hg.config;
import com.hg.pojo.Configuration;
import com.hg.pojo.MappedStatement;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.InputStream;
import java.util.List;

public class XMLMapperBuilder {
    private Configuration configuration;
    public XMLMapperBuilder(Configuration configuration) {
        this.configuration = configuration;
    }
    public void parse(InputStream inputStream) throws DocumentException {
        Document document = new SAXReader().read(inputStream);
        Element rootElement = document.getRootElement();
        String namespace = rootElement.attributeValue("namespace");
        List<Element> list = rootElement.selectNodes("http://select");
        for (Element element : list) {
            String id = element.attributeValue("id");
            String resultType = element.attributeValue("resultType");
            String paramterType = element.attributeValue("paramterType");
            String sqlText = element.getTextTrim();
            MappedStatement mappedStatement = new MappedStatement();
            mappedStatement.setId(id);
            mappedStatement.setParamterType(paramterType);
            mappedStatement.setResultType(resultType);
            mappedStatement.setSql(sqlText);
            String key = namespace+"."+id;
            configuration.getMappedStatementMap().put(key,mappedStatement);
        }
    }
}

public class DefaultSqlSessionFactory implements SqlSessionFactory{
    private Configuration configuration;

    public DefaultSqlSessionFactory(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public SqlSession openSession() {
        return new DefaultSqlSession(configuration);
    }
}

public class DefaultSqlSession implements SqlSession {
    private Configuration configuration;

    public DefaultSqlSession(Configuration configuration) {
        this.configuration = configuration;
    }

    @Override
    public <E> List<E> selectList(String statementId, Object... params) throws Exception {
//        將要完成對(duì)simpleExcutor里的query方法
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
        List<Object> list = simpleExecutor.query(configuration, mappedStatement, params);
        return (List<E>) list;
    }

    @Override
    public <T> T selectOne(String statementId, Object... params) throws Exception {
        List<Object> objects = selectList(statementId, params);
        if(objects.size()==1){
            return (T) objects.get(0);
        }else{
            throw new RuntimeException("查詢結(jié)果為空或返回結(jié)果過多");
        }
    }

    @Override
    public int insert(String statementId, Object... params) throws Exception {
        return this.update(statementId,params);
    }

    @Override
    public int delete(String statementId, Object... params) throws Exception {
        return this.update(statementId,params);
    }


    @Override
    public int update(String statementId, Object... params) throws Exception {
        SimpleExecutor simpleExecutor = new SimpleExecutor();
        MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
        int rows = simpleExecutor.update(configuration, mappedStatement, params);
        return rows;
    }



    @Override
    public <T> T getMapper(Class<?> mapperClass) {
        //使用動(dòng)態(tài)代理為DAO接口生成代理對(duì)象；并返回
        Object proxyInstance = Proxy.newProxyInstance(DefaultSqlSession.class.getClassLoader(), new Class[]{mapperClass}, (proxy, method, args) -> {
//                底層就是執(zhí)行jdbc  根據(jù)不同情況，調(diào)用  selectList和selectOne
//                準(zhǔn)備參數(shù)  1statementid  sql的唯一標(biāo)識(shí)  namespace.id=接口權(quán)限定名.方法名
            System.out.println(DefaultSqlSession.class.getClassLoader());
            System.out.println(mapperClass.getClassLoader());
            String methodName = method.getName();
            String className = method.getDeclaringClass().getName();
            String statementId = className+"."+methodName;
            MappedStatement mappedStatement = configuration.getMappedStatementMap().get(statementId);
            SqlCommandType sqlCommandType = mappedStatement.getSqlCommandType();
            switch (sqlCommandType){
                case SELECT:
                    //準(zhǔn)備參數(shù)2：params：args
                    //獲取被調(diào)用方法的返回值類型
                    Type genericReturnType = method.getGenericReturnType();
                    //判斷是否進(jìn)行了泛型類型參數(shù)化
                    if(genericReturnType instanceof ParameterizedType){
                        List<Object> objects = selectList(statementId, args);
                        return objects;
                    }
                    return selectOne(statementId,args);
                case DELETE:
                    return delete(statementId,args);
                case INSERT:
                    return insert(statementId,args);
                case UPDATE:
                    return update(statementId,args);
                default:
                    return null;
            }

        });
        return (T) proxyInstance;
    }
}

public interface Executor {
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception;

    public int update(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception;

}

public class SimpleExecutor implements Executor {
    @Override
    public <E> List<E> query(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {
        //1注冊(cè)驅(qū)動(dòng)，獲取連接
        Connection connection = configuration.getDataSource().getConnection();
        //2獲取sql語句 轉(zhuǎn)換sql語句  #{} 轉(zhuǎn)換成 ? 轉(zhuǎn)換的過程對(duì)#{}的值解析出來并存儲(chǔ)
        String sql = mappedStatement.getSql();
        BoundSql boundSql = getBoundSql(sql);
        //3獲取預(yù)處理對(duì)象
        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());

        //4設(shè)置參數(shù)
//        獲取到參數(shù)的全路徑
        String paramterType = mappedStatement.getParamterType();
        Class<?> paramterTypeClass = getClassType(paramterType);
        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
        for (int i = 0; i < parameterMappingList.size(); i++) {
            ParameterMapping parameterMapping = parameterMappingList.get(i);
            String content = parameterMapping.getContent();
            //反射
            Field declaredField = paramterTypeClass.getDeclaredField(content);
//            設(shè)置暴力訪問
            declaredField.setAccessible(true);
            Object o = declaredField.get(params[0]);
            preparedStatement.setObject(i+1,o);

        }

        //5執(zhí)行sql
        ResultSet resultSet = preparedStatement.executeQuery();
        String resultType = mappedStatement.getResultType();
        Class<?> resultTypeClass = getClassType(resultType);


        ArrayList<Object> objects = new ArrayList<>();

        //6封裝返回結(jié)果集
        while(resultSet.next()){
            Object o = resultTypeClass.newInstance();
            //元數(shù)據(jù)
            ResultSetMetaData metaData = resultSet.getMetaData();
//            getColumnCount  獲取總列數(shù)  就是屬性的個(gè)數(shù)
            for (int i = 1; i <= metaData.getColumnCount(); i++) {
                //字段名
                String columnName = metaData.getColumnName(i);
                //字段的值
                Object value = resultSet.getObject(columnName);
                //使用反射或者內(nèi)省，根據(jù)數(shù)據(jù)庫表和實(shí)體的對(duì)應(yīng)關(guān)系，完成封裝
                PropertyDescriptor propertyDescriptor = new PropertyDescriptor(columnName,resultTypeClass);
                Method writeMethod = propertyDescriptor.getWriteMethod();
                writeMethod.invoke(o,value);
            }
            objects.add(o);
        }

        return (List<E>) objects;
    }


    @Override
    public int update(Configuration configuration, MappedStatement mappedStatement, Object... params) throws Exception {

        //1注冊(cè)驅(qū)動(dòng)，獲取連接
        Connection connection = configuration.getDataSource().getConnection();
        //2獲取sql語句 轉(zhuǎn)換sql語句  #{} 轉(zhuǎn)換成 ? 轉(zhuǎn)換的過程對(duì)#{}的值解析出來并存儲(chǔ)
        String sql = mappedStatement.getSql();
        BoundSql boundSql = getBoundSql(sql);
        //3獲取預(yù)處理對(duì)象
        PreparedStatement preparedStatement = connection.prepareStatement(boundSql.getSqlText());

        //4設(shè)置參數(shù)
//        獲取到參數(shù)的全路徑
        String paramterType = mappedStatement.getParamterType();
        Class<?> paramterTypeClass = getClassType(paramterType);
        List<ParameterMapping> parameterMappingList = boundSql.getParameterMappingList();
        for (int i = 0; i < parameterMappingList.size(); i++) {
            ParameterMapping parameterMapping = parameterMappingList.get(i);
            String content = parameterMapping.getContent();
            //反射
            Field declaredField = paramterTypeClass.getDeclaredField(content);
//            設(shè)置暴力訪問
            declaredField.setAccessible(true);
            Object o = declaredField.get(params[0]);
            preparedStatement.setObject(i+1,o);

        }

        //5執(zhí)行sql
        int rows = preparedStatement.executeUpdate();
        return rows;
    }


    private Class<?> getClassType(String paramterType) throws ClassNotFoundException {
        if (paramterType!=null){
            Class<?> aClass = Class.forName(paramterType);
            return aClass;
        }
        return null;
    }

    //對(duì)#{}進(jìn)行解析，將#{}使用？代替，解析#{}中的值進(jìn)行存儲(chǔ)
    private BoundSql getBoundSql(String sql) {
        //標(biāo)記處理類：配置標(biāo)記解析器來完成對(duì)占位符的解析處理工作
        ParameterMappingTokenHandler parameterMappingTokenHandler = new ParameterMappingTokenHandler();
        //標(biāo)記解析器
        GenericTokenParser genericTokenParser = new GenericTokenParser("#{", "}", parameterMappingTokenHandler);
        //用標(biāo)記解析器解析出來的sql
        String parseSql = genericTokenParser.parse(sql);
//        #{}解析出來的參數(shù)名稱
        List<ParameterMapping> parameterMappings = parameterMappingTokenHandler.getParameterMappings();
        BoundSql boundSql = new BoundSql(parseSql, parameterMappings);
        return boundSql;
    }
}

public class GenericTokenParser {

  private final String openToken; //開始標(biāo)記
  private final String closeToken; //結(jié)束標(biāo)記
  private final TokenHandler handler; //標(biāo)記處理器

  public GenericTokenParser(String openToken, String closeToken, TokenHandler handler) {
    this.openToken = openToken;
    this.closeToken = closeToken;
    this.handler = handler;
  }

  /**
   * 解析${}和#{}
   * @param text
   * @return
   * 該方法主要實(shí)現(xiàn)了配置文件、腳本等片段中占位符的解析、處理工作，并返回最終需要的數(shù)據(jù)。
   * 其中，解析工作由該方法完成，處理工作是由處理器handler的handleToken()方法來實(shí)現(xiàn)
   */
  public String parse(String text) {
    // 驗(yàn)證參數(shù)問題，如果是null，就返回空字符串。
    if (text == null || text.isEmpty()) {
      return "";
    }

    // 下面繼續(xù)驗(yàn)證是否包含開始標(biāo)簽，如果不包含，默認(rèn)不是占位符，直接原樣返回即可，否則繼續(xù)執(zhí)行。
    int start = text.indexOf(openToken, 0);
    if (start == -1) {
      return text;
    }

   // 把text轉(zhuǎn)成字符數(shù)組src，并且定義默認(rèn)偏移量offset=0、存儲(chǔ)最終需要返回字符串的變量builder，
    // text變量中占位符對(duì)應(yīng)的變量名expression。判斷start是否大于-1(即text中是否存在openToken)，如果存在就執(zhí)行下面代碼
    char[] src = text.toCharArray();
    int offset = 0;
    final StringBuilder builder = new StringBuilder();
    StringBuilder expression = null;
    while (start > -1) {
     // 判斷如果開始標(biāo)記前如果有轉(zhuǎn)義字符，就不作為openToken進(jìn)行處理，否則繼續(xù)處理
      if (start > 0 && src[start - 1] == '\\') {
        builder.append(src, offset, start - offset - 1).append(openToken);
        offset = start + openToken.length();
      } else {
        //重置expression變量，避免空指針或者老數(shù)據(jù)干擾。
        if (expression == null) {
          expression = new StringBuilder();
        } else {
          expression.setLength(0);
        }
        builder.append(src, offset, start - offset);
        offset = start + openToken.length();
        int end = text.indexOf(closeToken, offset);
        while (end > -1) {////存在結(jié)束標(biāo)記時(shí)
          if (end > offset && src[end - 1] == '\\') {//如果結(jié)束標(biāo)記前面有轉(zhuǎn)義字符時(shí)
            // this close token is escaped. remove the backslash and continue.
            expression.append(src, offset, end - offset - 1).append(closeToken);
            offset = end + closeToken.length();
            end = text.indexOf(closeToken, offset);
          } else {//不存在轉(zhuǎn)義字符，即需要作為參數(shù)進(jìn)行處理
            expression.append(src, offset, end - offset);
            offset = end + closeToken.length();
            break;
          }
        }
        if (end == -1) {
          // close token was not found.
          builder.append(src, start, src.length - start);
          offset = src.length;
        } else {
          //首先根據(jù)參數(shù)的key（即expression）進(jìn)行參數(shù)處理，返回?作為占位符
          builder.append(handler.handleToken(expression.toString()));
          offset = end + closeToken.length();
        }
      }
      start = text.indexOf(openToken, offset);
    }
    if (offset < src.length) {
      builder.append(src, offset, src.length - offset);
    }
    return builder.toString();
  }
}


public class ParameterMapping {

    private String content;

    public ParameterMapping(String content) {
        this.content = content;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}


public class ParameterMappingTokenHandler implements TokenHandler {
    private List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();

    // context是參數(shù)名稱 #{id} #{username}

    public String handleToken(String content) 

主站蜘蛛池模板：
青青国产揄拍视频|
国产福利免费在线观看|
线观看的国产成人av天堂|
熟女一区二区中文字幕|
天天躁夜夜躁狠狠喷水|
欧美日韩在线视频|
国产精品无码专区|
久99久热免费视频播放|
精品亚洲没码中文字幕|
免费人成年激情视频在线观看|
一个人免费观看WWW在线视频|
国产成人精品无人区一区|
亚洲精品国产一二三区|
丰满妇女强制高潮18xxxx|
99亚洲男女激情在线观看|
电影在线观看+伦理片|
亚洲av无码之国产精品网址蜜芽
|
亚洲欧美电影在线一区二区|
亚洲精品一区二区三区大桥未久|
人妻系列无码专区69影院|
免费福利视频一区二区三区高清|
欧美日韩一线|
澳门永久av免费网站|
国产无遮挡又黄又爽不要vip软件
国产成人精品一区二区秒拍1o
|
中文字幕亚洲综合久久青草|
又黄又爽又色的少妇毛片|
热99久久这里只有精品|
中文字幕v亚洲日本在线电影|
欧美18videosex性欧美tube1080|
丁香五月亚洲综合在线国内自拍|
邵武市|
中文字幕av无码免费一区|
日本道不卡一二三区视频|
久久狠狠高潮亚洲精品夜色|
欧美视频专区一二在线观看|
曰本丰满熟妇xxxx性|
中文成人无字幕乱码精品区|
国产成人一区二区三区在线|
成人国产精品一区二区网站公司
|
日韩人妻精品中文字幕专区|
精品亚洲一区二区三区四区|