What is the principle and process of ssh framework

Struts2 working principle:

1. Initialize a request pointing to the servlet container.

2. The request is filtered by the filter configured in web.xml, and the FilterDispatcher (the core of the struts2 controller) asks the ActionMapper whether it needs to call an Action to handle the request. If ActionMapper decides that an Action needs to be called, FilterDispatcher hands over request processing to ActionProxy.

3.ActionProxy finds the Action class that needs to be called through the configuration file Struts.xml configuration file.

4.ActionProxy creates an ActionInvocation instance, and ActionInvocation calls Action through proxy mode. But before calling, ActionInvocation will load all Action-related Interceptors (interceptors) according to the configuration.

5. After the Action is executed, ActionInvocation is responsible for finding the corresponding return result based on the configuration in struts.xml.

Related recommendations: "FAQ"

That is, the developer sends an http request. This request is filtered through the web.xml filter to see if a certain action, if there is one, find the method implemented by the request in Struts.xml, and then return the running result. As shown in the figure:

Hibernate working principle:

1. Read and parse the configuration file

2. Read and parse mapping information, create SessionFactory

3. Open Session

4. Create transaction Transation

5. Persistence operation

6. Submit Transaction

7. Close Session

8. Close SesstionFactory

That is, when Hibernate managed by spring is initialized, xxx.hbm.xml is loaded and then the parsing mapping information is read and created. SessionFactory.

Then open the session, operate the thing through the session and submit it. Finally close the session and close the SessionFactory. As shown in the figure:

The three states of beans in Hibernate

Hibernate objects are divided into three states: transient state (new out) or independent of session when instantiated), persistent state (associated with session) and free state (used to be associated with session). Among them, the persistent objects are PO, and the transient and managed objects can be used as VO. (PO should not be used directly as the v layer) Therefore, attention should be paid to the transformation of the three states during use.

For example:

In a series of data operations, the save or saveorupdate operation can convert transient or free objects into persistent objects, while

delete or Operations such as close and flush of session will convert the persistent state object associated with the session into a free state.

The state and life cycle of Hibernate objects

The object initialized using the new operator is a transient (Transient) (does not have any behavior associated with the database table) , as long as the application no longer refers to these objects, their status will be lost and recycled by the garbage collection mechanism);

After the transient object passes save(), saveOrUpdate will be converted into a persistent state, which is managed uniformly by the session. The operation of persistent objects is synchronized with the database;

The persistent objects will be converted into free states after evict(), close(), clear(), etc. At this time, although they are persisted, they are not in the session cache. lock(),

update(), saveOrUpdate will be converted into persistent state. Objects obtained through get(), load(), find(), and iterate() are directly persistent.

How Spring works:

In the SSH framework, spring plays the role of managing the container. We all know that Hibernate is used as the persistence layer because it encapsulates JDBC well.

Programmers do not need to write a large number of SQL statements when interacting with the database. Struts is used as the application layer, which is responsible for calling the business logic serivce layer.

So the process of the SSH framework is roughly: Jsp page----Struts------Service (business logic processing class)---Hibernate (left to right)

struts Responsible for controlling the Service (business logic processing class), thereby controlling the life cycle of the Service. In this way, the dependence between layers is very strong and is coupled.

At this time, using the spring framework plays the role of controlling the Action object (in Strus) and the Service class. The relationship between the two is loose. Spring's Ioc mechanism (inversion of control and dependency injection ) is used here. Spring's Ioc (Inversion of Control and Dependency Injection):

Inversion of Control: The container controls the (dependency) relationship between programs, instead of being directly controlled by program code in traditional implementations.

Dependency injection: The dependencies between components are determined by the container during runtime, and the container dynamically injects certain dependencies into the components.

The second benefit of using Spring (AOP application):

Transaction processing:

In the past JDBCTemplate, the transaction was submitted successfully and exception The processing is done through Try/Catch in Spring.

Spring container integrates TransactionTemplate, which encapsulates all transaction processing functions, including transaction rollback when exceptions occur, data submission when operations succeed, and other complex business functions. This is all managed by the Spring container, which greatly reduces the amount of code for programmers and provides good management and control over transactions.

Hibernate also has transaction management. Transaction management in hibernate is accomplished by creating and maintaining Session through SessionFactory. Spring has also integrated the SessionFactory configuration, and there is no need to set the SessionaFactory through hibernate.cfg.xml.

In this way, you can make good use of Sping's powerful transaction management functions.

Avoids the need to obtain a Session instance to start transactions/submit/rollback transactions and cumbersome Try/Catch operations every time you operate on data.

These are good applications of the AOP (aspect-oriented programming) mechanism in Spring. On the one hand, it makes the development of business logic clearer and professional division of labor easier.

On the other hand, the application of Spirng AOP isolation reduces the coupling of the program, allowing us to combine various aspects in different applications, which greatly improves code reuse.

The above is the detailed content of What is the principle and process of ssh framework. For more information, please follow other related articles on the PHP Chinese website!