# Uses of Interface
org.springframework.aot.hint.TypeReference

Packages that use TypeReference
Package
Description
org.springframework.aot.generate
Support classes for components that contribute generated code equivalent to a runtime behavior.
org.springframework.aot.hint
Support for registering the need for reflection, resources, java serialization and proxies at runtime.
org.springframework.aot.hint.predicate
Predicate support for runtime hints.

## Uses of TypeReference in org.springframework.aot.generate

Classes in org.springframework.aot.generate that implement TypeReference
Modifier and Type
Class
Description
`final class`
`GeneratedTypeReference`
A `TypeReference` for a generated type.

## Uses of TypeReference in org.springframework.aot.hint

Classes in org.springframework.aot.hint that implement TypeReference
Modifier and Type
Class
Description
`class`
`AbstractTypeReference`
Base `TypeReference` implementation that ensures consistent behaviour for `equals()`, `hashCode()`, and `toString()` based on the canonical name.
Methods in org.springframework.aot.hint that return TypeReference
Modifier and Type
Method
Description
`TypeReference`
AbstractTypeReference.`getEnclosingType()`
`TypeReference`
TypeReference.`getEnclosingType()`
Return the enclosing type reference, or `null` if this type reference does not have an enclosing type.
`TypeReference`
ConditionalHint.`getReachableType()`
Return the type that should be reachable for this hint to apply, or `null` if this hint should always been applied.
`TypeReference`
JavaSerializationHint.`getReachableType()`
`TypeReference`
JdkProxyHint.`getReachableType()`
`TypeReference`
ResourceBundleHint.`getReachableType()`
`TypeReference`
ResourcePatternHint.`getReachableType()`
`TypeReference`
TypeHint.`getReachableType()`
`TypeReference`
JavaSerializationHint.`getType()`
Return the `type` that needs to be serialized using Java serialization at runtime.
`TypeReference`
TypeHint.`getType()`
Return the type that this hint handles.
`static TypeReference`
TypeReference.`of(Class<?> type)`
Create an instance based on the specified type.
`static TypeReference`
TypeReference.`of(String className)`
Create an instance based on the specified class name.
Methods in org.springframework.aot.hint that return types with arguments of type TypeReference
Modifier and Type
Method
Description
`List<TypeReference>`
ExecutableHint.`getParameterTypes()`
Return the parameter types of the executable.
`List<TypeReference>`
JdkProxyHint.`getProxiedInterfaces()`
Return the interfaces to be proxied.
`static List<TypeReference>`
TypeReference.`listOf(Class<?>... types)`
Create a list of `type references` mapped by the specified types.
Methods in org.springframework.aot.hint with parameters of type TypeReference
Modifier and Type
Method
Description
`int`
AbstractTypeReference.`compareTo(TypeReference other)`
`ResourcePatternHints.Builder`
ResourcePatternHints.Builder.`excludes(TypeReference reachableType, String... excludes)`
Exclude resources matching the specified patterns.
`TypeHint`
ReflectionHints.`getTypeHint(TypeReference type)`
Return the reflection hints for the type defined by the specified `TypeReference`.
`ResourcePatternHints.Builder`
ResourcePatternHints.Builder.`includes(TypeReference reachableType, String... includes)`
Include resources matching the specified patterns.
`static JdkProxyHint.Builder`
JdkProxyHint.`of(TypeReference... proxiedInterfaces)`
Initialize a builder with the proxied interfaces to use.
`JavaSerializationHint.Builder`
JavaSerializationHint.Builder.`onReachableType(TypeReference reachableType)`
Make this hint conditional on the fact that the specified type can be resolved.
`JdkProxyHint.Builder`
JdkProxyHint.Builder.`onReachableType(TypeReference reachableType)`
Make this hint conditional on the fact that the specified type can be resolved.
`ResourceBundleHint.Builder`
ResourceBundleHint.Builder.`onReachableType(TypeReference reachableType)`
Make this hint conditional on the fact that the specified type can be resolved.
`TypeHint.Builder`
TypeHint.Builder.`onReachableType(TypeReference reachableType)`
Make this hint conditional on the fact that the specified type is in a reachable code path from a static analysis point of view.
`JdkProxyHint.Builder`
JdkProxyHint.Builder.`proxiedInterfaces(TypeReference... proxiedInterfaces)`
Add the specified interfaces that the proxy should implement.
`ProxyHints`
ProxyHints.`registerJdkProxy(TypeReference... proxiedInterfaces)`
Register that a JDK proxy implementing the interfaces defined by the specified type references is required.
`ReflectionHints`
ReflectionHints.`registerType(TypeReference type, Consumer<TypeHint.Builder> typeHint)`
Register or customize reflection hints for the type defined by the specified `TypeReference`.
`ReflectionHints`
ReflectionHints.`registerType(TypeReference type, MemberCategory... memberCategories)`
Register or customize reflection hints for the specified type using the specified `MemberCategories`.
`ResourceHints`
ResourceHints.`registerType(TypeReference type)`
Register that the bytecode of the type defined by the specified `TypeReference` should be made available at runtime.
`SerializationHints`
SerializationHints.`registerType(TypeReference type)`
Register that the type defined by the specified `TypeReference` need to be serialized using java serialization.
`SerializationHints`
SerializationHints.`registerType(TypeReference type, Consumer<JavaSerializationHint.Builder> serializationHint)`
Register that the type defined by the specified `TypeReference` need to be serialized using java serialization.
Method parameters in org.springframework.aot.hint with type arguments of type TypeReference
Modifier and Type
Method
Description
`ReflectionHints`
ReflectionHints.`registerTypes(Iterable<TypeReference> types, Consumer<TypeHint.Builder> typeHint)`
Register or customize reflection hints for the types defined by the specified list of `type references`.
`TypeHint.Builder`
TypeHint.Builder.`withConstructor(List<TypeReference> parameterTypes, ExecutableMode mode)`
Register the need for reflection on the constructor with the specified parameter types, using the specified `ExecutableMode`.
`TypeHint.Builder`
TypeHint.Builder.`withMethod(String name, List<TypeReference> parameterTypes, ExecutableMode mode)`
Register the need for reflection on the method with the specified name and parameter types, using the specified `ExecutableMode`.
Constructors in org.springframework.aot.hint with parameters of type TypeReference
Modifier
Constructor
Description
`protected`
`AbstractTypeReference(String packageName, String simpleName, TypeReference enclosingType)`

## Uses of TypeReference in org.springframework.aot.hint.predicate

Methods in org.springframework.aot.hint.predicate with parameters of type TypeReference
Modifier and Type
Method
Description
`Predicate<RuntimeHints>`
ProxyHintsPredicates.`forInterfaces(TypeReference... interfaces)`
Return a predicate that checks whether a `JdkProxyHint` is registered for the given interfaces.
`Predicate<RuntimeHints>`
ResourceHintsPredicates.`forResource(TypeReference type, String resourceName)`
Return a predicate that checks whether a resource hint is registered for the given resource name, located in the given type's package.
`ReflectionHintsPredicates.TypeHintPredicate`
ReflectionHintsPredicates.`onType(TypeReference typeReference)`
Return a predicate that checks whether a reflection hint is registered for the given type.
`Predicate<RuntimeHints>`
SerializationHintsPredicates.`onType(TypeReference typeReference)`
Return a predicate that checks whether a `serialization hint` is registered for the given type reference.