JP5237030B2 - Software development support program, software development support apparatus, and software development support method - Google Patents

Description

  The present invention relates to a software development support program, a software development support apparatus, and a software development support method, and more particularly to a software development support program, a software development support apparatus, and a software development support method that support the development of software that accesses a database.

  Currently, computer systems are becoming larger and more complex, and there is a demand for lower system development costs and shorter delivery times. In this regard, in order to improve the efficiency of system development, a method of improving the reusability by converting frequently appearing software functions into components (components) and providing the components as a system development platform can be considered. Examples of techniques useful for enhancing reusability include techniques such as dependency injection (DI) and aspect oriented programming (AOP).

  In DI, dependency relationships between components can be injected at the time of execution in a program execution environment called a container. Thereby, the independence of each component can be improved more. In AOP, functions used across the system such as exception processing and log output are extracted as components, and the program execution environment can add these functions to the system afterwards.

In this way, by using DI or AOP technology, the dependency between components can be kept sparse, and the reusability of components can be improved. Such highly reusable components are separated from the business logic unique to the system, and many of them can be formed into a certain pattern. Therefore, from the viewpoint of improving the efficiency of system development, a method for supporting the creation of components has been considered. For example, there is a technique for automatically generating a data access object (DAO: Data Access Object) for accessing a table registered in a database from information about the database (see, for example, Patent Documents 1 and 2).
JP 2006-268124 A JP 2006-268126 A

  Here, in order to make components with improved reusability available to other programs, these components are registered in the program execution environment. However, the task of preparing a system development infrastructure in a state where components can be actually operated has a problem that it requires a great amount of man-hours. For example, in a system with a large number of database tables, the man-hour for registering DAO becomes a big problem. In addition, man-hours for incorporating cross-system processing such as log output processing and exception processing are also a problem.

  The present invention has been made in view of the above, and an object thereof is to provide a software development support program, a software development support apparatus, and a software development support method that support efficient system development.

In order to solve the above problems, a software development support program is provided. A computer that executes the software development support program includes data access component generation means, application generation means, common component storage means, and registration information generation means. The data access component generation unit is configured to obtain a data access component that is a program component that receives an access request and performs a predetermined operation on the corresponding table for each of the plurality of tables based on the information of the plurality of tables stored in the database. Generate. The application generation unit generates an application program that makes an access request to the data access component. The common component storage means stores a common component that defines a common process among a plurality of data access components to be executed in accordance with a predetermined operation. The registration information generation means includes information for registering the data access component generated by the data access component generation means in the program execution environment and a process defined by the common component stored in the common component storage means. Registration information including information for executing on the program execution environment during the operation and information for registering the application program generated by the application generation means in the program execution environment in association with the data access component Is generated.

  In order to solve the above problems, a software development support apparatus having the same function as a computer that executes the software development support program is provided. Also provided is a software development support method that performs the same processing as the processing realized by the software development support program.

  According to the software development support program, software development support apparatus, and software development support method, efficient system development can be supported.

Hereinafter, the present embodiment will be described in detail with reference to the drawings.
FIG. 1 is a diagram showing an outline of the present embodiment. The computer 1 automatically generates a program part (for example, DAO class) for accessing a table registered in the database 2. The computer 1 includes a data access component generation unit 1a, a common component storage unit 1b, and a registration information generation unit 1c.

  The data access component generation unit 1a is a program component that receives an access request for each table and performs a predetermined operation on the corresponding table based on information in the tables 2a, 2b, and 2c stored in the database 2. Data access components 4a, 4b and 4c are generated. Here, the data access component generation unit 1a connects to the database 2 based on predetermined connection information with respect to the database 2, for example, and acquires table information of the tables 2a, 2b, and 2c registered in the database 2. Then, data access components 4a, 4b and 4c are generated from the acquired table information.

  The common component storage unit 1b stores a common component 4d that defines a common process among the data access components 4a, 4b, and 4c to be executed in accordance with a predetermined operation. The common component 4d includes components necessary for execution of the data access components 4a, 4b, and 4c, such as connection processing to the database 2, exception processing, and log output processing.

  The registration information generating unit 1c includes information for registering the data access components 4a, 4b, and 4c generated by the data access component generating unit 1a in the program execution environment 4 and the common component 4d stored in the common component storage unit 1b. Registration information 3 including information for allowing the defined processing to be executed on the program execution environment 4 at the time of a predetermined operation by the data access components 4a, 4b, and 4c is generated.

  The program execution environment 4 executes the data access components 4a, 4b, 4c and the common component 4d. The program execution environment 4 associates the data access components 4a, 4b, and 4c with the common component 4d based on the registration information 3. The program execution environment 4 calls and executes the common component 4d before and after the execution of the data access components 4a, 4b, and 4c based on the registration information 3, for example.

  According to such a computer 1, data access components 4a, 4b, and 4c for the tables 2a, 2b, and 2c are generated based on the information of the tables 2a, 2b, and 2c stored in the database 2. When the program execution environment 4 executes the data access components 4a, 4b, 4c, the data access components 4a, 4b, 4c are set to execute the common component 4d stored in the common component storage unit 1b. Registration information 3 is generated for registration in.

  For this reason, the man-hour required for coding for associating the data access components 4a, 4b, and 4c with the common component 4d and creation of the registration information 3 is reduced. Then, the data access components 4a, 4b, 4c can be immediately operated together with the common component 4d.

As a result, the developer can focus on the development of business logic unique to the system, and can efficiently perform the system development work.
The data access component generation unit 1a may further generate a program that uses the data access components 4a, 4b, and 4c (for example, a simple program for sampling). In this way, it becomes possible to immediately start the operation confirmation regarding the access to the tables 2a, 2b, 2c via the data access components 4a, 4b, 4c by this program.

  Incidentally, the computer 1 is particularly useful when performing system development using an object-oriented language. In the following, this embodiment will be described in more detail by taking system development using Java (registered trademark) as an example.

[First Embodiment]
FIG. 2 is a diagram illustrating a hardware configuration of the computer according to the first embodiment. The computer 100 automatically generates a program serving as a system base in system development. The computer 100 is entirely controlled by a CPU (Central Processing Unit) 101. A random access memory (RAM) 102, an HDD interface 103, a graphic processing device 104, an input interface 105, and a communication interface 106 are connected to the CPU 101 via a bus 107.

  The RAM 102 temporarily stores at least part of an OS (Operating System) program and application programs to be executed by the CPU 101. The RAM 102 stores various data necessary for processing by the CPU 101.

  The HDD 103 is a disk device for storing data. The HDD 103 stores an OS program and application programs. The HDD 103 stores various data necessary for processing by the CPU 101.

  A monitor 11 is connected to the graphic processing device 104. The graphic processing device 104 displays an image on the screen of the monitor 11 in accordance with a command from the CPU 101. A keyboard 12 and a mouse 13 are connected to the input interface 105. The input interface 105 transmits a signal transmitted from the keyboard 12 or the mouse 13 to the CPU 101 via the bus 107.

