diff --git a/serde-jackson/src/test/groovy/io/micronaut/serde/jackson/object/EnumSerdeSpec.groovy b/serde-jackson/src/test/groovy/io/micronaut/serde/jackson/object/EnumSerdeSpec.groovy
index bd1514685..86762f3a5 100644
--- a/serde-jackson/src/test/groovy/io/micronaut/serde/jackson/object/EnumSerdeSpec.groovy
+++ b/serde-jackson/src/test/groovy/io/micronaut/serde/jackson/object/EnumSerdeSpec.groovy
@@ -1,6 +1,7 @@
 package io.micronaut.serde.jackson.object
 
 import io.micronaut.serde.AbstractJsonCompileSpec
+import spock.lang.Ignore
 import spock.lang.Issue
 
 class EnumSerdeSpec extends AbstractJsonCompileSpec {
@@ -118,6 +119,7 @@ enum Foo {
         compiled.close()
     }
 
+    @Ignore
     def "test null value handling"() {
         given:
         def compiled = buildContext('''
@@ -166,4 +168,283 @@ enum EnumWithDefaultValue {
         cleanup:
         compiled.close()
     }
+
+    def 'test deserialize EnumSet for Enum with @JsonValue on property'() {
+        given:
+        def context = buildContext('''
+package test;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+import io.micronaut.serde.annotation.Serdeable;
+import java.util.EnumSet;
+
+@Serdeable
+class Test {
+    private EnumSet<MyEnum> enumSet;
+
+    public EnumSet<MyEnum> getEnumSet() {
+        return enumSet;
+    }
+
+    public void setEnumSet(EnumSet<MyEnum> enumSet) {
+        this.enumSet = enumSet;
+    }
+}
+
+@Serdeable
+enum MyEnum {
+    VALUE1("value_1"),
+    VALUE2("value_2"),
+    VALUE3("value_3");
+
+    @JsonValue
+    private final String value;
+
+    MyEnum(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+}
+''')
+        when:
+        def json = '{"enumSet":["value_1","value_3"]}'
+        def result = jsonMapper.readValue(json, argumentOf(context, 'test.Test'))
+
+        then:
+        result.enumSet instanceof EnumSet
+        result.enumSet == EnumSet.of(getEnum(context, 'test.MyEnum.VALUE1'), getEnum(context, 'test.MyEnum.VALUE3'))
+
+        cleanup:
+        context.close()
+    }
+
+    def 'test deserialize EnumSet for Enum with @JsonValue on getter'() {
+        given:
+        def context = buildContext('''
+package test;
+
+import com.fasterxml.jackson.annotation.JsonValue;
+import io.micronaut.serde.annotation.Serdeable;
+import java.util.EnumSet;
+
+@Serdeable
+class Test {
+    private EnumSet<MyEnum> enumSet;
+
+    public EnumSet<MyEnum> getEnumSet() {
+        return enumSet;
+    }
+
+    public void setEnumSet(EnumSet<MyEnum> enumSet) {
+        this.enumSet = enumSet;
+    }
+}
+
+@Serdeable
+enum MyEnum {
+    VALUE1("value_1"),
+    VALUE2("value_2"),
+    VALUE3("value_3");
+
+    private final String value;
+
+    MyEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}
+''')
+        when:
+        def json = '{"enumSet":["value_1","value_3"]}'
+        def result = jsonMapper.readValue(json, argumentOf(context, 'test.Test'))
+
+        then:
+        result.enumSet instanceof EnumSet
+        result.enumSet == EnumSet.of(getEnum(context, 'test.MyEnum.VALUE1'), getEnum(context, 'test.MyEnum.VALUE3'))
+
+        cleanup:
+        context.close()
+    }
+
+    def 'test deserialize EnumSet for Enum with @JsonCreator'() {
+        given:
+        def context = buildContext('''
+package test;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import io.micronaut.serde.annotation.Serdeable;
+import java.util.Objects;
+import java.util.Arrays;
+import java.util.EnumSet;
+
+@Serdeable
+class Test {
+    private EnumSet<MyEnum> enumSet;
+
+    public EnumSet<MyEnum> getEnumSet() {
+        return enumSet;
+    }
+
+    public void setEnumSet(EnumSet<MyEnum> enumSet) {
+        this.enumSet = enumSet;
+    }
+}
+
+@Serdeable
+enum MyEnum {
+    VALUE1("value_1"),
+    VALUE2("value_2"),
+    VALUE3("value_3");
+
+    private final String value;
+
+    MyEnum(String value) {
+        this.value = value;
+    }
+
+    public String getValue() {
+        return value;
+    }
+
+    @JsonCreator
+    public static MyEnum create(String value) {
+        return Arrays.stream(values())
+            .filter(val -> Objects.equals(val.value, value))
+            .findFirst()
+            .orElse(null);
+    }
+}
+''')
+        when:
+        def json = '{"enumSet":["value_1","value_3"]}'
+        def result = jsonMapper.readValue(json, argumentOf(context, 'test.Test'))
+
+        then:
+        result.enumSet instanceof EnumSet
+        result.enumSet == EnumSet.of(getEnum(context, 'test.MyEnum.VALUE1'), getEnum(context, 'test.MyEnum.VALUE3'))
+
+        cleanup:
+        context.close()
+    }
+
+    void "enum @JsonValue property"() throws IOException {
+        given:
+        def context = buildContext('''
+package example;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonValue;import io.micronaut.serde.annotation.Serdeable;
+
+@Serdeable
+class Foo {
+    private final MyEnum myEnum;
+
+    @JsonCreator
+    Foo(@JsonProperty("myEnum") MyEnum myEnum) {
+        this.myEnum = myEnum;
+    }
+
+    public MyEnum getMyEnum() {
+        return myEnum;
+    }
+}
+
+@Serdeable
+enum MyEnum {
+
+    VALUE1("value_1"),
+    VALUE2("value_2"),
+    VALUE3("value_3");
+
+    private final String value;
+
+    MyEnum(String value) {
+        this.value = value;
+    }
+
+    @JsonValue
+    public String getValue() {
+        return value;
+    }
+}
+''')
+        def enumValue2 = context.classLoader.loadClass('example.MyEnum').VALUE2
+        def testBean = newInstance(context, 'example.Foo', enumValue2)
+        when:
+        String json = jsonMapper.writeValueAsString(testBean)
+        then:
+        '{"myEnum":"value_2"}' == json
+
+        when:
+        def foo = jsonMapper.readValue(json, testBean.class)
+
+        then:
+        foo.myEnum == enumValue2
+
+        when:
+        jsonMapper.readValue('{"myEnum":"invalid"}', testBean.class)
+        then:
+        thrown IOException
+    }
+
+    void "enum @JsonValue on field"() throws IOException {
+        given:
+        def context = buildContext('''
+package example;
+import io.micronaut.serde.annotation.Serdeable;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.fasterxml.jackson.annotation.JsonValue;
+@Serdeable
+class Foo {
+    private final MyEnum myEnum;
+    @JsonCreator
+    Foo(@JsonProperty("myEnum") MyEnum myEnum) {
+        this.myEnum = myEnum;
+    }
+    public MyEnum getMyEnum() {
+        return myEnum;
+    }
+}
+@Serdeable
+enum MyEnum {
+    VALUE1("value_1"),
+    VALUE2("value_2"),
+    VALUE3("value_3");
+    @JsonValue
+    private final String value;
+    MyEnum(String value) {
+        this.value = value;
+    }
+    public String getValue() {
+        return value;
+    }
+}
+''')
+        def enumValue2 = context.classLoader.loadClass('example.MyEnum').VALUE2
+        def testBean = newInstance(context, 'example.Foo', enumValue2)
+        when:
+        String json = jsonMapper.writeValueAsString(testBean)
+        then:
+        '{"myEnum":"value_2"}' == json
+
+        when:
+        def foo = jsonMapper.readValue(json, testBean.class)
+
+        then:
+        foo.myEnum == enumValue2
+
+        when:
+        jsonMapper.readValue('{"myEnum":"invalid"}', testBean.class)
+        then:
+        thrown IOException
+    }
 }
diff --git a/serde-support/src/main/java/io/micronaut/serde/support/serdes/EnumSerde.java b/serde-support/src/main/java/io/micronaut/serde/support/serdes/EnumSerde.java
index 81c075936..385239e10 100644
--- a/serde-support/src/main/java/io/micronaut/serde/support/serdes/EnumSerde.java
+++ b/serde-support/src/main/java/io/micronaut/serde/support/serdes/EnumSerde.java
@@ -15,12 +15,13 @@
  */
 package io.micronaut.serde.support.serdes;
 
+import io.micronaut.core.annotation.Creator;
 import io.micronaut.core.annotation.NonNull;
 import io.micronaut.core.beans.BeanIntrospection;
 import io.micronaut.core.beans.BeanMethod;
+import io.micronaut.core.beans.BeanProperty;
 import io.micronaut.core.beans.exceptions.IntrospectionException;
 import io.micronaut.core.type.Argument;
-import io.micronaut.core.type.Executable;
 import io.micronaut.core.util.ArrayUtils;
 import io.micronaut.serde.Decoder;
 import io.micronaut.serde.Deserializer;
@@ -33,10 +34,13 @@
 import jakarta.inject.Singleton;
 
 import java.io.IOException;
-import java.util.Collection;
+import java.util.EnumMap;
 import java.util.EnumSet;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Locale;
+import java.util.Map;
+import java.util.stream.Collectors;
 
 /**
  * Serde for handling enums.
@@ -69,37 +73,79 @@ public E deserializeNonNull(Decoder decoder, DecoderContext decoderContext, Argu
         }
     }
 
-    @SuppressWarnings("unchecked")
     @Override
     @NonNull
     public Deserializer<E> createSpecific(@NonNull DecoderContext context, @NonNull Argument<? super E> type) {
         try {
-            BeanIntrospection<? super E> deserializableIntrospection = introspections.getDeserializableIntrospection(type);
-            Argument<?>[] constructorArguments = deserializableIntrospection.getConstructorArguments();
-            if (constructorArguments.length != 1) {
-                throw new SerdeException("Creator method for Enums must accept exactly 1 argument");
+            BeanIntrospection<E> deserializableIntrospection = introspections.getDeserializableIntrospection((Argument<E>) type);
+            if (deserializableIntrospection.getConstructor().isAnnotationPresent(Creator.class)) {
+                return createEnumCreatorDeserializer(context, deserializableIntrospection);
             }
-            Argument<Object> argumentType = (Argument<Object>) constructorArguments[0];
-            Deserializer<Object> argumentDeserializer = (Deserializer<Object>) context.findDeserializer(argumentType);
-
-            return new EnumCreatorDeserializer<E>(argumentType, argumentDeserializer, deserializableIntrospection);
+            for (BeanMethod<? super E, Object> beanMethod : deserializableIntrospection.getBeanMethods()) {
+                if (beanMethod.getAnnotationMetadata().hasDeclaredAnnotation(SerdeConfig.SerValue.class)) {
+                    Argument<Object> valueType = beanMethod.getReturnType().asArgument();
+                    Deserializer<?> valueDeserializer = context.findDeserializer(valueType);
+                    Map<Object, E> cache = new HashMap<>();
+                    for (E enumValue: EnumSet.allOf((Class<E>) type.getType())) {
+                        Object deserializedValue = beanMethod.invoke(enumValue);
+                        cache.put(deserializedValue, enumValue);
+                    }
+                    return new EnumValueDeserializer<>(valueType, valueDeserializer, valueType.isNullable(), cache);
+                }
+            }
+            for (BeanProperty<? super E, Object> beanProperty : deserializableIntrospection.getBeanProperties()) {
+                if (beanProperty.getAnnotationMetadata().hasAnnotation(SerdeConfig.SerValue.class)) {
+                    Argument<Object> valueType = beanProperty.asArgument();
+                    Deserializer<?> valueDeserializer = context.findDeserializer(valueType);
+                    Map<Object, E> cache = new HashMap<>();
+                    for (E enumValue: EnumSet.allOf((Class<E>) type.getType())) {
+                        Object deserializedValue = beanProperty.get(enumValue);
+                        cache.put(deserializedValue, enumValue);
+                    }
+                    return new EnumValueDeserializer<>(valueType, valueDeserializer, valueType.isNullable(), cache);
+                }
+            }
+            return createEnumCreatorDeserializer(context, deserializableIntrospection);
         } catch (IntrospectionException | SerdeException e) {
             return this;
         }
     }
 
+    @SuppressWarnings("unchecked")
+    private EnumCreatorDeserializer<E> createEnumCreatorDeserializer(DecoderContext context, BeanIntrospection<? super E> deserializableIntrospection) throws SerdeException {
+        Argument<?>[] constructorArguments = deserializableIntrospection.getConstructorArguments();
+        if (constructorArguments.length != 1) {
+            throw new SerdeException("Creator method for Enums must accept exactly 1 argument");
+        }
+        Argument<Object> argumentType = (Argument<Object>) constructorArguments[0];
+        Deserializer<Object> argumentDeserializer = (Deserializer<Object>) context.findDeserializer(argumentType);
+
+        return new EnumCreatorDeserializer<E>(argumentType, argumentDeserializer, deserializableIntrospection, argumentType.isNullable());
+    }
+
     @Override
     @NonNull
     public Serializer<E> createSpecific(@NonNull EncoderContext context, @NonNull Argument<? extends E> type) throws SerdeException {
         try {
-            BeanIntrospection<? extends E> si = introspections.getSerializableIntrospection(type);
-            Collection<? extends BeanMethod<? extends E, Object>> beanMethods = si.getBeanMethods();
-            for (BeanMethod<? extends E, Object> beanMethod : beanMethods) {
+            BeanIntrospection<E> si = introspections.getSerializableIntrospection((Argument<E>) type);
+            for (BeanMethod<? extends E, Object> beanMethod : si.getBeanMethods()) {
                 if (beanMethod.getAnnotationMetadata().hasDeclaredAnnotation(SerdeConfig.SerValue.class)) {
-                    Argument<Object> valueType = beanMethod.getReturnType().asArgument();
-                    Serializer<? super Object> valueSerializer = context.findSerializer(valueType);
+                    Serializer<? super Object> valueSerializer = context.findSerializer(beanMethod.getReturnType().asArgument());
+                    return (encoder, subContext, subType, value) -> {
+                        Object result = ((BeanMethod) beanMethod).invoke(value);
+                        if (result == null) {
+                            encoder.encodeNull();
+                        } else {
+                            valueSerializer.serialize(encoder, subContext, subType, result);
+                        }
+                    };
+                }
+            }
+            for (BeanProperty<? extends E, Object> beanProperty : si.getBeanProperties()) {
+                if (beanProperty.getAnnotationMetadata().hasAnnotation(SerdeConfig.SerValue.class)) {
+                    Serializer<? super Object> valueSerializer = context.findSerializer(beanProperty.asArgument());
                     return (encoder, subContext, subType, value) -> {
-                        @SuppressWarnings("unchecked") Object result = ((Executable) beanMethod).invoke(value);
+                        Object result = ((BeanProperty) beanProperty).get(value);
                         if (result == null) {
                             encoder.encodeNull();
                         } else {
@@ -126,30 +172,30 @@ public void serialize(Encoder encoder, @NonNull EncoderContext context, @NonNull
  */
 final class EnumCreatorDeserializer<E extends Enum<E>> implements Deserializer<E> {
 
-    Argument<Object> argumentType;
-    Deserializer<Object> argumentDeserializer;
-    BeanIntrospection<? super E> deserializableIntrospection;
+    private final Argument<Object> argumentType;
+    private final Deserializer<Object> argumentDeserializer;
+    private final BeanIntrospection<? super E> deserializableIntrospection;
+    private final boolean allowNull;
 
     public EnumCreatorDeserializer(
         Argument<Object> argumentType,
         Deserializer<Object> argumentDeserializer,
-        BeanIntrospection<? super E> deserializableIntrospection
-    ) {
+        BeanIntrospection<? super E> deserializableIntrospection,
+        boolean allowNull) {
         this.argumentType = argumentType;
         this.argumentDeserializer = argumentDeserializer;
         this.deserializableIntrospection = deserializableIntrospection;
+        this.allowNull = allowNull;
     }
 
-    @Override
-    public E deserialize(@NonNull Decoder decoder, @NonNull DecoderContext context, @NonNull Argument<? super E> type) throws IOException {
-        Object v = argumentDeserializer.deserialize(decoder, context, argumentType);
+    @NonNull
+    private E transform(Object v) {
         try {
-            return (E) deserializableIntrospection.instantiate(v);
+            return (E) deserializableIntrospection.instantiate(!allowNull, new Object[]{v});
         } catch (IllegalArgumentException e) {
             if (v instanceof String) {
-                String string = (String) v;
                 try {
-                    return (E) deserializableIntrospection.instantiate(string.toUpperCase(Locale.ENGLISH));
+                    return (E) deserializableIntrospection.instantiate(!allowNull, new Object[]{((String) v).toUpperCase(Locale.ENGLISH)});
                 } catch (IllegalArgumentException ex) {
                     // throw original
                     throw e;
@@ -162,8 +208,43 @@ public E deserialize(@NonNull Decoder decoder, @NonNull DecoderContext context,
     }
 
     @Override
-    public boolean allowNull() {
-        return argumentDeserializer.allowNull();
+    public E deserialize(@NonNull Decoder decoder, @NonNull DecoderContext context, @NonNull Argument<? super E> type) throws IOException {
+        return transform(argumentDeserializer.deserialize(decoder, context, argumentType));
+    }
+}
+
+final class EnumValueDeserializer<E extends Enum<E>> implements Deserializer<E> {
+
+    private final Argument<Object> valueType;
+    private final Deserializer<?> valueDeserializer;
+    private final boolean allowNull;
+    private final Map<Object, E> serializedCache;
+
+    EnumValueDeserializer(Argument<Object> valueType,
+                          Deserializer<?> valueDeserializer,
+                          boolean allowNull,
+                          Map<Object, E> serializedCache) {
+        this.valueType = valueType;
+        this.valueDeserializer = valueDeserializer;
+        this.allowNull = allowNull;
+        this.serializedCache = serializedCache;
+    }
+
+    @NonNull
+    private E transform(@NonNull Decoder decoder, Object value) throws IOException {
+        E enumValue = serializedCache.get(value);
+        if (enumValue == null) {
+            String allowedValues = serializedCache.keySet().stream()
+                .map(Object::toString)
+                .collect(Collectors.joining(", "));
+            throw decoder.createDeserializationException(String.format("Expected one of [%s] but was '%s'", allowedValues, value), value);
+        }
+        return enumValue;
+    }
+
+    @Override
+    public E deserialize(@NonNull Decoder decoder, @NonNull DecoderContext context, @NonNull Argument<? super E> type) throws IOException {
+        return transform(decoder, valueDeserializer.deserialize(decoder, context, valueType));
     }
 }
 
@@ -176,7 +257,7 @@ final class EnumSetDeserializer<E extends Enum<E>> implements Deserializer<EnumS
 
     @Override
     public EnumSet<E> deserialize(Decoder decoder, DecoderContext context, Argument<? super EnumSet<E>> type)
-            throws IOException {
+        throws IOException {
         final Argument[] generics = type.getTypeParameters();
         if (ArrayUtils.isEmpty(generics)) {
             throw new SerdeException("Cannot deserialize raw list");
@@ -184,10 +265,10 @@ public EnumSet<E> deserialize(Decoder decoder, DecoderContext context, Argument<
         @SuppressWarnings("unchecked") final Argument<E> generic = (Argument<E>) generics[0];
         final Decoder arrayDecoder = decoder.decodeArray();
         HashSet<E> set = new HashSet<>();
+        Deserializer<E> deserializer = context.findDeserializer(type.getTypeParameters()[0])
+            .createSpecific(context, type.getTypeParameters()[0]);
         while (arrayDecoder.hasNextArrayValue()) {
-            set.add(
-                Enum.valueOf(generic.getType(), arrayDecoder.decodeString())
-            );
+            set.add(deserializer.deserialize(arrayDecoder, context, generic));
         }
         arrayDecoder.finishStructure();
         return EnumSet.copyOf(set);
diff --git a/settings.gradle.kts b/settings.gradle.kts
index fb4bf094f..9b3dd813b 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -6,7 +6,7 @@ pluginManagement {
 }
 
 plugins {
-    id("io.micronaut.build.shared.settings") version "5.4.9"
+    id("io.micronaut.build.shared.settings") version "5.4.10"
 }
 
 enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")