jx_ming
jx_ming

手写MyBatis框架

Mybaits和数据库交互的方式

  1. 使用传统的 MyBatis 提供的 API
  2. 使用 Mapper 接口

使用 Mapper 接口

MyBatis 将配置文件中的每一个 节点抽象为一个 Mapper 接口
这个接口中声明的方法和 节点中的 节点项对应，即 节点的id值为Mapper 接口中的方法名称，parameterType 值表示Mapper 对应方法的入参类型，而resultMap 值则对应了Mapper 接口表示的返回值类型或者返回结果集的元素类型。

根据MyBatis 的配置规范配置好后，通过SqlSession.getMapper(XXXMapper.class)方法，MyBatis 会根据相应的接口声明的方法信息，通过动态代理机制生成一个Mapper 实例，我们使用Mapper接口的某一个方法时，MyBatis会根据这个方法的方法名和参数类型，确定Statement Id，底层还是通过SqlSession.select(“statementId”,parameterObject);或者SqlSession.update(“statementId”,parameterObject); 等等来实现对数据库的操作，MyBatis引用Mapper 接口这种调用方式，纯粹是为了满足面向接口编程的需要。（其实还有一个原因是在于，面向接口的编程，使得用户在接口上可以使用注解来配置SQL语句，这样就可以脱离XML配置文件，实现“0配置”）。

数据处理层

数据处理层可以说是 MyBatis 的核心，从大的方面上讲，它主要完成两个功能

  1. 通过传入参数构建动态 SQL 语句
  2. SQL 语句的执行以及封装查询结果集成 List

框架支撑层

事务管理机制

事务管理机制对于 ORM 框架而言是不可缺少的一部分，事务管理机制的质量也是考量一个 ORM 框架是否优秀的一个标准。

连接池管理机制

由于创建一个数据库连接所占用的资源比较大，对数据吞吐量大和访问量非常大的应用而言，连接池的设计就显得非常重要。

缓存机制

为了提高数据利用率和减小服务器和数据库的压力，MyBatis 会对于一些查询提供会话级别的数据缓存，会将对某一次查询，放置到SqlSession 中，在允许的时间间隔内，对于完全相同的查询，MyBatis会直接将缓存结果返回给用户，而不用再到数据库中查找。

SQL语句的配置方式

传统的MyBatis 配置SQL语句方式就是使用XML文件进行配置的，但是这种方式不能很好地支持面向接口编程的理念，为了支持面向接口的编程，MyBatis 引入了Mapper接口的概念，面向接口的引入，对使用注解来配置SQL语句成为可能，用户只需要在接口上添加必要的注解即可，不用再去配置XML文件了，但是，目前的MyBatis 只是对注解配置SQL语句提供了有限的支持，某些高级功能还是要依赖XML配置文件配置SQL 语句。

引导层

引导层是配置和启动MyBatis配置信息的方式。MyBatis 提供两种方式来引导MyBatis ：基于XML配置文件的方式和基于Java API 的方式。

主要构件及其相互关系

从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个：

  • SqlSession：作为MyBatis工作的主要顶层API，表示和数据库交互的会话，完成必要数据库增删改查功能；
  • Executor：MyBatis执行器，是MyBatis 调度的核心，负责SQL语句的生成和查询缓存的维护；
  • StatementHandler：封装了JDBC Statement操作，负责对JDBC statement 的操作，如设置参数、将Statement结果集转换成List集合。
  • ParameterHandler：负责对用户传递的参数转换成JDBC Statement 所需要的参数；
  • ResultSetHandler：负责将JDBC返回的ResultSet结果集对象转换成List类型的集合；
  • TypeHandler：负责java数据类型和jdbc数据类型之间的映射和转换；
  • MappedStatement：MappedStatement维护了一条节点的封装；
  • SqlSource：负责根据用户传递的parameterObject，动态地生成SQL语句，将信息封装到BoundSql对象中，并返回；
  • BoundSql：表示动态生成的SQL语句以及相应的参数信息；
  • Configuration：MyBatis所有的配置信息都维持在Configuration对象之中；

手写MyBatis框架

定义JDBCUtils