The communication interface 106 is connected to the network 10. The communication interface 106 communicates with a DB (DataBase) server 200 via the network 10.
The computer 100 accesses the database 210 via the communication interface 106 and the DB server 200.

  FIG. 3 is a first block diagram illustrating functions of the computer according to the first embodiment. The computer 100 includes an ORM (Object Relational Mapping) file generation unit 110, an ORM file storage unit 115, an ORM class generation unit 120, an ORM class storage unit 125, a template storage unit 130, a DAO class generation unit 140, a DAO class storage unit 145, It includes a query description file generation unit 150, a query description file storage unit 155, a common component storage unit 160, a context file generation unit 170, a context file storage unit 175, a sample class generation unit 180, and a sample class storage unit 185.

  The ORM file generation unit 110 executes the ORM based on the DB connection information 20 and the table configuration of the database 210 acquired via the DB server 200. Here, ORM indicates that data of “object” handled in an object-oriented language is associated with a record of “relational database (RDB)”. The information indicating the table configuration of the database 210 includes, for example, DDL (Data Definition Language). By performing ORM, it is possible to reduce the coding work required to perform table access to the database 210 from the class that executes the business service. The ORM file generation unit 110 stores the ORM file generated by the ORM in the ORM file storage unit 115. For example, Middlegen can be used as an application for realizing the function of the ORM file generation unit 110.

The ORM file storage unit 115 stores the ORM file generated by the ORM file generation unit 110.
The ORM class generation unit 120 generates an ORM class based on the ORM file stored in the ORM file storage unit 115. The ORM class is a class for encapsulating data included in the ORM file. The ORM class generation unit 120 stores the generated ORM class in the ORM class storage unit 125. As an application for realizing the function of the ORM file generation unit 110, for example, Hibernate can be used.

The ORM class storage unit 125 stores the ORM class generated by the ORM class generation unit 120.
The template storage unit 130 stores a template (model) of a program automatically generated by the DAO class generation unit 140, the query description file generation unit 150, the context file generation unit 170, and the sample class generation unit 180. The DAO class generation unit 140, the query description file generation unit 150, the context file generation unit 170, and the sample class generation unit 180 automatically generate a program using a template engine or the like. For example, Velocity can be used as the template engine.

  The DAO class generation unit 140 generates a DAO class based on the ORM class stored in the ORM class storage unit 125 and the DAO class template stored in the template storage unit 130. The DAO class is a class for accessing the database 210 via the ORM class in response to a business service request. The DAO class generation unit 140 stores the generated DAO class in the DAO class storage unit 145.

  The DAO class storage unit 145 stores the DAO class generated by the DAO class generation unit 140. The DAO class storage unit 145 stores general-purpose DAO classes. The general-purpose DAO class is a class that provides basic operations for the tables of the database 210 to the DAO class generated by the DAO class generation unit 140. Here, the basic operation on the table is, for example, an operation such as CRUD (Create / Read / Update / Delete). The general DAO class will be described in detail with reference to FIG.

  The query description file generation unit 150 generates a query description file based on the DAO class stored in the DAO class storage unit 145 and the query description template stored in the template storage unit 130. In the query description file, an operation other than the basic operation of the table provided by the general-purpose DAO class, for example, a complicated table processing query required for business processing can be set. The query description file generation unit 150 stores the generated query description file in the query description file storage unit 155.

The query description file storage unit 155 stores the query description file generated by the query description file generation unit 150.
The common part storage unit 160 stores DAO classes generated by the DAO class generation unit 140 and components commonly used in processing of services generated by the sample class generation unit 180. Such a component is, for example, a component that performs exception processing, log output, and the like. Further, a component for managing a connection with the database 210 and a component for managing a transaction such as commit or rollback for the database 210 are included.

  The context file generation unit 170 registers the DAO class stored in the DAO class storage unit 145 and the common component stored in the common component storage unit 160 based on the context template stored in the template storage unit 130. Is generated. The context file is a file in which the association of the common component class, the DAO class, and a sample class to be described later is defined. The context file generation unit 170 stores the generated context file in the context file storage unit 175.

The context file storage unit 175 stores the context file generated by the context file generation unit 170.
The sample class generation unit 180 generates a sample class that is a sample service that uses a DAO class based on the DAO class stored in the DAO class storage unit 145 and the sample class template stored in the template storage unit 130. The sample class generation unit 180 stores the generated sample class in the sample class storage unit 185.

The sample class storage unit 185 stores the sample class generated by the sample class generation unit 180.
As described above, the computer 100 sequentially generates a definition file (ORM file or query description file), a DAO class, and a sample class necessary for accessing the table of the database 210.

Next, a configuration for executing a service based on the generated class will be described.
FIG. 4 is a second block diagram illustrating functions of the computer according to the first embodiment. The computer 100 includes an arrangement unit 190 and an execution unit 195 in addition to the configuration shown in FIG.

  The placement unit 190 stores the ORM class stored in the ORM class storage unit 125, the DAO class stored in the DAO class storage unit 145, the general DAO class, and the sample class based on the context file stored in the context file storage unit 175. The sample class stored in the unit 185 is arranged on the memory. At this time, the arrangement unit 190 reads definition files (ORM file and query description file) necessary for each class. Furthermore, the common component classes stored in the common component storage unit 160 are arranged on the memory.

The execution unit 195 executes the service by associating each class arranged on the memory based on the context file. The execution unit 195 is a so-called container.
The functions of the placement unit 190 and the execution unit 195 can be realized using, for example, a framework called Spring Framework that incorporates a DI or AOP technique. In the following, an example is assumed on the assumption that the functions of the placement unit 190 and the execution unit 195 are realized using Spring Framework.

  FIG. 5 is a diagram illustrating an example of DB connection information. In the DB connection information 20, a driver class 21, DB connection destination information 22, a DB connection user name 23, a password 24, and mapping target tables 25 and 26 are set.

