CN107967328B

CN107967328B - Method for solving hibernate incompatibility caused by Hessian

Info

Publication number: CN107967328B
Application number: CN201711194169.5A
Authority: CN
Inventors: 李波; 岳永胜; 孙小波
Original assignee: Sichuan Changhong Electric Co Ltd
Current assignee: Sichuan Changhong Electric Co Ltd
Priority date: 2017-11-24
Filing date: 2017-11-24
Publication date: 2021-04-02
Anticipated expiration: 2037-11-24
Also published as: CN107967328A

Abstract

The invention discloses a method for solving hibernate incompatibility caused by Hessian, which comprises the following steps: an object is transmitted and filtered; judging whether the object in the step 1 is a conventional object or not, and if the object is the conventional object, not traversing; judging whether the object belongs to a set object, if so, traversing the set content of the object, and then recursing; during recursion, whether dead circulation exists needs to be judged; judging whether the filtering class is entity.class in a specific filtering class, and if so, replacing the collection elements in the class; and replacing the content in the set, and after the content is replaced, the hessian cannot report an error. The method solves the problem of abnormal session closing caused by the fact that the corresponding relation of @ OneToMany in hibernate exceeds 7 in Hessian serialization, and is easy to use and stable in performance.

Description

Method for solving hibernate incompatibility caused by Hessian

Technical Field

The invention relates to the technical field of distributed cloud computing platforms, in particular to a method for solving hibernate incompatibility caused by Hessian, which uses a DUBBO framework to realize the aspect of distribution.

Background

Hessian is a lightweight remoting onhttp tool that provides RMI functionality using a simple method. Compared with WebService, Hessian is simpler and quicker. The binary RPC protocol is used, and is well suited for transmitting binary data because it is a binary protocol.

Hibernate is an object relation mapping framework of open source code, which encapsulates JDBC with very light weight objects, establishes a mapping relation between POJO and a database table, is a fully automatic orm framework, and can automatically generate SQL statements and automatically execute, so that Java programmers can use object programming thinking to manipulate the database at will. Hibernate can be applied to any occasions using JDBC, can be used in Java client programs and can also be used in Servlet/JSP Web applications, and has the revolutionary significance that Hibernate can replace CMP in the J2EE architecture applying EJB to complete the re-mission of data persistence.

Disclosure of Invention

The invention overcomes the defects of the prior art, provides a method for solving the incompatibility problem of hibernate caused by Hessian, and is used for solving the technical problem of session abnormity caused by the fact that the corresponding relation of @ OneToMany in hibernate exceeds 7 in Hessian serialization.

In view of the above problems of the prior art, according to one aspect of the present disclosure, the following technical solutions are adopted in the present invention:

a method of resolving hibernate incompatibility resulting from Hessian, comprising:

step 1: an object is transmitted and filtered;

step 2: judging whether the object in the step 1 is a conventional object or not, and if the object is the conventional object, not traversing;

and step 3: judging whether the object belongs to a set object, if so, traversing the set content of the object, and then recursing;

and 4, step 4: during recursion, judging whether dead circulation exists or not, and if the dead circulation exists and the dead circulation exceeds a certain number of times, the circulation is invalid;

and 5: judging whether the filtering class is entity.class in a specific filtering class, and if so, replacing the collection elements in the class;

step 6: and replacing the content in the set, and after the content is replaced, the hessian cannot report an error.

In order to better realize the invention, the further technical scheme is as follows:

according to an embodiment of the present invention, in the case that the object in step 2 is String, Integer, no traversal is needed.

According to another embodiment of the present invention, in the step 4, in case the number of dead cycles exceeds 9, the cycle is failed.

Compared with the prior art, the invention has the following beneficial effects:

the method for solving the incompatibility problem of hibernate caused by Hessian solves the problem that session closing is abnormal caused by the fact that the corresponding relation of @ OneToMany in hibernate exceeds 7 when Hessian is serialized; the invention has the application range of the place using hessian serialization in the distributed environment, and is suitable for the dubbo cluster; the device is convenient for developers, easy to use and stable in performance.