package com.xiaoming.day21.orm.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public final class JDBCUtils {

   private static String connect;
   private static String driverClassName;
   private static String URL;
   private static String username;
   private static String password;
   private static boolean autoCommit;

   /** 声明一个 Connection类型的静态属性，用来缓存一个已经存在的连接对象 */
   private static Connection conn;

   static {
      config();
   }

   /**
    * 开头配置自己的数据库信息
    */
   private static void config() {
      /*
       * 获取驱动
       */
      driverClassName = "com.mysql.jdbc.Driver";
      /*
       * 获取URL
       */
      URL = "jdbc:mysql://47.102.136.26:3306/test?useUnicode=true&characterEncoding=utf8";
      /*
       * 获取用户名
       */
      username = "root";
      /*
       * 获取密码
       */
      password = "123456";
      /*
       * 设置是否自动提交，一般为false不用改
       */
      autoCommit = false;

   }

   /**
    * 载入数据库驱动类
    */
   private static boolean load() {
      try {
         Class.forName(driverClassName);
         return true;
      } catch (ClassNotFoundException e) {
         System.out.println("驱动类 " + driverClassName + " 加载失败");
      }

      return false;
   }

   /**
    * 专门检查缓存的连接是否不可以被使用 ，不可以被使用的话，就返回 true
    */
   private static boolean invalid() {
      if (conn != null) {
         try {
            if (conn.isClosed() || !conn.isValid(3)) {
               return true;
               /*
                * isValid方法是判断Connection是否有效,如果连接尚未关闭并且仍然有效，则返回 true
                */
            }
         } catch (SQLException e) {
            e.printStackTrace();
         }
         /*
          * conn 既不是 null 且也没有关闭 ，且 isValid 返回 true，说明是可以使用的 ( 返回 false )
          */
         return false;
      } else {
         return true;
      }
   }

   /**
    * 建立数据库连接
    */
   public static Connection connect() {
      if (invalid()) { /* invalid为true时，说明连接是失败的 */
         /* 加载驱动 */
         load();
         try {
            /* 建立连接 */
            conn = DriverManager.getConnection(URL, username, password);
         } catch (SQLException e) {
            System.out.println("建立 " + connect + " 数据库连接失败 , " + e.getMessage());
         }
      }
      return conn;
   }

   /**
    * 设置是否自动提交事务
    **/
   public static void transaction() {

      try {
         conn.setAutoCommit(autoCommit);
      } catch (SQLException e) {
         System.out.println("设置事务的提交方式为 : " + (autoCommit ? "自动提交" : "手动提交") + " 时失败: " + e.getMessage());
      }

   }

   /**
    * 创建 Statement 对象
    */
   public static Statement statement() {
      Statement st = null;
      connect();
      /* 如果连接是无效的就重新连接 */
      transaction();
      /* 设置事务的提交方式 */
      try {
         st = conn.createStatement();
      } catch (SQLException e) {
         System.out.println("创建 Statement 对象失败: " + e.getMessage());
      }

      return st;
   }

   /**
    * 根据给定的带参数占位符的SQL语句，创建 PreparedStatement 对象
    * 
    * @param SQL
    *            带参数占位符的SQL语句
    * @return 返回相应的 PreparedStatement 对象
    */
   private static PreparedStatement prepare(String SQL, boolean autoGeneratedKeys) {

      PreparedStatement ps = null;
      connect();
      /* 如果连接是无效的就重新连接 */
      transaction();
      /* 设置事务的提交方式 */
      try {
         if (autoGeneratedKeys) {
            ps = conn.prepareStatement(SQL, Statement.RETURN_GENERATED_KEYS);
         } else {
            ps = conn.prepareStatement(SQL);
         }
      } catch (SQLException e) {
         System.out.println("创建 PreparedStatement 对象失败: " + e.getMessage());
      }

      return ps;

   }

   public static ResultSet query(String SQL, List params) {

      if (SQL == null || SQL.trim().isEmpty() || !SQL.trim().toLowerCase().startsWith("select")) {
         throw new RuntimeException("你的SQL语句为空或不是查询语句");
      }
      ResultSet rs = null;
      if (params.size() > 0) {
         /* 说明 有参数 传入，就需要处理参数 */
         PreparedStatement ps = prepare(SQL, false);
         try {
            for (int i = 0; i < params.size(); i++) {
               ps.setObject(i + 1, params.get(i));
            }
            rs = ps.executeQuery();
         } catch (SQLException e) {
            System.out.println("执行SQL失败: " + e.getMessage());
         }
      } else {
         /* 说明没有传入任何参数 */
         Statement st = statement();
         try {
            rs = st.executeQuery(SQL); // 直接执行不带参数的 SQL 语句
         } catch (SQLException e) {
            System.out.println("执行SQL失败: " + e.getMessage());
         }
      }

      return rs;

   }

   private static Object typeof(Object o) {
      Object r = o;

      if (o instanceof java.sql.Timestamp) {
         return r;
      }
      // 将 java.util.Date 转成 java.sql.Date
      if (o instanceof java.util.Date) {
         java.util.Date d = (java.util.Date) o;
         r = new java.sql.Date(d.getTime());
         return r;
      }
      // 将 Character 或 char 变成 String
      if (o instanceof Character || o.getClass() == char.class) {
         r = String.valueOf(o);
         return r;
      }
      return r;
   }

   public static boolean execute(String SQL, Object... params) {
      if (SQL == null || SQL.trim().isEmpty() || SQL.trim().toLowerCase().startsWith("select")) {
         throw new RuntimeException("你的SQL语句为空或有错");
      }
      boolean r = false;
      /* 表示 执行 DDL 或 DML 操作是否成功的一个标识变量 */

      /* 获得 被执行的 SQL 语句的 前缀 */
      SQL = SQL.trim();
      SQL = SQL.toLowerCase();
      String prefix = SQL.substring(0, SQL.indexOf(" "));
      String operation = ""; // 用来保存操作类型的 变量
      // 根据前缀 确定操作
      switch (prefix) {
      case "create":
         operation = "create table";
         break;
      case "alter":
         operation = "update table";
         break;
      case "drop":
         operation = "drop table";
         break;
      case "truncate":
         operation = "truncate table";
         break;
      case "insert":
         operation = "insert :";
         break;
      case "update":
         operation = "update :";
         break;
      case "delete":
         operation = "delete :";
         break;
      }
      if (params.length > 0) { // 说明有参数
         PreparedStatement ps = prepare(SQL, false);
         Connection c = null;
         try {
            c = ps.getConnection();
         } catch (SQLException e) {
            e.printStackTrace();
         }
         try {
            for (int i = 0; i < params.length; i++) {
               Object p = params[i];
               p = typeof(p);
               ps.setObject(i + 1, p);
            }
            ps.executeUpdate();
            commit(c);
            r = true;
         } catch (SQLException e) {
            System.out.println(operation + " 失败: " + e.getMessage());
            rollback(c);
         }

      } else { // 说明没有参数

         Statement st = statement();
         Connection c = null;
         try {
            c = st.getConnection();
         } catch (SQLException e) {
            e.printStackTrace();
         }
         // 执行 DDL 或 DML 语句，并返回执行结果
         try {
            st.executeUpdate(SQL);
            commit(c); // 提交事务
            r = true;
         } catch (SQLException e) {
            System.out.println(operation + " 失败: " + e.getMessage());
            rollback(c); // 回滚事务
         }
      }
      return r;
   }

   /*
    * 
    * @param SQL 需要执行的 INSERT 语句
    * 
    * @param autoGeneratedKeys 指示是否需要返回由数据库产生的键
    * 
    * @param params 将要执行的SQL语句中包含的参数占位符的 参数值
    * 
    * @return 如果指定 autoGeneratedKeys 为 true 则返回由数据库产生的键； 如果指定 autoGeneratedKeys
    * 为 false 则返回受当前SQL影响的记录数目
    */
   public static int insert(String SQL, boolean autoGeneratedKeys, List params) {
      int var = -1;
      if (SQL == null || SQL.trim().isEmpty()) {
         throw new RuntimeException("你没有指定SQL语句，请检查是否指定了需要执行的SQL语句");
      }
      // 如果不是 insert 开头开头的语句
      if (!SQL.trim().toLowerCase().startsWith("insert")) {
         System.out.println(SQL.toLowerCase());
         throw new RuntimeException("你指定的SQL语句不是插入语句，请检查你的SQL语句");
      }
      // 获得 被执行的 SQL 语句的 前缀 ( 第一个单词 )
      SQL = SQL.trim();
      SQL = SQL.toLowerCase();
      if (params.size() > 0) { // 说明有参数
         PreparedStatement ps = prepare(SQL, autoGeneratedKeys);
         Connection c = null;
         try {
            c = ps.getConnection(); // 从 PreparedStatement 对象中获得 它对应的连接对象
         } catch (SQLException e) {
            e.printStackTrace();
         }
         try {
            for (int i = 0; i < params.size(); i++) {
               Object p = params.get(i);
               p = typeof(p);
               ps.setObject(i + 1, p);
            }
            int count = ps.executeUpdate();
            if (autoGeneratedKeys) { // 如果希望获得数据库产生的键
               ResultSet rs = ps.getGeneratedKeys(); // 获得数据库产生的键集
               if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
                  var = rs.getInt(1); // 获得值并赋值给 var 变量
               }
            } else {
               var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
            }
            commit(c);
         } catch (SQLException e) {
            System.out.println("数据保存失败: " + e.getMessage());
            rollback(c);
         }
      } else { // 说明没有参数
         Statement st = statement();
         Connection c = null;
         try {
            c = st.getConnection(); // 从 Statement 对象中获得 它对应的连接对象
         } catch (SQLException e) {
            e.printStackTrace();
         }
         // 执行 DDL 或 DML 语句，并返回执行结果
         try {
            int count = st.executeUpdate(SQL);
            if (autoGeneratedKeys) { // 如果企望获得数据库产生的键
               ResultSet rs = st.getGeneratedKeys(); // 获得数据库产生的键集
               if (rs.next()) { // 因为是保存的是单条记录，因此至多返回一个键
                  var = rs.getInt(1); // 获得值并赋值给 var 变量
               }
            } else {
               var = count; // 如果不需要获得，则将受SQL影像的记录数赋值给 var 变量
            }
            commit(c); // 提交事务
         } catch (SQLException e) {
            System.out.println("数据保存失败: " + e.getMessage());
            rollback(c); // 回滚事务
         }
      }
      return var;
   }

   /** 提交事务 */
   private static void commit(Connection c) {
      if (c != null && !autoCommit) {
         try {
            c.commit();
         } catch (SQLException e) {
            e.printStackTrace();
         }
      }
   }

   /** 回滚事务 */
   private static void rollback(Connection c) {
      if (c != null && !autoCommit) {
         try {
            c.rollback();
         } catch (SQLException e) {
            e.printStackTrace();
         }
      }
   }

   /**
    * 释放资源
    **/
   public static void release(Object cloaseable) {

      if (cloaseable != null) {

         if (cloaseable instanceof ResultSet) {
            ResultSet rs = (ResultSet) cloaseable;
            try {
               rs.close();
            } catch (SQLException e) {
               e.printStackTrace();
            }
         }

         if (cloaseable instanceof Statement) {
            Statement st = (Statement) cloaseable;
            try {
               st.close();
            } catch (SQLException e) {
               e.printStackTrace();
            }
         }

         if (cloaseable instanceof Connection) {
            Connection c = (Connection) cloaseable;
            try {
               c.close();
            } catch (SQLException e) {
               e.printStackTrace();
            }
         }

      }

   }

}
 
  
定义MyInvocationHandlerMbatis
 
  
insert思路
 
  
     
   
  1. 判断方法上是否存在@ExtInsert（自定义insert注解）
    2.  
   
  2. 获取 SQL 语句，即：获取注解 insert 语句
    3.  
   
  3. 获取方法上的参数和 SQL 参数进行匹配
    4.  
   
  4. 替换参数变为 ？
    5.  
   
  5. 调用 JDBC 底层代码执行语句
    6.  
  
 
  
