339 results about "Java program" patented technology

Changes in performance in a Java program are deduced from information related to garbage collection events of the program. Assumptions are made about the system, the application and garbage collection, and changes in performance that will result from modifying the program are deduced.

The Virtual Machine is viewed by many as inherently insecure despite all the efforts to improve its security. This invention provides methods, apparatus, and computer products to implement a system that provides operating system style protection for code. Although applicable to many language systems, the invention is described for a system employing the Java language. Hardware protection domains are used to separate Java classes, provide access control on cross domain method invocations, efficient data sharing between protection domains, and memory and CPU resource control. Apart from the performance impact, these security measures are all transparent to the Java programs, even when a subclass is in one domain and its superclass is in another, when they do not violate the policy. To reduce the performance impact, classes are grouped and shared between protection domains and map data lazily as it is being shared. The system has been implemented on top of the Paramecium operating system used as an example of an extensible operating system application.

Disclosed is a system, method, and program for generating trace statements to a log file. A log method in a program, such as a Java program, including an identifier parameter is processed. The program includes multiple instances of the log method to trace the execution of the program during debugging operations. A determination is made as to whether a variable indicates that log methods called with the identifier parameter should be processed. The class and method from which the log method was called is determined if the variable indicates that log methods called with the identifier parameter should be processed. Information on the identifier parameter and determined class and method are written to the log file.

A digital rights management (DRM) system and methodology for a Java client implementing a Java Runtime Environment (JRE). The JRE comprises a Java Virtual Machine (JVM) and Java runtime libraries components and is capable of executing a player application for presenting content that can be presented through a Java program (e.g., a Java application, applet, servlet, bean, etc.) and downloaded from a content server to the client. The DRM system includes an acquisition component for receiving downloaded protected contents; and a dynamic rights management layer located between the JRE and player application for receiving requests to view or play downloaded protected contents from the player, and, in response to each request, determining the rights associated with protected content and enabling viewing or playing of the protected contents via the player application if permitted according to the rights. By providing a Ad DRM-enabled Java runtime, which does not affect the way non-DRM-related programs work, DRM content providers will not require the installation of customized players. By securing the runtime, every Java™ player automatically and transparently becomes a DRM-enabled player.

Metadata files representing Web document content are parsed in accordance with a specification file, with a specification file being generated for each class of documents, e.g., HTML pages, newsgroup articles, and JAVA programs. Each specification file has the same format, i.e., schema, as a metadata file for the associated document class. Within each specification file, each element in the hierarchy is associated with a weight. When a metadata file is received, both the metadata file and the specification file are walked through top-down to parse data out of the metadata file into an index file in accordance with the weights in the specification file, e.g., a data element having a weight of zero is not written to the index file, an element with a weight of two is written out twice to the index file, and so on. Importantly, the tags in the metadata file are not written out to the index file. The index file is then used by an index engine to build an index, which can then be accessed by a query executor to respond to a user query for Web documents without having to search through an index containing tags and other data that is irrelevant to the search.

The present invention relates to a method for program transformation and an apparatus for COBOL to Java program transformation. The method consists of: (1) a new approach for statement-to-statement program transformation, facilitated by a predefined target language library, which keeps original comments, program control flow, functionality, and time complexity; (2) a new approach for goto statement elimination, which uses existing exception handling mechanism in target language and its implementation is hidden in a super class in a library; (3) a new extended BNF to distinguish different occurrences of the same term in a BNF production; (4) a new approach for embedded statement as a special marker statement and a comment, (5) in the description of the above, a program transformation specification language is defined to describe relationship between comments in two languages. (6) an apparatus, as the preferred embodiment of the method, is a COBOL to Java program transformation system Cobol2Java; a sample COBOL application and its Cobol2Java translation are given.

