聊聊ShardingSphere是怎么进行sql重写的

序

本文主要研究一下ShardingSphere进行sql重写的原理

prepareStatement

org/apache/shardingsphere/driver/jdbc/core/connection/ShardingSphereConnection.java

public final class ShardingSphereConnection extends AbstractConnectionAdapter {

    @Override
    public PreparedStatement prepareStatement(final String sql) throws SQLException {
        return new ShardingSpherePreparedStatement(this, sql);
    }

    //......
}
ShardingSphereConnection的prepareStatement创建的是ShardingSpherePreparedStatement

ShardingSpherePreparedStatement

org/apache/shardingsphere/driver/jdbc/core/statement/ShardingSpherePreparedStatement.java

public final class ShardingSpherePreparedStatement extends AbstractPreparedStatementAdapter {
    
    @Getter
    private final ShardingSphereConnection connection;

    public ShardingSpherePreparedStatement(final ShardingSphereConnection connection, final String sql) throws SQLException {
        this(connection, sql, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT, false, null);
    }

    private ShardingSpherePreparedStatement(final ShardingSphereConnection connection, final String sql,
                                            final int resultSetType, final int resultSetConcurrency, final int resultSetHoldability, final boolean returnGeneratedKeys,
                                            final String[] columns) throws SQLException {
        if (Strings.isNullOrEmpty(sql)) {
            throw new EmptySQLException().toSQLException();
        }
        this.connection = connection;
        metaDataContexts = connection.getContextManager().getMetaDataContexts();
        SQLParserRule sqlParserRule = metaDataContexts.getMetaData().getGlobalRuleMetaData().getSingleRule(SQLParserRule.class);
        hintValueContext = sqlParserRule.isSqlCommentParseEnabled() ? new HintValueContext() : SQLHintUtils.extractHint(sql).orElseGet(HintValueContext::new);
        this.sql = sqlParserRule.isSqlCommentParseEnabled() ? sql : SQLHintUtils.removeHint(sql);
        statements = new ArrayList<>();
        parameterSets = new ArrayList<>();
        SQLParserEngine sqlParserEngine = sqlParserRule.getSQLParserEngine(
                DatabaseTypeEngine.getTrunkDatabaseTypeName(metaDataContexts.getMetaData().getDatabase(connection.getDatabaseName()).getProtocolType()));
        sqlStatement = sqlParserEngine.parse(this.sql, true);
        sqlStatementContext = SQLStatementContextFactory.newInstance(metaDataContexts.getMetaData(), sqlStatement, connection.getDatabaseName());
        parameterMetaData = new ShardingSphereParameterMetaData(sqlStatement);
        statementOption = returnGeneratedKeys ? new StatementOption(true, columns) : new StatementOption(resultSetType, resultSetConcurrency, resultSetHoldability);
        executor = new DriverExecutor(connection);
        JDBCExecutor jdbcExecutor = new JDBCExecutor(connection.getContextManager().getExecutorEngine(), connection.getDatabaseConnectionManager().getConnectionContext());
        batchPreparedStatementExecutor = new BatchPreparedStatementExecutor(metaDataContexts, jdbcExecutor, connection.getDatabaseName());
        kernelProcessor = new KernelProcessor();
        statementsCacheable = isStatementsCacheable(metaDataContexts.getMetaData().getDatabase(connection.getDatabaseName()).getRuleMetaData());
        trafficRule = metaDataContexts.getMetaData().getGlobalRuleMetaData().getSingleRule(TrafficRule.class);
        selectContainsEnhancedTable = sqlStatementContext instanceof SelectStatementContext && ((SelectStatementContext) sqlStatementContext).isContainsEnhancedTable();
        statementManager = new StatementManager();
    }

    //......
}
ShardingSpherePreparedStatement继承了AbstractPreparedStatementAdapter，其构造器主要是通过SQLParserEngine解析sql得到SQLStatement，创建DriverExecutor、BatchPreparedStatementExecutor、KernelProcessor、StatementManager；这里即使useServerPrepStmts=true，也不会触发mysql server的prepare操作

executeUpdate

    public int executeUpdate() throws SQLException {
        try {
            if (statementsCacheable && !statements.isEmpty()) {
                resetParameters();
                return statements.iterator().next().executeUpdate();
            }
            clearPrevious();
            QueryContext queryContext = createQueryContext();
            trafficInstanceId = getInstanceIdAndSet(queryContext).orElse(null);
            if (null != trafficInstanceId) {
                JDBCExecutionUnit executionUnit = createTrafficExecutionUnit(trafficInstanceId, queryContext);
                return executor.getTrafficExecutor().execute(executionUnit, (statement, sql) -> ((PreparedStatement) statement).executeUpdate());
            }
            executionContext = createExecutionContext(queryContext);
            if (hasRawExecutionRule()) {
                Collection executeResults = executor.getRawExecutor().execute(createRawExecutionGroupContext(), executionContext.getQueryContext(), new RawSQLExecutorCallback());
                return accumulate(executeResults);
            }
            return isNeedImplicitCommitTransaction(connection, executionContext) ? executeUpdateWithImplicitCommitTransaction() : useDriverToExecuteUpdate();
            // CHECKSTYLE:OFF
        } catch (final RuntimeException ex) {
            // CHECKSTYLE:ON
            handleExceptionInTransaction(connection, metaDataContexts);
            throw SQLExceptionTransformEngine.toSQLException(ex, metaDataContexts.getMetaData().getDatabase(connection.getDatabaseName()).getProtocolType().getType());
        } finally {
            clearBatch();
        }
    }

    private void clearPrevious() {
        statements.clear();
        parameterSets.clear();
        generatedValues.clear();
    }

    private ExecutionContext createExecutionContext(final QueryContext queryContext) {
        ShardingSphereRuleMetaData globalRuleMetaData = metaDataContexts.getMetaData().getGlobalRuleMetaData();
        ShardingSphereDatabase currentDatabase = metaDataContexts.getMetaData().getDatabase(connection.getDatabaseName());
        SQLAuditEngine.audit(queryContext.getSqlStatementContext(), queryContext.getParameters(), globalRuleMetaData, currentDatabase, null, queryContext.getHintValueContext());
        ExecutionContext result = kernelProcessor.generateExecutionContext(
                queryContext, currentDatabase, globalRuleMetaData, metaDataContexts.getMetaData().getProps(), connection.getDatabaseConnectionManager().getConnectionContext());
        findGeneratedKey(result).ifPresent(optional -> generatedValues.addAll(optional.getGeneratedValues()));
        return result;
    }
这里executeUpdate会先执行clearPrevious方法，清空statements、parameterSets、generatedValues，然后createExecutionContext，这里有一步是kernelProcessor.generateExecutionContext

KernelProcessor

generateExecutionContext

shardingsphere-infra-context-5.4.0-sources.jar!/org/apache/shardingsphere/infra/connection/kernel/KernelProcessor.java

    public ExecutionContext generateExecutionContext(final QueryContext queryContext, final ShardingSphereDatabase database, final ShardingSphereRuleMetaData globalRuleMetaData,
                                                     final ConfigurationProperties props, final ConnectionContext connectionContext) {
        RouteContext routeContext = route(queryContext, database, globalRuleMetaData, props, connectionContext);
        SQLRewriteResult rewriteResult = rewrite(queryContext, database, globalRuleMetaData, props, routeContext, connectionContext);
        ExecutionContext result = createExecutionContext(queryContext, database, routeContext, rewriteResult);
        logSQL(queryContext, props, result);
        return result;
    }
