Informacion sobre Websphere 5

[abuenog]

Hola, aqui os dejo información acerca de websphere 5. Esta en ingles, y es la info que viene con el producto:

Application development tools
This chapter describes the various application development tools that come with this configuration of WebSphere Studio.

Java development tools
The Java development tools included with WebSphere Studio support the development of any Java application. They add Java perspectives to the workbench as well as a number of views, editors, wizards, builders, and code merging and refactoring tools. The Java development tools offer the following capabilities:

JDK 1.3 support
Pluggable run-time support for JRE switching and targeting multiple run-time environments from IBM and other vendors
Automatic incremental compilation
One debugger for both local and remote debugging
Ability to run code with errors in methods
Crash protection and auto-recovery
Error reporting and correction
Java text editor with full syntax highlighting and complete content assist
Refactoring tools for reorganizing Java applications
Intelligent search, compare, and merge tools for Java source files
Scrapbook for evaluating code snippets

Java projects and incremental compilation
WebSphere Studio features a Java project structure which has an associated Java builder incrementally compile Java source files as they are changed. Each Java project maintains additional information about the type hierarchy and the references and declarations of Java elements. This information is constantly updated as the user changes the Java source code; it is not dependent on the builder.


Perspectives, views, and editors
WebSphere Studio includes the Java and Debug perspectives to organize resources for Java editing or debugging. The Java perspective provides views, wizards, preferences and property sheets for creating, viewing, and editing Java resources. The Java text editor features full syntax highlighting and complete content assist based on anything visible in the Java project's class path, including elements in the currently edited file. The Debug perspective features a debugger that can be used locally or remotely.


Configurable Java run-time environment and JDK level
You can add new JRE definitions to WebSphere Studio and switch between JDK levels. When installing a JRE, you can specify the JRE type, name, home directory, and the default library location. WebSphere Studio supports JDK 1.3 with the ability to configure multiple test environments.


Refactoring tools
Workbench Studio features refactoring tools for reorganizing Java applications. When you refactor a program, you transform your code while preserving its behavior. When refactoring, you can optionally preview all the impending changes resulting from a refactoring command before you finally choose to carry it out. You can rename an element, and the refactoring support changes both the selected resource's name and all references to it.


Scrapbook
The Java development environment contributes a facility that can be used to experiment and evaluate Java expressions (code snippets). Snippets are edited and evaluated in the Scrapbook page editor. You can select a code snippet, evaluate it, and display the result as a string or show the result object in the debugger's inspector.


Search tools
The Java development environment includes intelligent search tools for Java source files. The Java support allows you to precisely find declarations and references of Java elements (package, type, method, field). Searching is supported by an index that is kept up to date in the background as the resources corresponding to Java elements are changed.

For more information about the Java IDE, refer to the online help.


Visual Editor for Java
The Visual Editor for Java provides an interface to assist with visual construction of the user interface (UI) for a Java application or applet. It is based on the JavaBeans component model, and supports visual construction using either the Advanced Widget Toolkit (AWT) or Swing. The Visual Editor for Java comprises a tool palette, a design canvas, and a source pane. The design canvas displays a visual representation of the beans and the associated source is displayed in the source pane. As you modify the beans in the design canvas, the Java source is modified to reflect the change. The reverse is also true; as you make changes to the source, the design canvas is updated to reflect parsable changes. Not only can you generate your code, but you can immediately see the effect of source code modifications during development. You can make changes to your Java file in another editor and then open it again in the Visual Editor for Java; your changes will automatically be reflected in the Visual Editor for Java.

Web development tools
The Web development environment in WebSphere Studio provides the tools necessary to develop Web applications as defined in the Sun Microsystems Java Servlet 2.3 Specification and the Sun Microsystems JSP 1.2 Specification. Web applications include static Web pages, JavaServer Pages (JSPs), Java servlets, deployment descriptors (web.xml files), and other Web resources.

This environment brings all aspects of Web application development into a common interface. Everyone on your Web site team, including content authors, graphic artists, programmers, and Webmasters, can work on the same projects and access the files they need. Within the integrated Web development environment, it is easy to collaboratively create, assemble, publish, deploy and maintain dynamic, interactive Web applications.

The Web development environment includes the following high-level capabilities:

Web project creation, using either the J2EE-defined hierarchy or a static version that reduces project overhead when dynamic elements are not required.
Creation and editing of a Web deployment descriptor (web.xml) file
Site-level Web management templates and support
JSP and HTML file creation, validation, editing, and debugging
JavaScript editing and validation
Custom JSP tags (taglib) support, based on the JSP 1.2 specification
An extensible view, called the Library view, which allows users to catalog and organize reusable programming objects, such as HTML, JavaScript, and JSP code, along with files and tag libraries
Image editing and animation
Cascading Style Sheet (CSS) editing support
HTTP/FTP import
FTP export (simple resource copy) to a server
Web archive (WAR) file import, export, and validation
Link viewing, parsing, validation, and management, which includes converting links, flagging broken links, and fixing links as resources are moved or renamed
Servlet creation, by means of a wizard to create new servlets and add servlet mappings to the deployment descriptor (web.xml) file
Generation of Web applications using wizards that create Web resources from database (SQL) queries and beans
Integration with the WebSphere test environment
Publishing support for multiple Web server types

Web services development tools
WebSphere Studio provides wizards and other tools to enable rapid development of Web services. Web services are modular, standards-based e-business applications that businesses can dynamically mix and match to perform complex transactions with minimal programming. Web services allow buyers and sellers all over the world to discover each other, connect dynamically, and execute transactions in real time with minimal human interaction.

Some examples of Web services could be theatre review articles, weather reports, credit checks, stock quotations, travel advisories, or airline travel reservation processes. Each of these self-contained business services is an application that can easily integrate with other services, from the same or different companies, to create a complete business process. This interoperability allows businesses to dynamically publish, discover, and bind a range of Web services through the Internet.

The Web services development tools provided in WebSphere Studio are based on open, cross-platform standards:

Universal Description Discovery and Integration (UDDI), which enables businesses to describe themselves, publish technical specifications on how they want to conduct e-business with other companies, and search for other businesses that provide goods and services they need, all via online UDDI registries
Simple Object Access Protocol (SOAP), which is a standard for reliably transporting electronic business messages from one business application to another over the Internet
Web Services Description Language (WSDL), which describes programs accessible via the Internet (or other networks), and the message formats and protocols used to communicate with them
WebSphere Studio facilitates the following processes to assist with building and deploying Web services-enabled applications:

Discover. Browse the UDDI business registry to locate existing Web services for integration.
Create or Transform. Create Web services from existing artifacts, such as Java beans, EJB beans, URLs that take and return data, DB2(R) XML Extender calls, DB2 stored procedures, and SQL queries.
Build. Wrap existing artifacts as SOAP and HTTP GET/POST-accessible services and describe them in WSDL. The tools also assist you both in generating a SOAP and HTTP GET/POST proxies to Web services described in WSDL and in generating bean skeletons from WSDL.
Deploy. Deploy Web services in the WebSphere Application Server or Apache Tomcat test environments using Server Tools.
Test. Test Web services running locally or remotely in order to get instant feedback.
Develop. Generate sample applications to help you create your own Web service client application.
Publish. Publish Web services to the UDDI business registry, advertising your Web services so that other businesses can access them.

[abuenog]

Enterprise JavaBeans (EJB) development tools
The EJB development environment features full EJB 2.0 support, an EJB test client, a unit test environment for J2EE, and deployment support for Web archive (WAR) files and enterprise archive (EAR) files. Entity beans can be mapped to databases, and EJB components can be generated to tie into transaction processing systems. XML provides an extended format for deployment descriptors within EJB.

The following EJB development tools are included:

Tools for import/export, creation and code generation, and editing, as well as support for standard deployment descriptors and extensions and bindings specific to WebSphere Application Server.
EJB-to-RDB mapping tools that provide the model, run-time environment, and interface for editing the mapping between EJB beans and relational database tables with top-down and bottom-up capability. The mappers support associations, inheritance, and converters and composers as helpers on column maps.
A query engine that supports deployed code by generating SQL strings into persistent classes.
Tools that provide the ability to create, edit, and validate EAR files.
Editors for deployment descriptors.
Graphical RDB schema viewing and editing tools.
The deployment tools for enterprise beans provides a command-line environment so that you can run overnight build processes and automatically generate your deployment code in batch mode.

J2EE perspective
All of the EJB development environment tools are accessible from the J2EE perspective. This is where your EJB projects and individual enterprise beans reside, and it is where you accomplish all of your enterprise bean development and testing activities.


Support for enterprise beans and access beans
The EJB development environment provides tools to help you create enterprise beans (either with or without inheritance), including session beans, container-managed persistence (CMP) entity beans, bean-managed persistence (BMP) entity beans, and message-driven beans. Tools are also provided to create access beans and other EJB elements, such as relationships.