Metadata describing common Java classes is extracted and utilized to optimize a Java program's performance based on the code requirements of the application. Data mining techniques extract metadata and other information about different sets of JVM byte code written by multiple vendors to determine the design choices and optimizations made by each vendor in implementing their JVM. Then, byte code in a Java application being programmed is analyzed in comparison to each vendor's JVM metadata and information. Based upon the application's requirements (for example footprint, performance, etc.), recommendations are generated that yield a newly compiled rt.jar that combines the best practices of each vendor together or recommends a particular vendor's standard JVM that is best suited for the application.

A JAVA program language compile-on-demand service system and method for accelerating a processing speed of a JAVA program in a data processing system having a relatively low performance is provided. The JAVA COD service system compiles a JAVA class file to be executed in a data processing system into a pattern which can be executed more speedily on the data processing system, and then transmits the compiled result, upon a request of the data processing system connected via a network in order to execute the JAVA program at a relatively faster speed. The system includes JAVA program providing servers, data processing systems, and a compile-on-demand server for receiving a service request, downloading a requested JAVA class file, compiling the downloaded JAVA class file, and transmitting the compiled result.

The invention is applicable to the technical field of data processing, and provides a report file generation method, a terminal device and a medium. The method comprises the following steps: obtaininga report template uploaded by a client; Detecting each information field existing in the report template by a preset algorithm; Creating database query statements associated with each information field; Executing a database query statement to obtain a query result of a corresponding data query statement from a database matched by an application system; Populates the query results to the data column to which the information field belongs, and returns the resulting report file to the client when the population is complete. In the invention, the report file is only related to the report templateuploaded by the client, therefore, the developer does not need to manually change the Java program code of the application system, and the operation complexity is reduced. Users do not have to wait for a long code update cycle to obtain their own report files, thus improving the efficiency of report file export.

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.

The invention relates to a method for preventing a Java program from being decompiled, which comprises the following steps: 1) encrypting a Java bytecode file to be issued; 2) using a Java virtual machine tool interface to monitor an initialization event of a Java virtual machine; 3) designating a Hook function for the initialization event of the Java virtual machine; 4) when the initialization of the Java virtual machine is finished, automatically calling the Hook function, and using a Java local interface in the Hook function to register a function called by the Java virtual machine for generating class objects as a self-defined agent function; 5) when the Java virtual machine generates a certain class object, calling the self-defined agent function, and decrypting the encrypted Java bytecode file in the self-defined agent function; and 6) generating a class object corresponding to the decrypted Java bytecode file, and returning to the Java virtual machine. The invention solves the technical problem of the limited application range of the method for preventing a Java bytecode file from being decompiled in the prior art, keeps the cross-platform characteristics of the Java program and maintains the universality of the Java virtual machine.

The present invention, in various embodiments, provides techniques for improving performance of programs. In one embodiment, the program is written in the Java language and runs in the Java Runtime Environment (JRE) that includes a Java Virtual Machine (JVM) having a configuration. A control panel having access to the JVM is invoked. Via the control panel, a user observes the execution of the Java program, analyzes the results of the execution, changes the configuration of the JVM, and forces re-optimization of the critical portions of the running program. By repeating the above steps of observing the program execution, analyzing the results, changing the configuration of the Java machine, and forcing re-optimization of the critical portions of the program, the user improves the program's overall performance.

This invention provides a runtime environment dependency hiding apparatus and the like, which hides a part that depends on the runtime environment in software which runs on a plurality of runtime environments having different specifications. An environment information acquisition unit acquires environment information that pertains to the runtime environment of a Java program from standard properties and the like. A dependence information generation unit generates a dependence information list required for processing the part that depends on the runtime environment in the Java program on the basis of dependence information generation information. A search key generation unit generates a search key in accordance with search key generation knowledge on the basis of the environment information acquired by the environment information acquisition unit. A dependence information search unit searches the dependence information list generated by the dependence information generation unit for dependence information corresponding to the current runtime environment on the basis of the search key generated by the search key generation unit. A process execution unit executes the processing of the part that depends on the runtime environment on the basis of the dependence information obtained by the dependence information search unit.

