spring reading Download - spring reading Source code download

spring reading

JAVA source code

1.0.0

Download

Go deep into Spring and start from the source code!

Explore Java's most popular framework, understand its internal mechanisms, and take you from beginner to proficient.

⚡Technology

Introduction

Hello everyone, my name is Lex?‍. I am a Java back-end developer with 8 years of experience and a programmer who is passionate about the Spring framework❤️. In order to help programmers who want to learn more about the Spring framework, I created this "Spring Source Code Reading Series". Through this series, I hope to explore the inner workings of Spring with you. If you have the same interest or questions, please contact me!

? Why do Spring source code analysis ?

In my work as a developer working on frameworks, I often encounter situations where I need to deeply understand and adjust framework behavior. These tasks are not just about simply using the framework's API, but also require a detailed understanding of the internal workings of the framework. Although there are simplified versions of Spring on Github, which are indeed very helpful for getting started, when it comes to real project applications, they are still very different from the real Spring framework. Therefore, I began to delve into the source code of Spring, hoping to understand its internal working mechanism more thoroughly so that I can better apply it to my actual work. Sharing my source code analysis is also to provide some reference and help to developers who want to truly understand Spring, not just use it.

Just give me a star

Dear friends, I really spent a lot of time researching and organizing this "Spring Source Code Reading Series". If you think this thing is not bad, or it has brought you a little help, please click the star. It really means a lot to me, and every star makes me feel like all the hard work is worth it. I know this is a small thing, but your click is the best encouragement to me. Anyway, thank you for taking the time to read my content, I really appreciate it!

?Spring source code reading series

Spring Core
- Resource loading and access
  - Resource: abstract interface, representing files, class paths, etc., used to access resources from different sources.
  - ResourceLoader: The core interface for resource acquisition, which implements the strategy of uniformly loading resources from different locations.
  - ResourcePatternResolver: Resource pattern resolution interface, used to flexibly load multiple resources in applications.
  - DocumentLoader: XML document loading and parsing core interface, supporting automatic configuration of Spring applications in the background.
- Metadata and filtering
  - MetadataReader: The core of class metadata acquisition, supporting advanced functions such as component scanning, conditional annotations, and AOP.
  - AnnotationMetadata: Dynamically obtain and operate runtime class annotation information.
  - TypeFilter: Customize class filtering during component scanning, supporting complex conditions and precise filtering.
  - Condition: Conditional judgment, a flexible mechanism that determines Bean creation and configuration.
- Validation, data binding and type conversion
  - Validator: Provides custom data validation logic to ensure that model objects meet business rules.
  - PropertyEditor: Customize the conversion logic of JavaBean properties and handle property type conversion.
  - Converter: used for conversion between different types, defining simple source to target type conversion rules.
  - ConverterFactory: Creates a converter for a specific source type for type conversion.
  - GenericConverter: A more complex converter that supports multiple source and target type conversions.
  - ConditionalConverter: A converter that chooses whether to perform conversion based on conditions.
  - ConversionService: Provides a unified type conversion service interface and manages converters.
  - Printer: Used to format objects into text, focusing on formatted output.
  - Parser: used to parse text into objects, focusing on parsing logic.
- Spring Expression Language (SpEL)
  - ExpressionParser: Parses a SpEL expression in string form, creates and returns an Expression instance.
  - Expression: The function of evaluating expression strings, supporting operations such as type conversion and obtaining original strings.
  - EvaluationContext: manages the context information of SpEL expressions.
  - PropertyAccessor: Used to read and write properties of objects, and can be used to implement custom property access logic.
  - ConstructorResolver: Parses the constructor to determine how the bean is instantiated.
  - MethodResolver: Resolve class methods to ensure correct calls, handle overloading and parameter matching.
  - BeanResolver: Parse bean definition, including dependencies, property settings, instantiation and return.
  - TypeLocator: dynamically searches for classes and returns Class objects, used in expression parsing, type conversion, etc.
  - TypeConverter: Type conversion function that converts data in an expression from one type to another.
  - TypeComparator: Type comparison function, which defines a method to compare whether two objects are equal.
  - OperatorOverloader: Operator overloading function, a method for customizing operators in expressions.
- Bean definition and registration
  - BeanDefinition: Describe Bean in detail and support core functions such as dependency injection, AOP, and scope control.
  - BeanDefinitionHolder: The key class for managing and operating BeanDefinition.
  - BeanDefinitionRegistry: Bean definition registration management key interface, processing Bean metadata.
- Bean definition reading and scanning
  - XmlBeanDefinitionReader: Load and parse XML configuration, build IOC container, and register Bean definition.
  - PropertiesBeanDefinitionReader: Properties file is loaded and parsed into Bean definition.
  - GroovyBeanDefinitionReader: Groovy scripts are parsed into Bean definitions.
  - AnnotatedBeanDefinitionReader: Annotation configuration, automatically scans and registers Spring components, and simplifies Bean definition configuration.
  - ClassPathBeanDefinitionScanner: Class path scanning registers Spring Beans, supporting automatic assembly.