KernelProcessor的generateExecutionContext方法先创建routeContext，然后执行rewrite，最后执行createExecutionContext

rewrite

    private SQLRewriteResult rewrite(final QueryContext queryContext, final ShardingSphereDatabase database, final ShardingSphereRuleMetaData globalRuleMetaData,
                                     final ConfigurationProperties props, final RouteContext routeContext, final ConnectionContext connectionContext) {
        SQLRewriteEntry sqlRewriteEntry = new SQLRewriteEntry(database, globalRuleMetaData, props);
        return sqlRewriteEntry.rewrite(queryContext.getSql(), queryContext.getParameters(), queryContext.getSqlStatementContext(), routeContext, connectionContext, queryContext.getHintValueContext());
    }
rewrite主要是通过SQLRewriteEntry的rewrite方法进行的

SQLRewriteEntry

shardingsphere-infra-rewrite-5.4.0-sources.jar!/org/apache/shardingsphere/infra/rewrite/SQLRewriteEntry.java

    /**
     * Rewrite.
     * 
     * @param sql SQL
     * @param params SQL parameters
     * @param sqlStatementContext SQL statement context
     * @param routeContext route context
     * @param connectionContext connection context
     * @param hintValueContext hint value context
     * 
     * @return route unit and SQL rewrite result map
     */
    public SQLRewriteResult rewrite(final String sql, final List params, final SQLStatementContext sqlStatementContext,
                                    final RouteContext routeContext, final ConnectionContext connectionContext, final HintValueContext hintValueContext) {
        SQLRewriteContext sqlRewriteContext = createSQLRewriteContext(sql, params, sqlStatementContext, routeContext, connectionContext, hintValueContext);
        SQLTranslatorRule rule = globalRuleMetaData.getSingleRule(SQLTranslatorRule.class);
        DatabaseType protocolType = database.getProtocolType();
        Map storageTypes = database.getResourceMetaData().getStorageTypes();
        return routeContext.getRouteUnits().isEmpty()
                ? new GenericSQLRewriteEngine(rule, protocolType, storageTypes).rewrite(sqlRewriteContext)
                : new RouteSQLRewriteEngine(rule, protocolType, storageTypes).rewrite(sqlRewriteContext, routeContext);
    }

    private SQLRewriteContext createSQLRewriteContext(final String sql, final List params, final SQLStatementContext sqlStatementContext,
                                                      final RouteContext routeContext, final ConnectionContext connectionContext, final HintValueContext hintValueContext) {
        SQLRewriteContext result = new SQLRewriteContext(database.getName(), database.getSchemas(), sqlStatementContext, sql, params, connectionContext, hintValueContext);
        decorate(decorators, result, routeContext, hintValueContext);
        result.generateSQLTokens();
        return result;
    }

    private void decorate(final Map decorators, final SQLRewriteContext sqlRewriteContext,
                          final RouteContext routeContext, final HintValueContext hintValueContext) {
        if (hintValueContext.isSkipSQLRewrite()) {
            return;
        }
        for (Entry entry : decorators.entrySet()) {
            entry.getValue().decorate(entry.getKey(), props, sqlRewriteContext, routeContext);
        }
    } 
 

   SQLRewriteEntry的rewrite方法，先通过createSQLRewriteContext来创建SQLRewriteContext，这里通过decorate方法遍历decorators，挨个执行SQLRewriteContextDecorator的decorate方法；最后通过GenericSQLRewriteEngine或者RouteSQLRewriteEngine进行rewrite 
 
 
 
SQLRewriteContextDecorator
 
 
org/apache/shardingsphere/infra/rewrite/context/SQLRewriteContextDecorator.java
 
 
@SingletonSPI
public interface SQLRewriteContextDecorator extends OrderedSPI {
    
    /**
     * Decorate SQL rewrite context.
     *
     * @param rule rule
     * @param props ShardingSphere properties
     * @param sqlRewriteContext SQL rewrite context to be decorated
     * @param routeContext route context
     */
    void decorate(T rule, ConfigurationProperties props, SQLRewriteContext sqlRewriteContext, RouteContext routeContext);
}
 
 

   SQLRewriteContextDecorator定义了decorate方法，它有诸如ShardingSQLRewriteContextDecorator、EncryptSQLRewriteContextDecorator的实现类 
 
 
 
EncryptSQLRewriteContextDecorator
 
 
org/apache/shardingsphere/encrypt/rewrite/context/EncryptSQLRewriteContextDecorator.java
 
 
/**
 * SQL rewrite context decorator for encrypt.
 */
public final class EncryptSQLRewriteContextDecorator implements SQLRewriteContextDecorator {
    
    @Override
    public void decorate(final EncryptRule encryptRule, final ConfigurationProperties props, final SQLRewriteContext sqlRewriteContext, final RouteContext routeContext) {
        SQLStatementContext sqlStatementContext = sqlRewriteContext.getSqlStatementContext();
        if (!containsEncryptTable(encryptRule, sqlStatementContext)) {
            return;
        }
        Collection encryptConditions = createEncryptConditions(encryptRule, sqlRewriteContext);
        if (!sqlRewriteContext.getParameters().isEmpty()) {
            Collection parameterRewriters = new EncryptParameterRewriterBuilder(encryptRule,
                    sqlRewriteContext.getDatabaseName(), sqlRewriteContext.getSchemas(), sqlStatementContext, encryptConditions).getParameterRewriters();
            rewriteParameters(sqlRewriteContext, parameterRewriters);
        }
        Collection sqlTokenGenerators = new EncryptTokenGenerateBuilder(encryptRule,
                sqlStatementContext, encryptConditions, sqlRewriteContext.getDatabaseName()).getSQLTokenGenerators();
        sqlRewriteContext.addSQLTokenGenerators(sqlTokenGenerators);
    }
    
    private Collection createEncryptConditions(final EncryptRule encryptRule, final SQLRewriteContext sqlRewriteContext) {
        SQLStatementContext sqlStatementContext = sqlRewriteContext.getSqlStatementContext();
        if (!(sqlStatementContext instanceof WhereAvailable)) {
            return Collections.emptyList();
        }
        Collection whereSegments = ((WhereAvailable) sqlStatementContext).getWhereSegments();
        Collection columnSegments = ((WhereAvailable) sqlStatementContext).getColumnSegments();
        return new EncryptConditionEngine(encryptRule, sqlRewriteContext.getSchemas())
                .createEncryptConditions(whereSegments, columnSegments, sqlStatementContext, sqlRewriteContext.getDatabaseName());
    }
    
    private boolean containsEncryptTable(final EncryptRule encryptRule, final SQLStatementContext sqlStatementContext) {
        for (String each : sqlStatementContext.getTablesContext().getTableNames()) {
            if (encryptRule.findEncryptTable(each).isPresent()) {
                return true;
            }
        }
        return false;
    }
    
    private void rewriteParameters(final SQLRewriteContext sqlRewriteContext, final Collection parameterRewriters) {
        for (ParameterRewriter each : parameterRewriters) {
            each.rewrite(sqlRewriteContext.getParameterBuilder(), sqlRewriteContext.getSqlStatementContext(), sqlRewriteContext.getParameters());
        }
    }
    
