强子no2
强子no2

calcite 连接Mysql 数据库 demo

Calcite是一种动态数据管理系统，它具有标准SQL、连接不同前端和后端、可定制的逻辑规划器、物化视图、多维数据分析和流查询等诸多能力，使其成为大数据领域中非常有吸引力的查询引擎.

看了好多Github 都没有一些合适的例子，自己花了一段时间整理的，希望以后会用到，代码中有很多不足的地方，就不多说，直接在本地做了一个DEMO

BaseConnection: 定义接口，所有jdbc 都需要实现这个方法

public interface BaseConnection {
    public Connection getConnection();

}


JDBCConnection：implements  BaseConnection  


public class JDBCConnection extends FileLogger implements BaseConnection {


    // 静态成员变量，支持单态模式
    public static JDBCConnection jdbc = null;
    public static DataSource dataSource = 
            JdbcSchema.dataSource(ConfigurationUtils.getProperty("calcite.url"), ConfigurationUtils.getProperty("calcite.class"),
                    ConfigurationUtils.getProperty("calcite.user"), ConfigurationUtils.getProperty("calcite.password"));;
    private JDBCConnection() {
    }
    public static JDBCConnection getInstance() {
        if (jdbc == null) {
            synchronized (JDBCConnection.class) {
                if (jdbc == null) {
                    jdbc = new JDBCConnection();
                }
            }
        }
        return jdbc;
    }


    @Override
    public Connection getConnection() {
        try {
            if(ConfigurationUtils.getProperty("calcite.type").equals("mysql")){
                return dataSource.getConnection();
            }else{
                Properties properties = new Properties();
                properties.setProperty("spark", "true");
                Connection aConnection;
                try {
                    aConnection = DriverManager.getConnection("jdbc:calcite:", properties);
                    return aConnection.unwrap(CalciteConnection.class);
                } catch (SQLException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                return null;
            }
            
        } catch (SQLException e) {
            error_log.error(e.getStackTrace());
            e.printStackTrace();
        }
        return null;
    }

    private static Config buildParserConfig(DatabaseProduct dbms, String parserSqlQuoting) {
        ConfigBuilder aParserConfig = SqlParser.configBuilder();
        switch (dbms) {
            case HIVE:
            case MYSQL:
                aParserConfig.setLex(Lex.MYSQL);
                break;
            case POSTGRESQL:
                aParserConfig.setCaseSensitive(false).setQuoting(Quoting.DOUBLE_QUOTE).setQuotedCasing(Casing.UNCHANGED)
                        .setUnquotedCasing(Casing.TO_LOWER);
                break;
            case MSSQL:
                aParserConfig.setLex(Lex.SQL_SERVER);
                break;
            default:
                aParserConfig.setLex(Lex.ORACLE);
                break;
        }
        if ("ANSI".equals(parserSqlQuoting)) {
            aParserConfig.setQuoting(Quoting.DOUBLE_QUOTE);
        }
        return aParserConfig.build();
    }


    /**
     * 获取SchemaName
     * @Title: getSchemaName
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param theDatabaseProduct
     * @param conn
     * @return
     * @throws SQLException
     */
    private static String getSchemaName(DatabaseProduct theDatabaseProduct, final Connection conn) throws SQLException {
        if (theDatabaseProduct == SqlDialect.DatabaseProduct.MYSQL) {
            return conn.getCatalog();
        } else {
            String schemaName = conn.getSchema();
            if (schemaName == null) {
                schemaName = "PUBLIC";
            }
            return schemaName;
        }
    }


    /**
     * 创建Config  不同的数据库之间转移
     * @Title: createConfig
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param theDataSource
     * @param theDatabaseProduct
     * @param theCatalog
     * @param theSchemaName
     * @return
     */
    private static FrameworkConfig createConfig(final DataSource theDataSource,
            final SqlDialect.DatabaseProduct theDatabaseProduct, final String theCatalog, final String theSchemaName) {
        SchemaPlus aRootSchema = Frameworks.createRootSchema(true);
        aRootSchema.add(theSchemaName,
                JdbcSchema.create(aRootSchema, theSchemaName, theDataSource, theCatalog, theSchemaName));
        return Frameworks.newConfigBuilder().parserConfig(buildParserConfig(theDatabaseProduct, "ANSI"))
                .defaultSchema(aRootSchema.getSubSchema(theSchemaName))
                .traitDefs(ConventionTraitDef.INSTANCE, RelCollationTraitDef.INSTANCE).context(Contexts.EMPTY_CONTEXT)
                .typeSystem(RelDataTypeSystem.DEFAULT).build();
    }
    
    
    /**
     * 根据类型来匹配不同的转换形式
     * @Title: convertSqlByType
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param sql
     * @return
     * @throws SQLException
     * @throws SqlParseException
     * @throws ValidationException
     * @throws RelConversionException
     */
    public static String convertSqlByType(String sql)
            throws SQLException, SqlParseException, ValidationException, RelConversionException {
        if(ConfigurationUtils.getProperty("calcite.type").equals("mysql")){
            return convertMySql(sql);
        }else{
            return sql;
        }
    }


    /**
     * Mysql以及一些支持的格式转化 为可以执行的calcite
     * @Title: convertSql
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @return
     * @throws SQLException
     * @throws SqlParseException
     * @throws ValidationException
     * @throws RelConversionException
     */
    public static String convertMySql(String sql)
            throws SQLException, SqlParseException, ValidationException, RelConversionException {
        Connection aConnection = JDBCConnection.getInstance().getConnection();
        try{
            SqlDialectFactory aSqlDialectFactory = new SqlDialectFactoryImpl();
            SqlDialect aSqlDialect = aSqlDialectFactory.create(aConnection.getMetaData());
            SqlDialect.DatabaseProduct aDatabaseProduct =
                    SqlDialect.getProduct(aConnection.getMetaData().getDatabaseProductName(), "UNUSED");
            String schemaName = getSchemaName(aDatabaseProduct, aConnection);
            String catalog = aConnection.getCatalog();
            FrameworkConfig aConfig = createConfig(dataSource, aDatabaseProduct, catalog, schemaName);
            Planner aPlanner = Frameworks.getPlanner(aConfig);
            SqlNode aQuery = aPlanner.parse(sql);
            aQuery = aPlanner.validate(aQuery);
            RelNode aRelNode = aPlanner.rel(aQuery).project();
            RelToSqlConverter aSqlConverter = new RelToSqlConverter(aSqlDialect);
            SqlNode aSqlNode = aSqlConverter.visitChild(0, aRelNode).asStatement();
            System.out.println(sql);
            System.out.println(RelOptUtil.toString(aRelNode));
            System.out.println(aSqlNode);
            return sql;
        }catch(Exception e){
            e.getStackTrace();
        }
        
        return null;
    }
    
    
    /**
     * @Title: close
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param rs
     * @param pst
     * @param conn
     */
    public static void close(ResultSet rs, PreparedStatement pst, Connection conn) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                error_log.error(e.getStackTrace());
            }
            rs = null;
        }
        if (pst != null) {
            try {
                pst.close();
            } catch (SQLException e) {
                error_log.error(e.getStackTrace());
            }
            pst = null;
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                error_log.error(e.getStackTrace());
            }
            conn = null;
        }
    } 

}