select思路
 
  
     
   
  1. 判断方法上是否存在@ExtSelect
    2.  
   
  2. 获取 SQL 语句，获取注解 select 语句
    3.  
   
  3. 获取方法上的参数和 SQL 参数进行匹配
    4.  
   
  4. 替换参数变为 ？
    5.  
   
  5. 调用 JDBC 底层代码执行语句
    6.  
   
  6. 使用反射机制实例化对象 获取方法返回类型，进行实例化 
    
       
     
    1. 使用反射机制获取方法的类型
      2.  
     
    2. 判断是否有结果集，如果有结果集，再进行初始化
      3.  
     
    3. 使用反射机制，给对象赋值
      4.  
    
     
    7.  
  
 
  
代码
 
  
package com.xiaoming.day21.aop;

import com.xiaoming.day21.orm.annotation.ExtInsert;
import com.xiaoming.day21.orm.annotation.ExtParam;
import com.xiaoming.day21.orm.annotation.ExtSelect;
import com.xiaoming.day21.orm.utils.JDBCUtils;
import com.xiaoming.day21.orm.utils.SQLUtils;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 使用反射动态代理技术 拦截接口方法
 */
public class MyInvocationHandlerMybatis implements InvocationHandler {
    private Object object;

    public MyInvocationHandlerMybatis(Object object){
        this.object = object;
    }

