diff --git a/frameworks/bridge/declarative_frontend/jsview/js_badge.cpp b/frameworks/bridge/declarative_frontend/jsview/js_badge.cpp
index 601e199f382ccba6727a5e7f6b49f9a1afd3c11f..0833130a278ac376f66dfdf39a61e2710f4d88fc 100644
--- a/frameworks/bridge/declarative_frontend/jsview/js_badge.cpp
+++ b/frameworks/bridge/declarative_frontend/jsview/js_badge.cpp
@@ -109,6 +109,8 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
             bool yState = ParseJsDimensionVp(yVal, dimenY, resObjY);
             badgeParameters.resourceBadgePositionXObject = resObjX;
             badgeParameters.resourceBadgePositionYObject = resObjY;
+            badgeParameters.badgePositionXByUser = true;
+            badgeParameters.badgePositionYByUser = true;
             bool hasX = resObjX || xState;
             bool hasY = resObjY || yState;
             if (!(hasX || hasY)) {
@@ -116,6 +118,8 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
                 badgeParameters.badgePositionY = badgeTheme->GetBadgePositionY();
                 badgeParameters.resourceBadgePositionXObject = nullptr;
                 badgeParameters.resourceBadgePositionYObject = nullptr;
+                badgeParameters.badgePositionXByUser = false;
+                badgeParameters.badgePositionYByUser = false;
             }
         } else {
             bool xResult = ParseJsDimensionVp(xVal, dimenX);
@@ -147,6 +151,7 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
         Color colorVal;
         if (SystemProperties::ConfigChangePerform()) {
             RefPtr<ResourceObject> resObj;
+            badgeParameters.badgeTextColorByUser = true;
             bool state = ParseJsColor(colorValue, colorVal, resObj);
             if (resObj) {
                 badgeParameters.resourceColorObject = resObj;
@@ -154,6 +159,7 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
                 badgeParameters.badgeTextColor = colorVal;
             } else if (themeColors) {
                 badgeParameters.badgeTextColor = themeColors->FontOnPrimary();
+                badgeParameters.badgeTextColorByUser = false;
             }
         } else {
             if (ParseJsColor(colorValue, colorVal)) {
@@ -166,6 +172,7 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
         CalcDimension fontSize;
         if (SystemProperties::ConfigChangePerform()) {
             RefPtr<ResourceObject> resObj;
+            badgeParameters.badgeFontSizeByUser = true;
             bool state = ParseJsDimensionNG(fontSizeValue, fontSize, DimensionUnit::FP, resObj);
             if (resObj) {
                 badgeParameters.resourceFontSizeObject = resObj;
@@ -173,6 +180,7 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
                 badgeParameters.badgeFontSize = fontSize;
                 isDefaultFontSize = false;
             } else {
+                badgeParameters.badgeFontSizeByUser = false;
                 badgeParameters.badgeFontSize =
                     !fontSizeValue->IsUndefined() ? badgeTheme->GetBadgeFontSize() : UNDEFINED_DIMENSION;
             }
@@ -191,6 +199,7 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
         CalcDimension badgeSize;
         if (SystemProperties::ConfigChangePerform()) {
             RefPtr<ResourceObject> resObj;
+            badgeParameters.badgeCircleSizeByUser = true;
             bool state = ParseJsDimensionNG(badgeSizeValue, badgeSize, DimensionUnit::FP, resObj);
             if (resObj) {
                 badgeParameters.resourceBadgeSizeObject = resObj;
@@ -199,10 +208,11 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
                 isDefaultBadgeSize = false;
             } else {
                 badgeParameters.badgeCircleSize = badgeTheme->GetBadgeCircleSize();
+                badgeParameters.badgeCircleSizeByUser = false;
             }
         } else {
-            if (ParseJsDimensionNG(badgeSizeValue, badgeSize, DimensionUnit::FP) &&
-                badgeSize.IsNonNegative() && badgeSize.Unit() != DimensionUnit::PERCENT) {
+            if (ParseJsDimensionNG(badgeSizeValue, badgeSize, DimensionUnit::FP) && badgeSize.IsNonNegative() &&
+                badgeSize.Unit() != DimensionUnit::PERCENT) {
                 badgeParameters.badgeCircleSize = badgeSize;
                 isDefaultBadgeSize = false;
             } else {
@@ -214,11 +224,14 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
         Color color;
         if (SystemProperties::ConfigChangePerform()) {
             RefPtr<ResourceObject> badgeColorResObj;
+            badgeParameters.badgeColorByUser = false;
             bool state = ParseJsColor(badgeColorValue, color, badgeColorResObj);
             if (badgeColorResObj) {
                 badgeParameters.resourceBadgeColorObject = badgeColorResObj;
+                badgeParameters.badgeColorByUser = true;
             } else if (state) {
                 badgeParameters.badgeColor = color;
+                badgeParameters.badgeColorByUser = true;
             } else if (themeColors) {
                 badgeParameters.badgeColor = themeColors->Warning();
             }
@@ -233,14 +246,15 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
 
         if (SystemProperties::ConfigChangePerform()) {
             RefPtr<ResourceObject> resObj;
+            badgeParameters.badgeBorderWidthByUser = true;
             bool state = ParseJsDimensionVp(borderWidthValue, borderWidth, resObj);
             if (resObj) {
                 badgeParameters.resourceBorderWidthObject = resObj;
+            } else if (state && borderWidth.IsNonNegative() && borderWidth.Unit() != DimensionUnit::PERCENT) {
+                badgeParameters.badgeBorderWidth = borderWidth;
             } else {
-                badgeParameters.badgeBorderWidth =
-                    (state && borderWidth.IsNonNegative() && borderWidth.Unit() != DimensionUnit::PERCENT)
-                        ? borderWidth
-                        : badgeTheme->GetBadgeBorderWidth();
+                badgeParameters.badgeBorderWidth = badgeTheme->GetBadgeBorderWidth();
+                badgeParameters.badgeBorderWidthByUser = false;
             }
         } else {
             if (ParseJsDimensionVp(borderWidthValue, borderWidth) && borderWidth.IsNonNegative() &&
@@ -253,11 +267,14 @@ BadgeParameters JSBadge::CreateBadgeParameters(const JSCallbackInfo& info)
         Color borderColor;
         if (SystemProperties::ConfigChangePerform()) {
             RefPtr<ResourceObject> borderColorResObj;
+            badgeParameters.badgeBorderColorByUser = false;
             bool state = ParseJsColor(borderColorValue, borderColor, borderColorResObj);
             if (borderColorResObj) {
                 badgeParameters.resourceBorderColorObject = borderColorResObj;
+                badgeParameters.badgeBorderColorByUser = true;
             } else if (state) {
                 badgeParameters.badgeBorderColor = borderColor;
+                badgeParameters.badgeBorderColorByUser = true;
             } else {
                 badgeParameters.badgeBorderColor =
                     themeColors ? themeColors->Warning() : badgeTheme->GetBadgeBorderColor();
diff --git a/frameworks/core/components_ng/pattern/badge/badge_data.h b/frameworks/core/components_ng/pattern/badge/badge_data.h
index 76bba15669afa68c56349dd181dca9e9eade9d01..e4e33eb1836936f58119cc3b6970bba864b1182b 100644
--- a/frameworks/core/components_ng/pattern/badge/badge_data.h
+++ b/frameworks/core/components_ng/pattern/badge/badge_data.h
@@ -53,6 +53,15 @@ struct BadgeParameters {
     RefPtr<ResourceObject> resourceBadgePositionXObject;
     RefPtr<ResourceObject> resourceBadgePositionYObject;
     RefPtr<ResourceObject> resourceBorderWidthObject;
+    
+    bool badgePositionXByUser = false;
+    bool badgePositionYByUser = false;
+    bool badgeTextColorByUser = false;
+    bool badgeFontSizeByUser = false;
+    bool badgeCircleSizeByUser = false;
+    bool badgeColorByUser = false;
+    bool badgeBorderWidthByUser = false;
+    bool badgeBorderColorByUser = false;
 };
 } // namespace OHOS::Ace
 
diff --git a/frameworks/core/components_ng/pattern/badge/badge_layout_property.h b/frameworks/core/components_ng/pattern/badge/badge_layout_property.h
index de4e9a97cf16f9ff170f3d85b05b590696658864..4d582d69226e34d9b644b28c3023bd6a66cd496b 100644
--- a/frameworks/core/components_ng/pattern/badge/badge_layout_property.h
+++ b/frameworks/core/components_ng/pattern/badge/badge_layout_property.h
@@ -132,6 +132,16 @@ public:
     ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeFontWeight, FontWeight, PROPERTY_UPDATE_MEASURE);
     ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeBorderWidth, Dimension, PROPERTY_UPDATE_MEASURE);
 
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgePositionXByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgePositionYByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeColorByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeTextColorByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeCircleSizeByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeFontSizeByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeBorderColorByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeBorderWidthByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+    ACE_DEFINE_PROPERTY_ITEM_WITHOUT_GROUP(BadgeFontWeightByuser, bool, PROPERTY_UPDATE_MEASURE_SELF);
+
 private:
     double badgeCircleRadius_;
     bool isDefaultFontSize_;
diff --git a/frameworks/core/components_ng/pattern/badge/badge_model_ng.cpp b/frameworks/core/components_ng/pattern/badge/badge_model_ng.cpp
index 4d4b969e5a84d66181d619813fce49f07eb269b0..c77562d1a44b260bb51ac21d4a6d521ead7686dc 100644
--- a/frameworks/core/components_ng/pattern/badge/badge_model_ng.cpp
+++ b/frameworks/core/components_ng/pattern/badge/badge_model_ng.cpp
@@ -73,6 +73,7 @@ void BadgeModelNG::Create(BadgeParameters& badgeParameters)
     UpdateBadgeStyle(badgeParameters, frameNode);
     if (SystemProperties::ConfigChangePerform()) {
         CreateWithResourceObj(frameNode, badgeParameters);
+        CreateWithResourceObjFlag(frameNode, badgeParameters);
     }
 }
 
@@ -188,49 +189,55 @@ void BadgeModelNG::CreateWithResourceObj(const RefPtr<FrameNode>& frameNode, Bad
     ProcessBorderWidth(badgePattern, badgeParameters.resourceBorderWidthObject);
 }
 
+void BadgeModelNG::CreateWithResourceObjFlag(const RefPtr<FrameNode>& frameNode, BadgeParameters& badgeParameters)
+{
+    auto layoutProperty = frameNode->GetLayoutProperty<BadgeLayoutProperty>();
+    CHECK_NULL_VOID(layoutProperty);
+    layoutProperty->UpdateBadgePositionXByuser(badgeParameters.badgePositionXByUser);
+    layoutProperty->UpdateBadgePositionYByuser(badgeParameters.badgePositionYByUser);
+    layoutProperty->UpdateBadgeTextColorByuser(badgeParameters.badgeTextColorByUser);
+    layoutProperty->UpdateBadgeFontSizeByuser(badgeParameters.badgeFontSizeByUser);
+    layoutProperty->UpdateBadgeCircleSizeByuser(badgeParameters.badgeCircleSizeByUser);
+    layoutProperty->UpdateBadgeColorByuser(badgeParameters.badgeColorByUser);
+    layoutProperty->UpdateBadgeBorderWidthByuser(badgeParameters.badgeBorderWidthByUser);
+    layoutProperty->UpdateBadgeBorderColorByuser(badgeParameters.badgeBorderColorByUser);
+}
+
 void BadgeModelNG::ProcessBadgeValue(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    const std::string key = "badge.badgeValue";
+    badgePattern->RemoveResObj(key);
     if (!resourceObject) {
         return;
     }
     auto updateFunc = [badgePattern](const RefPtr<ResourceObject>& resObj, bool isFirstLoad = false) {
-        std::string key = "badge.badgeValue";
-        std::string badgeValue = badgePattern->GetResCacheMapByKey(key);
-        if (badgeValue.empty()) {
-            ResourceParseUtils::ParseResString(resObj, badgeValue);
-            badgePattern->AddResCache(key, badgeValue);
-        }
+        std::string badgeValue;
+        ResourceParseUtils::ParseResString(resObj, badgeValue);
         if (!badgeValue.empty()) {
             badgePattern->UpdateBadgeValue(badgeValue, isFirstLoad);
         }
     };
     updateFunc(resourceObject, true);
-    badgePattern->AddResObj("badge.badgeValue", resourceObject, std::move(updateFunc));
+    badgePattern->AddResObj(key, resourceObject, std::move(updateFunc));
 }
 
 void BadgeModelNG::ProcessBadgeTextColor(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    const std::string key = "badge.textColor";
+    badgePattern->RemoveResObj(key);
     if (!resourceObject) {
         return;
     }
     auto updateFunc = [badgePattern](const RefPtr<ResourceObject>& resObj, bool isFirstLoad = false) {
-        std::string key = "badge.textColor";
-        std::string cachedColor = badgePattern->GetResCacheMapByKey(key);
         Color result;
-        if (cachedColor.empty()) {
-            bool state = ResourceParseUtils::ParseResColor(resObj, result);
-            if (state) {
-                badgePattern->AddResCache(key, result.ColorToString());
-            } else {
-                auto pipeline = PipelineBase::GetCurrentContext();
-                CHECK_NULL_VOID(pipeline);
-                auto badgeTheme = pipeline->GetTheme<BadgeTheme>();
-                result = badgeTheme->GetBadgeTextColor();
-            }
-        } else {
-            result = Color::ColorFromString(cachedColor);
+        bool state = ResourceParseUtils::ParseResColor(resObj, result);
+        if (!state) {
+            auto pipeline = PipelineBase::GetCurrentContext();
+            CHECK_NULL_VOID(pipeline);
+            auto badgeTheme = pipeline->GetTheme<BadgeTheme>();
+            result = badgeTheme->GetBadgeTextColor();
         }
         badgePattern->UpdateColor(result, isFirstLoad);
     };
@@ -241,25 +248,19 @@ void BadgeModelNG::ProcessBadgeTextColor(
 void BadgeModelNG::ProcessBadgeColor(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    const std::string key = "badge.Color";
+    badgePattern->RemoveResObj(key);
     if (!resourceObject) {
         return;
     }
     auto updateFunc = [badgePattern](const RefPtr<ResourceObject>& resObj, bool isFirstLoad = false) {
-        std::string key = "badge.Color";
-        std::string cachedColor = badgePattern->GetResCacheMapByKey(key);
         Color result;
-        if (cachedColor.empty()) {
-            bool state = ResourceParseUtils::ParseResColor(resObj, result);
-            if (state) {
-                badgePattern->AddResCache(key, result.ColorToString());
-            } else {
-                auto pipeline = PipelineBase::GetCurrentContext();
-                CHECK_NULL_VOID(pipeline);
-                auto badgeTheme = pipeline->GetTheme<BadgeTheme>();
-                result = badgeTheme->GetBadgeColor();
-            }
-        } else {
-            result = Color::ColorFromString(cachedColor);
+        bool state = ResourceParseUtils::ParseResColor(resObj, result);
+        if (!state) {
+            auto pipeline = PipelineBase::GetCurrentContext();
+            CHECK_NULL_VOID(pipeline);
+            auto badgeTheme = pipeline->GetTheme<BadgeTheme>();
+            result = badgeTheme->GetBadgeColor();
         }
         badgePattern->UpdateBadgeColor(result, isFirstLoad);
     };
@@ -270,25 +271,19 @@ void BadgeModelNG::ProcessBadgeColor(
 void BadgeModelNG::ProcessBorderColor(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    const std::string key = "badge.BorderColor";
+    badgePattern->RemoveResObj(key);
     if (!resourceObject) {
         return;
     }
     auto updateFunc = [badgePattern](const RefPtr<ResourceObject>& resObj, bool isFirstLoad = false) {
-        std::string key = "badge.BorderColor";
-        std::string cachedBorderColor = badgePattern->GetResCacheMapByKey(key);
         Color result;
-        if (cachedBorderColor.empty()) {
-            bool state = ResourceParseUtils::ParseResColor(resObj, result);
-            if (state) {
-                badgePattern->AddResCache(key, result.ColorToString());
-            } else {
-                auto pipeline = PipelineBase::GetCurrentContext();
-                CHECK_NULL_VOID(pipeline);
-                auto badgeTheme = pipeline->GetTheme<BadgeTheme>();
-                result = badgeTheme->GetBadgeBorderColor();
-            }
-        } else {
-            result = Color::ColorFromString(cachedBorderColor);
+        bool state = ResourceParseUtils::ParseResColor(resObj, result);
+        if (!state) {
+            auto pipeline = PipelineBase::GetCurrentContext();
+            CHECK_NULL_VOID(pipeline);
+            auto badgeTheme = pipeline->GetTheme<BadgeTheme>();
+            result = badgeTheme->GetBadgeBorderColor();
         }
         badgePattern->UpdateBorderColor(result, isFirstLoad);
     };
@@ -299,23 +294,16 @@ void BadgeModelNG::ProcessBorderColor(
 void BadgeModelNG::ProcessFontWeight(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    const std::string key = "badge.FontWeight";
+    badgePattern->RemoveResObj(key);
     if (!resourceObject) {
         return;
     }
     auto updateFunc = [badgePattern](const RefPtr<ResourceObject>& resObj, bool isFirstLoad = false) {
-        std::string key = "badge.FontWeight";
         std::optional<FontWeight> badgeFontWeight;
-        std::string cachedFontWeight = badgePattern->GetResCacheMapByKey(key);
         std::string result;
-        if (cachedFontWeight.empty()) {
-            bool state = ResourceParseUtils::ParseResString(resObj, result);
-            if (state) {
-                badgePattern->AddResCache(key, result);
-            }
-        } else {
-            badgeFontWeight = ConvertStrToFontWeight(cachedFontWeight);
-        }
-
+        ResourceParseUtils::ParseResString(resObj, result);
+        badgeFontWeight = ConvertStrToFontWeight(result);
         badgePattern->UpdateFontWeight(
             badgeFontWeight.has_value() ? badgeFontWeight.value() : FontWeight::NORMAL, isFirstLoad);
     };
@@ -326,6 +314,7 @@ void BadgeModelNG::ProcessFontWeight(
 void BadgeModelNG::ProcessFontSize(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    badgePattern->RemoveResObj("badge.FontSize");
     if (!resourceObject) {
         return;
     }
@@ -352,6 +341,7 @@ void BadgeModelNG::ProcessFontSize(
 void BadgeModelNG::ProcessBadgeSize(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    badgePattern->RemoveResObj("badge.CircleSize");
     if (!resourceObject) {
         return;
     }
@@ -378,6 +368,7 @@ void BadgeModelNG::ProcessBadgeSize(
 void BadgeModelNG::ProcessBadgePositionX(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    badgePattern->RemoveResObj("badge.positionX");
     if (!resourceObject) {
         return;
     }
@@ -398,6 +389,7 @@ void BadgeModelNG::ProcessBadgePositionX(
 void BadgeModelNG::ProcessBadgePositionY(
     const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    badgePattern->RemoveResObj("badge.positionY");
     if (!resourceObject) {
         return;
     }
@@ -417,6 +409,7 @@ void BadgeModelNG::ProcessBadgePositionY(
 
 void BadgeModelNG::ProcessBorderWidth(const RefPtr<BadgePattern>& pattern, const RefPtr<ResourceObject>& resourceObject)
 {
+    pattern->RemoveResObj("badge.borderWidth");
     if (!resourceObject) {
         return;
     }
diff --git a/frameworks/core/components_ng/pattern/badge/badge_model_ng.h b/frameworks/core/components_ng/pattern/badge/badge_model_ng.h
index 0e47ba797b6fed160121702c7f780d0d059b389c..3057b6cecc059c69f38b5799ecac72d39b309233 100644
--- a/frameworks/core/components_ng/pattern/badge/badge_model_ng.h
+++ b/frameworks/core/components_ng/pattern/badge/badge_model_ng.h
@@ -29,6 +29,7 @@ public:
         isDefaultBadgeSize_ = isDefaultBadgeSize;
     };
     void CreateWithResourceObj(const RefPtr<FrameNode>& frameNode, BadgeParameters& badgeParameters);
+    void CreateWithResourceObjFlag(const RefPtr<FrameNode>& frameNode, BadgeParameters& badgeParameters);
     void ProcessBadgeValue(const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject);
     void ProcessBadgeTextColor(const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject);
     void ProcessBadgeColor(const RefPtr<BadgePattern>& badgePattern, const RefPtr<ResourceObject>& resourceObject);
diff --git a/frameworks/core/components_ng/pattern/badge/badge_pattern.cpp b/frameworks/core/components_ng/pattern/badge/badge_pattern.cpp
index 92987537c651b6610dacef938afa7621bb1f0614..5236160543bcedcc9c15d3f791da25c23394d4e9 100644
--- a/frameworks/core/components_ng/pattern/badge/badge_pattern.cpp
+++ b/frameworks/core/components_ng/pattern/badge/badge_pattern.cpp
@@ -375,4 +375,44 @@ void BadgePattern::UpdateBorderWidth(const CalcDimension& borderWidth, bool isFi
         layoutProperty->UpdateBadgeBorderWidth(borderWidth);
     }
 }
+
+void BadgePattern::OnColorConfigurationUpdate()
+{
+    if (!SystemProperties::ConfigChangePerform()) {
+        return;
+    }
+    auto host = GetHost();
+    CHECK_NULL_VOID(host);
+    auto pipeline = host->GetContext();
+    CHECK_NULL_VOID(pipeline);
+    auto badgeTheme = pipeline->GetTheme<BadgeTheme>();
+    CHECK_NULL_VOID(badgeTheme);
+    auto layoutProperty = GetLayoutProperty<BadgeLayoutProperty>();
+    CHECK_NULL_VOID(layoutProperty);
+    if (!layoutProperty->GetBadgePositionXByuser().value_or(false)) {
+        UpdateBadgePositionX(badgeTheme->GetBadgePositionX());
+    }
+    if (!layoutProperty->GetBadgePositionYByuser().value_or(false)) {
+        UpdateBadgePositionY(badgeTheme->GetBadgePositionY());
+    }
+    if (!layoutProperty->GetBadgeFontSizeByuser().value_or(false)) {
+        UpdateFontSize(badgeTheme->GetBadgeFontSize(), true);
+    }
+
+    if (!layoutProperty->GetBadgeCircleSizeByuser().value_or(false)) {
+        UpdateBadgeCircleSize(badgeTheme->GetBadgeCircleSize(), true);
+    }
+    if (!layoutProperty->GetBadgeBorderColorByuser().value_or(false)) {
+        UpdateBorderColor(badgeTheme->GetBadgeBorderColor());
+    }
+    if (!layoutProperty->GetBadgeBorderWidthByuser().value_or(false)) {
+        UpdateBorderWidth(badgeTheme->GetBadgeBorderWidth());
+    }
+    if (!layoutProperty->GetBadgeTextColorByuser().value_or(false)) {
+        UpdateColor(badgeTheme->GetBadgeTextColor());
+    }
+    if (!layoutProperty->GetBadgeColorByuser().value_or(false)) {
+        UpdateBadgeColor(badgeTheme->GetBadgeColor());
+    }
+}
 } // namespace OHOS::Ace::NG
diff --git a/frameworks/core/components_ng/pattern/badge/badge_pattern.h b/frameworks/core/components_ng/pattern/badge/badge_pattern.h
index e29b278adf361a2ba01d713d832b0bfe84213283..98298ccd7dcad85765c933b0d854dc0e0a93ae38 100644
--- a/frameworks/core/components_ng/pattern/badge/badge_pattern.h
+++ b/frameworks/core/components_ng/pattern/badge/badge_pattern.h
@@ -61,6 +61,7 @@ public:
     void UpdateBadgePositionX(const CalcDimension& positionX, bool isFirstLoad = false);
     void UpdateBadgePositionY(const CalcDimension& positionY, bool isFirstLoad = false);
     void UpdateBorderWidth(const CalcDimension& borderWidth, bool isFirstLoad = false);
+    void OnColorConfigurationUpdate() override;
 
 private:
     void OnModifyDone() override;