蚊子squirrel
蚊子squirrel

从源码看ShardingSphere设计-归并引擎篇

归并引擎的职责定位是进行结果集的合并，支持应用以标准的JDBC接口访问正确的结果集ResultSet。因为在数据分片模式下，SQL可能会需要在多个数据节点上执行，各数据节点的结果集之间是独立不关联的，在排序、分组、聚合等操作时，就需要对结果集进行归并处理，以屏蔽后端多个数据库给应用操作带来的差异性。

代码执行分析

合并引擎对应的类为MergeEngine，但其内部真正进行处理类为MergeEntry，其实例merger在构造函数中完成创建。

org.apache.shardingsphere.underlying.pluggble.merge.MergeEngine

   
   private final Collection rules;
   
   private final MergeEntry merger;
   
   public MergeEngine(final Collection rules, final ConfigurationProperties properties, final DatabaseType databaseType, final SchemaMetaData metaData) {
       this.rules = rules;
       merger = new MergeEntry(databaseType, metaData, properties);
   }
   
   /**
    * Merge.
    *
    * @param queryResults query results
    * @param sqlStatementContext SQL statement context
    * @return merged result
    * @throws SQLException SQL exception
    */
   public MergedResult merge(final List queryResults, final SQLStatementContext sqlStatementContext) throws SQLException {
       registerMergeDecorator();
       return merger.process(queryResults, sqlStatementContext);
   }
   
   private void registerMergeDecorator() {
       for (Class each : OrderedRegistry.getRegisteredClasses(ResultProcessEngine.class)) {
           ResultProcessEngine processEngine = createProcessEngine(each);
           Class ruleClass = (Class) processEngine.getType();
           // FIXME rule.getClass().getSuperclass() == ruleClass for orchestration, should decouple extend between orchestration rule and sharding rule
           rules.stream().filter(rule -> rule.getClass() == ruleClass || rule.getClass().getSuperclass() == ruleClass).collect(Collectors.toList())
                   .forEach(rule -> merger.registerProcessEngine(rule, processEngine));
       }
   }
   
   private ResultProcessEngine createProcessEngine(final Class processEngine) {
       try {
           return processEngine.newInstance();
       } catch (final InstantiationException | IllegalAccessException ex) {
           throw new ShardingSphereException(String.format("Can not find public default constructor for result process engine `%s`", processEngine), ex);
       }
   }
}

merge方法首先进行了对merge装饰器进行了注册，具体根据传入的BaseRule类型，将需要的ResultProcessEngine进行实例化，并添加到MergeEntry实例的engines属性中。真正的处理逻辑在MergeEngine实例的process方法中。

在4.1.1版本中，结果集合并引擎ResultMergerEngine接口实现类只有ShardingResultMergerEngine类，结果装饰器ResultDecoratorEngine接口实现类只有EncryptResultDecoratorEngine。

接下来看下MergeEntry 类的process方法

org.apache.shardingsphere.underlying.merge.MergeEntry

@RequiredArgsConstructor
public final class MergeEntry {
    
    private final DatabaseType databaseType;
    
    private final SchemaMetaData schemaMetaData;
    
    private final ConfigurationProperties properties;
    
    private final Map engines = new LinkedHashMap<>();
    
    … 
    /**
     * Process query results.
     *
     * @param queryResults query results
     * @param sqlStatementContext SQL statement context
     * @return merged result
     * @throws SQLException SQL exception
     */
    public MergedResult process(final List queryResults, final SQLStatementContext sqlStatementContext) throws SQLException {
        Optional mergedResult = merge(queryResults, sqlStatementContext);
        Optional result = mergedResult.isPresent() ? Optional.of(decorate(mergedResult.get(), sqlStatementContext)) : decorate(queryResults.get(0), sqlStatementContext);
        return result.orElseGet(() -> new TransparentMergedResult(queryResults.get(0)));
}
private Optional merge(final List queryResults, final SQLStatementContext sqlStatementContext) throws SQLException {
        for (Entry entry : engines.entrySet()) {
            if (entry.getValue() instanceof ResultMergerEngine) {
                ResultMerger resultMerger = ((ResultMergerEngine) entry.getValue()).newInstance(databaseType, entry.getKey(), properties, sqlStatementContext);
                return Optional.of(resultMerger.merge(queryResults, sqlStatementContext, schemaMetaData));
            }
        }
        return Optional.empty();
    }
    
    @SuppressWarnings("unchecked")
    private MergedResult decorate(final MergedResult mergedResult, final SQLStatementContext sqlStatementContext) throws SQLException {
        MergedResult result = null;
        for (Entry entry : engines.entrySet()) {
            if (entry.getValue() instanceof ResultDecoratorEngine) {
                ResultDecorator resultDecorator = ((ResultDecoratorEngine) entry.getValue()).newInstance(databaseType, schemaMetaData, entry.getKey(), properties, sqlStatementContext);
                result = null == result ? resultDecorator.decorate(mergedResult, sqlStatementContext, schemaMetaData) : resultDecorator.decorate(result, sqlStatementContext, schemaMetaData);
            }
        }
        return null == result ? mergedResult : result;
    }
    
    @SuppressWarnings("unchecked")
    private Optional decorate(final QueryResult queryResult, final SQLStatementContext sqlStatementContext) throws SQLException {
        MergedResult result = null;
        for (Entry entry : engines.entrySet()) {
            if (entry.getValue() instanceof ResultDecoratorEngine) {
                ResultDecorator resultDecorator = ((ResultDecoratorEngine) entry.getValue()).newInstance(databaseType, schemaMetaData, entry.getKey(), properties, sqlStatementContext);
                result = null == result ? resultDecorator.decorate(queryResult, sqlStatementContext, schemaMetaData) : resultDecorator.decorate(result, sqlStatementContext, schemaMetaData);
            }
        }
        return Optional.ofNullable(result);
    }

process方法主要逻辑主要有两部分：
一、 遍历拿到注册的ResultMergerEngine实例（只能有一个），调用其newInstance方法返回对应的ResultMerger对象，然后执行ResultMerger实例的merge方法生成合并结果集MergedResult实例。

转入ShardingResultMergerEngine的newInstance方法可以看到，根据SQLStatementContext类型的种类创建不同的ResultMerger实例。如果是SQL是Select，则创建ShardingDQLResultMerger对象；如果是DAL语句(show database、show table 等)，则创建ShardingDALResultMerger对象。

org.apache.shardingsphere.sharding.merge.ShardingResultMergerEngine

/**
 * Result merger engine for sharding.
 */
public final class ShardingResultMergerEngine implements ResultMergerEngine {
    
