What is the principle and process of ssh framework

##SSH (Struts2 Spring Hibernate) framework project, the architecture is mainly divided into three levels:

( 1) Struts2: Responsible for the web layer

(2) Spring: Business layer management

(3) Hibernate: Responsible for data persistence

Struts2 working principle:

1. Initialize a request 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.

That is, the developer sends an http request. This request is filtered by the filter of web.xml to see if an action needs to be called. If so, the method to implement the request is found in Struts.xml, and then returned The result of the operation.

Related recommendations: "

java Development Tutorial"

Hibernate working principle:

1. Read and parse the configuration file

2. Read and parse mapping information, create SessionFactory

3. Open Sesssion

4. Create transaction Transation

5. Persistence operation

6. Submit transaction

7. Close Session

8. Close SesstionFactory

That is, xxx.hbm.xml is loaded during Hibernate initialization managed by spring Then read the parsing mapping information and create a SessionFactory. Then open the session, operate the thing through the session and submit it. Finally close the session and close the SessionFactory.

Three states of beans in Hibernate

Hibernate objects are divided into three states: transient state (new or session-independent when instantiated), persistent state (session-associated) and free state (Once 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 session close , flush and other operations 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) (there is no behavior associated with the database table, as long as the application no longer refers to it) The status of these objects will be lost and recycled by the garbage collection mechanism);

Transient objects will be converted into persistent objects through save() and saveOrUpdate, and will be managed uniformly by the session. The operations of persistent objects are the same as Database synchronization;

The persistent object will be converted into a free state after evict(), close(), clear(), etc. At this time, although it is persisted, it is not in the session cache. Through 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 provides a good encapsulation of JDBC, and 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.

Inversion of control: The container controls the (dependency) relationship between programs, instead of the traditional implementation, which is directly controlled by the program code.

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 handling was completed through Try/Catch. The 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 the transaction/submit/rollback the transaction and the cumbersome Try/Catch operation every time the data is operated.

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!