The driver class 21 is set with information (for example, “com.mysql.jdbc.Driver”) that specifies the JDBC driver class used for accessing the database 210.
In the DB connection destination information 22, connection destination information (for example, “jdbc: mysql: // database / testdb”) indicating the DB server 200 is set.

In the DB connection user name 23, information (for example, “jim”) for specifying a user name used for accessing the database 210 is set.
In the password 24, information (for example, “0123”) indicating a password corresponding to the DB connection user name 23 is set.

In the mapping target tables 25 and 26, a table name (for example, “Grouptbl” or “Ikisakitbl”) to be executed by the ORM file generating unit 110 is set.
Based on the DB connection information 20, the ORM file generation unit 110 accesses the database 210 and executes ORM.

  The DB connection information 20 may include information other than the information described above. For example, information indicating the schema information of the database or the SQL dialect (Dialect) of the connection destination database may be included.

  FIG. 6 is a diagram illustrating an example of a table structure stored in the database. The table 211 shows the structure of the “Grouptbl” table stored in the database 210. The table 211 shows items indicating column names, data types, constraints, and primary keys. Information arranged in the horizontal direction of each item is associated with each other to form attribute information for one column.

  In the item indicating the column name, information indicating the column name is set. In the item indicating the data type, information indicating the type of data to be registered is set. Information for controlling data to be registered is set in the item indicating restriction. In the item indicating the primary key, information indicating whether or not the corresponding column is the primary key of the table 211 is set.

  In the table 211, for example, information that the column name is “GRCD”, the data type is “varchar (8)”, the constraint is “NOT NULL”, and the primary key is “◯” is set. This indicates that the column name “GRCD” can register data of variable length character type 8 digits and not “NULL”, and “GRCD” is a primary key. Note that “-(hyphen)” is set in the item of the primary key of “GRNAME” or “USERID” which is a column that is not the primary key.

Such a table structure is described by a predetermined DDL file, for example.
FIG. 7 is a diagram illustrating an example of a file stored in the template storage unit. The template storage unit 130 stores a DAO class template file 131, a query description template file 132, a context template file 133, and a sample class template file 134.

The DAO class template file 131 is a DAO class template generated by the DAO class generation unit 140.
The query description template file 132 is a template of a query description file generated by the query description file generation unit 150.

The context template file 133 is a model of a context file generated by the context file generation unit 170.
The sample class template file 134 is a service class template generated by the sample class generation unit 180.

These template files are stored in the template storage unit 130 in advance.
FIG. 8 is a diagram illustrating an example of a DAO class template file. The DAO class template file 131 is a template of the DAO interface. The DAO class template file 131 includes codes 131a, 131b, and 131c. The DAO class generation unit 140 replaces the portion indicated by the character strings “{0}, {1}, {2}, {3}” included in the codes 131a, 131b, and 131c with an appropriate character string, thereby enabling the DAO class. A class interface can be created.

The code 131a specifies a package to which the DAO class belongs. The DAO class generation unit 140 replaces the character string “{2}” with the package name of the DAO class.
The code 131b specifies the ORM class to be imported. The DAO class generation unit 140 replaces the character string “{3}” with the package name of the ORM class, and replaces the character string “{0}” with the ORM class name corresponding to the DAO class.

  The code 131c defines the DAO class interface. The DAO class generation unit 140 replaces the character string “0” with the ORM class name corresponding to the DAO class, and replaces the character string “{1}” with the primary key class name of the corresponding ORM class. The name of the DAO class is, for example, a name in which the character string “Dao” is added after the ORM class name.

  Note that the DAO class generated by the DAO class generation unit 140 may be an interface only and does not need to be implemented. The method defined in the generic DAO class (“GenericDao” class) can be used in common by a plurality of DAO classes.

  Here, in “GenaricDao”, the data type of the ORM class and the primary key type of the table corresponding to the corresponding ORM class can be set. As a result, it is possible to prevent inconsistency between the data input to each DAO class and the primary key type at the DAO class generation stage. That is, the DAO class type safety can be ensured.

In the case of a DAO class that handles a dynamically changing query, it can be dealt with by creating an implementation class individually with the corresponding DAO class.
FIG. 9 is a diagram illustrating an example of a template file for query description. The query description file generation unit 150 generates a query description file based on the contents described in the query description template file 132. The developer can describe, in the tag 132a, a complicated table operation query that is not defined in the general-purpose DAO class in the generated query description file according to the business logic.

  FIG. 10 is a first diagram illustrating an example of a context template file. In the context template file 133, a plurality of beans (Beans) used to execute the service are defined. In the context template file 133, tags 133a, 133b, and 133c are provided.

  In the tag 133a, a “dataSourceMain” bean is defined. “DataSourceMain” manages connection information for the database 210. For example, information such as the driver class 21 of the DB connection information 20, the DB connection destination information 22, the DB connection user name 23, and the password 24 is set in “dataSourceMain”.

  In the tag 133b, a “sessionFactory” bean is defined. “SessionFactory” refers to “dataSourceMain” and performs an operation on each table of the database 210. In “sessionFactory”, an ORM file (for example, specified by a file name of “(ORM class name) .hbm.xml”) or a query description file (for example, “(ORM class name)” is definition information necessary for processing. ) .Hql.xml ”is specified).

  In the tag 133c, a “transactionManager” bean is defined. “TransactionManager” refers to “sessionFactory” and manages transactions with the database 210. Here, transaction management refers to control of commit and rollback for the database 210 and the like.

  FIG. 11 is a second diagram illustrating an example of a context template file. The context template file 133 is further provided with tags 133d, 133e, and 133f.

  In the tag 133d, a “txAttribute” bean is defined. “TxAttribute” manages the transaction attribute for the method. In “txAttribute”, for example, an attribute for controlling a transaction is defined such that a new transaction is started or read-only for a method starting with a character string such as “read” or “get”.

  In the tag 133e, a “txInterceptor” bean is defined. “TxInterceptor” is a bean for calling a transaction management function when another class is executed. “TxInterceptor” refers to “transactionManager” of the tag 133c and “txAttribute” of the tag 133d.

  The tag 133f defines an “applicationLoggingInterceptor” bean. “ApplicationLoggingInterceptor” is a bean for calling a log output function when another class is executed.

  FIG. 12 is a third diagram illustrating an example of a context template file. The context template file 133 is further provided with tags 133g, 133h, and 133i.

  In the tag 133g, a “serviceThrowsAdvice” bean is defined. “ServiceThrowsAdvice” is a bean for calling a function that performs exception handling in a service class when the service class is executed.

  In the tag 133h, a “daoThrowsAdvice” bean is defined. “DaoThrowsAdvice” is a bean for calling a function for performing exception handling in the DAO class when the DAO class is executed.

  In the tag 133i, an “autoProxyCreator” bean is defined. “AutoProxyCreator” is a bean for calling each bean defined by the tags 133e, 133f, and 133g when the service class is executed.

  FIG. 13 is a fourth diagram illustrating an example of a context template file. The context template file 133 is further provided with tags 133j, 133k, 133l, and 133m. The tags 133j, 133k, 133l, and 133m define a bean that is commonly called when the DAO class is executed.

  In the tag 133j, a “finderIntroductionAdvisor” bean is defined. “FinderIntroductionAdvisor” is a bean for calling a query description file corresponding to a corresponding DAO class when a general-purpose DAO class cannot be used among the methods of each DAO class.

  An “abstractDaoTarget” bean is defined in the tag 133k. “AbstractDaoTarget” is a bean for making an instance of the general-purpose DAO class stored in the common component storage unit 160 reusable in each DAO class.

An “abstractDao” bean is defined in the tag 133l. “AbstractDao” is a bean for adding the function of “finderIntroductionAdvisor” to each DAO class.
In the tag 133m, “daoAutoProxyCreator” is defined. “DaoAutoProxyCreator” is a bean for calling each bean defined by the tags 133f and 133h when each DAO class is executed.

FIG. 14 is a fifth diagram illustrating an example of a context template file. The context template file 133 is further provided with tags 133n and 133o.
In the tag 133n, a DAO class bean is defined for each DAO class. An appropriate character string is replaced and set in “bean id” indicating the bean identification information. In the property “proxyInterfaces”, an appropriate character string designating the DAO class stored in the DAO class storage unit 145 is replaced and set. Also, an ORM class corresponding to the corresponding DAO class is set in the constructor of “abstractDaoTarget”.

  The tag 133n defines a DAO class bean that does not need to be implemented. For example, when a variable query is handled according to a processing request, the tag 133n needs to be implemented. In this case, it is possible to directly define a DAO class bean that needs to be implemented in the context template file 133.

  In the tag 133o, a “sampleService” bean is defined. “SampleService” is a bean of a service class. In “sampleService”, a property tag for setting a DAO class is provided, and a name for each DAO class is set.

  FIG. 15 is a diagram illustrating an example of a sample class template file. In the sample class template file 134, codes 134a, 134b, and 134c are provided.

  The code 134a specifies the DAO class or ORM class to be imported. The sample class generation unit 180 sets an appropriate character string indicating all DAO classes and ORM classes in the code 134a.

  The code 134b defines an object variable for each DAO class. The sample class generation unit 180 sets an appropriate character string indicating all DAO classes and their object names in the code 134b.

  The code 134c defines a method related to the defined object variable (for example, a method for setting a reference to an instance of the DAO class by DI). The sample class generation unit 180 defines methods for all object variables.

  FIG. 16 is a diagram illustrating an example of a file stored in the common component storage unit. The common component storage unit 160 stores component files that can be reused in each class. The common component storage unit 160 stores a DB connection management class 161, a DB transaction management class 162, a log output class 163, and an exception processing class 164.

  The DB connection management class 161 is a database connection class. The DB connection management class 161 includes, for example, classes such as a “dataSourceMain” bean of the tag 133 a and a “sessionFactory” bean of the tag 133 b of the context template file 133.

  The DB transaction management class 162 is a class for managing transactions such as commit and rollback for the database. The DB transaction management class 162 includes classes such as a “transactionManager” bean of the tag 133c, a “txAttribute” bean of the tag 133d, and a “txInterceptor” bean of the tag 133e in the context template file 133.

  The log output class 163 is a class for outputting a log. The log output class 163 includes, for example, the “applicationLoggingInterceptor” bean class of the tag 133f of the context template file 133.

  The exception handling class 164 is a class for exception handling at the time of execution. The exception processing class 164 includes, for example, classes such as a “serviceThrowsAdvice” bean of the tag 133g of the context template file 133 and a “daoThrowsAdvice” bean of the tag 133h.

  FIG. 17 is a diagram illustrating an example of a general-purpose DAO class. The general-purpose DAO class 145a is stored in advance in the DAO class storage unit 145. The general-purpose DAO class 145a defines main functions commonly used by a plurality of DAO classes. In the general-purpose DAO class 145a, for example, CRUD processing, exclusive-owner key search, and exclusive-release waiting main key search are defined.

