All Classes and Interfaces
Class
Description
An abstract class that serves as a foundation for injecting property values based on annotations.
The
AbstractValueTypeInjector is an abstract class that serves as a base for value type injectors.Registry class responsible for:
Registering beans by bean name and bean definition: The bean name is created using
AnnotationResolver and is the key of the DefaultBringBeanFactory.beanDefinitionMap.Represents an interface for resolving annotations on classes.
Annotation indicating that a field, constructor, or method should be autowired by the Bring IoC container.
The
Banner class provides functionality for printing a banner to the console,
either from a predefined string or custom banner by reading from a file.An enumeration of possible values for configuring the Banner.
Annotation indicating that a method will be used to create
Singleton or Prototype Beans.Exception thrown when a required annotation is missing on a bean.
Responsible for creating beans and injecting dependencies into these beans based on provided definitions.
Represents the definition of a bean within an application context.
Interface for registering bean definitions in a bean definition registry.
Interface to modify the bean factory before bean instantiation.
Interface for post-processing beans during their initialization phase.
Exception thrown to indicate limitations or issues during the construction of a BeanPostProcessor
within a Bring Dependency Injection framework.
The
BeanPostProcessorDefinitionFactory class is responsible for creating and managing a list
of BeanFactoryPostProcessor instances.The
BeanPostProcessorFactory class is responsible for creating and managing a list
of BeanPostProcessor instances.Annotation used to mark extensions for custom scanners, resolvers, or processors in the client's application.
Interface for registering beans with their associated definitions in a bean registry.
Enumeration representing the scope of beans in an application.
Utility class providing methods for resolving bean scopes and proxy modes based on annotations.
Enumeration representing different types of beans in an application based on their annotations.
The
BringApplication class provides a simple entry point to initialize and run a BringApplicationContext.The
BringApplicationContext class represents the core context for managing and initializing
the Bring application's beans.An interface representing a simplified Bean Factory, allowing retrieval of beans by type or name.
General-purpose exception used to wrap and propagate other exceptions within a system.
Implementation of BringSourceScanner for scanning properties files based on a specified type.
Implementation of BringSourceLoader for loading properties from files.
Interface for a Bring source loader, defining methods to retrieve file extensions and load resources.
Interface for scanning Bring sources to retrieve a list of files based on a specified type.
Defines an interface for scanning the classpath to discover classes.
Factory responsible for managing and handling classpath scanning operations for bean processing.
Indicates that an annotated class is a Bring component.
An implementation of AnnotationResolver specifically designed for resolving
component bean names based on the Component annotation.
Implementation of ClassPathScanner that scans for classes annotated with @Component using Reflections.
Annotation indicating that a class is a source of bean definitions.
This class implements the AnnotationResolver interface to resolve
the name of a configuration bean based on the presence of the Configuration annotation.
This class implements the ClassPathScanner interface to scan for classes annotated with Configuration.
This post processor registers bean definitions in the DefaultBringBeanFactory for beans -
methods annotated with
Bean annotation.Responsible for facilitating constructor-based dependency injection, the ConstructorBeanInjection class assists in
creating beans by instantiating classes through constructors annotated with @Autowired or utilizing
a single constructor without explicit @Autowired.
Configures a custom schedule with a specific core pool size for executing scheduled tasks.
Represents a custom scheduler utilizing a ScheduledExecutorService for task scheduling.
Exception thrown to indicate the presence of cyclic dependencies between beans
within a Bring Dependency Injection framework.
Default implementation of the BringBeanFactory interface providing basic bean management functionalities.
Responsible for injecting dependencies into fields of a bean using annotations like @Autowired or @Value.
Handles injection of values into fields that are interfaces and not assignable from java.util.Collection.
The
FieldListValueTypeInjector class is responsible for injecting dependencies into fields of type List.The
FieldMapValueTypeInjector class is responsible for handling field injections for types of Map.The
FieldQueueValueTypeInjector class is responsible for handling field injections for types of Queue.The
FieldSetValueTypeInjector class is responsible for handling field injections for types of Set.The
FieldValueTypeInjector interface defines methods for injecting values into fields annotated with the
@Value annotation.An implementation of AnnotationResolver designed for resolving bean names associated with interfaces.
Exception thrown to indicate that no constructor with the Autowired annotation is found for a bean class
within a Bring Dependency Injection framework.
Exception thrown to indicate that a requested bean does not exist within a Bring Dependency Injection framework.
Exception thrown to indicate that no unique bean is available or multiple beans match the expected type
within a Bring Dependency Injection framework.
@Order defines the sort order for an annotated component.Comparator implementation for objects marked Order, sorting
by order value ascending,A simple generic class representing a pair of two values: left and right.
Handles injection of values into parameters that are interfaces and not assignable from java.util.Collection.
The
ParameterListValueTypeInjector class is responsible for handling parameter injections for types of List.The
ParameterMapValueTypeInjector class is responsible for handling parameter injections for types of Map.The
ParameterQueueValueTypeInjector class is responsible for handling parameter injections for types of Queue.The
ParameterSetValueTypeInjector class is responsible for handling parameter injections for types of Set.ParameterValueTypeInjector is an interface that defines methods for injecting values into parameters
annotated with the @Value annotation.The
PostConstruct annotation is used on a method that needs
to be executed after dependency injection is done to perform any
initialization.The
PostConstructBeanPostProcessor is a custom implementation of the
BeanPostProcessor interface in the Bring framework, designed to
handle post-construction tasks for beans.Exception thrown when method annotated with @PostConstruct violates rules of usage such as have parameters.
The
PreDestroy annotation is used to signal that the annotated method
should be executed before the container removes the instance of the class
in which the method is declared.Exception thrown when method annotated with @PreDestroy violates rules of usage such as have parameters.
Indicates that a bean marked with this annotation is the primary candidate
when multiple beans of the same type are available for autowiring or injection.
Class responsible for resolving profile sources using BringSourceLoader and BringSourceScanner.
The `PropertyFieldValueTypeInjector` class is responsible for injecting property values into fields annotated with
Value.The `PropertyParameterValueTypeInjector` class is responsible for injecting property values into constructor parameters annotated with
Value.Exception thrown to indicate that a property value is not found within a Bring Dependency Injection framework.
Enumeration representing the modes of proxy functionality.
Utility class providing methods to create proxies.
Annotation used to qualify the selection of a bean when multiple beans of the same type
are available for autowiring or injection.
Utility class providing reflection-related functionalities, including methods for constructor instantiation,
field manipulation, method invocation, and annotation processing.
Inner class extending AnnotationParanamer to handle Qualifier annotations.
A BeanProcessor responsible for processing beans and registering methods annotated with @ScheduledTask
for scheduling via a CustomScheduler.
Annotation used to mark a method as a scheduled task.
Annotation indicating the visibility of a Bean.
Indicates that an annotated class is a Bring component.
An implementation of AnnotationResolver specifically designed for resolving
bean names associated with classes annotated with @Service.
Implementation of ClassPathScanner that scans for classes annotated with @Service using Reflections.
Responsible for injecting dependencies into setter methods of a bean using the @Autowired annotation.
The TypeCast class provides methods to perform type casting operations
between different object types in Java.
The
TypeResolverFactory class is responsible for creating instances of FieldValueTypeInjector
and ParameterValueTypeInjector implementations based on the provided configuration and classpath scanning.Indicates that the annotated element is to be resolved to a value.
This post processor populates properties for the DefaultBringBeanFactory using ProfileSourceResolve.