Abstract:
A system and method for generating code for an Enterprise Java Bean comprising generating at least one output based on a description of at least one Enterprise Java Bean, wherein the description is attended by at least one annotation. A system and method for generating an annotated description of an Enterprise Java Bean based on at least one input, wherein the description can be used to generate the at least one input.

Description:
CROSS REFERENCES 
     The following related documents are hereby incorporated by reference in their entirety: BEAW EB L OGIC  S ERVER ®: A SSEMBLING AND  C ONFIGURING  W EB  A PPLICATIONS  (Release 7.0, Jun. 28, 2002); BEAW EB L OGIC  S ERVER ®: P ROGRAMMING  W EB L OGIC  E NTERPRISE  J AVA B EANS ® (Release 7.0, Jun. 28, 2002); BEAW EB L OGIC  S ERVER ®: D EVELOPING  W EB L OGIC  S ERVER  A PPLICATIONS  (Release 7.0, Jun. 28, 2002); BEAW EB L OGIC  S ERVER ®: W EB L OGIC  B UILDER  O NLINE  H ELP  (Release 7.0, Jun. 28, 2002); BEAW EB L OGIC  S ERVER ®: P ROGRAMMING  WEBL OGIC  XML (Release 7.0, Jun. 28, 2002); BEAW EB L OGIC  S ERVER ®: P ROGRAMMING  WEBL OGIC  W EB  S ERVICES  (Release 7.0, Jun. 28, 2002); BEA WebLogic Server®: Programming WebLogic E NTERPRISE  J AVA B EANS ® (Release 7.0, Jun. 28, 2002). 
     COPYRIGHT NOTICE 
     A portion of the disclosure of this patent document contains material which is subject to copyright protection. The copyright owner has no objection to the facsimile reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office patent file or records, but otherwise reserves all copyright rights whatsoever. 
     FIELD OF THE DISCLOSURE 
     The present invention disclosure relates to the field of automatic code generation, in particular, automatic generation of Enterprise Java™ Bean source code files from an annotated class definition and the reverse. 
     BACKGROUND 
     Enterprise Java™ Beans are reusable software components written in the Java™ programming language. An Enterprise Java™ Bean (EJB) is typically declared in a number of separate source files which define various aspects of the EJB, such as its class, interfaces and deployment behavior. Each time a modification is made to one EJB source file, the other associated EJB source files must also be modified accordingly. This activity is cumbersome and error prone, since the changes must be manually propagated to different files. What is needed is a way to generate source files for EJB&#39;s with minimal editing and duplication of information. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         FIG. 1  is a block diagram of an EJB code generation system in accordance to one embodiment of the invention. 
         FIG. 2  is a block diagram of a reverse EJB code generation system in accordance to one embodiment of the invention. 
     
    
    
     DETAILED DESCRIPTION 
     The invention is illustrated by way of example and not by way of limitation in the figures of the accompanying drawings in which like references indicate similar elements. It should be noted that references to “an” or “one” embodiment in this disclosure are not necessarily to the same embodiment, and such references mean at least one. 
     In one embodiment, instead of having to edit and maintain several EJB files for each EJB (e.g., the bean class, remote and home classes, deployment descriptors, etc.), editing is limited to a single file that contains an annotated description of one or more EJB class definitions. EJB&#39;s are declared in the Java™ programming language. The Java™ programming language and run-time environment are available from Sun Microsystems, Inc., of Palo Alto, Calif. The annotated description file is processed in accordance to one embodiment and the EJB files required for deployment on a server are automatically generated. Annotations are directives that contain information needed to create an EJB&#39;s source files. In one embodiment, annotations are interspersed between Java™ source code statements. In another embodiment, annotations are embedded in Java™ comments. In yet another embodiment, an annotation is a Javadoc tag. Javadoc is the tool for generating source code documentation in hypertext markup language (“HTML”) format from tags embedded in Java™ source code comments. Javadoc is available from Sun Microsystems, Inc. In another embodiment, annotations are provided separately from the description of one or more EJB classes. For example, annotations can be provided in a graphical user interface, a separate file, or created dynamically based on run-time properties a user has associated with an EJB. 
     In one embodiment, by way of example, annotations can take the form: @ejbgen-name [attribute[=expression]] . . . attribute[=expression]], where items in square brackets are optional arguments. Name can be the type of annotation and the optional attribute=expression list can be comprised of one or more attribute-expression pairs. In one embodiment, attribute is the name of a required or optional parameter associated with an annotation and the optional expression can be, for example, an infix, postfix or prefix expression that evaluates to a constant (e.g., a number or an alpha-numeric string). In another embodiment, an expression&#39;s operators can be arithmetic, logical and string-based. For example, the following Java™ code segment has a comment block that contains three annotations: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 /** 
               
               
                   
                  * @ejbgen:cmp-field column = acct_id 
               
               
                   
                  * @ejbgen:primkey-field 
               
               
                   
                  * @ejbgen:remote-method transaction-attribute = Required 
               
               
                   
                  */ 
               
               
                   
                 abstract public String getAccountId( ); 
               
               
                   
                   
               
             
          
         
       
     
     Conventionally, an EJB&#39;s abstract accessor methods define container-managed persistence (“CMP”) data fields of the same name. For example, in the code segment above, assuming the accessor method getAccountId( ) was an EJB method, a corresponding data field called “accountId” would be defined upon deployment of the EJB. In one embodiment, the annotation “@ejbgen:cmp-field” specifies that the Accountld CMP field will be stored in column named “acct_id” of a database upon deployment of the EJB. The annotation “@ejbgen:primkey-field” indicates that Accountld will be a primary key in the database. Finally, the annotation “@ejbgen:remote-method” specifies that transaction isolation is required for the method getAccountId( ). All three annotations can be considered method annotations since they come before the declaration of a method. 
       FIG. 1  is a block diagram in accordance to one embodiment of the invention. An annotated description  1  is processed by analyzer  2 . Annotated description  1  can include one or more EJB definitions. In one embodiment, annotated description  1  can reside in a computer file. In another embodiment, annotated description  1  can reside in a computer memory. In yet a further embodiment, annotated description  1  can be transmitted via a computer network (not shown) to analyzer  2 . Analyzer  2  employs parser  4  to divide the Java™ source text in annotated description  1  into discrete units and extract annotations therefrom. Analyzer  2  may perform preprocessing of annotated description  1  before making use of parser  4 . In one embodiment, parser  4  can exploit the doclet application programming interface available in Javadoc. The Javadoc doclet interface provides programmatic access to a parsed representation of a Java™ source file. In one embodiment, parser  4  can process the entire annotated description  1  at once. In another embodiment, parser  4  can be employed repeatedly by analyzer  2  to incrementally process annotated description  1 . Each annotation is verified by comparing what was found in the annotated description  1  with a formal definition in annotation library  5 . In one embodiment, by way of example, annotation library  5  can be a database that includes the definition of each annotation (e.g., its required and optional parameters, permissible values, etc.). In another embodiment, annotation library  5  can be implemented as a cache, tree or any other suitable data structure without departing from the spirit or scope of the present disclosure. 
     If the annotation and its arguments are proper, analyzer  2  evaluates any attribute-expression arguments provided. The can be done during the validation of each annotation, or in another embodiment, after all annotations have been verified. Values for variable names that occur in expressions are retrieved from variable library  6 . In one embodiment, variable library  6  can be implemented in a similar fashion to annotation library  5 . In a further embodiment, variable names can be constructed dynamically from expressions using string concatenation operators. In one embodiment, each attribute-expression is evaluated, comparing the value of the expression to permissible values allowed for a given attribute as dictated by annotation library  5 . If an expression&#39;s value is out of range or erroneous, an error can be declared. In another embodiment, a suitable default value can be provided in place of the errant expression. The form of expressions can be, for example, infix, postfix and prefix. Means for parsing and evaluating such expressions are well known in the art. Based on the parsed annotations, code generator  3  emits the classes or files  7  necessary to deploy the EJB(s) described in annotated description  1 . 
     In one embodiment, annotations can be described in terms of their attributes, their scope (e.g., class or method) and the type of EJB they are applicable to (e.g., message, stateless session, stateful session, entity, etc.). Annotations having class scope come before a class declaration and annotations having method scope come before a method declaration. Annotations can also be adjacent to or associated with other Java™ elements such as fields or variables. In a further embodiment, and by way of illustration, annotations can be defined as in the following tables. The Annotation/Attribute column contains the annotation name in the first row of each table and any associated attribute names in the subsequent rows. The Description column contains a description of the annotation or attribute. The For column indicates whether the annotation is applicable to a class or a method. Finally, the EJB Type column indicates the type of EJB the annotation is applicable to (e.g., session, message, entity, etc.). It will be apparent to those skilled in the art that many such annotations are possible and therefore this illustration is illustrative and should not be construed to be limiting in any respect. 
     
       
         
               
               
               
               
             
           
               
                   
               
               
                   
                   
                   
                 EJB 
               
               
                 Annotation/Attribute 
                 Description 
                 For 
                 Type 
               
               
                   
               
             
             
               
                 @ejbgen:automatic-key- 
                 Automatically generate database keys for new 
                 Class 
                 Entity 
               
               
                 generation 
                 entity objects. 
               
               
                 cache-size 
                 The size of the key cache. (Required) 
               
               
                 Name 
                 The name of the key generator. (Required) 
               
               
                 Type 
                 The type of the key generator. (Required) 
               
               
                 @ejbgen:cmp-field 
                 Specifies a container-managed field. 
                 Method 
                 Entity 
               
               
                 Column 
                 The column where this CMP field will be mapped. 
               
               
                   
                 (Required) 
               
               
                 column-type 
                 (OracleClob|OracleBlob) The type of this column. 
               
               
                 group-names 
                 The names of the groups this field belongs to, 
               
               
                   
                 separated by commas. 
               
               
                 ordering-number 
                 (0..n) The number where this field must 
               
               
                   
                 appear in signatures and constructors. For this 
               
               
                   
                 ordering to work, all CMR and CMP fields must 
               
               
                   
                 have this attribute to a distinct numeric value. 
               
               
                 @ejbgen:cmr-field 
                 Specifies a container-managed relationship. 
                 Method 
                 Entity 
               
               
                 group-names 
                 The names of the groups this field belongs to 
               
               
                   
                 separated by commas. 
               
               
                 ordering-number 
                 (0..n) The number where this field must 
               
               
                   
                 appear in signatures and constructors. For this 
               
               
                   
                 ordering to work, all CMR and CMP fields must 
               
               
                   
                 have this attribute to a distinct numeric value. 
               
               
                 @ejbgen:create-default- 
                 Automatically create required database tables. 
                 Class 
                 Entity 
               
               
                 rdbms-tables 
               
               
                 @ejbgen:ejb-client-jar 
                 Specify the name of the jar file to generate. 
                 Class 
                 All 
               
               
                 file-name 
                 The name of the client jar to generate. If more than 
               
               
                   
                 one EJB&#39;s have this tag, only one of the specified 
               
               
                   
                 jar files will be included in the deployment 
               
               
                   
                 descriptor. (Required) 
               
               
                 @ejbgen:ejb-local-ref 
                 Declare a reference to an EJB that is in the same 
                 Class 
                 All 
               
               
                   
                 container and EJB JAR file. 
               
               
                 Home 
                 Logal class of the bean. 
               
               
                 jndi-name 
                 The JNDI name of the reference. 
               
               
                 Link 
                 Link of the bean. 
               
               
                 Local 
                 Home class of the bean. 
               
               
                 Name 
                 Name of the reference. 
               
               
                 Type 
                 (Entity|Session) 
               
               
                 @ejbgen:ejb-ref 
                 Define a reference to another EJB within the 
                 Class 
                 All 
               
               
                   
                 Java ™ Naming and Directory Interface (“JNDI”) 
               
               
                   
                 Environment Naming Context (“ENC”). 
               
               
                 Home 
                 Home class of the bean. 
               
               
                 jndi-name 
                 The JNDI name of the reference. 
               
               
                 Link 
                 Link of the bean. 
               
               
                 Name 
                 Name of the reference. 
               
               
                 Remote 
                 Remote class of the bean. 
               
               
                 Type 
                 (Entity|Session) 
               
               
                 @ejbgen:entity 
                 Declare an entity bean. 
                 Class 
                 Entity 
               
               
                 ejb-name 
                 The name of this Entity bean. (Required) 
               
               
                 prim-key-class 
                 The Java ™ class of the primary key. In case of a 
               
               
                   
                 compound primary key, this class will be 
               
               
                   
                 generated. (Required) 
               
               
                   
                 Sometimes, a simple (e.g. java.lang.String) 
               
               
                   
                 primary key class will not be enough to identify an 
               
               
                   
                 EJB uniquely. In such a case, a primary key is 
               
               
                   
                 needed. A primary key is a custom Java class 
               
               
                   
                 containing several fields. All of the fields together 
               
               
                   
                 identify an EJB uniquely. 
               
               
                   
                 There are certain constraints associated with the 
               
               
                   
                 compound primary key class (e.g it must be 
               
               
                   
                 Serializable, implement hashCode( ), equals( ), etc.). 
               
               
                   
                 A compound primary key class can contain fields 
               
               
                   
                 that form a subset of the CMP fields of the EJB. In 
               
               
                   
                 order to define a compound primary key class: 
               
               
                   
                 Annotate each CMP field that should be part of the 
               
               
                   
                 primary key class with @primkey-field. 
               
               
                 abstract-schema-name 
                 The abstract schema name for this EJB. If not 
               
               
                   
                 specified, the ejb-name value will be used. 
               
               
                 cache-between- 
                 (True|False) Whether to cache the persistent data 
               
               
                 transactions 
                 of an entity bean across (between) transactions. 
               
               
                 check-exists-on-method 
                 (True|False) Whether the container checks for the 
               
               
                   
                 existence of a bean for each method call. 
               
               
                 concurrency-strategy 
                 (Read Only|Exclusive|Database) Defines the 
               
               
                   
                 concurrency strategy for this bean. 
               
               
                 data-source-name 
                 The name of the data source (as it was declared in 
               
               
                   
                 config.xml). 
               
               
                 database-type 
                 The type of the database. 
               
               
                 db-is-shared 
                 (True|False) Whether the database is shared. 
               
               
                 default-transaction 
                 The transaction attribute to be applied to all 
               
               
                   
                 methods that do not have a more specific 
               
               
                   
                 transaction attribute setting. 
               
               
                 delay-database-insert- 
                 (ejb Create|ejbPost Create) 
               
               
                 until 
               
               
                 delay-updates-until-end- 
                 (True|False) Whether updates will be sent after the 
               
               
                 of-tx 
                 transaction has committed. 
               
               
                 enable-dynamic-queries 
                 (True|False) Whether dynamic queries are enabled. 
               
               
                 finders-load-bean 
                 (True|False) If this is set to True, the beans will 
               
               
                   
                 immediately be loaded into the cache by the finder. 
               
               
                 home-call-router-class- 
                 Class to be used for routing home method calls. 
               
               
                 name 
               
               
                 home-is-clusterable 
                 (True|False) Whether this bean can be deployed 
               
               
                   
                 from multiple servers in a cluster. 
               
               
                 home-load-algorithm 
                 (Round|Robin|Random|WeightBased) The 
               
               
                   
                 algorithm to use for load-balancing between 
               
               
                   
                 replicas of this home. 
               
               
                 idle-timeout-seconds 
                 Maximum duration an EJB should stay in the 
               
               
                   
                 cache. 
               
               
                 invalidation-target 
                 The ejb-name of a read-only Entity bean that 
               
               
                   
                 should be invalidated when this Container- 
               
               
                   
                 Managed Persistence Entity EJB has been 
               
               
                   
                 modified. 
               
               
                 max-beans-in-cache 
                 The maximum number of beans in the cache. 
               
               
                 Optimistic-column 
                 The column that holds the time stamp for 
               
               
                   
                 optimistic concurrency 
               
               
                 persistence-type 
                 (cmp|bmp) The type of this Entity bean (default: 
               
               
                   
                 cmp) 
               
               
                 prim-key-class-nogen 
                 (True|False). If this keyword is specified, EJBGen 
               
               
                   
                 will not generate the primary key class. 
               
               
                 read-timeout-seconds 
                 The number of seconds between each ejbLoad( ) 
               
               
                   
                 call on a Read-Only Entity bean. 
               
               
                 reentrant 
                 (True|False) Whether the class methods are 
               
               
                   
                 reentrant. 
               
               
                 run-as 
                 Specifies the role-name for this EJB. 
               
               
                 run-as identity-principal 
                 The name of the principal in case the role maps to 
               
               
                   
                 several principals. 
               
               
                 table-name 
                 The name of the table this Entity bean is mapped 
               
               
                   
                 to. 
               
               
                 trans-timeout-seconds 
                 The transaction timeout (in seconds). 
               
               
                 use-caller-identity 
                 (True|False) Whether this EJB uses caller&#39;s 
               
               
                   
                 identity. 
               
               
                 verify-columns 
                 (Read|Modified|Version|Timestamp) How 
               
               
                   
                 optimistic concurrency verifies that the columns 
               
               
                   
                 modified during the transactions have not been 
               
               
                   
                 modified. 
               
               
                 @ejbgen:env-entry 
                 Declare an environment entry to be made available 
                 Class 
                 All 
               
               
                   
                 through JNDI ENC. 
               
               
                 Name 
                 The name of this environment entry. (Required) 
               
               
                 Type 
                 The Java type for this environment entry (must be 
               
               
                   
                 fully qualified, even if java.lang). (Required) 
               
               
                 Value 
                 The value for this environment entry. (Required) 
               
               
                 @ejbgen:file-generation 
                 Control which files are generated. 
                 Class 
                 All 
               
               
                 local-class 
                 (True|False) Whether to generate the local 
               
               
                   
                 interface for this EJB. 
               
               
                 local-home 
                 (True|False) Whether to generate the local home 
               
               
                   
                 interface for this EJB. 
               
               
                 pk-class 
                 (True|False) Whether to generate the primary key 
               
               
                   
                 class for this EJB. 
               
               
                 remote-class 
                 (True|False) Whether to generate the remote 
               
               
                   
                 interface for this EJB. 
               
               
                 remote-home 
                 (True|False) Whether to generate the remote home 
               
               
                   
                 interface for this EJB. 
               
               
                 value-class 
                 (True|False) Whether to generate the value class 
               
               
                   
                 for this EJB 
               
               
                 @ejbgen:finder 
                 Specify finder method attributes. 
                 Class 
                 Entity 
               
               
                 caching-name 
                 The name of an eager relationship caching. 
               
               
                 ejb-ql 
                 The EJB QL request as it will appear in the 
               
               
                   
                 deployment descriptor. 
               
               
                 group-name 
                 Name of the group for the WebLogic query 
               
               
                 include-updates 
                 (True|False) Whether updates made during the 
               
               
                   
                 current transaction must be reflected in the result 
               
               
                   
                 of a query. 
               
               
                 isolation-level 
                 The type of transaction isolation for this method. 
               
               
                 max-elements 
                 The maximum number of elements that should be 
               
               
                   
                 returned by a multi-valued query. 
               
               
                 Signature 
                 It must match exactly the signature generated on 
               
               
                   
                 the Home class. 
               
               
                 sql-select-distinct 
                 (True|False) Whether the generated SQL 
               
               
                   
                 ‘SELECT’ will contain a ‘DISTINCT’ qualifier. 
               
               
                 transaction-attribute 
                 The transaction attribute for this local method. If 
               
               
                   
                 not specified, the default transaction attribute will 
               
               
                   
                 be used. Methods with this tag will be generated on 
               
               
                   
                 the Local class. 
               
               
                 Weblogic-ejb-ql 
                 The Weblogic EJB QL request as it will appear in 
               
               
                   
                 the deployment descriptor. 
               
               
                 @ejbgen:foreign jms- 
                 Specify the provider of a Java ™ Message Service 
                 Class 
                 Message- 
               
               
                 provider 
                 (“JMS”) 
                   
                 Driven 
               
               
                 connection-factory-jndi- 
                 The connection factory JNDI name. (Required) 
               
               
                 name 
               
               
                 initial context-factory 
                 The initial JNDI context factory. (Required) 
               
               
                 provider-url 
                 The provider URL. (Required) 
               
               
                 @ejbgen:isolation- 
                 Specify transaction isolation level in the server. 
                 Class 
                 All 
               
               
                 level pattern 
               
               
                 isolation-level 
                 The isolation level for the methods specified in the 
               
               
                   
                 pattern tag. (Required) 
               
               
                 Pattern 
                 The pattern that matches all methods that will 
               
               
                   
                 receive this isolation level (e.g. “*”). (Required) 
               
               
                 @ejbgen:jndi-name 
                 Specify the JNDI name of this bean. 
                 Class 
                 All 
               
               
                 Local 
                 The local JNDI name of this EJB. If not specified, 
               
               
                   
                 local interfaces will not be generated. 
               
               
                 Remote 
                 The remote JNDI name of this EJB. If not 
               
               
                   
                 specified, remote interfaces will not be generated. 
               
               
                 @ejbgen:local-home 
                 Specify attributes of this local home method. 
                 Method 
                 Entity, 
               
               
                 method 
                   
                   
                 Session 
               
               
                 Roles 
                 Comma-separated list of roles that are allowed to 
               
               
                   
                 invoke this method. 
               
               
                 transaction-attribute 
                 The transaction attribute for this local method. If 
               
               
                   
                 not specified, the default transaction attribute will 
               
               
                   
                 be used. Methods with this tag will be generated on 
               
               
                   
                 the Local class. 
               
               
                 @ejbgen:local-method 
                 Specify attributes of this local method. 
                 Method 
                 Entity, 
               
               
                   
                   
                   
                 Session 
               
               
                 isolation-level 
                 The type of transaction isolation for this method. 
               
               
                 Roles 
                 Comma-separated list of roles that are allowed to 
               
               
                   
                 invoke this method. 
               
               
                 transaction-attribute 
                 The transaction attribute for this local method. If 
               
               
                   
                 not specified, the default transaction attribute will 
               
               
                   
                 be used. Methods with this tag will be generated on 
               
               
                   
                 the Local class. 
               
               
                 @ejbgen:message-driven 
                 Declare a message-driven EJB. 
                 Class 
                 Message- 
               
               
                   
                   
                   
                 Driven 
               
               
                 destination-jndi-name 
                 The JNDI name of the destination. (Required) 
               
               
                 ejb-name 
                 The name of this Message-Driven bean. 
               
               
                   
                 (Required) 
               
               
                 acknowledge-mode 
                 (auto-acknowledge-ok-acknowledge) The 
               
               
                   
                 acknowledgement mode. 
               
               
                 default-transaction 
                 The transaction attribute to be applied to all 
               
               
                   
                 methods that do not have a more specific 
               
               
                   
                 transaction attribute setting. 
               
               
                 destination-type 
                 (javax.jms.Queue|javax.jms.Topic). 
               
               
                 initial-beans-in-free-pool 
                 The initial number of beans in the free pool. 
               
               
                 max-beans-in-free-pool 
                 The maximum number of beans in the free pool. 
               
               
                 message-selector 
                 The JMS message selector. 
               
               
                 run-as 
                 Specifies the role-name for this EJB. 
               
               
                 run-as-identity-principal 
                 The name of the principal in case the role maps to 
               
               
                   
                 several principals. 
               
               
                 trans-timeout-seconds 
                 The transaction timeout (in seconds). 
               
               
                 transaction-type 
                 (Bean|Container) Who manages the transactions 
               
               
                   
                 for this EJB. 
               
               
                 use-caller-identity 
                 (True|False) Whether this EJB uses caller&#39;s 
               
               
                   
                 identity. 
               
               
                 @ejbgen:method- 
                 Specify a permission pattern for this class. 
                 Class 
                 All 
               
               
                 permission-pattern 
               
               
                 Pattern 
                 The pattern that matches all methods that will 
               
               
                   
                 receive this method permission (e.g. “*”). 
               
               
                 Roles 
                 The roles for the methods specified in the pattern 
               
               
                   
                 tag. Separated by a comma. 
               
               
                 @ejbgen:primkey-field 
                 Specify the primary key field for an entity bean. 
                 Method 
                 Entity 
               
               
                 @ejbgen:relation 
                 Specify an entity bean relationship. 
                 Class 
                 Entity 
               
               
                   
                 Unidirectional relationships are achieved by 
               
               
                   
                 specifying only the first three parameters (i.e, no 
               
               
                   
                 cmr-field, no fk-column, no joint-table). 
               
               
                 multiplicity 
                 Many to many relationships must specify an extra 
               
               
                   
                 table (“joint-table”) which must contain at least 
               
               
                   
                 two columns. The names of these columns must 
               
               
                   
                 match the names of the columns containing the 
               
               
                   
                 foreign keys of the two EJB&#39;s being joined. 
               
               
                   
                 (one|many) Specifies the multiplicity of the 
               
               
                   
                 relationship. (Required) 
               
               
                 Name 
                 The name of the relationship. Use the same name 
               
               
                   
                 on both ends of a relationship for the roles to be 
               
               
                   
                 generated properly (note that this constraint applies 
               
               
                   
                 to unidirectional as well). (Required) 
               
               
                 target-ejb 
                 The EJB name of the target of this relationship. 
               
               
                   
                 (Required) 
               
               
                 cascade-delete 
                 (True|False) 
               
               
                 cmr-field 
                 The CMR field where this relationship will be 
               
               
                   
                 kept. If it not specified, the relationship is 
               
               
                   
                 unidirectional. If specified, the attribute fk-column 
               
               
                   
                 must be specified as well. 
               
               
                 db-cascade-delete 
                 (True|False) Whether a cascade delete will use the 
               
               
                   
                 built-in cascade delete facilities of the underlying 
               
               
                   
                 database. 
               
               
                 fk-column 
                 Only needed in a relationship having at least one 
               
               
                   
                 side. In that case, the non-one side EJB must 
               
               
                   
                 declare a column that it will use to store the 
               
               
                   
                 primary key of its counterpart. 
               
               
                 joint-table 
                 Only needed in a Many-Many relationship. It must 
               
               
                   
                 be the name of an existing table that will be used to 
               
               
                   
                 hold the joint table containing the relationships. If 
               
               
                   
                 using a compound primary key, specify a set of 
               
               
                   
                 corresponding foreign keys separated by commas. 
               
               
                 role-name 
                 The name of this role (such as 
               
               
                   
                 “ParentHasChildren”). If no role name is given, 
               
               
                   
                 will generate one. 
               
               
                 @ejbgen:relationship- 
                 Specify cache information for relationship. 
                 Class 
                 Entity 
               
               
                 caching-element 
               
               
                 caching-name 
                 The name of an eager relationship cashing. 
               
               
                   
                 (Required) 
               
               
                 cmr-field 
                 The name of the CMR field. (Required) 
               
               
                 group-name 
                 The name of the group to be loaded for the CMR 
               
               
                   
                 field. 
               
               
                 @ejbgen:remote-home- 
                 Specify roles allowed to invoke this home method. 
                 Method 
                 Entity, 
               
               
                 method 
                   
                   
                 Session 
               
               
                   
                 The method name must start with “ejbHome”. 
               
               
                   
                 Note: Home Methods do not apply to message 
               
               
                   
                 EJB&#39;s Beans. The “throws RemoteException” in 
               
               
                   
                 the EJB class will be automatically generated in 
               
               
                   
                 the home class. 
               
               
                 Roles 
                 Comma-separated list of roles that are allowed to 
               
               
                   
                 invoke this method. 
               
               
                 transaction-attribute 
                 The transaction attribute for this remote method. If 
               
               
                   
                 not specified, the default transaction attribute will 
               
               
                   
                 be used. Methods with this tag will be generated on 
               
               
                   
                 the Remote class. 
               
               
                 @ejbgen:remote-method 
                 Specify a method available in a remote interface. 
                 Method 
                 Entity, 
               
               
                   
                   
                   
                 Session 
               
               
                 isolation-level 
                 The type of transaction isolation for this method. 
               
               
                 Roles 
                 Comma-separated list of roles that are allowed to 
               
               
                   
                 invoke this method. 
               
               
                 transaction-attribute 
                 The transaction attribute for this remote method. If 
               
               
                   
                 not specified, the default transaction attribute will 
               
               
                   
                 be used. Methods with this tag will be generated on 
               
               
                   
                 the Remote class. 
               
               
                 @ejbgen:resource- 
                 Specify the name of a resource environment 
                 Class 
                 All 
               
               
                 env-ref 
                 reference. (Required) 
               
               
                 Name 
                 Name of the resource environment reference. 
               
               
                   
                 (Required) 
               
               
                 Type 
                 Type of the environment resource references (e.g. 
               
               
                   
                 javax.jms.Queue). (Required) 
               
               
                 jndi-name 
                 JNDI name of the resource. 
               
               
                 @ejbgen:resource-ref 
                 Specify the JNDI name of a resource. 
                 Class 
                 All 
               
               
                 Auth 
                 (Application|Container) (Required) 
               
               
                 jndi-name 
                 JNDI name of the resource. (Required) 
               
               
                 Name 
                 Name of the resource. (Required) 
               
               
                 Type 
                 Tyoe of the resource (e.g. javax.sql.DataSource). 
               
               
                   
                 (Required) 
               
               
                 sharing-scope 
                 (Shareable|Unshareable) 
               
               
                 @ejbgen:role-mapping 
                 Specify roles. 
                 Class 
                 All 
               
               
                 Principals 
                 The names of the principals in this role (separated 
               
               
                   
                 by commas). (Required) 
               
               
                 role-name 
                 The name of the role. (Required) 
               
               
                 @ejbgen:select 
                 Specify attributes of select method. 
                 Method 
                 Entity 
               
               
                 ejb-ql 
                 The EJB-QL defining this select method. Note: the 
               
               
                   
                 method name must start with ejbSelect. (Required) 
               
               
                 caching-name 
                 The name of an eager relationship caching. 
               
               
                 group-name 
                 Name of the group for the WebLogic query. 
               
               
                 include-updates 
                 (True|False) Whether updates made during the 
               
               
                   
                 current transaction must be reflected in the result 
               
               
                   
                 of a query. 
               
               
                 max-elements 
                 The maximum number of elements that should be 
               
               
                   
                 returned by a multi-valued query. 
               
               
                 result-type-mapping 
                 (Remote|Local) Whether the returned objects are 
               
               
                   
                 mapped to EJBLocalObject or EJBObject. 
               
               
                 sql-select-distinct 
                 (True|False) Whether the generated SQL 
               
               
                   
                 ‘SELECT’ will contain a ‘DISTINCT’ qualifier. 
               
               
                 Weblogic-ejb-ql 
                 The Weblogic EJB QL request as it will appear in 
               
               
                   
                 the deployment descriptor. 
               
               
                 @ejbgen:session 
                 Declare a session bean. 
                 Class 
                 Session 
               
               
                 ejb-name 
                 The name of this Session bean. (Required) 
               
               
                 bean-load-algorithm 
                 The algorithm to use for load-balancing between 
               
               
                   
                 replicas of this bean. 
               
               
                 call-router-class-name 
                 Class name to be used for routing home method 
               
               
                   
                 calls 
               
               
                 default-transaction 
                 The transaction attribute to be applied to all 
               
               
                   
                 methods that do not have a more specific 
               
               
                   
                 transaction attribute setting. 
               
               
                 home-call-router-class- 
                 Class to be used for routing home method calls. 
               
               
                 name 
               
               
                 home-is-clusterable 
                 (True|False) Whether this bean can be deployed 
               
               
                   
                 from multiple servers in a cluster. 
               
               
                 home-load-algorithm 
                 (RoundRobin|Random|WeightBased) The 
               
               
                   
                 algorithm to use for load-balancing between 
               
               
                   
                 replicas of this home. 
               
               
                 idle-timeout-seconds 
                 Maximum duration an EJB should stay in the 
               
               
                   
                 cache 
               
               
                 initial-beans-in-free-pool 
                 The initial number of beans in the free pool. 
               
               
                 is-clusterable 
                 (True|False) Whether this bean is cluster-able. 
               
               
                 load-algorithm 
                 (RoundRobin|Random|WeightBased) The name of 
               
               
                   
                 the algorithm used to balance replicas of this 
               
               
                   
                 home. 
               
               
                 max-beans-in-cache 
                 The maximum number of beans in the cache. 
               
               
                 max-beans-in-free-pool 
                 The maximum number of beans in the free pool. 
               
               
                 methods-are-idempotent 
                 (True|False) Whether the methods for this stateless 
               
               
                   
                 session bean are idem potent or not. 
               
               
                 replication-type 
                 (InMemory|None) How to replicate stateful session 
               
               
                   
                 beans in a cluster. 
               
               
                 run-as 
                 Specifies the role-name for this EJB. 
               
               
                 run-as-identity-principal 
                 The name of the principal in case the role maps to 
               
               
                   
                 several principals. 
               
               
                 trans-timeout-seconds 
                 The transaction timeout (in seconds). 
               
               
                 transaction-type 
                 (Bean|Counter) Who manages the transactions for 
               
               
                   
                 this EJB. 
               
               
                 Type 
                 (Stateless|Stateful) The type of the Session bean. If 
               
               
                   
                 this attribute is not specified, EJBGen will guess 
               
               
                   
                 the right type by looking at the ejbCreate( ) 
               
               
                   
                 methods on the class. 
               
               
                 use-caller-identity 
                 (True|False) Whether this EJB uses caller&#39;s 
               
               
                   
                 identity. 
               
               
                 @ejbgen:value-object 
                 Specify objects to be referenced by the value 
                 Class 
                 All 
               
               
                   
                 object class. 
               
               
                 Reference 
                 (Local|Value) Specify what objects the value 
               
               
                   
                 object class should reference when accessing other 
               
               
                   
                 EJB&#39;s. (Required) 
               
               
                   
               
             
          
         
       
     
     In one embodiment, by way of example, the following class annotations accompany a Java™ code fragment that declares a stateless session EJB “Trader” having a JNDI name of “ejb20-statelessSession-TraderHome”, and an environment variable “tradeLimit” with a default value of 500. 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 /** 
               
               
                   
                  * @ejbgen:session 
               
               
                   
                  *  ejb-name = statelessSession 
               
               
                   
                  *  max-beans-in-free-pool = 100 
               
               
                   
                  *  is-clusterable = false 
               
               
                   
                  *  load-algorithm = Random 
               
               
                   
                  * 
               
               
                   
                  * @ejbgen:jndi-name 
               
               
                   
                  *  remote = ejb20-statelessSession-TraderHome 
               
               
                   
                  * 
               
               
                   
                  * @ejbgen:env-entry 
               
               
                   
                  *  name = tradeLimit 
               
               
                   
                  *  type = java.lang.Integer 
               
               
                   
                  *  value = 500 
               
               
                   
                  * 
               
               
                   
                  */ 
               
               
                   
                 public class TraderEJB implements SessionBean { 
               
               
                   
                  private static final boolean VERBOSE = true; 
               
               
                   
                  private SessionContext ctx; 
               
               
                   
                  private int tradeLimit; 
               
               
                   
                  ejbCreate( ) ; 
               
               
                   
                 . . . 
               
               
                   
                   
               
             
          
         
       
     
     The type of session EJB (e.g., stateful or stateless) can be automatically determined. For example, if there is an ejbCreate( ) method having a non-empty parameter list, the EJB is stateful. Otherwise, the EJB is stateless. Two methods associated with this EJB are declared below with method annotations indicating that they are available through a remote interface (i.e., to clients residing outside of the Java™ application server in which this EJB is deployed). Notice that both methods make use of the environment variable “tradeLimit” which was declared in the class annotation. 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                  /** 
               
               
                   
                   *  Buys shares of a stock for a named customer. 
               
               
                   
                   * 
               
               
                   
                   *  @ejbgen:remote-method 
               
               
                   
                   */ 
               
               
                   
                  public TradeResult buy(String stockSymbol, int shares) { 
               
               
                   
                   if (shares &gt; tradeLimit) { 
               
               
                   
                    log(“Attempt to buy “+shares+” is greater than limit of 
               
               
                   
                 ”+tradeLimit); 
               
               
                   
                    shares = tradeLimit; 
               
               
                   
                   } 
               
               
                   
                  log(“Buying “+shares+” shares of ”+stockSymbol); 
               
               
                   
                  return new TradeResult(shares, stockSymbol); 
               
               
                   
                  } 
               
               
                   
                  /** 
               
               
                   
                   *  Sells shares of a stock for a named customer. 
               
               
                   
                   * 
               
               
                   
                   *  @ejbgen:remote-method 
               
               
                   
                   * 
               
               
                   
                   */ 
               
               
                   
                  public TradeResult sell(String stockSymbol, int shares) { 
               
               
                   
                   if (shares &gt; tradeLimit) { 
               
               
                   
                    log(“Attempt to sell “+shares+” is greater than limit of 
               
               
                   
                 ”+tradeLimit); 
               
               
                   
                    shares = tradeLimit; 
               
               
                   
                   } 
               
               
                   
                   log(“Selling “+shares+” shares of ”+stockSymbol); 
               
               
                   
                   return new TradeResult(shares, stockSymbol); 
               
               
                   
                  } 
               
               
                   
                 } 
               
               
                   
                   
               
             
          
         
       
     
     The @ejbgen:remote-method annotation indicates that a method will be available in a remote interface. A remote interface declares an EJB&#39;s methods that are accessible to applications outside of an EJB&#39;s container. Two Java™ files and two deployment descriptors are automatically generated in accordance to an embodiment based on the code fragment above: 
     
       
         
               
               
             
           
               
                   
               
               
                 File Name 
                 Contents 
               
               
                   
               
             
             
               
                 TraderHome 
                 import javax.ejb.CreateException; 
               
               
                 .java 
                 import javax.ejb.EJBHome; 
               
               
                 Home 
                 import javax.ejb.FinderException; 
               
               
                 Interface 
                 import java.rmi.RemoteException; 
               
               
                   
                 import java.util.Collection; 
               
               
                   
                 public interface TraderHome extends EJBHome { 
               
               
                   
                  public Trader create( )   throws CreateException, 
               
               
                   
                 RemoteException, CreateException; 
               
               
                   
                 } 
               
               
                 Trader.java 
                 import java.rmi.RemoteException; 
               
               
                 Remote 
                 import javax.ejb.EJBObject; 
               
               
                 Interface 
                 public interface Trader extends EJBObject { 
               
               
                   
                  public TradeResult buy(String stockSymbol, int 
               
               
                   
                 shares)  throws RemoteException; 
               
               
                   
                   public TradeResult sell (String stockSymbol, int 
               
               
                   
                 shares)   throws RemoteException; 
               
               
                   
                 } 
               
               
                 ejb-jar.xml 
                 &lt;ejb-jar&gt; 
               
               
                 EJB 
                  &lt;enterprise-beans&gt; 
               
               
                 Deployment 
                   &lt;session&gt; 
               
               
                 Descriptor 
                    &lt;ejb-name&gt;statelessSession&lt;/ejb-name&gt; 
               
               
                   
                 &lt;home&gt;examples.ejb20.basic.statelessSession. 
               
               
                   
                 TraderHome&lt;/home&gt; 
               
               
                   
                 &lt;remote&gt;examples.ejb20.basic.statelessSession. 
               
               
                   
                 Trader&lt;/remote&gt; 
               
               
                   
                    &lt;ejb- 
               
               
                   
                 class&gt;examples.ejb20.basic.statelessSession.TraderEJB&lt;/ 
               
               
                   
                 ejb-class&gt; 
               
               
                   
                    &lt;session-type&gt;Stateless&lt;/session-type&gt; 
               
               
                   
                    &lt;transaction-type&gt;Container&lt;/transaction-type&gt; 
               
               
                   
                    &lt;env-entry&gt; 
               
               
                   
                     &lt;env-entry-name&gt;INTL&lt;/env-entry-name&gt; 
               
               
                   
                     &lt;env-entry-type&gt;java.lang.Double&lt;/env-entry- 
               
               
                   
                 type&gt; 
               
               
                   
                     &lt;env-entry-value&gt;15.0&lt;/env-entry-value&gt; 
               
               
                   
                    &lt;/env-entry&gt; 
               
               
                   
                    &lt;env-entry&gt; 
               
               
                   
                     &lt;env-entry-name&gt;tradeLimit&lt;/env-entry-name&gt; 
               
               
                   
                     &lt;env-entry-type&gt;java.lang.Integer&lt;/env-entry- 
               
               
                   
                 type&gt; 
               
               
                   
                     &lt;env-entry-value&gt;500&lt;/env-entry-value&gt; 
               
               
                   
                    &lt;/env-entry&gt; 
               
               
                   
                    &lt;env-entry&gt; 
               
               
                   
                     &lt;env-entry-name&gt;WEBL&lt;/env-entry-name&gt; 
               
               
                   
                     &lt;env-entry-type&gt;java.lang.Double&lt;/env-entry- 
               
               
                   
                 type&gt; 
               
               
                   
                     &lt;env-entry-value&gt;10.0&lt;/env-entry-value&gt; 
               
               
                   
                    &lt;/env-entry&gt; 
               
               
                   
                   &lt;/session&gt; 
               
               
                   
                  &lt;/enterprise-beans&gt; 
               
               
                   
                 &lt;/ejb-jar&gt; 
               
               
                 weblogic- 
                 &lt;?xml version=“1.0”?&gt; 
               
               
                 ejb-jar.xml 
                 &lt;!DOCTYPE weblogic-ejb-jar PUBLIC “-//BEA Systems, 
               
               
                 BEA 
                 Inc.//DTD WebLogic 6.0.0 EJB//EN” 
               
               
                 WebLogic 
                 “http://www.bea.com/servers/wls600/dtd/weblogic-ejb- 
               
               
                 Server ® 
                 jar.dtd” &gt; 
               
               
                 Deployment 
                 &lt;weblogic-ejb-jar&gt; 
               
               
                 Descriptor 
                  &lt;weblogic-enterprise-bean&gt; 
               
               
                   
                   &lt;ejb-name&gt;statelessSession&lt;/ejb-name&gt; 
               
               
                   
                   &lt;stateless-session-descriptor&gt; 
               
               
                   
                    &lt;pool&gt; 
               
               
                   
                     &lt;max-beans-in-free-pool&gt;100&lt;/max-beans- 
               
               
                   
                     in-free-pool&gt; 
               
               
                   
                    &lt;/pool&gt; 
               
               
                   
                    &lt;stateless-clustering&gt; 
               
               
                   
                     &lt;stateless-bean-is- 
               
               
                   
                 clusterable&gt;false&lt;/stateless-bean-is-clusterable&gt; 
               
               
                   
                    &lt;/stateless-clustering&gt; 
               
               
                   
                   &lt;/stateless-session-descriptor&gt; 
               
               
                   
                   &lt;jndi-name&gt;ejb20-statelessSession-TraderHome&lt;/jndi- 
               
               
                   
                 name&gt; 
               
               
                   
                  &lt;/weblogic-enterprise-bean&gt; 
               
               
                   
                 &lt;/weblogic-ejb-jar&gt; 
               
               
                   
               
             
          
         
       
     
     In one embodiment, a value associated with an attribute can be specified with a constant or a variable. In another embodiment, a variable definition can be separate from the EJB definition (e.g., in another file). For example, the variable “remote-jndi-name” can be defined as “Account” as follows:
         remote-jndi-name=Account       

     Within the annotated description, variables can be accessed with the delimiters “${“and”}”. For example:
         @ejbgen:jndi-name   remote=${remote-jndi-name}
 