    @Override
    public int getOrder() {
        return EncryptOrder.ORDER;
    }
    
    @Override
    public Class getTypeClass() {
        return EncryptRule.class;
    }
}
 
 

   rewriteParameters是通过ParameterRewriter进行rewrite，主要是修改ParameterBuilder；而具体sql语句的修改则通过sqlTokenGenerators进行 
 
 
 
SQLToken
 
 
@RequiredArgsConstructor
@Getter
public abstract class SQLToken implements Comparable {
    
    private final int startIndex;
    
    @Override
    public final int compareTo(final SQLToken sqlToken) {
        return startIndex - sqlToken.startIndex;
    }
}
 
 

   SQLToken它有诸如InsertValuesToken、SubstitutableColumnNameToken、InsertColumnsToken之类的实现类 
 
 
 
RouteSQLRewriteEngine
 
 
    /**
     * Rewrite SQL and parameters.
     *
     * @param sqlRewriteContext SQL rewrite context
     * @param routeContext route context
     * @return SQL rewrite result
     */
    public RouteSQLRewriteResult rewrite(final SQLRewriteContext sqlRewriteContext, final RouteContext routeContext) {
        Map sqlRewriteUnits = new LinkedHashMap<>(routeContext.getRouteUnits().size(), 1F);
        for (Entry> entry : aggregateRouteUnitGroups(routeContext.getRouteUnits()).entrySet()) {
            Collection routeUnits = entry.getValue();
            if (isNeedAggregateRewrite(sqlRewriteContext.getSqlStatementContext(), routeUnits)) {
                sqlRewriteUnits.put(routeUnits.iterator().next(), createSQLRewriteUnit(sqlRewriteContext, routeContext, routeUnits));
            } else {
                addSQLRewriteUnits(sqlRewriteUnits, sqlRewriteContext, routeContext, routeUnits);
            }
        }
        return new RouteSQLRewriteResult(translate(sqlRewriteContext.getSqlStatementContext().getSqlStatement(), sqlRewriteUnits));
    }

    private void addSQLRewriteUnits(final Map sqlRewriteUnits, final SQLRewriteContext sqlRewriteContext,
                                    final RouteContext routeContext, final Collection routeUnits) {
        for (RouteUnit each : routeUnits) {
            sqlRewriteUnits.put(each, new SQLRewriteUnit(new RouteSQLBuilder(sqlRewriteContext, each).toSQL(), getParameters(sqlRewriteContext.getParameterBuilder(), routeContext, each)));
        }
    }

    private Map translate(final SQLStatement sqlStatement, final Map sqlRewriteUnits) {
        Map result = new LinkedHashMap<>(sqlRewriteUnits.size(), 1F);
        for (Entry entry : sqlRewriteUnits.entrySet()) {
            DatabaseType storageType = storageTypes.get(entry.getKey().getDataSourceMapper().getActualName());
            String sql = translatorRule.translate(entry.getValue().getSql(), sqlStatement, protocolType, storageType);
            SQLRewriteUnit sqlRewriteUnit = new SQLRewriteUnit(sql, entry.getValue().getParameters());
            result.put(entry.getKey(), sqlRewriteUnit);
        }
        return result;
    }
 
 

   addSQLRewriteUnits是往sqlRewriteUnits添加SQLRewriteUnit，最后translate方法构建SQLRewriteUnit；SQLRewriteUnit包含了更改之后的sql以及对应改动后的参数 
 
 
 
useDriverToExecuteUpdate
 
 
org/apache/shardingsphere/driver/jdbc/core/statement/ShardingSpherePreparedStatement.java
 
 
    private int useDriverToExecuteUpdate() throws SQLException {
        ExecutionGroupContext executionGroupContext = createExecutionGroupContext();
        cacheStatements(executionGroupContext.getInputGroups());
        return executor.getRegularExecutor().executeUpdate(executionGroupContext,
                executionContext.getQueryContext(), executionContext.getRouteContext().getRouteUnits(), createExecuteUpdateCallback());
    }

    private ExecutionGroupContext createExecutionGroupContext() throws SQLException {
        DriverExecutionPrepareEngine prepareEngine = createDriverExecutionPrepareEngine();
        return prepareEngine.prepare(executionContext.getRouteContext(), executionContext.getExecutionUnits(), new ExecutionGroupReportContext(connection.getDatabaseName()));
    } 

    private void cacheStatements(final Collection> executionGroups) throws SQLException {
        for (ExecutionGroup each : executionGroups) {
            each.getInputs().forEach(eachInput -> {
                statements.add((PreparedStatement) eachInput.getStorageResource());
                parameterSets.add(eachInput.getExecutionUnit().getSqlUnit().getParameters());
            });
        }
        replay();
    }

    private void replay() throws SQLException {
        replaySetParameter();
        for (Statement each : statements) {
            getMethodInvocationRecorder().replay(each);
        }
    }

    private void replaySetParameter() throws SQLException {
        for (int i = 0; i < statements.size(); i++) {
            replaySetParameter(statements.get(i), parameterSets.get(i));
        }
    }

    protected final void replaySetParameter(final PreparedStatement preparedStatement, final List params) throws SQLException {
        setParameterMethodInvocations.clear();
        addParameters(params);
        for (PreparedStatementInvocationReplayer each : setParameterMethodInvocations) {
            each.replayOn(preparedStatement);
        }
    }

    private void addParameters(final List params) {
        int i = 0;
        for (Object each : params) {
            int index = ++i;
            setParameterMethodInvocations.add(preparedStatement -> preparedStatement.setObject(index, each));
        }
    } 
 

   useDriverToExecuteUpdate方法会执行createExecutionGroupContext(会执行prepare方法)，cacheStatements这里主要是把eachInput.getStorageResource()真正的PrepareStatement赋值到ShardingSpherePreparedStatement的statements变量中，把eachInput.getExecutionUnit().getSqlUnit().getParameters()赋值到parameterSets，然后执行replay方法通过PreparedStatementInvocationReplayer把修改后的变量replay到真正的PrepareStatement 
  
该方法委托给executor.getRegularExecutor().executeUpdate，最后一个参数为callback，即createExecuteUpdateCallback 
 
 
 
