Annotation Interface ProtoSchema
SerializationContextInitializer
. Annotate a class or interface
extending from SerializationContextInitializer
with this annotation and a new concrete public class named
based on className()
, having a default no-arguments public constructor will be generated at compile time in
the same package. The implementations of the methods from SerializationContextInitializer
will be generated
based on the information provided in the attributes of this annotation.
This annotation is used at compile time annotation processing only and should not be relied upon at runtime, so its
retention is set to RetentionPolicy.CLASS
.
- Since:
- 5.0
- Author:
- [email protected]
-
Optional Element Summary
Modifier and TypeOptional ElementDescriptionString[]
The list of packages to scan (optional).The name of the generated Java implementation class (optional).Class<? extends SerializationContextInitializer>[]
TheSerializationContextInitializer
s that must be executed before this one.Class<?>[]
Classes to be explicitly excluded.Class<?>[]
Annotated classes to process (optional).boolean
Generate only the marshallers and skip the schema file.The generated Protobuf schema file name (optional).Generated Protobuf schema resource file path (optional).Package of the generated Protobuf schema.boolean
Enable generation of aMETA-INF/services
file for the generated implementation class of theSerializationContextInitializer
to be loadable by theServiceLoader
.Specifies the protobuf syntax used by the generated schema.String[]
A handy alias forbasePackages()
.
-
Element Details
-
className
String classNameThe name of the generated Java implementation class (optional). If missing, the name of the current class plus the "Impl" suffix is assumed by default.- Default:
- ""
-
schemaFileName
String schemaFileNameThe generated Protobuf schema file name (optional). It can contain'/'
characters, so it might appear like a relative or absolute file name. Must end with ".proto" suffix. The schema will be registered under this name in theSerializationContext
bySerializationContextInitializer.registerSchema(SerializationContext)
. If missing, the simple name of the annotated class plus the ".proto" suffix will be used by default.- Default:
- ""
-
schemaFilePath
String schemaFilePathGenerated Protobuf schema resource file path (optional). If this is present then a resource file is generated in the designated path, with the given file name, and will be available to the ClassLoader at runtime, otherwise the generated schema file is directly baked as a String constant into the generated class and no resource file is generated.- Default:
- ""
-
schemaPackageName
String schemaPackageNamePackage of the generated Protobuf schema. This is optional. If the package name is not specified then the unnamed/default package is assumed.- Default:
- ""
-
value
String[] valueA handy alias forbasePackages()
.value
andbasePackages()
are mutually exclusive. SeebasePackages()
for usage.- Default:
- {}
-
basePackages
String[] basePackagesThe list of packages to scan (optional).basePackages
andincludeClasses()
are mutually exclusive. The packages are scanned for annotated classes recursively. IfbasePackages
is empty then all packages are considered, starting from root and including the default (unnamed) package. The packages are filtered based on theexcludeClasses()
filter. If neitherincludeClasses()
norbasePackages
is specified then the entire source path is scanned. Be wary of using this last option in anything but very simple demo projects.- Default:
- {}
-
includeClasses
Class<?>[] includeClassesAnnotated classes to process (optional). IfincludeClasses
is empty, allProtoXyz
annotated classes that belong to the packages listed inbasePackages()
will be scanned. If neitherincludeClasses
norbasePackages()
was specified then the entire source path will be scanned. Be wary of using this last option in anything but very simple demo projects.- Default:
- {}
-
excludeClasses
Class<?>[] excludeClassesClasses to be explicitly excluded.excludeClasses
andincludeClasses()
are mutually exclusive. This can be used together withbasePackages()
.- Default:
- {}
-
service
boolean serviceEnable generation of aMETA-INF/services
file for the generated implementation class of theSerializationContextInitializer
to be loadable by theServiceLoader
. This defaults totrue
. The ProtoStream library does not make any use of theServiceLoader
to benefit from this mechanism but the user's application is free to use it.- Default:
- true
-
marshallersOnly
boolean marshallersOnlyGenerate only the marshallers and skip the schema file.The schema is actually always generated at compile time, in memory, so that various validations can be performed at compile time, but with this flag you effectively ensure it finally gets excluded from both the generated source code and the generated resource files and it does not get registered at runtime by this
SerializationContextInitializer
implementation. This flag is useful in cases where you want to register the schema manually for whatever reason or the schema is already provided/registered by other parts of your application.This option conflicts with
schemaFilePath()
and they cannot be used together. Also, this option cannot be set totrue
if the annotated element is a subtype ofGeneratedSchema
, which is expected to always provide a generated schema, as the name implies.- Default:
- false
-
dependsOn
Class<? extends SerializationContextInitializer>[] dependsOnTheSerializationContextInitializer
s that must be executed before this one. Classes or interfaces listed here must implementSerializationContextInitializer
and must also be annotated withAutoProtoSchemaBuilder
. Classes not annotated withProtoSchema
will result in a compilation error.- Default:
- {}
-
syntax
ProtoSyntax syntaxSpecifies the protobuf syntax used by the generated schema. Defaults toProtoSyntax.PROTO2
- Default:
- PROTO2
-