This is an automated email from the ASF dual-hosted git repository.
duanzhengqiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/shardingsphere.git
The following commit(s) were added to refs/heads/master by this push:
new 20fb4bb6a25 Refactor ReadwriteSplittingRule and TrafficRule
trafficAlgorithm map and loadBalancers map (#22085)
20fb4bb6a25 is described below
commit 20fb4bb6a2501fc92c65377d7a67e049755f615a
Author: zhaojinchao <[email protected]>
AuthorDate: Fri Nov 11 19:42:46 2022 +0800
Refactor ReadwriteSplittingRule and TrafficRule trafficAlgorithm map and
loadBalancers map (#22085)
* Refactor ReadwriteSplittingRule and TrafficRule trafficAlgorithm map and
loadBalancers map
* Replace .
* Update
---
.../rule/ReadwriteSplittingRule.java | 25 ++++++++------------
.../shardingsphere/traffic/rule/TrafficRule.java | 27 +++++++++++++---------
2 files changed, 26 insertions(+), 26 deletions(-)
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
index 9703ef5d0c8..f01fb291c75 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/rule/ReadwriteSplittingRule.java
@@ -19,7 +19,6 @@ package org.apache.shardingsphere.readwritesplitting.rule;
import com.google.common.base.Preconditions;
import lombok.Getter;
-import org.apache.shardingsphere.infra.config.algorithm.AlgorithmConfiguration;
import org.apache.shardingsphere.infra.config.rule.RuleConfiguration;
import org.apache.shardingsphere.infra.distsql.constant.ExportableConstants;
import
org.apache.shardingsphere.infra.distsql.constant.ExportableItemConstants;
@@ -61,38 +60,34 @@ public final class ReadwriteSplittingRule implements
DatabaseRule, DataSourceCon
@Getter
private final RuleConfiguration configuration;
+ private final Map<String, ReadQueryLoadBalanceAlgorithm> loadBalancers =
new LinkedHashMap<>();
+
private final Map<String, ReadwriteSplittingDataSourceRule>
dataSourceRules;
public ReadwriteSplittingRule(final ReadwriteSplittingRuleConfiguration
ruleConfig, final Collection<ShardingSphereRule> builtRules) {
configuration = ruleConfig;
+ ruleConfig.getDataSources().stream().filter(each -> null !=
ruleConfig.getLoadBalancers().get(each.getLoadBalancerName()))
+ .forEach(each -> loadBalancers.put(each.getName() + "." +
each.getLoadBalancerName(),
+
ReadQueryLoadBalanceAlgorithmFactory.newInstance(ruleConfig.getLoadBalancers().get(each.getLoadBalancerName()))));
dataSourceRules = new HashMap<>(ruleConfig.getDataSources().size(), 1);
for (ReadwriteSplittingDataSourceRuleConfiguration each :
ruleConfig.getDataSources()) {
-
dataSourceRules.putAll(createReadwriteSplittingDataSourceRules(each,
ruleConfig.getLoadBalancers(), builtRules));
+
dataSourceRules.putAll(createReadwriteSplittingDataSourceRules(each,
builtRules));
}
}
public ReadwriteSplittingRule(final
AlgorithmProvidedReadwriteSplittingRuleConfiguration ruleConfig, final
Collection<ShardingSphereRule> builtRules) {
configuration = ruleConfig;
+ ruleConfig.getDataSources().stream().filter(each -> null !=
ruleConfig.getLoadBalanceAlgorithms().get(each.getLoadBalancerName()))
+ .forEach(each -> loadBalancers.put(each.getName() + "." +
each.getLoadBalancerName(),
ruleConfig.getLoadBalanceAlgorithms().get(each.getLoadBalancerName())));
dataSourceRules = new HashMap<>(ruleConfig.getDataSources().size(), 1);
for (ReadwriteSplittingDataSourceRuleConfiguration each :
ruleConfig.getDataSources()) {
-
dataSourceRules.putAll(createReadwriteSplittingDataSourceRules0(each,
ruleConfig.getLoadBalanceAlgorithms(), builtRules));
+
dataSourceRules.putAll(createReadwriteSplittingDataSourceRules(each,
builtRules));
}
}
private Map<String, ReadwriteSplittingDataSourceRule>
createReadwriteSplittingDataSourceRules(final
ReadwriteSplittingDataSourceRuleConfiguration config,
-
final Map<String, AlgorithmConfiguration> algorithmConfigs,
final Collection<ShardingSphereRule> builtRules) {
- ReadQueryLoadBalanceAlgorithm loadBalanceAlgorithm = null ==
algorithmConfigs.get(config.getLoadBalancerName()) ?
ReadQueryLoadBalanceAlgorithmFactory.newInstance()
- :
ReadQueryLoadBalanceAlgorithmFactory.newInstance(algorithmConfigs.get(config.getLoadBalancerName()));
- return null == config.getStaticStrategy()
- ? createDynamicReadwriteSplittingDataSourceRules(config,
builtRules, loadBalanceAlgorithm)
- : createStaticReadwriteSplittingDataSourceRules(config,
builtRules, loadBalanceAlgorithm);
- }
-
- private Map<String, ReadwriteSplittingDataSourceRule>
createReadwriteSplittingDataSourceRules0(final
ReadwriteSplittingDataSourceRuleConfiguration config,
-
final Map<String, ReadQueryLoadBalanceAlgorithm>
loadBalanceAlgorithms,
-
final Collection<ShardingSphereRule> builtRules) {
- ReadQueryLoadBalanceAlgorithm loadBalanceAlgorithm =
loadBalanceAlgorithms.getOrDefault(config.getLoadBalancerName(),
ReadQueryLoadBalanceAlgorithmFactory.newInstance());
+ ReadQueryLoadBalanceAlgorithm loadBalanceAlgorithm =
loadBalancers.getOrDefault(config.getName() + "." +
config.getLoadBalancerName(),
ReadQueryLoadBalanceAlgorithmFactory.newInstance());
return null == config.getStaticStrategy()
? createDynamicReadwriteSplittingDataSourceRules(config,
builtRules, loadBalanceAlgorithm)
: createStaticReadwriteSplittingDataSourceRules(config,
builtRules, loadBalanceAlgorithm);
diff --git
a/kernel/traffic/core/src/main/java/org/apache/shardingsphere/traffic/rule/TrafficRule.java
b/kernel/traffic/core/src/main/java/org/apache/shardingsphere/traffic/rule/TrafficRule.java
index 223f54d43c0..f4d8f331690 100644
---
a/kernel/traffic/core/src/main/java/org/apache/shardingsphere/traffic/rule/TrafficRule.java
+++
b/kernel/traffic/core/src/main/java/org/apache/shardingsphere/traffic/rule/TrafficRule.java
@@ -46,7 +46,6 @@ import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.Map;
-import java.util.Map.Entry;
import java.util.Optional;
import java.util.Properties;
@@ -69,16 +68,22 @@ public final class TrafficRule implements GlobalRule {
private Map<String, TrafficAlgorithm> createTrafficAlgorithms(final
Map<String, AlgorithmConfiguration> trafficAlgorithms) {
Map<String, TrafficAlgorithm> result = new LinkedHashMap<>();
- for (Entry<String, AlgorithmConfiguration> entry :
trafficAlgorithms.entrySet()) {
- result.put(entry.getKey(),
TrafficAlgorithmFactory.newInstance(entry.getValue()));
+ for (TrafficStrategyConfiguration each :
configuration.getTrafficStrategies()) {
+ if (null == trafficAlgorithms.get(each.getAlgorithmName())) {
+ break;
+ }
+ result.put(each.getName() + "." + each.getAlgorithmName(),
TrafficAlgorithmFactory.newInstance(trafficAlgorithms.get(each.getAlgorithmName())));
}
return result;
}
private Map<String, TrafficLoadBalanceAlgorithm>
createTrafficLoadBalanceAlgorithms(final Map<String, AlgorithmConfiguration>
loadBalancers) {
Map<String, TrafficLoadBalanceAlgorithm> result = new
LinkedHashMap<>();
- for (Entry<String, AlgorithmConfiguration> entry :
loadBalancers.entrySet()) {
- result.put(entry.getKey(),
TrafficLoadBalanceAlgorithmFactory.newInstance(entry.getValue()));
+ for (TrafficStrategyConfiguration each :
configuration.getTrafficStrategies()) {
+ if (null == loadBalancers.get(each.getLoadBalancerName())) {
+ break;
+ }
+ result.put(each.getName() + "." + each.getLoadBalancerName(),
TrafficLoadBalanceAlgorithmFactory.newInstance(loadBalancers.get(each.getLoadBalancerName())));
}
return result;
}
@@ -88,7 +93,7 @@ public final class TrafficRule implements GlobalRule {
Collection<TrafficStrategyRule> noneTransactionStrategyRules = new
LinkedList<>();
Collection<TrafficStrategyRule> result = new LinkedList<>();
for (TrafficStrategyConfiguration each : trafficStrategies) {
- TrafficAlgorithm trafficAlgorithm =
getTrafficAlgorithm(trafficAlgorithms, each.getAlgorithmName());
+ TrafficAlgorithm trafficAlgorithm = getTrafficAlgorithm(each,
trafficAlgorithms);
TrafficStrategyRule trafficStrategyRule =
createTrafficStrategyRule(each, trafficAlgorithm, loadBalancers);
if (isTransactionStrategyRule(trafficAlgorithm)) {
result.add(trafficStrategyRule);
@@ -106,7 +111,7 @@ public final class TrafficRule implements GlobalRule {
if (trafficAlgorithm instanceof SimplifiedTrafficAlgorithm) {
result = new TrafficStrategyRule(strategyConfig.getName(),
Collections.emptyList(), trafficAlgorithm, null);
} else {
- TrafficLoadBalanceAlgorithm loadBalancer =
getLoadBalancer(loadBalancers, strategyConfig.getLoadBalancerName());
+ TrafficLoadBalanceAlgorithm loadBalancer =
getLoadBalancer(strategyConfig, loadBalancers);
result = new TrafficStrategyRule(strategyConfig.getName(), new
LinkedHashSet<>(strategyConfig.getLabels()), trafficAlgorithm, loadBalancer);
}
return result;
@@ -132,8 +137,8 @@ public final class TrafficRule implements GlobalRule {
return Optional.empty();
}
- private TrafficAlgorithm getTrafficAlgorithm(final Map<String,
TrafficAlgorithm> trafficAlgorithms, final String algorithmName) {
- TrafficAlgorithm result = trafficAlgorithms.get(algorithmName);
+ private TrafficAlgorithm getTrafficAlgorithm(final
TrafficStrategyConfiguration strategyConfig, final Map<String,
TrafficAlgorithm> trafficAlgorithms) {
+ TrafficAlgorithm result =
trafficAlgorithms.get(strategyConfig.getName() + "." +
strategyConfig.getAlgorithmName());
Preconditions.checkState(null != result, "Traffic algorithm can not be
null.");
return result;
}
@@ -171,8 +176,8 @@ public final class TrafficRule implements GlobalRule {
return trafficAlgorithm.match(transactionTrafficValue);
}
- private TrafficLoadBalanceAlgorithm getLoadBalancer(final Map<String,
TrafficLoadBalanceAlgorithm> loadBalancers, final String loadBalancerName) {
- TrafficLoadBalanceAlgorithm result =
loadBalancers.get(loadBalancerName);
+ private TrafficLoadBalanceAlgorithm getLoadBalancer(final
TrafficStrategyConfiguration strategyConfig, final Map<String,
TrafficLoadBalanceAlgorithm> loadBalancers) {
+ TrafficLoadBalanceAlgorithm result =
loadBalancers.get(strategyConfig.getName() + "." +
strategyConfig.getLoadBalancerName());
Preconditions.checkState(null != result, "Traffic load balance
algorithm can not be null.");
return result;
}