Here, the exclusive primary key search is a function for performing primary key search by locking data.
Similarly, the exclusive non-primary key search is a function for locking the data and performing the primary key search. However, in the exclusive primary key search, if the corresponding data is already locked by another process, exception processing is performed without waiting for the lock to be released.

  As described above, when each processing is performed on the database 210 in each DAO class, the processing is executed using the function defined in the general-purpose DAO class 145a, thereby making the implementation unnecessary in each DAO class. Can do.

Next, details of processing executed in the computer 100 having the above-described configuration will be described.
FIG. 18 is a flowchart illustrating the procedure of the program generation process according to the first embodiment. In the following, the process illustrated in FIG. 18 will be described in order of step number.

  [Step S1] The ORM file generation unit 110 executes the ORM based on the DB connection information and the table structure of the database 210 to generate an ORM file. The ORM file generation unit 110 stores the generated ORM file in the ORM file storage unit 115.

  [Step S2] The ORM class generation unit 120 generates an ORM class for storing a value in each table of the database 210 or reading a value from each table based on the ORM file stored in the ORM file storage unit 115. . The ORM class generation unit 120 stores the generated ORM class in the ORM class storage unit 125.

  [Step S <b> 3] The DAO class generation unit 140 generates a DAO class based on the DAO class template file 131 stored in the template storage unit 130 and the ORM class name stored in the ORM class storage unit 125. The DAO class generation unit 140 stores the generated DAO class in the DAO class storage unit 145.

  [Step S <b> 4] The query description file generation unit 150 generates a query description file based on the query description template file 132 stored in the template storage unit 130 and the DAO class name stored in the DAO class storage unit 145. To do. The query description file generation unit 150 stores the generated query description file in the query description file storage unit 155.

  [Step S <b> 5] The context file generation unit 170 generates a context file based on the context template file 133 stored in the template storage unit 130 and the DAO class name stored in the DAO class storage unit 145. The context file generation unit 170 stores the generated context file storage unit 175.

  [Step S6] The sample class generation unit 180 is a sample application that is a sample application based on the sample class template file 134 stored in the template storage unit 130 and the name of the DAO class stored in the DAO class storage unit 145. Generate a class. The sample class generation unit 180 stores the generated sample class in the sample class storage unit 185.

  [Step S7] The placement unit 190 places each class such as a DAO class, a sample class, and a common component on the memory based on the context file stored in the context file storage unit 175. The execution unit 195 associates the classes arranged by the arrangement unit 190 based on the context file, and executes the sample class.

  In this way, DAO classes and sample classes are automatically generated. At this time, functions such as connection to the database 210, transaction management, log output, and exception handling necessary for execution are prepared in advance, and are configured to be automatically called when each class is executed. This eliminates the need for the developer to perform coding for calling these functions for each DAO class. Thereby, even when there are a large number of tables handled by the application, the man-hours for incorporating these functions can be reduced. In addition, the number of steps for creating a context file for registering each generated class in the execution environment can be reduced.

Next, the processing procedure in each step of the above processing procedure will be described in more detail.
FIG. 19 is a flowchart illustrating a procedure of ORM file generation processing according to the first embodiment. In the following, the process illustrated in FIG. 19 will be described in order of step number. The following process describes the process of step S1 in detail.

[Step S11] The ORM file generation unit 110 connects to the database 210 based on the information set in the DB connection information 20.
[Step S12] The ORM file generation unit 110 acquires one table information (for example, DDL) in which the ORM file has not been created from the ORM target table set in the DB connection information 20, and the corresponding table information in the database 210. Refer to

[Step S13] The ORM file generation unit 110 extracts column information included in the referenced table information.
[Step S14] The ORM file generation unit 110 determines whether or not information on all columns included in the referenced table information has been extracted. If all the column information has been extracted, the process proceeds to step S15. If an unextracted column exists, the process proceeds to step S13.

[Step S15] The ORM file generation unit 110 generates an ORM file based on the extracted column information, and outputs the ORM file to the ORM file storage unit 115.
[Step S <b> 16] The ORM file generation unit 110 determines whether ORM files have been generated for all the tables set in the DB connection information 20. If the ORM file has been generated for all the tables, the process is completed. If there is a table for which no ORM file has been generated, the process proceeds to step S12.

  In this way, the columns of each table existing in the database 210 are referred to, and the information of each column is mapped to the ORM file generated for each table. The file format of the ORM file is, for example, the xml format.

  FIG. 20 is a flowchart illustrating a procedure of ORM class generation processing according to the first embodiment. In the following, the process illustrated in FIG. 20 will be described in order of step number. The following process describes the process in step S2 in detail.

[Step S21] The ORM class generation unit 120 acquires one unprocessed ORM file among the ORM files stored in the ORM file storage unit 115.
[Step S22] The ORM class generation unit 120 extracts one unprocessed column from the columns set in the ORM file.

[Step S23] The ORM class generation unit 120 acquires the attribute of the extracted column, and generates attribute information of the corresponding column.
[Step S24] The ORM class generation unit 120 generates a Getter method for acquiring information set in the extracted column.

[Step S25] The ORM class generator 120 generates a Setter method for setting information in the extracted column.
[Step S26] The ORM class generation unit 120 determines whether or not the attribute information, the Getter method, and the Setter method have been generated for all the columns included in the ORM file. If all columns have been processed, the process proceeds to step S27. If there is an unprocessed column, the process proceeds to step S22.

  [Step S <b> 27] The ORM class generation unit 120 outputs the generated column attribute information, the Getter method, and the ORM class in which the Setter method is set to the ORM class storage unit 125.

  [Step S28] The ORM class generation unit 120 determines whether ORM classes have been generated for all ORM files. When the ORM class is generated for all ORM files, the process is completed. If there is an ORM file for which no ORM class has been generated, the process proceeds to step S21.

In this way, an ORM class for each ORM file is generated.
FIG. 21 is a flowchart illustrating a procedure of DAO class generation processing according to the first embodiment. In the following, the process illustrated in FIG. 21 will be described in order of step number. Note that the following processing describes the processing in step S3 in detail.

[Step S31] The DAO class generation unit 140 acquires an ORM class file list stored in the ORM class storage unit 125.
[Step S32] The DAO class generation unit 140 acquires one unprocessed ORM class from the acquired file list.