DriverExecutionPrepareEngine.prepare
 
 
org/apache/shardingsphere/infra/executor/sql/prepare/AbstractExecutionPrepareEngine.java
 
 
    public final ExecutionGroupContext prepare(final RouteContext routeContext, final Collection executionUnits,
                                                  final ExecutionGroupReportContext reportContext) throws SQLException {
        return prepare(routeContext, Collections.emptyMap(), executionUnits, reportContext);
    }

    public final ExecutionGroupContext prepare(final RouteContext routeContext, final Map connectionOffsets, final Collection executionUnits,
                                                  final ExecutionGroupReportContext reportContext) throws SQLException {
        Collection> result = new LinkedList<>();
        for (Entry> entry : aggregateSQLUnitGroups(executionUnits).entrySet()) {
            String dataSourceName = entry.getKey();
            List sqlUnits = entry.getValue();
            List> sqlUnitGroups = group(sqlUnits);
            ConnectionMode connectionMode = maxConnectionsSizePerQuery < sqlUnits.size() ? ConnectionMode.CONNECTION_STRICTLY : ConnectionMode.MEMORY_STRICTLY;
            result.addAll(group(dataSourceName, connectionOffsets.getOrDefault(dataSourceName, 0), sqlUnitGroups, connectionMode));
        }
        return decorate(routeContext, result, reportContext);
    }

    protected List> group(final String dataSourceName, final int connectionOffset, final List> sqlUnitGroups, final ConnectionMode connectionMode) throws SQLException {
        List> result = new LinkedList<>();
        List connections = databaseConnectionManager.getConnections(dataSourceName, connectionOffset, sqlUnitGroups.size(), connectionMode);
        int count = 0;
        for (List each : sqlUnitGroups) {
            result.add(createExecutionGroup(dataSourceName, each, connections.get(count++), connectionMode));
        }
        return result;
    }

    private ExecutionGroup createExecutionGroup(final String dataSourceName, final List sqlUnits, final C connection, final ConnectionMode connectionMode) throws SQLException {
        List result = new LinkedList<>();
        for (SQLUnit each : sqlUnits) {
            result.add((T) sqlExecutionUnitBuilder.build(new ExecutionUnit(dataSourceName, each), statementManager, connection, connectionMode, option, databaseTypes.get(dataSourceName)));
        }
        return new ExecutionGroup<>(result);
    }
 
 

   group方法调用遍历SQLUnit执行createExecutionGroup，而后者则执行sqlExecutionUnitBuilder.build；这里databaseConnectionManager.getConnections获取的connection是通过真正driver获取的connection(com.mysql.jdbc.Driver) 
 
 
 
PreparedStatementExecutionUnitBuilder
 
 
org/apache/shardingsphere/infra/executor/sql/prepare/driver/jdbc/builder/PreparedStatementExecutionUnitBuilder.java
 
 
    public JDBCExecutionUnit build(final ExecutionUnit executionUnit, final ExecutorJDBCStatementManager statementManager,
                                   final Connection connection, final ConnectionMode connectionMode, final StatementOption option, final DatabaseType databaseType) throws SQLException {
        PreparedStatement preparedStatement = createPreparedStatement(
                executionUnit, statementManager, connection, connectionMode, option, databaseType);
        return new JDBCExecutionUnit(executionUnit, connectionMode, preparedStatement);
    }

    private PreparedStatement createPreparedStatement(final ExecutionUnit executionUnit, final ExecutorJDBCStatementManager statementManager, final Connection connection,
                                                      final ConnectionMode connectionMode, final StatementOption option, final DatabaseType databaseType) throws SQLException {
        return (PreparedStatement) statementManager.createStorageResource(executionUnit, connection, connectionMode, option, databaseType);
    }
 
 

   PreparedStatementExecutionUnitBuilder的build方法这里才真正创建PreparedStatement 
 
 
 
StatementManager
 
 
org/apache/shardingsphere/driver/jdbc/core/statement/StatementManager.java
 
 
    public Statement createStorageResource(final ExecutionUnit executionUnit, final Connection connection, final ConnectionMode connectionMode, final StatementOption option,
                                           final DatabaseType databaseType) throws SQLException {
        Statement result = cachedStatements.get(new CacheKey(executionUnit, connectionMode));
        if (null == result || result.isClosed() || result.getConnection().isClosed()) {
            String sql = executionUnit.getSqlUnit().getSql();
            if (option.isReturnGeneratedKeys()) {
                result = null == option.getColumns() || 0 == option.getColumns().length
                        ? connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)
                        : connection.prepareStatement(sql, option.getColumns());
            } else {
                result = connection.prepareStatement(sql, option.getResultSetType(), option.getResultSetConcurrency(), option.getResultSetHoldability());
            }
            cachedStatements.put(new CacheKey(executionUnit, connectionMode), result);
        }
        return result;
    }
 
 

   createStorageResource则是通过connection.prepareStatement来创建真正的PrepareStatement，而此时传入的sql也是经过重写之后的sql 
 
 
 
createExecuteUpdateCallback
 
 
org/apache/shardingsphere/driver/jdbc/core/statement/ShardingSpherePreparedStatement.java
 
 
    private JDBCExecutorCallback createExecuteUpdateCallback() {
        boolean isExceptionThrown = SQLExecutorExceptionHandler.isExceptionThrown();
        return new JDBCExecutorCallback(metaDataContexts.getMetaData().getDatabase(connection.getDatabaseName()).getProtocolType(),
                metaDataContexts.getMetaData().getDatabase(connection.getDatabaseName()).getResourceMetaData().getStorageTypes(), sqlStatement, isExceptionThrown) {
            
            @Override
            protected Integer executeSQL(final String sql, final Statement statement, final ConnectionMode connectionMode, final DatabaseType storageType) throws SQLException {
                return ((PreparedStatement) statement).executeUpdate();
            }
            
            @Override
            protected Optional getSaneResult(final SQLStatement sqlStatement, final SQLException ex) {
                return Optional.empty();
            }
        };
    }
 
 

   createExecuteUpdateCallback创建的JDBCExecutorCallback，其executeSQL方法则是通过((PreparedStatement) statement).executeUpdate()来执行，即委托给了真正的PreparedStatement 
 
 
 
小结
 
 
     
  
  • ShardingSphereConnection的prepareStatement创建的是ShardingSpherePreparedStatement，它在ShardingSpherePreparedStatement的executeUpdate的时候进行sql重写，然后prepare，最后执行的时候是通过JDBCExecutorCallback，其executeSQL方法则是通过((PreparedStatement) statement).executeUpdate()来执行，即委托给了真正的PreparedStatement
    •  
  
  • rewriteParameters是通过ParameterRewriter进行rewrite，主要是修改ParameterBuilder；而具体sql语句的修改则通过sqlTokenGenerators进行
    •  
  
  • PreparedStatementExecutionUnitBuilder的build方法这里才真正创建PreparedStatement：它通过StatementManager.createStorageResource则是通过connection.prepareStatement来创建真正的PrepareStatement，而此时传入的sql也是经过重写之后的sql
    •  
  
  • useDriverToExecuteUpdate方法会执行createExecutionGroupContext(会执行prepare方法)，cacheStatements这里主要是把eachInput.getStorageResource()真正的PrepareStatement赋值到ShardingSpherePreparedStatement的statements变量中，把eachInput.getExecutionUnit().getSqlUnit().getParameters()赋值到parameterSets，然后执行replay方法通过PreparedStatementInvocationReplayer把修改后的变量replay到真正的PrepareStatement
     
   
    
     ShardingSpherePreparedStatement实现了java.sql.PreparedStatement接口，其sql属性是用户传入的sql，即未经过重写的sql，而实际execute的时候，会触发sql重写(包括重写sql语句及参数)，最后会通过connection.prepareStatement(传入重写之后的sql)来创建真正的PrepareStatement，然后有一步replay操作，把重写后的参数作用到真正的PrepareStatement，最后通过((PreparedStatement) statement).executeUpdate()来触发执行 
    
    至此我们可以得到sql重写的一个基本思路：通过实现java.sql.PreparedStatement接口伪装一个PreparedStatement类，其创建和set参数先内存缓存起来，之后在execute的时候进行sql重写，创建真正的PreparedStatement，replay参数，执行execute方法 
   
    •  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(shardingsphere)

        

            

                
    
                    
  • SpringBoot整合ShardingSphere
                        陌殇殇