    /**
     * 使用白话文翻译，@ExtInsert 封装过程
     *
     * 1. 判断方法上是否存在@ExtInsert
     * 2. 获取 SQL 语句，获取注解 Insert 语句
     * 3. 获取方法上的参数和 SQL 参数进行匹配
     * 4. 替换参数变为 ？
     * 5. 调用 JDBC 底层代码执行语句
     *
     * @param proxy 生成的代理类对象
     * @param method 被拦截的方法
     * @param args 被拦截的方法参数
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("使用反射动态代理技术拦截接口方法开始");
        //1. 判断方法上是否存在@ExtInsert
        ExtInsert extInsert = method.getAnnotation(ExtInsert.class);
        if (extInsert != null) {
            return extInsert(method, args, extInsert);
        }

        //查询思路
        //1.判断方法上是否存在@ExtSelect
        ExtSelect extSelect = method.getAnnotation(ExtSelect.class);
        if (extSelect != null){
            return extSelect(method, args, extSelect);
        }

        return null;
    }

    private Object extSelect(Method method, Object[] args, ExtSelect extSelect) throws SQLException, InstantiationException, IllegalAccessException {
        //2. 获取 SQL 语句，获取注解 select 语句
        String selectSql = extSelect.value();
        //3. 获取方法上的参数和 SQL 参数进行匹配
        //定义一个 Map 集合，key：@ExtParam     value：参数值
        ConcurrentHashMap paramMap = getparamsMap(method, args);
        //存放 SQL 的执行参数--参数绑定过程
        List selectParameter = SQLUtils.sqlSelectParameter(selectSql);
        List sqlParams = new ArrayList<>();
        for (String paramName : selectParameter) {
            Object paramValue = paramMap.get(paramName);
            sqlParams.add(paramValue);
        }

        String newSql = SQLUtils.parameQuestion(selectSql, selectParameter);
        System.out.println(newSql);
        //5. 调用 JDBC 底层代码执行语句
        ResultSet resultSet = JDBCUtils.query(newSql, sqlParams);

        //6,使用反射机制实例化对象 获取方法返回类型，进行实例化
        //1.使用反射机制获取方法的类型
        //2.判断是否有结果集，如果有结果集，再进行初始化
        //3.使用反射机制，给对象赋值

        //判断是否存在质
        if (!resultSet.next()){
            return null;
        }
        //下标往上移动一位
        resultSet.previous();
        //1.使用反射机制获取方法的类型
        Class returnType = method.getReturnType();
        Object object = returnType.newInstance();
        while (resultSet.next()){
            Field[] fields = returnType.getDeclaredFields();
            for (Field field : fields) {
                String fieldName = field.getName();
                Object filedValue = resultSet.getObject(fieldName);
                field.setAccessible(true);
                field.set(object, filedValue);
            }
            /*for (String paramName : selectParameter) {
                Object resultValue = resultSet.getObject(paramName);
                //使用 java 反射机制赋值
                Field field = returnType.getDeclaredField(paramName);
                field.setAccessible(true);
                field.set(object, resultValue);
            }*/
        }
        return object;
    }

    private Object extInsert(Method method, Object[] args, ExtInsert extInsert) {
        //2. 获取 SQL 语句，获取注解 Insert 语句
        String insertSql = extInsert.value();
        System.out.println(insertSql);

        //3. 获取方法上的参数和 SQL 参数进行匹配
        //定义一个 Map 集合，key：@ExtParam     value：参数值
        ConcurrentHashMap paramMap = getparamsMap(method, args);
        //存放 SQL 的执行参数--参数绑定过程
        String[] sqlInsertParameter = SQLUtils.sqlInsertParameter(insertSql);
        List sqlParams = sqlParams(paramMap, sqlInsertParameter);
        //4. 替换参数变为 ？
        String newSql = SQLUtils.parameQuestion(insertSql, sqlInsertParameter);
        System.out.println(newSql);
        //5. 调用 JDBC 底层代码执行语句
        int insert = JDBCUtils.insert(newSql, false, sqlParams);
        return 1;
    }

    private List sqlParams(ConcurrentHashMap paramMap, String[] sqlInsertParameter) {
        List sqlParams = new ArrayList<>();
        for (String paramName : sqlInsertParameter) {
            Object paramValue = paramMap.get(paramName);
            sqlParams.add(paramValue);
        }
        return sqlParams;
    }


    private ConcurrentHashMap getparamsMap(Method method, Object[] args) {
        ConcurrentHashMap paramMap = new ConcurrentHashMap<>();
        //获取方法上的参数
        Parameter[] parameters = method.getParameters();
        for (int i = 0; i < parameters.length; i++) {
            Parameter parameter = parameters[i];
            ExtParam extParam = parameter.getAnnotation(ExtParam.class);
            if (extParam!=null){
                //参数名称
                String paramName = extParam.value();
                Object paramValue = args[i];
                paramMap.put(paramName, paramValue);
            }
        }
        return paramMap;
    }
}
 
  
定义SqlSession
 
  
/**
 * 获取SqlSession对象
 */
public class SqlSession {
    public static   T getMapper(Class clazz){
        return (T) Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, new MyInvocationHandlerMybatis(clazz));
    }
}

 
  
定义SQLUtils
 
  
/**
 * SQL拼接

 */
public class SQLUtils {
   /**
    * 
    * 获取Insert语句后面values 参数信息

    * 
    * @param sql
    * @return
    */
   public static String[] sqlInsertParameter(String sql) {
      int startIndex = sql.indexOf("values");
      int endIndex = sql.length();
      String substring = sql.substring(startIndex + 6, endIndex).replace("(", "").replace(")", "").replace("#{", "")
            .replace("}", "");
      String[] split = substring.split(",");
      return split;
   }