BaseDao ： 定义接口


public interface BaseDao {


    /**
     * 查询
     * @Title: query
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param sql
     * @return
     */
    public List> queryBySql(String sql);
    
    public List> queryBySql(String sql, List params);


    public List> queryBySql(String sql, Object params);
    
    public List> queryByTable(String tableName, Map whereMap) throws SQLException;


    public List> queryByTable(String tableName, String whereClause, List whereArgs) 
            throws SQLException;


    public List> queryByTable(String tableName, boolean distinct, String[] columns, String selection,
            List selectionArgs, String groupBy, String having, String orderBy, String limit) throws SQLException;


    /**
     * 插入
     * @Title: insert
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @return
     * @throws SQLException
     */
    
    public int insertBySql(String sql) throws SQLException;
    
    public int insertBySql(String sql, List bindArgs) throws SQLException;
        
    public int insertByTable(String tableName, Map valueMap) throws SQLException;
    
    public int insertBatchByTable(String tableName, List> valueMap) throws SQLException;


    /**
     * 更新
     * @Title: update
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @return
     * @throws SQLException
     */
    public int updateBySql(String sql) throws SQLException;
    
    public int updateBySql(String sql, List params) throws SQLException;
    
  public int updateByTable(String tableName, Map valueMap, Map whereMap) throws SQLException;


    /**
     * 删除
     * @Title: delete
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @throws SQLException
     */
    
    public int deleteBySql(String sql) throws SQLException;
    
    public int deleteBySql(String sql,Object params) throws SQLException;
    
    public int deleteBySql(String sql,List params) throws SQLException;
    
    public int deleteByTable(String tableName, Map whereMap) throws SQLException;


    /**
     * 最开始处理的方案
     * @Title: execute
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param sql
     * @return
     */
    public Boolean execute(String sql);


    /**
     * 需要单独转换
     * @Title: getDBSQL
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param sql
     * @return
     */
    public String getDBSQL(String sql);

}


BaseDaoImpl  : implements BaseDao

public class BaseDaoImpl extends FileLogger implements BaseDao {

    private JDBCConnection jdbcConn = JDBCConnection.getInstance();
    
    public static final Pattern sLimitPattern =
            Pattern.compile("\\s*\\d+\\s*(,\\s*\\d+\\s*)?");

    @Override
    public List> queryBySql(String sql) {
        return queryBySql(sql, null);
    }


    @Override
    public List> queryBySql(String sql, Object params) {
        return queryBySql(sql, (ArrayList) params);
    }


    @Override
    public List> queryBySql(String sql, List params) {
        Connection conn = jdbcConn.getConnection();
        PreparedStatement pst = null;
        ResultSet rs = null;
        try {
            String newSQL = JDBCConnection.convertSqlByType(sql);
            info_log.info(newSQL);
            pst = conn.prepareStatement(newSQL);
            int parameterIndex = 1;
            if (null != params && params.size() > 0) {
                for (Object object : params) {
                    pst.setObject(parameterIndex++, object);
                }
            }
            rs = pst.executeQuery();
            ResultSetMetaData rst = rs.getMetaData();
            int column = rst.getColumnCount();
            List> rstList = new ArrayList>();
            while (rs.next()) {
                Map m = new HashMap();
                for (int i = 1; i <= column; i++) {
                    m.put(rst.getColumnName(i), rs.getObject(i));
                }
                rstList.add(m);
            }
            return rstList;
        } catch (SQLException | SqlParseException | ValidationException | RelConversionException e) {
            error_log.error(e.getMessage());
            e.printStackTrace();
            return null;
        } finally {
            JDBCConnection.close(rs, pst, conn);
        }
    }

    @Override
    public String getDBSQL(String sql) {
        ConfigBuilder builder = SqlParser.configBuilder();
        builder.setQuotedCasing(Casing.TO_LOWER);
        builder.setLex(Lex.MYSQL);
        Config config = builder.build();
        SqlParser sqlParser = SqlParser.create(sql, config);
        SqlString sqlString = null;
        try {
            SqlNode sqlNode = sqlParser.parseStmt();
            sqlString = sqlNode.toSqlString(CalciteSqlDialect.DEFAULT);
            return sqlString.getSql();
        } catch (SqlParseException e) {
            error_log.error(e.getStackTrace());
            e.printStackTrace();
        }
        return null;
    }


    @Override
    public List> queryByTable(String tableName, Map whereMap) throws SQLException {
        String whereClause = "";
        List whereArgs = new ArrayList();
        if (whereMap != null && whereMap.size() > 0) {
            Iterator iterator = whereMap.keySet().iterator();
            int i = 0;
            while (iterator.hasNext()) {
                String key = iterator.next();
                whereClause += (i == 0 ? "" : " AND ");
                whereClause += (key + " = ? ");
                whereArgs.add(whereMap.get(key));
                i++;
            }
        }
        return queryByTable(tableName, false, null, whereClause, whereArgs, null, null, null, null);
    }


    @Override
    public List> queryByTable(String tableName, String whereClause, List whereArgs)
            throws SQLException {
        return queryByTable(tableName, false, null, whereClause, whereArgs, null, null, null, null);
    }
    
    @Override
    public List> queryByTable(String tableName, boolean distinct, String[] columns,
            String selection, List selectionArgs, String groupBy, String having, String orderBy, String limit)
            throws SQLException {
        String sql = buildQueryString(distinct, tableName, columns, selection, groupBy, having, orderBy, limit);
        return executeQuery(sql, selectionArgs);
    }


    @Override
    public int insertBySql(String sql) throws SQLException {
        return executeUpdate(sql,null);
    }


    @Override
    public int insertBySql(String sql,List bindArgs) throws SQLException {
        return executeUpdate(sql,bindArgs);
    }


