Search Images Maps Play YouTube News Gmail Drive More »
Sign in
Screen reader users: click this link for accessible mode. Accessible mode has the same essential features but works better with your reader.

Patents

  1. Advanced Patent Search
Publication numberUS20050240945 A1
Publication typeApplication
Application numberUS 11/158,734
Publication date27 Oct 2005
Filing date22 Jun 2005
Priority date19 Oct 1998
Also published asUS6385661, US6549955, US20020120793, WO2000023877A2, WO2000023877A3
Publication number11158734, 158734, US 2005/0240945 A1, US 2005/240945 A1, US 20050240945 A1, US 20050240945A1, US 2005240945 A1, US 2005240945A1, US-A1-20050240945, US-A1-2005240945, US2005/0240945A1, US2005/240945A1, US20050240945 A1, US20050240945A1, US2005240945 A1, US2005240945A1
InventorsGraham Glass
Original AssigneeGlass Graham W
Export CitationBiBTeX, EndNote, RefMan
External Links: USPTO, USPTO Assignment, Espacenet
System and method for dynamic generation of remote proxies
US 20050240945 A1
Abstract
A software system is disclosed which provides for dynamic generation of remote proxy classes at run time through a distributed object management system 16. The software system provides for a client system 14 and server system 12 which communicate via distributed object management system 16 which operates over a distributed computer network to allow communications between client system 14 and server system 12. Any inter-object communication will invoke a remote proxy generation control module 34 if a remote proxy class 23 does not already exist for the requested subject object 18. A remote proxy generation control module 34 is provided which first invokes reflection engine 36 to determine the applicable information of subject class 19. Next, a communication enabling module 40 determines and inserts the appropriate computer code to allow local object 20 to communicate with subject object 18 utilizing remote proxy object 22. After the system determines what information is required by remote proxy class 23, byte code generator 42 automatically generates the executable code containing remote proxy class 23. Finally, class loader 46 loads remote proxy class 23 onto the system and creates a new instance which is remote proxy object 22.
Images(3)
Previous page
Next page
Claims(1)
1. A remote proxy generator for dynamic generation of remote proxy classes within an object oriented distributed processing environment, comprising:
a reflection engine operable to determine the name, interfaces, methods and superclass information of a remote object within the object oriented distributed processing environment for use in creating the remote proxy class in response to a request for access to the remote object;
a communications enabling module operable to aid in creating the remote proxy class by inserting within the remote proxy class computer code required for communications between objects within the object oriented distributed processing environment; and
a byte code generator operable to generate the executable computer code representing the determined name, interfaces, methods, superclass information and communications computer code for the remote proxy class.
Description
    RELATED APPLICATIONS
  • [0001]
    This application is a continuation of pending U.S. application Ser. No. 09/451,507, which is a continuation-in-part application of U.S. application Ser. No. 09/175,079 now U.S. Pat. No. 6,385,661.
  • TECHNICAL FIELD OF THE INVENTION
  • [0002]
    This invention relates in general to the field of software systems, and more particularly to an improved system and method for dynamic generation of remote proxy classes within a distributed object management system.
  • BACKGROUND OF THE INVENTION
  • [0003]
    Object oriented programming is a method of programming which abstracts a computer program into manageable sections. The key to object oriented programming is the concept of encapsulation. Encapsulation is a method by which the subroutines, or methods, that manipulate data are combined with the declaration and storage of that data. This encapsulation prevents the data from arbitrarily being accessed by other program subroutines, or objects. When an object is invoked, the associated data is available and can be manipulated by any of the methods which are defined within the object to act upon the data. The basic component of encapsulation is a class. A class is an abstraction for a set of objects that share the same structure and behavior. An object is a single instance of a class that retains the structure and behavior of the class. Objects also contain methods which are the processes by which an object is instructed to perform some procedure or manipulation of data which it controls. Classes may also be characterized by their interface which defines the elements necessary for proper communication between objects.
  • [0004]
    Distributed computing allows an object on one computer system to seamlessly communicate with and manipulate an object contained in a second computer system when these computers are connected with a computer network. This second computer system may also be referred to as another address space. Sophisticated distributed computing systems have removed the communications burden from the computer programs, or objects in an object oriented programming environment, and placed it in a mid-level operating system which purpose is to manage communications across a computer network to facilitate a client's access to and manipulation of data contained on a server system, for example, a computer remote to the user in a different address space.
  • [0005]
    Distributed computing and object oriented programming have led to the development of distributed object management systems. When an object on a client computer system requests access to an object which exists only on a server computer system, the distributed object management system steps in to facilitate the communication between the two computer systems and, thus, between the two objects. The distributed object management system removes the requirement of the object on the client system communicating directly with the object on the server system. Instead, current distributed object management systems create a remote proxy object on the client system which models the interface of the object which exists on the server system. The client computer system which requested access to the remote object communicates with the remote proxy object which now exists on the client computer system. Therefore, the client computer system can operate as if it is communicating directly with a local object. The remote proxy object contains the necessary communications information to allow the client computer system to access and manipulate an object which actually exists on the server computer system. Remote proxies allow the client system to disregard the location of the requested object and the communication details.
  • [0006]
    A proxy is an object which has an interface and method list identical to another object. However, it does not contain the same detail computer programming. Instead it contains communications requirements which allow the proxy to communicate directly with another object without the knowledge of the first object. Proxies can be used to control access to certain objects. They may also be used to remove the labor of distributed processing communications from local objects. For example, if object A which resides on a first computer system needs to communicate with object B which resides on a second computer system, object A must know the location of object B and have the necessary computer code to initiate communications with object B located on the second computer system. A proxy for object B located on the first computer system allows object A to simply communicate with the proxy of object B as if object B resided on the same computer. The proxy for Object B has all the necessary information and computer code to communicate with the real object B on the second computer system. This type of proxy is known as a remote proxy since it exists on a computer system remote from the computer system which contains the requested object.
  • [0007]
    Systems heretofore known have required all possible remote proxies to be built when the software system is initially compiled and loaded onto a computer. This process can be very time consuming and the resultant remote proxies can require large amounts of computer storage. In addition, software system designers must predict every possible remote proxy which may be needed in the future so that it can be built when the software system is loaded. This process does not allow a system to adapt to its usage and environment.
  • SUMMARY OF THE INVENTION
  • [0008]
    Accordingly, a need has arisen for a software system in the area of distributed processing which reduces the time and expense required to build, load and store a distributed object management system.
  • [0009]
    According to one embodiment of the present invention, a software system is provided that comprises a client system and server system that communicate via a distributed computer network utilizing a distributed object management system. The distributed object management system also comprises a remote proxy generator to dynamically generate at run time remote proxy classes as needed for inter-object communications within the distributed computer network.
  • [0010]
    One important technical advantage of the present invention inheres in the fact that it decreases development time and increases developer productivity since the developer does not have to manually generate the remote proxy classes when the system is initially installed or when the subject class is modified in the future. Other technical advantages include reduced initial system build time and reduced disk storage space required to store the application programs.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • [0011]
    For a more complete understanding of the present invention and the advantages thereof, reference is now made to the following description taken in conjunction with the accompanying drawings in which like reference numbers indicate like features and wherein:
  • [0012]
    FIG. 1 is a block diagram illustrating a distributed object management system constructed according to the teachings of the present invention;
  • [0013]
    FIG. 2 illustrates a flow chart of a method of determining when dynamic generation of remote proxy classes is needed according to the teachings of the present invention;
  • [0014]
    FIG. 3 is a block diagram illustrating dynamic generation of remote proxy classes according to the teachings of the present invention; and
  • [0015]
    FIG. 4 illustrates a flow chart of a method of dynamically generating remote proxy classes according to the teachings of the present invention.
  • DETAILED DESCRIPTION OF THE INVENTION
  • [0016]
    Referring to FIG. 1, a distributed processing computer system generally indicated at 10 is illustrated that comprises one or more server systems 12 and one or more client systems 14. The client/server computer systems allow for decentralized computing which includes the ability to manipulate data which is resident on a remote system. The server system 12 and client system 14 may comprise a personal computer, mini computer, main frame computer, or any other suitable computer type device. In a computer network environment, each computer is assigned a unique address. Therefore, if data, code or objects exist on a different computer, it is said to exist in a different address space.
  • [0017]
    The client system 14 requests access to data or services which may be contained on server system 12. Server system 12 may then process the request and approve access as requested by client system 14. Client system 14 is connected to server system 12 via a distributed object management system 16 operating across a computer network. The distributed object management system 16 handles the communications between client system 14 and server system 12. Without distributed object management system 16, distributed processing could not take place since client system 14 would not be able to determine the location of or obtain access to the requested data or services. The distributed object management system 16 may comprise Voyager, a distributed network communications system developed by ObjectSpace, Inc., CORBA (Common Object Request Broker Architecture), a technology for inter-object communications developed by a consortium of companies, DCOM, an inter-application communications system for networked computers developed by Microsoft, or any other suitable distributed object management system.
  • [0018]
    The present invention teaches a system and method for generating proxies on local systems to facilitate access to objects on remote systems. An object is an instance of a class within the programming methodology of object oriented programming. The present invention may be implemented using the Java language, developed by Sun Micro Systems, Inc., or any other suitable computer language.
  • [0019]
    When an object class source code description is created in the Java language, it is stored on a storage device as a java file. Upon compilation, the object class executable code is represented as a class file on the storage device. When an object is needed, a new instance, as prescribed by the class file is created, and it then is referred to as an object. Server system 12 may contain one or more subject objects 18 for which client system 14 may issue a request for access. In such a case, subject object 18 is the subject of client system's 14 request. Client system 14 may contain one or more local objects 20. It is important to note that local object 20 can itself be a subject object, and subject object 18 can itself be a local object depending on what computer, or address space, is making the request for access. For purposes of illustrating the present invention, local object 20 and subject object 18 exist in different address spaces. However, both local object 20 and subject object 18 could reside on the same computer and still invoke the system and method of the present invention. The present invention is utilized in all inter-object communications regardless of their relative locations.
  • [0020]
    Local object 20 may request access to subject object 18. This request invokes the distributed object management system 16. In order to isolate the distributed processing communication requirements from local object 20, a remote proxy object 22 may be created on client system 14. Remote proxy object 22 has an interface and list of methods identical to subject object 18. Remote proxy object 22 is so named since it may be remote from subject object 18, and it provides a local representative for an object which may reside in a different address space. Remote proxies in general are responsible for encoding a request and its arguments and for sending the encoded request to the subject object which may exist in a different address space. Remote proxies also hide the location of the subject object from the requesting local object. Therefore, any local object can assume, from an access point of view, that any object it needs is local. Local object 20 communicates with remote proxy object 22 which then communicates with subject object 18 via distributed object management system 16. By doing this, local object 20 is unconcerned with the location of subject object 18. As far as it is concerned, local object 20 is communicating directly with another local object, but in reality, it is communicating with subject object 18 which may reside in a different address space.
  • [0021]
    Currently, a system developer must anticipate all necessary remote proxies and create the remote proxy classes. Some distributed object management systems have a utility which augments the build process by allowing remote proxy classes to be built when the system is compiled. Although this process minimizes the system developer's effort, it still involves developer intervention, computer resources and time. Another disadvantage with current distributed object management systems is that these remote proxy classes must be kept in sync with the subject classes as the subject classes and interfaces are modified. Another disadvantage with current distributed object management systems is that all remote proxy classes must be stored on the computer and available for use when needed. This creates high overhead in developer effort, computer storage and processing requirements.
  • [0022]
    In contrast, a system constructed using the present invention dynamically generates remote proxy classes as needed at run-time. There are several advantages of this method. The primary advantage is reduced system development time since the system developer does not have to manually generate remote proxy classes when the system is initially compiled or manually regenerate remote proxy classes each time a subject object class is modified. The system of the present invention also reduces computer program storage requirements since remote proxy classes are not a permanent part of the operating environment. It also minimizes compile and load time for the computer program since remote proxy classes do not have to be generated at compile and load time. In order to optimize system performance, generated remote proxy classes remain in memory until the distributed object management system is shut down.
  • [0023]
    Referring again to FIG. 1, the dynamic generation of remote proxies may be accomplished by parsing the .class or java file for subject object 18 and creating a .java file for remote proxy object 22 which contains the interfaces and methods of the subject object 18. The Java compiler may then be invoked to compile the .java file into a .class file for remote proxy object 22. The compiled .class file can then be loaded into the computer system via a class loader which is a standard element in a Java environment. A .class file must be loaded before it is available for use by distributed processing computer system 10. Once the .class file is loaded, a new instance of the compiled .class file may be created which will be remote proxy object 22.
  • [0024]
    The process of parsing the subject object 18 class (subject class 19) or .java file, creating a source code file for remote proxy class 23, compiling, loading, and creating a new instance may be excessively slow at run-time. In order to address this issue, a reflection process may be used on subject object 18 to determine its name, interfaces and list of methods and then to directly generate the byte codes into a .class file, subject class 19. The byte codes are the executable code stored in a class file. The class file can then be loaded into the computer system with the class loader. This embodiment eliminates the need to parse the .class file, create a .java source code file, and shell out the .java file to a compiler since the code generation process occurs as part of the dynamic generation of remote proxies. This entire process of dynamic generation of remote proxies will be discussed in detail with reference to FIGS. 2, 3 and 4.
  • [0025]
    Referring to FIG. 2, the process of determining if a remote proxy is necessary is invoked via a request from local object 20 for access to subject object 18. The method begins at step 24 where local object 20 on client system 14 requests access to subject object 18 on server system 12. This request could be for any object whether it is local or remote and in a different address space. The system of the present invention generates and utilizes remote proxy objects in all inter-object communication to provide additional processing support. Thus, any communication between objects, regardless of their location, utilizes remote proxy objects. These remote proxy objects act as a middle man between the requested object and the requesting object to provide additional processing functionality which may include increased security.
  • [0026]
    Referring again to FIG. 2, the method then proceeds to step 26 where the requested object is located on either client system 14 or server system 12. The method proceeds to step 30 where a determination is made regarding the need for a remote proxy class. If remote proxy class 23 already exists on client system 14, then the method terminates since remote proxy classes are not removed from client system 14 until the distributed object management system 16 is shut down. However, if remote proxy class 23 does not exist on client system 14, the method then proceeds to step 32 where remote proxy class 23 is generated on client system 14 based on the name, interfaces and methods of subject object 18 which may reside on either server system 12 or client system 14. The method for generating these remote proxies is described in detail with reference to FIGS. 3 and 4.
  • [0027]
    FIG. 3 is a functional diagram of the portions of distributed object management system 16 that are used to create remote proxy classes as necessary. Remote proxy generation control module 34 is invoked at step 32 in FIG. 2. When the distributed object management system 16 invokes the remote proxy generation control module 34, the method described previously has already determined that the remote proxy class 23 does not yet exist on client system 14. Remote proxy generation control module 34 generates remote proxy 22 on client system 14 so local object 20 can communicate with subject object 18 via distributed object management system 16.
  • [0028]
    As previously discussed, in object oriented programming, an object is an instance of a class. Classes may be defined in a class hierarchy where each class inherits the attributes of all of its ancestors. Inheritance is a concept which maps related classes onto each other in a hierarchical way. This allows a descendant of a class to inherit all of its variables and methods from its ancestors as well as create its own. The immediate ancestor of a class is known as its superclass. Therefore, in order to determine all of a class's attributes, all of the class's ancestors, or superclasses, must be determined.
  • [0029]
    To fully define a remote proxy for a subject object, remote proxies must be generated for each of the subject object's superclasses. By generating these superclass remote proxies, the remote proxy for subject object will inherit all of the variables and methods of its ancestors, or superclasses. An alternative to generating superclass remote proxies includes adding all of the superclass methods and interface requirements to the remote proxy class. By adding the superclass information to the remote proxy class, the need for generating superclass remote proxies is eliminated.
  • [0030]
    Referring again to FIG. 3, remote proxy generation control module 34 first invokes reflection engine 36 to determine information regarding subject class 19. The process of reflection operates on subject class 19 which is the Java .class file for subject object 18. Although for illustrative purposes, subject object 18 and its Java .class file, subject class 19, exist on server system 12, subject class 19 could exist on either client system 14 or server system 12. Therefore, the dynamic generation of remote proxy classes as described in the present invention could take place on either client system 14 or server system 12.
  • [0031]
    Reflection is a process that determines what an object can do, how it is defined, and how it communicates with other objects. Reflection mirrors the public view of an object to collect information to facilitate the creation of proxies which resemble objects on the public view, but are very different internally, or privately. The public view of an object represents the information external objects must know in order to communicate with the first object. Proxies need to be reflections, or duplicates on the surface, of objects since proxies perform specific tasks such as controlling access to or communications with the objects they represent. Thus, proxies need to look like the object on the outside, but on the inside, proxies contain unique computer code to accomplish their assigned function. The reflection process is only concerned with determining the public view of an object. Therefore, the information determined by the reflection process includes the following: name; list of implemented interfaces; list of methods; and superclass information.
  • [0032]
    Continuing with FIG. 3, reflection engine 36 issues queries against subject class 19, which is the .class file for subject object 18, to determine each of subject class 19 superclasses, its name, its interfaces, and each of its methods. The results of these queries are temporarily stored within remote proxy generation control module 34 as JClass information 38. JClass information 38 is a temporary storage area which defines the name, superclasses, interfaces, and methods of subject class 19. JClass information 38 would also include the name, interfaces, and methods of each of subject class 19 superclasses.
  • [0033]
    If subject class 19 has superclasses, a remote proxy may be first generated for each superclass using the system and method described with reference to the present invention. After the superclass remote proxies are generated, JClass information 38 contains the name, interface, and list of methods for subject class 19. An alternate methodology for providing superclass methods and interfaces for the remote proxy class is to add all superclass method and interface information to the remote proxy class. By doing this, the need for separate superclass remote proxies is eliminated.
  • [0034]
    Once the name, interface, methods, and superclass information are determined for subject class 19, a communication enabling module 40 adds to JClass information 38 the computer code necessary for remote proxy object 22 to communicate with subject object 18 via distributed object management system 16. The communication enabling module 40 inserts the computer code into JClass information 38 which is the definition of all the information that remote proxy object 22 needs to function within distributed object management system 16.
  • [0035]
    Since a remote proxy's purpose is to communicate with a subject object which may exist either in a different address space or in the same address space, the remote proxy contains essentially only the following information: interfaces identical to the subject object; a list of methods identical to the subject object; and computer code necessary for the remote proxy to communicate with the subject object. In an alternate embodiment of the present invention, the remote proxy would contain all of the information mentioned above and the interfaces and methods of all of the subject object's superclasses.
  • [0036]
    At this point, JClass information 38 contains subject object's 18 name, interfaces, methods, and the computer code necessary for communications within distributed object management system 16. JClass information 38 could also contain the superclass information for subject object 18. The next function invoked by remote proxy generation control module 34 is byte code generator 42. The purpose of byte code generator 42 is to directly generate the executable code corresponding to JClass information 38. JClass information 38 is the definition of the Java class of which remote proxy object 22 is an instance. That is, JClass information 38 is the definition of remote proxy class 23. Byte code generator 42 reviews JClass information 38 and generates the corresponding byte codes, or executable code, into remote proxy class 23 which is a Java class file. As previously discussed, a Java class file is executable code which defines a Java class.
  • [0037]
    Byte code generator 42 is a collection of Java classes which are capable of taking the description of the needed proxy class in JClass information 38 and directly generating the executable Java code in memory. The function of byte code generator 42 is similar to that of a Java compiler. Like a Java compiler, byte code generator 42 generates executable Java code. However, the inputs are very different. A compiler requires a source code file which is a string of bytes which is the sequence of statements for a Java object definition. The string of bytes is parsed by the Java compiler and translated into executable Java code. In contrast, byte code generator 42 takes general information regarding the needed Java object and directly generates executable Java code without the need for the intermediate step of creating a Java source file. This technique yields considerable time savings since several steps are omitted. For example, like a Java compiler, byte code generator 42 generates a hexadecimal “CAFEBABE” to indicate to the Java virtual machine that a Java class file begins at that point in memory. Byte code generator 42 is constructed in such a way that the byte codes are generated in the sequence required by the Java virtual machine.
  • [0038]
    For each Java construct, byte code generator 42 writes the appropriate header information and hexadecimal byte codes representing the Java construct into computer memory. Thus, there is a block of code, or hexadecimal bytes, for each Java construct. As described above, JClass information 38 contains the computer code necessary for communications within distributed object management system 16. Byte code generator 42 translates this communications information into byte codes recognizable to the Java virtual machine. When byte code generator 42 terminates, the string of hexadecimal bytes necessary to define the proxy class has been stored in memory as remote proxy class 23 which is an executable Java class file. Remote proxy class 23 has a unique name which is derived from subject class 19 name. For example, if subject class 19 is named “Foo.class”, its remote proxy class 23 name would be “Foo_Proxy.class”.
  • [0039]
    Before remote proxy class 23 can be used, it must be loaded onto client system 14 utilizing a class loader 46. Class loader 46 may comprise any number of suitable programs which exist in typical object oriented programming environments. The class loader 46 will then create remote proxy object 22 which is an instance of remote proxy class 23 generated by byte code generator 42.
  • [0040]
    FIG. 4 is a flow diagram that illustrates the process of generating a remote proxy when invoked by step 32 in FIG. 2 and as represented in general by the block diagram in FIG. 3. The method begins at step 48 where the reflection engine 38 queries subject class 19 to determine its superclass. The method then proceeds to step 50 where a determination is made regarding the existence of a superclass for subject class 19. If a superclass is found for subject class 19, then the method proceeds to step 52 where a determination is made regarding the existence of the remote proxy class on client system 14 representing subject class' 19 superclass. If a remote proxy class does not exist for subject class' 19 superclass, the method proceeds to step 54 where the remote proxy class is generated for subject class' 19 superclass by recursively invoking the remote proxy generation control module 34. Thus, step 54 recursively invokes the method illustrated in FIG. 4.
  • [0041]
    Referring to step 52, if the remote proxy class does exist on client system 14 for subject class' 19 superclass, then the method proceeds to step 56 (described below) since remote proxy classes already exist for all of subject object's 18 superclasses.
  • [0042]
    In an alternate embodiment of the present invention, instead of recursively generating remote proxy classes for each of subject class 19 superclasses, the interfaces and methods of each of subject class 19 superclasses are stored in JClass information 38 and are later used in the generation of remote proxy class 23. In the alternate embodiment, steps 48-54 would not exist in their current form. Instead, these steps would consist of determining the names, interfaces, and methods of all of subject class 19 superclasses and storing the information in JClass information 38.
  • [0043]
    Referring to step 50 if a superclass does not exist for subject object 18, then the method proceeds to step 56 where reflection engine 36 queries subject class 19 to determine subject class' 19 name and interface. The method then proceeds to step 58 where reflection engine 38 queries subject class 19 regarding its methods. Reflection engine 36 issues queries for each of subject class' 19 methods until all methods are determined. For each of subject class' 19 methods, the software system determines the method name, return type, parameters, and exceptions and stores the information in JClass information 38.
  • [0044]
    The method then proceeds to step 60 where reflection engine 36 creates JClass information 38 from the name, interface, and methods information determined in steps 56 and 58. The method then proceeds to step 62 where communication enabling module 40 inserts in JClass information 38 the computer code, in the form of an expression tree, necessary for remote proxy object 22 to communicate with subject object 18 via distributed object management system 16.
  • [0045]
    The method then proceeds to step 64 where byte code generator 42 generates the executable code representing JClass information 38 into remote proxy class 23. The method then proceeds to step 66 where class loader 46 loads remote proxy class 23 onto client system 14 where it is now available for use. The method then proceeds to step 68 where remote proxy object 22 is generated as a new instance of remote proxy class 23 which was loaded in step 66.
  • [0046]
    According to the teachings of the present invention, a software system is provided that allows for the dynamic generation of remote proxy classes. The advantages of dynamic generation of remote proxy classes includes reduced system development time, reduced system compile and build time, reduced system modification time, and reduced system storage requirements. Remote proxy classes are generated as needed at run time. Once a remote proxy class is generated, it continues to exist until the system is shut down. Therefore, the software system is only required to generate a particular remote proxy class once during a session of the software system.
  • [0047]
    Although the present invention and its advantages have been described in detail, it should be understood that various changes, substitutions and alterations can be made therein without departing from the spirit and scope of the invention as defined by the appended claims.