- Bean factory
  - BeanFactory: Spring's core interface, providing basic functions for Bean configuration, creation, and management.
  - ListableBeanFactory: Supports obtaining a collection of beans by type.
  - HierarchicalBeanFactory: supports parent-child container relationship and implements the hierarchical structure of Bean definition.
  - ConfigurableBeanFactory: Provides extensions to BeanFactory configuration, such as property editor, scope, etc.
  - AutowireCapableBeanFactory: Core functional interface for Bean creation, initialization, injection, and destruction.
  - ConfigurableListableBeanFactory: Configurable Bean factory interface that supports configuration and list operations.
- container context
  - ClassPathXmlApplicationContext: The context in which the classpath loads the XML configuration file.
  - AnnotationConfigApplicationContext: The context for loading configuration information in the annotation configuration class.
  - GenericApplicationContext: Supports multiple configuration methods, XML, annotations, and manually registered contexts.
- Bean definition import and combination
  - ImportBeanDefinitionRegistrar: dynamically register beans at runtime to achieve flexible configuration and expand configuration class functions.
  - ImportSelector: dynamically import configuration classes at runtime to achieve conditional selection and flexible configuration.
  - DeferredImportSelector: Dynamically import configuration at runtime, supporting conditional selection and delayed loading by group.
- Bean life cycle
  - Bean definition registration process: loading and parsing configuration files, registering and parsing Bean definitions, class names, scopes, attributes, etc.
  - Bean initialization process: instantiation, property injection, Aware callback, post-processor, initialization method call.
  - Bean's dependency resolution process: declare dependencies, find dependencies, inject dependencies, handle circular dependencies, and delay dependency resolution.
  - Bean destruction process: destruction method call, interface callback, post-processing cleanup, notification triggering, GC resource recycling.
- Property parsing and environment configuration
  - PropertySource: An abstract class that manages various configuration sources and supports flexible loading and access of application configurations.
  - PropertySources: Used to uniformly manage and access multiple PropertySource instances, simplifying the processing of configuration data.
  - PropertyResolver: Universal property parsing, obtaining configuration values, handling missing properties, simple and flexible.
  - ConfigurablePropertyResolver: Property parsing configuration and placeholder settings to adapt to different configuration needs.
  - Environment: Application environment representation, providing attribute access, supporting configuration files, and realizing dynamic configuration.
  - ConfigurableEnvironment: Dynamically configure the application environment, activate and default configuration, and improve application flexibility.
- Bean initialization and extension points
  - InitializingBean: Provides an interface for executing custom logic during Bean initialization.
  - DisposableBean: Defines the interface for performing cleanup operations before the Bean is destroyed.
  - BeanDefinitionRegistryPostProcessor: Dynamically modify or add BeanDefinition when the container starts.
  - BeanFactoryPostProcessor: Globally modify or configure BeanFactory before instantiating the Bean.
  - BeanPostProcessor: Perform custom processing before and after Bean initialization, which can affect all Beans.
  - InstantiationAwareBeanPostProcessor: Provides deeper instantiation and property injection control.
  - DestructionAwareBeanPostProcessor: Allows additional cleanup operations before the Bean is destroyed.
  - MergedBeanDefinitionPostProcessor: Processes BeanDefinition when merging Bean definitions.
  - SmartInstantiationAwareBeanPostProcessor: Provides smarter instantiation control.
  - SmartInitializingSingleton: Execute custom logic after all singleton beans are initialized.
- Aware interface series
  - BeanNameAware: Let the Bean obtain its own name in the container.
  - BeanClassLoaderAware: Allows a bean to obtain its class loader.
  - BeanFactoryAware: Provides Bean to obtain the BeanFactory to which it belongs.
  - EnvironmentAware: Allows beans to obtain application environment configuration.
  - EmbeddedValueResolverAware: Allows beans to resolve embedded value placeholders.
  - ResourceLoaderAware: Allows beans to obtain resource loaders.
  - ApplicationEventPublisherAware: Allows the bean to publish application events.
  - MessageSourceAware: Allows the Bean to obtain the message source.
  - ApplicationContextAware: Allows beans to obtain application context.
  - ImportAware: Allows an imported configuration class to obtain information about the class that imported it.
- Core annotations
  - @Configuration: Declare the class as a configuration class and define dependencies between beans and beans.
  - @ComponentScan: Enables component scanning to automatically discover and register classes marked as components.
  - @Bean: Declare a method in the configuration class and return a Bean instance.
  - @Import: Introduce other configuration classes and merge their Bean definitions into the current container.
  - @PropertySource: Specify the property file and load external configuration into the environment.
  - @DependsOn: Specify the dependency order of beans to ensure that specific beans are initialized before other beans.
  - @Conditional: Determine whether to create a bean based on conditions.
  - @Lazy: Specifies lazy initialization of the bean, which is only created when it is first used.
  - @Value: Inject a simple value or expression into a Bean's field or method parameter.
  - @Autowired: Automatically assemble Bean dependencies.
  - @Primary: Specifies the preferred bean to be selected first among multiple candidate beans.
  - @Description: Provide descriptive information for the Bean.
  - @Role: Provides role hints for beans to distinguish beans of similar types.
  - @Indexed: Marks the bean for indexing.
  - @Order: Specify the loading order of beans.
