This is an automated email from the ASF dual-hosted git repository.
zhaojinchao 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 7fd45e366f3 Refactor RuleConfigurationEventBuilder‘s impl (#26641)
7fd45e366f3 is described below
commit 7fd45e366f3341604ead058a26cdd1f5c604183b
Author: Liang Zhang <[email protected]>
AuthorDate: Tue Jun 27 23:18:48 2023 +0800
Refactor RuleConfigurationEventBuilder‘s impl (#26641)
---
.../BroadcastRuleConfigurationEventBuilder.java | 18 +--
...atibleEncryptRuleConfigurationEventBuilder.java | 23 ++--
.../EncryptRuleConfigurationEventBuilder.java | 23 ++--
.../event/MaskRuleConfigurationEventBuilder.java | 23 ++--
...riteSplittingRuleConfigurationEventBuilder.java | 23 ++--
.../event/ShadowRuleConfigurationEventBuilder.java | 44 +++----
.../ShardingRuleConfigurationEventBuilder.java | 141 +++++++++++----------
.../event/SingleRuleConfigurationEventBuilder.java | 18 +--
8 files changed, 148 insertions(+), 165 deletions(-)
diff --git
a/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/event/BroadcastRuleConfigurationEventBuilder.java
b/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/event/BroadcastRuleConfigurationEventBuilder.java
index 4b218880377..4a22a165a53 100644
---
a/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/event/BroadcastRuleConfigurationEventBuilder.java
+++
b/features/broadcast/core/src/main/java/org/apache/shardingsphere/broadcast/event/BroadcastRuleConfigurationEventBuilder.java
@@ -39,22 +39,18 @@ public final class BroadcastRuleConfigurationEventBuilder
implements RuleConfigu
@Override
public Optional<GovernanceEvent> build(final String databaseName, final
DataChangedEvent event) {
- if (!broadcastRuleNodePath.getRoot().isValidatedPath(event.getKey())
|| Strings.isNullOrEmpty(event.getValue())) {
- return Optional.empty();
- }
- if
(broadcastRuleNodePath.getUniqueItem(BroadcastNodePath.TABLES).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return createBroadcastConfigEvent(databaseName, event);
- }
- return Optional.empty();
+ return Strings.isNullOrEmpty(event.getValue()) ||
!broadcastRuleNodePath.getUniqueItem(BroadcastNodePath.TABLES).isActiveVersionPath(event.getKey())
+ ? Optional.empty()
+ : Optional.of(createBroadcastConfigEvent(databaseName, event));
}
- private Optional<GovernanceEvent> createBroadcastConfigEvent(final String
databaseName, final DataChangedEvent event) {
+ private GovernanceEvent createBroadcastConfigEvent(final String
databaseName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new AddBroadcastTableEvent(databaseName,
event.getKey(), event.getValue()));
+ return new AddBroadcastTableEvent(databaseName, event.getKey(),
event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new AlterBroadcastTableEvent(databaseName,
event.getKey(), event.getValue()));
+ return new AlterBroadcastTableEvent(databaseName, event.getKey(),
event.getValue());
}
- return Optional.of(new DeleteBroadcastTableEvent(databaseName));
+ return new DeleteBroadcastTableEvent(databaseName);
}
}
diff --git
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/event/CompatibleEncryptRuleConfigurationEventBuilder.java
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/event/CompatibleEncryptRuleConfigurationEventBuilder.java
index cc381a8a0bc..9e45671fb7b 100644
---
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/event/CompatibleEncryptRuleConfigurationEventBuilder.java
+++
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/event/CompatibleEncryptRuleConfigurationEventBuilder.java
@@ -47,30 +47,27 @@ public final class
CompatibleEncryptRuleConfigurationEventBuilder implements Rul
return Optional.empty();
}
Optional<String> tableName =
encryptRuleNodePath.getNamedItem(CompatibleEncryptNodePath.TABLES).getNameByActiveVersion(event.getKey());
- if (tableName.isPresent() && !Strings.isNullOrEmpty(event.getValue()))
{
- return createEncryptConfigEvent(databaseName, tableName.get(),
event);
+ if (tableName.isPresent()) {
+ return Optional.of(createEncryptConfigEvent(databaseName,
tableName.get(), event));
}
Optional<String> encryptorName =
encryptRuleNodePath.getNamedItem(CompatibleEncryptNodePath.ENCRYPTORS).getNameByActiveVersion(event.getKey());
- if (encryptorName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createEncryptorEvent(databaseName, encryptorName.get(),
event);
- }
- return Optional.empty();
+ return encryptorName.map(optional ->
createEncryptorEvent(databaseName, optional, event));
}
- private Optional<GovernanceEvent> createEncryptConfigEvent(final String
databaseName, final String groupName, final DataChangedEvent event) {
+ private GovernanceEvent createEncryptConfigEvent(final String
databaseName, final String groupName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddCompatibleEncryptTableEvent(databaseName, event.getKey(), event.getValue()));
+ return new AddCompatibleEncryptTableEvent(databaseName,
event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterCompatibleEncryptTableEvent(databaseName, groupName, event.getKey(),
event.getValue()));
+ return new AlterCompatibleEncryptTableEvent(databaseName,
groupName, event.getKey(), event.getValue());
}
- return Optional.of(new DeleteCompatibleEncryptTableEvent(databaseName,
groupName));
+ return new DeleteCompatibleEncryptTableEvent(databaseName, groupName);
}
- private Optional<GovernanceEvent> createEncryptorEvent(final String
databaseName, final String encryptorName, final DataChangedEvent event) {
+ private GovernanceEvent createEncryptorEvent(final String databaseName,
final String encryptorName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new AlterCompatibleEncryptorEvent(databaseName,
encryptorName, event.getKey(), event.getValue()));
+ return new AlterCompatibleEncryptorEvent(databaseName,
encryptorName, event.getKey(), event.getValue());
}
- return Optional.of(new DeleteCompatibleEncryptorEvent(databaseName,
encryptorName));
+ return new DeleteCompatibleEncryptorEvent(databaseName, encryptorName);
}
}
diff --git
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/event/EncryptRuleConfigurationEventBuilder.java
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/event/EncryptRuleConfigurationEventBuilder.java
index 0dd8193ef38..3fbcd828d66 100644
---
a/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/event/EncryptRuleConfigurationEventBuilder.java
+++
b/features/encrypt/core/src/main/java/org/apache/shardingsphere/encrypt/event/EncryptRuleConfigurationEventBuilder.java
@@ -45,30 +45,27 @@ public final class EncryptRuleConfigurationEventBuilder
implements RuleConfigura
return Optional.empty();
}
Optional<String> tableName =
encryptRuleNodePath.getNamedItem(EncryptNodePath.TABLES).getNameByActiveVersion(event.getKey());
- if (tableName.isPresent() && !Strings.isNullOrEmpty(event.getValue()))
{
- return createEncryptConfigEvent(databaseName, tableName.get(),
event);
+ if (tableName.isPresent()) {
+ return Optional.of(createEncryptConfigEvent(databaseName,
tableName.get(), event));
}
Optional<String> encryptorName =
encryptRuleNodePath.getNamedItem(EncryptNodePath.ENCRYPTORS).getNameByActiveVersion(event.getKey());
- if (encryptorName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createEncryptorEvent(databaseName, encryptorName.get(),
event);
- }
- return Optional.empty();
+ return encryptorName.flatMap(optional ->
Optional.of(createEncryptorEvent(databaseName, optional, event)));
}
- private Optional<GovernanceEvent> createEncryptConfigEvent(final String
databaseName, final String groupName, final DataChangedEvent event) {
+ private GovernanceEvent createEncryptConfigEvent(final String
databaseName, final String groupName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new AddEncryptTableEvent(databaseName,
event.getKey(), event.getValue()));
+ return new AddEncryptTableEvent(databaseName, event.getKey(),
event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new AlterEncryptTableEvent(databaseName,
groupName, event.getKey(), event.getValue()));
+ return new AlterEncryptTableEvent(databaseName, groupName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteEncryptTableEvent(databaseName,
groupName));
+ return new DeleteEncryptTableEvent(databaseName, groupName);
}
- private Optional<GovernanceEvent> createEncryptorEvent(final String
databaseName, final String encryptorName, final DataChangedEvent event) {
+ private GovernanceEvent createEncryptorEvent(final String databaseName,
final String encryptorName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new AlterEncryptorEvent(databaseName,
encryptorName, event.getKey(), event.getValue()));
+ return new AlterEncryptorEvent(databaseName, encryptorName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteEncryptorEvent(databaseName,
encryptorName));
+ return new DeleteEncryptorEvent(databaseName, encryptorName);
}
}
diff --git
a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/event/MaskRuleConfigurationEventBuilder.java
b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/event/MaskRuleConfigurationEventBuilder.java
index d1dc39a1c9d..63b54778097 100644
---
a/features/mask/core/src/main/java/org/apache/shardingsphere/mask/event/MaskRuleConfigurationEventBuilder.java
+++
b/features/mask/core/src/main/java/org/apache/shardingsphere/mask/event/MaskRuleConfigurationEventBuilder.java
@@ -45,30 +45,27 @@ public final class MaskRuleConfigurationEventBuilder
implements RuleConfiguratio
return Optional.empty();
}
Optional<String> tableName =
maskRuleNodePath.getNamedItem(MaskNodePath.TABLES).getNameByActiveVersion(event.getKey());
- if (tableName.isPresent() && !Strings.isNullOrEmpty(event.getValue()))
{
- return createMaskConfigEvent(databaseName, tableName.get(), event);
+ if (tableName.isPresent()) {
+ return Optional.of(createMaskConfigEvent(databaseName,
tableName.get(), event));
}
Optional<String> algorithmName =
maskRuleNodePath.getNamedItem(MaskNodePath.ALGORITHMS).getNameByActiveVersion(event.getKey());
- if (algorithmName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createMaskAlgorithmEvent(databaseName, algorithmName.get(),
event);
- }
- return Optional.empty();
+ return algorithmName.flatMap(optional ->
Optional.of(createMaskAlgorithmEvent(databaseName, optional, event)));
}
- private Optional<GovernanceEvent> createMaskConfigEvent(final String
databaseName, final String tableName, final DataChangedEvent event) {
+ private GovernanceEvent createMaskConfigEvent(final String databaseName,
final String tableName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new AddMaskTableEvent(databaseName,
event.getKey(), event.getValue()));
+ return new AddMaskTableEvent(databaseName, event.getKey(),
event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new AlterMaskTableEvent(databaseName,
tableName, event.getKey(), event.getValue()));
+ return new AlterMaskTableEvent(databaseName, tableName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteMaskTableEvent(databaseName, tableName));
+ return new DeleteMaskTableEvent(databaseName, tableName);
}
- private Optional<GovernanceEvent> createMaskAlgorithmEvent(final String
databaseName, final String algorithmName, final DataChangedEvent event) {
+ private GovernanceEvent createMaskAlgorithmEvent(final String
databaseName, final String algorithmName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new AlterMaskAlgorithmEvent(databaseName,
algorithmName, event.getKey(), event.getValue()));
+ return new AlterMaskAlgorithmEvent(databaseName, algorithmName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteMaskAlgorithmEvent(databaseName,
algorithmName));
+ return new DeleteMaskAlgorithmEvent(databaseName, algorithmName);
}
}
diff --git
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/event/ReadwriteSplittingRuleConfigurationEventBuilder.java
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/event/ReadwriteSplittingRuleConfigurationEventBuilder.java
index bed2dfb9ee2..a8e2a7416a4 100644
---
a/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/event/ReadwriteSplittingRuleConfigurationEventBuilder.java
+++
b/features/readwrite-splitting/core/src/main/java/org/apache/shardingsphere/readwritesplitting/event/ReadwriteSplittingRuleConfigurationEventBuilder.java
@@ -45,30 +45,27 @@ public final class
ReadwriteSplittingRuleConfigurationEventBuilder implements Ru
return Optional.empty();
}
Optional<String> groupName =
readwriteSplittingRuleNodePath.getNamedItem(ReadwriteSplittingNodePath.DATA_SOURCES).getNameByActiveVersion(event.getKey());
- if (groupName.isPresent() && !Strings.isNullOrEmpty(event.getValue()))
{
- return createReadwriteSplittingConfigEvent(databaseName,
groupName.get(), event);
+ if (groupName.isPresent()) {
+ return
Optional.of(createReadwriteSplittingConfigEvent(databaseName, groupName.get(),
event));
}
Optional<String> loadBalancerName =
readwriteSplittingRuleNodePath.getNamedItem(ReadwriteSplittingNodePath.LOAD_BALANCERS).getNameByActiveVersion(event.getKey());
- if (loadBalancerName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createLoadBalanceEvent(databaseName,
loadBalancerName.get(), event);
- }
- return Optional.empty();
+ return loadBalancerName.flatMap(optional ->
Optional.of(createLoadBalanceEvent(databaseName, optional, event)));
}
- private Optional<GovernanceEvent>
createReadwriteSplittingConfigEvent(final String databaseName, final String
groupName, final DataChangedEvent event) {
+ private GovernanceEvent createReadwriteSplittingConfigEvent(final String
databaseName, final String groupName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddReadwriteSplittingDataSourceEvent(databaseName, groupName, event.getKey(),
event.getValue()));
+ return new AddReadwriteSplittingDataSourceEvent(databaseName,
groupName, event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterReadwriteSplittingDataSourceEvent(databaseName, groupName, event.getKey(),
event.getValue()));
+ return new AlterReadwriteSplittingDataSourceEvent(databaseName,
groupName, event.getKey(), event.getValue());
}
- return Optional.of(new
DeleteReadwriteSplittingDataSourceEvent(databaseName, groupName));
+ return new DeleteReadwriteSplittingDataSourceEvent(databaseName,
groupName);
}
- private Optional<GovernanceEvent> createLoadBalanceEvent(final String
databaseName, final String loadBalancerName, final DataChangedEvent event) {
+ private GovernanceEvent createLoadBalanceEvent(final String databaseName,
final String loadBalancerName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new AlterLoadBalanceEvent(databaseName,
loadBalancerName, event.getKey(), event.getValue()));
+ return new AlterLoadBalanceEvent(databaseName, loadBalancerName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteLoadBalanceEvent(databaseName,
loadBalancerName));
+ return new DeleteLoadBalanceEvent(databaseName, loadBalancerName);
}
}
diff --git
a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/event/ShadowRuleConfigurationEventBuilder.java
b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/event/ShadowRuleConfigurationEventBuilder.java
index 599522d60ec..853fa486dd7 100644
---
a/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/event/ShadowRuleConfigurationEventBuilder.java
+++
b/features/shadow/core/src/main/java/org/apache/shardingsphere/shadow/event/ShadowRuleConfigurationEventBuilder.java
@@ -50,54 +50,54 @@ public final class ShadowRuleConfigurationEventBuilder
implements RuleConfigurat
return Optional.empty();
}
Optional<String> dataSourceName =
shadowRuleNodePath.getNamedItem(ShadowNodePath.DATA_SOURCES).getNameByActiveVersion(event.getKey());
- if (dataSourceName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createShadowConfigEvent(databaseName, dataSourceName.get(),
event);
+ if (dataSourceName.isPresent()) {
+ return Optional.of(createShadowConfigEvent(databaseName,
dataSourceName.get(), event));
}
Optional<String> tableName =
shadowRuleNodePath.getNamedItem(ShadowNodePath.TABLES).getNameByActiveVersion(event.getKey());
- if (tableName.isPresent() && !Strings.isNullOrEmpty(event.getValue()))
{
- return createShadowTableConfigEvent(databaseName, tableName.get(),
event);
+ if (tableName.isPresent()) {
+ return Optional.of(createShadowTableConfigEvent(databaseName,
tableName.get(), event));
}
Optional<String> algorithmName =
shadowRuleNodePath.getNamedItem(ShadowNodePath.ALGORITHMS).getNameByActiveVersion(event.getKey());
- if (algorithmName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createShadowAlgorithmEvent(databaseName,
algorithmName.get(), event);
+ if (algorithmName.isPresent()) {
+ return Optional.of(createShadowAlgorithmEvent(databaseName,
algorithmName.get(), event));
}
- if
(shadowRuleNodePath.getUniqueItem(ShadowNodePath.DEFAULT_ALGORITHM).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return createDefaultShadowAlgorithmNameEvent(databaseName, event);
+ if
(shadowRuleNodePath.getUniqueItem(ShadowNodePath.DEFAULT_ALGORITHM).isActiveVersionPath(event.getKey()))
{
+ return
Optional.of(createDefaultShadowAlgorithmNameEvent(databaseName, event));
}
return Optional.empty();
}
- private Optional<GovernanceEvent> createShadowConfigEvent(final String
databaseName, final String dataSourceName, final DataChangedEvent event) {
+ private GovernanceEvent createShadowConfigEvent(final String databaseName,
final String dataSourceName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new AddShadowDataSourceEvent(databaseName,
dataSourceName, event.getKey(), event.getValue()));
+ return new AddShadowDataSourceEvent(databaseName, dataSourceName,
event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new AlterShadowDataSourceEvent(databaseName,
dataSourceName, event.getKey(), event.getValue()));
+ return new AlterShadowDataSourceEvent(databaseName,
dataSourceName, event.getKey(), event.getValue());
}
- return Optional.of(new DeleteShadowDataSourceEvent(databaseName,
dataSourceName));
+ return new DeleteShadowDataSourceEvent(databaseName, dataSourceName);
}
- private Optional<GovernanceEvent> createShadowTableConfigEvent(final
String databaseName, final String tableName, final DataChangedEvent event) {
+ private GovernanceEvent createShadowTableConfigEvent(final String
databaseName, final String tableName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new AddShadowTableEvent(databaseName,
tableName, event.getKey(), event.getValue()));
+ return new AddShadowTableEvent(databaseName, tableName,
event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new AlterShadowTableEvent(databaseName,
tableName, event.getKey(), event.getValue()));
+ return new AlterShadowTableEvent(databaseName, tableName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteShadowTableEvent(databaseName,
tableName));
+ return new DeleteShadowTableEvent(databaseName, tableName);
}
- private Optional<GovernanceEvent> createShadowAlgorithmEvent(final String
databaseName, final String algorithmName, final DataChangedEvent event) {
+ private GovernanceEvent createShadowAlgorithmEvent(final String
databaseName, final String algorithmName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new AlterShadowAlgorithmEvent(databaseName,
algorithmName, event.getKey(), event.getValue()));
+ return new AlterShadowAlgorithmEvent(databaseName, algorithmName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteShadowAlgorithmEvent(databaseName,
algorithmName));
+ return new DeleteShadowAlgorithmEvent(databaseName, algorithmName);
}
- private Optional<GovernanceEvent>
createDefaultShadowAlgorithmNameEvent(final String databaseName, final
DataChangedEvent event) {
+ private GovernanceEvent createDefaultShadowAlgorithmNameEvent(final String
databaseName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterDefaultShadowAlgorithmNameEvent(databaseName, event.getKey(),
event.getValue()));
+ return new AlterDefaultShadowAlgorithmNameEvent(databaseName,
event.getKey(), event.getValue());
}
- return Optional.of(new
DeleteDefaultShadowAlgorithmNameEvent(databaseName));
+ return new DeleteDefaultShadowAlgorithmNameEvent(databaseName);
}
}
diff --git
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/event/ShardingRuleConfigurationEventBuilder.java
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/event/ShardingRuleConfigurationEventBuilder.java
index 2c75f39c242..2428b5b549e 100644
---
a/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/event/ShardingRuleConfigurationEventBuilder.java
+++
b/features/sharding/core/src/main/java/org/apache/shardingsphere/sharding/event/ShardingRuleConfigurationEventBuilder.java
@@ -50,6 +50,9 @@ import
org.apache.shardingsphere.sharding.event.strategy.table.DeleteTableShardi
import
org.apache.shardingsphere.sharding.event.table.auto.AddShardingAutoTableConfigurationEvent;
import
org.apache.shardingsphere.sharding.event.table.auto.AlterShardingAutoTableConfigurationEvent;
import
org.apache.shardingsphere.sharding.event.table.auto.DeleteShardingAutoTableConfigurationEvent;
+import
org.apache.shardingsphere.sharding.event.table.binding.AddShardingTableReferenceConfigurationEvent;
+import
org.apache.shardingsphere.sharding.event.table.binding.AlterShardingTableReferenceConfigurationEvent;
+import
org.apache.shardingsphere.sharding.event.table.binding.DeleteShardingTableReferenceConfigurationEvent;
import
org.apache.shardingsphere.sharding.event.table.sharding.AddShardingTableConfigurationEvent;
import
org.apache.shardingsphere.sharding.event.table.sharding.AlterShardingTableConfigurationEvent;
import
org.apache.shardingsphere.sharding.event.table.sharding.DeleteShardingTableConfigurationEvent;
@@ -70,158 +73,158 @@ public final class ShardingRuleConfigurationEventBuilder
implements RuleConfigur
return Optional.empty();
}
Optional<String> tableName =
shardingRuleNodePath.getNamedItem(ShardingNodePath.TABLES).getNameByActiveVersion(event.getKey());
- if (tableName.isPresent() && !Strings.isNullOrEmpty(event.getValue()))
{
- return createShardingTableConfigEvent(databaseName,
tableName.get(), event);
+ if (tableName.isPresent()) {
+ return Optional.of(createShardingTableConfigEvent(databaseName,
tableName.get(), event));
}
Optional<String> autoTableName =
shardingRuleNodePath.getNamedItem(ShardingNodePath.AUTO_TABLES).getNameByActiveVersion(event.getKey());
- if (autoTableName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createShardingAutoTableConfigEvent(databaseName,
autoTableName.get(), event);
+ if (autoTableName.isPresent()) {
+ return
Optional.of(createShardingAutoTableConfigEvent(databaseName,
autoTableName.get(), event));
}
Optional<String> bindingTableName =
shardingRuleNodePath.getNamedItem(ShardingNodePath.BINDING_TABLES).getNameByActiveVersion(event.getKey());
- if (bindingTableName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createShardingTableReferenceConfigEvent(databaseName,
bindingTableName.get(), event);
+ if (bindingTableName.isPresent()) {
+ return
Optional.of(createShardingTableReferenceConfigEvent(databaseName,
bindingTableName.get(), event));
}
- if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_DATABASE_STRATEGY).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return createDefaultDatabaseStrategyConfigEvent(databaseName,
event);
+ if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_DATABASE_STRATEGY).isActiveVersionPath(event.getKey()))
{
+ return
Optional.of(createDefaultDatabaseStrategyConfigEvent(databaseName, event));
}
- if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_TABLE_STRATEGY).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return createDefaultTableStrategyConfigEvent(databaseName, event);
+ if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_TABLE_STRATEGY).isActiveVersionPath(event.getKey()))
{
+ return
Optional.of(createDefaultTableStrategyConfigEvent(databaseName, event));
}
- if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_KEY_GENERATE_STRATEGY).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return createDefaultKeyGenerateStrategyConfigEvent(databaseName,
event);
+ if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_KEY_GENERATE_STRATEGY).isActiveVersionPath(event.getKey()))
{
+ return
Optional.of(createDefaultKeyGenerateStrategyConfigEvent(databaseName, event));
}
- if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_AUDIT_STRATEGY).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return
createDefaultShardingAuditorStrategyConfigEvent(databaseName, event);
+ if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_AUDIT_STRATEGY).isActiveVersionPath(event.getKey()))
{
+ return
Optional.of(createDefaultShardingAuditorStrategyConfigEvent(databaseName,
event));
}
- if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_SHARDING_COLUMN).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return createDefaultShardingColumnEvent(databaseName, event);
+ if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.DEFAULT_SHARDING_COLUMN).isActiveVersionPath(event.getKey()))
{
+ return Optional.of(createDefaultShardingColumnEvent(databaseName,
event));
}
Optional<String> algorithmName =
shardingRuleNodePath.getNamedItem(ShardingNodePath.ALGORITHMS).getNameByActiveVersion(event.getKey());
- if (algorithmName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createShardingAlgorithmEvent(databaseName,
algorithmName.get(), event);
+ if (algorithmName.isPresent()) {
+ return Optional.of(createShardingAlgorithmEvent(databaseName,
algorithmName.get(), event));
}
Optional<String> keyGeneratorName =
shardingRuleNodePath.getNamedItem(ShardingNodePath.KEY_GENERATORS).getNameByActiveVersion(event.getKey());
- if (keyGeneratorName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createKeyGeneratorEvent(databaseName,
keyGeneratorName.get(), event);
+ if (keyGeneratorName.isPresent()) {
+ return Optional.of(createKeyGeneratorEvent(databaseName,
keyGeneratorName.get(), event));
}
Optional<String> auditorName =
shardingRuleNodePath.getNamedItem(ShardingNodePath.AUDITORS).getNameByActiveVersion(event.getKey());
- if (auditorName.isPresent() &&
!Strings.isNullOrEmpty(event.getValue())) {
- return createAuditorEvent(databaseName, auditorName.get(), event);
+ if (auditorName.isPresent()) {
+ return Optional.of(createAuditorEvent(databaseName,
auditorName.get(), event));
}
- if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.SHARDING_CACHE).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return createShardingCacheEvent(databaseName, event);
+ if
(shardingRuleNodePath.getUniqueItem(ShardingNodePath.SHARDING_CACHE).isActiveVersionPath(event.getKey()))
{
+ return Optional.of(createShardingCacheEvent(databaseName, event));
}
return Optional.empty();
}
- private Optional<GovernanceEvent> createShardingTableConfigEvent(final
String databaseName, final String tableName, final DataChangedEvent event) {
+ private GovernanceEvent createShardingTableConfigEvent(final String
databaseName, final String tableName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddShardingTableConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new AddShardingTableConfigurationEvent(databaseName,
event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterShardingTableConfigurationEvent(databaseName, tableName, event.getKey(),
event.getValue()));
+ return new AlterShardingTableConfigurationEvent(databaseName,
tableName, event.getKey(), event.getValue());
}
- return Optional.of(new
DeleteShardingTableConfigurationEvent(databaseName, tableName));
+ return new DeleteShardingTableConfigurationEvent(databaseName,
tableName);
}
- private Optional<GovernanceEvent> createShardingAutoTableConfigEvent(final
String databaseName, final String tableName, final DataChangedEvent event) {
+ private GovernanceEvent createShardingAutoTableConfigEvent(final String
databaseName, final String tableName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddShardingAutoTableConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new AddShardingAutoTableConfigurationEvent(databaseName,
event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterShardingAutoTableConfigurationEvent(databaseName, tableName,
event.getKey(), event.getValue()));
+ return new AlterShardingAutoTableConfigurationEvent(databaseName,
tableName, event.getKey(), event.getValue());
}
- return Optional.of(new
DeleteShardingAutoTableConfigurationEvent(databaseName, tableName));
+ return new DeleteShardingAutoTableConfigurationEvent(databaseName,
tableName);
}
- private Optional<GovernanceEvent>
createShardingTableReferenceConfigEvent(final String databaseName, final String
tableName, final DataChangedEvent event) {
+ private GovernanceEvent createShardingTableReferenceConfigEvent(final
String databaseName, final String tableName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddShardingAutoTableConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new
AddShardingTableReferenceConfigurationEvent(databaseName, event.getKey(),
event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterShardingAutoTableConfigurationEvent(databaseName, tableName,
event.getKey(), event.getValue()));
+ return new
AlterShardingTableReferenceConfigurationEvent(databaseName, tableName,
event.getKey(), event.getValue());
}
- return Optional.of(new
DeleteShardingAutoTableConfigurationEvent(databaseName, tableName));
+ return new
DeleteShardingTableReferenceConfigurationEvent(databaseName, tableName);
}
- private Optional<GovernanceEvent>
createDefaultDatabaseStrategyConfigEvent(final String databaseName, final
DataChangedEvent event) {
+ private GovernanceEvent createDefaultDatabaseStrategyConfigEvent(final
String databaseName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddDatabaseShardingStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new
AddDatabaseShardingStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterDatabaseShardingStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new
AlterDatabaseShardingStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue());
}
- return Optional.of(new
DeleteDatabaseShardingStrategyConfigurationEvent(databaseName));
+ return new
DeleteDatabaseShardingStrategyConfigurationEvent(databaseName);
}
- private Optional<GovernanceEvent>
createDefaultTableStrategyConfigEvent(final String databaseName, final
DataChangedEvent event) {
+ private GovernanceEvent createDefaultTableStrategyConfigEvent(final String
databaseName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddTableShardingStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new
AddTableShardingStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterTableShardingStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new
AlterTableShardingStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue());
}
- return Optional.of(new
DeleteTableShardingStrategyConfigurationEvent(databaseName));
+ return new DeleteTableShardingStrategyConfigurationEvent(databaseName);
}
- private Optional<GovernanceEvent>
createDefaultKeyGenerateStrategyConfigEvent(final String databaseName, final
DataChangedEvent event) {
+ private GovernanceEvent createDefaultKeyGenerateStrategyConfigEvent(final
String databaseName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddKeyGenerateStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new AddKeyGenerateStrategyConfigurationEvent(databaseName,
event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterKeyGenerateStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new
AlterKeyGenerateStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue());
}
- return Optional.of(new
DeleteKeyGenerateStrategyConfigurationEvent(databaseName));
+ return new DeleteKeyGenerateStrategyConfigurationEvent(databaseName);
}
- private Optional<GovernanceEvent>
createDefaultShardingAuditorStrategyConfigEvent(final String databaseName,
final DataChangedEvent event) {
+ private GovernanceEvent
createDefaultShardingAuditorStrategyConfigEvent(final String databaseName,
final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddShardingAuditorStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new
AddShardingAuditorStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterShardingAuditorStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new
AlterShardingAuditorStrategyConfigurationEvent(databaseName, event.getKey(),
event.getValue());
}
- return Optional.of(new
DeleteShardingAuditorStrategyConfigurationEvent(databaseName));
+ return new
DeleteShardingAuditorStrategyConfigurationEvent(databaseName);
}
- private Optional<GovernanceEvent> createDefaultShardingColumnEvent(final
String databaseName, final DataChangedEvent event) {
+ private GovernanceEvent createDefaultShardingColumnEvent(final String
databaseName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new AddDefaultShardingColumnEvent(databaseName,
event.getKey(), event.getValue()));
+ return new AddDefaultShardingColumnEvent(databaseName,
event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterDefaultShardingColumnEvent(databaseName, event.getKey(),
event.getValue()));
+ return new AlterDefaultShardingColumnEvent(databaseName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteDefaultShardingColumnEvent(databaseName));
+ return new DeleteDefaultShardingColumnEvent(databaseName);
}
- private Optional<GovernanceEvent> createShardingAlgorithmEvent(final
String databaseName, final String algorithmName, final DataChangedEvent event) {
+ private GovernanceEvent createShardingAlgorithmEvent(final String
databaseName, final String algorithmName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new AlterShardingAlgorithmEvent(databaseName,
algorithmName, event.getKey(), event.getValue()));
+ return new AlterShardingAlgorithmEvent(databaseName,
algorithmName, event.getKey(), event.getValue());
}
- return Optional.of(new DeleteShardingAlgorithmEvent(databaseName,
algorithmName));
+ return new DeleteShardingAlgorithmEvent(databaseName, algorithmName);
}
- private Optional<GovernanceEvent> createKeyGeneratorEvent(final String
databaseName, final String algorithmName, final DataChangedEvent event) {
+ private GovernanceEvent createKeyGeneratorEvent(final String databaseName,
final String algorithmName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new AlterKeyGeneratorEvent(databaseName,
algorithmName, event.getKey(), event.getValue()));
+ return new AlterKeyGeneratorEvent(databaseName, algorithmName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteKeyGeneratorEvent(databaseName,
algorithmName));
+ return new DeleteKeyGeneratorEvent(databaseName, algorithmName);
}
- private Optional<GovernanceEvent> createAuditorEvent(final String
databaseName, final String algorithmName, final DataChangedEvent event) {
+ private GovernanceEvent createAuditorEvent(final String databaseName,
final String algorithmName, final DataChangedEvent event) {
if (Type.ADDED == event.getType() || Type.UPDATED == event.getType()) {
- return Optional.of(new AlterAuditorEvent(databaseName,
algorithmName, event.getKey(), event.getValue()));
+ return new AlterAuditorEvent(databaseName, algorithmName,
event.getKey(), event.getValue());
}
- return Optional.of(new DeleteAuditorEvent(databaseName,
algorithmName));
+ return new DeleteAuditorEvent(databaseName, algorithmName);
}
- private Optional<GovernanceEvent> createShardingCacheEvent(final String
databaseName, final DataChangedEvent event) {
+ private GovernanceEvent createShardingCacheEvent(final String
databaseName, final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new
AddShardingCacheConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new AddShardingCacheConfigurationEvent(databaseName,
event.getKey(), event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new
AlterShardingCacheConfigurationEvent(databaseName, event.getKey(),
event.getValue()));
+ return new AlterShardingCacheConfigurationEvent(databaseName,
event.getKey(), event.getValue());
}
- return Optional.of(new
DeleteShardingCacheConfigurationEvent(databaseName));
+ return new DeleteShardingCacheConfigurationEvent(databaseName);
}
}
diff --git
a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/event/SingleRuleConfigurationEventBuilder.java
b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/event/SingleRuleConfigurationEventBuilder.java
index 6c4e9762371..ec1886a17ac 100644
---
a/kernel/single/core/src/main/java/org/apache/shardingsphere/single/event/SingleRuleConfigurationEventBuilder.java
+++
b/kernel/single/core/src/main/java/org/apache/shardingsphere/single/event/SingleRuleConfigurationEventBuilder.java
@@ -39,22 +39,18 @@ public final class SingleRuleConfigurationEventBuilder
implements RuleConfigurat
@Override
public Optional<GovernanceEvent> build(final String databaseName, final
DataChangedEvent event) {
- if (!singleRuleNodePath.getRoot().isValidatedPath(event.getKey()) ||
Strings.isNullOrEmpty(event.getValue())) {
- return Optional.empty();
- }
- if
(singleRuleNodePath.getUniqueItem(SingleNodePath.TABLES).isActiveVersionPath(event.getKey())
&& !Strings.isNullOrEmpty(event.getValue())) {
- return createSingleConfigEvent(databaseName, event);
- }
- return Optional.empty();
+ return Strings.isNullOrEmpty(event.getValue()) ||
!singleRuleNodePath.getUniqueItem(SingleNodePath.TABLES).isActiveVersionPath(event.getKey())
+ ? Optional.empty()
+ : Optional.of(createSingleConfigEvent(databaseName, event));
}
- private Optional<GovernanceEvent> createSingleConfigEvent(final String
databaseName, final DataChangedEvent event) {
+ private GovernanceEvent createSingleConfigEvent(final String databaseName,
final DataChangedEvent event) {
if (Type.ADDED == event.getType()) {
- return Optional.of(new AddSingleTableEvent(databaseName,
event.getKey(), event.getValue()));
+ return new AddSingleTableEvent(databaseName, event.getKey(),
event.getValue());
}
if (Type.UPDATED == event.getType()) {
- return Optional.of(new AlterSingleTableEvent(databaseName,
event.getKey(), event.getValue()));
+ return new AlterSingleTableEvent(databaseName, event.getKey(),
event.getValue());
}
- return Optional.of(new DeleteSingleTableEvent(databaseName));
+ return new DeleteSingleTableEvent(databaseName);
}
}