中间件springboot后端java
                        
    SpringBoot整合ShardingSphere文章目录SpringBoot整合ShardingSphere1.概述1.Sharding-JDBC2.Sharding-Proxy3.比较2.ShardingJdbc读写分离1.pom依赖2.yml配置3.测试4.props其他配置3.ShardingJdbc分库分表1.分库分表方式2.逻辑表3.分库分表数据节点-actual-data-node
    
                    
    • 
                    
  • 中间件的学习理解总结
                        DCDDDDcccc
中间件学习
                        
    目录一、定义与作用二、主要类型数据库中间件远程过程调用中间件面向消息的中间件事务处理中间件三、特点与优势独立性高效性可扩展性可靠性四、应用场景企业应用集成分布式系统电子商务移动应用开发五、数据库中间件功能细节：应用优势：六、远程过程调用中间件功能细节：应用优势：七、面向消息的中间件功能细节：应用优势：八、事务处理中间件功能细节：应用优势：数据库中间件MyCat：ShardingSphere：远程过
    
                    
    • 
                    
  • 数据库分库分表-ShardingSphere学习
                        学Java的skyyyyyyyy
数据库java
                        
    ShardingSphere是一个开源的分布式数据库中间件解决方案，旨在提供数据库分片、分布式事务、读写分离、数据治理等多种数据服务，它以模块化的方式设计，使用户可以根据不同的应用场景选择适合的模块来部署。ShardingSphere架构概述ShardingSphere的架构主要围绕四个核心组件展开，分别是Sharding-JDBC、Sharding-Proxy、Sharding-Sidecar（
    
                    
    • 
                    
  • shardingsphere-elastic-job-ui 管理界面安装
                        天道有情战天下
ui
                        
    下载地址https://shardingsphere.apache.org/elasticjob/current/cn/downloads/将mysql包放到解压文件中，用于事件追踪修改配置文件，会自动创建数据表用于事件追踪其他配置参考下载地址中文档
    
                    
    • 
                    
  • 发现ElasticJob-UI：分布式任务调度的得力助手
                        黎杉娜Torrent

                        
    发现ElasticJob-UI：分布式任务调度的得力助手shardingsphere-elasticjob-uiAdministratorconsoleofElasticJob项目地址:https://gitcode.com/gh_mirrors/sh/shardingsphere-elasticjob-ui在这个高度分布化的时代，如何高效管理定时任务成为了一个不容忽视的挑战。今天，我们为您介绍一
    
                    
    • 
                    
  • 推荐开源项目：ElasticJob-UI —— 强大的弹性任务管理神器
                        任澄翊

                        
    推荐开源项目：ElasticJob-UI——强大的弹性任务管理神器项目介绍ElasticJob-UI是ApacheShardingSphere生态系统中的一个重要组件，它为ElasticJob提供了一款功能强大的可视化管理控制台。这个平台涵盖了动态配置和作业管控等一系列关键功能，帮助开发者轻松管理和监控分布式任务。ElasticJob-UI包含了针对ElasticJob-Lite和ElasticJ
    
                    
    • 
                    
  • shardingsphere自定义hint分片算法，完美实现按区域编码数据隔离，没改一行旧代码
                        

                        
    因为已经改造了登录平台，实现了集群统一部署，然后后续就是继续弄集中统一部署服务改造（这里的集中统一部署的意思是区别于每个区域私有部署，服务本身还是可以弹性伸缩的），首先改造一个比较简单的白名单微服务，只涉及到三张表，业务逻辑也简单就是CRUD以及关联查询。因为当初这个服务是由其他人实现交给我这边部署维护一下，具体的业务逻辑和代码我也没看过，所以改造的时候就想着尽量不动代码，无侵入式的或者低侵入式的
    
                    
    • 
                    
  • 使用ShardingJDBC实现分库分表
                        不摸鱼的程序员
中间件shardingJDBC分库分表
                        
    一、测试环境JDK：1.8SpringBoot：2.7.17MySQL驱动：5.1.49MyBatis：2.3.1shardingJDBC：5.1.0二、核心依赖mysqlmysql-connector-java5.1.49org.mybatis.spring.bootmybatis-spring-boot-starter2.3.1org.apache.shardingspheresharding
    
                    
    • 
                    
  • Sharding-JDBC学习笔记
                        重生之Java再爱我一次
学习笔记
                        
    1.基本概念1.1什么是ShardingSphere？ShardingSphere是一个开源的分布式数据库中间件，提供了分布式数据库的跨节点分片和分布式事务解决方案。它由分片（Sharding）和球（Sphere）两个单词组成，分片表示数据分片，球表示这些分片组成的球形空间，象征着分布式数据库的全景视图。ShardingSphere支持多种数据库的分片和分布式事务，包括关系型数据库（如MySQL、
    
                    
    • 
                    
  • 基于 ShardingSphere 的分布式数据库负载均衡架构搭建实战
                        ShardingSphere
数据库负载均衡分布式架构服务器
                        
    本文主要分为3部分，将依次介绍：基于ShardingSphere的分布式数据库「负载均衡架构搭建」要点结合实际的「用户问题案例」，介绍引入「负载均衡」的影响介绍并展示ShardingSphere分布式数据库在云上的「一站式解决方案」要点介绍ShardingSphere负载均衡架构搭建要点ApacheShardingSphere是一款分布式的数据库生态系统，可以将任意数据库转换为分布式数据库，并通过
    
                    
    • 
                    
  • 数据库切片大对决：ShardingSphere与Mycat技术解析
                        一只牛博
数据库数据库ShardingSpheremycat
                        
    欢迎来到我的博客，代码的世界里，每一行都是一个故事数据库切片大对决：ShardingSphere与Mycat技术解析前言ShardingSphere与Mycat简介工作原理对比功能特性对比前言在数据库的舞台上，有两位颇受欢迎的明星，它们分别是ShardingSphere和Mycat。这两位巨星在数据库切片的世界里大放异彩，好像是一场引人入胜的数据库技术盛宴。在这场Sharding大战中，我们将揭开
    
                    
    • 
                    
  • ShardingSphere 5.x 系列【7】元数据持久化
                        云烟成雨TD
ShardingSphere5.xspringbootshardingsphere分库分表
                        
    有道无术，术尚可求，有术无道，止于术。本系列SpringBoot版本3.1.0本系列ShardingSphere版本5.4.0源码地址：https://gitee.com/pearl-organization/study-sharding-sphere-demo文章目录概述2.单机模式2.1H22.2MySQL3.集群模式3.1ZooKeeper3.2Nacos3.3Consul
    
                    
    • 
                    
  • ElasticJob分布式调度，分布式多个微服务执行只需要执行一个定时任务，基本概念介绍（一）
                        时间是一种毒药

                        
    问题背景最近的项目中需要做一个定时任务，该项目是一个分布式多节点调度任务，所以里面的定时任务在不同的节点不应该同时进行，应该使用其中一个节点做定时任务，目前寻找的方案为ElasticJob，这个篇章简单介绍一下ElasticJob简介1Elastic-job官网地址：https://shardingsphere.apache.org/elasticjob/current/cn/overview/ 
    
                    
    • 
                    
  • ShardingSphere-Proxy5搭建使用
                        Echo_bf84

                        
    ShardingSphere-Proxy5搭建使用ApacheShardingSphere下的一个产品，定位为透明化的数据库代理端，与mycat类似，所有的分片都由其完成。ShardingSphere-Proxy5下载安装官网提供三种安装方式，这里主要记录两种二进制包安装官网下载二进制包apache-shardingsphere-5.2.0-shardingsphere-proxy-bin.tar
    
                    
    • 
                    
  • ElasticJob 3.0 带你快速入门
                        @lihewei