- JSR specification
  - @Inject: JSR-330 standard dependency injection annotation.
  - @Named: JSR-330 standard naming annotation.
  - @Resource: Java EE standard resource injection annotation.
  - @Qualifier: used to qualify injected beans.
  - @Scope: Specifies the scope of the Bean.
  - @Singleton: Specify the Bean as a singleton.
  - @PostConstruct: Specify the initialization method.
  - @PreDestroy: Specify the destruction method.
  - Provider: A common Bean factory interface provided by the Java standard library.
- Spring AOP
  - JDK dynamic proxy: interface implementation, dynamic generation of proxy classes, processing method calls, and unified cross-cutting concerns.
  - Cglib dynamic proxy: A library based on bytecode generation, no interface is required, and it can intercept class methods and enhance them.
  - ClassFilter: Determines whether the class matches the interception condition.
  - MethodMatcher: Determine whether the method matches the interception condition.
  - Pointcut: Define the entry point and match the intercepted method.
  - Advice: The core interface in AOP that defines various notification type behaviors.
    - MethodInterceptor: Intercepts method execution, allowing additional logic to be added before and after.
    - MethodBeforeAdvice: Allows custom logic to be inserted before method calls.
    - AfterReturningAdvice: Allows custom logic to be inserted after a method call. <
    - ThrowsAdvice: Exception notification, captures exceptions thrown by methods, and performs additional logic.
    - IntroductionInterceptor: Dynamically introduces new functionality or properties to the target object.
  - Advisor: Used to combine notifications and pointcuts to realize cross-cutting concerns in aspect programming.
  - Advised: Configure the notifications, notifiers, targets, etc. of the AOP agent.
  - ProxyFactory: A convenient way to create proxy objects.
  - AopProxyFactory: Create an AOP proxy factory, supporting JDK and CGLIB.
  - AopProxy: Create and manage AOP proxy objects.
  - AdvisorChainFactory: Factory interface for creating Advisor chain.
  - AdvisorAdapterRegistry: Adapt various Advice to AOP interceptors, register and manage Advisor adapters.
  - AdvisorAdapter: Adapt different types of notifications to interceptor chains.
  - ProxyMethodInvocation: AOP method invocation proxy, handles interceptor chains and method invocations.
  - @EnableAspectJAutoProxy: Enable AspectJ aspect automatic proxy.
  - AnnotationAwareAspectJAutoProxyCreator: Creates an AOP proxy to apply AspectJ-style aspects.
  - BeanFactoryAdvisorRetrievalHelper: Helps retrieve and manage Advisor Beans in Spring AOP.
  - BeanFactoryAspectJAdvisorsBuilder: Build @AspectJ annotation aspects and generate Spring AOP Advisors.
  - AspectInstanceFactory: Creates aspect instances and supports multiple implementation methods.
  - MetadataAwareAspectInstanceFactory: manages aspect instances and metadata, and supports multiple instantiation strategies.
  - AspectJAdvisorFactory: Creates an AspectJ notifier instance and manages the creation and configuration of aspect notifications.
  - TargetSource: manages the acquisition and release of AOP proxy objects.
  - TargetSourceCreator: Creates special target sources and customizes the creation and management of proxy objects.
  - AopContext: Tool for obtaining Spring AOP proxy objects.
  - ExposeInvocationInterceptor: An interceptor that exposes Spring AOP method invocation context.
  - @EnableLoadTimeWeaving: Enable Spring load-time weaving.
Spring transaction
- Connection: manages database connections, executes SQL, and processes transactions.
- DataSource: Provides an interface for efficient management of database connections.
- DriverManager: The core class for managing and establishing database connections.
- JdbcTemplate: Simplifies JDBC operations and provides convenient database access abstraction.
- TransactionDefinition: Defines the transaction propagation behavior and isolation level.
- TransactionAttributeSource: Strategy interface for obtaining transaction attributes.
- PlatformTransactionManager: used to manage and coordinate the life cycle and execution of transactions.
- TransactionTemplate: Simplifies transaction management and supports programmatic transaction control and exception handling.
- SpringTransactionAnnotationParser: Parse @Transactional annotation and convert it into transaction configuration.
- TransactionInterceptor: Transaction interceptor, used to manage method-level transaction processing.
- EnableTransactionManagement: Enable Spring's annotation-driven transaction management.
SpringMVC
SpringOpenFeign

contact me

✉️ Email | Issue | CSDN Me about everything!

⛵Contributions welcome!

If you find any errors or have suggestions for improvements, please feel free to submit an issue or pull request. Your feedback is very valuable to me!

Continuously updating

In order to provide you with the latest and most valuable content, I will insist on updating this warehouse every day⏳. Every day, you can expect to see some new content or improvements to existing content. If you have any suggestions or feedback, please feel free to contact me?. I value every feedback? because it is my motivation for continuous improvement.