The invention discloses a method and a system for dynamically converting telecommunications service data. The method comprises the following steps of: obtaining a preset telecommunications service data converting rule; dynamically generating a JAVA source code in a service realizing type according to the data converting rule and a preset service realizing type template; compiling and generating aJAVA program code; dynamically loading and executing the service realizing type; and generating a source data file into an object data file. The invention aims at the characteristics of the telecommunications service data to establish a rich function set, provides a function self-defining interface at the same time and is convenient to user self definition and function set expansion. Different from the current script interpretative type ETL (Extract-Transform-Load) tool, the invention adopts dynamic compiling, dynamic loading and a JAVA reflection technology, increases data conversion efficiency and has stronger cross-platform property and application flexibility.

The invention relates to a method for realizing dynamic update of Java program in the computer technical field, which comprises the following steps: firstly, modifying the class definitions that need dynamic update in the passive dynamic update program, and adding update support method for realizing judgment to the subobjects of the class objects one by one, wherein the parameter is class loader; secondly, modifying the update class definitions in the dynamic update program, and adding update method for realizing initialization to the variables under the update class objects, wherein, the input parameter is class loader and old object; thirdly, modifying part of the method invocation, data field memory, and object set of the updated program with the Java reflection to realize running recovery of the program; finally, adding update support method to the main class and adding update checkpoint in the main method circulation. The invention has the advantages of avoiding software update that needs halt, update and reboot and avoiding loss caused by halt.

The invention provides a method for protecting Java program progress based on an inheritance relationship among the progresses, wherein the method is used for protecting the Java program (the program developed by the Java programming language, hereinafter referred to as Java program) in a windows system (a name of an operating system). The method is mainly used for solving the authentication and determination of the protected Java program progress, monitoring the operating state of the Java program, and preventing the unexpected ending of the operation. The method establishes a father and soninheritance relationship between the protected Java program progress and the protecting program progress, uniquely determines the protected Java program progress by the protecting program progress based on the inheritance relationship and determines the operating state of the protected Java progress based on the inner core object state of the protected Java program progress.

An improved system and method are disclosed for processing Java program code. Java source code is annotated with a Module or a ControlFlow annotation. The Java source code is then compiled to produce Java bytecode, which in turn is compiled by a just-in-time compiler to produce native code, which retains the annotations. The native code with annotations is then executed. If a bug is identified during the execution of the native code, an associated Module is selected for debugging, followed by determining associated Java source code segments within the responsible control flow path. Debugging operations are then performed on the associated Java source code segments.

A program written in untrusted code (e.g., JAVA) is enabled to access a native operating system resource (e.g., supported in WINDOWS NT) through a staged login protocol. In operation, a trusted login service listens, e.g., on a named pipe, for requests for login credentials. In response to a login request, the trusted login service requests a native operating system identifier. The native operating system identifier is then sent to the program. Using this identifier, a credential object is then created within an authentication framework. The credential object is then used to login to the native operating system to enable the program to access the resource. This technique enables a JAVA program to access a WINDOWS NT operating system resource under the identity of the user running the JAVA program.

The invention discloses a byte-code file reconstruction-based Java type online updating method. In the method, when Java programs are updated dynamically, binary files are analyzed and reconstructed; and the method is combined with a new VM dynamic loading type mechanism to reduce the expense caused by recompiling a machine code by the dynamic updating during the time of running, and improve the updating efficiency.

The invention relates to a business object and xml message mutual conversion method and system. The method specifically comprises the following steps of: step 1: establishing a message node mapping table, and introducing message node and business object mapping information into the mapping table; step 2: receiving a reading request for reading the message node and business object mapping information into a buffer; step 3: performing format verification on a message node and a business object; and step 4: the system, according to a mapping relationship, converting the XML message into the business object; or the system, according to the mapping relationship, converting the business object into XML message data. The business object and xml message mutual conversion method adopts java programming, so that the code execution efficiency and reliability are relatively high and the program portability is good; and configuration is simple and flexible, mutual conversions between XML messages in different formats and business objects with different structures are supported, and the maintainability is good.