javaelastic-job
                        
    ElasticJobElasticJob简介当当网开源的分布式定时任务框架，后被apache基金会支持；官方文档：https://shardingsphere.apache.org/elasticjob/current/cn/overview/问：ElasticJob是什么？答：定时任务框架；优势：支持分布式部署；不同节点上执行的是不一样的任务(代码是同一套)；对于一个大任务，可以用分片策略，让他
    
                    
    • 
                    
  • openGauss X ShardingSphere，分布式方案的另一种最佳实践
                        胡正策
openGauss技术分享openGauss社区新知分布式数据库database
                        
    openGauss数据库自2020年6月开源以来，受到了业界的广泛关注，现已吸引众多伙伴、开发者参与其中，共建繁荣的数据库生态。面对如今海量数据，超高并发等诸多场景，openGauss将目光转向于分布式解决方案，专注于解决海量数据存储、超高并发吞吐、大表瓶颈等众多难题，与ShardingSphere一起构建全栈开源分布式解决方案，实现openGauss的又一大突破。分布式解决方案图1分布式解决方案
    
                    
    • 
                    
  • 启动shardingsphere-proxy报错
                        福娃筱欢
shardingsphere
                        
    --问题描述启动shardingsphere-proxy报错[INFO]2024-02-0515:47:44.920[main]o.o.core.v3.ConnectionFactoryImpl-Connectcomplete.ID:2e065e33-dbcb-4499-ac2d-dea6692b8202Exceptioninthread"main"java.lang.IllegalStateEx
    
                    
    • 
                    
  • ShardingSphere实现openGauss分布式架构
                        福娃筱欢
分布式架构
                        
    本文档采用openGauss结合ShardingSphere中间件的架构，实现openGauss数据库分布式OLAP场景的环境部署。术语说明：开源数据库引擎：openGaussshardingsphereProxy：定位为透明化的数据库代理端，提供封装了数据库二进制协议的服务端版本，用于完成对异构语言的支持。目前提供MySQL和PostgreSQL（兼容openGauss等基于PostgreSQL
    
                    
    • 
                    
  • ShardingSphere 5.x 系列【5】Spring Boot 3 集成并实现读写分离
                        云烟成雨TD
ShardingSphere5.xspringbootshardingsphere分库分表
                        
    有道无术，术尚可求，有术无道，止于术。本系列SpringBoot版本3.1.0本系列ShardingSphere版本5.4.0源码地址：https://gitee.com/pearl-organization/study-sharding-sphere-demo文章目录1.概述2.使用限制3.案例演示3.1一主双从3.2项目搭建3.3配置3.4测试4.负载均衡算法4.1轮询4.2随机4.3权重4.
    
                    
    • 
                    
  • ShardingSphere 5.x 系列【3】分库分表中间件技术选型
                        云烟成雨TD
ShardingSphere5.xspringbootshardingsphere分库分表
                        
    有道无术，术尚可求，有术无道，止于术。本系列SpringBoot版本3.1.0本系列ShardingSphere版本5.4.0源码地址：https://gitee.com/pearl-organization/study-sharding-sphere-demo文章目录1.前言2.MyCat3.ShardingSphere4.Dble5.Vitess6.大厂开源6.1Cobar6.2Atlas6.
    
                    
    • 
                    
  • Mybatis | update 时报错 Can not update sharding key
                        土Bo鼠
工作实践记录数据库mybatis
                        
    分片的列必须在where条件里，并且同更新的值相同；或者将该列设置为null。因为分表键不能修改，如果改了的话，数据所在库表的位置会变，这是不符合预期的。参考：【已解决】ShardingSphere使用记录，ShardingException:Cannotupdateshardingkey,logictable:[user_log]解决-腾讯云开发者社区-腾讯云
    
                    
    • 
                    
  • 好好的系统，为什么要分库分表？
                        书火网_firebook

                        
    大家好，我是小富～说在前边今天是《分库分表ShardingSphere原理与实战》系列的开篇文章，之前写过几篇关于分库分表的文章反响都还不错，到现在公众号:程序员小富后台不断的有人留言、咨询分库分表的问题，我也没想到大家对于分库分表的话题会这么感兴趣，可能很多人的工作内容业务量较小很难接触到这方面的技能。这个系列在我脑子里筹划了挺久的，奈何手说啥也不干活，就一直拖到了现在。image其实网上关于分
    
                    
    • 
                    
  • Apache ShardingSphere（Incubating）周报 2019.3.25-2019.3.29
                        ShardingSphere

                        
    本周工作ShardingSphere功能开发新模块开发‍‍‍‍1.调研jetcd的使用，在shardingsphere-spi-impl项目中创建sharding-orchestration-reg-jetcd模块进行开发2.shardingsphere-spi-impl项目中增加shardingsphere-distribution模块进行spi的发布3.加密业务性能测试‍功能优化&重构1.优化
    
                    
    • 
                    
  • 关于分库分表
                        薛薛哦
java
                        
    儒猿购买过一个视频课程：基于ShardingSphere的分库分表实战课（9.9专享）(xiaoe-tech.com)如何演进到分库分表的？数据量大了首先考虑优化索引→缓存→读写分离(写主库，主从复制，查询从库)→垂直分库→→→→
    
                    
    • 
                    
  • sharding-jdbc5系列教程（一）springboot配置shardingjdbc+mybatis-plus+druid+dynamic-datasource
                        爱音乐的程序猿
springbootmysqljavaspringbootjavashardingjdbc分库分表mysql
                        
    系列文章目录文章目录系列文章目录前言一、shardingjdbcApacheShardingSphere是一套开源的分布式数据库解决方案组成的生态圈，它由JDBC、Proxy和Sidecar（规划中）这3款既能够独立部署，又支持混合部署配合使用的产品组成。它们均提供标准化的数据水平扩展、分布式事务和分布式治理等功能，可适用于如Java同构、异构语言、云原生等各种多样化的应用场景。ApacheSha
    
                    
    • 
                    
  • ShardingSphere之ShardingJDBC客户端分库分表下
                        山鸟与鱼！
分布式中间件数据库后端javaspringboot
                        
    目录ShardingJDBC实战STANDARD标准分片策略COMPLEX_INLINE复杂分片策略CLASS_BASED自定义分片策略HINT_INLINE强制分片策略ShardingJDBC实战上篇已经将需要用到的类、数据库表都准备好了，本篇主要介绍分片配置文件。STANDARD标准分片策略如果按照上篇文章所讲，使用INLINE分片算法是不能支持Between查找的，如果使用会报错。@Test
    
                    
    • 
                    
  • ShardingSphere之ShardingJDBC客户端分库分表上
                        山鸟与鱼！
分布式中间件数据库java后端springboot
                        
    目录什么是ShardingSphere？客户端分库分表与服务端分库分表ShardingJDBC客户端分库分表ShardingProxy服务端分库分表ShardingSphere实现分库分表的核心概念ShardingJDBC实战什么是ShardingSphere？ShardingSphere是一款起源于当当网内部的应用框架。2015年在当当网内部诞生，最初就叫ShardingJDBC。Shardin
    
                    
    • 
                    
  • SpringBoot+JPA+ShardingSphere4.x单库按月份分表
                        fengpojian
