Electrical computers and digital processing systems: multicomput – Computer-to-computer data routing – Least weight routing
Reexamination Certificate
1997-11-24
2001-09-11
Oberley, Alvin E. (Department: 2755)
Electrical computers and digital processing systems: multicomput
Computer-to-computer data routing
Least weight routing
Reexamination Certificate
active
06289395
ABSTRACT:
RELATED APPLICATIONS
The present invention is related to the subject matter of the following commonly assigned, copending U.S. patent application Ser. No. 08/976,779 entitled “A Multilingual Hierarchical Scripting Environment” and filed Nov. 24, 1997; and U.S. Pat. No. 6,078,743 entitled “Generic IDE Interface Support for Scripting” and filed Nov. 24, 1997. The content of the above-referenced applications is incorporated herein by reference.
BACKGROUND OF THE INVENTION
1. Technical Field
The present invention relates in general to scripting in component software architectures and in particular to supporting event connections in scripting objects within a component software architecture such as Java. Still more particularly, the present invention relates to providing a generic event listener for arbitrary events generated in an arbitrary manner by scriptable objects within a component software architecture.
2. Description of the Related Art
Component software architectures and rapid application development (RAD) tools are increasingly proliferating. Component software architectures employ discrete software components to quickly prototype and flesh out interactive applications. Applications are built by combining a set of independent components with developer-written code which acts as a “glue” between components, usually responding directly to component events by setting component properties or invoking component methods. One currently popular component software architecture is the Java Bean specification of the Java programming language.
Developed by Sun Microsystems, the portability, security, and intrinsic distributed programming support features of the Java programming language make this language useful for Internet programming. Java is a totally object-oriented, platform independent programming language, which achieves architectural independence by compiling source code into its own intermediate representation. Java source code is not compiled into normal machine code, but is translated into code for a virtual machine specifically designed to support Java's features. A Java interpreter or a Java-enabled browser then executes the translated code. While Java source code must be compiled, no link step is required since the Java interpreter dynamically links the translated code at run time.
Java Beans is a component model for building and using Java-based software components. A “bean” is simply a Java class with extra descriptive information, similar to the concept of an OLE-type library. Unlike an OLE library, however, a bean is usually self-describing, including a file which contains the class's symbol information and method signatures and which may be scanned by a development tool to gather information about the bean, a process referred to as introspection. Any Java class with public methods may be considered a bean, but a bean typically has properties and events as well as methods.
In scripting components—writing executable scripts connecting various components—within a component software architecture such as Java beans, events fired by scriptable objects must be connected to the appropriate executable script code. However, different scriptable objects fire different events, and each event may have an arbitrary number and type of parameters which may or may not be defined in the software component architecture. For example, in the Java event model (which is a callback model in which components register for notification with the object expected to fire the event) there is no generic event listener which would act as a sink to any arbitrary event that a bean may fire. Most applications using the Java event model implement a set of custom listeners to listen for events which a bean may fire.
It would be desirable, therefore, to have a generic event listener connected to scriptable objects which listens for arbitrary events. It would further be advantageous for the event listener to allow events to be generated in an arbitrary manner, rather than in a specific format, and to pass events between a source and sink without them knowing about each other.
SUMMARY OF THE INVENTION
It is therefore one object of the present invention to provide an improved method and apparatus for scripting in component software architectures.
It is another object of the present invention to provide support for event connections in scripting objects within a component software architecture.
It is yet another object of the present invention to provide a generic event listener for arbitrary events generated in an arbitrary manner by scriptable objects within a component software architecture.
The foregoing objects are achieved as is now described. In scripting connections between objects within a component software architecture, a generic event processing module is provided to listen to all possible events. Objects registered for scripting are introspected to determine all events which may be fired by the object. In the case of the Java beans specification, this includes both Java-defined and user-defined events. One or more event listener classes for user-defined events may then be created, instantiated and added to the registered objects at runtime. When an event is fired and detected by a system listener, the appropriate event listener notifies the client, which may be a scripting component. The client may then take appropriate action. With an event processing module as described, event sinks need not be wrapped to become event listeners and event sources need not be wrapped to generate events in a specific manner. Events may be passed between sources and sinks without either knowing of the existence of the other.
The above as well as additional objects, features, and advantages of the present invention will become apparent in the following detailed written description.
REFERENCES:
patent: 5583993 (1996-12-01), Foster et al.
patent: 5768510 (1998-06-01), Gish
patent: 5905890 (1999-05-01), Seaman et al.
patent: 5933144 (1999-08-01), Alcorn
patent: 5987245 (1999-11-01), Gish
Apte Ajay Arvind
Chen Ping
Sanchez John Conrad
Bracewell & Patterson L.L.P.
Courtenay III St. John
International Business Machines - Corporation
Mims Jr. David A.
Oberley Alvin E.
LandOfFree
Generic Java-based event processor for scripting Java beans does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Generic Java-based event processor for scripting Java beans, we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Generic Java-based event processor for scripting Java beans will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-2463135