[Step S33] The DAO class generation unit 140 refers to the ORM class source code.
[Step S34] The DAO class generation unit 140 extracts the name of the ORM class from the referenced source code. Specifically, for example, for each line included in the referenced source code, a class name defined following the character string “public class” at the beginning of the line is extracted.

  [Step S35] The DAO class generation unit 140 extracts a primary key class name included in the corresponding ORM class. Specifically, for example, for each line included in the referenced source code, the class name defined following the character string “private” at the beginning of the line that appears first is extracted.

[Step S <b> 36] The DAO class generation unit 140 reads the DAO class template file 131 stored in the template storage unit 130.
[Step S37] The DAO class generation unit 140 sets the acquired information in the DAO class template file 131. Specifically, the character string “{0}” in the DAO class template file 131 is replaced with the ORM class name acquired in step S34. Similarly, the character string “{1}” is replaced with the primary key class name acquired in step S35. Also, the character string “{2}” is replaced with the DAO package name, and the character string “{3}” is replaced with the ORM package name.

[Step S38] The DAO class generation unit 140 outputs the DAO class generated by replacing the DAO class template file 131 to the DAO class storage unit 145.
[Step S39] The DAO class generation unit 140 determines whether or not a DAO class has been generated for all ORM classes included in the file list. If the DAO class has been generated for all ORM classes, the process is completed. If there is an ORM class for which no DAO class has been generated, the process proceeds to step S32.

In this way, a DAO class for each ORM class is generated.
FIG. 22 is a flowchart illustrating a procedure of query description file generation processing according to the first embodiment. In the following, the process illustrated in FIG. 22 will be described in order of step number. The following process describes the process of step S4 in detail.

[Step S41] The query description file generation unit 150 acquires a DAO class file list stored in the DAO class storage unit 125.
[Step S42] The query description file generation unit 150 acquires one unprocessed DAO class from the acquired file list.

[Step S43] The query description file generation unit 150 acquires the ORM class name from the file name of the DAO class.
[Step S44] The query description file generation unit 150 reads the query description template file 132 stored in the template storage unit 130.

  [Step S45] The query description file generation unit 150 generates a query description file that duplicates the content described in the query description template file 132 and associates it with the ORM class name, and outputs the query description file to the query description file storage unit 155. To do.

  [Step S46] The query description file generation unit 150 determines whether query description files have been generated for all DAO classes existing in the file list. When query description files are generated for all DAO classes, the process is completed. If there is a DAO class for which no query description file has been generated, the process proceeds to step S42.

In this way, a query description file is generated for each DAO class.
FIG. 23 is a flowchart illustrating a procedure of context file generation processing according to the first embodiment. In the following, the process illustrated in FIG. 23 will be described in order of step number. The following process describes the process in step S5 in detail.

[Step S <b> 51] The context file generation unit 170 acquires a DAO class file list stored in the DAO class storage unit 125.
[Step S52] The context file generation unit 170 acquires one unacquired DAO class from the acquired file list.

[Step S53] The context file generation unit 170 acquires the ORM class name and the DAO class name from the file name of the DAO class.
[Step S54] The context file generation unit 170 determines whether or not the ORM class name and the DAO class name have been acquired for all DAO classes included in the acquired file list. If already acquired, the process proceeds to step S55. If there is an unacquired DAO class, the process proceeds to step S52.

[Step S <b> 55] The context file generation unit 170 reads the context template file 133 stored in the template storage unit 130.
[Step S56] The context file generation unit 170 sets a DB connection parameter in “dataSourceMain” which is a bean defined by the tag 133a.

  [Step S57] The context file generation unit 170 sets an ORM file and a query description file corresponding to the ORM class name acquired in Steps S52 to S54 in “sessionFactory” which is a bean defined by the tag 133b.

  [Step S58] The context file generation unit 170 sets each ORM class name and each DAO class name acquired in Steps S52 to S54 to the DAO class bean defined by the tag 133n.

  [Step S59] The context file generation unit 170 sets the DAO class name acquired in steps S52 to S54 to the “sampleService” tag that is a bean of the sample service class defined by the tag 133o.

  [Step S60] The context file generation unit 170 outputs the context file generated based on the context template file 133 to the context file storage unit 175, and the processing is completed.

  In this manner, the ORM class and the DAO class are automatically set in the connection information of the context template file 133 to the database 210 and the bean definition information of the sample class. Also, in the context template file 133, a common component such as a transaction management class and a log output class are set in advance.

  FIG. 24 is a flowchart illustrating a procedure of sample application generation processing according to the first embodiment. In the following, the process illustrated in FIG. 24 will be described in order of step number. In addition, the following process explains the process of said step S6 in detail.

[Step S61] The sample class generation unit 180 obtains a DAO class file list stored in the DAO class storage unit 125.
[Step S62] The sample class generation unit 180 acquires one unacquired DAO class from the acquired file list.

[Step S63] The sample class generation unit 180 obtains the ORM class name and the DAO class name from the file name of the DAO class.
[Step S64] The sample class generation unit 180 determines whether or not the ORM class name and the DAO class name have been acquired for all the DAO classes included in the acquired file list. If already acquired, the process proceeds to step S65. If an unacquired DAO class exists, the process proceeds to step S62.

[Step S65] The sample class generating unit 180 reads the sample class template file 134 stored in the template storage unit 130.
[Step S66] The sample class generation unit 180 adds the methods of the ORM class and DAO class acquired in steps S62 to S64 to the sample class template file 134 to generate a sample class that is a sample application.

[Step S67] The sample class generation unit 180 outputs the generated sample class to the sample class storage unit 185, and the processing is completed.
In this way, the ORM class name and DAO class name are automatically set in the sample class template file 134, and the sample class is generated. Since the generated sample class can operate without any contradiction with respect to all DAO class definitions included in the context file, the operation check of the access process for the database 210 can be performed immediately using the sample class. Also, when creating an actual business service, it is possible to copy and use the sample class generated without contradiction with the context file, so that coding work can be performed efficiently.

  FIG. 25 is a flowchart illustrating a procedure of sample application execution processing according to the first embodiment. The sample application associates the DAO class and the sample class using the DAO class by the execution unit 195 so that a series of processing of the sample class can be executed. In the following, the process illustrated in FIG. 25 will be described in order of step number. Note that the following processing describes the processing in step S7 in detail.

[Step S71] The placement unit 190 reads the context file stored in the context file storage unit 175.
[Step S72] The placement unit 190 stores the ORM class stored in the ORM class storage unit 125, the DAO class stored in the DAO class storage unit 145, and the sample class storage unit 185 based on the contents of the context file. Place the sample class in memory. The execution unit 195 associates each class or common component class placed on the memory by the placement unit 190, and the sample application is in an operating state.

  [Step S <b> 73] The execution unit 195 determines whether the sample class has accepted a processing request for the database 210. If accepted, the process proceeds to step S74. If not received, the process proceeds to step S78.

  [Step S74] The execution unit 195 generates an SQL statement according to the content of the processing request. At this time, for simple CRUD processing for the table, an SQL statement is generated based on the general-purpose DAO class 145a. For complex queries not supported by the general DAO class, an SQL statement is generated based on a query description file for the corresponding DAO class.