Patent Citations
Cited PatentFiling datePublication dateApplicantTitle
US5307490 *28 Aug 199226 Apr 1994Tandem Computers, Inc.Method and system for implementing remote procedure calls in a distributed computer system
US5314478 *26 Apr 199124 May 1994Kyocera CorporationArtificial bone connection prosthesis
US5325524 *6 Apr 199228 Jun 1994Digital Equipment CorporationLocating mobile objects in a distributed computer system
US5396630 *6 Oct 19927 Mar 1995International Business Machines CorporationMethod and system for object management across process boundries in a data processing system
US5432924 *15 Dec 199311 Jul 1995Microsoft CorporationMethod and system for selectively applying an appropriate object ownership model
US5481721 *31 Oct 19942 Jan 1996Next Computer, Inc.Method for providing automatic and dynamic translation of object oriented programming language-based message passing into operation system message passing using proxy objects
US5511197 *29 Nov 199323 Apr 1996Microsoft CorporationMethod and system for network marshalling of interface pointers for remote procedure calls
US5603031 *8 Jul 199311 Feb 1997General Magic, Inc.System and method for distributed computation based upon the movement, execution, and interaction of processes in a network
US5619710 *22 Jun 19948 Apr 1997Digital Equipment CorporationMethod and apparatus for object-oriented invocation of a server application by a client application
US5634010 *21 Oct 199427 May 1997Modulus Technologies, Inc.Managing and distributing data objects of different types between computers connected to a network
US5655101 *27 May 19945 Aug 1997International Business Machines CorporationAccessing remote data objects in a distributed memory environment using parallel address locations at each local memory to reference a same data object
US5724503 *31 Mar 19953 Mar 1998Sun Microsystems, Inc.Method and apparatus for interpreting exceptions in a distributed object system
US5737607 *28 Sep 19957 Apr 1998Sun Microsystems, Inc.Method and apparatus for allowing generic stubs to marshal and unmarshal data in object reference specific data formats
US5745703 *18 Jul 199528 Apr 1998Nec Research Institute, Inc.Transmission of higher-order objects across a network of heterogeneous machines
US5778227 *1 Aug 19957 Jul 1998Intergraph CorporationSystem for adding attributes to an object at run time in an object oriented computer environment
US5781633 *1 Jul 199614 Jul 1998Sun Microsystems, Inc.Capability security for transparent distributed object systems
US5787175 *23 Oct 199528 Jul 1998Novell, Inc.Method and apparatus for collaborative document control
US5793965 *22 Mar 199511 Aug 1998Sun Microsystems, Inc.Method and apparatus for determining the type of an object in a distributed object system
US5812781 *5 Sep 199522 Sep 1998Telefonaktiebolaget Lm EricssonSystem for routing incoming connection-less messages to processes which are already handling messages from same source node
US5812793 *26 Jun 199622 Sep 1998Microsoft CorporationSystem and method for asynchronous store and forward data replication
US5822585 *30 May 199713 Oct 1998Compuware CorporationSystem and method for cooperative processing using object-oriented framework
US5862325 *27 Sep 199619 Jan 1999Intermind CorporationComputer-based communication system and method using metadata defining a control structure
US5867665 *24 Mar 19972 Feb 1999Pfn, IncDomain communications server
US5881230 *24 Jun 19969 Mar 1999Microsoft CorporationMethod and system for remote automation of object oriented applications
US5897634 *9 May 199727 Apr 1999International Business Machines CorporationOptimized caching of SQL data in an object server system
US5903725 *6 Sep 199611 May 1999International Business Machines CorporationRecoverable proxy object in an object oriented environment
US5923833 *14 Mar 199713 Jul 1999International Business Machines CoporationRestart and recovery of OMG-compliant transaction systems
US5928335 *29 Oct 199727 Jul 1999Ricoh Company, Ltd.Client/server system having middleware-based interface between client and server image processing objects
US5945737 *6 Nov 199731 Aug 1999International Business Machines CorporationThin film or solder ball including a metal and an oxide, nitride, or carbide precipitate of an expandable or contractible element
US6012067 *2 Mar 19984 Jan 2000Sarkar; Shyam SundarMethod and apparatus for storing and manipulating objects in a plurality of relational data managers on the web
US6012081 *3 Jul 19964 Jan 2000Siemens AktiengesellschaftService and event synchronous/asynchronous manager
US6016393 *10 Feb 199718 Jan 2000General Magic, Inc.System and method for distributed computation based upon the movement, execution, and interaction of processes in a network
US6026415 *11 Nov 199715 Feb 2000Next Software, Inc.Transparent local and distributed memory management system
US6032190 *3 Oct 199729 Feb 2000Ascend Communications, Inc.System and method for processing data packets
US6041166 *15 Jul 199621 Mar 20003Com Corp.Virtual network architecture for connectionless LAN backbone
US6044409 *26 Jun 199628 Mar 2000Sun Microsystems, Inc.Framework for marshaling and unmarshaling argument object references
US6049821 *24 Jan 199711 Apr 2000Motorola, Inc.Proxy host computer and method for accessing and retrieving information between a browser and a proxy
US6061740 *15 Jul 19979 May 2000Novell, Inc.Method and apparatus for heterogeneous network management
US6070197 *12 Aug 199730 May 2000International Business Machines CorporationObject oriented transaction monitor for distributed transaction processing environments
US6085030 *2 May 19974 Jul 2000Novell, Inc.Network component server
US6085086 *27 Jun 19974 Jul 2000Lucent Technologies Inc.Network-based migrating user agent for personal communication services
US6092196 *25 Nov 199718 Jul 2000Nortel Networks LimitedHTTP distributed remote user authentication system
US6134591 *18 Jun 199717 Oct 2000Client/Server Technologies, Inc.Network security and integration method and system
US6178505 *4 Mar 199823 Jan 2001Internet Dynamics, Inc.Secure delivery of information in a network
US6182153 *15 Feb 199630 Jan 2001International Business Machines CorporationObject-oriented programming interface for developing and running network management applications on a network communication infrastructure
US6182154 *7 Apr 199730 Jan 2001International Business Machines CorporationUniversal object request broker encapsulater
US6182155 *2 Jan 199830 Jan 2001International Business Machines CorporationUniform access to and interchange between objects employing a plurality of access methods
US6195794 *12 Aug 199727 Feb 2001International Business Machines CorporationMethod and apparatus for distributing templates in a component system
US6205491 *18 Dec 199720 Mar 2001Sun Microsystems, Inc.Method and apparatus for deferred throwing of exceptions in C++
US6212574 *4 Apr 19973 Apr 2001Microsoft CorporationUser mode proxy of kernel mode operations in a computer operating system
US6226690 *14 Jun 19931 May 2001International Business Machines CorporationMethod and apparatus for utilizing proxy objects to communicate with target objects
US6230160 *16 Jul 19988 May 2001International Business Machines CorporationCreating proxies for distributed beans and event objects
US6237135 *11 Sep 199822 May 2001Borland Software CorporationDevelopment system with visual design tools for creating and maintaining Java Beans components
US6253253 *25 Aug 199726 Jun 2001International Business Machines CorporationMethod and apparatus for optimizing references to objects in a data processing system
US6253256 *15 Oct 199726 Jun 2001Sun Microsystems, Inc.Deferred reconstruction of objects and remote loading in a distributed system
US6260021 *12 Jun 199810 Jul 2001Philips Electronics North America CorporationComputer-based medical image distribution system and method
US6260078 *3 Jul 199610 Jul 2001Sun Microsystems, Inc.Using a distributed object system to find and download java-based applications
US6269373 *26 Feb 199931 Jul 2001International Business Machines CorporationMethod and system for persisting beans as container-managed fields
US6272559 *20 Mar 19987 Aug 2001Sun Microsystems, Inc.Deferred reconstruction of objects and remote loading for event notification in a distributed system
US6279030 *12 Nov 199821 Aug 2001International Business Machines CorporationDynamic JAVA™ class selection and download based on changeable attributes
US6282580 *2 Jul 199628 Aug 2001Sun Microsystems, Inc.Bridge providing communication between different implementations of object request brokers
US6338089 *31 Mar 19998 Jan 2002Bull Hn Information Systems Inc.Method and system for providing session pools for high performance web browser and server communications
US6343332 *17 Mar 199829 Jan 2002Fujitsu LimitedCommunication link information generating device, a three-tier client/server system, and a medium storing a communication link information generator program
US6345382 *12 Feb 19985 Feb 2002International Business Machines CorporationRun-time customization in object-oriented design
US6347342 *15 Jul 199612 Feb 2002Next Software, Inc.Method and apparatus for dynamically brokering object messages among object models
US6347641 *30 Jan 200119 Feb 2002L'air Liquide, Societe Anonyme Pour L'etude Et L'exploitation Des Procedes Georges ClaudeGas pressure-regulating device for dispensing working fluid
US6356930 *15 Oct 199912 Mar 2002Silverstream Software, Inc.Connection concentrator for distributed object systems
US6374308 *23 Apr 199616 Apr 2002Sun Microsystems, Inc.Method and apparatus for interactively connecting distributed objects to a graphic user interface
US6385661 *19 Oct 19987 May 2002Recursion Software, Inc.System and method for dynamic generation of remote proxies
US6401125 *5 Aug 19994 Jun 2002Nextpage, Inc.System and method for maintaining state information between a web proxy server and its clients
US6405246 *18 Feb 199911 Jun 2002International Business Machines CorporationAutomatic and dynamic software code management
US6415315 *25 Nov 19982 Jul 2002Recursion Software, Inc.Method of moving objects in a computer network
US6434595 *25 Nov 199813 Aug 2002International Business Machines CorporationMethod of executing mobile objects and recording medium storing mobile objects
US6438616 *18 Dec 199720 Aug 2002Sun Microsystems, Inc.Method and apparatus for fast, local corba object references
US6442564 *14 Jun 199927 Aug 2002International Business Machines CorporationFacilitating workload management by using a location forwarding capability
US6442620 *17 Aug 199827 Aug 2002Microsoft CorporationEnvironment extensibility and automatic services for component applications using contexts, policies and activators
US6453333 *10 Jun 199817 Sep 2002Lion Bioscience AgResearch system using multi-platform object oriented program language for providing objects at runtime for creating and manipulating biological or chemical data to facilitate research
US6453362 *12 Aug 199817 Sep 2002International Business Machines CorporationSystems, methods and computer program products for invoking server applications using tickets registered in client-side remote object registries
US6505231 *18 Jun 19997 Jan 2003Victor Company Of Japan, LimitedSoftware agent system for acquiring information from server arranged on network
US6513315 *8 Oct 19974 Feb 2003Verhaeghe IndustriesMethod, device and installation for the continuous displacement processing of threads
US6549955 *12 Apr 200215 Apr 2003Recursion Software, Inc.System and method for dynamic generation of remote proxies
US6553384 *14 Jun 199922 Apr 2003International Business Machines CorporationTransactional name service
US6567818 *14 Jun 199920 May 2003International Business Machines CorporationEmploying management policies to manage instances of objects
US6594671 *14 Jun 199915 Jul 2003International Business Machines CorporationSeparating privileged functions from non-privileged functions in a server instance
US6615188 *14 Oct 19992 Sep 2003Freedom Investments, Inc.Online trade aggregating system
US6629112 *31 Dec 199830 Sep 2003Nortel Networks LimitedResource management for CORBA-based applications
US6629128 *30 Nov 199930 Sep 2003Recursion Software, Inc.System and method for distributed processing in a computer network
US6629153 *17 Sep 199730 Sep 2003Trilogy Development Group, Inc.Method and apparatus for providing peer ownership of shared objects
US6701382 *23 Dec 19982 Mar 2004Nortel Networks LimitedName service for transparent container objects
US6708171 *14 Jun 199916 Mar 2004Sun Microsystems, Inc.Network proxy
US6714976 *3 Aug 199930 Mar 2004Concord Communications, Inc.Systems and methods for monitoring distributed applications using diagnostic information
US6851118 *27 Jun 20001 Feb 2005Sun Microsystems, Inc.Remote object access
US6931455 *30 Nov 199916 Aug 2005Recursion Software, Inc.System and method for communications between a CORBA object request broker and a non-CORBA object request broker
US6947965 *30 Nov 199920 Sep 2005Recursion Software, Inc.System and method for communications in a distributed computing environment
US6951021 *30 Nov 199927 Sep 2005Recursion Software, Inc.System and method for server-side communication support in a distributed computing environment
US6993774 *30 Nov 199931 Jan 2006Recursion Software, Inc.System and method for remote enabling classes without interfaces
US7347342 *29 Oct 200425 Mar 2008Elmar GrandyContainer for holding sterile goods and sterile goods dispenser
US20020032803 *15 Jul 199614 Mar 2002Paul MarcosMethod and apparatus for dynamically brokering object messages among object models
US20030105735 *11 Feb 20025 Jun 2003Iona Technologies, PlcMethod and system for providing object references in a distributed object environment supporting object migration
Referenced by
Citing PatentFiling datePublication dateApplicantTitle
US7533388 *28 Apr 200512 May 2009Sun Microsystems, Inc.Method and apparatus for dynamic Stubs and Ties in RMI-IIOP
US20060242305 *20 Apr 200626 Oct 2006Telefonaktiebolaget L M Ericsson (Publ)VPN Proxy Management Object
US20090157800 *18 Dec 200718 Jun 2009Cheng-Chieh ChengDynamically Generating a Proxy Object in a Client for Dynamically Created Object on the Server Using Retrieved Class Metadata of the Object
Classifications
U.S. Classification719/330
International ClassificationG06F9/46
Cooperative ClassificationG06F9/548
European ClassificationG06F9/54P1
Legal Events
DateCodeEventDescription
7 Sep 2005ASAssignment
Owner name: MAINLINE DATA LLC, NEVADA
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:RECURSION SOFTWARE, INC.;REEL/FRAME:016500/0181
Effective date: 20050621
14 Nov 2007ASAssignment
Owner name: OBJECTSPACE, INC., TEXAS
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:GUTHRIE, RHETT DAVIS;GLASS, GRAHAM W.;REEL/FRAME:020111/0714
Effective date: 19981011
16 Nov 2007ASAssignment
Owner name: RECURSION SOFTWARE, INC., TEXAS
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:OBJECTSPACE, INC.;REEL/FRAME:020121/0875
Effective date: 20020214