Data persistence
The EJB development environment provides a mapping editor to help you map entity enterprise beans to data stores such as relational databases. There is support for top-down, bottom-up, and meet-in-the-middle development. You can also create schemas and maps from existing enterprise beans.


Deployment code
WebSphere Studio includes tools to set deployment descriptor and control descriptor properties for your enterprise beans and to generate the deployed classes that allow your beans to operate on a server. The tool that generates the deployment code is integrated with the WebSphere Studio generation options, so you can simply select individual enterprise beans as input and then select a menu item to automatically generate the deployment code. The tools support session beans, BMP and CMP entity beans, and message-driven beans. They also allow you to create relational database tables for CMP entity beans. Once code has been generated for deployment, you can export your enterprise beans to a JAR file for installation on an EJB server, such as WebSphere Application Server.


Verifying enterprise bean and access bean code
The EJB development environment automatically and seamlessly verifies that your enterprise bean code is consistent and that it conforms to the rules defined by the Enterprise JavaBean specification. Code verification occurs whenever an enterprise bean or its properties are changed. If any problems are detected, an error or warning icon appears beside the problematic lines of code and a message appears in the Tasks view at the bottom of the J2EE perspective.

The EJB development environment also automatically verifies that access beans are constructed correctly and that they are consistent with their associated enterprise beans. Code verification occurs whenever you create or edit access beans.

For more information about the EJB development environment, refer to the online help.

XML and XSL tools
The comprehensive XML toolset includes components for building DTDs, XML schemas, XML and XSL files. It also supports integration of relational data and XML.


XML editor
The XML editor is a tool for creating, viewing, and validating XML files. You can also use it to edit XML files, associate them with DTDs or schemas, and validate them.

The XML editor simplifies development tasks in the following ways:

Provides a wizard that makes it quick and easy to create XML files from scratch, or from existing DTD or XML schema files.
Provides both a Design view and a Source view. The Design view represents the XML file simultaneously as a table and a tree, which helps make navigation and editing easier. You can use the Source view to view and work with a file's source code directly.
Enables you to easily add a DTD declaration or XML schema information to an XML editor.

DTD editor
The DTD editor is a tool for creating, viewing, and validating DTDs. Using the DTD editor, you can create and validate DTD elements, attributes, entities, and notations.

The DTD editor simplifies development tasks in the following ways:

Provides wizards that enable you to quickly and easily generate XML schema files, Java beans, and HTML forms from DTD files.
Includes a built-in mechanism to handle referential integrity issues. When you delete or rename certain nodes, clean up will automatically occur.

XML schema editor
The XML schema editor facilitates creating, viewing, and validating XML schemas. You can use the XML schema editor to perform tasks such as creating XML schema components, importing and viewing XML schemas.

The XML schema editor simplifies development tasks in the following ways:

Provides wizards that enable you to quickly and easily generate DTDs, XML files, relational table definitions, Java beans, HTML documentation, and DDLs from an XML schema.
Provides pop-up menus for XML schema components, so you know what each XML component can have added to it

[abuenog]

XSL editor
The XSL editor is a tool for creating, viewing, and validating XSL files.

The XSL editor simplifies development tasks in the following ways:

Provides a wizard that makes it quick and easy to create XSL files and associate them with XML files
Provides numerous wizards, as well as content assist, that make it easy for you to edit your XSL file.

XSL debugging and transformation tool
The XSL debugging and transformation tool can be used to apply XSL files to XML files and transform them into new XML, HTML or text files. As you trace through the transformation, you can use the XSL Debug perspective to debug your source files.

The XSL debugging and transformation tool simplifies development tasks in the following ways:

Provides a simple pop-up menu option for quick transformations as well as a wizard for more complex transformations.
Opens your source files in the XSL Debug perspective after you have run your transformation, enabling you to step through them and see any breakpoints or errors in them, and well as which templates are being called during the transformation.

XML to XML mapping editor
The XML to XML mapping editor maps one or more source XML documents to a single target XML document. You can provide a source file (DTD or XML) and a target file and define the mappings between the source and the target. Each mapping is a selection of a target field, a conversion function and source fields. Mappings can be edited, deleted or stored for later use.

The XML to XML mapping editor simplifies development tasks in the following ways:

Provides a visual interface to easily define mappings between source and target XML documents.
Automatically generates XSLT scripts.

XML and SQL query
You can use the XML and SQL query wizard to create an XML file from the results of an SQL query. You can optionally choose to create an XML schema or DTD file that describes the structure that the XML file has for use in other applications. You can also use the XML and SQL Query wizard to create a DADX file that can be used with the Web services tool. The generated DADX file will contain your SQL query.