[Step S75] The execution unit 195 connects to the table to be processed in the database 210 via the DAO class and the ORM class.
[Step S76] The execution unit 195 executes processing for the table based on the SQL statement generated in step S74.

  [Step S77] When the sample class receives a response of the processing result via the ORM class and the DAO class, the execution unit 195 recognizes that a series of processing based on the processing request has been completed, and the processing proceeds to step S73. .

  [Step S78] The execution unit 195 determines whether or not a sample application termination request has been received. If accepted, the process is complete. If not received, the process proceeds to step S73.

  In this way, a sample application is executed based on each generated class. Functions necessary for the processing of each class are called by the execution unit 195 and added when the classes are executed. In addition, an SQL statement corresponding to the processing request is generated, and processing for each table in the database 210 is executed.

  FIG. 26 is a diagram illustrating an example of a list of files generated from a template. This list shows a list of files generated by the computer 100. The generated file shown in the list is an example when “Grouptbl” and “Ikisakitbl” are specified in the mapping target table of the DB connection information 20.

The ORM file generation unit 110 generates “Grouptbl.hbm.xml” and “Ikisakitbl.hbm.xml” as the ORM files.
The ORM class generation unit 120 generates “Grouptbl.java” and “Ikisakitbl.java” as the ORM class.

  The DAO class generation unit 140 generates DAO classes “GrouptblDAO.java” and “IkisakitblDAO.java” based on “TemplateDAO.java” which is the template file 131 for DAO class.

  The query description file generation unit 150 generates query description files “Grouptbl.hql.xml” and “Ikisakitbl.hql.xml” based on “template.hql.xml.vm” which is the template file 132 for query description. .

  The context file generation unit 170 generates a context file “sample-application-context.xml” based on “template-application-context.vm” which is the context template file 133.

  The sample class generation unit 180 generates a sample class “SampleServiceImpl.java” based on “SampleServiceImpl.java.vm” which is the sample class template file 134.

  FIG. 27 is a diagram illustrating an example of the generated ORM file. The ORM file 115a shows an example of “Grouptbl.hbm.xml”. In the ORM file 115a, column attribute information of each table is set.

  FIG. 28 is a diagram illustrating an example of the generated ORM class. The ORM class 125a shows an example of “Grouptbl.java”. In the ORM class 125a, attribute information of each column set in the ORM file 115a, a Getter method, and a Setter method are defined.

  FIG. 29 is a diagram illustrating an example of the generated DAO class. The DAO class 145a shows an example of “GrouptblDAO.java”. The DAO class 145a is generated by replacing “{0}, {1}, {2}, {3}” included in the codes 131a, 131b, and 131c of the DAO class template file 131 with appropriate character strings. Is.

  FIG. 30 is a diagram illustrating an example of the generated query description file. The query description file 155a shows an example of “Grouptbl.hql.xml”. The contents described in the query description template file 132 are set in the query description file 155a. In the query description file 155a, a query corresponding to a business process other than a process that can be executed by the general-purpose DAO class 145a can be described.

  FIG. 31 is a first diagram illustrating an example of the generated context file. The context file 175a shows an example of “sample-application-context.xml”. The context file 175a is generated based on the context template file 133. In the context file 175a, only the locations corresponding to the tags 133a and 133b into which settings are inserted according to the mapping target table set in the DB connection information 20 in the context template file 133 are shown.

  FIG. 32 is a second diagram illustrating an example of the generated context file. In the context file 175a, DAO class information is further set at locations corresponding to the tags 133n and 133o of the context template file 133.

  FIG. 33 is a diagram illustrating an example of the generated sample class. The sample class 185a shows an example of “SampleServiceImpl.java”. The sample class generation unit 180 generates the sample class 185a by replacing the codes 134a, 134b, and 134c of the sample class template file 134 with the ORM class name and the DAO class name.

  In this way, each class is automatically generated only by selecting database connection information and tables. The sample class 185a can operate without contradiction with respect to all DAO class definitions included in the context file 175a. For this reason, it is possible to immediately confirm the operation of the processing on the database 210 using the sample class 185a. Also, when creating an actual business service, the sample class 185a is copied and used, so that there is no contradiction to the DAO class setting in the context file 175a, so that coding work can be performed efficiently. it can.

  In the following, the relevance at the time of execution of the generated class file will be described in detail. In the following description, a case where the generated class file is operated on an application server as a Web application that provides a business service will be described as an example.

  FIG. 34 is a diagram showing a configuration of a Web system. This Web system includes a terminal device 50, a DB server 200, a database 210, and an application server 300.

  The terminal device 50 is an information processing device used by a user. The user can input a processing request to the application server 300 by operating a browser output on the screen of the terminal device 50.

The DB server 200 is a server that operates the database 210 in response to a request from the application server 300.
The application server 300 generates an SQL statement in response to the processing request received from the terminal device 50 and requests the DB server 200 to operate the database 210. The application server 300 has three layers (layers) according to processing roles. Specifically, the Web layer 310, the service layer 320, and the data access layer 330.

The Web layer 310 receives a processing request for a business service via the browser of the terminal device 50. The web layer 310 includes a web layer component 311.
The Web layer component 311 is an interface to the business service terminal device 50. The Web layer component 311 receives a processing request for the business service from the terminal device 50 and outputs it to the service class 321. In addition, the Web layer component 311 receives the result of the processing request for the business service from the service class 321 and responds to the browser of the terminal device 50.

The service layer 320 is a layer for executing business logic. The service layer 320 has a service class 321.
The service class 321 executes business processing based on the business processing request from the Web layer component 311. The service class 321 requests the DAO class 331 to perform a table operation corresponding to the business process request. Also, the service class 321 receives data encapsulated by the DAO class 331 by the ORM class 332 and executes business processing. Furthermore, the service class 321 encapsulates the processed data by the ORM class 332, outputs the data to the DAO class 331, and requests a table operation of the database 210.

The service class 321 corresponds to, for example, the sample class 185a described above.
The data access layer 330 is a layer for accessing the database 210. The data access layer 330 has a DAO class 331 and an ORM class 332.

  The DAO class 331 generates an SQL statement for operating a table on the database 210 based on a table operation request from the service class 321 and transmits it to the DB server 200. For example, when the DAO class 331 acquires the data acquisition result from the DB server 200, the DAO class 331 encapsulates the data acquired by the ORM class 332 and outputs it to the service class 321.

The DAO class 331 corresponds to the above-described DAO class 145a, for example. The ORM class 332 corresponds to the ORM class 125a, for example.
Here, the service class 321, the DAO class 331, and the ORM class 332 are executed on the container 350.

  The container 350 is an execution environment for each class that incorporates DI and AOP techniques. The container 350 associates each class. The container 350 calls components that can be commonly used in each class from the common part storage unit 340 as needed, adds the function before and after each class is called, and references other classes from each class. It is possible to do. For example, when executing the service class 321, the container 350 executes components such as connection processing with the DB server 200, log output processing, and exception processing, and adds these functions to the service class 321. Similarly, when executing the DAO class 331, components such as log output processing and exception processing are executed, and these functions are added to the DAO class 331. The container 350 corresponds to the execution unit 195.

  FIG. 35 is a diagram illustrating association between objects by containers. In the container 350, each object is associated based on the context information 354. For example, on the container 350, objects 351, 352, and 353 are generated based on the context information 354. Based on the context information 354, for example, reference or call from the object 351 to the objects 352 and 353 is performed. The context information 354 corresponds to the context file 175a.

