Workshop 8.1—More Than a Web Services Tool

The first release of BEA WebLogic Workshop concentrated primarily on Web Services. Workshop was seen as an enabler for Web Services development, testing, and orchestration. In the current BEA WebLogic Platform release, Workshop has undergone major revision. The core theme of Web Services enablement has not changed, but the scope has been expanded. Workshop is now the standard, integrated development view into the BEA WebLogic Platform. All WebLogic Integration and WebLogic Portal development can now be done through Workshop.

Goals of Workshop 8.1

The new Workshop tool accomplishes two key goals: simplifying J2EE development and reducing IT complexity. It achieves these goals in numerous different ways that we discuss in this section.

Simplifying J2EE Development

Eighty percent of the application code that's written for an application deals with low-level plumbing, such as a J2EE component. Developers typically spend more time trying to understand what J2EE technologies to use and how to use them than they do writing code to solve a business problem.

Workshop generates a lot of this plumbing code for developers, thus lowering the barrier to entry and enabling them to focus on business requirements and leverage their domain experience. They don't need to worry about the complexities of writing to the J2EE APIs, such as writing an EJB or servlet. The goal of Workshop is to make developers write simple business code and set up different properties and code annotations. Workshop takes care of the complexities of J2EE and the underlying implementation of Web Services.

Reducing IT Complexity

Workshop 8.1 provides developers with a single tool and a single, simplified programming model for building and integrating any type of application using core J2EE, Web Services, Portal, and Integration technologies. This enables developers to leverage the entire BEA WebLogic Platform from one tool and in a unified manner.

Figure C.1 clearly shows the role of BEA WebLogic Workshop in the BEA WebLogic Platform. The components shown in Figure C.1 live on top of J2EE. Workshop provides a powerful, easy-to-use, and unified development environment for all BEA products. It provides the visual development and runtime environment to deliver on the J2EE Made Easy vision of BEA. Many developers view the new Workshop IDE as a Visual Studio for Java programmers.

Key Focal Points of Workshop

To achieve the goals set out in the previous section, Workshop is built around various key focal points.

Javadoc Properties and Code Generation

Workshop uses Java-annotated file formats that enable it to provide a source and graphical view of the application being developed. Workshop provides a What You See Is What You Get (WYSIWYG) approach to Java development. Just as HTML editors such as Dreamweaver and FrontPage enable you to graphically develop HTML pages and make it possible to see the code and output side by side, Workshop provides a Design view and Code view of the Java files.

Design view enables you to set various properties on the components you create, that allow the Workshop framework to generate appropriate code during compile time. These properties can also be edited in the Code view as they get represented as code annotations. Code annotations are Javadoc-like comments that store the properties used to determine how the implementation or plumbing code is generated. BEA is promoting various Java Specification Requests (JSRs) to standardize the annotated code definitions.

Application Architecture

Workshop writes much of the plumbing code based on a solid J2EE application architecture that can fully leverage best practice design patterns and the J2EE blueprints. Workshop generates the application leveraging an MVC framework based on Struts, EJBs, and Web Services. It hides the complexity of J2EE applications by providing data binding, navigation management, state management, transaction management, and other architecture services through annotated coding.

Visual Development Environment

The Workshop IDE is a complete development environment for creating J2EE applications and Web Services. It has visual development, testing, and debugging capabilities. This IDE will compete with the other IDEs in the marketplace. Figure C.2 shows a screenshot of a Web Service being developed in Workshop 8.1.

Figure C.2 shows various windows. The window that is most different from other Java IDEs is the Design View section. This is a graphical representation of an underlying Web Service written in Java and J2EE.

Runtime Framework

The runtime framework that comes with BEA WebLogic Workshop provides the loose coupling and the layer of abstraction between business code and the J2EE plumbing code. This framework can generate EJBs (using a tool called EJBGen), Java Message Service (JMS) and JDBC code, as well as code for several other J2EE technologies as required by the application. The framework takes the different code annotations supported in Workshop and generates all the J2EE and Web Services code in the background. It addresses several J2EE design issues and uses best practices, design patterns, and the J2EE blueprints to provide code that is reliable, scalable, and secure.

The runtime framework provides an added layer of convergence for the BEA WebLogic Platform by sitting on top of the core BEA WebLogic Server, as well as WebLogic Integration and WebLogic Portal.

Extend Workshop Using Java Controls

Java controls are visually created components that contain all the methods and properties to connect to external systems, applications, and business code. After a Java control has been created, that control can be used easily and consistently from a Web Service, a Web page flow, a portal, a workflow, or another Java control. Files with the extension JCS (Java Control Source) or JCX (Java Control Extension) contain WebLogic Workshop controls. They typically include a collection of method definitions that enable you to easily access a resource such as a database or a Web Service. Workshop 8.1 also provides an extensible Java controls technology to make it easy to leverage existing IT infrastructure such as databases, legacy applications, and other backend resources, which empowers developers to accomplish more in less time.

WebLogic Workshop includes several built-in controls that facilitate access to commonly used enterprise resources. These controls include

• Timer control— Runs code at a given interval

• Database control— Accesses a relational database

• Web Service control— Calls a Web Service from within your application

• EJB control— Accesses an existing Enterprise JavaBean

• JMS control— Sends and receives messages via a Java Message Service queue or topic

You can create custom Java controls to encapsulate any business logic that's required by your application. You can create a Java control in one of two ways:

• Controls for a single project— You use the control's source files directly when you want the convenience of code that can be called from multiple places within a project, but probably won't be reused in additional projects. When you use control sources directly, the control's implementation file and interface file are in the same project as the application that uses them.

• Custom control libraries— You build a control within a control project when you want to end up with a Java library-style JAR file that can also be used in other projects, such as Web application projects, and potentially by other developers. To use the control in another project, that project's developer simply puts the control JAR file into the project's library folder. The control then appears in the palette and menu.

BEA provides a graphical palette and tools to specify the interfaces to custom controls and properties that dictate their runtime behavior. They also write the business code that is exposed by the control. BEA views the use of controls in WebLogic as an enabler for its view of a service-oriented architecture. Controls can be exposed as Web Services in a Web Services architecture. Such controls would fit our definition of an enterprise-class Web Service.

Controls have the following key benefits:

• Visual representation— Controls have a design-time view that gives developers a visual representation of the business logic that they expose.

• Properties— Controls expose simple properties that implement advanced and complex functionality, such as asynchronous messaging, security, state and life cycle management, transaction-based connections to external systems, and so on.

• Package— Controls are packaged in JAR files so that they can be reused.

• Connectivity— Controls are used to connect to remote systems such as databases or custom and legacy applications.

• Extensibility— An open API and wizards enable third parties to create controls for use in their custom applications or for packaging and selling to enhance Workshop or to expose some of the functionality of their tools in Workshop.