CN100504773C - Loose coupling access method by employing server public service - Google Patents
Loose coupling access method by employing server public service Download PDFInfo
- Publication number
- CN100504773C CN100504773C CNB2007101106747A CN200710110674A CN100504773C CN 100504773 C CN100504773 C CN 100504773C CN B2007101106747 A CNB2007101106747 A CN B2007101106747A CN 200710110674 A CN200710110674 A CN 200710110674A CN 100504773 C CN100504773 C CN 100504773C
- Authority
- CN
- China
- Prior art keywords
- public service
- realization
- function
- application server
- service
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Expired - Fee Related
Links
Images
Landscapes
- Stored Programmes (AREA)
Abstract
The utility model relates to a loose couple access methods for public service of application server, which is used to define the contract between the EJB container and the public service, analyze the matching degree between the API for different implementations based on the same public service and the contract, and loosely coupled and integrated the into the public service into the application server using the adapter pattern and the reflection mechanism. The utility model can build a flexible and extensible framework of the integrated service for the developer of the application server, by introducing the adapter pattern and the reflection mechanism into framework, the EJB container can be separated from the implementation detail of the public service, enabling independent upgrade and the replacement of the system elements in the application server, thereby building a pluggable system architecture for the application server.
Description
Technical field:
The invention belongs to software technology field, is a kind of at the integrated loose coupling method of public service in the application server.
Background technology:
Nowadays each major company, mechanism are nowadays all at the enterprise-level information platform of building separately, and these platforms pass through the new functional module of exploitation, or integrate the application system of original stand-alone development, so that unified complete framework to be provided.J2EE (Java2platform Enterprise Edition, see SUN Microsystems, Java 2 PlatformEnterprise Edition Specification, Version1.3,2001) technology is arisen at the historic moment just in this case, the standard (as shown in Figure 1) that it is used by a series of exploitation distributed enterprise levels of definition, simplify the exploitation of enterprise-level application, challenges such as deployment and management, EJB (Enterprise Java Beans) conduct member standard wherein, the developer realizes the EJB member of service logic according to this standard exploitation, utilize these application components then, set up distributed enterprise level application system as playing with building blocks.The J2EE application server is followed the J2EE standard, between operating system and enterprise-level application,, peel off out as characteristics such as affairs, safety, communications with general character such as the affairs that exist in the application of distributed enterprise level, form public service, for application component provides exploitation and running environment.In general, the J2EE application server comprises two type systematic members: a class is public service, provides the NOT-function attribute to application component, as safety, affairs etc.; Another kind of is the member container, comprise Enterprise Java Bean container and Web container, the running environment of application component and required public service are provided, the support of for example life cycle management of member, distribution affairs, the management that database connects etc. can operate in the application server application component (as the EJB member) more efficiently.
Continuous expansion along with the J2EE standard, the complexity of J2EE application server and scale also constantly increase, therefore except some specialized vendors, for most of application server developers, be difficult to set up a comprehensive application server system, just say that also any application server exploitation commercial city can't realize all public services or the container that requires in the J2EE standard.In order to tackle day by day huge application server scale, present most of application server developers select oneself to realize Enterprise Java Bean container and some public service on the one hand, and the public service and the Web container that can integrated third party provide are provided on the other hand.Meanwhile, some communities that increase income also begin to provide reliable public service to realize that this just makes, and integrated public service becomes a kind of main flow trend in application server.
Present most of public service is integrated all adopts a kind of tightly coupled mode, Enterprise Java Bean container directly writes in code calling that certain public service realizes, the evolution of container and public service interdepends in application server with regard to making for this, for example after public service realizes offering the call method change of container, invoke code in the container also needs correspondingly to make amendment, and has brought very high maintenance cost thus; Can not make the application server user according to enterprise's demands of applications on the other hand, the dynamically realization of configuration or customization public service, for example for the affairs service, the application server user who has wishes that it has faster issued transaction speed and need not too much issued transaction additional function, the user who has is then just the opposite, simultaneously because Enterprise Java Bean container has been bound a certain definite public service realization in code rigidly, and the user can not directly revise the Enterprise Java Bean container code in the application server, so this just makes application server to realize according to the integrated different affairs service of user's different demands.Be not difficult to find out thus,, promptly in the code of application server, do not bind some public services rigidly and realize, become the problem demanding prompt solution in application server aspect as the integrated public service of the mode of how a kind of loose coupling.
Summary of the invention:
The loose coupling access method that the purpose of this invention is to provide public service in a kind of application server, instruct the application server developer set up one flexibly, extendible service integrated framework, pass through to introduce mode adapter and reflex mechanism in the framework, concrete public service is realized separating with Enterprise Java Bean container, thereby make the upgrading of the component of a system in the application server (public service and container) and replace separately, finally set up one and can plug architecture for application server.
Loose coupling access method by employing server public service of the present invention, its step comprises:
1. set the public service function of the required realization of this server member container according to application server;
2. with required each function one method representation that provides of above-mentioned public service;
3. said method is encapsulated in the interface, this interface is realized the unified interface of the required realization of application-oriented server as the different public services of same class public service;
4. realize to provide the public service function of the required realization of above-mentioned member container as a public service, then selected one or more methods that above-mentioned corresponding public service function can be provided; Realize providing the function of the required realization of above-mentioned member container as this public service, then establishment can realize the method for this function;
5. said method is encapsulated or makes up, for this public service realizes providing the connection adaptor that realizes above-mentioned unified interface;
6. the member container of application server reads the public service information file by the public service factory class in the time of running, and the connection adaptor of utilizing reflex mechanism to realize by public service is called corresponding public service and realized, inserts this public service.
The public service function of the required realization of above-mentioned member container is provided providing as a public service, the connection adaptor that this public service realizes is a configuration file, corresponding interface or method name configuration file is realized the interface in the unified interface or method name corresponding to this public service in.
The function of the required realization of above-mentioned member container is provided providing as a public service, then the connection adaptor of this public service realization is a realization class, each method in the realization class is corresponding to a function of the required realization of member container, and this realization class keeps the example that this public service realizes.
Create the public service information file in application server, this document specifies public service to be called to realize.
Public service for the public service function that the required realization of above-mentioned member container can be provided realizes that described public service information file is the configuration file of connection adaptor.
Public service for the public service function that the required realization of above-mentioned member container can not be provided realizes that the connection adaptor that described public service information file writes appointment realizes the class class name.
The inventive method totally comprises three aspects::
(1) the definition Enterprise Java Bean container is with the contract between the public service.
(2) matching degree between the different API that realize of analysis contract and same public service.
(3) utilize mode adapter and reflex mechanism with the public service loose coupling be integrated in the application server.
One, the definition Enterprise Java Bean container is with the contract between the public service
Contract is meant and needs one or more methods that public service provides or interface by Enterprise Java Bean container (method also can be called function in other programming language, interface is the classical notion in the computing machine object-oriented, here can be understood as the polymerization of method), these interfaces and method representation the member container function that requires public service externally to provide, like this when container needs some function of public service, in the container code, can directly call these methods and interface, realize calling public service.Therefore a contract that accurately defines is the integrated important foundation of public service in the application server.And relevant Enterprise Java Bean container is quite fuzzy with the definition that concerns between the public service in the present J2EE standard, that is to say the functional interface that generally public service is externally provided, promptly service provider interface (SPI) does not have clear and definite definition or is dispersed in a plurality of standards.Therefore in order to define Enterprise Java Bean container with contract clearly between the public service, this step was made of following two stages:
Phase one: collection demand.Collecting demand stage, the application server developer need investigate about the realization situation of this service to serving relevant standard and mainstream applications server.Determine the member container, the service function and the expanded function of the public service that must realize as Enterprise Java Bean container, these functions are called public service by container and are realized obtaining.
Subordinate phase: definition contract.In the definition contract stage, the application server developer should at first classify to the J2EE standard of existing relevant this service, selects service provider interface (SPI) relevant in the J2EE standard then according to demand.To the demand that can't satisfy in the standard, definition specific method or interface.
Two, the matching degree between the different API that realize of analysis contract and same public service
Be similar to that a plurality of different production firms provide same commodity in the life, have a plurality of different service providers, provide different public services to realize for a certain public service.Generally, most of public services realize all can providing the application programming interface (ApplicationProgrammingInterface is called for short API) of its function of description, the extraneous function that provides by this interface interchange public service.Because the different API that provided that realize of same public service have nothing in common with each other, Enterprise Java Bean container is realized in order to call certain public service at present, usually be chosen in the invoke code that writes direct in the code, brought a very big drawback to be exactly like this, the calling interface of realizing when this public service changes or when application server wishes to change a certain public service realization, the invoke code of Enterprise Java Bean container part also needs corresponding change, and this has just brought very big maintenance cost to application server.Therefore application server need be realized with the difference of the integrated same public service of a kind of uniform way, that is to say, for Enterprise Java Bean container, it no longer realizes certain concrete public service to be hard-coded in the code, but all public services are realized and can both call with a kind of uniform way, be converted into Same Way or interface name such as distinct methods name or interface name during different public services are realized, concrete mode will be introduced in the 3rd step in detail.And the Enterprise Java Bean container that defines in the first step is with the contract between the public service, in fact is exactly do not considering that Enterprise Java Bean container is wished the API that public service provides under the prerequisite that concrete public service realizes, in other words to the functional requirement of this public service.For a certain method or the interface in the contract, different public services realizes having different application programming interface (API), for example, defined method a in the contract, presentation function A, public service realizes the method for Method Of Accomplishment A function in b, and public service realizes might being c in two, does not have the method for presentation function A in also might public service realization three.The application server developer just needs to analyze the contract that defines in the first step and different public services and realizes matching degree between API for this reason, so that select suitable public service integrated framework in the 3rd step.The present invention relates to two other matching degrees of level:
Mate fully, interface that defines in the contract and method, the API that public service realizes has correlation method or interface correspondence, is that interface, method name are inconsistent.
The part coupling, the method that defines in the contract does not have correspondence in public service realizes, need to carry out extra process before or after the API that Enterprise Java Bean container is realized providing in the service of calling, be the corresponding method of this method that defines in this API establishment and the contract, different required extra process according to the public service that inserts also may be different, the for example conversion of types of variables, perhaps this method need be called public service and realize that serial of methods realizes among the API, for example finish method A function in the contract, need at first call the method m1 among the public service realization API, then the last call method m3 of call method m2.; Again or public service realize among the API then needing to write corresponding method not to the support of this method.
Need the application server developer be integrated into the method for disperseing in the contract that (implication of the words please be explained in the interface for the part match condition?), contract finally only contains the unified interface definition.In addition, in the matching degree checkout procedure, inadequately rationally the time, after can making amendment to contract, carry out the matching degree inspection more again, repeat this process when the application server developer finds contract definition, until finish contract customization and matching degree check (.
Three, utilize connection adaptor pattern and reflex mechanism with the public service loose coupling be integrated into application service
Connection adaptor pattern (Adapter Pattern) is the Design Mode of classics in the object-oriented, core concept is similar to the transformer in the life, a kind of voltage transformation is become another kind of voltage, and the connection adaptor pattern can change into an interface the desired interface of client, to eliminate the problem that interface does not match and brings.The connection adaptor pattern is formed (as shown in Figure 2) by client (Client), target interface (target), adapter (adapter) with by adaptive side (adaptee) four parts.
The reflex mechanism of Java allows operating java applet that self is checked, ignorant attribute of institute and function when being used for obtaining compiling, thus make program more flexible.The following procedure section has illustrated how java applet obtains attribute, method and the constructed fuction of load classes, and call method or set property.
// acquisition class example
Class?class＝Class.forName(“Class?Name”)；
// obtain the method stated in the class by the Java reflex mechanism
Method?method＝class.getMethod(“Method?Name”，new?Class[]{})；
// instantiation such
Objectobject＝cl.newInstance()；
// call method method on the example object by reflex mechanism
Method.invoke (object, new Object mouth { });
Known from the introduction of front, though the difference of same public service the API that is provided is provided has nothing in common with each other, but Enterprise Java Bean container is wished with uniform way---the unified interface mode that defines in the contract, visit different public services and realize, thereby the evolution that member container and public service are realized is separate.For this reason, the present invention introduces the connection adaptor pattern, and difference is realized that the API that has nothing in common with each other that provides changes into the form that the member container is wished, also is defined unified interface form in the contract.The pragmatic existing API of member container, contract kimonos corresponds respectively to client in the connection adaptor pattern, target interface and by adaptive side.
The form of connection adaptor determines according to the matching degree in second step: for mating fully, owing to only need the statement contract with the mapping relations between the public service realization API, realize interface B among the API such as a certain interface A in the contract corresponding to public service, therefore adapter is embodied as a configuration file (as shown in Figure 3), be called for short file adapter, every row of file is described a corresponding relation respectively, and concrete form is: corresponding interface or method name during interface in the contract or method name=a certain public service realizes; For the part coupling, owing to there is not this direct corresponding relation, such as before certain method that public service realizes providing is provided, Enterprise Java Bean container need carry out some extra processing, so just need write a method in addition, at first finish extra process, make that public service realizes having the method corresponding with contract, call the method that the public service realization provides again.Therefore adapter is embodied as a java class (as shown in Figure 4), is called for short the class adapter, and each method in the class is corresponding to a function that defines in the contract, specifically finish in each method public service is realized unmatched adaptive.Adapter class keeps the example that a public service realizes, so that call the function that the public service realization provides.Difference for same public service realizes that the application server developer need be respectively the distinct interface that defines in its realization contract.
In addition, consider the dirigibility that service is integrated, the present invention introduces reflex mechanism (as shown in Figure 5).In application server, create the public service information file and be used to describe which the concrete public service realization of concrete loading.In file adapter, the information that comprises in the configuration file is enough to satisfy service and loads required information, so the public service information file is equal to configuration file.And in the class adapter, extra file state of needs writes direct in the file and selected service realizes corresponding adapter class class name.Enterprise Java Bean container reads the public service information file by the public service factory class in the time of running, utilizes reflex mechanism to load corresponding public service and realizes.The benefit of doing like this is exactly no longer concrete public service to be realized being hard-coded in the Enterprise Java Bean container, but write in the public service information file, therefore need change public service when application server realizes, when perhaps public service realizes that the functional interface that provides changes, only need the corresponding public service information file of change, no longer need to change the code in the Enterprise Java Bean container, because this will bring very high maintenance cost for the application server developer, change application server internal code is unpractical especially for the application server user.
So far, the present invention has finished the foundation of this public service loose coupling integrated framework.Because Enterprise Java Bean container is finished calling by contract of public service in the application server, the service that do not rely on fully realizes, the evolution that so just makes Enterprise Java Bean container and public service realize is separate, and when needs change public service realizes, only need revise the public service information file simply.
The access process of public service is as follows: when application server starts, at first read the concrete public service that needs to load and realize title from the public service information file, utilize the Java reflex mechanism to load the realization class that concrete public service realizes.When Enterprise Java Bean container needs the public service function, it uses method or the interface that defines in the contract, public service is called, connection adaptor among the present invention further will be called form with the unification of contract regulation, be converted into concrete public service and realize corresponding form, realization is really called a certain concrete public service, finishes the function of Enterprise Java Bean container requirement.
Description of drawings:
Fig. 1 is the J2EE system assumption diagram.
Fig. 2 is mode adapter figure.
Fig. 3 is the mode adapter of document form.
Fig. 4 is the mode adapter of class form.
Fig. 5 is this method reflex mechanism structure.
Fig. 6 is affairs service integrated framework.
Embodiment:
This section provides the integrated realization of an affairs service.
Affairs are meant the unit operation of a plurality of distributed components to shared data, guarantee atomicity, consistance, isolation and the persistence of shared data.Java affairs services (JTS, a kind of public service) and Java transactional applications DLL (dynamic link library) (JTA, a kind of API) are two basic standards among the Java EE5, have stipulated that wherein the affairs public service realizes providing the minimal set of interface.JTS has specified Java transaction model core component---the realization of Java task manager (functional module that defines in the public service), it provides service and the management function that needs, to support the division of affairs, the management of transaction resource, synchronously and the transmission of transaction context, be the part that each affairs public service all must realization.JTA has stipulated that task manager and other distribution affairs participate in the high-level interface between member.
Generally, application server is all bound a task manager, and the enterprise-level application development person can only dispose some simple transaction parameter, for example affairs time-out time.And this can't satisfy affairs user's demand, and they wish and can select different affairs to realize according to different application scenarioss usually, and for example the processing speed of task manager is a primary factor sometimes, but not strong functions is then just the opposite sometimes.Use the present invention for this reason, build the public service integrated framework of a loose coupling for the affairs service, according to the present invention, the specific implementation step is as follows:
1. the definition Enterprise Java Bean container is with contract between the affairs service.By analyzing Java EE5 and JTS standard and investigating the realization that affairs are served on the present generic server, required affairs service function demand mainly contains following 3 points in the application server: (1) control affairs boundary demarcation.(2) related global transaction and the transaction resource task of finishing.(3) support transactional synchronization.
Further analyze and determine that Enterprise Java Bean container comprises with the method in the contract between the affairs service: the realization of (1) task manager (TransactionManager).(2) realization of transactions classes (Transaction).(3) obtain the method for affairs major key (Xid) in the transactions classes.(4) obtain the method for transactions classes in the task manager by the affairs major key.
2. analyze the matching degree between the different API that realize of contract and affairs service.Because (1), (2) two parts in the contract come from the standard interface that defines in the JTA standard, so the service of any affairs realizes all can providing the realization support of response.And for (3) in the contract, (4) two parts, process is investigated as can be known, and at present nearly all affairs service realizes also all providing support, so matching degree is for mating fully.
3. utilize mode adapter and reflex mechanism that affairs are integrated in the application server with serving loose coupling.In view of second step, matching degree between the different API of realization with the affairs service of contract is for mating fully, therefore adopt file adapter, implementation framework as shown in Figure 6, Enterprise Java Bean container calls affairs and serves factory (it is the module of finishing affairs service-creation function that these affairs are served factory, be embodied as a class TxFactory) in static method, this static method directly reads the affairs services realization information of putting down in writing in the configuration file.Indicate in the configuration file that the affairs service realizes the information of body, realizes pairing configuration file for these affairs of ObjectWebJOTM below:
When the user will replace affairs services when realizing body, only need content with equal sign the right change the API that respective transaction realizes into and get final product.In TxFactory,, load concrete affairs service and realize by the reflex mechanism among the following manner use Java.
Claims (6)
1. loose coupling access method by employing server public service, its step comprises:
1) sets the public service function of the required realization of this server member container according to application server;
2) with required each function one method representation that provides of above-mentioned public service;
3) said method is encapsulated in the interface, this interface is realized the unified interface of the required realization of application-oriented server as the different public services of same class public service;
4) realize to provide the public service function of the required realization of above-mentioned member container as a public service, then selected one or more methods that above-mentioned corresponding public service function can be provided; Realize providing the function of the required realization of above-mentioned member container as this public service, then establishment can realize the method for this function;
5) said method is encapsulated or makes up, for this public service realizes providing the connection adaptor that realizes above-mentioned unified interface;
6) the member container of application server reads the public service information file by the public service factory class in the time of running, and the connection adaptor of utilizing reflex mechanism to realize by public service is called corresponding public service and realized, inserts this public service.
2. loose coupling access method by employing server public service as claimed in claim 1, it is characterized in that to provide the public service function of the required realization of above-mentioned member container as public service realization, the connection adaptor that this public service realizes is a configuration file, corresponding interface or method name configuration file is realized the interface in the unified interface or method name corresponding to this public service in.
3. loose coupling access method by employing server public service as claimed in claim 1, it is characterized in that to provide the function of the required realization of above-mentioned member container as public service realization, then the connection adaptor of this public service realization is a realization class, each method in the realization class is corresponding to a function of the required realization of member container, and this realization class keeps the example that this public service realizes.
4. loose coupling access method by employing server public service as claimed in claim 1 is characterized in that creating described public service information file in application server, this document specifies public service to be called to realize.
5. loose coupling access method by employing server public service as claimed in claim 4, it is characterized in that realizing that for the public service of the public service function that the required realization of above-mentioned member container can be provided described public service information file is the configuration file of connection adaptor.
6. loose coupling access method by employing server public service as claimed in claim 4, it is characterized in that realizing that for the public service of the public service function that the required realization of above-mentioned member container can not be provided the connection adaptor that described public service information file writes appointment realizes the class class name.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CNB2007101106747A CN100504773C (en) | 2007-06-08 | 2007-06-08 | Loose coupling access method by employing server public service |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CNB2007101106747A CN100504773C (en) | 2007-06-08 | 2007-06-08 | Loose coupling access method by employing server public service |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN101126979A CN101126979A (en) | 2008-02-20 |
| CN100504773C true CN100504773C (en) | 2009-06-24 |
Family
ID=39095029
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CNB2007101106747A Expired - Fee Related CN100504773C (en) | 2007-06-08 | 2007-06-08 | Loose coupling access method by employing server public service |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN100504773C (en) |
Families Citing this family (7)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN102811199B (en) * | 2011-05-30 | 2015-10-28 | 深圳市金蝶友商电子商务服务有限公司 | A kind of method for interface adaptation, Apparatus and system |
| CN103150168A (en) * | 2013-03-27 | 2013-06-12 | 汉柏科技有限公司 | Method for mutually calling modules in .net framework |
| CN105022626B (en) * | 2015-05-29 | 2018-08-03 | 克拉玛依红有软件有限责任公司 | The system and method that dynamic interaction is carried out using reflex mechanism based on model-driven |
| CN106610839B (en) * | 2015-10-21 | 2020-10-30 | 阿里巴巴集团控股有限公司 | Method for issuing upgrade package, lightweight upgrade method, device and system |
| CN107766344B (en) * | 2016-08-15 | 2021-07-30 | 阿里巴巴集团控股有限公司 | Template rendering method and device and browser |
| JP2019096244A (en) * | 2017-11-28 | 2019-06-20 | 京セラドキュメントソリューションズ株式会社 | Information processing system and information processing method |
| CN110188071B (en) * | 2019-04-19 | 2021-11-02 | 北京奇艺世纪科技有限公司 | Data processing method and device, electronic equipment and computer readable medium |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1570812A (en) * | 2003-07-18 | 2005-01-26 | 北京航空航天大学 | Implement method of assembly adapter |
| CN1967485A (en) * | 2006-06-20 | 2007-05-23 | 华为技术有限公司 | Method and system for realizing J2EE application |
-
2007
- 2007-06-08 CN CNB2007101106747A patent/CN100504773C/en not_active Expired - Fee Related
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1570812A (en) * | 2003-07-18 | 2005-01-26 | 北京航空航天大学 | Implement method of assembly adapter |
| CN1967485A (en) * | 2006-06-20 | 2007-05-23 | 华为技术有限公司 | Method and system for realizing J2EE application |
Non-Patent Citations (4)
| Title |
|---|
| EJB应用服务器的研究与设计. 付利勇.沈阳工业大学硕士学位论文. 2004 |
| EJB应用服务器的研究与设计. 付利勇.沈阳工业大学硕士学位论文. 2004 * |
| 基于拦截器实现EJB容器方法调用. 闫波，战守义.北京理工大学学报，第24卷第2期. 2004 |
| 基于拦截器实现EJB容器方法调用. 闫波，战守义.北京理工大学学报，第24卷第2期. 2004 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN101126979A (en) | 2008-02-20 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10324690B2 (en) | Automated enterprise software development | |
| CN100504773C (en) | Loose coupling access method by employing server public service | |
| US8312414B2 (en) | Method and system for executing a data integration application using executable units that operate independently of each other | |
| CA2446809C (en) | General and reusable components for defining net-centric application program architectures | |
| US8458660B1 (en) | Semantic-based, service-oriented system and method of developing, programming and managing software modules and software solutions | |
| US7810102B2 (en) | Service adaptation of the enterprise services framework | |
| US20090100405A1 (en) | Synchronizing an abstract model and source code | |
| US20030200533A1 (en) | Method and apparatus for creating software objects | |
| US7055134B2 (en) | Service provider integration framework in object oriented programming environment | |
| US20120060141A1 (en) | Integrated environment for software design and implementation | |
| Vitharana et al. | Research issues in testing business components | |
| Gomaa et al. | Feature driven dynamic customization of software product lines | |
| Dittrich | Extraction of user behavior profiles for software modernization | |
| Papadopoulos | Automatic code generation: A practical approach | |
| KR101061326B1 (en) | Application Server Development System | |
| Kim et al. | MS2Web: Applying MDA and SOA to Web Services | |
| Zarras | Applying model-driven architecture to achieve distribution transparencies | |
| CN100462914C (en) | Constructive method for use in member initialization process | |
| Sang | COMP610E Software Development of E-Business Applications | |
| David et al. | Introduction to the Object Modelling System version 3. | |
| Loecher | A common conceptual basis for analyzing transaction service configurations | |
| Sun et al. | Extendable and interchangeable architecture description of distributed systems using UML and XML | |
| Hall | DataBinding |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| C14 | Grant of patent or utility model | ||
| GR01 | Patent grant | ||
| C17 | Cessation of patent right | ||
| CF01 | Termination of patent right due to non-payment of annual fee |
Granted publication date: 20090624 Termination date: 20130608 |