In this manner, the association among the service class 321, the DAO class 331, the ORM class 332, and the common component class is performed.
As described above, according to the computer 100, the ORM class and the DAO class corresponding to each table are automatically generated based on the information of the plurality of tables stored in the database 210. In addition, a context file that defines the association between each generated class and a common component that is commonly used in each class is automatically generated. For this reason, the coding for associating each class with the common component can be reduced, and the number of man-hours required until execution is possible after the DAO class is generated is reduced. As a result, the developer can focus on the development of business logic unique to the system, and can efficiently perform the system development work.

  Further, the computer 100 automatically generates a sample class that uses the generated DAO class, and sets the sample class in the context file. By using this sample class, the developer can immediately start the operation confirmation of the process involving the table access of the database 210 via the generated DAO class.

[Second Embodiment]
Next, a second embodiment will be described in detail with reference to the drawings. Differences from the first embodiment will be mainly described, and description of similar matters will be omitted.

  In the first embodiment, an example in which the database 210 has already been constructed has been shown. On the other hand, in the second embodiment, a case where a new table is constructed in the database 210 will be described.

The hardware configuration of the computer according to the second embodiment is the same as the hardware configuration of the computer 100 according to the first embodiment shown in FIG.
FIG. 36 is a block diagram illustrating functions of a computer according to the second embodiment. The computer 100a includes an ORM file acquisition unit 110a, an ORM file storage unit 115, a DDL file generation unit 116, an ORM class generation unit 120, an ORM class storage unit 125, a template storage unit 130, a DAO class generation unit 140, and a DAO class storage unit 145. A query description file generation unit 150, a query description file storage unit 155, a common component storage unit 160, a context file generation unit 170, a context file storage unit 175, a sample class generation unit 180, and a sample class storage unit 185. Note that the configuration (including the placement unit 190 and the execution unit 195) other than the ORM file acquisition unit 110a and the DDL file generation unit 116 is the same as the configuration of the computer 100 of the first embodiment, and thus description thereof is omitted. .

  The ORM file acquisition unit 110a acquires the ORM file 20a. The ORM file 20a is created in advance by the developer for each new table stored in the database 210. The ORM file acquisition unit 110 a stores the acquired ORM file 20 a in the ORM file storage unit 115.

  The DDL file generation unit 116 acquires the ORM file stored in the OR file storage unit 115. Then, the DDL file generation unit 116 transmits the generated DDL file to the DB server 200. The DB server 200 constructs a new table in the database 210 based on the acquired DDL file. For example, Hibernate can be used as an application for realizing the function of the DDL file generation unit 116.

Next, details of processing executed in the computer 100a having the above configuration will be described.
FIG. 37 is a flowchart illustrating a procedure of a program generation process according to the second embodiment. In the following, the process illustrated in FIG. 37 will be described in order of step number.

[Step S110] The ORM file acquisition unit 110a acquires the ORM file 20a, and stores the acquired ORM file 20a in the ORM file storage unit 115.
[Step S120] The DDL file generation unit 116 generates a DDL file for constructing the database 210 based on the ORM file 20a stored in the ORM file storage unit 115. The DDL file generation unit 116 outputs the generated DDL file to the DB server 200. The DB server 200 constructs the database 210 based on this DDL file.

  [Step S130] Based on the ORM file 20a stored in the ORM file storage unit 115, the ORM class generation unit 120 stores an value in each table of the database 210 or generates an ORM class for reading the value from each table. To do. The ORM class generation unit 120 stores the generated ORM class in the ORM class storage unit 125.

  [Step S140] The DAO class generation unit 140 generates a DAO class based on the DAO class template file 131 stored in the template storage unit 130 and the ORM class name stored in the ORM class storage unit 125. The DAO class generation unit 140 stores the generated DAO class in the DAO class storage unit 145.

  [Step S150] The query description file generation unit 150 generates a query description file based on the query description template file 132 stored in the template storage unit 130 and the DAO class name stored in the DAO class storage unit 145. To do. The query description file generation unit 150 stores the generated query description file in the query description file storage unit 155.

  [Step S <b> 160] The context file generation unit 170 generates a context file based on the context template file 133 stored in the template storage unit 130 and the DAO class name stored in the DAO class storage unit 145. The context file generation unit 170 stores the generated context file storage unit 175.

  [Step S170] The sample class generation unit 180 generates a sample service class based on the sample class template file 134 stored in the template storage unit 130 and the DAO class name stored in the DAO class storage unit 145. To do. The sample class generation unit 180 stores the generated service class in the sample class storage unit 185.

  [Step S180] The arrangement unit 190 arranges each class such as a DAO class, a service class, and a common component on the memory based on the context file stored in the context file storage unit 175. Then, the execution unit 195 associates the classes arranged by the arrangement unit 190 based on the context file, and executes a sample service.

  In this way, a DAO class, a sample service class, and the like are automatically generated together with a DDL file for constructing a table in the database 210. Note that the process in step S120 may be performed asynchronously with the processes in steps S130 to S170.

  Next, the process of step S120 will be described in more detail. Note that details of the processes in steps S130 to S180 are the same as the details of the processes in steps S2 to S7 shown in FIG.

  FIG. 38 is a flowchart illustrating a procedure of DDL file generation processing according to the second embodiment. In the following, the process illustrated in FIG. 38 will be described in order of step number. The following process describes the process of step S120 in detail.

[Step S <b> 111] The DDL file generation unit 116 reads the ORM file that has not been created yet and is stored in the ORM file storage unit 115.
[Step S112] The DDL file generation unit 116 extracts an unextracted column from the columns included in the referenced ORM file, and acquires attribute information of the column.

  [Step S113] The DDL file generation unit 116 determines whether information on all columns included in the referenced table has been extracted. If all the column information has been extracted, the process proceeds to step S114. If unextracted column information exists, the process proceeds to step S112.

[Step S114] The DDL file generation unit 116 generates a DDL file based on the extracted column information, and transmits the DDL file to the DB server 200.
[Step S115] The DDL file generation unit 116 determines whether or not DDL files have been generated for all ORM files stored in the ORM file storage unit 115. If DDL files have been generated for all ORM files, the process is completed. If there is an ORM file for which a DDL file has not been generated, the process proceeds to step S111.

  In this way, the columns of the table defined in the ORM file are referred to, and the information of each column is mapped to the DDL file for constructing the corresponding table.

  FIG. 39 is a diagram illustrating an example of the generated DDL file. The DDL file 116a shows an example of “grouptbl.ddl” which is the DDL of the “Grouptbl” table shown in FIG. The DB server 200 constructs a “Grouptbl” table in the database 210 based on the DDL file 116a.

  As described above, the DAO class, the sample service class, and the like are automatically generated together with the DDL file for constructing the database 210. Thereby, the effect similar to the effect shown in 1st Embodiment can be acquired. Furthermore, even when the database 210 and the target table are not constructed, it is possible to generate a DAO class and a sample service class that access the database 210 together with the construction of the database 210. For this reason, the developer can perform operations on the tables in the database 210 immediately after constructing the tables in the database 210. Then, other applications can be easily created based on the sample service class, and the development efficiency can be improved.

  The software development support program, the software development support apparatus, and the software development support method of the present invention have been described based on the illustrated embodiments. However, the present invention is not limited to these, and the configuration of each unit has similar functions. Any configuration can be substituted. Moreover, other arbitrary structures and processes may be added. Further, any two or more configurations (features) of the above-described embodiments may be combined.

  The above processing functions can be realized by a computer. In that case, a program describing the processing contents of the functions that the computer should have is provided. By executing the program on a computer, the above processing functions are realized on the computer.

  The program describing the processing contents can be recorded on a computer-readable recording medium. Examples of the computer-readable recording medium include a magnetic recording device, an optical disk, a magneto-optical recording medium, and a semiconductor memory. Examples of the magnetic recording device include an HDD, a flexible disk (FD), and a magnetic tape (MT). Optical disks include DVD (Digital Versatile Disc), DVD-RAM, CD-ROM (Compact Disc-Read Only Memory), CD-R (Recordable) / RW (ReWritable), and the like. Magneto-optical recording media include MO (Magneto-Optical disk).

  When the program is distributed, for example, a portable recording medium such as a DVD or CD-ROM in which the program is recorded is sold. It is also possible to store the program in a server computer and transfer the program from the server computer to another computer via a network.

  The computer that executes the program stores, for example, the program recorded on the portable recording medium or the program transferred from the server computer in its own storage device. Then, the computer reads the program from its own storage device and executes processing according to the program. The computer can also read the program directly from the portable recording medium and execute processing according to the program. In addition, each time the program is transferred from the server computer, the computer can sequentially execute processing according to the received program.