    @Override
    public ResultMerger newInstance(final DatabaseType databaseType, final ShardingRule shardingRule, final ConfigurationProperties properties, final SQLStatementContext sqlStatementContext) {
        if (sqlStatementContext instanceof SelectStatementContext) {
            return new ShardingDQLResultMerger(databaseType);
        } 
        if (sqlStatementContext.getSqlStatement() instanceof DALStatement) {
            return new ShardingDALResultMerger(shardingRule);
        }
        return new TransparentResultMerger();
    }
…
}

接下来我们看下最常见的Select类的结果合并器
org.apache.shardingsphere.sharding.merge.dql.ShardingDQLResultMerger

public final class ShardingDQLResultMerger implements ResultMerger {
    
    private final DatabaseType databaseType;
    
    @Override
    public MergedResult merge(final List queryResults, final SQLStatementContext sqlStatementContext, final SchemaMetaData schemaMetaData) throws SQLException {
        if (1 == queryResults.size()) {
            return new IteratorStreamMergedResult(queryResults);
        }
        Map columnLabelIndexMap = getColumnLabelIndexMap(queryResults.get(0));
        SelectStatementContext selectStatementContext = (SelectStatementContext) sqlStatementContext;
        selectStatementContext.setIndexes(columnLabelIndexMap);
        MergedResult mergedResult = build(queryResults, selectStatementContext, columnLabelIndexMap, schemaMetaData);//生成合并结果集
        return decorate(queryResults, selectStatementContext, mergedResult);//对合并结果集进行装饰处理
    }
    …    
    private MergedResult build(final List queryResults, final SelectStatementContext selectStatementContext,
                               final Map columnLabelIndexMap, final SchemaMetaData schemaMetaData) throws SQLException {
        if (isNeedProcessGroupBy(selectStatementContext)) {
            return getGroupByMergedResult(queryResults, selectStatementContext, columnLabelIndexMap, schemaMetaData);
        }
        if (isNeedProcessDistinctRow(selectStatementContext)) {
            setGroupByForDistinctRow(selectStatementContext);
            return getGroupByMergedResult(queryResults, selectStatementContext, columnLabelIndexMap, schemaMetaData);
        }
        if (isNeedProcessOrderBy(selectStatementContext)) {
            return new OrderByStreamMergedResult(queryResults, selectStatementContext, schemaMetaData);
        }
        return new IteratorStreamMergedResult(queryResults);
}
…private MergedResult getGroupByMergedResult(final List queryResults, final SelectStatementContext selectStatementContext,
                                                final Map columnLabelIndexMap, final SchemaMetaData schemaMetaData) throws SQLException {
        return selectStatementContext.isSameGroupByAndOrderByItems()
                ? new GroupByStreamMergedResult(columnLabelIndexMap, queryResults, selectStatementContext, schemaMetaData)
                : new GroupByMemoryMergedResult(queryResults, selectStatementContext, schemaMetaData);
    }
    
    private boolean isNeedProcessOrderBy(final SelectStatementContext selectStatementContext) {
        return !selectStatementContext.getOrderByContext().getItems().isEmpty();
    }
    
    private MergedResult decorate(final List queryResults, final SelectStatementContext selectStatementContext, final MergedResult mergedResult) throws SQLException {
        PaginationContext paginationContext = selectStatementContext.getPaginationContext();
        if (!paginationContext.isHasPagination() || 1 == queryResults.size()) {
            return mergedResult;
        }
        String trunkDatabaseName = DatabaseTypes.getTrunkDatabaseType(databaseType.getName()).getName();
        if ("MySQL".equals(trunkDatabaseName) || "PostgreSQL".equals(trunkDatabaseName)) {
            return new LimitDecoratorMergedResult(mergedResult, paginationContext);
        }
        if ("Oracle".equals(trunkDatabaseName)) {
            return new RowNumberDecoratorMergedResult(mergedResult, paginationContext);
        }
        if ("SQLServer".equals(trunkDatabaseName)) {
            return new TopAndRowNumberDecoratorMergedResult(mergedResult, paginationContext);
        }
        return mergedResult;
    }

}

可以看到ShardingDQLResultMerger的merge方法：

  1. 首先生成columnLabel位置下标的Map，然后传入SelectStatementContext.setIndexes方法，进行聚合projecttion、group by、order by设置其对应的columnLabel所在位置下标，这些下标会在GroupByStreamMergedResult的等类中访问。
  2. build方法中判断是否需要处理group by、distinct以及order by，然后返回对应的
    MergedResult实现类。这些实现类是合并结果集的真正逻辑所在。getGroupByMergedResult方法中判断group by与order by的列是否一样，如果是则创建GroupByStreamMergedResult实例，否则创建GroupByMemoryMergedResult实例，前者为基于流方式，后者为基于内存方式。

看下GroupByStreamMergedResult类的实现

org.apache.shardingsphere.sharding.merge.dql.groupby.GroupByStreamMergedResult

/**
 * Stream merged result for group by.
 */
public final class GroupByStreamMergedResult extends OrderByStreamMergedResult {
    
    private final SelectStatementContext selectStatementContext;
    
    private final List currentRow;
    
    private List currentGroupByValues;
    