   /**
    * 
    * 获取select 后面where语句
    * 
    * @param sql
    * @return
    */
   public static List sqlSelectParameter(String sql) {
      int startIndex = sql.indexOf("where");
      int endIndex = sql.length();
      String substring = sql.substring(startIndex + 5, endIndex);
      String[] split = substring.split("and");
      List listArr = new ArrayList<>();
      for (String string : split) {
         String[] sp2 = string.split("=");
         listArr.add(sp2[0].trim());
      }
      return listArr;
   }

   /**
    * 将SQL语句的参数替换变为?

    * 
    * @param sql
    * @param parameterName
    * @return
    */
   public static String parameQuestion(String sql, String[] parameterName) {
      for (int i = 0; i < parameterName.length; i++) {
         String string = parameterName[i];
         sql = sql.replace("#{" + string + "}", "?");
      }
      return sql;
   }

   public static String parameQuestion(String sql, List parameterName) {
      for (int i = 0; i < parameterName.size(); i++) {
         String string = parameterName.get(i);
         sql = sql.replace("#{" + string + "}", "?");
      }
      return sql;
   }

   public static void main(String[] args) {

      // String[] sqlParameter = sqlInsertParameter(sql);
      // for (String string : sqlParameter) {
      // System.out.println(string);
      // }

   }
}

 
  
运行
 
  
UserMapper userMapper = SqlSession.getMapper(UserMapper.class);
User result = userMapper.selectUser("xiaoming", 18);
System.out.println(result);

 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(源码分析)

        

            

                
    
                    
  • JVM源码分析之堆外内存完全解读
                        HeapDump性能社区

                        
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
    
                    
    • 
                    
  • Golang Channel
                        PandaSkr
