254 results about "Java object" patented technology

A cache server is provided in a network for storing Java objects for retrieval by one or multiple application servers. Application server(s) are configured to request an object from the cache server, rather than requesting the Java object directly from a database, so as to reduce processing load on the database and free up database resources. Responsive to a request for a Java object from an application server, e.g., in an HTTP request, the cache server determines if the object is stored in memory and if so, serializes the requested object and sends the serialized object to the requesting server, e.g., in an HTTP response. The requesting server then deserializes the Java object. If the object is not stored in memory, the cache server instantiates the object (typically by requesting the object from the database), serializes the instantiated object and sends it to the requesting server. Cache coherency methods are also provided.

A method for serving a web page uses eXtensible Markup Language (XML) server pages. The first time a page is accessed, a given flat file is parsed into an XML Document Object Model (DOM), and required tag libraries are loaded. The DOM tree is then traversed, preferably in a depth-first, inside-out manner to locate custom tags. Upon locating a custom tag, if the tag is registered as a Java object, the object is loaded. A process method is then called on the object, passing the custom tag's tree node. The Java object then examines the custom tag and replaces it with an object, e.g., script code. Alternatively, if the tag is registered as an XSL stylesheet, the stylesheet is loaded and passed, together with the DOM, to an XSL processor. The processor applies the template to the custom tag and replaces it with given script code. Once all custom tags are reduced to HTML and script code, the DOM is compiled into a Java servlet to service the client request.

The present invention provides a method and apparatus for executing ERP application requests in a computer-implemented ERP data processing system via a network, using the steps of:

• • (a) transmitting a HyperText Markup Language (HTML) input form to a browser executed by a client computer in the network for display on a monitor attached thereto;
  • (b) receiving a HyperText Transfer Protocol (HTTP) request from the browser to access the ERP System, wherein the request optionally includes data entered by the user into an HTML input form;
  • (c) transferring any data entered by the user into the HTML input form and any data stored in the requested HTML page into the ERP application API
  • (d) transferring control to the ERP application for execution;
  • (e) receiving output data from the ERP application in response to the transmitted data and request;
  • (f) merging the output data from the ERP application into a strongly typed Java object;
  • (g) transforming the strongly typed Java objects into a transmittable format, such as XML or HTML, and
  • (h) transmitting the HTML or XML object to the browser for display on the monitor attached to the client computer.

Embodiments of a mechanism for providing results gates to clients in the distributed computing environment to be used by the clients to access results generated by services on behalf of the clients. A client generates a request message for a service. The request message is generated by a client method gate. The service then generates results in response to the message. A results gate is generated for accessing the results. A gate on the client generates the results gate. The results are then accessed through the results gate. The results are structured as an object (e.g. Java object), and the results gate an object proxy for the results object. The results gate is returned to the process as results of the method call made by the process. In one embodiment, the results gate is a method gate and provides a method interface to the results.

One embodiment of the invention provides a method for processing actuator, sensor or radio frequency identification (RFID) tag data. The method includes receiving actuator, sensor or RFID tag data and generating a Java object associated with the actuator, sensor or RFID tag data. The Java object includes an assigned destination address. The method further includes forwarding the Java object to the assigned destination address.

The present invention is directed to a pluggable custom data binding system and method utilizing a generic data structure exchanged between a run-time system and a user define binding logic in Web Service Applications. The custom data binding system may replace the existing mappings for XML schema types. The custom binder is a function that works with the pairing of a particular XML schema type and Java type. The custom binder may define an interface including serialize and de-serialize methods to convert between Java objects and SOAPElements. After the custom binder is plugged into the run-time system, this custom binder may interact with the run-time system through use of SOAPElement. The custom binding provider may aggregate related custom binders to support particular custom data bindings. The custom binding provider may be created for a specific application that has a few XML schema types that are not supported by the JAX-RPC specification.

The invention relates to the field of computer safety, in particular to a method for protecting application programs in an Android system. By carrying out encryption transformation on a plurality of method instruction codes of JAVA objects to be protected, encrypted method codes are subjected to real-time decryption operation according to the calling requirement when the programs operate, so that the application programs are difficult to subject to decompilation and static analysis, and therefore, the effective protection on the JAVA programs in the Android system is implemented.