    public GroupByStreamMergedResult(final Map labelAndIndexMap, final List queryResults,
                                     final SelectStatementContext selectStatementContext, final SchemaMetaData schemaMetaData) throws SQLException {
        super(queryResults, selectStatementContext, schemaMetaData);
        this.selectStatementContext = selectStatementContext;
        currentRow = new ArrayList<>(labelAndIndexMap.size());
        currentGroupByValues = getOrderByValuesQueue().isEmpty()
                ? Collections.emptyList() : new GroupByValue(getCurrentQueryResult(), selectStatementContext.getGroupByContext().getItems()).getGroupValues();
    }
    
    @Override
    public boolean next() throws SQLException {
        currentRow.clear();
        if (getOrderByValuesQueue().isEmpty()) {
            return false;
        }
        if (isFirstNext()) {
            super.next();
        }
        if (aggregateCurrentGroupByRowAndNext()) {
            currentGroupByValues = new GroupByValue(getCurrentQueryResult(), selectStatementContext.getGroupByContext().getItems()).getGroupValues();
        }
        return true;
    }
    
    private boolean aggregateCurrentGroupByRowAndNext() throws SQLException {
        boolean result = false;
//生成各AggregationProjection对应的聚合单元AggregationUnit，在进行聚合计算时会根据该map进行运算。
        Map aggregationUnitMap = Maps.toMap(
                selectStatementContext.getProjectionsContext().getAggregationProjections(), input -> AggregationUnitFactory.create(input.getType(), input instanceof AggregationDistinctProjection));
//如果从优先队列中取到的group by值与当前group by值一样，则进行聚合运算
        while (currentGroupByValues.equals(new GroupByValue(getCurrentQueryResult(), selectStatementContext.getGroupByContext().getItems()).getGroupValues())) {
            aggregate(aggregationUnitMap);
            cacheCurrentRow();
            result = super.next();
            if (!result) {
                break;
            }
        }
//将聚合计算后的结果设置到currentRow中，这样外围在调用getValue()时，就可以拿到聚合运算后的准确结果(在sharding-jdbc中，应用调用ShardingResultSet的getXXX方法，其内部再调用MergeResult的getValue方法)
        setAggregationValueToCurrentRow(aggregationUnitMap);
        return result;
    }
    //聚合计算
    private void aggregate(final Map aggregationUnitMap) throws SQLException {
        for (Entry entry : aggregationUnitMap.entrySet()) {
            List> values = new ArrayList<>(2);
            if (entry.getKey().getDerivedAggregationProjections().isEmpty()) {
                values.add(getAggregationValue(entry.getKey()));
            } else {///当为avg聚合操作时会有DerivedAggregationProjections，主要是rewrite时添加的sum和count
                for (AggregationProjection each : entry.getKey().getDerivedAggregationProjections()) {
                    values.add(getAggregationValue(each));
                }
            }
            entry.getValue().merge(values);
        }
    }
    
    private void cacheCurrentRow() throws SQLException {
        for (int i = 0; i < getCurrentQueryResult().getColumnCount(); i++) {
            currentRow.add(getCurrentQueryResult().getValue(i + 1, Object.class));
        }
    }
    
...
    private void setAggregationValueToCurrentRow(final Map aggregationUnitMap) {
        for (Entry entry : aggregationUnitMap.entrySet()) {
            currentRow.set(entry.getKey().getIndex() - 1, entry.getValue().getResult());
        }
    }
    
    @Override
    public Object getValue(final int columnIndex, final Class type) {
        Object result = currentRow.get(columnIndex - 1);
        setWasNull(null == result);
        return result;
    }
    …
    }
 
 
GroupByStreamMergedResult继承自OrderByStreamMergedResult类，该类实现的即为基于流模式的排序合并结果集。
 
 
org.apache.shardingsphere.sharding.merge.dql.orderby.OrderByStreamMergedResult
 
 
/**
 * Stream merged result for order by.
 */
public class OrderByStreamMergedResult extends StreamMergedResult {
    
    private final Collection orderByItems;
    
    @Getter(AccessLevel.PROTECTED)
    private final Queue orderByValuesQueue;
    
    @Getter(AccessLevel.PROTECTED)
    private boolean isFirstNext;
    
    public OrderByStreamMergedResult(final List queryResults, final SelectStatementContext selectStatementContext, final SchemaMetaData schemaMetaData) throws SQLException {
        this.orderByItems = selectStatementContext.getOrderByContext().getItems();
        this.orderByValuesQueue = new PriorityQueue<>(queryResults.size());
        orderResultSetsToQueue(queryResults, selectStatementContext, schemaMetaData);
        isFirstNext = true;
    }
    //将每个数据节点的查询结果各取一个放入优先队列中，设置当前查询结果为队列头元素，由于优先队列能保证其中元素的顺序性，因此 每次取出的队头元素即为排序最小的。
    private void orderResultSetsToQueue(final List queryResults, final SelectStatementContext selectStatementContext, final SchemaMetaData schemaMetaData) throws SQLException {
        for (QueryResult each : queryResults) {
            OrderByValue orderByValue = new OrderByValue(each, orderByItems, selectStatementContext, schemaMetaData);
            if (orderByValue.next()) {
                orderByValuesQueue.offer(orderByValue);
            }
        }
        setCurrentQueryResult(orderByValuesQueue.isEmpty() ? queryResults.get(0) : orderByValuesQueue.peek().getQueryResult());
    }
    
