All Classes and Interfaces
Class
Description
Helper that builds the message with stacktrace.
Base class for
MetadataReaderFactory
and ResourcePatternResolver.Annotation that merges
EnableAcrossContext together with Spring Boot configuration classes
for web applications.Tracks requested auto-configuration classes and determines which action should be taken:
- allow the auto-configuration class (on the application level)
- inject the auto-configuration class in another module instead
- inject another configuration class instead of the one requested
- simply reject it
ApplicationContext that allows a set of preregistered singletons to be passed in.
Holds the Spring ApplicationContext information for the AcrossContext or an AcrossModule.
Custom
SpringApplication extension that will immediately use an AcrossListableBeanFactory
as the bean factory for the root ApplicationContext.SpringApplicationBuilder extension that will use an AcrossApplicationRunner
instead of a regular SpringApplication.SpringBootServletInitializer extension which ensures an AcrossApplicationRunner
is being used instead of a regular SpringApplication.Defers the actual import selection to Across.
Represents the global bootstrap configuration for the AcrossContext.
Interface to be implemented by any bean from a parent context that allows customization
of either the
AcrossBootstrapConfig of the context, or any ModuleBootstrapConfig.Specialization of
AcrossException for wrapping non-Across exceptions thrown during the actual bootstrapping of the context.Builds the list of all installers in a configured AcrossContext.
Takes care of bootstrapping an entire across context.
Used for creating an Across startup time report.
This implementation mimics a
CompositeCacheManager,
but overrides its default behaviour regarding the noop cache fallback as well as the internal ordering of the cache managers.Installs the common Across Context beans that are always available.
Interface the ApplicationContext must implement for Across to be able to use it.
Utility loader for retrieving data from META-INF/across.configuration file.
Specialization of
AcrossException used to indicate a configuration error.Main class representing a set of Across modules.
Custom implementation of
ApplicationEventMulticaster for use in a single AcrossContext.Provides access to all BeanFactories present in an AcrossContext.
Event published after the AcrossContext has bootstrapped.
Convenience builder for an
AcrossContext.Creates an AcrossContext bean and will apply all AcrossContextConfigurer instances
before bootstrapping.
Interface to implement when delegate configuration of an AcrossContext.
Holds the intermediate and final state of a running AcrossContext.
Custom
DelegatingMessageSource that allows
subscribing additional MessageSources.Helper methods for AcrossContext configuration.
Custom configuration that modifies the Across context bootstrapper in case
of a web application.
Special bean that takes care of installing the very minimum schema for module installation versioning.
Conditional annotation that can be put on an Across module descriptor to define the other Across modules it depends on.
Bean that is created if development mode is active on the AcrossContext.
Configuration that automatically adds a
AcrossDynamicModulesConfigurer that uses the importing class
as a base for the dynamic modules.AcrossContextConfigurer bean that will add dynamic modules to an AcrossContext.Marker interface.
Marker interface used for events published by Across core.
Generic base class for exceptions thrown by Across processing.
Provides the installer configuration for an AcrossContext.
Specialization of
AcrossException for an exception that occurred during the execution of an installer.Central repository interface for managing the installer execution tracking records.
Responsible for bootstrapping an Across context.
Base class for events published by Across core during the bootstrap (and shutdown) phase of an Across context.
Dispatching interface for intercepting
AcrossLifecycleEvent in situations where
EventListener can not be used (eg. in the parent
ApplicationContext of an Across context).Custom implementation of
DefaultLifecycleProcessor which excludes exposed beans.Responsible for shutting down an
AcrossContext.This class is the base for Installers which run liquibase update on installation
Extends a
DefaultListableBeanFactory
with support for Exposed beans.Event that is sent right before the module is bootstrapped.
Represents the actual configuration that will be used to bootstrap a module.
Converts a set of
AcrossModuleDescriptors into the actual AcrossModuleBootstrapConfigurations that
should be used to startup the module context.Event published when a module has bootstrapped.
Represents the actual configuration that will be bootstrapped for a module.
Represents the original descriptor of an Across module, as defined by an
AcrossModule implementation.Responsible for building the entire set of
AcrossModuleDescriptor instances for a defined
collection of modules.Extension of
ReloadableResourceBundleMessageSource.Dependency hints - impact the bootstrapping order of modules.
Across context related utility methods for modules.
A specifier that contains the different Across order related attributes.
A multi-level comparator for sorting beans scanned from the modules in an AcrossContext.
Utility class for resolving order annotations.
Marker interface.
AcrossRole annotations impact the bootstrapping order of AcrossModules.
ServletContextInitializer that ensures that the AcrossContext is bootstrapped before the
ServletContext is fully initialized.Contains version information for an
AcrossEntity.Supports Spring Boot configuration of an
AcrossContext, ensures bootstrap of the
AcrossContext is done before the web server starts.WebApplicationContext that allows a set of preregistered singletons to be passed in.
Simple implementation for specifying annotated classes an ApplicationContext should register.
Filter that searches for beans having a method with the specific annotation.
Beans or definitions with any of the given annotations will be copied.
Adapter class that implements the ApplicationContextConfigurer interface.
Represents the actual collection of
ApplicationContextConfigurer
that should be loaded for a AcrossModuleBootstrapConfiguration and its extensions.A utility class that generates an easily readable String for use in
Configures dynamic application modules for an
AcrossApplication.Extension to
AttributeSupport that optionally takes a parent ReadableAttributes instance.Support class for
WritableAttributes, providing a base implementation of all methods.Will apply all configured BeanDefinitionTransformers in the order registered.
Helper used to filter the beans that should be exposed to the parent context.
Holds any number of BeanFilter implementations and will delegate calls to all of them.
Will add a prefix to all bean names, and will camelCase if required (default).
Transformer that allows defining a new name for specific bean names.
Modules implementing this interface can modify the BootstrapFactories.
In charge of creating the ApplicationContext and loading all the beans.
Instance that manages the distributed lock for an Across context bootstrap.
Fired when an instance representing some form of registry is being built.
Filters on any number of specific classes.
Based on
ClassPathScanningCandidateComponentProvider, this class
scans class path resources to detect valid AcrossModule implementations that could
be autoconfigured.Provider that finds direct child packages for a given package.
Scanner to detect installer beans from one or more class paths.
Scans a set of base packages to find all classes annotated with
ModuleConfiguration.Implementation of
ModuleDependencyResolver that uses a ClassPathScanningCandidateModuleProvider
to determine the modules that can be resolved.Base configuration for a module
ApplicationContext.Simple implementation for specifying packages an ApplicationContext should scan.
Conditional annotation that can be put on an @Configuration class, @Bean method or any component.
Conditional to check that an auto-configuration class has been configured in the Across application.
Conditional that only matches when the application context is a web application
context and the ServletContext that it is a part of allows customization.Condition to be used on beans and configuration classes that should only execute if development mode is active.
Conditional that only matches when the application context is not a web application, or
the ServletContext is already fully initialized.Used on AcrossContext to determine to which level the configurers should be applied.
Utility to quickly get some properties of a data source.
Dynamic instance of an Across module.
Factory bean that creates a
DynamicAcrossModule instance based on a root package and the parameters
passed in.Default empty AcrossModule with a configurable name.
Using this annotation on a
Configuration class
will automatically create an AcrossContext using the settings from this annotation.Beans having this annotation will be exposed to the parent context.
Represents an exposed BeanDefinition.
Apply modification to a set of BeanDefinitions and singletons.
Simple
AcrossBootstrapConfigurer that can be used to expose additional classes from modules.Registry of all beans for an AcrossContext that are exposed to the parent ApplicationContext.
Builds a set of BeanDefinitions that should be exposed to other contexts.
Registers extensions determined by auto-configuration classes that have been requested.
Validation class that checks wrong use of @Configuration classes, either in a module
or on the application configuration level.
Extends the
RefreshableRegistry by scanning for members
every time a module has bootstrapped.Represents an attribute value in a
ReadableAttributes hierarchy.Used to indicate installer metadata.
Implement to have a callback for resolving installer actions upon bootstrap.
Used to specify the label for a group of installers.
Holds all properties of an installer.
Used to specify a method to executed in an @Installer annotated class.
Determines during which phase the installer should execute.
Represents the reference to a single installer instance.
Determines when to execute an installer:
VersionDifferent: only if the @Installer.version() attribute is higher than the one currently installed
AlwaysRun: always execute this installer
Merges support for manually added installers with installers scanned from packages.
Class representing the installer settings for a configured AcrossContext.
Annotation to indicate that beans should only be used internally in the module.
Allows registering additional
ContextAnnotationAutowireCandidateResolver classes that will be taken into account
to determine if a certain DependencyDescriptor is lazy or not.Takes care of building the MessageSourceHierarchy associated with an AcrossModule
or AcrossContext.
Qualifier that can be used to wire the AcrossModule or AcrossModuleInfo instance.
Represents the actual bootstrap configuration of an AcrossModule.
Creates an ordered list of all modules, depending on the AcrossDepends annotations configured.
Represents the status of an Across module
during the lifecycle of the context.
Extension of
Configuration to declare configurations
that should not be added to the current BeanDefinitionRegistry,
but rather be added to the registry of the modules specified in the ModuleConfiguration.value() attribute.Extends the default
AnnotationBeanNameGenerator to always use a fully qualified class name
as bean name in case of a Configuration or ModuleConfiguration class, as well
as for any class not annotated with Component (which is in fact the case for ModuleConfiguration).Represents a single configuration class that should be added as an extension configuration to a module.
Responsible for importing
ModuleConfiguration classes and other
configuration classes that have been added from other modules.Represents a collection of - usually {@link @ModuleConfiguration} - classes, mapped on the module names they apply for.
Responsible for resolving an
AcrossModule by name.Represents a defined list of
AcrossModule instances and
their basic meta information.Helper that builds a
ModuleSet.Represents a modifiable configuration of an Across module.
Event with a specific name that can be used for name based filtering of events.
Filters beans on a set of allowed bean names.
Extension of
EventListenerMethodProcessor to be injected in modules.Registers the Across compatible
EventListenerMethodProcessor, replaces the original one from Spring.Interface that defines the order of an instance within the AcrossModule.
Annotation that defines ordering inside the AcrossModule.
Applies to all classes that are in one of the given packages.
Simple implementation for adding BeanFactoryPostProcessors to an ApplicationContext.
Marks a method as to be autowired by Spring's dependency injection facilities,
after the Across context has been bootstrapped.
Will register the bean definitions as primary beans.
Helper class that wraps around a singleton to register it as primary bean under that name.
Enables property placeholder support in the application context, by creating
a default PropertySourcesPlaceholderConfigurer.
Allows specifying a ProvidedBeansMap to provide to an ApplicationContext.
Special object map that represent a collection of beans: either singleton
or bean definitions (or a combination).
Interface defining a generic contract for accessing metadata from arbitrary objects.
All beans having this annotation will get their properties refreshed once the
entire AcrossContext has been bootstrapped.
Annotation to use on fields that need to be autowired with a
RefreshableRegistry collection type instead
of the collection of beans from the ApplicationContext.The RefreshableRegistry is a simple bean holding a collection of instances and provides more flexibility than
autowiring a list of instances directly.
ResolvableTypeProviderPayloadApplicationEvent<T extends org.springframework.core.ResolvableTypeProvider>
Extension to
PayloadApplicationEvent where the payload itself defines the ResolvableType directly.Interface representing a particular revision of an entity.
Interface for entities that are related to a specificy
Revision.Base class for revision based interaction of entities.
Class encapsulating general database properties to be used when creating/updating the schema.
Registers a shared metadata reader for all Across related contexts.
Wrapper to force an instance to be configured as a singleton in a ProvidedBeansMap.
Simple configurer to provide a singleton bean.
Takes care of actions that need to happen whenever the parent Spring ApplicationContext
of the AcrossContext is refreshed.
Merge semantics for an Across environment are different: the standard property sources
are kept in the order of the parent environment.
Servlet version of an Across environment.
Default converter that tries a long list of default patterns for parsing a String back to a
Date or a TemporalAccessor
for a fixed (default: US) locale.Creates WebApplicationContext versions of the standard ApplicationContext.
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.