当前页面: 开发资料首页 → Eclipse 英文资料 → Levels of Integration

Levels of Integration

摘要: The types of problems web application developers face today require the use of a diverse set of tools that operate in many domains. In order to provide flexible tool integration, a tool integration platform must allow tool developers to target different levels or integration based on the desired level of investment, time to market, and specific tool needs. Each integration level determines how a tool must behave, and what end users can expect as a result. This article defines the different levels of tool integration supported by Eclipse, and gives an overview of how they work. By Jim Amsden, OTI

Five ways you can integrate with the Eclipse Platform

Web Application development results in the need for integrated tools

The Web represents a complex, highly dynamic, rapidly changing application problem space. A Web application incorporates many resource types representing diverse, yet highly interrelated components including: HTML, GIF, JPEG, DHTML, scripting, Java™ Applets, ActiveX controls, servlets, etc. In most cases, these resources are never collectively compiled in order to validate the intended relationships. This often results in applications that are fragile, and difficult to test, scale, and maintain.

Because of this wide range of content types, building a Web application requires a set of diverse, highly specialized skills including: programmers, graphic designers, database designers, business experts, and document designers. The overall architecture of Web applications is established by the target runtime including client web browsers and HTTP, and web application servers. The resulting distributed applications require compromises between accessibility, availability, integrity, ease of use, performance, and footprint. Web applications are targeted to a broad audience which requires emphasis on ease of use, appealing look and feel, and masking resource and distribution technologies. This isn't easy stuff!

To make matters worse, techniques for developing Web applications are changing fast. Developers end up using new and immature technologies and tools in different stages of maturity: new tools, new revisions of old tools, and beta releases of emerging tools. There is a significant opportunity for point tools that support emerging web technologies to facilitate application development. However, these tools must be effectively integrated with other tools in order to speed Web application development, minimize gaps and overlaps between tools, and provide a positive developer experience.

Tools vendors need to maximize acceptance while minimizing development cost

In order to be successful, tool developers need to focus on the value added by their tools while minimizing their investment in "plumbing", porting to other operating systems, browsers, and/or web servers, and minimizing the amount of ancillary functionality that must be provided in order for their tool to be accessible and useful. Minimizing this investment involves integrating tools with other complementary tools and IDEs in such a way that the integrated result provides more value to the end user than the individual tools by themselves. However, integrating tools can require a significant investment! Each tool or IDE that is a candidate for integration may provide its own set of extensibility and integration mechanisms. In order to achieve maximum market penetration, a tool vendor needs to integrate with as many other tools and IDEs as possible, and in such a way that the tools complement each other without creating undue redundancy and coupling.

The Eclipse Platform provides a tool integration framework

The Eclipse Platform reduces the cost of tool integration by providing a large number of services, APIs, and frameworks that enable effective and scalable tool integration. Wherever possible, Eclipse uses open standards to limit tool vendor investment and reduce time to market. The Platform provides a focal point for integrating and configuring best-of-breed tools in a manner that best fits the end user's development process and Web application architecture. The Eclipse Workbench provides a central integration point for project control and an integration mechanism for resource-specific tools. This approach allows a user to build applications using a heterogeneous set of tools while at the same time providing a common view of the complete application across all components and the entire team.

The Eclipse Platform can also provide services common to different tools including user interface frameworks, managing relationships between components, component version management, and publishing services. Using Eclipse simplifies tool integration by allowing tools to integrate with the platform instead of each other. This significantly reduces the number of integration problems that must be solved, and provides a more consistent environment for the end user.

Integration Conformance Levels

Full integration with Eclipse provides an experience for the end user that is so seamless they can't tell where one tool ends and another begins. However full integration isn't always practical for all tools. In order to provide flexible tool integration, Eclipse supports a number of integration levels that tool developers can target based on the desired level of investment, time to market, and specific tool needs. Each level specifies what tool vendors must do to achieve that level of integration, and the required technologies that must be employed. The integration levels are summarized in the table below, and described in detail in the following sections.

None

</td> <td>No integration, tools are separate and independent.</td> </tr> <tr> <td>Invocation</td> <td>Integration is through invocation of registered applications on resource types</td> </tr> <tr> <td>Data</td> <td>Integration is achieved through data sharing</td> </tr> <tr> <td>API</td> <td>Tools interact with other tools through Java APIs that abstract tool behavior and make it publicly available</td> </tr> <tr> <td>UI</td> <td>Tools and their user interfaces are dynamically integrated at runtime including window panes, menus, toolbars, properties, preferences, etc.</td> </tr> </table>

None - No integration

Invocation - Tool launched in external process

Data - Data sharing

API - Integration through platform API's

UI - User interface integration

Conclusion

Application development, and in particular Web application development, isn't getting any easier. Clients are demanding high-quality applications in Web time to support critical business processes. They're betting their business on our software. But these aren't the only demands we face. Modern Web applications consist of many loosely coupled technologies requiring diverse, often distributed teams, to create highly linked resources that are seldom collectively managed. Addressing this "software paradox" and managing application development complexity requires truly best-of-breed tools that can be selected and integrated to provide a roles appropriate, end-to-end development environment tailored to individual development processes. No longer can we wait for six to twelve months for the next release of our development tools to get that bug fixed or add the features we need to get our work done. We want what we need when we need it!

But integrated tools require a platform of services, frameworks, and standards that allow vendors to focus on their value-add while reusing common infrastructure. The platform must include a workbench that provides a common view of the whole application across all resource types and the entire team. And the platform must be accessible to tool vendors under an acceptable license. Eclipse not only provides such a platform, but it's architecture also provides flexibility in how tool venders integrate their tools and at what level. This allows vendors to match their integration investment with their product needs and market window.

Some tools don't need to be integrated at all. That's great when it works, not so great when it doesn't. For simple integration, use invocation integration to provide users navigation, access, editing, and management of file-based resources. Use data integration to share data between tools that are otherwise unconnected. When data integration isn't enough, use API integration to provide secure access to encapsulated data. Finally, for the whole Enchilada, use UI integration to make tool components fit seamlessly together as if they were built by a single hand. Pick the integration you need today, but use Eclipse to do it in such a way that you're prepared for integration your customers want tomorrow.

Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States, other countries, or both.

Microsoft, Windows, Windows NT, and the Windows logo are trademarks of Microsoft Corporation in the United States, other countries, or both.

↑返回目录
前一篇: Mark My Words
后一篇: Understanding Layouts in SWT