[WIP] try to support Jackson 3

README.md

@@ -1,8 +1,8 @@
 Project to build [Jackson](../../../jackson) module to
 support JSON serialization and deserialization of Hibernate (https://hibernate.org) specific data types and properties; and features like lazy-loading.
 
-[![Maven Central](https://maven-badges.herokuapp.com/maven-central/com.fasterxml.jackson.datatype/jackson-datatype-hibernate5/badge.svg)](https://maven-badges.herokuapp.com/maven-central/com.fasterxml.jackson.datatype/jackson-datatype-hibernate5/)
-[![Javadoc](https://javadoc.io/badge/com.fasterxml.jackson.datatype/jackson-datatype-hibernate5.svg)](https://www.javadoc.io/doc/com.fasterxml.jackson.datatype/jackson-datatype-hibernate5)
+[![Maven Central](https://maven-badges.herokuapp.com/maven-central/tools.jackson.datatype/jackson-datatype-hibernate5/badge.svg)](https://maven-badges.herokuapp.com/maven-central/tools.jackson.datatype/jackson-datatype-hibernate5/)
+[![Javadoc](https://javadoc.io/badge/tools.jackson.datatype/jackson-datatype-hibernate5.svg)](https://www.javadoc.io/doc/tools.jackson.datatype/jackson-datatype-hibernate5)
 
 ## Status
 
@@ -11,32 +11,17 @@ Module is usable and supported for Jackson 2.x. and used by non-trivial number o
 Currently (October 2025) module is **NOT supported for Jackson 3.x** due to lack of active maintainer.
 It is considered Deprecated as part of [JSTEP-9](https://github.com/FasterXML/jackson-future-ideas/wiki/JSTEP-9).
 
-Note: Hibernate 4.x, 5.x, 6.x and 7.x are supported (5.x starting with Jackson 2.6; 6.x with Jackson 2.15 and 7.x with Jackson 2.20) but they require different jars, and Maven artifact names (and jar names differ).
+Note: Hibernate 4.x, 5.x, 6.x and 7.x are supported but they require different jars, and Maven artifact names (and jar names differ).
 
 This document refers to "Hibernate 5" version, but changes with 4.x/6.x/7.x should require
 little more than replacing "5" in names with "4", "6" or "7".
 
-Hibernate 3.x was supported up to Jackson 2.12 but is no longer supported at and after 2.13
-
-Jackson 2.13 adds Support for "Hibernate 5 Jakarta" variant (for Hibernate 5.5 and beyond);
+See also "Hibernate 5 Jakarta" variant (for Hibernate 5.5 and beyond);
 see below for more information.
 
-Jackson 2.15 adds Support for Hibernate 6.x; see below for more information.
-
-Jackson 2.20 adds Support for Hibernate 7.x; see below for more information.
-
 ### JDK requirements
 
-Before Jackson 2.15, baseline JDK needed for building for JDK 8 and all
-module variants worked on Java 8.
-
-With Jackson 2.15, JDK 11 will be required to build: all modules run on
-Java 8 except for Hibernate 6.x module which requires Java 11 like
-Hibernate 6.x itself.
-
-With Jackson 2.20, JDK 17 will be required to build: 4.x and 5.x modules run on
-Java 8, 6.x on 11 and Hibernate 7.x module requires Java 17 like
-Hibernate 7.x itself.
+Java 17 or above is required.
 
 ### Javax vs Jakarta
 
@@ -59,9 +44,9 @@ To use module on Maven-based projects, use following dependency
 
 ```xml
 <dependency>
-  <groupId>com.fasterxml.jackson.datatype</groupId>
+  <groupId>tools.jackson.datatype</groupId>
   <artifactId>jackson-datatype-hibernate5</artifactId>
-  <version>2.20.0</version>
+  <version>3.0.0</version>
 </dependency>
 ```
 
@@ -71,9 +56,9 @@ Note that you need to use "jackson-datatype-hibernate4" for Hibernate 4.x.
 
 ```xml
 <dependency>
-  <groupId>com.fasterxml.jackson.datatype</groupId>
+  <groupId>tools.jackson.datatype</groupId>
   <artifactId>jackson-datatype-hibernate4</artifactId>
-  <version>2.20.0</version>
+  <version>3.0.0</version>
 </dependency>
 ```
 
@@ -82,9 +67,9 @@ you will need the jakarta suffixed dependency for Hibernate 5.5:
 
 ```xml
 <dependency>
-  <groupId>com.fasterxml.jackson.datatype</groupId>
+  <groupId>tools.jackson.datatype</groupId>
   <artifactId>jackson-datatype-hibernate5-jakarta</artifactId>
-  <version>2.20.0</version>
+  <version>3.0.0</version>
 </dependency>
 ```
 
@@ -93,20 +78,19 @@ but you will need to use "jackson-datatype-hibernate6" for Hibernate 6.x:
 
 ```xml
 <dependency>
-  <groupId>com.fasterxml.jackson.datatype</groupId>
+  <groupId>tools.jackson.datatype</groupId>
   <artifactId>jackson-datatype-hibernate6</artifactId>
-  <version>2.20.0</version>
+  <version>3.0.0</version>
 </dependency>
 ```
 
-and finally, for Hibernate 7.x (not yet released)
+and finally, for Hibernate 7.x
 
 ```xml
 <dependency>
-    <groupId>com.fasterxml.jackson.datatype</groupId>
+    <groupId>tools.jackson.datatype</groupId>
     <artifactId>jackson-datatype-hibernate7</artifactId>
-    <!-- will be added in Jackson 2.20.0: -->
-    <version>2.20.0-SNAPSHOT</version>
+    <version>3.0.0</version>
 </dependency>
 ```
 

hibernate4/pom.xml

@@ -6,9 +6,9 @@
   <!-- do_not_remove: published-with-gradle-metadata -->
   <modelVersion>4.0.0</modelVersion> 
   <parent>
-    <groupId>com.fasterxml.jackson.datatype</groupId>
+    <groupId>tools.jackson.datatype</groupId>
     <artifactId>jackson-datatype-hibernate-parent</artifactId>
-    <version>2.21.0-SNAPSHOT</version>
+    <version>3.0.0-SNAPSHOT</version>
   </parent>
   <artifactId>jackson-datatype-hibernate4</artifactId>
   <name>Jackson-datatype-Hibernate4</name>
@@ -21,7 +21,7 @@ Hibernate (https://hibernate.org) version 4.x data types.
     <javac.src.version>1.8</javac.src.version>
     <javac.target.version>1.8</javac.target.version>
     <!-- Generate PackageVersion.java into this directory. -->
-    <packageVersion.dir>com/fasterxml/jackson/datatype/hibernate4</packageVersion.dir>
+    <packageVersion.dir>tools/jackson/datatype/hibernate4</packageVersion.dir>
     <packageVersion.package>${project.groupId}.hibernate4</packageVersion.package>
     <!-- Hibernate with JPA 2.0 -->
     <hibernate.version>4.3.11.Final</hibernate.version>
@@ -67,8 +67,8 @@ Hibernate (https://hibernate.org) version 4.x data types.
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <configuration>
-          <source>8</source>
-          <target>8</target>
+          <source>17</source>
+          <target>17</target>
         </configuration>
       </plugin>
       <plugin>

hibernate4/src/main/java/com/fasterxml/jackson/datatype/hibernate4/Hibernate4Module.java → hibernate4/src/main/java/tools/jackson/datatype/hibernate4/Hibernate4Module.java

@@ -1,11 +1,11 @@
-package com.fasterxml.jackson.datatype.hibernate4;
+package tools.jackson.datatype.hibernate4;
 
-import com.fasterxml.jackson.core.Version;
-import com.fasterxml.jackson.databind.AnnotationIntrospector;
+import tools.jackson.core.Version;
+import tools.jackson.databind.AnnotationIntrospector;
 import org.hibernate.SessionFactory;
 import org.hibernate.engine.spi.Mapping;
 
-public class Hibernate4Module extends com.fasterxml.jackson.databind.Module
+public class Hibernate4Module extends tools.jackson.databind.JacksonModule
 {
     /**
      * Enumeration that defines all toggleable features this module
@@ -178,11 +178,11 @@ public void setupModule(SetupContext context)
             context.appendAnnotationIntrospector(ai);
         }
         context.addSerializers(new HibernateSerializers(_mapping, _moduleFeatures));
-        context.addBeanSerializerModifier(new HibernateSerializerModifier(_moduleFeatures, _sessionFactory));
+        context.addSerializerModifier(new HibernateSerializerModifier(_moduleFeatures, _sessionFactory));
     }
 
     /**
-     * Method called during {@link #setupModule}, to create {@link com.fasterxml.jackson.databind.AnnotationIntrospector}
+     * Method called during {@link #setupModule}, to create {@link tools.jackson.databind.AnnotationIntrospector}
      * to register along with module. If null is returned, no introspector is added.
      */
     protected AnnotationIntrospector annotationIntrospector() {

hibernate4/src/main/java/com/fasterxml/jackson/datatype/hibernate4/HibernateAnnotationIntrospector.java → hibernate4/src/main/java/tools/jackson/datatype/hibernate4/HibernateAnnotationIntrospector.java

@@ -1,16 +1,17 @@
-package com.fasterxml.jackson.datatype.hibernate4;
+package tools.jackson.datatype.hibernate4;
 
 import javax.persistence.Transient;
 
 import org.hibernate.bytecode.internal.javassist.FieldHandler;
 
-import com.fasterxml.jackson.core.Version;
-import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
-import com.fasterxml.jackson.databind.introspect.AnnotatedMember;
-import com.fasterxml.jackson.databind.introspect.NopAnnotationIntrospector;
+import tools.jackson.core.Version;
+import tools.jackson.databind.cfg.MapperConfig;
+import tools.jackson.databind.introspect.AnnotatedClass;
+import tools.jackson.databind.introspect.AnnotatedMember;
+import tools.jackson.databind.introspect.NopAnnotationIntrospector;
 
 /**
- * Simple {@link com.fasterxml.jackson.databind.AnnotationIntrospector} that adds support for using
+ * Simple {@link tools.jackson.databind.AnnotationIntrospector} that adds support for using
  * {@link javax.persistence.Transient} to denote ignorable fields (alongside with Jackson
  * and/or JAXB annotations).
  */
@@ -67,12 +68,12 @@ public Version version() {
      */
 
     @Override
-    public boolean hasIgnoreMarker(AnnotatedMember m) {
+    public boolean hasIgnoreMarker(MapperConfig<?> config, AnnotatedMember m) {
         return _cfgCheckTransient && m.hasAnnotation(Transient.class);
     }
 
     @Override
-    public Boolean isIgnorableType(AnnotatedClass ac)
+    public Boolean isIgnorableType(MapperConfig<?> config, AnnotatedClass ac)
     {
         /* 26-Dec-2015, tatu: To fix [datatype-hibernate#72], need to suppress handling
          *  of `FieldHandled`. Not sure if it works without test (alas, none provided),

hibernate4/src/main/java/com/fasterxml/jackson/datatype/hibernate4/HibernateProxySerializer.java → hibernate4/src/main/java/tools/jackson/datatype/hibernate4/HibernateProxySerializer.java

@@ -1,24 +1,23 @@
-package com.fasterxml.jackson.datatype.hibernate4;
+package tools.jackson.datatype.hibernate4;
 
 import java.beans.Introspector;
-import java.io.IOException;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.util.HashMap;
 
 import javax.persistence.EntityNotFoundException;
 
-import com.fasterxml.jackson.core.*;
-import com.fasterxml.jackson.databind.BeanProperty;
-import com.fasterxml.jackson.databind.JavaType;
-import com.fasterxml.jackson.databind.JsonMappingException;
-import com.fasterxml.jackson.databind.JsonSerializer;
-import com.fasterxml.jackson.databind.SerializerProvider;
-import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
-import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
-import com.fasterxml.jackson.databind.ser.ContextualSerializer;
-import com.fasterxml.jackson.databind.ser.impl.PropertySerializerMap;
-import com.fasterxml.jackson.databind.util.NameTransformer;
+import tools.jackson.core.*;
+import tools.jackson.databind.BeanProperty;
+import tools.jackson.databind.JavaType;
+import tools.jackson.databind.DatabindException;
+import tools.jackson.databind.ValueSerializer;
+import tools.jackson.databind.SerializationContext;
+import tools.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
+import tools.jackson.databind.jsontype.TypeSerializer;
+import tools.jackson.databind.ser.impl.PropertySerializerMap;
+import tools.jackson.databind.type.TypeFactory;
+import tools.jackson.databind.util.NameTransformer;
 
 import org.hibernate.engine.spi.Mapping;
 import org.hibernate.engine.spi.SessionImplementor;
@@ -36,8 +35,7 @@
  * this one) have.
  */
 public class HibernateProxySerializer
-    extends JsonSerializer<HibernateProxy>
-    implements ContextualSerializer
+    extends ValueSerializer<HibernateProxy>
 {
     /**
      * Property that has proxy value to handle
@@ -144,12 +142,12 @@ protected HibernateProxySerializer(HibernateProxySerializer base,
     }
 
     @Override
-    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) {
+    public ValueSerializer<?> createContextual(SerializationContext prov, BeanProperty property) {
         return new HibernateProxySerializer(this, property, _unwrapper);
     }
 
     @Override
-    public JsonSerializer<HibernateProxy> unwrappingSerializer(final NameTransformer unwrapper)
+    public ValueSerializer<HibernateProxy> unwrappingSerializer(final NameTransformer unwrapper)
     {
         return new HibernateProxySerializer(this, _property, unwrapper);
     }
@@ -161,36 +159,34 @@ public boolean isUnwrappingSerializer() {
 
     /*
     /**********************************************************************
-    /* JsonSerializer impl
+    /* ValueSerializer impl
     /**********************************************************************
      */
 
     @Override
-    public boolean isEmpty(SerializerProvider provider, HibernateProxy value) {
+    public boolean isEmpty(SerializationContext provider, HibernateProxy value) {
         return (value == null) || (findProxied(value) == null);
     }
 
     @Override
-    public void serialize(HibernateProxy value, JsonGenerator jgen, SerializerProvider provider)
-        throws IOException
+    public void serialize(HibernateProxy value, JsonGenerator jgen, SerializationContext provider)
     {
         Object proxiedValue = findProxied(value);
         // TODO: figure out how to suppress nulls, if necessary? (too late for that here)
         if (proxiedValue == null) {
-            provider.defaultSerializeNull(jgen);
+            provider.defaultSerializeNullValue(jgen);
             return;
         }
         findSerializer(provider, proxiedValue).serialize(proxiedValue, jgen, provider);
     }
 
     @Override
-    public void serializeWithType(HibernateProxy value, JsonGenerator jgen, SerializerProvider provider,
+    public void serializeWithType(HibernateProxy value, JsonGenerator jgen, SerializationContext provider,
             TypeSerializer typeSer)
-        throws IOException
     {
         Object proxiedValue = findProxied(value);
         if (proxiedValue == null) {
-            provider.defaultSerializeNull(jgen);
+            provider.defaultSerializeNullValue(jgen);
             return;
         }
         /* This isn't exactly right, since type serializer really refers to proxy
@@ -203,9 +199,9 @@ public void serializeWithType(HibernateProxy value, JsonGenerator jgen, Serializ
 
     @Override
     public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType typeHint)
-        throws JsonMappingException
+        throws DatabindException
     {
-        SerializerProvider prov = visitor.getProvider();
+        SerializationContext prov = visitor.getContext();
         if ((prov == null) || (_property == null)) {
             super.acceptJsonFormatVisitor(visitor, typeHint);
         } else {
@@ -221,8 +217,7 @@ public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitor, JavaType t
     /**********************************************************************
      */
 
-    protected JsonSerializer<Object> findSerializer(SerializerProvider provider, Object value)
-        throws IOException
+    protected ValueSerializer<Object> findSerializer(SerializationContext provider, Object value)
     {
         /* TODO: if Hibernate did use generics, or we wanted to allow use of Jackson
          *  annotations to indicate type, should take that into account.
@@ -236,7 +231,11 @@ protected JsonSerializer<Object> findSerializer(SerializerProvider provider, Obj
          *   really anyone's guess at this point; proxies can exist at any level?
          */
         PropertySerializerMap.SerializerAndMapResult result =
-                _dynamicSerializers.findAndAddPrimarySerializer(type, provider, _property);
+                _dynamicSerializers.findAndAddPrimarySerializer(
+                        //TODO find better way to get JavaType
+                        TypeFactory.createDefaultInstance().unsafeSimpleType(type),
+                        provider,
+                        _property);
         if (_dynamicSerializers != result.map) {
             _dynamicSerializers = result.map;
         }