golang
                        
    Channel解析1.Channel源码分析1.1Channel数据结构typehchanstruct{qcountuint//channel的元素数量dataqsizuint//channel循环队列长度bufunsafe.Pointer//指向循环队列的指针elemsizeuint16//元素大小closeduint32//channel是否关闭0-未关闭elemtype*_type//元素类
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • 【鸿蒙OH-v5.0源码分析之 Linux Kernel 部分】004 - Kernel 启动引导代码head.S 源码逐行分析
                        "小夜猫&小懒虫&小财迷"的男人
鸿蒙OH-v5.0源码分析之Uboot+Kernel部分harmonyoslinux华为
                        
    【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析系列文章汇总：《鸿蒙OH-v5.0源码分析之Uboot+Kernel部分】000-文章链接汇总》本文链接：《【鸿蒙OH-v5.0源码分析之LinuxKernel部分】004-Kernel启动引导代码head.S源码逐行分析》head.S主要工作如下：保存内核启动参数,无效化处理器缓存(
    
                    
    • 
                    
  • Java高并发编程详解系列-深入理解Thread构造
                        nihui123
高并发Java高并发Java高并发
                        
    上篇分享中主要是对线程的基本概念和基本操作做了一个分享，同时提出了两种常用的创建多线程的方法，当然在后期的分享中也会提及到更多的创建线程的方式，到后期的分享的时候再说。这次主要是深入的理解一下Thread的构造函数，通过构造函数对于Thread有一个更加深入的了解。这里首先提供一个JDK1.6的ThreadAPI截图线程命名规范  从源码分析可以看到在Thread类中默认提供了线程的命名方式，这个
    
                    
    • 
                    
  • 【QT教程】QT6硬件图形界面编程 QT硬件编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6硬件图形界面编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件图形界面编程概述1.1QT6硬件图形界面编程简介1.1.1QT6硬件
    
                    
    • 
                    
  • Jetpack LiveData源码分析
                        xiangxiongfly915
#AndroidJetpack系列JetpackLiveData源码分析
                        
    文章目录JetpackLiveData源码分析前提源码分析注册订阅流程LiveData#observe()LifecycleRegistry#addObserver()ObserverWithState#dispatchEvent()LiveData#removeObserver()LiveData$LifecycleBoundObserver类LifecycleBoundObserver#sho
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（17）——TrackSelector
                        山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码
                        
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（12）——Cache
                        山雨楼
ExoPlayer架构android音视频ExoPlayerMedia3源码
                        
    系列文章目录ExoPlayer架构详解与源码分析（1）——前言ExoPlayer架构详解与源码分析（2）——PlayerExoPlayer架构详解与源码分析（3）——TimelineExoPlayer架构详解与源码分析（4）——整体架构ExoPlayer架构详解与源码分析（5）——MediaSourceExoPlayer架构详解与源码分析（6）——MediaPeriodExoPlayer架构详解与
    
                    
    • 
                    
  • ExoPlayer架构详解与源码分析（7）——SampleQueue(4)
                        2401_83740189
程序员架构
                        
    long[]newSourceIds=newlong[newCapacity];long[]newOffsets=newlong[newCapacity];long[]newTimesUs=newlong[newCapacity];int[]newFlags=newint[newCapacity];int[]newSizes=newint[newCapacity];CryptoData[]newC
    
                    
    • 
                    
  • 【HarmonyOS】- 常见算法简单写法
                        数的羊都睡了
HarmonyOSArkTS鸿蒙
                        
    文章目录知识回顾前言源码分析1.冒泡排序2.二分法查找拓展知识时间、空间复杂度总结知识回顾前言常见算法简单写法源码分析1.冒泡排序functionbubbleSort(arr:number[]):number[]{constn=arr.length;for(leti=0;iarr[j+1]){//交换元素consttemp=arr[j];arr[j]=arr[j+1];arr[j+1]=temp;
    
                    
    • 
                    
  • [ docker-ce源码分析系列 ] 修改resolv.conf文件被还原的原因
                        nangonghen
dockerdocker
                        
    1概述：1.1环境版本信息如下：a、操作系统：centos7.6，amd64b、服务器docker版本：v18.09.22resolv.conf文件被还原的现象：容器中的/etc/resolv.conf文件，是由宿主机/var/lib/docker/containers/xxxx/resolv.conf文件挂载。在dockerrestart容器之前，手动修改了/var/lib/docker/con
    
                    
    • 
                    
  • dispatch_once源码分析
                        福伟_Y

                        
    GCD里的单例函数dispatch_once是我们经常会用到的，今天我们来稍做深入分析一下。GCD的源码都在libdispatch.dylib库里，这个库在libSystem_initializer被初始化，可理解为在dyld里被加载和初始化的(之前的文章有分析过)。dispatch_once作为单例的使用入口，通过分析得到它是一个宏定义，_dispatch_once函数在libdispatch.
    
                    
    • 
                    
  • jQuery Easyui 源码分析之combo组件
                        90后北京程序员
前端-easyuieasyui之combobox
                        
    /***jQueryEasyUI1.3.1*该源码完全由压缩码翻译而来，并非网络上放出的源码，请勿索要。*/(function($){functionsetSize(target,width){varopts=$.data(target,"combo").options;varcombo=$.data(target,"combo").combo;varpanel=$.data(target,"co
    
                    
    • 
                    
  • html5carousel图片轮播,全面解析Bootstrap中Carousel轮播的使用方法
                        RemusrickCat

                        
    本文实例为大家全面的解析了Bootstrap中Carousel的使用方法，供大家参考，具体内容如下源码文件：Carousel.scssCarousel.js实现原理：隐藏所有要显示的元素，然后指定当前要显示的为block，宽、高自适应源码分析：1、Html结构：主要分为以四个部分1.1、容器：最外层div，需要一个data-ride=”carousel”来指定为轮播放插件，并且提供一个Id，方便圆
    
                    
    • 
                    
  • Java集合-----List接口及其实现类：ArrayList、LinkedList、Vector
                        Colourful．
Java集合java集合
                        
    文章目录List接口概述List接口的常用方法List接口的实现类ArrayList源码分析类继承关系ArrayList中的属性：ArrayList构造函数：ArrayList中常用方法添加操作：add()删除操作：remove()获取元素：get()ArrayList是如何实现序列化的？ArrayList的总结LinkedList源码分析类继承关系类成员属性类构造器LinkedList的List
    
                    
    • 
                    
  • React Native通讯原理
                        zbl_zbl
androidReactNativ
                        
    之前写过一篇文章ReactNativeAndroid源码分析，在此文章的基础上分析和总结下RN与Native的通讯流程。本文基于Android代码分析，iOS实现原理类似。1.通讯框架图先来解析下各个模块的角色与作用：Java层，这块的实现在ReactAndroid中-ReactContext:Android上下文子类，包含一个CatalystInstance实例，用于获取NativeModule
    
                    
    • 
                    
  • [linux 驱动]增加一个文件节点控制led灯亮灭
                        嵌入式成长家
linux内核的系统实战linux驱动linux驱动led灯驱动
                        
    目录1修改设备树2修改驱动3驱动源码3.1驱动源码3.2设备树节点3.3驱动源码分析3.3.1##解释3.3.2class_create解释3.3.3class_create_file解释3.3.4of_get_named_gpio_flags解释3.3.5devm_gpio_request解释3.3.6platform_driver_register解释3.3.7platform_driver_
    
                    
    • 
                    
  • 【QT教程】QT6对话框编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6对话框编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6对话框编程基础1.1QT6对话框简介1.1.1QT6对话框简介QT6对话框简介
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列十二 事件Event
                        OpenHarmony_小贾
OpenHarmonyHarmonyOS鸿蒙开发harmonyosopenharmony鸿蒙内核鸿蒙开发移动开发嵌入式硬件驱动开发
                        
    事件（Event）是一种任务间通信的机制，可用于任务间的同步。多任务环境下，任务之间往往需要同步操作，一个等待即是一个同步。事件可以提供一对多、多对多的同步操作。本文通过分析鸿蒙轻内核事件模块的源码，深入掌握事件的使用。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列四 中断Hwi
                        OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSharmonyos单片机OpenHarmony嵌入式硬件鸿蒙开发移动开发鸿蒙内核
                        
    在鸿蒙轻内核源码分析系列前几篇文章中，剖析了重要的数据结构。本文，我们讲述一下中断，会给读者介绍中断的概念，鸿蒙轻内核的中断模块的源代码。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1、中断概念介绍中断是指出现需要时，CPU暂停执行当前程序，转而执行新程序的过程。当外设需要CPU时，将通过产生中断信号使CPU立即中断当前任务来响应中断请求。在剖析中断源代码之前，下面介绍些
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列五 时间管理
                        OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发harmonyosopenharmony鸿蒙开发NAPI鸿蒙内核移动开发嵌入式
                        
    在鸿蒙轻内核源码分析上一篇文章中，我们剖析了中断的源码，简单提到了Tick中断。本文会继续分析Tick和时间相关的源码，给读者介绍鸿蒙轻内核的时间管理模块。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例，均可以在开源站点https://gitee.com/openharmony/kernel_liteos_m获取。时间管理模块以系统时钟为基础，可以分为2部分，一部分是SysT
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列六 任务及任务调度（1）任务栈
                        OpenHarmony_小贾
鸿蒙开发OpenHarmonyHarmonyOSHarmonyOSopenharmony鸿蒙开发移动开发鸿蒙内核驱动开发嵌入式硬件
                        
    继续分析鸿蒙轻内核源码，我们本文开始要分析下任务及任务调度模块。首先，我们介绍下任务栈的基础概念。任务栈是高地址向低地址生长的递减栈，栈指针指向即将入栈的元素位置。初始化后未使用过的栈空间初始化的内容为宏OS_TASK_STACK_INIT代表的数值0xCACACACA，栈顶初始化为宏OS_TASK_MAGIC_WORD代表的数值0xCCCCCCCC。一个任务栈的示意图如下，其中，栈底指针是栈的最
    
                    
    • 
                    
  • 鸿蒙轻内核M核源码分析系列三 数据结构-任务排序链表
                        OpenHarmony_小贾
HarmonyOSOpenHarmony鸿蒙开发数据结构harmonyos移动开发OpenHarmony鸿蒙内核鸿蒙开发嵌入式硬件
                        
    在鸿蒙轻内核源码分析系列一和系列二，我们分析了双向循环链表、优先级就绪队列的源码。本文会继续给读者介绍鸿蒙轻内核源码中重要的数据结构：任务排序链表TaskSortLinkAttr。鸿蒙轻内核的任务排序链表，用于任务延迟到期/超时唤醒等业务场景，是一个非常重要、非常基础的数据结构。本文中所涉及的源码，以OpenHarmonyLiteOS-M内核为例。1任务排序链表我们先看下任务排序链接的数据结构。任
    
                    
    • 
                    
  • 鸿蒙轻内核A核源码分析系列七 进程管理 (2)
                        OpenHarmony_小贾
HarmonyOS鸿蒙开发OpenHarmonyharmonyosOpenHarmony移动开发驱动开发鸿蒙内核LiteOS-A内核进程通信
                        
    本文先熟悉下进程管理的文件kernel\base\core\los_process.c中的内部接口，读读代码，做些记录。1、LiteOS-A内核进程全局变量⑴是进程池，存放各个进程控制块LosProcessCB的信息。⑵处开始的g_freeProcess是空闲进程链表，挂载各个空闲进程控制块；g_processRecycleList是待回收进程控制块链表，挂载各个等待回收的进程控制块。⑶处开始的g
    
                    
    • 
                    
  • 鸿蒙原生开发——轻内核A核源码分析系列三 物理内存（2）
                        OpenHarmony_小贾
鸿蒙开发HarmonyOSOpenHarmonyharmonyosopenharmony移动开发程序人生鸿蒙开发
                        
    3.1.2.3函数OsVmPhysLargeAlloc当执行到这个函数时，说明空闲链表上的单个内存页节点的大小已经不能满足要求，超过了第9个链表上的内存页节点的大小了。⑴处计算需要申请的内存大小。⑵从最大的链表上进行遍历每一个内存页节点。⑶根据每个内存页的开始内存地址，计算需要的内存的结束地址，如果超过内存段的大小，则继续遍历下一个内存页节点。⑷处此时paStart表示当前内存页的结束地址，接下来
    
                    
    • 
                    
  • JsonCpp源码分析——Reader
                        哎呦，帅小伙哦
#jsoncppjson
                        
    1、与Writer模块功能相反，可以将Reader理解成一个反序列化的工具，Writer的作用主要是将Value对象转成string或者流式的结构，Reader的作用主要是将流式的结构转成Value类型的对象。Reader类的主要职责有3个，解析JSON字符串：将JSON格式的字符串读取并解析成相应的C++数据结构。处理不同的数据类型，支持解析JSON对象、数组、字符串、数字、布尔值和null。处
    
                    
    • 
                    
  • vue源码分析-挂载流程和模板编译
                        yyzzabc123
vue.js
                        
    前面几节我们从newVue创建实例开始，介绍了创建实例时执行初始化流程中的重要两步，配置选项的资源合并,以及响应式系统的核心思想，数据代理。在合并章节，我们对Vue丰富的选项合并策略有了基本的认知，在数据代理章节我们又对代理拦截的意义和使用场景有了深入的认识。按照Vue源码的设计思路，初始化过程还会进行很多操作，例如组件之间创建关联，初始化事件中心，初始化数据并建立响应式系统等，并最终将模板和数据
    
                    
    • 
                    
  • 鸿蒙内核解析,鸿蒙内核源码分析(内存概念篇)|解读鸿蒙源码
                        刘轩鸿
鸿蒙内核解析
                        
    提示：本文基于开源鸿蒙内核分析，官方源码【kernel_liteos_a】官方文档【docs】参考文档【HuaweiLiteOS】本文作者：鸿蒙内核发烧友，用生活场景讲故事的方式去解构内核，一窥究竟，让神秘的内核栩栩如生，浮现眼前。博文全部原创，持续更新，敬请关注。内容仅代表个人观点，错误之处，欢迎大家指正完善。本系列全部文章进入鸿蒙源码分析(总目录)查看目录最难讲的章节坦白讲内存是整个系列里面最
    
                    
    • 
                    
  • 鸿蒙轻内核A核源码分析系列七 进程管理 (3)
                        OpenHarmony_小贾
OpenHarmony鸿蒙开发HarmonyOSharmonyos嵌入式硬件OpenHarmony鸿蒙嵌入式鸿蒙开发鸿蒙内核进程关联
                        
    本文记录下进程相关的初始化函数，如OsSystemProcessCreate、OsProcessInit、OsProcessCreateInit、OsUserInitProcess、OsDeInitPCB、OsUserInitProcessStart等。1、LiteOS-A内核进程创建初始化通用函数先看看一些内部函数，不管是初始化用户态进程还是内核态进程，都会使用这些函数，包含进程控制块初始化函数
    
                    
    • 
                                
  • LeetCode[位运算] - #137 Single Number II
                                    Cwind
javaAlgorithmLeetCode题解位运算
                                    
    原题链接：#137 Single Number II  
要求： 
给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 
注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间 
  
难度：中等 
  
分析： 
与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
    
                                
    • 
                                
  • 《JavaScript语言精粹》笔记
                                    aijuans
JavaScript
                                    
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 
1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 
2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
    
                                
    • 
                                
  • 你应该更新的Java知识之常用程序库
                                    Kai_Ge
java
                                    
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 
Guava 
Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 
guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
    
                                
    • 
                                
  • HttpClient
                                    120153216
httpclient
                                    
    /**
 * 可以传对象的请求转发，对象已流形式放入HTTP中
 */
public static Object doPost(Map<String,Object> parmMap,String url)
	{
		Object object = null;
		HttpClient hc = new HttpClient();
		
		String fullURL 
    
                                
    • 
                                
  • Django model字段类型清单
                                    2002wmj
django
                                    
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段)  BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。  Cha
    
                                
    • 
                                
  • 在SQLSERVER中查找消耗CPU最多的SQL
                                    357029540
SQL Server
                                    
    返回消耗CPU数目最多的10条语句 
 
SELECT TOP 10 
   total_worker_time/execution_count AS avg_cpu_cost, plan_handle, 
   execution_count, 
   (SELECT SUBSTRING(text, statement_start_of
    
                                
    • 
                                
  • Myeclipse项目无法部署，Undefined exploded archive location
                                    7454103
eclipseMyEclipse
                                    
    做个备忘！ 
 
错误信息为： 
      Undefined exploded archive location 
 
 
原因： 
          在工程转移过程中，导致工程的配置文件出错； 
 
 
解决方法： 
   
    
                                
    • 
                                
  • GMT时间格式转换
                                    adminjun
GMT时间转换
                                    
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 
1、可以使用 
SimpleDateFormat SimpleDateFormat    
EEE-三位星期 
d-天 
MMM-月 
yyyy-四位年 

    
                                
    • 
                                
  • Oracle数据库新装连接串问题
                                    aijuans
oracle数据库
                                    
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： 
Fatal NI connect error 12170. 
  VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
    
                                
    • 
                                
  • 回顾java数组复制
                                    ayaoxinchao
java数组
                                    
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
    
                                
    • 
                                
  • java web会话监听并使用spring注入
                                    bewithme
Java Web
                                    
      
      在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。 
       
import java.util.ArrayList;
import java.ut
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用)
                                    bijian1013
redis数据库NoSQL
                                    
    一 .Redis常用命令 
        Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。 
        a.键值相关命令 
        b.服务器相关命令 
1.键值相关命令 
      &
    
                                
    • 
                                
  • java枚举序列化问题
                                    bingyingao
java枚举序列化
                                    
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 
 
 
1.加一个枚举值 
新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 
 
老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 
 
 
 
  2.删一个枚举值 
新机器代码读分布式缓存中老对象，反序列
    
                                
    • 
                                
  • 【Spark七十八】Spark Kyro序列化
                                    bit1129
spark
                                    
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 
 
 Spark
    
                                
    • 
                                
  • Hybridizing OO and Functional Design
                                    bookjovi
erlanghaskell
                                    
      推荐博文：
Tell Above, and Ask Below - Hybridizing OO and Functional Design  
文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-HashMap
                                    BrokenDreams
Collections
                                    
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。 
 &nb
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 




/**
 * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请
 * bylijinnan
 */
abstract class Handler {
	/* 
    
                                
    • 
                                
  • Android中启动外部程序
                                    cherishLC
android
                                    
    1、启动外部程序 
引用自： 
http://blog.csdn.net/linxcool/article/details/7692374 
 
//方法一
Intent intent=new Intent();
//包名 包名+类名（全路径）
intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
    
                                
    • 
                                
  • summary_keep_rate
                                    coollyj
SUM
                                    
    
BEGIN  
      /*DECLARE  minDate varchar(20) ;
      DECLARE  maxDate varchar(20) ;*/
      DECLARE  stkDate varchar(20) ;

      DECLARE done int default -1; 
			/* 游标中 注册服务器地址 */  
      DE
    
                                
    • 
                                
  • hadoop hdfs 添加数据目录出错
                                    daizj
hadoophdfs扩容
                                    
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 
 
2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
    
                                
    • 
                                
  • grep 目录级联查找
                                    dongwei_6688
grep
                                    
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： 
grep -n -r "GET" . 
  
上面的命令将会找出当前目录“.”及当前目录中所有下级目录
    
                                
    • 
                                
  • yii 修改模块使用的布局文件
                                    dcj3sjt126com
yiilayouts
                                    
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如:  'theme'=>'mythm',   那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件；   如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
    
                                
    • 
                                
  • 设计模式之单例模式
                                    come_for_dream
设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                                    
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。 
  
*********************************
    
                                
    • 
                                
  • 8、数组
                                    豆豆咖啡
二维数组数组一维数组
                                    
      
一、概念 
  
    数组是同一种类型数据的集合。其实数组就是一个容器。 
  
二、好处 
  
    可以自动给数组中的元素从0开始编号，方便操作这些元素 
  
三、格式 
  
//一维数组
1,元素类型[] 变量名 = new 元素类型[元素的个数]
int[] arr =
    
                                
    • 
                                
  • Decode Ways
                                    hcx2013
decode
                                    
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 
'A' -> 1
'B' -> 2
...
'Z' -> 26
 
Given an encoded message containing digits, det
    
                                
    • 
                                
  • Spring4.1新特性——异步调度和事件机制的异常处理
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • squid3(高命中率)缓存服务器配置
                                    liyonghui160com

                                    
      
  
系统:centos 5.x 
  需要的软件:squid-3.0.STABLE25.tar.gz 
1.下载squid 
wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz 
tar zxf squid-3.0.STABLE25.tar.gz &&
    
                                
    • 
                                
  • 避免Java应用中NullPointerException的技巧和最佳实践
                                    pda158
java
                                    
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。   　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 
Object unk
    
                                
    • 
                                
  • 如何在Swift语言中创建http请求
                                    shoothao
httpswift
                                    
      
 概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。  
   
如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 
在这里,我将作出一些建议来回答上述问题。常见的
    
                                
    • 
                                
  • Spring事务的传播方式
                                    uule
spring事务
                                    
    传播方式：  
      新建事务 
      required 
      required_new   - 挂起当前 
  
      非事务方式运行 
      supports 
  &nbs
    
                                
    •