    @Override
    public boolean next() throws SQLException {
        if (orderByValuesQueue.isEmpty()) {
            return false;
        }
        if (isFirstNext) {
            isFirstNext = false;
            return true;
        }
//获取队列头元素，然后取该元素所在数据组的下一个元素，如果存在则继续压入有限队列
        OrderByValue firstOrderByValue = orderByValuesQueue.poll();
        if (firstOrderByValue.next()) {
            orderByValuesQueue.offer(firstOrderByValue);
        }
        if (orderByValuesQueue.isEmpty()) {
            return false;
        }
        setCurrentQueryResult(orderByValuesQueue.peek().getQueryResult());
        return true;
    }
}

 
 
OrderByStreamMergedResult类巧妙的使用优先队列实现了基于流模式的排序，由于每个数据集已经有序，所以在next()操作时弹出队列头部元素，然后再取该数据集下一个压入队列，当进行读取数据时直接读取队头元素对应值即可。
 
 
这里需要注意的是该优先队列采用的是小顶堆，但实际排序的时候可能是升序也可能是降序，那这里如何保证在不同排序方向时都能正确返回结果呢。玄机在排序元素OrderByValue类，其实现了Comparable接口，其会根据排序方向保证元素值的正确顺序。
 org.apache.shardingsphere.sharding.merge.dql.orderby.OrderByValue
 
 
public final class OrderByValue implements Comparable {
…
    public int compareTo(final OrderByValue o) {
        int i = 0;
        for (OrderByItem each : orderByItems) {
            int result = CompareUtil.compareTo(orderValues.get(i), o.orderValues.get(i), each.getSegment().getOrderDirection(),
                each.getSegment().getNullOrderDirection(), orderValuesCaseSensitive.get(i));
            if (0 != result) {
                return result;
            }
            i++;
        }
        return 0;
}
}

 
 
在CompareUtil类的compareTo方法中，根据排序方向进行返回比较结果，当降序时直接返回值得比较结果，如果是升序则对值比较结果取反。
 
 
public final class CompareUtil {
    
    /**
     * Compare two object with order type.
     *
     * @param thisValue this value
     * @param otherValue other value
     * @param orderDirection order direction 
     * @param nullOrderDirection order direction for null value
     * @param caseSensitive case sensitive
     * @return compare result
     */
    @SuppressWarnings("unchecked")
    public static int compareTo(final Comparable thisValue, final Comparable otherValue, final OrderDirection orderDirection, final OrderDirection nullOrderDirection, final boolean caseSensitive) {
        if (null == thisValue && null == otherValue) {
            return 0;
        }
        if (null == thisValue) {
            return orderDirection == nullOrderDirection ? -1 : 1;
        }
        if (null == otherValue) {
            return orderDirection == nullOrderDirection ? 1 : -1;
        }
        if (!caseSensitive && thisValue instanceof String && otherValue instanceof String) {
            return compareToCaseInsensitiveString((String) thisValue, (String) otherValue, orderDirection);
        }
        return OrderDirection.ASC == orderDirection ? thisValue.compareTo(otherValue) : -thisValue.compareTo(otherValue);//当升序时，将比较结果值取反
    }
    

 
 
当group by和order by的列不一样时，则采用基于内存模式归并，对应合并结果集类为org.apache.shardingsphere.sharding.merge.dql.groupby.GroupByMemoryMergedResult
 
 
/**
 * Memory merged result for group by.
 */
public final class GroupByMemoryMergedResult extends MemoryMergedResult {
    
    public GroupByMemoryMergedResult(final List queryResults, final SelectStatementContext selectStatementContext, final SchemaMetaData schemaMetaData) throws SQLException {
        super(null, schemaMetaData, selectStatementContext, queryResults);
    }
    
    @Override
    protected List init(final ShardingRule shardingRule,
                                              final SchemaMetaData schemaMetaData, final SQLStatementContext sqlStatementContext, final List queryResults) throws SQLException {
        SelectStatementContext selectStatementContext = (SelectStatementContext) sqlStatementContext;
        Map dataMap = new HashMap<>(1024);
        Map> aggregationMap = new HashMap<>(1024);
        for (QueryResult each : queryResults) {//遍历所有结果集元素，然后进行聚合运算
            while (each.next()) {
                GroupByValue groupByValue = new GroupByValue(each, selectStatementContext.getGroupByContext().getItems());
                initForFirstGroupByValue(selectStatementContext, each, groupByValue, dataMap, aggregationMap);//初始化创建GroupByValue对应的AggregationUnit
                aggregate(selectStatementContext, each, groupByValue, aggregationMap);//对各分组进行聚合计算
            }
        }
        setAggregationValueToMemoryRow(selectStatementContext, dataMap, aggregationMap);//将计算的值设置到aggregationMap
        List valueCaseSensitive = queryResults.isEmpty() ? Collections.emptyList() : getValueCaseSensitive(queryResults.iterator().next(), selectStatementContext, schemaMetaData);
        return getMemoryResultSetRows(selectStatementContext, dataMap, valueCaseSensitive);//
}
…
//将aggregationMap中值排序后生成List集合，此及时作为内存合并结果的内部数据类
    private List getMemoryResultSetRows(final SelectStatementContext selectStatementContext, 
                                                              final Map dataMap, final List valueCaseSensitive) {
        List result = new ArrayList<>(dataMap.values());
        result.sort(new GroupByRowComparator(selectStatementContext, valueCaseSensitive));
        return result;
    }
}

 
 
可以看到与基于流模式归并的区别在于需要遍历读取所有结果集中元素，然后根据GroupByValue分组进行聚合运算。
 
 
在上面我们提到会根据创建聚合类型，创建AggregationUnit实例，其对应的工厂类为org.apache.shardingsphere.sharding.merge.dql.groupby.aggregation.AggregationUnitFactory
 
 
public final class AggregationUnitFactory {
    
    /**
     * Create aggregation unit instance.
     * 
     * @param type aggregation function type
     * @param isDistinct is distinct
     * @return aggregation unit instance
     */
    public static AggregationUnit create(final AggregationType type, final boolean isDistinct) {
        switch (type) {
            case MAX:
                return new ComparableAggregationUnit(false);
            case MIN:
                return new ComparableAggregationUnit(true);
            case SUM:
                return isDistinct ? new DistinctSumAggregationUnit() : new AccumulationAggregationUnit();
            case COUNT:
                return isDistinct ? new DistinctCountAggregationUnit() : new AccumulationAggregationUnit();
            case AVG:
                return isDistinct ? new DistinctAverageAggregationUnit() : new AverageAggregationUnit();
            default:
                throw new UnsupportedOperationException(type.name());
        }
    }

 
 
这些AggregationUnit实现类逻辑都比较简单，主要就是累积计算传入集合元素的和，如果带有distinct的，则其内部通过一个HashSet进行判重，当为avg聚合运算时，传入的值有两个元素，分别为count和sum值。
 
 
org.apache.shardingsphere.sharding.merge.dql.groupby.aggregation.AccumulationAggregationUnit
 
 
/**
 * Accumulation aggregation unit.
 */
@RequiredArgsConstructor
public final class AccumulationAggregationUnit implements AggregationUnit {
    
