Shulou(Shulou.com)06/01 Report--

Introduction to related knowledge of Spring

To put it simply, Spring is a hierarchical JavaSE/EE one-stop lightweight open source framework. Spring is committed to providing a way to manage your business objects. Spring is committed to all layers of solutions for J2EE applications, rather than just focusing on one layer of solutions. It can be said that Spring is an one-stop choice for enterprise applications, running through the presentation layer, business layer and persistence layer. However, spring does not want to replace them, but seamlessly integrates with them.

Control inversion-Spring promotes low coupling through a technique called control inversion (IoC). When IoC is applied, other objects that an object depends on are passed in passively, rather than the object itself creating or looking for dependent objects. You can think of IoC as the opposite of JNDI-it's not that the object looks for dependencies from the container, but that the container actively passes the dependency to the object at initialization without waiting for the object request.

Aspect-oriented-Spring provides rich support for aspect-oriented programming, allowing cohesive development by separating the application's business logic from system-level services such as auditing and transaction management. Application objects only do what they are supposed to do-- complete the business logic-- that's all. They are not responsible for (or even aware of) other system-level concerns, such as logging or transaction support.

Container-Spring contains and manages the configuration and lifecycle of application objects, in this sense it is a container, you can configure how each of your bean is created-based on a configurable prototype (prototype), your bean can create a separate instance or generate a new instance every time needed-and how they relate to each other.

Framework-Spring can configure and combine simple components into complex applications. In Spring, application objects are grouped declaratively, typically in a XML file. Spring also provides many basic functions (transaction management, persistence framework integration, etc.), leaving you with the development of application logic.

The role of MVC-Spring is integration, but not limited to integration. The Spring framework can be seen as an enterprise solution-level framework. The client sends the request, the server controller (implemented by DispatcherServlet) forwards the request, and the controller calls a class HandlerMapping for mapping, which is used to map the request to the corresponding processor to process the request. HandlerMapping maps the request to the corresponding processor Controller (equivalent to Action). If you write some processor components in Spring, you can generally implement the Controller interface. In Controller, you can call some Service or DAO for data manipulation. ModelAndView is used to store data extracted from DAO and some data from the response view. If you want to return the processing result to the user, a view component ViewResolver is also provided in the Spring framework, which finds the corresponding view according to the mark returned by Controller, and returns the response response to the user.

The view is an interface responsible for displaying the model; the controller represents the logic code and is the implementation of Controller.

IOC and AOP

The basic concept of the inversion pattern of control (also known as dependency injection) is that objects are not created, but describe how they are created. Do not connect directly to objects and services in the code, but describe which component needs which service in the configuration file. Containers (IOC containers in the Spring framework) are responsible for linking these together. In a typical IOC scenario, the container creates all the objects and sets the necessary properties to connect them together to determine when the method is called. The following table lists an implementation pattern for IOC.

The basic framework of Spring:

The Spring framework is a hierarchical architecture consisting of seven well-defined modules. The Spring module is built on top of the core container, which defines how the bean is created, configured, and managed. Each module (or component) that makes up the Spring framework can exist alone or can be implemented jointly with one or more other modules. The functions of each module are as follows:

1. Core container: the core container provides the basic functions of Spring framework (SpringCore). The main component of the core container is BeanFactory, which is the implementation of the factory pattern. BeanFactory uses the inversion of Control (IOC) mode to separate the application's configuration and dependency specifications from the actual application code.

2. Spring context: the Spring context is a configuration file that provides context information to the Spring framework. The Spring context includes enterprise services such as JNDI, EJB, email, internationalization, checksum and scheduling capabilities.

3. Spring AOP: through the configuration management feature, the Spring AOP module directly integrates the aspect-oriented programming function into the Spring framework. Therefore, you can easily make any object managed by the Spring framework support AOP. The Spring AOP module provides transaction management services for objects in Spring-based applications. By using Spring AOP, you can integrate declarative transaction management into your application without relying on EJB components.

4. The Spring DAO:JDBCDAO abstraction layer provides a meaningful exception hierarchy that can be used to manage exception handling and error messages thrown by different database vendors. The exception hierarchy simplifies error handling and greatly reduces the amount of exception code that needs to be written (such as opening and closing connections). Spring DAO's JDBC-oriented exceptions follow the general DAO exception hierarchy.

5. Spring ORM:Spring framework inserts several ORM frameworks, thus providing object-relational tools for ORM, including JDO, Hibernate and iBatisSQLMap. All of this follows Spring's generic transaction and DAO exception hierarchy.

6. Spring Web module: the Web context module is based on the application context module, which provides context for Web-based applications. Therefore, the Spring framework supports integration with Jakarta Struts. The Web module also simplifies the work of handling multipart requests and binding request parameters to domain objects.

7. Spring MVC framework: the MVC framework is a full-featured MVC implementation for building Web applications. Through the policy interface, the MVC framework becomes highly configurable, and MVC hosts a number of view technologies, including JSP, Velocity, Tiles, iText, and POI. The model is composed of javabean and stored in the Map; view is an interface responsible for displaying the model; the controller represents the logic code and is the implementation of Controller.

The annotated form of DI:

The role and characteristics of annotations:

1. It plays the role of an explanation

2. Annotations cannot exist alone

3. Comments should be marked on: classes, methods, properties, parameters, etc.

There should be a class: the purpose of this class is to explain

1.1 steps to take advantage of annotation

Public class Person {

@ Resource

Private Student student

Public void say () {

This.student.student ()

}

}

Note: @ Resource comment

In the configuration file of spring

To import naming

Xmlns:context= http://www.springframework.org/schema/context

Http://www.springframework.org/schema/context

Http://www.springframework.org/schema/context/spring-context-3.0.xsd

Start the annotation parser

1.2 principle

1. When the spring container is started, the container instantiates person and student

2. When the spring container parses to

The spring container scans the bean of the spring container scope to check which properties of bean

There is a @ Resource comment on the

3. When the annotation is checked, check whether the value of the name attribute of the @ Resource annotation is ""

If it's empty,

Match the name of the attribute where the annotation is located with the value of id in bean in the spring configuration file

If the match is successful, the value is assigned

If the match is not successful, match by type

If the type does not match, the error must be reported.

If it is not empty

The value of the name attribute will be extracted and matched with the id in the spring container according to this value

If the match is not successful, an error will be reported.

two。 Class scanning mechanism

2.1. Steps

1. In the spring configuration file

2. In the corresponding class

@ Component

Publicclass Person {}

= =

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.