Drawings

For a clearer explanation of the embodiments or technical solutions in the prior art of the present application, the drawings used in the description of the embodiments or prior art will be briefly described below, it is obvious that the drawings in the following description are only references to some embodiments in the present application, and other drawings can be obtained by those skilled in the art without creative efforts.

FIG. 1 is a block flow diagram according to one embodiment of the invention.

Detailed Description

The present invention will be described in further detail with reference to examples, but the embodiments of the present invention are not limited thereto.

As shown in fig. 1, fig. 1 is a flow chart according to an embodiment of the present invention, and a method for solving hibernate incompatibility caused by Hessian is a solution proposed for session abnormal shutdown caused by @ onetomay correspondence exceeding 7 in hibernate during Hessian serialization. For example, in an Entity object @ Entity, if the annotation @ OneToMany has more than 7 relationships. Then over the 7-entry segment, Hessian serialization would page it. But at the time of the second request, the hibernate session has been closed, so compatibility issues arise. Aiming at the compatibility problem, the invention replaces the proxy class realized by hibernate with the common set class. The method comprises the following specific steps:

the method comprises the following steps: passing an object into a filtering means;

step two: it is judged whether the method is a normal one. These classes, such as String Integer, do not need to be traversed;

step three: judging whether the object belongs to a set object, if so, traversing the set content of the object, and then recursing;

step four: during recursion, whether dead cycles exist needs to be judged, and if the dead cycles exceed 9 times, the cycles fail;

step five: class is judged whether to be entity in a specific filtering class, and if so, the collection elements in the class need to be replaced. (ii) a

Step six: replacing the content within the collection. After replacing the content, the hessian will not report an error.

In conclusion, the method for solving the incompatibility problem of hibernate caused by Hessian solves the problem of abnormal session closing caused by the fact that the corresponding relation of @ OneToMany in hibernate exceeds 7 when Hessian is serialized; the invention has the application range of the place using hessian serialization in the distributed environment, and is suitable for the dubbo cluster; the device is convenient for developers, easy to use and stable in performance.

Reference throughout this specification to "one embodiment," "another embodiment," "an embodiment," etc., means that a particular feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment described generally in this application. The appearances of the same phrase in various places in the specification are not necessarily all referring to the same embodiment. Further, when a particular feature, structure, or characteristic is described in connection with any embodiment, it is submitted that it is within the scope of the invention to effect such feature, structure, or characteristic in connection with other embodiments.

Although the invention has been described herein with reference to a number of illustrative embodiments thereof, it should be understood that numerous other modifications and embodiments can be devised by those skilled in the art that will fall within the spirit and scope of the principles of this disclosure. More specifically, various variations and modifications are possible in the component parts and/or arrangements of the subject combination arrangement within the scope of the disclosure and claims of this application. In addition to variations and modifications in the component parts and/or arrangements, other uses will also be apparent to those skilled in the art.

Claims

1. A method for solving hibernate incompatibility caused by Hessian is characterized by comprising the following steps:

step 1: introducing a hessian object into a judgment rule and filtering, wherein the judgment rule is as follows: judging that the hessian object value is not null and the execution times is less than 9, if the hessian object value meets the judgment rule, adding 1 to the execution times, and entering the step 2; if the judgment rule is not satisfied, the processing is finished;

step 2: judging whether the hessian object type in the step 1 belongs to a String or Integer type, if so, ending the processing; otherwise, entering step 3;

and step 3: judging whether the hessian object type in the step 1 belongs to a set type, if so, traversing the hessian object value, and executing the step 1 again on the hessian object value obtained by traversal, otherwise, entering the step 4;

and 4, step 4: judging whether the hessian object is a hibernate entity class, if so, entering step 5;

and 5: replacing the hessian object with a List type or a Set type.