Enterprise application rapid development platform
table of Contents
TU1 demand UT 2
TU2 target UT 2
TU3 technical solution UT 3
TU4 Technology Line UT 4
TU4.1AOP technology UT 4
TU4.2IOC Technology UT 5
TU4.3 Enterprise Function Components UT 5
TU4.4 Template and Wizard Rule UT 6
TU5 technical difficulties and target UT 6
TU5.1 Technology Difficulties 1UT 6
Tu5.2 Technology Difficulties 2UT 6
Tu5.3 Technology Difficult Points 3UT 6
TU 5.4 expected target UT 6
TU5.5 main innovation UT 7
Tu
1 need
Enterprises build their own information system, there are two ways, one is to buy existing products, but independently develop. Even if you purchase an existing product, you often need to develop secondary development because the purchased product is not developed for its own needs. The development of enterprise application systems is always a very complex process. Because of the uncertainty of enterprise application requirements, the diversity of development tools and support platforms, the lack of technical resources, leading to enterprise application development, often investing a large amount of funds. Using the existing development platform, regardless of Microsoft's Visual Studio, IBM's WSAD, Sun's Sun One, or third-party independent software vendor such as Borland's JBuilder, Dephi, is very difficult to conduct a typical enterprise application development. Things, because the starting point of these development tools is the technical level (more precisely a software engineer), rather than the need for business needs, so even if senior software engineers and experienced system architects cannot be short A system that meets usually applicable is quickly built in time.
Can there be a rapid development platform for business needs to meet the rapid construction of various scale companies?
Summarize a typical enterprise application, whether it is an Enterprise Resource Program (ERP), Customer Relationship Management (CRM), E-Government, E-Business), Workflow or Content Management System (CMS), it may have the following characteristics:
Ø Safety: Restrict the role of the system (Role) and corresponding permissions (Permission), the resource (resource), may also need to manage the same role packets (Group).
Ø Affairs: For a typical electronic transaction or approval process, the transaction is a crucial ring that ensures that all of the system activities are completed or all rollbacks.
Ø Object Relationship Mapping: The existing main programming mode is more OOP, and the main data storage mode is RDBMS, so almost every application involves object relationship mapping O / R mapping.
Ø Message Service: How to pass the message between each activity and each subsystem. The transmission mode of the message should be a unified model that is independent of the selected platform and the build system.
Ø Cache and timely update: For high concurrent, large-access system, you need to increase the cache policy, cache the most frequently accessible information, and ensure that this information is updated in time.
Ø Log: Record the operation process to ensure the unrecobability of the operation; record the error message to facilitate debugging and monitoring the system.
For a variety of enterprise applications, these features are not necessarily, but optional configurations. What we need is a well-designed pluggable corporate feature component, each component meets a specific business needs, and then uses these components to quickly build enterprise applications.
2 goal
Building a business application rapid development platform requires such a part:
Ø Enterprise function component components: including security, transaction, object relationship mapping, message service, caching mechanism, log management, etc. Each component uses AOP technology implementation, providing unified interfaces, transversely inserted into the system, not intrusive, and does not affect the design implementation of other subsystems. Ø Abstract container layer: Enterprise Apply follows the standard J2EE standard, but runs above an abstract container layer to facilitate separation of the system with the underlying middleware server so that the enterprise application is independent of the J2EE application server.
Ø Template and Wizard: Provide a template for each component to describe the functionality of the component and the provided interface. The wizard uses the rules defined by the template to build the component as a subsystem.
Ø Build system: Building system should be independent of various integrated development environment IDE, automatically construct various components, and each subsystem as a complete enterprise application.
Enterprise Application Rapid Development Platform should be built using open standards such as Java, XML, and widespread useful open source tools such as Ant, XDoclet, etc., as far as they do not rely on operating systems and application servers.
3 technical solution
The overall structure of the enterprise application rapid development platform is as follows:
In this figure, the pink part is the core of the enterprise's rapid application development platform.
The first is the enterprise function component. All corporate feature components, whether existing or redesigned, must follow IOC (Inversion of Control) and AOP (Aspects-Oriented Programming) design paradigm, which can be dynamically inserted into IOC / AOP Container. Components and components should be a chain relationship, which does not interde them to each other, as shown below:
Each component must also provide an XML-based template file (Templates) that defines the functions implemented by this component, the interface provided, the resources required. When building a system, the component will be assembled (or inserted) according to this template file.
The second is the IOC / AOP Container container. The container will provide the minimum runtime environment required for each component, once implemented, it will be a stable kernel, which is developed to each new enterprise application, it is something on the underlying, no need to develop Personnel pay attention to and understand.
The third is the wizard wizards. Use Wizards to define some packaged processes for typical applications (how to combine existing components into a specific enterprise application), describe the rapid development process of enterprise applications at higher level abstractions. Developers can gradually build a system using the wizard, and the settings made in each step will be changed after the wizard is completed. There are two ways to implement the wizard, one is based on XML-based templates to complete, similar to UNIX's MAKE tool. The second is to develop Eclipse plugins, complete using the graphical interface.
Finally, the system build system is built. This step will complete the construction of the entire enterprise application, provided that there is a useful enterprise function component, each with a perfect self-description template, and use the wizard to set the package package. On this basis, the system is built using Ant and XDoclet technology or its extended form. Building systems should complete compilation, deployment, operation, and testing.
4 technology line
4.1AOP technology
AOP, Aspect-Oralted Programming is a new programming technology. The founder of UML Grandy Booch believes that AOP will be the most important programming technology of the next decade. Traditional procedures often exhibit some behaviors that cannot naturally fit a single program module or several tightly related program modules, so it is born to ASPECT-oriented programming (AOP). Aspect's pioneer refers to this behavior as cross cuts because it spans typical responsibilities in a given programming model. For example, in an object-oriented programming, the modular natural unit is class, and the cross-cut relationship is a relationship across multiple classes. Typical cross-cutting relationships include log records for context-sensitive error handling, performance optimization, and design patterns. Aspects of programming AOP is an exciting new model. Object-Oriented Programming (OOP, Object-Oriented Programming) is the most important programming technology in the past decade, mainly used to model common behavior for the same object level. Its main weakness is that the relationship between objects must be static, and a public function module has to be implemented by multiple object models. Therefore, the changes in any need, any object of model can lead to software engineering extension. This is precisely a place for AOP. AOP technology allows us to dynamically design new models to meet the needs of changes, without having to modify the original static model. In addition, we can put the code of these models in one place, only one interface is an external service, rather than scattering code in many packages and classes. AOP and OOP-supplemented development technologies. AOP can be abstract from the function module of the package, class, and method, encapsulate intercepting Interceptor, which is easier to maintain and provides call interfaces for the outside world, each interceptor focuses on completing its own features and not associated with unrelated modules Each interceptor is pluggable. AOP technology can combine related objects that complete specific functions, making code better readability and facilitates maintenance.
At present, AOP has the following items:
AspectJ (TM): Created in Xerox Parc. There are nearly ten years of history, technology maturation, and is currently combined with Eclipse. The disadvantage is too complex; destroying the package; a special Java compiler is required.
Dynamic AOP: Use JDK dynamic proxy API or bytecode bytecode processing technology.
The specific items based on dynamic agent API are: JBoss4 and Nanning.
Bytecode-based items are: AspectWerkz and Spring.
The latter three AOP technologies can be run directly in the Java platform. There is currently no AOP products available in China.
4.2IOC technology
IOC is an abbreviation for Inversion of Control. Its principle is based on the Hollywood Principle of the OO Design: Don't access me, we will visit you. That is, all components are passive, all components initialization and calls are responsible for containers. There are several types of implementation, including method-based (m) IOC based on method parameters, which passes components to each method call; interface-based interface-based (i) IoC (commonly referred to as type 1), It uses interfaces to declare dependencies between components, such as serviceable, configurable; setter-based setter-based (s) IOC (commonly referred to as type 2), which uses the setter method to set the dependence between components; Constructor-based (C) IOC based on constructor (commonly referred to as type 3). IOC is a basic principle of framework development. In open source software, many container frameworks use IOC ideas. For example, PicoContainer uses type 3 IOC technology. Spring mainly uses type 2 IOC technology, and Apache's Avalon mainly uses IOC technology of type 1. There are currently no IOC technology products. 4.3 Enterprise Function Components
Enterprise functional components based on AOP technology and IOC technology are mainly divided by enterprise application needs. Many enterprise applications such as security and user verification modules, almost all systems need to be revisited, which is a great waste of software resources. This functional module is designed using AOP and IOC technology, which can be used to reuse this functional component in different systems, greatly improve software reuse rate and productivity. At present, there are no special research on the topic at home and abroad, and there is no ready-made product available.
4.4 Templates and Wizard Rules
Each enterprise function component requires a self-description template to define the functionality and interface of the component, and the required resources. This template is based on XML technology, provided by the enterprise function component supplier. The wizard rules describe how to use the templates of the functional components to combine these components to become a complete system, and the wizard rules are eventually reflected in the visual Eclipse plugin. Templates and wizards Technical standards for JSR175 metadata, which can be used as XDoclet and Ant. Visual wizards will follow the Eclipse plugin development technology and provide a Chinese operating interface.
5 technical difficulties and goals
5.1 Technology is difficult
Follow the J2EE standard application development framework. J2EE is an international standard for enterprise-based applications developed by Java language, making application development only need to complete business logic's object package, and system logic will automatically bear by J2EE application servers. However, there is a great gap between the establishment of the business needs to the application framework, requiring technicians to not only know the J2EE standard, but also have a superb skill that models model modeling. The enterprise application framework is the basis for the rapid development of enterprise applications in J2EE, providing the basic model of the system modeling and application architecture for business logic.
5.2 Technology Difficulties 2
The usual integrated development platform is divided into a development process of a business application from the technical level, rather than horizontally dividing the functional module of the company. Enterprise Application Rapid Development Platforms will start from enterprise applications, build a reused enterprise function component, all function components have self-descriptive templates, using wizard tools to dynamically assemble the required functional components to build enterprise application systems.
5.3 Technology is difficult 3
The system developed using the enterprise application Rapid Development Platform will run over the designed IOC / AOP container, so that the designed system will not depend on the specific middleware server, with a cross-platform feature. At the same time, the system running on the IOC / AOP container will not change with the upgrade of the underlying middleware server, can extend the service life of the system. 5.4 expected goals
Our rapid development platform is mainly to build enterprise application services. Enterprise applications include typical ERP systems, CRM systems, PDM systems, and other traditional enterprise information systems and industry-enabled rapid development tools with industry applications. This tool is based on the Linuix operating system, which will expand the range of use of domestic Linux operating systems in the majority of enterprises.
Key technical indicators and levels:
Implement the foundation of the application framework and rapid development platform: IOC / AOP container,
Using AOP technology to implement accessible corporate feature components such as security, transaction, distribution, cache, messages, etc., using XML technology-based templates from describing their functions and interfaces.
Implement a fast application development plugin based on Eclipse general development tools, including an editor of a business model, a template custom wizard, and a plugin generated by the program automation.
5.5 Main Innovation
Enterprise functional components that are available: including security, transaction, object relationship mapping, message service, caching mechanism, log management, etc. Each component uses AOP technology implementation, providing unified interfaces, transversely inserted into the system, not intrusive, and does not affect the design implementation of other subsystems.
Independent abstract container layer IOC / AOP container: Enterprise application follows the standard J2EE standard, but runs above an abstract container layer to facilitate separating the system to the underlying middleware server, so that enterprise application is independent of J2EE application server . The container uses IOC / AOP technology, a lightweight container, responsible for the lifecycle management of components and provides runtime Runtime Context.
Template and Wizard: Provide a template for each component to describe the functionality of the component and the interface provided. The wizard uses the rules defined by the template to build the component as a subsystem.
Building system: Building a system should be independent of various integrated development environment IDEs, automated code generated, automatically construct various components, and each subsystem as a complete enterprise application.
