All Classes and Interfaces
Class
Description
Base implementation for the artefact type transformation.
Abstract transformer that takes an implementation class and creates methods
in a target ClassNode that delegate to that implementation class.
Abstract base class for Grails types that provides common functionality for
evaluating conventions within classes.
Abstract implementation that provides some default behaviours
Abstract implementation of the GrailsPluginManager interface
Configures Grails classes to be autowirable by name, always.
AbstractTypeConvertingMap is a Map with type conversion capabilities.
An annotation to mark controller methods as actions.
Extended marker interface that indicates this ClassInjector applies to all types of artefacts (but not all classes).
Injector applied to annotated (local transform) entities
Detects annotated domain classes for EJB3 style mappings.
A more limited version of Spring's annotation reader that only reads annotations on classes
Deprecated.
Similar to Groovy's @Delegate AST transform but instead assumes the first
argument to every method is 'this'.
The logic for the
ApiDelegate location transform.Used to define the artefact type for classes declared outside of Grails' usual conventions.
The ArtefactHandler interface's purpose is to allow the analysis of conventions within a Grails application.
Adapter for the
ArtefactHandler interfaceHolder for all the class-related info and structures relating to an Artefact.
A transformation used to apply transformers to classes not located in Grails
directory structure.
Enhances a class to contain an Errors property of type org.springframework.validation.Errors.
Marker annotation that for classes that transform Grails classes at the AST level.
Deprecated.
Use traits instead
Base functionality shared by
IncludingPluginFilter and
ExcludingPluginFilter.Adds timings of bean creation times logged to the "org.grails.startup" group
Adapter implementation of
BeanPostProcessor.Models a pre-compiled binary plugin.
Holds a reference to the parsed grails-plugin.xml descriptor and the
resource used to parse the descriptor
Wrapper for a value inside a cache that adds timestamp information
for expiration and prevents "cache storms" with a Lock.
URL converter that allows for camel case URLs
PlatformTransactionManager implementation that orchestrates transaction creation, commits and rollbacks to a
list of delegates.A
BeanDefinitionRegistryPostProcessor for using the "Best Effort 1 Phase Commit" (BE1PC) in Grails
applications when there are multiple data sources.Converts Strings to Class references for Spring.
When implemented allows additional properties to be injected into Grails
classes at compile time (ie when they are loaded by the GroovyClassLoader).
Convenience interface that can be implemented by classes that are registered by plugins.
Attempts to limit classpath searching to only locations relative to the given class
Extends Spring's default <context:component-scan/> element to ignore
generated classes.
A simple class that takes method invocations and property setters and populates
the arguments of these into the supplied map ignoring null values.
Loads locations starting with /WEB-INF from the Grails web-app directory.
A
Config composed of other ConfigsA interface for something that is constrained by various criteria
Deprecated.
Use org.grails.datastore.gorm.validation.constraints.eval.ConstraintsEvaluator instead
Lookup controllers for uris.
Core beans.
Loads core plugin classes.
Mutable holder of artefact info.
Default implementation of the GrailsApplication interface that manages application loading,
state, and artefact instances.
A default implementation for Grails classes that need to be registered and managed by a GrailsApplication,
but don't need any special handling.
Evaluates the conventions contained within controllers to perform auto-configuration.
Deprecated.
Default implementation of domain class injector interface that adds the 'id'
and 'version' properties and other previously boilerplate code.
Implementation of the GrailsPlugin interface that wraps a Groovy plugin class
and provides the magic to invoke its various methods from Java.
Handles the loading and management of plug-ins in the Grails system.
Trivial default implementation that always returns true and the object.
Default ResourceLocator implementation that doesn't take into account servlet loading.
Binding operations that are deferred until either validate() or save() are called.
Allows the construction of object graphs of domain classes.
Evaluates the conventions that define a domain class in Grails.
Dummy annotation to fool boot into not applying the real 'EnableAutoConfiguration' annotation.
An annotation for classes that are compile-time enhanced.
Can be applied to any Trait to indicate to Grails that the trait should be automatically added to the given artefact types
A class annotation used to make a class into a GORM domain class.
Methods specified to proxied entities
A PropertySource aware of the Grails environment and that resolves keys based on the environment from other property sources
Enum of the available events that Grails triggers.
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.Extends the Groovy Proxy implementation and adds proxying of property getters/setters.
A fork of the Spring 2.5.6 GenericBeanFactoryAccess class that was removed from Spring 3.0.
The main interface representing a running Grails application.
Convenience interface that can be implemented by classes that are
registered by plugins.
Implementation of
BeanPostProcessor
that recognizes GrailsApplicationAware
and injects and instance of GrailsApplication.Interface specific to Grails artefacts that returns the artefact type.
Helper methods for working with Groovy AST trees.
A class loader that is aware of Groovy sources and injection operations.
A Groovy compiler injection operation that uses a specified array of
ClassInjector instances to attempt AST injection.
Hacky version of the ByteArrayResource that implements the
GrailsByteArrayResource.getURL() method, required for the resource to work with Spring's
ServletContextResource.Represents any class in a Grails application.
Utility methods for dealing with Grails class artifacts.
Obtains the Grails ConfigObject via Spring.
Provides custom implementation of component-scan that ignores Groovy closures.
Represents a controller class in Grails.
Represents a data source in Grails.
Deprecated.
Use
PersistentEntity insteadMainly just a marker interface for implementations that perform injection on domain classes.
Thrown when creation of the Grails domain from the Grails domain classes fails.
Base class for all Grails exceptions that are not recoverable.
Provides utility methods for working with the Groovy MetaClass API.
Uses Grails' ConfigObject for place holder values.
Plugin interface that adds Spring
BeanDefinitions
to a registry based on a GrailsApplication object.Handles the loading and management of plug-ins in the Grails system.
Generic global runtime exception.
Extended version of
RuleBasedTransactionAttribute that ensures all exception types are rolled back and allows inheritance of setRollbackOnlyLoads the UrlMappings.
Grails utility methods for command line and GUI applications.
Enables AspectJ weaving from the application context.
Tells Spring always to proxy Groovy classes.
Extended marker interface that indicates this ClassInjector applies to GSPs.
Allows looking up key classes in a static context
URL converter that allows for hyphenated URLs
No-op implementation of
PluginFilter.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.Represents a Grails class that is to be configured in Spring and as such is injectable.
Simple singleton instance implementation of Spring's FactoryBean interface
mainly useful in unit tests
Thrown when a property of a Grails class is invalidated.
A map implementation that reads an objects properties lazily using Groovy's MetaClass.
Simple class that reports when meta class changes and where (in what stack frame) those changes took place
Deprecated.
As of Spring Framework 5.2, this class and related classes in this
package have been replaced by SimpleAnnotationMetadataReadingVisitor
and related classes for internal use within the framework.
The logic for the
Mixin location transform.Mocks the behavior of a FileResource.
Loads from the file system if its not found on the classpath.
Loads Resources from Strings that are registered as Mock resources.
An AST transform used to apply a named artefact type
Deprecated.
This class behavior is related to
NavigableMap which will be removed in future.Occurs when the creation of a new instance fails.
A dummy persistence context interceptor that does nothing.
Exception thrown when there was an error in the packing process of an application.
Allows objects to be aware of the Grails parent application context.
Sets up the persistent context before and after a Grails operation is invoked.
A marker annotation for methods added to a class that are for persistence purposes
A ReloadableResourceBundleMessageSource that is capable of loading message sources from plugins.
Defines interface for obtaining a sublist of
GrailsPlugin instances
based on an original supplied list of GrailsPlugin instances.Implements mechanism for figuring out what
PluginFilter
implementation to use based on a set of provided configuration properties.For implementors interested in obtaining a reference to the Grails PluginManager instance.
Auto-injects beans that implement PluginManagerAware.
FileSystemResourceLoader capable of understanding paths to plugins via the ResourceLocator interface
A config that accepts a prefix
A GrailsPluginManager implementation that outputs profile data to a logger.
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
Interface that defines logic for handling proxied instances
Spring-specific
MessageSource implementation
that accesses resource bundles using specified basenames, participating in the
Spring ApplicationContext's resource loading.Used to locate resources at development or production time.
Operations that should be executed on shutdown.
Simple implementation of the ResourceLoader interface that uses a Map to load resources.
Bridges Grails and Spring Resource APIs
A ResourceLoader that loads resources from a statically defined base resource.
A static resource locator that uses an internal map to locate resources.
Based on the Spring StopWatch class, but supporting nested tasks
Inner class to hold data about one task executed within the stop watch.
Indicates whether the Transformation/TraitInjector supports given ClassNode
Injects the platform transaction manager into beans that implement
TransactionManagerAware.URL converter interface for conversion strategies to implement
A handler for UrlMappings.
Thrown when validation fails during a .save().
Parses a Grails plugin's watchedResources property value into a list of
Replacement for Spring Boot's YAML loader that uses Grails' NavigableMap.
AnnotationMetadataReadingVisitor.