SpringBootSpringBootJPAShardingsphere数据库分表月份
                        
    1.走过的弯路在研究分表的时候,我他喵的是真的体会到了"浩如烟海"是啥意思.要么就是资料太老,要么就很少是按照月份分表的.中间我走了很多弯路,甚至一度怀疑jap不适合用来进行分表.从我看过的资料来说,没有一个博客介绍使用Shardingsphere进行分表是思路是什么样的,这也是我走了很多弯路的原因.先介绍背景:单个数据库,按照月份进行分表,每个表有月份的后缀,类似于:table_202006.我
    
                    
    • 
                    
  • Apache ShardingSphere分表的简单使用和常见问题
                        瑶山
java技术数据库javaShardingSphereShardingJDBCspringboot
                        
    目录简介什么是ApacheShardingSphere?分库分表的背景使用pom配置1，application.properties配置文件2，创建配置类分表验证分表常见问题自定义分表规则未生效使用sum函数无法获取值合并或共用数据源问题简介官网：ApacheShardingSphere版本：4.x什么是ApacheShardingSphere?ApacheShardingSphere是一款分布式
    
                    
    • 
                    
  • 分表过多引起的问题/Apache ShardingSphere元数据加载慢
                        瑶山
java数据库ShardingSphere元数据分表
                        
    目录环境背景探寻元数据的加载策略如何解决升级版本到5.x调大max.connections.size.per.querymax.connections.size.per.query分析服务启动阶段相关源码服务运行阶段相关源码受到的影响注意事项（重要）其他环境SpringBoot2.2.13ShardingJDBC4.1.1背景因项目特殊性问题，系统需要处理大量数据，有多个数据源，且因数据过多每个数
    
                    
    • 
                                
  • html
                                    周华华
html
                                    
    js 
 1，数组的排列 