    @Override
    public int insertByTable(String tableName, Map valueMap) throws SQLException {
        /** 获取数据库插入的Map的键值对的值 **/
        Set keySet = valueMap.keySet();
        Iterator iterator = keySet.iterator();
        /** 要插入的字段sql，其实就是用key拼起来的 **/
        StringBuilder columnSql = new StringBuilder();
        /** 要插入的字段值，其实就是？ **/
        StringBuilder unknownMarkSql = new StringBuilder();
        List bindArgs = new ArrayList();
        int i = 0;
        while (iterator.hasNext()) {
            String key = iterator.next();
            columnSql.append(i == 0 ? "" : ",");
            columnSql.append(key);
            unknownMarkSql.append(i == 0 ? "" : ",");
            unknownMarkSql.append("?");
            bindArgs.add(valueMap.get(key));
            i++;
        }
        /** 开始拼插入的sql语句 **/
        StringBuilder sql = new StringBuilder();
        sql.append("INSERT INTO ");
        sql.append(tableName);
        sql.append(" (");
        sql.append(columnSql);
        sql.append(" )  VALUES (");
        sql.append(unknownMarkSql);
        sql.append(" )");
        return executeUpdate(sql.toString(), bindArgs);
    }


    @Override
    public int insertBatchByTable(String tableName, List> datas) throws SQLException {
        /** 影响的行数 **/
        int affectRowCount = -1;
        Connection connection = jdbcConn.getConnection();
        PreparedStatement preparedStatement = null;
        try {
            /** 从数据库连接池中获取数据库连接 **/
            //connection = DBConnectionPool.getInstance().getConnection();
            
            Map valueMap = datas.get(0);
            /** 获取数据库插入的Map的键值对的值 **/
            Set keySet = valueMap.keySet();
            Iterator iterator = keySet.iterator();
            /** 要插入的字段sql，其实就是用key拼起来的 **/
            StringBuilder columnSql = new StringBuilder();
            /** 要插入的字段值，其实就是？ **/
            StringBuilder unknownMarkSql = new StringBuilder();
            Object[] keys = new Object[valueMap.size()];
            int i = 0;
            while (iterator.hasNext()) {
                String key = iterator.next();
                keys[i] = key;
                columnSql.append(i == 0 ? "" : ",");
                columnSql.append(key);
                unknownMarkSql.append(i == 0 ? "" : ",");
                unknownMarkSql.append("?");
                i++;
            }
            /** 开始拼插入的sql语句 **/
            StringBuilder sql = new StringBuilder();
            sql.append("INSERT INTO ");
            sql.append(tableName);
            sql.append(" (");
            sql.append(columnSql);
            sql.append(" )  VALUES (");
            sql.append(unknownMarkSql);
            sql.append(" )");
            
            String newSQL = JDBCConnection.convertSqlByType(sql.toString());
            preparedStatement = connection.prepareStatement(newSQL);
            /** 设置不自动提交，以便于在出现异常的时候数据库回滚 **/
            connection.setAutoCommit(false);
            System.out.println(sql.toString());
            for (int j = 0; j < datas.size(); j++) {
                for (int k = 0; k < keys.length; k++) {
                    preparedStatement.setObject(k + 1, datas.get(j).get(keys[k]));
                }
                preparedStatement.addBatch();
            }
            int[] arr = preparedStatement.executeBatch();
            connection.commit();
            affectRowCount = arr.length;
            System.out.println("成功了插入了" + affectRowCount + "行");
            System.out.println();
        } catch (Exception e) {
            if (connection != null) {
                connection.rollback();
            }
            e.printStackTrace();
        } finally {
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
        return affectRowCount;
    }
    @Override
    public int updateBySql(String sql) throws SQLException{
        return executeUpdate(sql, null);
    }
    
    @Override
    public int updateBySql(String sql,List params) throws SQLException{
        return executeUpdate(sql, params);
    }
    @Override
    public int updateByTable(String tableName, Map valueMap, Map whereMap)
            throws SQLException {
        /** 获取数据库插入的Map的键值对的值 **/
        Set keySet = valueMap.keySet();
        Iterator iterator = keySet.iterator();
        /** 开始拼插入的sql语句 **/
        StringBuilder sql = new StringBuilder();
        sql.append("UPDATE ");
        sql.append(tableName);
        sql.append(" SET ");
        /** 要更改的的字段sql，其实就是用key拼起来的 **/
        StringBuilder columnSql = new StringBuilder();
        int i = 0;
        List params = new ArrayList<>();
        while (iterator.hasNext()) {
            String key = iterator.next();
            columnSql.append(i == 0 ? "" : ",");
            columnSql.append(key + " = ? ");
            params.add(valueMap.get(key));
            i++;
        }
        sql.append(columnSql);
        /** 更新的条件:要更改的的字段sql，其实就是用key拼起来的 **/
        StringBuilder whereSql = new StringBuilder();
        int j = 0;
        if (whereMap != null && whereMap.size() > 0) {
            whereSql.append(" WHERE ");
            iterator = whereMap.keySet().iterator();
            while (iterator.hasNext()) {
                String key = iterator.next();
                whereSql.append(j == 0 ? "" : " AND ");
                whereSql.append(key + " = ? ");
                params.add(whereMap.get(key));
                j++;
            }
            sql.append(whereSql);
        }
        return executeUpdate(sql.toString(), params);
    }
    
    @Override
    public int deleteBySql(String sql) throws SQLException{
        return executeUpdate(sql, null);
    }
    
    @Override
    public int deleteBySql(String sql,Object params) throws SQLException{
        return executeUpdate(sql, (ArrayList)params);
    }
    
    @Override
    public int deleteBySql(String sql,List params) throws SQLException{
        return executeUpdate(sql, params);
    }


    @Override
    public int deleteByTable(String tableName, Map whereMap) throws SQLException {
        /** 准备删除的sql语句 **/
        StringBuilder sql = new StringBuilder();
        sql.append("DELETE FROM ");
        sql.append(tableName);
        /** 更新的条件:要更改的的字段sql，其实就是用key拼起来的 **/
        StringBuilder whereSql = new StringBuilder();
        List bindArgs = new ArrayList();
        if (whereMap != null && whereMap.size() > 0) {
            whereSql.append(" WHERE ");
            /** 获取数据库插入的Map的键值对的值 **/
            Set keySet = whereMap.keySet();
            Iterator iterator = keySet.iterator();
            int i = 0;
            while (iterator.hasNext()) {
                String key = iterator.next();
                whereSql.append(i == 0 ? "" : " AND ");
                whereSql.append(key + " = ? ");
                bindArgs.add(whereMap.get(key));
                i++;
            }
            sql.append(whereSql);
        }
        return executeUpdate(sql.toString(), bindArgs);
    }
    public Boolean execute(String sql) {
        Connection conn = jdbcConn.getConnection();
        PreparedStatement pst = null;
        ResultSet rs = null;
        try {
            String newSQL = JDBCConnection.convertSqlByType(sql);
            info_log.info(newSQL);
            pst = conn.prepareStatement(newSQL);
            return pst.executeUpdate() >= 1 ? true : false;
        } catch (SQLException | SqlParseException | ValidationException | RelConversionException e) {
            error_log.error(e.getStackTrace());
            e.printStackTrace();
            return false;
        } finally {
            JDBCConnection.close(rs, pst, conn);
        }
    }

  
    private static boolean isEmpty(String s) {
        if (null != s && s.trim().length() > 0) {
            return false;
        }
        return true;
    }
    
    private static String buildQueryString(boolean distinct, String tables, String[] columns, String where,
            String groupBy, String having, String orderBy, String limit) {
        if (isEmpty(groupBy) && !isEmpty(having)) {
            throw new IllegalArgumentException("HAVING clauses are only permitted when using a groupBy clause");
        }
        if (!isEmpty(limit) && !sLimitPattern.matcher(limit).matches()) {
            throw new IllegalArgumentException("invalid LIMIT clauses:" + limit);
        }
        StringBuilder query = new StringBuilder(120);
        query.append("SELECT ");
        if (distinct) {
            query.append("DISTINCT ");
        }
        if (columns != null && columns.length != 0) {
            appendColumns(query, columns);
        } else {
            query.append(" * ");
        }
        query.append("FROM ");
        query.append(tables);
        appendClause(query, " WHERE ", where);
        appendClause(query, " GROUP BY ", groupBy);
        appendClause(query, " HAVING ", having);
        appendClause(query, " ORDER BY ", orderBy);
        appendClause(query, " LIMIT ", limit);
        return query.toString();
    }

    private List> executeQuery(String sql, List bindArgs) throws SQLException {
        List> datas = new ArrayList<>();
        Connection connection = jdbcConn.getConnection();
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        try {
            /** 获取数据库连接池中的连接 **/
            // connection = DBConnectionPool.getInstance().getConnection();
            String newSQL = JDBCConnection.convertSqlByType(sql);
            preparedStatement = connection.prepareStatement(newSQL);
            if (bindArgs != null && bindArgs.size()>0) {
                int i = 0;
                for(Object object:bindArgs){
                    preparedStatement.setObject(i + 1, object);
                }
            }
            System.out.println(getExecSQL(sql, bindArgs));
            resultSet = preparedStatement.executeQuery();
            datas = getDatas(resultSet);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (resultSet != null) {
                resultSet.close();
            }
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
        return datas;
    }

    private List> getDatas(ResultSet resultSet) throws SQLException {
        List> datas = new ArrayList<>();
        /** 获取结果集的数据结构对象 **/
        ResultSetMetaData metaData = resultSet.getMetaData();
        while (resultSet.next()) {
            Map rowMap = new HashMap<>();
            for (int i = 1; i <= metaData.getColumnCount(); i++) {
                rowMap.put(metaData.getColumnName(i), resultSet.getObject(i));
            }
            datas.add(rowMap);
        }
        System.out.println("成功查询到了" + datas.size() + "行数据");
        for (int i = 0; i < datas.size(); i++) {
            Map map = datas.get(i);
            System.out.println("第" + (i + 1) + "行：" + map);
        }
        return datas;
    }


    /**
     * 所有的更新处理
     * @Title: executeUpdate
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param sql
     * @param bindArgs
     * @return
     * @throws SQLException
     */
    public int executeUpdate(String sql, List bindArgs) throws SQLException {
        int affectRowCount = -1;
        Connection connection = jdbcConn.getConnection();
        PreparedStatement preparedStatement = null;
        try {
            /** 从数据库连接池中获取数据库连接 **/
            // connection = DBConnectionPool.getInstance().getConnection();
            String newSQL = JDBCConnection.convertSqlByType(sql);
            preparedStatement = connection.prepareStatement(newSQL);
            /** 设置不自动提交，以便于在出现异常的时候数据库回滚 **/
            connection.setAutoCommit(false);
            System.out.println(getExecSQL(sql, bindArgs));
            if (bindArgs != null) {
                /** 绑定参数设置sql占位符中的值 **/
                int i = 0;
                for(Object object : bindArgs){
                    preparedStatement.setObject(i + 1, object);
                }
            }
            affectRowCount = preparedStatement.executeUpdate();
            connection.commit();
            String operate;
            if (sql.toUpperCase().indexOf("DELETE FROM") != -1) {
                operate = "删除";
            } else if (sql.toUpperCase().indexOf("INSERT INTO") != -1) {
                operate = "新增";
            } else {
                operate = "修改";
            }
            System.out.println("成功" + operate + "了" + affectRowCount + "行");
        } catch (Exception e) {
            if (connection != null) {
                connection.rollback();
            }
            e.printStackTrace();
        } finally {
            if (preparedStatement != null) {
                preparedStatement.close();
            }
            if (connection != null) {
                connection.close();
            }
        }
        return affectRowCount;
    }


    /**
     * 转化SQL
     * @Title: getExecSQL
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param sql
     * @param bindArgs
     * @return
     */
    private static String getExecSQL(String sql, List bindArgs) {
        StringBuilder sb = new StringBuilder(sql);
        if (bindArgs != null && bindArgs.size() > 0) {
            int index = 0;
            for(Object object:bindArgs){
                index = sb.indexOf("?", index);
                sb.replace(index, index + 1, String.valueOf(object));
            }
        }
        return sb.toString();
    }


    /**
     * 拼接SQL
     * @Title: appendClause
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param s
     * @param name
     * @param clause
     */
    private static void appendClause(StringBuilder s, String name, String clause) {
        if (!isEmpty(clause)) {
            s.append(name);
            s.append(clause);
        }
    }


    /**
     * 添加Cloumn查询项
     * @Title: appendColumns
     * @Description: TODO(方法简要描述，必须以句号为结束)
     * @since: (开始使用的版本)
     * @param s
     * @param columns
     */
    private static void appendColumns(StringBuilder s, String[] columns) {
        int n = columns.length;
        for (int i = 0; i < n; i++) {
            String column = columns[i];


            if (column != null) {
                if (i > 0) {
                    s.append(", ");
                }
                s.append(column);
            }
        }
        s.append(' ');
    }

}


到此为止，主要工具类已经完事，开始测试：


public class MysqlTest {
    public static Connection conn = JDBCConnection.getInstance().getConnection();
    public static void query() {
        BaseDao dao = new BaseDaoImpl();
        String sql = "select * from test where id=?";
        List params = new ArrayList();
        //params.add(101);
        List> list = dao.queryBySql(sql,params);
        for (Map map : list) {
            System.out.println(map.toString());
        }
    }


    public static void insert() {
        BaseDao dao = new BaseDaoImpl();
        String sql = "insert into spark_caa.test (id,name) values (101,'caozqa'),(100,'weilpa')";
        boolean list = dao.execute(sql);
        System.out.println(list);
    }




    public static void updata() {
        BaseDao dao = new BaseDaoImpl();
        String sql = "update  spark_caa.test set name='888' where id=2";
        boolean list = dao.execute(sql);
        System.out.println(list);
    }


    public static void delete() {
        BaseDao dao = new BaseDaoImpl();
        String sql = "delete  from spark_caa.test where id=1";
        boolean list = dao.execute(sql);
        System.out.println(list);
    }
    
    public static void main(String[] args) throws SqlParseException {

        query();

        insert() 

    }


}



你可能感兴趣的:(大数据)

  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 免费的GPT可在线直接使用（一键收藏） kkai人工智能 gpt
    1、LuminAI（https://kk.zlrxjh.top）LuminAI标志着一款融合了星辰大数据模型与文脉深度模型的先进知识增强型语言处理系统，旨在自然语言处理（NLP）的技术开发领域发光发热。此系统展现了卓越的语义把握与内容生成能力，轻松驾驭多样化的自然语言处理任务。VisionAI在NLP界的应用领域广泛，能够胜任从机器翻译、文本概要撰写、情绪分析到问答等众多任务。通过对大量文本数据的
  • 如何利用大数据与AI技术革新相亲交友体验 h17711347205 回归算法安全系统架构交友小程序
    在数字化时代，大数据和人工智能（AI）技术正逐渐革新相亲交友体验，为寻找爱情的过程带来前所未有的变革（编辑h17711347205）。通过精准分析和智能匹配，这些技术能够极大地提高相亲交友系统的效率和用户体验。大数据的力量大数据技术能够收集和分析用户的行为模式、偏好和互动数据，为相亲交友系统提供丰富的信息资源。通过分析用户的搜索历史、浏览记录和点击行为，系统能够深入了解用户的兴趣和需求，从而提供更
  • 未来软件市场是怎么样的？做开发的生存空间如何？ cesske 软件需求
    目录前言一、未来软件市场的发展趋势二、软件开发人员的生存空间前言未来软件市场是怎么样的？做开发的生存空间如何？一、未来软件市场的发展趋势技术趋势：人工智能与机器学习：随着技术的不断成熟，人工智能将在更多领域得到应用，如智能客服、自动驾驶、智能制造等，这将极大地推动软件市场的增长。云计算与大数据：云计算服务将继续普及，大数据技术的应用也将更加广泛。企业将更加依赖云计算和大数据来优化运营、提升效率，并
  • Hadoop架构 henan程序媛 hadoop大数据分布式
    一、案列分析1.1案例概述现在已经进入了大数据(BigData)时代，数以万计用户的互联网服务时时刻刻都在产生大量的交互，要处理的数据量实在是太大了，以传统的数据库技术等其他手段根本无法应对数据处理的实时性、有效性的需求。HDFS顺应时代出现，在解决大数据存储和计算方面有很多的优势。1.2案列前置知识点1.什么是大数据大数据是指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的大量数据集合，
  • [转载] NoSQL简介 weixin_30325793 大数据数据库运维
    摘自“百度百科”。NoSQL，泛指非关系型的数据库。随着互联网web2.0网站的兴起，传统的关系数据库在应付web2.0网站，特别是超大规模和高并发的SNS类型的web2.0纯动态网站已经显得力不从心，暴露了很多难以克服的问题，而非关系型的数据库则由于其本身的特点得到了非常迅速的发展。NoSQL数据库的产生就是为了解决大规模数据集合多重数据种类带来的挑战，尤其是大数据应用难题。虽然NoSQL流行语
  • Kafka详细解析与应用分析 芊言芊语 kafka分布式
    Kafka是一个开源的分布式事件流平台（EventStreamingPlatform），由LinkedIn公司最初采用Scala语言开发，并基于ZooKeeper协调管理。如今，Kafka已经被Apache基金会纳入其项目体系，广泛应用于大数据实时处理领域。Kafka凭借其高吞吐量、持久化、分布式和可靠性的特点，成为构建实时流数据管道和流处理应用程序的重要工具。Kafka架构Kafka的架构主要由
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • 疫情，疫情 东山草
    2020年，疫情爆发，至今已近三年，反反复复，此起彼伏。不但没被消灭，还自我发展，从德尔塔到奥密克戎，与时俱进的变异着。去年11月，疫情之下，大数据800米范围内，都成为时空伴随者。“你的码儿有没有变颜色”“你绿码还是黄码”成为那段时间的流行语，当然少不了的还有全员核酸。段子手整出来一首歌：我走过你走过的路,这算不算相逢？我吹过你吹过的风，这算不算相拥？800米内我们不曾擦肩而过，你却要我14天相
  • 在服务器计算节点中使用 jupyter Lab ranshan567 程序人生
    JupyterLab是一个基于网页的交互式开发环境,用于科学计算、数据分析和机器学.jupyterlab是jupyternotebook的下一代产品,集成了更多功能,使用起来更方便.在进行数据分析及可视化时，个人电脑不能满足大数据的分析需求，就需要用到高性能计算机集群资源，然而计算机集群的计算节点往往没有联网功能，所以在计算机集群中使用jupyterLab需要进行一些配置。具体的步骤如下：
  • 大数据真实面试题---SQL The博宇 大数据面试题——SQL大数据mysqlsql数据库bigdata
    视频号数据分析组外包招聘笔试题时间限时45分钟完成。题目根据3张表表结构，写出具体求解的SQL代码（搞笑品类定义：视频分类或者视频创建者分类为“搞笑”）1、表创建语句：createtablet_user_video_action_d(dsint,user_idstring,video_idstring,action_typeint,`timestamp`bigint)rowformatdelimi
  • Flume：大规模日志收集与数据传输的利器 傲雪凌霜，松柏长青 后端大数据flume大数据
    Flume：大规模日志收集与数据传输的利器在大数据时代，随着各类应用的不断增长，产生了海量的日志和数据。这些数据不仅对业务的健康监控至关重要，还可以通过深入分析，帮助企业做出更好的决策。那么，如何高效地收集、传输和存储这些海量数据，成为了一项重要的挑战。今天我们将深入探讨ApacheFlume，它是如何帮助我们应对这些挑战的。一、Flume概述ApacheFlume是一个分布式、可靠、可扩展的日志
  • 云服务业界动态简报-20180128 Captain7
    一、青云青云QingCloud推出深度学习平台DeepLearningonQingCloud，包含了主流的深度学习框架及数据科学工具包，通过QingCloudAppCenter一键部署交付，可以让算法工程师和数据科学家快速构建深度学习开发环境，将更多的精力放在模型和算法调优。二、腾讯云1.腾讯云正式发布腾讯专有云TCE(TencentCloudEnterprise)矩阵，涵盖企业版、大数据版、AI
  • 大数据毕业设计hadoop+spark+hive知识图谱租房数据分析可视化大屏 租房推荐系统 58同城租房爬虫 房源推荐系统 房价预测系统 计算机毕业设计 机器学习 深度学习 人工智能 2401_84572577 程序员大数据hadoop人工智能
    做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。我先来介绍一下这些东西怎么用，文末抱走。（1）Python所有方向的学习路线（
  • 架构评审的自动化与人工智能: 如何提高效率 光剑书架上的书 架构自动化人工智能运维
    1.背景介绍架构评审是软件开发过程中的一个关键环节，它旨在确保软件架构的质量、可维护性和可扩展性。传统的架构评审通常是由人工进行，需要大量的时间和精力。随着大数据技术和人工智能的发展，自动化和人工智能技术已经开始应用于架构评审，从而提高评审的效率和准确性。在本文中，我们将讨论如何通过自动化和人工智能技术来提高架构评审的效率。我们将从以下几个方面进行讨论：背景介绍核心概念与联系核心算法原理和具体操作
  • 【数字化供应链】数字化供应链架构、全景管理、全流程贯通方案 数字化建设方案 数字化转型数据治理主数据数据仓库供应链数字仓储智慧物流智慧仓储物流园区架构微服务数据挖掘大数据人工智能
    原文《数字化供应链架构、全景管理、全流程贯通方案》PPT格式。主要从供应链管理全景、智慧供应链建设总体目标、供应链总体业务流程、供应链总体功能架构、供应链总体技术架构、供应链全流程贯通、供应链全领域管理、供应链数据数据分析、供应链决策中台等进行建设。本文仅对主要内容进行介绍。来源网络公开渠道，旨在交流学习，如有侵权联系速删，更多参考公众号：优享智库基于先进IT技术、大数据能力、物联网应用、区块链平
  • 80 鑫_259b
    科普一个谈恋爱的方法。在以前，谈恋爱千难万难，就难在对对方不知底细，不知道对方希望自己是一个怎样的人，要耗费大量的时间去试探、再磨合，往往会因为一些小事一些细节，满盘皆输。在一个信息化的时代，在一个大数据近乎变成了流行语的时代，我们要跟上时代的步伐，通过大数据，去寻找异性最希望自己展现出来的形象是什么，才可以在爱情的道路上少走弯路。那这个大数据怎么操作呢？上街发问卷？问别人的择偶标准？一来会被打死
  • 解锁企业潜能，Vatee万腾平台引领智能新纪元 自媒体经济说 其他
    在数字化转型的浪潮中，企业正站在一个前所未有的十字路口，面对着前所未有的机遇与挑战。解锁企业内在潜能，实现跨越式发展，已成为众多企业的共同追求。而Vatee万腾平台，作为智能科技的先锋，正以其强大的智能赋能能力，引领企业步入一个全新的智能纪元。Vatee万腾平台，是一个集成了人工智能、大数据、云计算等前沿技术的综合性智能服务平台。它不仅仅是一个技术工具，更是企业转型升级的加速器，能够深入企业运营的
  • 释放“AI+”新质生产力，深算院如何“把大数据变小”？ YashanDB YashanDB国产数据库数据库数据库大数据
    近期，南都·湾财社推出《新质·中国造》栏目，深入千行百业，遍访湾区企业，解锁湾区新质生产力，共探高质量发展之道。本期对话深圳计算科学研究院YashanDB首席技术官陈志标，探讨国产数据库如何实现创新突围，抢抓数字经济时代的新机遇。以下是专访内容：如何应对AI时代所面临的算力挑战？南都·湾财社：数据、算力和算法是发展人工智能的三要素，深算院做了怎样的前瞻性布局？陈志标：今年，政府工作报告中首次提及开
  • 数字化智能工厂数字化供应链架构、全景管理、全流程贯通方案 数字化建设方案 智能制造数字工厂制造业数字化转型工业互联网架构
    随着信息技术的飞速发展，数字化转型已成为制造企业提升竞争力的关键途径。数字化智能工厂通过集成先进的物联网(IoT)、大数据、云计算、人工智能(AI)等技术，实现了生产过程的智能化、供应链管理的精准化及决策的科学化。本方案旨在构建一套完善的数字化供应链架构，实现全景管理、全流程贯通、智慧化升级，以数据为驱动，强化技术支撑与安全管理体系，推动企业向智能制造迈进。一、数字化供应链架构1.**集成化平台构
  • 日记——我的歌单 静若小猴
    又到一年一度大数据汇总的时候了，听歌已经成为很多人生活里的一种乐趣。春夏秋冬，我们都有自己喜欢的歌，歌词歌曲唱出沃尔玛你的心声。还记得大学时候最喜欢听的《春天里》，我有一天单曲回放了30遍，总觉得听着仿佛看到自己声音。还有的歌，初听不知曲中意，再听已经是曲终人，听着歌流泪，听着歌入睡……还记得那些年少的故事吗，总觉得自己才是故事外的人，却不是自己已经入歌。一段时间会喜欢一个人的音乐，一段时间会沉静
  • Linux dmesg命令：显示开机信息 fafadsj666 linux数据库数据挖掘机器学习大数据
    通过学习《Linux启动管理》一章可以知道，在系统启动过程中，内核还会进行一次系统检测（第一次是BIOS进行加测），但是检测的过程不是没有显示在屏幕上，就是会快速的在屏幕上一闪而过那么，如果开机时来不及查看相关信息，我们是否可以在开机后查看呢？答案是肯定的，使用dmesg命令就可以。无论是系统启动过程中，还是系统运行过程中，只要是内核产生的信息，都会被存储在系统缓冲区中，已经为大家精心准备了大数据
  • 大数据新视界 --大数据大厂之揭秘大数据时代 Excel 魔法：大厂数据分析师进阶秘籍 青云交 大数据新视界Excel数据分析函数公式数据透视表图表功能规划求解数据分析工具库大数据新视界数据库
    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
  • 大数据新视界 --大数据大厂之数据挖掘入门：用 R 语言开启数据宝藏的探索之旅 青云交 大数据新视界数据库大数据数据挖掘R语言算法案例未来趋势应用场景学习建议大数据新视界
    亲爱的朋友们，热烈欢迎你们来到青云交的博客！能与你们在此邂逅，我满心欢喜，深感无比荣幸。在这个瞬息万变的时代，我们每个人都在苦苦追寻一处能让心灵安然栖息的港湾。而我的博客，正是这样一个温暖美好的所在。在这里，你们不仅能够收获既富有趣味又极为实用的内容知识，还可以毫无拘束地畅所欲言，尽情分享自己独特的见解。我真诚地期待着你们的到来，愿我们能在这片小小的天地里共同成长，共同进步。本博客的精华专栏：Ja
  • 高职人工智能训练师边缘计算实训室解决方案 武汉唯众智创 人工智能训练师边缘计算实训室人工智能训练师实训室边缘计算实训室
    一、引言随着物联网（IoT）、大数据、人工智能（AI）等技术的飞速发展，计算需求日益复杂和多样化。传统的云计算模式虽在一定程度上满足了这些需求，但在处理海量数据、保障实时性与安全性、提升计算效率等方面仍面临诸多挑战。在此背景下，边缘计算作为一种新兴的计算模式应运而生，通过将计算能力推向数据生成或用户所在的网络边缘，显著降低了数据传输的延迟，提升了处理效率，并增强了数据安全性。针对高等职业院校的人工
  • python基于django/flask的NBA球员大数据分析与可视化python+java+node.js QQ_511008285 pythondjangoflaskjavaspringboot数据分析
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以本文针对NBA球员的大数据进行
  • Java基于spring boot的国产电影数据分析与可视化python+java+node.js QQ_511008285 javaspringboot数据分析pythondjangovue.jsflask
    前端开发框架:vue.js数据库mysql版本不限后端语言框架支持：1java(SSM/springboot)-idea/eclipse2.Nodejs+Vue.js-vscode3.python(flask/django)--pycharm/vscode4.php(thinkphp/laravel)-hbuilderx数据库工具：Navicat/SQLyog等都可以  该系统使用进行大数据处理和
  • 数字化（电子化）招标采购平台系统核心功能详细介绍 xinyuan_123456 oracle
    数智化招标采购平台覆盖全业务类型、全采购流程、全采购方式，是郑州信源公司运用“互联网+”、大数据、人工智能、区块链、物联网等新兴技术，结合供应链管理理念，以招标采购为核心，提供交易、管理、数据、服务、监管为一体的高标准采购管理平台，赋能政企用户实现采购业务全流程的电子化、数字化、智慧化。根据产品功能及应用领域，产品包括：企业数智化招采供应链平台、金融数智化招采平台、政府数智化采购平台、公共资源数智
  • 设计模式介绍 tntxia 设计模式
    设计模式来源于土木工程师 克里斯托弗 亚历山大（http://en.wikipedia.org/wiki/Christopher_Alexander）的早期作品。他经常发表一些作品，内容是总结他在解决设计问题方面的经验，以及这些知识与城市和建筑模式之间有何关联。有一天，亚历山大突然发现，重复使用这些模式可以让某些设计构造取得我们期望的最佳效果。 亚历山大与萨拉-石川佳纯和穆雷 西乐弗斯坦合作
  • android高级组件使用(一) 百合不是茶 androidRatingBarSpinner
    1、自动完成文本框（AutoCompleteTextView） AutoCompleteTextView从EditText派生出来，实际上也是一个文本编辑框，但它比普通编辑框多一个功能：当用户输入一个字符后，自动完成文本框会显示一个下拉菜单，供用户从中选择，当用户选择某个菜单项之后，AutoCompleteTextView按用户选择自动填写该文本框。 使用AutoCompleteTex
  • [网络与通讯]路由器市场大有潜力可挖掘 comsci 网络
              如果国内的电子厂商和计算机设备厂商觉得手机市场已经有点饱和了,那么可以考虑一下交换机和路由器市场的进入问题.....        这方面的技术和知识,目前处在一个开放型的状态,有利于各类小型电子企业进入  &nbs
  • 自写简单Redis内存统计shell 商人shang Linux shell统计Redis内存
    #!/bin/bash address="192.168.150.128:6666,192.168.150.128:6666" hosts=(${address//,/ }) sfile="staticts.log" for hostitem in ${hosts[@]} do ipport=(${hostitem
  • 单例模式(饿汉 vs懒汉) oloz 单例模式
    package 单例模式; /* * 应用场景:保证在整个应用之中某个对象的实例只有一个 * 单例模式种的《 懒汉模式》 * */ public class Singleton { //01 将构造方法私有化，外界就无法用new Singleton()的方式获得实例 private Singleton(){}; //02 申明类得唯一实例 priva
  • springMvc json支持 杨白白 json springmvc
    1.Spring mvc处理json需要使用jackson的类库，因此需要先引入jackson包 2在spring mvc中解析输入为json格式的数据:使用@RequestBody来设置输入 @RequestMapping("helloJson") public @ResponseBody JsonTest helloJson() {
  • android播放，掃描添加本地音頻文件 小桔子
            最近幾乎沒有什麽事情，繼續鼓搗我的小東西。想在項目中加入一個簡易的音樂播放器功能，就像華為p6桌面上那麼大小的音樂播放器。用過天天動聽或者QQ音樂播放器的人都知道，可已通過本地掃描添加歌曲。不知道他們是怎麼實現的，我覺得應該掃描設備上的所有文件，過濾出音頻文件，每個文件實例化為一個實體，記錄文件名、路徑、歌手、類型、大小等信息。具體算法思想，
  • oracle常用命令 aichenglong oracledba常用命令
    1 创建临时表空间 create temporary tablespace user_temp  tempfile 'D:\oracle\oradata\Oracle9i\user_temp.dbf' size 50m  autoextend on  next 50m maxsize 20480m  extent management local
  • 25个Eclipse插件 AILIKES eclipse插件
    提高代码质量的插件1. FindBugsFindBugs可以帮你找到Java代码中的bug，它使用Lesser GNU Public License的自由软件许可。2. CheckstyleCheckstyle插件可以集成到Eclipse IDE中去，能确保Java代码遵循标准代码样式。3. ECLemmaECLemma是一款拥有Eclipse Public License许可的免费工具，它提供了
  • Spring MVC拦截器+注解方式实现防止表单重复提交 baalwolf spring mvc
    原理：在新建页面中Session保存token随机码，当保存时验证，通过后删除，当再次点击保存时由于服务器端的Session中已经不存在了，所有无法验证通过。   1.新建注解：   ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
  • 《Javascript高级程序设计(第3版)》闭包理解 bijian1013 JavaScript
    “闭包是指有权访问另一个函数作用域中的变量的函数。”--《Javascript高级程序设计(第3版)》         看以下代码： <script type="text/javascript"> function outer() { var i = 10; return f
  • AngularJS Module类的方法 bijian1013 JavaScriptAngularJSModule
            AngularJS中的Module类负责定义应用如何启动，它还可以通过声明的方式定义应用中的各个片段。我们来看看它是如何实现这些功能的。 一.Main方法在哪里         如果你是从Java或者Python编程语言转过来的，那么你可能很想知道AngularJS里面的main方法在哪里？这个把所
  • [Maven学习笔记七]Maven插件和目标 bit1129 maven插件
    插件(plugin)和目标(goal) Maven，就其本质而言，是一个插件执行框架，Maven的每个目标的执行逻辑都是由插件来完成的，一个插件可以有1个或者几个目标，比如maven-compiler-plugin插件包含compile和testCompile，即maven-compiler-plugin提供了源代码编译和测试源代码编译的两个目标   使用插件和目标使得我们可以干预
  • 【Hadoop八】Yarn的资源调度策略 bit1129 hadoop
    1. Hadoop的三种调度策略 Hadoop提供了3中作业调用的策略， FIFO Scheduler Fair Scheduler Capacity Scheduler 以上三种调度算法，在Hadoop MR1中就引入了，在Yarn中对它们进行了改进和完善.Fair和Capacity Scheduler用于多用户共享的资源调度   2. 多用户资源共享的调度
  • Nginx使用Linux内存加速静态文件访问 ronin47
    Nginx是一个非常出色的静态资源web服务器。如果你嫌它还不够快，可以把放在磁盘中的文件，映射到内存中，减少高并发下的磁盘IO。 先做几个假设。nginx.conf中所配置站点的路径是/home/wwwroot/res，站点所对应文件原始存储路径：/opt/web/res shell脚本非常简单，思路就是拷贝资源文件到内存中，然后在把网站的静态文件链接指向到内存中即可。具体如下：
  • 关于Unity3D中的Shader的知识 brotherlamp unityunity资料unity教程unity视频unity自学
    首先先解释下Unity3D的Shader，Unity里面的Shaders是使用一种叫ShaderLab的语言编写的，它同微软的FX文件或者NVIDIA的CgFX有些类似。传统意义上的vertex shader和pixel shader还是使用标准的Cg/HLSL 编程语言编写的。因此Unity文档里面的Shader，都是指用ShaderLab编写的代码，然后我们来看下Unity3D自带的60多个S
  • CopyOnWriteArrayList vs ArrayList bylijinnan java
    package com.ljn.base; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.concurrent.CopyOnWriteArrayList; /** * 总述： * 1.ArrayListi不是线程安全的，CopyO
  • 内存中栈和堆的区别 chicony 内存
    1、内存分配方面：     堆：一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式是类似于链表。可能用到的关键字如下：new、malloc、delete、free等等。     栈：由编译器(Compiler)自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中
  • 回答一位网友对Scala的提问 chenchao051 scalamap
    本来准备在私信里直接回复了，但是发现不太方便，就简要回答在这里。 问题 写道 对于scala的简洁十分佩服，但又觉得比较晦涩，例如一例，Map("a" -> List(11,111)).flatMap(_._2)，可否说下最后那个函数做了什么，真正在开发的时候也会如此简洁？谢谢    先回答一点，在实际使用中，Scala毫无疑问就是这么简单。
  • mysql 取每组前几条记录 daizj mysql分组最大值最小值每组三条记录
    一、对分组的记录取前N条记录：例如：取每组的前3条最大的记录 1.用子查询： SELECT * FROM tableName a  WHERE 3> (SELECT COUNT(*) FROM  tableName b WHERE b.id=a.id AND b.cnt>a. cnt) ORDER BY a.id,a.account DE
  • HTTP深入浅出 http请求 dcj3sjt126com http
      HTTP(HyperText Transfer Protocol)是一套计算机通过网络进行通信的规则。计算机专家设计出HTTP，使HTTP客户（如Web浏览器）能够从HTTP服务器(Web服务器)请求信息和服务，HTTP目前协议的版本是1.1.HTTP是一种无状态的协议，无状态是指Web浏览器和Web服务器之间不需要建立持久的连接，这意味着当一个客户端向服务器端发出请求，然后We
  • 判断MySQL记录是否存在方法比较 dcj3sjt126com mysql
    把数据写入到数据库的时，常常会碰到先要检测要插入的记录是否存在，然后决定是否要写入。 　　我这里总结了判断记录是否存在的常用方法： 　　sql语句： select   count ( * )  from  tablename; 　　然后读取count(*)的值判断记录是否存在。对于这种方法性能上有些浪费，我们只是想判断记录记录是否存在，没有必要全部都查出来。
  • 对HTML XML的一点认识 e200702084 htmlxml
    感谢http://www.w3school.com.cn提供的资料 HTML 文档中的每个成分都是一个节点。 节点 根据 DOM，HTML 文档中的每个成分都是一个节点。 DOM 是这样规定的： 整个文档是一个文档节点 每个 HTML 标签是一个元素节点 包含在 HTML 元素中的文本是文本节点 每一个 HTML 属性是一个属性节点 注释属于注释节点 Node 层次
  • jquery分页插件 genaiwei jqueryWeb前端分页插件
    //jquery页码控件// 创建一个闭包    (function($) {      // 插件的定义      $.fn.pageTool = function(options) {        var totalPa
  • Mybatis与Ibatis对照入门于学习 Josh_Persistence mybatisibatis区别联系
    一、为什么使用IBatis/Mybatis         对于从事 Java EE 的开发人员来说，iBatis 是一个再熟悉不过的持久层框架了，在 Hibernate、JPA 这样的一站式对象 / 关系映射（O/R Mapping）解决方案盛行之前，iBaits 基本是持久层框架的不二选择。即使在持久层框架层出不穷的今天，iBatis 凭借着易学易用、
  • C中怎样合理决定使用那种整数类型？ 秋风扫落叶 c数据类型
    如果需要大数值(大于32767或小于32767), 使用long 型。 否则, 如果空间很重要 (如有大数组或很多结构), 使用 short 型。 除此之外, 就使用 int 型。 如果严格定义的溢出特征很重要而负值无关紧要, 或者你希望在操作二进制位和字节时避免符号扩展的问题, 请使用对应的无符号类型。 但是, 要注意在表达式中混用有符号和无符号值的情况。    &nbs
  • maven问题 zhb8015 maven问题
      问题1： Eclipse 中 新建maven项目 无法添加src/main/java 问题    eclipse创建maevn web项目，在选择maven_archetype_web原型后，默认只有src/main/resources这个Source Floder。     按照maven目录结构，添加src/main/ja
  • (二)androidpn-server tomcat版源码解析之--push消息处理 spjich javaandrodipn推送
    在 (一)androidpn-server tomcat版源码解析之--项目启动这篇中，已经描述了整个推送服务器的启动过程，并且把握到了消息的入口即XmppIoHandler这个类，今天我将继续往下分析下面的核心代码，主要分为3大块，链接创建，消息的发送，链接关闭。 先贴一段XmppIoHandler的部分代码 /** * Invoked from an I/O proc
  • 用js中的formData类型解决ajax提交表单时文件不能被serialize方法序列化的问题 中华好儿孙 JavaScriptAjaxWeb上传文件FormData
    var formData = new FormData($("#inputFileForm")[0]); $.ajax({ type:'post', url:webRoot+"/electronicContractUrl/webapp/uploadfile", data:formData, async: false, ca
  • mybatis常用jdbcType数据类型 ysj5125094 mybatismapperjdbcType
      MyBatis 通过包含的jdbcType 类型 BIT         FLOAT      CHAR