Thus, “remote” would be equal to “Account”.
       

     In another embodiment, variables can be used anywhere after an annotation and can contain whole annotation definitions. Assuming the following variable definition:
         jndi-name-tag=remote=RemoteAccount local=LocalAccount       

     The following annotation:
         @ejbgen:jndi-name   ${jndi-name-tag}
 
would expand to:
   @ejbgen:jndi-name   remote=RemoteAccount Local=LocalAccount       

     In another embodiment, predefined variables are recognized. Predefined variables have default values that can be overridden. In one embodiment, predefined variables can be defined as follows: 
     
       
         
               
               
               
             
           
               
                   
                   
               
               
                   
                 Variable Name 
                 Description 
               
               
                   
                   
               
             
             
               
                   
                 remote.baseClass 
                 The value of this variable will be 
               
               
                   
                   
                 used as the base class for all generate 
               
               
                   
                   
                 remote classes. 
               
               
                   
                 home.baseClass 
                 The value of this variable will be 
               
               
                   
                   
                 used as the base class for all 
               
               
                   
                   
                 generated remote home classes. 
               
               
                   
                 local.baseClass 
                 The value of this variable will be 
               
               
                   
                   
                 used as the base class for all 
               
               
                   
                   
                 generated local classes. 
               
               
                   
                 localHome.baseClass 
                 The value of this variable will be 
               
               
                   
                   
                 used as the base class for all 
               
               
                   
                   
                 generated local home classes. 
               
               
                   
                 value.baseClass 
                 The value of this variable will be 
               
               
                   
                   
                 used as the base class for all 
               
               
                   
                   
                 generated value classes. 
               
               
                   
                 value.package 
                 The value of this variable will be 
               
               
                   
                   
                 used as the package for all 
               
               
                   
                   
                 generated value classes. 
               
               
                   
                   
               
             
          
         
       
     
     In another embodiment, predefined variables can be prefixed with a class name. For example, if the following predefined variables are overridden as follows:
         Account.home-baseClass=BaseAccountHome   home.baseClass=BaseHome   value.package=value   containerManaged.value.package=valuePackageForContainerManaged       

     Thus, all home interfaces generated will extend the class BaseHome except the home of EJB “Account”, which will extend BaseAccountHome. 
     In another embodiment, EJB annotations can be inherited according to Java™ class inheritance. For example, if an EJB named AccountEJB has a base class BaseAccount: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 /** 
               
               
                   
                  *  @ejbgen:jndi-name 
               
               
                   
                  *    remote=“BaseRemote” 
               
               
                   
                  *  @ejbgen:entity 
               
               
                   
                  *   max-beans-in-cache = 300 
               
               
                   
                 */ 
               
               
                   
                 public class BaseAccount implements EntityBean { 
               
               
                   
                 . . . 
               
               
                   
                 } 
               
               
                   
                 /** 
               
               
                   
                  *  @ejbgen:entity 
               
               
                   
                  *   ejb-name = containerManaged 
               
               
                   
                  *   table-name = ejbAccounts 
               
               
                   
                  *   data-source-name = examples-dataSource-demoPool 
               
               
                   
                  *   max-beans-in-cache = 400 
               
               
                   
                  * 
               
               
                   
                 */ 
               
               
                   
                 public class AccountEJB extends BaseAccount { 
               
               
                   
                 . . . 
               
               
                   
                   
               
             
          
         
       
     
     The JNDI remote name “BaseRemote” and max-beans-in-cache of 300 that are defined in the class BaseAccount are inherited by the subclass AccountEJB. The subclass can optionally override these values. For example, the value of max-beans-in-cache is overridden to be 400 instead of 300. 
     In another embodiment, EJB relations can be inherited if a value for the attribute ‘role-name’ is specified. All “role-name” attributes in the Java™ inheritance path can be merged. For example, the following parent class defines a partial relation: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                 /** 
               
               
                   
                  *  @ejbgen:relation 
               
               
                   
                  *   name = Many1–Many2 
               
               
                   
                  *   role-name = Many1HasMany2 
               
               
                   
                  *   multiplicity = many * role-name = Many1HasMany2 
               
               
                   
                  *   target-ejb = Many2EJB 
               
               
                   
                  *   fk-column = many2_fk 
               
               
                   
                  *   joint-table = join_table 
               
               
                   
                  */ 
               
               
                   
                 abstract public class BaseMany1 extends BaseEntityBean { 
               
               
                   
                   
               
             
          
         
       
     
     The following subclass inherits the above relation and completes its definition: 
     
       
         
               
               
             
           
               
                   
                   
               
             
             
               
                   
                  *  @ejbgen:relation 
               
               
                   
                  *   role-name = Many1HasMany2 
               
               
                   
                  *   cmr-field = many2 
               
               
                   
                  * 
               
               
                   
                  */ 
               
               
                   
                 abstract public class Many1EJB extends BaseMany1 { 
               
               
                   
                   
               
             
          
         
       
     
     It will be apparent to those skilled in the art that the process of generating EJB source files from an annotated description of an EJB can be performed in reverse. All of the files or classes needed to deploy an EJB can be reduced into a single annotated description of the EJB which can, in accordance to one embodiment, be used in turn to reproduce the EJB source files. Annotations can be generated automatically based information contained in the class definitions, deployment descriptors and relationships between classes. 
       FIG. 2  is a block diagram in accordance to one embodiment of the invention. A plurality of input files  7  containing EJB classes and deployment information is processed by analyzer  8 . Input files  7  can include one or more EJB class definitions. In one embodiment, input files  7  can reside in a single file, such as a Java™ Archive File (“JAR”). In another embodiment, input files  7  can reside in a computer memory. In yet a further embodiment, input files  7  can be transmitted via a computer network (not shown) to analyzer  8 . Analyzer  8  employs parser  10  to extract information related to class structure, class relationships and deployment from input files  7 . Analyzer  8  may perform preprocessing of input files  7  before making use of parser  10 . In one embodiment, parser  10  can exploit the doclet application programming interface available in Javadoc. In one embodiment, parser  10  can process all input files  7  at once. In another embodiment, parser  10  can be employed repeatedly by analyzer  8  to incrementally process input files  7 . During or after parsing, analyzer  8  builds an EJB database  11  containing all of the extracted information pertaining to each EJB represented by input files  7 . The EJB database  11  information is then examined to identify which annotation(s) from annotation library  5  adequately describe the EJB&#39;s. The these annotations (not shown) along with the EJB database  11  information are provided to code generator  9 . Code generator  9  then emits annotated Java™ code  1  to describe the EJB class(s) in input files  7 . 
     The foregoing description of the preferred embodiments of the present invention has been provided for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise forms disclosed. Many modifications and variations will be apparent to the practitioner skilled in the art. Embodiments were chosen and described in order to best describe the principles of the invention and its practical application, thereby enabling others skilled in the art to understand the invention, the various embodiments and with various modifications that are suited to the particular use contemplated. It is intended that the scope of the invention be defined by the following claims and their equivalents.