Optimize option saving

src/main/java/run/halo/app/controller/admin/api/OptionController.java

@@ -49,7 +49,7 @@ public class OptionController {
 
     @PostMapping("map_view/saving")
     @ApiOperation("Saves options by option map")
-    public void saveOptionsWithMapView(@RequestBody Map<String, String> optionMap) {
+    public void saveOptionsWithMapView(@RequestBody Map<String, Object> optionMap) {
         optionService.save(optionMap);
     }
 

src/main/java/run/halo/app/model/params/OptionParam.java

@@ -8,7 +8,7 @@ import javax.validation.constraints.NotBlank;
 import javax.validation.constraints.Size;
 
 /**
- * Optiona param.
+ * Optional param.
  *
  * @author johnniang
  * @date 3/20/19

src/main/java/run/halo/app/service/OptionService.java

@@ -39,7 +39,7 @@ public interface OptionService extends CrudService<Option, Integer> {
      * @param options options
      */
     @Transactional
-    void save(@Nullable Map<String, String> options);
+    void save(@Nullable Map<String, Object> options);
 
     /**
      * SAve multiple options

src/main/java/run/halo/app/service/impl/OptionServiceImpl.java

@@ -6,7 +6,10 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.lang.NonNull;
+import org.springframework.lang.Nullable;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.springframework.util.Assert;
 import org.springframework.util.CollectionUtils;
 import run.halo.app.cache.StringCacheStore;
@@ -23,6 +26,7 @@ import run.halo.app.service.base.AbstractCrudService;
 import run.halo.app.utils.DateUtils;
 import run.halo.app.utils.HaloUtils;
 import run.halo.app.utils.ServiceUtils;
+import run.halo.app.utils.ValidationUtils;
 
 import java.util.*;
 
@@ -59,57 +63,65 @@ public class OptionServiceImpl extends AbstractCrudService<Option, Integer> impl
         propertyEnumMap = Collections.unmodifiableMap(PropertyEnum.getValuePropertyEnumMap());
     }
 
-    private void save(String key, String value) {
+    @Deprecated
+    @Transactional
+    private void save(@NonNull String key, @Nullable String value) {
         Assert.hasText(key, "Option key must not be blank");
-
+        save(Collections.singletonMap(key, value));
-        if (StringUtils.isBlank(value)) {
-            // If the value is blank, remove the key
-            optionRepository.deleteByKey(key);
-            log.debug("Removed option key: [{}]", key);
-            return;
-        }
-
-        Option option = optionRepository.findByKey(key)
-                .map(anOption -> {
-                    log.debug("Updating option key: [{}], value: from [{}] to [{}]", key, anOption.getValue(), value);
-                    // Exist
-                    anOption.setValue(value);
-                    return anOption;
-                }).orElseGet(() -> {
-                    log.debug("Creating option key: [{}], value: [{}]", key, value);
-                    // Not exist
-                    Option anOption = new Option();
-                    anOption.setKey(key);
-                    anOption.setValue(value);
-                    return anOption;
-                });
-
-        // Save or update the options
-        Option savedOption = optionRepository.save(option);
-
-        log.debug("Saved option: [{}]", savedOption);
     }
 
     @Override
-    public void save(Map<String, String> options) {
+    @Transactional
-        if (CollectionUtils.isEmpty(options)) {
+    public void save(Map<String, Object> optionMap) {
+        if (CollectionUtils.isEmpty(optionMap)) {
             return;
         }
 
-        options.forEach(this::save);
+        Map<String, Option> optionKeyMap = ServiceUtils.convertToMap(listAll(), Option::getKey);
 
+        List<Option> optionsToCreate = new LinkedList<>();
+        List<Option> optionsToUpdate = new LinkedList<>();
+
+        optionMap.forEach((key, value) -> {
+            Option oldOption = optionKeyMap.get(key);
+            if (oldOption == null || !StringUtils.equals(oldOption.getValue(), value.toString())) {
+                OptionParam optionParam = new OptionParam();
+                optionParam.setKey(key);
+                optionParam.setValue(value.toString());
+                ValidationUtils.validate(optionParam);
+
+                if (oldOption == null) {
+                    // Create it
+                    optionsToCreate.add(optionParam.convertTo());
+                } else if (!StringUtils.equals(oldOption.getValue(), value.toString())) {
+                    // Update it
+                    optionParam.update(oldOption);
+                    optionsToUpdate.add(oldOption);
+                }
+            }
+        });
+
+        // Update them
+        updateInBatch(optionsToUpdate);
+
+        // Create them
+        createInBatch(optionsToCreate);
+
+        if (!CollectionUtils.isEmpty(optionsToUpdate) || !CollectionUtils.isEmpty(optionsToCreate)) {
+            // If there is something changed
             publishOptionUpdatedEvent();
         }
 
+    }
+
     @Override
     public void save(List<OptionParam> optionParams) {
         if (CollectionUtils.isEmpty(optionParams)) {
             return;
         }
 
-        optionParams.forEach(optionParam -> save(optionParam.getKey(), optionParam.getValue()));
+        Map<String, Object> optionMap = ServiceUtils.convertToMap(optionParams, OptionParam::getKey, OptionParam::getValue);
-
+        save(optionMap);
-        publishOptionUpdatedEvent();
     }
 
     @Override
@@ -117,8 +129,6 @@ public class OptionServiceImpl extends AbstractCrudService<Option, Integer> impl
         Assert.notNull(property, "Property must not be null");
 
         save(property.getValue(), value);
-
-        publishOptionUpdatedEvent();
     }
 
     @Override
@@ -127,9 +137,11 @@ public class OptionServiceImpl extends AbstractCrudService<Option, Integer> impl
             return;
         }
 
-        properties.forEach((property, value) -> save(property.getValue(), value));
+        Map<String, Object> optionMap = new LinkedHashMap<>();
 
-        publishOptionUpdatedEvent();
+        properties.forEach((property, value) -> optionMap.put(property.getValue(), value));
+
+        save(optionMap);
     }
 
     @Override