It is a figure which shows the outline | summary of this Embodiment. It is a figure which shows the hardware constitutions of the computer of 1st Embodiment. FIG. 3 is a first block diagram illustrating functions of a computer according to the first embodiment. It is a 2nd block diagram which shows the function of the computer of 1st Embodiment. It is a figure which shows the example of DB connection information. It is a figure which shows the example of the table structure stored in a database. It is a figure which shows the example of the file stored in a template memory | storage part. It is a figure which shows the example of the template file for DAO classes. It is a figure which shows the example of the template file for query description. It is a 1st figure which shows the example of the template file for contexts. It is a 2nd figure which shows the example of the template file for contexts. It is a 3rd figure which shows the example of the template file for contexts. It is a 4th figure which shows the example of the template file for contexts. It is a 5th figure which shows the example of the template file for contexts. It is a figure which shows the example of the template file for sample classes. It is a figure which shows the example of the file stored in a common components memory | storage part. It is a figure which shows the example of a general purpose DAO class. It is a flowchart which shows the procedure of the program production | generation process of 1st Embodiment. It is a flowchart which shows the procedure of the ORM file production | generation process of 1st Embodiment. It is a flowchart which shows the procedure of the ORM class production | generation process of 1st Embodiment. It is a flowchart which shows the procedure of the DAO class production | generation process of 1st Embodiment. It is a flowchart which shows the procedure of the query description file production | generation process of 1st Embodiment. It is a flowchart which shows the procedure of the context file production | generation process of 1st Embodiment. It is a flowchart which shows the procedure of the sample application production | generation process of 1st Embodiment. It is a flowchart which shows the procedure of the sample application execution process of 1st Embodiment. It is a figure which shows the example of the list of the files produced | generated from a template. It is a figure which shows the example of the produced | generated ORM file. It is a figure which shows the example of the produced | generated ORM class. It is a figure which shows the example of the produced | generated DAO class. It is a figure which shows the example of the produced | generated query description file. It is a 1st figure which shows the example of the produced | generated context file. It is a 2nd figure which shows the example of the produced | generated context file. It is a figure which shows the example of the produced | generated sample class. It is a figure which shows the structure of a Web system. It is a figure which shows the correlation between the objects by a container. It is a block diagram which shows the function of the computer of 2nd Embodiment. It is a flowchart which shows the procedure of the program production | generation process of 2nd Embodiment. It is a flowchart which shows the procedure of the DDL file generation process of 2nd Embodiment. It is a figure which shows the example of the produced | generated DDL file.

Explanation of symbols

DESCRIPTION OF SYMBOLS 1 Computer 1a Data access component production | generation means 1b Common component memory | storage means 1c Registration information production | generation means 2 Database 2a, 2b, 2c Table 3 Registration information 4 Program execution environment 4a, 4b, 4c Data access component 4d Common component

Claims (9)

Computer
Data access component generation means for generating a data access component that is a program component that receives an access request and performs a predetermined operation on the table for each of the plurality of tables based on information of the plurality of tables stored in the database ,
Application generation means for generating an application program for making the access request to the data access component;
Common component storage means for storing a common component defining a common process among the plurality of data access components to be executed in accordance with the predetermined operation;
Information for registering the data access component generated by the data access component generation unit in a program execution environment and processing defined by the common component stored in the common component storage unit are performed by the data access component. Information for execution on the program execution environment during the operation of the information, and information for registering the application program generated by the application generation means in the program execution environment in association with the data access component Registration information generating means for generating registration information including:
Software development support program characterized by functioning as The computer further functions as a general-purpose component storage means for storing a general-purpose data access component that defines the predetermined operation by parameterizing a data type,
The data access component generated by the data access component generation unit is a program component that uses the general-purpose data access component stored in the general-purpose component storage unit by designating a data type corresponding to the table as the parameter. is there,
The software development support program according to claim 1. The computer is further caused to function as a query document generation unit that generates a query document for describing an operation other than the predetermined operation defined in the general-purpose data access component.
The registration information generation means includes information for enabling the operation described in the query document generated by the query document generation means to be executed on the program execution environment in the registration information to be generated.
The software development support program according to claim 2. The computer further generates mapping information for each of the plurality of tables to generate mapping information that associates the data type of the data used by the application program making the access request with the data type of the data included in the table. Function as a means,
The registration information generation means includes information for causing the predetermined operation by the data access component to be executed based on the mapping information generated by the mapping information generation means in the registration information to be generated.
The software development support program according to claim 1.   The computer further receives connection information for connecting to the database, and functions as table information acquisition means for acquiring information of the plurality of tables by connecting to the database,
  The data access component generation unit generates the data access component based on the information of the plurality of tables acquired by the table information acquisition unit.
  The software development support program according to claim 1.   Said computer further
  Mapping information acquisition means for acquiring mapping information that associates the data type of the data used by the application program that makes the access request with the data type of the data included in the table for each of the plurality of tables.
  Table definition information generating means for generating table definition information for constructing a table in the database based on the mapping information acquired by the mapping information acquiring means, and outputting the table definition information to the database;
  Function as
  The data access component generation unit generates the data access component based on a plurality of the mapping information acquired by the mapping information acquisition unit.
  The software development support program according to claim 1.   2. The common component stored in the common component storage means defines at least one of management of connection with the database, transaction management, log output, and exception processing. Software development support program. Data access component generation means for generating a data access component that is a program component that receives an access request and performs a predetermined operation on the table for each of the plurality of tables based on information of the plurality of tables stored in the database When,
Application generation means for generating an application program for making the access request to the data access component;
A common component storage unit that stores a common component that defines a common process among the plurality of data access components to be executed in accordance with the predetermined operation;
Information for registering the data access component generated by the data access component generation unit in a program execution environment and processing defined by the common component stored in the common component storage unit are performed by the data access component. Information for execution on the program execution environment during the operation of the information, and information for registering the application program generated by the application generation means in the program execution environment in association with the data access component Registration information generating means for generating registration information including:
A software development support apparatus characterized by comprising: Computer
Based on information of a plurality of tables stored in the database, for each of the plurality of tables, a data access component that is a program component that receives an access request and performs a predetermined operation on the table is generated,
Generating an application program for making the access request to the data access component;
Information for registering the generated data access component in the program execution environment and a process common to the plurality of data access components to be executed in accordance with the predetermined operation and stored in the common component storage means Information for causing the processing defined by the common component to be executed on the program execution environment during the predetermined operation by the data access component, and the generated application program as the data access component Generating registration information including information for registering in the program execution environment in association with
A software development support method characterized by the above.

Images