Relational database (RDB) to XML mapping editor
The RDB to XML mapping editor makes it easy to define the mapping between relational tables and a DTD file. You can map columns in one or more relational tables to elements and attributes in an XML document. You can generate a document access definition (DAD) script, used by IBM DB2 Extender, to either compose XML documents from existing DB2 data, or decompose XML documents into DB2 data. You can also create a test harness to test the generated DAD file.

The RDB to XML mapping editor is designed to work in conjunction with the DB2 XML Extender. It simplifies development tasks in the following ways:

Provides a visual interface to easily define mappings between relational data and XML elements and attributes.
Automatically generates DAD files.
Automatically generates a test harness.
For more information about XML tools, refer to the online help. There are also samples to help you get started.

Relational database tools
WebSphere Studio provides you will relational database tools that you need to work with relational databases in your application development. The relational database tools include views, wizards, editors, and other features that make it easy for you to develop and test the database elements of your application. Unless explicitly stated, the feature in the relational database tools support all database vendors.

You can manage the database definitions and connections that you need for your application development. You can connect to databases and import database definitions, or you can define new databases, schemas, tables, and views.

You can connect to or import from several database types, such as DB2(R), Oracle, SQL Server, Sybase, Cloudscape, and Informix.

The SQL query builder provides a visual interface for creating and executing SQL statements. You can create a simple statement or add complex expressions and grouping. When you are satisfied with your statement, you can use the SQL to XML wizard to generate an XML document as well as XSL, DTD, XSD, and HTML files, plus other related artifacts, then use the files to implement your query in other applications, for example, a servlet or JSP.

You can create a simple query using the SQL statement wizard, or you can use the SQL query builder that supports a wider range of statements. There is also an SQL editor with highlighting and content assist that allows you to manually edit and create .sql files.

The DB2 stored procedure and UDF builder component provides wizards and tools for creating and working with stored procedures and user-defined functions (UDFs) for use with DB2 Universal Database. When you create an application that accesses DB2 data, you can improve your application's performance by incorporating stored procedures and UDFs that are registered with the database server. You can reduce network traffic and make better use of shared business logic.

After you create a routine (stored procedure or UDF) with one of the wizards, you can modify it in the text editor. When you are satisfied, you can build it and register it on the DB2 server. After the routine is on the server, you can execute it and run the SQL statements that are included in the routine. When you run a routine, you can look in the Output view to see relevant information such as messages, parameters (input and output), and result sets that are returned. If you are not satisfied with the results, you can continue to modify and rebuild the routine until it returns the desired results.

Use this component to create the following types of routines:

SQL and Java stored procedures
SQL UDFs
UDFs that read or receive messages from MQSeries message queues
You can:

Create a new routine using a wizard
Modify existing routines using the text editor
Build (register) routines on the DB2 database server
Run (execute) routines on the DB2 database server
View result sets, messages, and parameters in the Output view
Drop routines from the database
For more information about relational database tools, refer to the online help.

Component test tools
The component test tools provide a framework for defining and executing testcases. The basic framework supports three sorts of testcase: manual, Java, and HTTP. You can also create report generators to work with the data returned by an executed testcase.

You can use the component test tools to do the following tasks:

Define manual testcases, which automate a tester's to-do list
Define HTTP testcases, which automate of requests against a Web site
Define Java testcases, which implement the JUnit framework to automate Java method calls
Run testcases locally or remotely, using the Agent Controller
Track execution results as the testcase executes
Generate reports on your testcase information
Define new report generators
The tools can be used by developers to test their own code, or by testers to coordinate project-wide testing efforts.

For more information about component test tools, refer to the online help.

Testing and publishing tools
The testing and publishing tools (referred to in this section as "Server Tools") provides a unit test environment where you can test JSP files, servlets, and HTML files. It also provides the capability to configure other local or remote servers for integrated testing and debugging of Web and EJB applications. Server Tools supports the following projects:

[abuenog]

Web projects, which may contain JSP files, HTML files, servlets, and beans
EJB projects, which contain enterprise beans
Enterprise Application projects, which may contain java archive (JAR) files or web archive (WAR) files or both, and pointers to other Web or EJB projects.

Supported run-time environments
Server Tools uses servers and server configurations to test your projects. Servers identify where you can test your projects. Server configurations contain setup information. Server Tools allows you to test your applications in different run-time environments that can be installed locally or remotely:

The Server Tools feature includes a local copy of the full WebSphere Application Server run-time environment, where you can test Web projects, EJB projects, and Enterprise Application projects.
You can also test on a remote copy of the WebSphere Application Server. To do this, you must install on your remote machine:
WebSphere Application Server
IBM Agent Controller (included with WebSphere Studio as a separate install)
Server Tools also supports the Apache Tomcat run-time environment, running locally. With Tomcat, you can only test Web projects that contain servlets and JSPs.
A test environment called the TCP/IP Monitoring Server is also packaged with Server Tools. This is a simple server that forwards requests and responses, and monitors test activity. This run-time environment can only be run locally, and it only supports Web projects. You cannot deploy projects to the TCP/IP Monitoring Server.
For more information about testing and publishing to a server, refer to the online help.

Profiling and logging tools

Performance profiling
WebSphere Studio provides tools that enable you to test your application's performance early in the development cycle. This allows enough time to make architectural changes and resulting implementation changes. This reduces risk early in the cycle, and avoids problems in the final performance tests. The Profiling tools bring together a range of techniques that let you explore many aspects of your program.


Visualization

Graphical and Statistical profiling views
The Profiling tools collect data related to a Java program's run-time behavior, and present this data in graphical and statistical views. In addition to being memory leak diagnostic aids, which the statistical views also are, the graphical views afford pattern extraction and information exploration capabilities.


Sequence diagram views
Sequence Diagram views are specialized views that provide a means to visualize the execution of Java applications in the form of sequence diagrams that are defined by the Unified Modeling Language (UML) notation. These views are best put to the following uses:

Software development management personnel can verify a software implementation with the design documentation for the purpose of accuracy.
Software developers can use the views to understand the execution flow of an application and to analyze its performance.
Business application administrators can monitor the state and performance of such applications, where the monitoring may be performed at any level: that of the agent, the process, the host, or the monitor (cluster of hosts).
Computer network administrators can monitor interactions among hosts on the network.

Distributed process monitoring
The Profiling tools also give you the ability to launch remote applications. You can concurrently monitor multiple, live processes that may reside on different machines.


WebSphere Application Server profiling
The ability to profile Java projects from WebSphere Studio is supplemented by the ability to effortlessly start and profile either a local or a remote WebSphere Application Server using Server Tools.


Logging
The logging capabilities of WebSphere Studio are manifested in the Activity Log view within the Profiling perspective for graphically and textually displaying real-time and batch-loaded logs. The WebSphere Application Server activity logs can only be viewed in the Activity Log view. The other log views are the Message Log view for viewing default records, and the Default Log view that displays all other log records.


The XML symptom database
The Logging tools can also present current solutions to known patterns found within the displayed logs. Log entries can be analyzed using an XML symptom database to interpret known events and error conditions. As Support staff locate reasons and solutions for unique errors and events cited within logs, entries are added to an XML symptom database with the appropriate search data for log entry and pattern matching. This provides the ability to analyze one or more log entries based on the most current symptom database for detailed information on error resolution and event significance.


Note:
Searching of symptom databases of any format is supported. But, currently only the WebSphere Application Server version 4.x and WebSphere Application Server version 5.x symptom databases are used.

Data transport and agent control technologies
The Agent Controller provides a means for extending application behavior so that information regarding the application's execution can be externalized and then collected either locally or remotely. The Profiling tools use this facility, as do various other IBM testing and debugging tools.

For more information about profiling and logging, refer to the online help.

Debugger
All products based on Eclipse include a debugger that enables you to detect and diagnose errors in your programs running either locally or remotely. The debugger lets you control the execution of your program by setting breakpoints, suspending execution, stepping through your code, and examining the contents of variables.

You can debug live server-side code as well as programs running locally on your workstation. The debugger includes a Debug view that shows threads and stack frames, a Processes view that shows all currently running and recently terminated processes, and a Console view that lets you interact with running processes. There are also views that display breakpoints and let you inspect variables.

The following debug components, all of which can be used for debugging locally and for remote debugging, are included:

The WebSphere Application Server debug adapter, which allows you to debug Web objects that are running on WebSphere Application Server. These objects include EJBs, JSPs, and servlets. Through use of the debug adapter, you can also debug server-side JavaScript.
The Java development tools (JDT) debugger, which allows you to debug Java.
The SQL Stored Procedure Debugger, which allows you to detect and diagnose errors in SQL procedures that are running on a DB2 server.
The Compiled language debugger, which allows you to debug compiled-language applications.