    private BigDecimal result;
    
    @Override
    public void merge(final List> values) {
        if (null == values || null == values.get(0)) {
            return;
        }
        if (null == result) {
            result = new BigDecimal("0");
        }
        result = result.add(new BigDecimal(values.get(0).toString()));
    }
    
    @Override
    public Comparable getResult() {
        return result;
    }
}

 
 
org.apache.shardingsphere.sharding.merge.dql.groupby.aggregation.DistinctAverageAggregationUnit
 
 
**
 * Distinct average aggregation unit.
 */
@RequiredArgsConstructor
public final class DistinctAverageAggregationUnit implements AggregationUnit {
    
    private BigDecimal count;
    
    private BigDecimal sum;
    
    private Collection> countValues = new LinkedHashSet<>();
    
    private Collection> sumValues = new LinkedHashSet<>();
    
    @Override
    public void merge(final List> values) {
        if (null == values || null == values.get(0) || null == values.get(1)) {
            return;
        }
        if (this.countValues.add(values.get(0)) && this.sumValues.add(values.get(0))) {
            if (null == count) {
                count = new BigDecimal("0");
            }
            if (null == sum) {
                sum = new BigDecimal("0");
            }
            count = count.add(new BigDecimal(values.get(0).toString()));
            sum = sum.add(new BigDecimal(values.get(1).toString()));
        }
    } 

 
 
由于这些类逻辑比较简单，这里就不详细介绍其中代码。
 
 
在基于流或者内存生成合并结果集后，最后还有一个分页的装饰操作，其核心操作是根据offset，先对结果集取next()操作offset次，之所以需要这样处理，是因为如果是多个数据节点的分页操作，在rewrite环节会将offset设置成0，所以在返回给应用前需要跳过前offset记录。
 org.apache.shardingsphere.sharding.merge.dql.pagination.LimitDecoratorMergedResult
 
 
/**
 * Decorator merged result for limit pagination.
 */
public final class LimitDecoratorMergedResult extends DecoratorMergedResult {
    
    private final PaginationContext pagination;
    
    private final boolean skipAll;
    
    private int rowNumber;
    
    public LimitDecoratorMergedResult(final MergedResult mergedResult, final PaginationContext pagination) throws SQLException {
        super(mergedResult);
        this.pagination = pagination;
        skipAll = skipOffset();
    }

    private boolean skipOffset() throws SQLException {
        for (int i = 0; i < pagination.getActualOffset(); i++) {
            if (!getMergedResult().next()) { //如果结果集总概述小于offset值，设置skipAll为true，表示跳过所有结果集，后续next()直接返回false
                return true;
            }
        }
        rowNumber = 0;
        return false;
    }
    
    @Override
    public boolean next() throws SQLException {
        if (skipAll) {
            return false;
        }
        if (!pagination.getActualRowCount().isPresent()) {
            return getMergedResult().next();
        }
//由于改写了offset，多个数据节点返回的结果集总数大于SQL中指定的RowCount，因此在next()操作时要记录当前已返回的记录总数rowNumber，同时要判断该值不能大于SQL指定的RowCount
        return ++rowNumber <= pagination.getActualRowCount().get() && getMergedResult().next();
    }
}

 
 
二、 回到MergeEntry的decorate方法，该方法遍历拿到注册的ResultDecoratorEngine，依次调用其newInstance创建ResultDecorator实例，然后执行其decorate方法，对第一步生成的MergedResult实例进行二次处理。ResultDecoratorEngine接口目前实现类只有org.apache.shardingsphere.encrypt.merge.EncryptResultDecoratorEngine
 
 
/**
 * Result decorator engine for encrypt.
 */
public final class EncryptResultDecoratorEngine implements ResultDecoratorEngine {
    
    @Override
    public ResultDecorator newInstance(final DatabaseType databaseType, final SchemaMetaData schemaMetaData, 
                                       final EncryptRule encryptRule, final ConfigurationProperties properties, final SQLStatementContext sqlStatementContext) {
        if (sqlStatementContext instanceof SelectStatementContext) {
            return new EncryptDQLResultDecorator(
                    new EncryptorMetaData(schemaMetaData, encryptRule, (SelectStatementContext) sqlStatementContext), properties.getValue(ConfigurationPropertyKey.QUERY_WITH_CIPHER_COLUMN));
        } 
        if (sqlStatementContext.getSqlStatement() instanceof DALStatement) {
            return new EncryptDALResultDecorator();
        }
        return new TransparentResultDecorator();
}
..
}

 
 
可以看到其创建了org.apache.shardingsphere.encrypt.merge.dql.EncryptDQLResultDecorator实例
 
 

/**
 * DQL result decorator for encrypt.
 */
@RequiredArgsConstructor
public final class EncryptDQLResultDecorator implements ResultDecorator {
    
    private final EncryptorMetaData encryptorMetaData;
    
    private final boolean queryWithCipherColumn;
    
    @Override
    public MergedResult decorate(final QueryResult queryResult, final SQLStatementContext sqlStatementContext, final SchemaMetaData schemaMetaData) {
        return new EncryptMergedResult(encryptorMetaData, new TransparentMergedResult(queryResult), queryWithCipherColumn);
    }
    
    @Override
    public MergedResult decorate(final MergedResult mergedResult, final SQLStatementContext sqlStatementContext, final SchemaMetaData schemaMetaData) {
        return new EncryptMergedResult(encryptorMetaData, mergedResult, queryWithCipherColumn);
    }
}

 
 
decorate方法则直接创建了EncryptMergedResult实例返回，该类逻辑也很清晰，实现了MergedResult接口，在getValue方法中，先判断是否需要进行解密，如果需要则查询对应的加密器对象，然后执行解密，然后返回。
 
 
org.apache.shardingsphere.encrypt.merge.dql.EncryptMergedResult
 
 
/**
 * Merged result for encrypt.
 */
@RequiredArgsConstructor
public final class EncryptMergedResult implements MergedResult {
    
