All Classes

Class	Description
AbstractArtefactTypeAstTransformation	Base implementation for the artefact type transformation.
AbstractGrailsApplication
AbstractGrailsArtefactTransformer	Abstract transformer that takes an implementation class and creates methods in a target ClassNode that delegate to that implementation class.
AbstractGrailsClass	Abstract base class for Grails types that provides common functionality for evaluating conventions within classes.
AbstractGrailsPlugin	Abstract implementation that provides some default behaviours
AbstractGrailsPluginManager	Abstract implementation of the GrailsPluginManager interface
AbstractInjectableGrailsClass	Configures Grails classes to be autowirable by name, always.
AbstractTypeConvertingMap	AbstractTypeConvertingMap is a Map with type conversion capabilities.
Action	An annotation to mark controller methods as actions.
AllArtefactClassInjector	Extended marker interface that indicates this ClassInjector applies to all types of artefacts (but not all classes).
AnnotatedClassInjector	Injector applied to annotated (local transform) entities
AnnotationDomainClassArtefactHandler	Detects annotated domain classes for EJB3 style mappings.
AnnotationMetadataReader	A more limited version of Spring's annotation reader that only reads annotations on classes
ApiDelegate	Similar to Groovy's @Delegate AST transform but instead assumes the first argument to every method is 'this'.
ApiDelegateTransformation	The logic for the ApiDelegate location transform.
ApplicationAttributes
Artefact	Used to define the artefact type for classes declared outside of Grails' usual conventions.
ArtefactHandler	The ArtefactHandler interface's purpose is to allow the analysis of conventions within a Grails application.
ArtefactHandlerAdapter	Adapter for the ArtefactHandler interface
ArtefactInfo	Holder for all the class-related info and structures relating to an Artefact.
ArtefactTypeAstTransformation	A transformation used to apply transformers to classes not located in Grails directory structure.
ASTErrorsHelper	Enhances a class to contain an Errors property of type org.springframework.validation.Errors.
AstTransformer	Marker annotation that for classes that transform Grails classes at the AST level.
ASTValidationErrorsHelper
BaseApiProvider	Deprecated. Use traits instead
BasePluginFilter	Base functionality shared by IncludingPluginFilter and ExcludingPluginFilter.
BeanCreationProfilingPostProcessor	Adds timings of bean creation times logged to the "org.grails.startup" group
BeanPostProcessorAdapter	Adapter implementation of BeanPostProcessor.
BinaryGrailsPlugin	Models a pre-compiled binary plugin.
BinaryGrailsPluginDescriptor	Holds a reference to the parsed grails-plugin.xml descriptor and the resource used to parse the descriptor
CacheEntry<V>	Wrapper for a value inside a cache that adds timestamp information for expiration and prevents "cache storms" with a Lock.
CacheEntry.UpdateException
CamelCaseUrlConverter	URL converter that allows for camel case URLs
ChainedTransactionManager	PlatformTransactionManager implementation that orchestrates transaction creation, commits and rollbacks to a list of delegates.
ChainedTransactionManagerPostProcessor	A BeanDefinitionRegistryPostProcessor for using the "Best Effort 1 Phase Commit" (BE1PC) in Grails applications when there are multiple data sources.
ClassEditor	Converts Strings to Class references for Spring.
ClassInjector	When implemented allows additional properties to be injected into Grails classes at compile time (ie when they are loaded by the GroovyClassLoader).
ClassLoaderAware	Convenience interface that can be implemented by classes that are registered by plugins.
ClassLoaderAwareBeanPostProcessor
ClassRelativeResourcePatternResolver	Attempts to limit classpath searching to only locations relative to the given class
ClosureClassIgnoringComponentScanBeanDefinitionParser	Extends Spring's default <context:component-scan/> element to ignore generated classes.
ClosureToMapPopulator	A simple class that takes method invocations and property setters and populates the arguments of these into the supplied map ignoring null values.
CommandLineResourceLoader	Loads locations starting with /WEB-INF from the Grails web-app directory.
CompositeConfig	A Config composed of other Configs
Constrained	A interface for something that is constrained by various criteria
ConstraintsEvaluator	Deprecated. Use org.grails.datastore.gorm.validation.constraints.eval.ConstraintsEvaluator instead
ControllerArtefactHandler	Lookup controllers for uris.
CoreConfiguration	Core beans.
CorePluginFinder	Loads core plugin classes.
DefaultArtefactInfo	Mutable holder of artefact info.
DefaultGrailsApplication	Default implementation of the GrailsApplication interface that manages application loading, state, and artefact instances.
DefaultGrailsClass	A default implementation for Grails classes that need to be registered and managed by a GrailsApplication, but don't need any special handling.
DefaultGrailsControllerClass	Evaluates the conventions contained within controllers to perform auto-configuration.
DefaultGrailsDomainClass	Deprecated.
DefaultGrailsDomainClassInjector	Default implementation of domain class injector interface that adds the 'id' and 'version' properties and other previously boilerplate code.
DefaultGrailsPlugin	Implementation of the GrailsPlugin interface that wraps a Groovy plugin class and provides the magic to invoke its various methods from Java.
DefaultGrailsPluginManager	Handles the loading and management of plug-ins in the Grails system.
DefaultGrailsServiceClass
DefaultGrailsUrlMappingsClass
DefaultProxyHandler	Trivial default implementation that always returns true and the object.
DefaultResourceLocator	Default ResourceLocator implementation that doesn't take into account servlet loading.
DeferredBindingActions	Binding operations that are deferred until either validate() or save() are called.
DomainBuilder	Allows the construction of object graphs of domain classes.
DomainBuilder.DefaultGrailsChildPropertySetter
DomainClassArtefactHandler	Evaluates the conventions that define a domain class in Grails.
EnableAutoConfiguration	Dummy annotation to fool boot into not applying the real 'EnableAutoConfiguration' annotation.
Enhanced	An annotation for classes that are compile-time enhanced.
Enhances	Can be applied to any Trait to indicate to Grails that the trait should be automatically added to the given artefact types
Entity	A class annotation used to make a class into a GORM domain class.
EntityASTTransformation
EntityProxyHandler	Methods specified to proxied entities
EnvironmentAwarePropertySource	A PropertySource aware of the Grails environment and that resolves keys based on the environment from other property sources
Event	Enum of the available events that Grails triggers.
ExcludingPluginFilter	Implementation of PluginFilter which removes that all of the supplied plugins (identified by name) as well as their dependencies are omitted from the filtered plugin list.
ExtendedProxy	Extends the Groovy Proxy implementation and adds proxying of property getters/setters.
GenericBeanFactoryAccessor	A fork of the Spring 2.5.6 GenericBeanFactoryAccess class that was removed from Spring 3.0.
GrailsApplication	The main interface representing a running Grails application.
GrailsApplicationAware	Convenience interface that can be implemented by classes that are registered by plugins.
GrailsApplicationAwareBeanPostProcessor	Implementation of BeanPostProcessor that recognizes GrailsApplicationAware and injects and instance of GrailsApplication.
GrailsArtefactClassInjector	Interface specific to Grails artefacts that returns the artefact type.
GrailsASTUtils	Helper methods for working with Groovy AST trees.
GrailsAwareClassLoader	A class loader that is aware of Groovy sources and injection operations.
GrailsAwareInjectionOperation	A Groovy compiler injection operation that uses a specified array of ClassInjector instances to attempt AST injection.
GrailsByteArrayResource	Hacky version of the ByteArrayResource that implements the GrailsByteArrayResource.getURL() method, required for the resource to work with Spring's ServletContextResource.
GrailsClass	Represents any class in a Grails application.
GrailsClassUtils	Utility methods for dealing with Grails class artifacts.
GrailsConfigurationAware	Obtains the Grails ConfigObject via Spring.
GrailsConfigurationException
GrailsContextNamespaceHandler	Provides custom implementation of component-scan that ignores Groovy closures.
GrailsControllerClass	Represents a controller class in Grails.
GrailsDataSource	Represents a data source in Grails.
GrailsDomainClass	Deprecated. Use PersistentEntity instead
GrailsDomainClassInjector	Mainly just a marker interface for implementations that perform injection on domain classes.
GrailsDomainException	Thrown when creation of the Grails domain from the Grails domain classes fails.
GrailsException	Base class for all Grails exceptions that are not recoverable.
GrailsMetaClassUtils	Provides utility methods for working with the Groovy MetaClass API.
GrailsPlaceholderConfigurer	Uses Grails' ConfigObject for place holder values.
GrailsPlugin	Plugin interface that adds Spring BeanDefinitions to a registry based on a GrailsApplication object.
GrailsPluginManager	Handles the loading and management of plug-ins in the Grails system.
GrailsRuntimeException	Generic global runtime exception.
GrailsServiceClass
GrailsTransactionAttribute	Extended version of RuleBasedTransactionAttribute that ensures all exception types are rolled back and allows inheritance of setRollbackOnly
GrailsUrlMappingsClass	Loads the UrlMappings.
GrailsUtil	Grails utility methods for command line and GUI applications.
GroovyAwareAspectJAwareAdvisorAutoProxyCreator	Enables AspectJ weaving from the application context.
GroovyAwareInfrastructureAdvisorAutoProxyCreator	Tells Spring always to proxy Groovy classes.
GroovyAwareNamedTransactionAttributeSource
GroovyPageInjector	Extended marker interface that indicates this ClassInjector applies to GSPs.
Holders	Allows looking up key classes in a static context
HyphenatedUrlConverter	URL converter that allows for hyphenated URLs
IdentityPluginFilter	No-op implementation of PluginFilter.
IncludingPluginFilter	Implementation of PluginFilter which ensures that only the supplied plugins (identified by name) as well as their dependencies are included in the filtered plugin list.
InjectableGrailsClass	Represents a Grails class that is to be configured in Spring and as such is injectable.
InstanceFactoryBean<T>	Simple singleton instance implementation of Spring's FactoryBean interface mainly useful in unit tests
InvalidPropertyException	Thrown when a property of a Grails class is invalidated.
LazyMetaPropertyMap	A map implementation that reads an objects properties lazily using Groovy's MetaClass.
MetaClassChangeReporter	Simple class that reports when meta class changes and where (in what stack frame) those changes took place
Mixin
MixinTransformation	The logic for the Mixin location transform.
MockFileResource	Mocks the behavior of a FileResource.
MockGrailsPluginManager
MockResourceLoader	Loads from the file system if its not found on the classpath.
MockStringResourceLoader	Loads Resources from Strings that are registered as Mock resources.
NamedArtefactTypeAstTransformation	An AST transform used to apply a named artefact type
NavigableMapConfig	Deprecated. This class behavior is related to NavigableMap which will be removed in future.
NavigableMapConfig.ClassConversionException
NewInstanceCreationException	Occurs when the creation of a new instance fails.
NullPersistentContextInterceptor	A dummy persistence context interceptor that does nothing.
OptimizedAutowireCapableBeanFactory	Deprecated.
PackagingException	Exception thrown when there was an error in the packing process of an application.
Pair<A,B>
ParentApplicationContextAware	Allows objects to be aware of the Grails parent application context.
PersistenceContextInterceptor	Sets up the persistent context before and after a Grails operation is invoked.
PersistenceMethod	A marker annotation for methods added to a class that are for persistence purposes
PluginAwareResourceBundleMessageSource	A ReloadableResourceBundleMessageSource that is capable of loading message sources from plugins.
PluginFilter	Defines interface for obtaining a sublist of GrailsPlugin instances based on an original supplied list of GrailsPlugin instances.
PluginFilterRetriever	Implements mechanism for figuring out what PluginFilter implementation to use based on a set of provided configuration properties.
PluginManagerAware	For implementors interested in obtaining a reference to the Grails PluginManager instance.
PluginManagerAwareBeanPostProcessor	Auto-injects beans that implement PluginManagerAware.
PluginPathAwareFileSystemResourceLoader	FileSystemResourceLoader capable of understanding paths to plugins via the ResourceLocator interface
PrefixedConfig	A config that accepts a prefix
ProfilingGrailsPluginManager	A GrailsPluginManager implementation that outputs profile data to a logger.
PropertiesEditor	Fixed version of Spring's PropertiesEditor that converts all keys and values to String values java.util.Properties should only contain String keys and values
PropertySourcesConfig
ProxyHandler	Interface that defines logic for handling proxied instances
ReloadableResourceBundleMessageSource	Spring-specific MessageSource implementation that accesses resource bundles using specified basenames, participating in the Spring ApplicationContext's resource loading.
ReloadableResourceBundleMessageSource.PropertiesHolderCacheEntry
ResourceLocator	Used to locate resources at development or production time.
RuntimeSpringConfigUtilities
ServiceArtefactHandler
ShutdownOperations	Operations that should be executed on shutdown.
SimpleMapResourceLoader	Simple implementation of the ResourceLoader interface that uses a Map to load resources.
SpringResource	Bridges Grails and Spring Resource APIs
StaticResourceLoader	A ResourceLoader that loads resources from a statically defined base resource.
StaticResourceLocator	A static resource locator that uses an internal map to locate resources.
StopWatch	Based on the Spring StopWatch class, but supporting nested tasks
StopWatch.TaskInfo	Inner class to hold data about one task executed within the stop watch.
SupportsClassNode	Indicates whether the Transformation/TraitInjector supports given ClassNode
TraitInjectionUtils
TraitInjector
TransactionManagerAware
TransactionManagerPostProcessor	Injects the platform transaction manager into beans that implement TransactionManagerAware.
Triple<A,B,C>
UrlConverter	URL converter interface for conversion strategies to implement
UrlMappingsArtefactHandler	A handler for UrlMappings.
ValidationException	Thrown when validation fails during a .save().
WatchPatternParser	Parses a Grails plugin's watchedResources property value into a list of
YamlPropertySourceLoader	Replacement for Spring Boot's YAML loader that uses Grails' NavigableMap.