An object oriented mechanism and method allow allocating Java objects on a method's invocation stack in a dynamic compilation environment under certain conditions. When a class is dynamically compiled by a just-in-time (JIT) compiler (as the program runs), one or more of its methods may create objects that may be placed on the method's invocation stack. During the compilation of the class, only the information relating to the previously-loaded classes is taken into account. After compilation, as each new class is loaded, the class is analyzed to see if loading the class might change the analysis used to allocate objects on the invocation stacks of previously-compiled methods. If so, the previous object allocations are analyzed in light of the object reference(s) in the newly loaded class, and the previous object allocations are changed from the invocation stack to the heap, if required. In this manner objects may be allocated to a method's invocation stack based on information that is available from the classes that have been loaded, and can then be changed to be allocated from the heap if information in new classes shows that the previous decision (to allocate on the invocation stack) is no longer valid.

A JavaScript program may be represented in an intermediate form to be executed by a JavaScript interpreter. A browser may be configured to intercept JavaScript code and pass execution control to a Java-based interpreter engine. The instructions are converted by a representation generator component of the engine into an intermediate representation equivalent using the Java programming language. The representation scheme may be suitable for execution by a stack-machine implemented interpreter. The representation scheme may use Java classes and objects, and create logical commands representing the JavaScript program. The intermediate representation may be stored as Java objects in a stack data structure. The stack data structure may be constructed from an array of elements, where each element is either an operator or an operand, and where each element derives from an abstract Java class with generic functionality and each element contains data relating to the operator or data type it represents.

The invention discloses a method for binding Java and XML data, which comprises the following steps of: 1) designing an XML document; 2) creating a Java class corresponding to an element according to the structure of the XML document; 3) setting a corresponding relationship between the XML element and the Java class; 4) realizing a disorganization algorithm, adopting a recursive algorithm to transverse an XML document tree, and creating a Java object corresponding to the structure of the XML document; 5) realizing a grouping algorithm, adopting the recursive algorithm to transverse a Java object tree, and creating an XML document corresponding to the whole Java object tree; and 6) realizing a disorganization class and a grouping class. The method realizes bidirectional data mapping binding between the Java object and the XML document, simplifies development work by using the XML, realizes an automation process from resolving the XML document to creating the Java object, and can write the modified Java object back to the XML document and conveniently adapt to the change of the structure of the XML document by modifying few Java codes.

The invention discloses a code generation method and system. The code generation system comprises a static state sheet reading module, a Java server page (JSP) generation module, a data persistence layer generation module, a controller generation module and a configuration file generation module. The JSP generation module generates view JSP files, the data persistence layer generation module generates simple JAVA object (POJO) type files and data access object (DAO) type files, the controller generation module generates controller Java type files, and the configuration file generation file generates extensible markup language (XML) configuration files. By adopting the code generation method and system, service codes can be generated efficiently according to specific frameworks of different software to be developed, and development cost can be reduced.

The invention provides a cross-system internal service call method and device. The device comprises the steps that a first request sent by a calling party for calling a first service is received, wherein the first request comprises a hessian or json serializable byte stream put into a request body; the byte stream in the request body is obtained, and the obtained byte stream is stored in the context of a thread; the byte stream in the context of the thread is obtained and deserialized so as to be converted into a first java object, wherein the first java object comprises identification information of the first service; scheduling process is conducted on application processing logic corresponding to the situation that the first java object calls the first service according to the identification information of the first service. According to the cross-system internal service call method and device, the service calling efficiency can be improved.

The invention provides a server and a data processing method thereof. The method comprises the following steps of: receiving a connection request from a client; forming a two-tuple request data packet by using a connection identifier of the connection request and transmitted byte data, and storing the two-tuple request data packet to a two-tuple request data packet queue; resolving the two-tuple request data packet into a java data object, and storing the java data object to a legal request java object queue; searching for an idle thread of a corresponding type according to the request type of the java data object for processing, forming a processing result java object by using a processing result and the connection identifier, and storing the processing result java object to a processing result java object queue; and finding the connection request from a requested connection queue according to the connection identifier, and transmitting the processing result to the client. By the technical scheme provided by the invention, the processing speed of a system is high, a thread and a code are less dependent, upgrading and maintaining are convenient, and the logical process of the system can be extended to different service rules and service logics without modification.