    private final EncryptorMetaData metaData;
    
    private final MergedResult mergedResult;
    
    private final boolean queryWithCipherColumn;
    
    @Override
    public boolean next() throws SQLException {
        return mergedResult.next();
    }
    
    @Override
    public Object getValue(final int columnIndex, final Class type) throws SQLException {
        if (!queryWithCipherColumn) {
            return mergedResult.getValue(columnIndex, type);
        }
        Optional encryptor = metaData.findEncryptor(columnIndex);
        if (!encryptor.isPresent()) {
            return mergedResult.getValue(columnIndex, type);
        }
        String ciphertext = (String) mergedResult.getValue(columnIndex, String.class);
        return null == ciphertext ? null : encryptor.get().decrypt(ciphertext);
    }
    

 
 
关于加密的源码限于篇幅，这里不展开分析。
 
 
 
  
 
   
  
   
 
  
 
  

    归并引擎执行流程 
  
 
 
 
 
官网文档对归并引擎画了一张流程图：
 
 
 
  
 
   
  
   
 
  
 
  
 
 
 
 
其它关于归并引擎原理的更多介绍可参见官网介绍https://shardingsphere.apache.org/document/current/cn/features/sharding/principle/merge/
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(从源码看ShardingSphere设计-归并引擎篇)

        

            

                
    
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • 消息中间件有哪些常见类型
                        xmh-sxh-1314
java
                        
    消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
    
                    
    • 
                    
  • 那个抄袭的大张伟
                        猫小努

                        
    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
    
                    
    • 
                    
  • 三大师传
                        beca酱

                        
    巴尔扎克的作品被誉为“法国社会的一面镜子”。文学大师维克多·雨果对巴尔扎克的评价是：“在最伟大的人物中间，巴尔扎克是名列前茅者；在最优秀的人物中间，巴尔扎克是佼佼者之一。”一个原本寂寂无名的小人物，从地中海的某个海岛上，只身一人来到巴黎，没有朋友，也没有名望。作为一个一文不名的外乡人，凭着赤手空拳赢得了巴黎，征服了整个法兰西，并且赢得了世界。这个人就是十九世纪法国伟大的军事家、政治家，法兰西第一帝
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • 活给自己看，笑容才灿烂
                        听着了么

                        
    白岩松说“有时候，我们活得很累，并非生活过于刻薄，而是我们太容易被外界的氛围所感染，被他人的情绪所左右。”心情是自己的。若只是活在别人的眼里、嘴里，便掌握不了让自己开心的主动权。人活着，不是为了活给别人看的，唯有做最真实的自己，活给自己看，笑容才灿烂。诚然，世事纷繁复杂，人人都有一张嘴，管也管不了。永远有人欣赏你，也永远有人批评你，不可能做到让所有人都满意，开心做自己才是最重要的。人生苦短，有太多
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • git常用命令笔记
                        咩酱-小羊
git笔记
                        
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
    
                    
    • 
                    
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
    
                    
    • 
                    
  • Python教程：一文了解使用Python处理XPath
                        旦莫
Python进阶python开发语言
                        
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
    
                    
    • 
                    
  • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
    
                    
    • 
                    
  • 从鸡肉高汤到记忆的魔法再到有效提示的艺术
                        步子哥
人工智能
                        
    还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
    
                    
    • 
                    
  • 谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘
                        李虓酒评论

                        
    文/王赛时中国的酒器酒具历史久远，举世闻名。从北京的故宫博物院、中国国家博物馆，到世界各国的大型博物馆，都以能够收藏中国古代酒具而夸耀。但很少有人知道，在山东阳谷景阳冈酒厂，默默地收藏了两千件中国酒器。这些酒器，就封藏在景阳冈的酒道馆里。其中有一些青铜酒器，一睡就是三、四千年，堪称无声国宝，堪作无字史书！今天，我将引领诸位首先窥视一下景阳冈酒道馆的9件先秦藏品，你自己来说震撼不震撼。提示：这只是景
    
                    
    • 
                    
  • 下载github patch到本地
                        小米人er
我的博客gitpatch
                        
    以下是几种从GitHub上下载以.patch结尾的补丁文件的方法：通过浏览器直接下载打开包含该.patch文件的GitHub仓库。在仓库的文件列表中找到对应的.patch文件。点击该文件，浏览器会显示文件的内容，在页面的右上角通常会有一个“Raw”按钮，点击它可以获取原始文件内容。然后在浏览器中使用快捷键（如Ctrl+S或者Command+S）将原始文件保存到本地，选择保存的文件名并确保后缀为.p
    
                    
    • 
                    
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    
                    
    • 
                    
  • 山东大学小树林支教调研团青青仓木队——翟晓楠
                        山东大学青青仓木队

                        
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
    
                    
    • 
                    
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记
                        爱吃丸子的小樱桃

                        
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                                
  • linux系统服务器下jsp传参数乱码
                                    3213213333332132
javajsplinuxwindowsxml
                                    
    在一次解决乱码问题中， 发现jsp在windows下用js原生的方法进行编码没有问题，但是到了linux下就有问题， escape,encodeURI,encodeURIComponent等都解决不了问题 
但是我想了下既然原生的方法不行，我用el标签的方式对中文参数进行加密解密总该可以吧。于是用了java的java.net.URLDecoder,结果还是乱码，最后在绝望之际，用了下面的方法解决了
    
                                
    • 
                                
  • Spring 注解区别以及应用
                                    BlueSkator
spring
                                    
    1. @Autowired 
@Autowired是根据类型进行自动装配的。如果当Spring上下文中存在不止一个UserDao类型的bean，或者不存在UserDao类型的bean，会抛出 BeanCreationException异常，这时可以通过在该属性上再加一个@Qualifier注解来声明唯一的id解决问题。 
  
2. @Qualifier 
当spring中存在至少一个匹
    
                                
    • 
                                
