Classification:
Java Framework Learning
The architecture of Spring
Spring is an open-source lightweight framework
Spring Project development process:
Create a project--add the required class Library jar package--Create a source file programming call Library--Create a bean's profile--run debugging
Core Features:
1. AOP: Plane-oriented programming
2, IOC: control inversion, the creation of objects to spring management, Dependency injection Di, object generation is placed in the XML definition
3. Spanning Java EE three layers
Web tier: SPRINGMVC
Service layer: Spring IOC
DAO Layer: JdbcTemplate
For example, the Spring framework module is divided into core containers (cores Container), data access Integration (dataaccess/integration), Web (mvc/remoting), and other modules in four categories, a total of about 20 modules
Core container
The core container, the bottom four modules in the diagram, is the core, Bean, context, and expression language module, where
The core module provides a basic component of the framework, including IoC and dependency injection capabilities.
The Bean module provides beanfactory, which is a complex implementation of a factory pattern.
The context module is built on a solid foundation provided by the core and the Bean module, which is the medium for accessing any object defined and configured. The ApplicationContext interface is the focus of the context module.
The expression Language module provides a powerful expression language for querying and manipulating an object graph at run time.
Data Access/Integration
The data access/Integration layer includes the JDBC,ORM,OXM,JMS and transaction processing modules, where:
The JDBC module provides a JDBC abstraction layer that removes redundant JDBC-related encodings.
The ORM module provides an integration layer for the popular object relational mapping APIs, including Jpa,jdo,hibernate and IBatis.
The OXM module provides an abstraction layer that supports object/xml mapping implementations of JAXB,CASTOR,XMLBEANS,JIBX and XStream.
The Java Messaging Service JMS module contains the functionality of production and consumption information.
The transaction module supports both programmatic and declarative transaction management for classes that implement special interfaces and all POJO.
Web
The WEB layer consists of web,web-mvc,web-socket and Web-portlet, where:
The Web module provides basic web-oriented integration features, such as the ability to upload multiple files, and the use of servlet listeners and Web application-oriented contexts to initialize the IoC container.
The WEB-MVC module contains Spring's model-view-Controller (MVC), which implements the Web application.
The Web-socket module provides support for websocket-based and provides two ways to communicate between client and server side in a Web application.
The Web-portlet module provides the implementation of MVC in a Portlet environment and reflects the functionality of the Web-servlet module.
Other modules
There are other important modules, like Aop,aspects,instrumentation,web and test modules, where
The AOP module provides an aspect-oriented programming implementation that allows you to define method interceptors and pointcuts to cleanly decouple the code, which implements the functions that should be detached.
The aspects module provides integration with the AspectJ, a powerful and sophisticated aspect-oriented programming (AOP) framework.
The instrumentation module provides support for class instrumentation and implementation of Class loaders in a certain application server.
The Messaging module provides STOMP with support for the use of WebSocket sub-protocols in the application. It also supports an annotated programming model for Routing and processing of stomp information from WebSocket clients.
The test module supports testing of Spring components that have a JUnit or TestNG framework.
Spring IOC Container:
Divided into spring beanfactory containers and spring applicationcontext containers
The ApplicationContext container includes all the functions of the Beanfactory container, so it is generally recommended to exceed beanfactory. Beanfactory can still be used for lightweight applications, such as mobile devices or applet-based applications, where its data volume and speed are significant.
The spring IOC container is the core of the spring framework. Containers will create objects, connect them together, configure them, and manage their entire lifecycle from creation to destruction. The Spring container uses Dependency injection (DI) to manage the components that make up an application. These objects are called Spring Beans
The Bean container component, the entire IOC container core, the so-called Bean container, is where the bean object is loaded and the various data required. Where beanfactory is a pure bean container, used to store description beans, unrelated to other environments, and like ApplicationContext, is also a bean container, but it is closely related to the application environment, so called the application context (environment) more appropriate, ApplicationContext not only has eanfactory "descent", but also inherited Environmentcapable, Messagesource, Applicationeventpublisher, It expands many of its additional features, and its implementation classes are related to specific applications.
IOC container underlying principle:
(1), XML configuration file
(2), dom4j Resolve XML
(3), factory design mode
(4), Reflection
IOC Operation:
1. IOC configuration file Mode
2. The IOC annotation method
The entire work flow:
ApplicationContext context = new Classpathxmlapplicationcontext (path);
0. New ApplicationContext container object (not initialized);
1.ResourceLoader load and parse resource file ——— > Get resource object;
2.BeanDefinitionReader reads the resource object and encapsulates the bean element data it reads into
Beandefinition components;
3.BeanDefinitionRegister Register all beandefinition in Beanfactory
(Beandefinition is the basic data structure of the container's internal bean, Beanfactory maintains a
Beandefinition Map);
4. Container initialization starts, container initialization work is provided by Abstractapplicationcontext
Refresh () method completed
Context functions as a contextual function of the application environment, and the program can then pass through the Gebean of the context
The (String Beanname) method obtains the Bean object defined by the path file declaration
Architecture of the Java Framework Learning path--spring