var arr=[1,4,234,43,52,]; 
 for(var x=0;x<arr.length;x++){ 
   for(var y=x-1;y<arr.length;y++){ 
     if(arr[x]<arr[y]){ 
    &
    
                                
    • 
                                
  • 【Struts2 四】Struts2拦截器
                                    bit1129
struts2拦截器
                                    
    Struts2框架是基于拦截器实现的，可以对某个Action进行拦截，然后某些逻辑处理，拦截器相当于AOP里面的环绕通知，即在Action方法的执行之前和之后根据需要添加相应的逻辑。事实上，即使struts.xml没有任何关于拦截器的配置，Struts2也会为我们添加一组默认的拦截器，最常见的是，请求参数自动绑定到Action对应的字段上。 
  
Struts2中自定义拦截器的步骤是：
    
                                
    • 
                                
  • make:cc 命令未找到解决方法
                                    daizj
linux命令未知make cc
                                    
    安装rz sz程序时，报下面错误： 
  
[root@slave2 src]# make posix 
cc   -O -DPOSIX -DMD=2 rz.c -o rz 
make: cc：命令未找到 
make: *** [posix] 错误 127 
  
系统：centos 6.6 
环境：虚拟机 
  
错误原因：系统未安装gcc，这个是由于在安
    
                                
    • 
                                
  • Oracle之Job应用
                                    周凡杨
oracle job
                                    
      
最近写服务，服务上线后，需要写一个定时执行的SQL脚本，清理并更新数据库表里的数据，应用到了Oracle 的 Job的相关知识。在此总结一下。 
  
一：查看相关job信息 
   1、相关视图  
 dba_jobs  
 all_jobs  
 user_jobs  
 dba_jobs_running 包含正在运行
    
                                
    • 
                                
  • 多线程机制
                                    朱辉辉33
多线程
                                    
    转至http://blog.csdn.net/lj70024/archive/2010/04/06/5455790.aspx 
程序、进程和线程： 
 程序是一段静态的代码，它是应用程序执行的蓝本。进程是程序的一次动态执行过程，它对应了从代码加载、执行至执行完毕的一个完整过程，这个过程也是进程本身从产生、发展至消亡的过程。线程是比进程更小的单位，一个进程执行过程中可以产生多个线程，每个线程有自身的
    
                                
    • 
                                
  • web报表工具FineReport使用中遇到的常见报错及解决办法（一）
                                    老A不折腾
web报表finereportjava报表报表工具
                                    
    FineReport使用中遇到的常见报错及解决办法（一） 
这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。 
  
出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 
  
1、address pool is full： 
含义：地址池满，连接数超过并发数上
    
                                
    • 
                                
  • mysql rpm安装后没有my.cnf
                                    林鹤霄
没有my.cnf
                                    
    Linux下用rpm包安装的MySQL是不会安装/etc/my.cnf文件的， 
至于为什么没有这个文件而MySQL却也能正常启动和作用，在这儿有两个说法， 
第一种说法，my.cnf只是MySQL启动时的一个参数文件，可以没有它，这时MySQL会用内置的默认参数启动， 
第二种说法，MySQL在启动时自动使用/usr/share/mysql目录下的my-medium.cnf文件，这种说法仅限于r
    
                                
    • 
                                
  • Kindle Fire HDX root并安装谷歌服务框架之后仍无法登陆谷歌账号的问题
                                    aigo
root
                                    
    原文：http://kindlefireforkid.com/how-to-setup-a-google-account-on-amazon-fire-tablet/ 
  
Step 4: Run ADB command from your PC 
  
On the PC, you need install Amazon Fire ADB driver and instal
    
                                
    • 
                                
  • javascript 中var提升的典型实例
                                    alxw4616
JavaScript
                                    
    // 刚刚在书上看到的一个小问题,很有意思.大家一起思考下吧
myname = 'global';
var fn = function () {
	console.log(myname); // undefined
	var myname = 'local';
	console.log(myname); // local
};
fn()

// 上述代码实际上等同于以下代码
m
    
                                
    • 
                                
  • 定时器和获取时间的使用
                                    百合不是茶
时间的转换定时器
                                    
    定时器:定时创建任务在游戏设计的时候用的比较多 
  Timer();定时器 
TImerTask();Timer的子类  由 Timer 安排为一次执行或重复执行的任务。 
  
  
  定时器类Timer在java.util包中。使用时，先实例化，然后使用实例的schedule(TimerTask task, long delay)方法，设定
    
                                
    • 
                                
  • JDK1.5 Queue
                                    bijian1013
javathreadjava多线程Queue
                                    
    JDK1.5 Queue 
LinkedList： 
LinkedList不是同步的。如果多个线程同时访问列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方
    
                                
    • 
                                
  • http认证原理和https
                                    bijian1013
httphttps
                                    
    一.基础介绍 
        在URL前加https://前缀表明是用SSL加密的。 你的电脑与服务器之间收发的信息传输将更加安全。 
        Web服务器启用SSL需要获得一个服务器证书并将该证书与要使用SSL的服务器绑定。 
http和https使用的是完全不同的连接方式，用的端口也不一样,前者是80，后
    
                                
    • 
                                
  • 【Java范型五】范型继承
                                    bit1129
java
                                    
    定义如下一个抽象的范型类，其中定义了两个范型参数，T1，T2 
  
package com.tom.lang.generics;

public abstract class SuperGenerics<T1, T2> {
    private T1 t1;
    private T2 t2;

    public abstract void doIt(T
    
                                
    • 
                                
  • 【Nginx六】nginx.conf常用指令(Directive)
                                    bit1129
Directive
                                    
    1. worker_processes    8; 
表示Nginx将启动8个工作者进程，通过ps -ef|grep nginx,会发现有8个Nginx Worker Process在运行 
  
nobody    53879 118449  0 Apr22 ?        00:26:15 nginx: worker process          
    
                                
    • 
                                
  • lua 遍历Header头部
                                    ronin47
lua header 遍历　
                                    
     
 local headers = ngx.req.get_headers()   
 ngx.say("headers begin", "<br/>")   
 ngx.say("Host : ", he
    
                                
    • 
                                
  • java-32.通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小(两数组的差最小)。
                                    bylijinnan
java
                                    
    
import java.util.Arrays;

public class MinSumASumB {

	/**
	 * Q32.有两个序列a,b，大小都为n,序列元素的值任意整数，无序.
	 * 
	 * 要求：通过交换a,b中的元素，使[序列a元素的和]与[序列b元素的和]之间的差最小。 
	 * 例如: 
	 * int[] a = {100,99,98,1,2,3
    
                                
    • 
                                
  • redis
                                    开窍的石头
redis
                                    
    在redis的redis.conf配置文件中找到# requirepass foobared 
把它替换成requirepass 12356789 后边的12356789就是你的密码 
 
打开redis客户端输入config get requirepass 
返回 
redis 127.0.0.1:6379> config get requirepass 
1) "require
    
                                
    • 
                                
  • [JAVA图像与图形]现有的GPU架构支持JAVA语言吗？
                                    comsci
java语言
                                    
     
 
      无论是opengl还是cuda，都是建立在C语言体系架构基础上的，在未来，图像图形处理业务快速发展，相关领域市场不断扩大的情况下，我们JAVA语言系统怎么从这么庞大，且还在不断扩大的市场上分到一块蛋糕，是值得每个JAVAER认真思考和行动的事情 
 
 
       
    
                                
    • 
                                
  • 安装ubuntu14.04登录后花屏了怎么办
                                    cuiyadll
ubuntu
                                    
    这个情况，一般属于显卡驱动问题。 
可以先尝试安装显卡的官方闭源驱动。 
按键盘三个键：CTRL + ALT  +  F1 
进入终端，输入用户名和密码登录终端： 
安装amd的显卡驱动       
sudo  
apt-get  
install  
fglrx       
安装nvidia显卡驱动       
sudo  
ap
    
                                
    • 
                                
  • SSL 与 数字证书 的基本概念和工作原理
                                    darrenzhu
加密ssl证书密钥签名
                                    
    SSL 与 数字证书 的基本概念和工作原理 

http://www.linuxde.net/2012/03/8301.html 
 
SSL握手协议的目的是或最终结果是让客户端和服务器拥有一个共同的密钥，握手协议本身是基于非对称加密机制的，之后就使用共同的密钥基于对称加密机制进行信息交换。 
 
 
 

http://www.ibm.com/developerworks/cn/webspher
    
                                
    • 
                                
  • Ubuntu设置ip的步骤
                                    dcj3sjt126com
ubuntu
                                    
    在单位的一台机器完全装了Ubuntu Server，但回家只能在XP上VM一个，装的时候网卡是DHCP的，用ifconfig查了一下ip是192.168.92.128,可以ping通。 
转载不是错： 
Ubuntu命令行修改网络配置方法 
/etc/network/interfaces打开后里面可设置DHCP或手动设置静态ip。前面auto eth0，让网卡开机自动挂载. 
1. 以D
    
                                
    • 
                                
  • php包管理工具推荐
                                    dcj3sjt126com
PHPComposer
                                    
    http://www.phpcomposer.com/ 
       Composer是 PHP 用来管理依赖（dependency）关系的工具。你可以在自己的项目中声明所依赖的外部工具库（libraries），Composer 会帮你安装这些依赖的库文件。  
中文文档  
入门指南  
下载  
安装包列表   
Composer 中国镜像      
    
                                
    • 
                                
  • Gson使用四（TypeAdapter）
                                    eksliang
jsongsonGson自定义转换器gsonTypeAdapter
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2175595 一.概述 
       Gson的TypeAapter可以理解成自定义序列化和返序列化 二、应用场景举例 
       例如我们通常去注册时（那些外国网站），会让我们输入firstName，lastName,但是转到我们都
    
                                
    • 
                                
  • JQM控件之Navbar和Tabs
                                    gundumw100
htmlxmlcss
                                    
    在JQM中使用导航栏Navbar是简单的。 
 
只需要将data-role="navbar"赋给div即可： 
 

<div data-role="navbar">
    <ul>
        <li><a href="#" class="ui-btn-active&qu
    
                                
    • 
                                
  • 利用归并排序算法对大文件进行排序
                                    iwindyforest
java归并排序大文件分治法Merge sort
                                    
      
归并排序算法介绍，请参照Wikipeida 
zh.wikipedia.org/wiki/%E5%BD%92%E5%B9%B6%E6%8E%92%E5%BA%8F 
基本思想： 
大文件分割成行数相等的两个子文件，递归（归并排序）两个子文件，直到递归到分割成的子文件低于限制行数 
低于限制行数的子文件直接排序 
两个排序好的子文件归并到父文件 
直到最后所有排序好的父文件归并到输入
    
                                
    • 
                                
  • iOS UIWebView URL拦截
                                    啸笑天
UIWebView
                                    
    本文译者：candeladiao，原文：URL filtering for UIWebView on the iPhone说明：译者在做app开发时，因为页面的javascript文件比较大导致加载速度很慢，所以想把javascript文件打包在app里，当UIWebView需要加载该脚本时就从app本地读取，但UIWebView并不支持加载本地资源。最后从下文中找到了解决方法，第一次翻译，难免有
    
                                
    • 
                                
  • 索引的碎片整理SQL语句
                                    macroli
sql
                                    
    SET NOCOUNT ON
DECLARE @tablename VARCHAR (128)
DECLARE @execstr VARCHAR (255)
DECLARE @objectid INT
DECLARE @indexid INT
DECLARE @frag DECIMAL
DECLARE @maxfrag DECIMAL
--设置最大允许的碎片数量,超过则对索引进行碎片
    
                                
    • 
                                
  • Angularjs同步操作http请求with $promise
                                    qiaolevip
每天进步一点点学习永无止境AngularJS纵观千象
                                    
    // Define a factory
app.factory('profilePromise', ['$q', 'AccountService', function($q, AccountService) {
      var deferred = $q.defer();
      AccountService.getProfile().then(function(res) {
  
    
                                
    • 
                                
  • hibernate联合查询问题
                                    sxj19881213
sqlHibernateHQL联合查询
                                    
    最近在用hibernate做项目，遇到了联合查询的问题，以及联合查询中的N+1问题。 
针对无外键关联的联合查询，我做了HQL和SQL的实验，希望能帮助到大家。（我使用的版本是hibernate3.3.2） 
  
1 几个常识： 
 （1）hql中的几种join查询，只有在外键关联、并且作了相应配置时才能使用。 
 （2）hql的默认查询策略，在进行联合查询时，会产
    
                                
    • 
                                
  • struts2.xml
                                    wuai
struts
                                    
    <?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE struts PUBLIC 
 "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN" 
 "http://struts.apache
    
                                
    •