  • printf和sprintf的应用
                                    dcj3sjt126com
PHPsprintfprintf
                                    
    <?php
printf('b: %b <br>c: %c <br>d: %d <bf>f: %f', 80,80, 80, 80);
echo '<br />';
printf('%0.2f <br>%+d <br>%0.2f <br>', 8, 8, 1235.456);

printf('th
    
                                
    • 
                                
  • config.getInitParameter
                                    171815164
parameter
                                    
    web.xml 
 
 <servlet>
  	<servlet-name>servlet1</servlet-name>
  	<jsp-file>/index.jsp</jsp-file>
  	<init-param>
  		<param-name>str</param-name>

    
                                
    • 
                                
  • Ant标签详解--基础操作
                                    g21121
ant
                                    
            Ant的一些核心概念： 
        build.xml：构建文件是以XML 文件来描述的，默认构建文件名为build.xml。        project：每个构建文
    
                                
    • 
                                
  • [简单]代码片段_数据合并
                                    53873039oycg
代码
                                    
            合并规则:删除家长phone为空的记录,若一个家长对应多个孩子,保留一条家长记录,家长id修改为phone,对应关系也要修改。 
        代码如下: 
       
    
                                
    • 
                                
  • java 通信技术
                                    云端月影
Java 远程通信技术
                                    
    在分布式服务框架中，一个最基础的问题就是远程服务是怎么通讯的，在Java领域中有很多可实现远程通讯的技术，例如：RMI、MINA、ESB、Burlap、Hessian、SOAP、EJB和JMS等，这些名词之间到底是些什么关系呢，它们背后到底是基于什么原理实现的呢，了解这些是实现分布式服务框架的基础知识，而如果在性能上有高的要求的话，那深入了解这些技术背后的机制就是必须的了，在这篇blog中我们将来
    
                                
    • 
                                
  • string与StringBuilder 性能差距到底有多大
                                    aijuans

                                    
      
        之前也看过一些对string与StringBuilder的性能分析，总感觉这个应该对整体性能不会产生多大的影响，所以就一直没有关注这块！ 
        由于学程序初期最先接触的string拼接，所以就一直没改变过自己的习惯！ 
        
    
                                
    • 
                                
  • 今天碰到 java.util.ConcurrentModificationException 异常
                                    antonyup_2006
java多线程工作IBM
                                    
    今天改bug，其中有个实现是要对map进行循环，然后有删除操作，代码如下： 

Iterator<ListItem> iter = ItemMap.keySet.iterator();
while(iter.hasNext()){
ListItem it = iter.next();
//...一些逻辑操作
ItemMap.remove(it);
}
 
结果运行报Con
    
                                
    • 
                                
  • PL/SQL的类型和JDBC操作数据库
                                    百合不是茶
PL/SQL表标量类型游标PL/SQL记录
                                    
    PL/SQL的标量类型: 
   字符,数字,时间,布尔,%type五中类型的 
--标量：数据库中预定义类型的变量
--定义一个变长字符串 
v_ename varchar2(10); 

--定义一个小数,范围 -9999.99~9999.99 
v_sal number(6,2); 

--定义一个小数并给一个初始值为5.4 :=是pl/sql的赋值号 

    
                                
    • 
                                
  • Mockito：一个强大的用于 Java 开发的模拟测试框架实例
                                    bijian1013
mockito单元测试
                                    
    Mockito框架： 
        Mockito是一个基于MIT协议的开源java测试框架。         Mockito区别于其他模拟框架的地方主要是允许开发者在没有建立“预期”时验证被测系统的行为。对于mock对象的一个评价是测试系统的测
    
                                
    • 
                                
  • 精通Oracle10编程SQL(10)处理例外
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *处理例外
 */
--例外简介
--处理例外-传递例外
declare
   v_ename emp.ename%TYPE;
begin
   SELECT ename INTO v_ename FROM emp
      where empno=&no;
   dbms_output.put_line('雇员名：'||v_ename);
exceptio
    
                                
    • 
                                
  • 【Java】Java执行远程机器上Linux命令
                                    bit1129
linux命令
                                    
    Java使用ethz通过ssh2执行远程机器Linux上命令， 
  
封装定义Linux机器的环境信息 
  
package com.tom;


import java.io.File;

public class Env {
    private String hostaddr; //Linux机器的IP地址
    private Integer po
    
                                
    • 
                                
  • java通信之Socket通信基础
                                    白糖_
javasocket网络协议
                                    
    正处于网络环境下的两个程序，它们之间通过一个交互的连接来实现数据通信。每一个连接的通信端叫做一个Socket。一个完整的Socket通信程序应该包含以下几个步骤： 
①创建Socket； 
②打开连接到Socket的输入输出流； 
④按照一定的协议对Socket进行读写操作； 
④关闭Socket。 
  
Socket通信分两部分：服务器端和客户端。服务器端必须优先启动，然后等待soc
    
                                
    • 
                                
  • angular.bind
                                    boyitech
AngularJSangular.bindAngularJS APIbind
                                    
    angular.bind   描述：           上下文，函数以及参数动态绑定，返回值为绑定之后的函数. 其中args是可选的动态参数，self在fn中使用this调用。    使用方法：            angular.bind(se
    
                                
    • 
                                
  • java-13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;


public class KickOutBadGuys {

	/**
	 * 题目：13个坏人和13个好人站成一圈，数到7就从圈里面踢出一个来，要求把所有坏人都给踢出来，所有好人都留在圈里。请找出初始时坏人站的位置。
	 * Maybe you can find out 
    
                                
    • 
                                
  • Redis.conf配置文件及相关项说明（自查备用）
                                    Kai_Ge
redis
                                    
       Redis.conf配置文件及相关项说明 
# Redis configuration file example
 
# Note on units: when memory size is needed, it is possible to specifiy
# it in the usual form of 1k 5GB 4M and so forth:
#

    
                                
    • 
                                
  • [强人工智能]实现大规模拓扑分析是实现强人工智能的前奏
                                    comsci
人工智能
                                    
     
 
     真不好意思,各位朋友...博客再次更新... 
 
     节点数量太少,网络的分析和处理能力肯定不足,在面对机器人控制的需求方面,显得力不从心.... 
 
     但是,节点数太多,对拓扑数据处理的要求又很高,设计目标也很高,实现起来难度颇大... 
 
    
                                
    • 
                                
  • 记录一些常用的函数
                                    dai_lm
java
                                    
    
public static String convertInputStreamToString(InputStream is) {

	StringBuilder result = new StringBuilder();

	if (is != null)
		try {
			InputStreamReader inputReader = new InputStreamRead
    
                                
    • 
                                
  • Hadoop中小规模集群的并行计算缺陷
                                    datamachine
mapreducehadoop并行计算
                                    
    注：写这篇文章的初衷是因为Hadoop炒得有点太热，很多用户现有数据规模并不适用于Hadoop，但迫于扩容压力和去IOE（Hadoop的廉价扩展的确非常有吸引力）而尝试。尝试永远是件正确的事儿，但有时候不用太突进，可以调优或调需求，发挥现有系统的最大效用为上策。 
 
-----------------------------------------------------------------
    
                                
    • 
                                
  • 小学4年级英语单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
    egg  蛋 
twenty 二十 
any 任何 
well 健康的，好 
  
twelve 十二 
farm 农场 
every 每一个 
back 向后，回 
  
fast 快速的 
whose 谁的 
much 许多 
flower 花 
  
watch 手表 
very 非常，很 
sport 运动 
Chinese 中国的 
  
    
                                
    • 
                                
  • 自己实践了github的webhooks, linux上面的权限需要注意
                                    dcj3sjt126com
githubwebhook
                                    
    环境, 阿里云服务器 
  
1. 本地创建项目, push到github服务器上面 
  
2. 生成www用户的密钥 
sudo -u www ssh-keygen -t rsa -C "[email protected]" 
  
  
3. 将密钥添加到github帐号的SSH_KEYS里面 
  
3. 用www用户执行克隆, 源使
    
                                
    • 
                                
  • Java冒泡排序
                                    蕃薯耀
冒泡排序Java冒泡排序Java排序
                                    
    冒泡排序 
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年6月23日 10:40:14 星期二 
http://fanshuyao.iteye.com/
    
                                
    • 
                                
  • Excle读取数据转换为实体List【基于apache-poi】
                                    hanqunfeng
apache
                                    
    1.依赖apache-poi 
  
2.支持xls和xlsx 
  
3.支持按属性名称绑定数据值 
  
4.支持从指定行、列开始读取 
  
5.支持同时读取多个sheet 
  
6.具体使用方式参见org.cpframework.utils.excelreader.CP_ExcelReaderUtilTest.java 
比如： 
Str
    
                                
    • 
                                
  • 3个处于草稿阶段的Javascript API介绍
                                    jackyrong
JavaScript
                                    
    原文： 
http://www.sitepoint.com/3-new-javascript-apis-may-want-follow/?utm_source=html5weekly&utm_medium=email 
 
 
  本文中，介绍3个仍然处于草稿阶段，但应该值得关注的Javascript API. 
 
1) Web Alarm API 
  &
    
                                
    • 
                                
  • 6个创建Web应用程序的高效PHP框架
                                    lampcy
Web框架PHP
                                    
    以下是创建Web应用程序的PHP框架，有coder bay网站整理推荐： 
1. CakePHP 
CakePHP是一个PHP快速开发框架，它提供了一个用于开发、维护和部署应用程序的可扩展体系。CakePHP使用了众所周知的设计模式，如MVC和ORM，降低了开发成本，并减少了开发人员写代码的工作量。 
2. CodeIgniter 
CodeIgniter是一个非常小且功能强大的PHP框架，适合需
    
                                
    • 
                                
  • 评"救市后中国股市新乱象泛起"谣言
                                    nannan408

                                    
    首先来看百度百家一位易姓作者的新闻： 
 

    三个多星期来股市持续暴跌，跌得投资者及上市公司都处于极度的恐慌和焦虑中，都要寻找自保及规避风险的方式。面对股市之危机，政府突然进入市场救市，希望以此来重建市场信心，以此来扭转股市持续暴跌的预期。而政府进入市场后，由于市场运作方式发生了巨大变化，投资者及上市公司为了自保及为了应对这种变化，中国股市新的乱象也自然产生。

首先，中国股市这两天
    
                                
    • 
                                
  • 页面全屏遮罩的实现 方式
                                    Rainbow702
htmlcss遮罩mask
                                    
    之前做了一个页面，在点击了某个按钮之后，要求页面出现一个全屏遮罩，一开始使用了position:absolute来实现的。当时因为画面大小是固定的，不可以resize的，所以，没有发现问题。 
最近用了同样的做法做了一个遮罩，但是画面是可以进行resize的，所以就发现了一个问题，当画面被reisze到浏览器出现了滚动条的时候，就发现，用absolute 的做法是有问题的。后来改成fixed定位就
    
                                
    • 
                                
  • 关于angularjs的点滴
                                    tntxia
AngularJS
                                    
      
angular是一个新兴的JS框架，和以往的框架不同的事，Angularjs更注重于js的建模，管理，同时也提供大量的组件帮助用户组建商业化程序，是一种值得研究的JS框架。 
  
Angularjs使我们可以使用MVC的模式来写JS。Angularjs现在由谷歌来维护。 
  
这里我们来简单的探讨一下它的应用。 
  
首先使用Angularjs我
    
                                
    • 
                                
  • Nutz--->>反复新建ioc容器的后果
                                    xiaoxiao1992428
DAOmvcIOCnutz
                                    
    问题： 
public class DaoZ { 
  
  public static Dao dao() { // 每当需要使用dao的时候就取一次 
    Ioc ioc = new NutIoc(new JsonLoader("dao.js")); 
    return ioc.get(
    
                                
    •