Oracle JDeveloper (10.1.3.2.0) extends the SOA
development features from the previous release by introducing the
Oracle WebCenter extension. Oracle WebCenter Suite combines the
standards-based, declarative development of JavaServer Faces (JSF), the
flexibility and power of portals, and a set of integrated Web 2.0 services to
boost end-user productivity. Oracle WebCenter Suite provides the
tools and services to embed portlets, content, customizable components, Web 2.0
content, collaboration and communication services directly into your JavaServer
Faces (JSF) application. These WebCenter features are in addition to the large set of new features
that were introduced in Oracle JDeveloper 10.1.3.0 and 10.1.3.1.0. For
more information on WebCenter, visit the
Oracle
WebCenter Suite page on OTN.
Oracle JDeveloper (10.1.3.1.0) extends the IDE
features from the previous release by adding integrated SOA development
tools to provide an Integrated Service Environment workbench. In
particular, BPEL (Business Process Execution Language) and ESB
(Enterprise Service Bus) tooling is now fully integrated into
JDeveloper. In addition, JDeveloper's core IDE features for EJB 3 and
JPA (Java Persistence API) have been extended, and made fully up to
date with the final EJB 3 specification. This document lists the new
features in the Production release. These features are in addition to
the large set of new features that were introduced in Oracle JDeveloper
10.1.3.0.
Oracle JDeveloper 10g is a complete and integrated development
environment for standards-based SOA applications. The Oracle JDeveloper
10g Release 3 (10.1.3) version adds many new features including a new
look and feel, a greatly improved coding environment with extensive
refactoring options, support for the latest Java standards (J2SE 5.0,
J2EE 1.4, EJB 3.0), and visual JSF development. A visual and
declarative approach and the improved Oracle Application Development
Framework (Oracle ADF) work together to simplify application
development and reduce mundane coding tasks, offering developers
unparalleled productivity regardless of their choice of technology
stacks and deployment platforms.
Detailed Features of Oracle JDeveloper (10.1.3.2.0)
Build Portlets
The WebCenter Framework enables you to build and deploy portlets
using the WebCenter Extension for JDeveloper. Oracle JDeveloper’s portlet
creation wizards help you build JSR 168 as well as Oracle PDK-Java portlets
quickly and easily. Another set of wizards guide you through portlet producer
deployment. For testing purposes, you can deploy your portlets to the WebCenter
Preconfigured OC4J.
JSR 168 Portlet wizard: Use the
portlet wizard to build a portlet skeleton and update with business logic.
Oracle PDK-Java Portlet wizard: Use
the portlet wizard to build a portlet skeleton and update with business
logic.
Preliminary version of WSRP 2.0: Check a box in the JSR 168
portlet wizard to enable WSRP 2.0 extensions which include inter-portlet
communication and export/import of portlet customizations.
Expose JavaServer Faces application
as portlets: The JSF-Portlet Bridge in Oracle WebCenter Suite allows
developers to expose a JavaServer Faces (JSF) application as a JSR 168
portlet (portletize).
The portletized application can be consumed by any portal framework
that supports the portlet standards, such as an Oracle WebCenter
application or OracleAS Portal.
To publish a JSF application as a portlet, you must ensure that your
JSF pages emit markup that conforms to JSR 168 portlet markup fragment
rules. Most of the ADF Faces components render portlet-compatible
markup.
When you portletize an ADF application, there are a number of
guidelines and best practices to keep in mind. These are described in
the Oracle WebCenter Framework
Developers Guide.
Preconfigured OC4J within Oracle
JDeveloper: The WebCenter Extension for Oracle JDeveloper includes a
Preconfigured OC4J which hosts a number of out of the box portlets and
portlet samples.
Deploy portlets to the preconfigured OC4J for testing purposes.
Deploy full WebCenter applications to the preconfigured OC4J for
testing purposes.
Stop and Start the OC4J directly from Oracle JDeveloper
Consume Portlets
Producer registration wizards: Producers are registered with each
application using registration wizards provided by the WebCenter Framework.
Once registered, portlet show up in the component palette under the producer
registered. There are two registration wizards:
WSRP Registration Wizard (supports both WSRP 2.0 and WSRP 1.0)
Oracle PDK-Java Registration Wizard
Drag and drop portlets: Drag portlets directly from the component
palette onto a JSF page.
Inter-component communication:
Using new page variables, developers can enable many different types of
components to communicate with each other.
JSF component to any portlet
JSR 168 portlet to any portlet through WSRP 2.0 (preliminary version)
Business User Web 2.0 Enterprise Mashup Tools
In Web 2.0 terminology, a mashup is
the result of integrating complementary elements from two or more sources. Using
the tools provided by WebCenter Framework, business developers can create their
own mashups in minutes. A set of declarative wizards guides users through the
process of combining data and services to suit their individual requirements.
These tools are deployed to the Preconfigured OC4J
and available immediately to register with your application without additional
configuration. WebCenter’s versatile publishing tools include:
Rich Text / Blog Portlet: A
portlet that offers browser-based, rich text editing at runtime. It allows
users to author and publish formatted HTML on a JSF page. The Rich Text/Blog
portlet is a useful tool for blogging or for posting enterprise
announcements and news items. Once the portlet is added to a page, users
with appropriate permissions can edit text items directly in the page. All
the necessary editing tools are presented in place. Depending on the
security privileges set for the page, the Rich Text portlet can be used to
broadcast information (such as a simple blog) to a wide audience or to a
more narrowly defined group.
WebClipping Portlet: A
browser-based declarative tool that empowers business users to create their
own feeds with no programming required. In addition, users can use the
WebClipping Portlet to clip some information to determine whether they need
to ask IT to provide a supporting feed. Using the Web Clipping portlet,
users can create Web 2.0 mashups from nearly any source.
OmniPortlet: A tool
that allows business developers to quickly leverage Web services, RSS, and
XML feeds as data sources for their enterprise mashups. Using a wizard-based
approach, business users can quickly produce new mashups at runtime from all
the standard feeds that developers produce. In addition, developers can
easily build AJAX-based user interfaces and add them into the wizard for
users to select.
Runtime Customization
Customizable components provide the ability to customize the
behavior of the application at runtime. These components enable the site
administrator to make changes to the users’ view of the application content. For
example, the administrator may decide to hide a certain piece of content or move
a component from the bottom of the page to the top. These changes and settings
are then persisted for end users.
showDetailFrame: A
showDetailFrame surrounds one or more JSF and/or ADF components and can
provide a border and a header with a menu for actions such as minimizing the
content. A showDetailFrame component provides the following:
Minimize, maximize, and restore the display of the
contained component(s)
Header and border around the contained component(s)
Actions menu to perform specific tasks on the child component(s)
panelCustomizable:
A
panelCustomizable component
offers horizontal and vertical layout capabilities to a group of ADF
components. Similar to a showDetailFrame
component, a panelCustomizable component can display a header to
provide menu actions. A
panelCustomizable
component enables you to do the following:
Hide and show child components
Rearrange child components within the
panelCustomizable
component
Oracle MDS: Customization applied to the
application is saved to a metadata repository, Oracle’s Metadata Services
(MDS). All metadata, including base application definitions and runtime
customizations, is stored in the central metadata store.
Integrating Content using JCR 1.0
With the ratification of JSR 170, which specifies the Content
Repository for Java API and the Java Content Repository (JCR), access to content
becomes standardized and creating new applications that integrate content is
made much easier.
Oracle WebCenter Suite leverages the standard and provides an
easy alternative to pure coding against JCR APIs for content integration. Using
data controls (as specified by JSR 227), WebCenter hides the complexity of the
JCR standard behind this generic framework, making integration simply a matter
of dragging and dropping the relevant data controls into your application.
Adapters written to the JCR API standard provide access to the underlying
content system. As part of WebCenter Suite, you have access to five
repositories:
Oracle Content DB
OracleAS Portal
Sharepoint
Documentum
File system (development & testing only)
WebCenter Services
As part of WebCenter Suite, a wide range of Web 2.0 services and
tools is available for you to extend the functionality of your applications and
enrich the end-user experience. Earlier, we introduced some Web 2.0
services, specifically OmniPortlet, Web Clipping, and the Rich Text/Blog
Portlet. The following describes all the other Web 2.0 services that are
integrated within WebCenter Suite.
Secure Enterprise Search (SES): Oracle Secure
Enterprise Search 10g
enables a secure, high quality, easy-to-use search across all enterprise
information assets. You can integrate WebCenter applications (ADF
applications) into this unified search experience at two levels:
Crawler-Based Approach:
SES can crawl and index all content within all pages of the
application.
Custom Search Approach:
You can build a custom search UI in your WebCenter application by
using data controls to access the Web Services API that SES provides.
Oracle Communication and Mobility Server (OCMS)
Oracle Web Center provides a scalable telephony infrastructure that you can
use to embed telephony components such as call control and presence into
applications built with Web Center. Parlay X presence Web services APIs are
available to include presence information to any WebCenter-based
application.
Oracle Content Database: Oracle Content
Database (Oracle Content DB), the default content repository for WebCenter
Suite, is a full-fledged content management system that allows you to
professionally manage your content through the Web or from your desktop
applications. Use the Content Repository Data Control,
based on JSR 170, to access and display content from Content DB.
Discussions: Oracle WebCenter
Discussions has a rich set of APIs that allow developers to integrate Jive
Forums directly into JSF applications.
Wiki: The standards-based, open-source wiki
server that is included with Oracle WebCenter brings wiki capability to
WebCenter applications.
Declarative Security
ADF Security Wizard: The ADF Security wizard automatically
enables ADF Security and configures any authorization files or tags that
needs to be added to the XML files.
Authentication: ADF Security extends the default authentication
model of the J2EE container by supporting both an implicit and explicit
authentication process.
Authorization Editor: The Authorization Editor enables
developers to declaratively set policies (View, Customize, Manage, etc) for
a page based on user or role.
Lifecycle Tool
In terms of deployment, WebCenter applications behave exactly
like traditional J2EE applications except for the fact that, in addition to the
deployed application code, they include any customizations applied to the
application at runtime. Therefore, simply creating and deploying a packed EAR
file to the runtime environment is not enough, as this would not carry over the
customizations (both for the page and any portlets within the page). To address
this additional complexity, the WebCenter Framework comes with the Lifecycle
Tool to deploy the associated customizations along with the application itself.
There are three ways to deploy WebCenter applications:
Embedded Lifecycle Tool: The embedded
Lifecycle Tool allows the developer to deploy directly from Oracle
JDeveloper and is normally used for iterative development testing.
Command Line Lifecycle Tool: The
command line Lifecycle Tool is a stand-alone version intended for use on the
production server. This interactive tool walks the administrator through the
connections and rewires the application as required.
ANT Tasks: ANT Tasks incorporates the
Lifecycle Tool into ANT scripts, exposing WebCenter Lifecycle Tool’s
functionality through a number of ANT Tasks.
The following are a set of new features for the Java developer
in JDeveloper 10.1.3.1.0:
Keyboard word
movement, selection and deletion in code editor has been improved in
the following areas:
Word boundaries are now recognized when there is
repeated punctuation and (optionally) when there are case changes
An IDE Preference has been added to treat case changes
as word boundaries (disabled by default). This affects all move,
select, and delete by word commands, and double click selection.
The "Ctrl-Delete" key combination is now bound to the
"Delete To Next Word Start" command in the default keymap.
A project can now
be run even if compiler errors have been encountered. This feature is
disabled by default. Visit the Run/Debug configuration page in the
Project Properties to enable it.
This new release of JDeveloper provides extended support for
developing EJB 3.0 according to the final release of the JSR-220
specification:
The code editor
offers full annotation support with code-insight for EJB 3 (final
specification) annotations, including JAX-B 2.0 O-R mapping, and
JSR-181 web services annotations
Java Persistence API
Support for creating new persistence units
New Java Service Facade Wizard for generating a Java
class that wraps JPA entities and provides query and transaction methods
Ability to run JPA entities outside container using
Java Service Facade.
The
EJB 3.0 Entity Wizard has been extended with the following DB mapping
features:
Specify table name, or accept default
Specify PK field details
Optionally bind to a new (define on demand) or
existing generator
For table generator, specify field-specific
details
Define table or sequence generators (@TableGenerator
or @SequenceGenerator)
Define one or more new generators
Create offline DB objects into project to
represent each new generator
Option to create an @Version field
Support in the
Entity wizard for specifying inheritance details, allowing an entity to
be created as a root entity in a new inheritance hierarchy, or as a
subclass entity in an existing inheritance hierarchy. Standalone
entities that don't participate in an inheritance hierarchy continue to
be the default. The following options can be specified:
Abstract entity
Embedded entity
Superclass
Base superclass in entity hierarchy
o A base class has options to specify inheritance strategy,
discriminatorColumn and type details
o A concrete entity has the option to, specify a discriminatorValue
The EJB 3.0
deployment descriptors "persistence.xml" and "orm.xml" can be created
through the J2EE deployment descriptor editor, and packaged for
deployment.
Web Service support
for EJB 3.0 web services has been extended at design-time and run-time:
Design-time support for generating web service
interface with JSR-181 annotations for EJB 3 Session Bean:
Option to add a Web Service interface from the EJB
3.0 Session Bean wizard
Option to add or remove methods to a Web Service
interface
EJB 3.0 web services can be deployed to run in
embedded and standalone OC4J containers
A url is provided in the console window for quick
access to OC4J Web Service test page
BPEL Designer
JDeveloper (10.1.3.1.0) provides a visual BPEL designer to
model BPEL-based process flows and Web services orchestration. BPEL
processes can be executed on the Oracle Business Process Manager.
BPEL
modeler now fully integrated in the latest version of JDeveloper IDE
Single integrated install
Enables standard Ant (according to JDev Ant
capabilities, with support for a build properties file) and JUnit test
support
Check for updates now for BPEL as well
Usage of Application Server connection in the
Connections Navigator
A large number of
User Interface improvements have been added to the BPEL modeler:
Improved Look and Feel
Ability to "zoom in" on hierarchical elements. A BPEL
process contains several "container" activities, like scope, switch,
flow, etc. There is now a drill-down button the toolbar to drill down
on a specific part of your BPEL process and hide the rest.
Diagram properties to set the parameters for layout
optimization
New user interface for decision service, with option to
leverage Oracle Rules server
Support for Bookmarks to quickly jump to e.g. an
activity
Layout management improvements, allowing more of a
process graph to be viewed on a single screen
Support for organizing artifacts in a BPEL project in
the Application navigator
Search in BPEL
process
Ability to do a keyword search to quickly find elements
in large BPEL processes
Desicion services
as part of a process flow can now be implemented using the Oracle
Business Rules server
Human workflow
improvements
The editor to define Human Workflow aspects to a BPEL
process (e.g. such as e-mail notifications and decisions) has been
fully re-designed
ESB Designer
JDeveloper (10.1.3.1.0) adds a new tool to design ESB services
that enable message transformations, filtering, routing and
interconnectivity of web services or legacy applications via adapters.
ESB systems can be executed on the Oracle Enterprise Service Bus
run-time.
Full graphical
drag and drop operation
Visually build message flows, connecting message
sources to target services
Indicate message payload transformations, and define
them using the XSLT mapping tool
Add content-based routing rules to the message flows
using XPath expressions
Explore and edit XML artifacts (XSLT, WSDL...) using
JDeveloper's XML graphical viewer and editor
Advanced ESB
configuration tools
Dictionary-based graphical Xpath mapping tool with
built-in testing capabilities
Adapter configuration wizards that allow for graphical
introspection of the target systems, such as database tables or JMS
destinations, and automatic exposure as SOAP web services.
register ESB services (or synchronize them) directly
from JDeveloper simply by pointing to the target ESB runtime.
XSLT Mapping Editor
JDeveloper (10.1.3.1.0) provides a graphical environment for
defining XSLT transformations between XML documents.
Transformations are defined by visually connecting the elements of the
two schemas which are displayed side-by-side
Support for
renaming, merging and deriving elements
Can be used
to generate standalone XSLT mapping files, or mappings that are part of
an ESB system or BPEL process
This release introduces a
brand new look and feel for JDeveloper. The new look and
feel is based on JGoodies Looks and is the default for all platforms.
We've also applied
some fixes for the Windows L&F to make it more consistent with
Windows XP. Choose the
look and feel for JDeveloper from Tools >
Preferences, Environment
where you can also select a color theme for the JGoodies L&F.
You can also override
the Look and Feel at startup using -Dswing.defaultlaf=<laf_class_name>.
Icon artwork: All of the icons have
been redesigned in a new, trendy style to enhance the overall visual
appeal of JDeveloper.
Dialog headers: Many of JDeveloper's
dialogs sport a cool new header for the dialog's hint text and a
relevant graphic.
Drag and drop feedback: The visual
feedback provided when repositioning editor windows and dockable
windows has been improved. You now see an outline shape of where the
window will be placed when the mouse is released. You can also now
reorder the document tabs using drag and drop.
Fast maximize and restore: To quickly
maximize a dockable window or the editor area, double-click on the
title bar of the window you want to maximize. To restore the window to
its previous dimensions, double-click again on the title bar.
Title bars as tabs: The tab for a
dockable window (when tabbed with another dockable window) is now also
the title bar. This makes more effective use of the space on the
screen. Reposition a window by dragging its tab. Some additional
related enhancements include a new context menu from the gray
background area behind the tab, change in terminology from "auto-hide"
and "show" to "minimize" and "restore", ability to minimize a set of
tabbed windows with a single click, and toggling the display of a
minimized window by clicking on its button.
Double-click to split window: You can
now double-click on the splitter tool (at the top or right of the
editor scroll bar) to quickly split the document. As in previous
releases, double-clicking on the divider of a split document will
remove the split view.
Forward and back buttons: Now you can
easily return to a previously visited document with the convenient
browser-style forward and back buttons on the main toolbar. These
buttons maintain a history, so you can drop down the back or forward
button to get a list of the documents and edit locations you have
visited. Alt+Left and Alt+Right
activate the back and forward buttons.
Go to last edit: Easily return to the
last edit location using the Navigate > Go to
Last Edit command (Ctrl+Shift+Backspace).
Quick document switching: Switching
between documents has been improved. Now when you press Ctrl+Tab
or Ctrl+F6, you can choose which document you
want to switch from a list ordered by the most recently used. You can
use the same technique to switch between open dockable windows by first
placing focus in a dockable window, then pressing Ctrl+Tab
or Ctrl+F6.
JDeveloper 10.1.3 introduces intuitive new features for
providing users
better guidance for the product
Welcome/Start Page: The Welcome page
has been revamped to provide the user with quick access to help and
common tasks. Links from the Start page can directly launch
dialogs in the IDE.
Help Center: The Help
system has been reorganized
to provide all access to the help content (browsing through table of
contents, searching, favorines, etc) through one convenient window
called the Help Center.
Help bookmarks: The Help window has a
new tab labeled Favorites. While browsing the help, you can click on
the Add to Favorites button to add the
document to this tab.
Cue Cards: JDeveloper provides cue
cards, providing step-by-step instructions for completing a wide range
of tasks offered by JDeveloper.
Dynamic Help: Contextual help is
provided in the Dynamic Help window to assist in many tasks, and
provide topical reference materials and other supporting documents.
Tip of the Day: JDeveloper offers a
Tip of the Day dialog at startup containing tips and tricks for getting
the most out of JDeveloper as well as some notable features.
In previous releases, users have reported some hurdles in
working with projects in a
team development environment. JDeveloper 10.1.3 introduces a number of
changes to projects
to allow for effective team collaboration.
Dynamic projects: Projects are now
always "dynamic", meaning that the project stores a list of content
directories containing source files, rather than a list of files. In
previous releases, you could make a project dynamic by choosing the Scan
Source Paths to Determine Project Contents option. Now,
only dynamic projects are permitted.
Working sets: Working sets allow you
to configure the navigator to show you a subset of files from your
project. This is particularly handy when working with large projects.
Shareable and user-local properties:
The user now has control over whether certain project properties should
be shared. This allows users to override project settings without
impacting the rest of the team.
Global ignore list: The global ignore
list (Tools > Preferences, Global Ignore List)
identifies file name patterns that will not be considered to be a part
of any project.
Library management: With this release,
libraries definitions can now be stored in any file anywhere on disk.
The new flexible system allows for libraries to be source controlled
along with, or independently of, projects.
Performance: Improvements to many parts of the Version
control integration, especially in the Pending Changes
window.
Generate Local Patch: Generate Patch now works with all VCS
systems, and also from local history when not using a VCS system.
Perforce Import Project: You can now import a project into
Perforce .
Character Diff: The internal difference viewer now
optionally supports character-by-character difference display in
addition to line-by-line display.
Customizable History Filters: The local and VCS history UI
now supports customizable filters.
JDeveloper now has a History tab available for all text file
types. This local history
does not require a version control system to provide a recent change
history and visual
diff between versions. Versions are automatically created based on user
interactions such
as Save, Compile, Rename, Refactor, etc.
New Compare viewer: When you click on
the History tab for a file, you can compare the current version of the
file to a previous version using the Compare viewer. (You can also use
the Compare viewer to compare any two arbitrary files (File
> Compare With > Other File) or with
source control revisions. The Compare viewer now supports in-place
editing of the current document. The UI of the Compare viewer has been
redesigned with a more modern appearance and to provide support for
easily re-applying changes shown in the viewer.
Restore deleted files: Local history
allows you to recover files deleted from disk (if deleted using
JDeveloper). To restore a deleted file, right-click on the project and
choose Restore from Local History from
the context menu.
The new task window displays a list of tasks. The tasks can be
one of three types.
Source tasks are derived from your source code by looking for specific
strings (TASK,
TODO, and FIXME). You can add additional strings to the list in Tools
>
Preferences, Tasks. You can also create tasks that are
not embedded in a source
file by clicking the Add button in the
task window. These personal tasks
can be marked as completed and can have specific due dates. Finally,
you can create tasks
by right-clicking in the code editor margin and selecting Add
Task. These
tasks are associated with the specific source file and line number.
The new Print to HTML (File > Print to
HTML) feature allows you to
create an HTML document from the any type of source file. The HTML
document retains all
your syntax color and font settings. Visit Tools
> Preferences, Code Editor,
Printing HTML to set up your preferences for the
feature.
The File Types page in preferences has been redesigned. The
new page allows you to
specify which editor to use by default for file types, for example, you
could specify to
use the Source editor by default for XML Schema documents. You can also
use it to confirm
whether the file type should be treated as binary or text (for source
control operations),
and whether the file type is associated with JDeveloper on Windows
platforms.
File overview margin: The new file
overview margin appears to the right of the document scroll bar. It
provides quick navigation to bookmarks, breakpoints, tasks, syntax
errors and warnings located anywhere in the file -- even off the
screen. A summary block at the top indicates whether the file has 1 or
more errors (red), 1 or more warnings but no errors (yellow), or no
errors or warnings (green).
Multiple-file search and replace: Now
you can perform a search and replace on multiple files at once using Search
> Replace in Files.
Multiple icons in code editor margin:
Several JDeveloper features use icons in the code editor margin to
indicate something to the user. Some of these icons respond to mouse
clicks from the user. JDeveloper now supports having more than one icon
per line accepting mouse interactions. If you see an icon in the
margin, try clicking or right-clicking on it to see what it does.
Multiple Clipboard Buffers: JDeveloper
now supports multiple clipboard buffers via the Edit
> Extended Paste command.
Collapsible Code Regions: Code
regions can be collapsed to hide the details in the code
editor.
Anti-aliased text support: The code
editor can use Anti-aliased fonts for improved readability on some
displays.
A number of usability improvements have been made to the
product. In some cases we've made improvements to existing features and
in other cases we added new functionality to
enhance overall usability of the product.
Automatic detection of external tools:
On Windows, Tools > External Tools
will now automatically create buttons and menu items for common
applications (e.g. Explorer, Firefox, Notepad, etc). You can choose to
do this the first time you enter the External Tools dialog and you can
access this functionality any time by pressing the Find
Tools button in the dialog.
Environment variable support in external tools:
You may now use environment variables and Java system properties as
parameters to external tools.
Project from Existing Source wizard:
The Project from Existing Source wizard has been simplified and reduces
the learning curve to creating a new project using existing sources.
Progress indicator in status bar: A
progress indicator has been added to the status bar. This is used for
tasks that are running in the background.
Drag and drop in navigators: You can
now make use of drag and drop in the navigators. Specifically, you can
drag a project from one Application to another to move it (or Ctrl+Drag
to copy the project).
Optional Warning dialogs: Optional
warning dialogs can be permanently hidden by the user checking the Skip
this Message Next Time box when the dialog is displayed. You can
redisplay all hidden dialogs from Tools >
Preferences, Environment by pressing the Reset
Skipped Messages button.
Automatic saves: When you create new
files from JDeveloper, those files are now automatically saved for you.
Additionally, all your edits are automatically saved when you switch to
another application if you have chosen to activate the new Save
All When Deactivating or Exiting option at Tools
> Preferences, Environment.
Automatically expand nodes in navigator:
If when you expand a tree node in the navigator there is exactly one
child of that node, the child node will also be expanded.
Multiple-file undo and redo:
Multiple-file undo and redo were added in this release to support
refactoring and other actions which can modify multiple files in a
single action. If you are developing extensions for JDeveloper you can
take advantage of this new functionality by bundling multiple buffer
changes (which may span multiple documents) into a single Undo stack
command.
Run Manager improvements: The Run
Manager window now has a toolbar to stop the current process.
Authenticated proxy server support:
JDeveloper now supports authenticated (basic and NTLM on Windows) proxy
servers.
Improved source import: You can now
use File > Import to import source
code into an existing project.
The new refactoring framework allows for more powerful
refactoring, and performing
refactoring actions is faster and much smoother. Furthermore, the new
framework allows you
to optionally search in non-Java files and in comments and strings in
Java source files.
Before proceeding with a refactoring action, you now have the option
(off by default) to
preview the occurrences that will be updated. You can then elect to
continue with the
refactoring action or cancel it. You can even undo a refactoring if
needed.
Refactoring has been more tightly integrated with the IDE. For
example, you can now
right-click on a method or field in the Java Structure window and
choose Refactor
> Rename from the context menu to initiate a
refactoring. Similarly,
you can
right-click on an identifier name directly in the editor and press Ctrl+Alt+R
to
rename it using a refactoring, or press Ctrl+Alt+U
to find usages of
the identifier. When refactoring or finding usages of code
elements, JDeveloper
searches your
entire project and any projects that are listed in Tools
> Project
Properties,
Dependencies.
Additionally, refactoring is seamlessly integrated with your
source control system. So, for example, if you rename a class that is
being referenced from a source file that isn't
checked out, JDeveloper will offer to check the file out for you so the
operation can
proceed.
The following new refactorings are available:
Rename Class: Renames a class, its
constructors, and its source file and updates all references to the
class in the project. Note, the Rename Class refactoring has been
available since JDeveloper 9.0.2, but it now uses the new refactoring
framework.
Rename Field: Renames a field and
updates all references to the field in the project.
Rename Method: Renames a method and
updates all references to the method in the project.
Rename Package: Renames a package and
updates all references to the package in the project (including
organization of sub-packages).
Rename Local Variable: Renames a local
variable and updates all references to the variable.
Rename Parameter: Renames a parameter
and updates all references to the variable.
Introduce Variable: Replaces the
selected expression with a new local variable.
Introduce Field: Replaces the selected
expression with a new field. It also offers to replace all occurrences
of the selected expression with the newly introduced field.
Introduce Constant: Replaces the
selected expression with a new constant.
Introduce Parameter: Replaces the
selected expression with a new parameter.
Extract Method: Creates a new method
from the selected code, setting up parameters for any variables that
need to be passes to the new method.
Extract Interface: Creates a new
interface from any of the public methods in the current type definition
and implements that interface for the current type.
Move Class: Moves the current class to
another existing package or new package and updates all references.
Move Class has been available since JDeveloper 9.0.2, but it now uses
the new refactoring framework. You can move instance as well as static
methods.
Use Supertype Where Possible: Replaces
all occurrences of a type with one of its supertypes if applicable.
Pull Members Up: Promotes the
declaration of methods or fields to the supertype and updates
references accordingly.
Push Members Down: Moves the
declaration of methods or fields to all the subtypes of the current
type and updates references accordingly.
Duplicate Class: Creates a new type
definition based on the current type.
Delete Safely: Checks to make sure
that the element you are attempting to delete is not actually being
used in your code before allowing the delete operation to proceed. If
references are found, you will be warned and given the option to cancel
the delete operation. Delete Safely can be used when deleting types,
methods, and fields.
Drag and Drop Refactoring: You can now
drag and drop a classes in the navigator to refactor them into a new
package.
Change Method: You can now change the
signature of any method, and can combine 2 overloaded methods into one
method.
Multiple Selection refactoring: You
can select multiple classes in the navigator and refactor them
all.
Inline Constant: Replaces a constant
with the literal value.
Inline Variable: Replaces a local
variable with the literal value.
Inline Method: Replaces a method call
with the contents of the method.
Make Static: Transforms an instance
method to a static method, optionally adding a parameter for the class
instance, if required.
Convert variable to field: Introduce
variable will convert a local variable to a class field.
Move to top level: Changes a
secondary or inner class to a top level class.
Encapsulate Fields: Encapsulates the
access of fields with accessor functions.
Convert Anonymous to Inner: Converts
an anonymous inner class to a named inner class.
Replace Constructor with Factory Method: Adds
a factory method to create a class and makes the existing constructor
private.
Find Usages: Find Usages complements
refactoring by allowing you to locate references to a given symbol
across the project. It uses the same framework as described above for
refactoring and offers the same benefits. The results of a Find Usages
action are displayed in the Log window. JDeveloper can find usages of
classes, fields, methods, variables, and parameters. Note, Find Usages
of Class has been available since JDeveloper 9.0.2 (previously accessed
via Tools > Show Dependencies), but it now uses the new
framework.
Hierarchy Browser: You can now find
out the inheritance tree information for a selected class or interface
by opening it in the new Hierarchy Browser. You can either see the
supertypes (super classes, interfaces) for the selected type, or you
can choose to see the subtypes (subclasses, implementations) for the
selected type. You can open the type hierarchy for an arbitrary type
using Navigate > View Type Hierarchy,
or you can right-click on a type name in the code editor and choose View
Type Hierarchy from the context menu.
Implemented and overridden margin markers:
Methods that override a definition from a supertype or implement a
declaration from an interface have callout icons in the code editor
margin. To navigate to the supertype definition or interface
declaration of the method, you can simply click on the icon in the
margin.
Navigation between members: You can
quickly navigate between fields and methods by using the Previous
Member (Alt+Up) and Next Member (Alt+Down)
accelerators. There are also commands available for Next/Previous
Method and Next/Previous Field in case you want more control, but no
accelerators are mapped to these commands by default.
Code Highlight: JDeveloper will
highlight the relevant source items (locations where an exception is
thrown, instances of the currently selected variable or method, etc.)
based on the current cursor selection.
Usages working set: You can create a
working set from the results of a Find Usages execution.
Searchable Class and Package Dialogs: The
class and package browser dialogs are now fully searchable and support
camel case naming.
Hyperlink Navigation: You can now use
ctrl+left mouse click to go to a
declaration.
The System Navigator has been redesigned to provide a
Java-centric view of your
application. Source files (and resource files such as images,
properties files, xml
documents, etc) are displayed in a package view. The "flatness" of the
package
view can be adjusted by setting the Flat Level in the toolbar (defaults
to 3). You can
choose to display sources organized by source directory or as a
combined logical source
path. You can also choose to see libraries represented in the
navigator.
Code Assist examines your code in the editor and provides
assistance to fix common problems and makes offers to automate common
coding changes. A light bulb icon appears in
the code editor margin when JDeveloper has a suggestion for a code
change. Code Assist can
be invoked manually using Ctrl+Alt+Enter.
Examples of Code Assist include
offering to create a new class or interface when an unknown class is
used, add
missing Javadoc comments and tags, and invert conditional test in and
if statement.
Many other
Code Assists are available -- check the documentation for more details
or simply
take a
look in Tools > Preferences, Audit, Profiles.
You can control
how Code
Assists are displayed in the editor (or disable them completely) from Tools
>
Preferences, Audit.
Implement Method: Suggestion to add a
method when an call to an unimplemented method is encountered.
Implement Interface: Suggestion to add method or make class
abstract when missing methods from an implemented interface are
encountered.
Use JDK 5 loop: Converts for loops to
use the new JDK 5 syntax.
Expand Statement: Adds semicolons to
statements, code blocks for loops, and any other missing constructs
around a section of code.
Use JDK 5 autoboxing: Removes unneeded
calls to Integer and other Object primitives.
Code Templates just got a whole lot more interesting! You can
now define code templates with predefined hot-spots that you can
quickly tab through when expanding the template.
These hot-spots (variables) can take advantage of new utility macros to
provide smart
default values. For example, try typing fori
followed by Ctrl+Enter in
the code editor. You can edit or create new Code Templates from Tools
>
Preferences, Code Editor, Code Templates. Also, code
insight is now
available for the template names.
Javadoc tag insight: JDeveloper
provides code insight for javadoc tags. Pause or press Ctrl+Space
after typing the symbol "@" in a javadoc comment
to get javadoc code insight.
Expand and collapse selection: Ever
need to quickly select the entire string you are currently editing?
What about grabbing the entire method that you are currently working
on? Now you can easily expand your selection to the next logical
boundary by simply pressing Ctrl+Shift+NumPlus.
For example, if your insertion point is located in a text string that's
part of a parameter to a method call, press Expand Selection once to
grab the current text string. Press it again to select the arguments,
again to select the method call, and again to select the expression
including the method call, and so on. If you expand the selection too
much, you can use Collapse Selection (Ctrl+Shift+NumMinus)
to restore the previous selection.
Smart type-over: When you type an open
parenthesis ((), open brace ({),
or double quote ("), JDeveloper will automatically
add the matching symbol for you. If you then type that symbol anyway,
JDeveloper will recognize it as a duplicate and type over the existing
character.
Smart line split: Pressing Enter
while the insertion point is inside a quoted string causes the string
to be split into the next line with the concatenation character being
used to appropriately join the string.
Convert case: New commands have been
introduced to the editor that convert the case of the selected text to
upper or lower case. There is no pre-defined accelerator for these
commands. Use the Tools > Preferences,
Accelerators panel to define a key mapping.
Automatic highlighting of current block's enclosing
parenthesis or braces.
Automatic imports on copy-paste: When
you copy and paste code between code editors, JDeveloper automatically
adds the required imports to the new location.
Automatic indention: When you paste
code, it is now automatically indented into your file.
Smart Paste: When you paste a string
literal into you code, it is automatically wrapped with double-quotes
and escaped when needed.
Smart Insight: Code insight that
restricts the results to members that can be used specifically in the
given context. [invoked with control-alt-space]
Pluggable compiler: You now have the
option to use javac or ojc as the compiler for each project. The
setting can be found in the Compiler page of the Project Properties
dialog.
Clean output path: You can force
JDeveloper to remove all the files from the project's output directory (Run
> Clean <Project>). This is useful
when one or more resources have been removed from the project, but the
compiled output still remains. Use with caution; this command cannot be
undone.
Improved error log: The compiler
error log from building a project or workspace is now saved when you
subsequently compile only a single file.
Method execution: During a debugging
session you can now evaluate expressions involving method calls from a
breakpoint condition, a breakpoint log expression, the Watches window,
an Inspector window, or an object value expression. This feature can be
used with both Hotspot and OJVM.
Class loader information: The debugger
can now show information about the class loaders used to load classes
during a debug session. To see class loader details right-click on a
class in the Classes window and choose Watch Class Loader
from the context menu, or enable the Show Class Loaders
option in Tools > Preferences, Debugger, Classes
to see the class loaders in the Classes window. Also, you can see the
context class loader for a thread by right clicking on a thread in the
Threads window and choosing Watch Context Class Loader
from the context menu.
Watchpoints: Watchpoints allow you to
pause the debugger when the value of a specified field is accessed or
modified. Set a watchpoint by right-clicking on a variable in the code
editor and choosing Toggle Watchpoint
from the context menu.
User-defined expressions for object values:
You can specify an expression for the debugger to use for displaying
the value of an object. While debugging, right-click on an object in
the Data window and choose Object Preferences
from the context menu. Select either to evaluate the toString() method,
or enter a custom expression.
Automatic Sequence Diagrams: JDeveloper
can automatically generate sequence diagrams of you code as you step
through it in the debugger.
The JDeveloper profiler, CodeCoach and certain advanced
debugging features require
Oracle's OJVM. Now you can easily install OJVM into a J2SE. When you
create a new J2SE
definition (Tools > Manage Libraries),
you will be prompted to choose
whether to allow JDeveloper to install OJVM into that J2SE.
JDeveloper makes it easier than ever to integrate with the
enormously popular Ant tool.
Code insight: While editing an Ant
build.xml file, you can take advantage of code insight. Code insight is
provided for tag names, attribute names, property names, and
properties.
Component Palette support: When you're
working on an Ant build file, you can use the component palette to
easily drop in tags to the build file. You can also access the tags to
edit them from the convenience of the Structure window and Property
Inspector.
Specify Ant version: The Production
release ships with Ant 1.6.5. If you need to use a different version of
Ant, you can point to the your own Ant installation from Tools
> Project Properties, Ant, Options.
Set classpath and properties: From Tools
> Project Properties, Ant you can specify the
classpath for Ant to use, as well as identify properties and property
files to be available from Ant scripts. You can also determine whether
Ant should run in the same process as JDeveloper or in a separate
process.
Integrated Ant runner: A new
integrated Ant runner provides a wizard to setup the Ant environment
and to specify which target(s) to run. When Ant is run, the color-coded
output is integrated with the Log window with links to the Ant script.
A drop-down list of targets is available from the toolbar for quick
access to Ant.
Property Tooltips: If the value of an
ant build.xml property can be derived, it is displayed as a tooltip in
the editor.
Input Support: While running an Ant
build script, GUI dialogs are used to provide values from the ant input
task.
Improved Structure Pane: You can sort and filter targets
and properties, as well as directly execute a target from the structure
pane.
Ant Toolbar: A customizable list of
targets is available from the drop down on the Ant toolbar
button.
External Tool Support: You can now
run an ant task as an external tool in JDeveloper, making it available
from any context menu.
OC4J JSR-88 Support: OC4J's JSR-88
ant tasks are now included with JDeveloper.
Execute imported tasks: You can now execute a task imported
from another build file.
Automatic add-to-ant-classpath support: Jar files located
in ${user.home}/.ant/lib are now
automatically added to Ant's classpath if desired.
Now it's much easier to create JUnit tests for your code. Note
that JUnit is not
installed in the product by default. To install JUnit, choose Tools
> Check for
Updates. Select the update center to download and
install the JUnit extension.
Smart test class selection: When you
invoke the Create Unit Test wizard, the active class is the presumed
test class. If a package is selected in the navigator, the list of test
classes is populated with all java files in the active package.
Easily select test methods: The
methods list automatically shows all the methods in the classes,
grouped by superclass. You can select the class node to select all
methods in the class.
Optionally generate method stubs: New
options for generating a main method, TestRunner statements, and
setUp() and tearDown() methods. The first 2 options make it easy for
you to run a single test case without adding it to a Test Suite and
then running that. This applies to both the Create Test Case wizard and
to the Create Test Suite wizard.
New Method Test command: Creates a new
test case for a method selected in the code editor or in the Structure
pane.
Refresh Test Suite command: Adds
available Test Case classes to the selected test suite from the code
editor or from the Navigator context menu.
Integrated JUnit runner: A new
integrated JUnit runner provides a graphical UI as a dockable window.
The JUnit window shows the overall test status with drill-down
capabilities to each test. For failed tests, the window displays the
expected and actual values.
Single Method test: You can test a
single test method within a testcase without needing to execute the
entire testcase.
JDeveloper has renewed focus on the integration with source
control systems in general,
and CVS in particular.
Use recent CVS comment: When
committing to CVS from the dialog or the Uncommitted Files Window,
previously entered comments will be available via an insight list. The
insight list will appear if you type the first letters of a previous
comment, or click the Use Recent Comment
context menu item.
Copy CVSROOT to clipboard: You can now
copy the CVSROOT for a CVS connection to the clipboard by right
clicking the connection and choosing Copy CVSROOT.
CVS global exclude filters: A new CVS
preferences page, Exclude Filters can be used to globally configure
file name patterns that will never be imported to CVS.
CVS patch support: Functionality has
been added to make it easier to create and apply patches across
multiple files or for the whole project. Open source projects typically
use patches for change submissions. The Versioning
> Patch > Generate Patch command creates a
patch between your local changes and the repository. Versioning
> Patch > Apply Patch displays a preview
dialog that summarizes the changes a patch will make to your project
using the new compare viewer, then allows you to apply the patch.
Create local CVS repository: You can
now create a local repository using the Versioning
> Create Local Repository.
New CVS Navigator: JDeveloper can
browse the contents of local and remote CVS Repositories and perform
operations (like checkout modules and viewing files) directly from the
repository.
Internal CVS client: Oracle has
written a pure Java implementation of the CVS Password Server client
and also integrated a native pure Java SSH2 client with support for
generating SSH public and private keys. This removes the requirement of
having ANY CVS software installed to talk to a remote CVS repository.
Struts support in JDeveloper has been significantly
enhanced.
Multiple Struts configurations: Now
you can effectively manage multiple struts configuration files in the
same project.
Struts refactoring: Refactoring
implementation Java classes will also refactor your Struts
configuration files to keep your configuration files in sync with
changes made to your related Java classes.
JDeveloper 10g 9.0.5 introduced XSLT debugging, but users
needed to download and
install a different XDK from what was delivered in the product. That
extra step is no
longer necessary with 10.1.3. Furthermore, you can now step into
embedded Java while
debugging XSLT for a seamless XML and Java debugging experience.
JDeveloper can now generate an XML instance document from a
registered XSD schema
document or from any arbitrary XSD. Choose XML Document from XML Schema
from File
> New, General, XML. Select a schema already
registered with JDeveloper or
browse to locate any schema.
JDeveloper includes easy access to JAX-B. Select an XSD schema
document in the
navigator and choose Tools > JAX-B Compilation
to create
a Java API
for the selected schema.
The Oracle XML Developer Kit (XDK) is bundled with JDeveloper.
This release of
JDeveloper includes the Oracle XDK 10g Release 2 version which offers
new support for DOM
3.0, XSLT 2.0, and StAX. Refer to Oracle Technology Network (OTN) for
more information
about Oracle XDK (http://www.oracle.com/technology/tech/xml/xdkhome.html).
Register and unregister schemas: You
can register XSD schema documents with Oracle XML Database (XDB) by
selection the schema in the navigator and choosing Tools
> Register Schema with XDB. During the
registration process, you can request for JDeveloper to create Object
Types or database tables based on the schema.
Oracle XDB annotations: Oracle XDB
annotations are now visible and editable in the Property Inspector.
Display Error and Warnings in code editor: Errors
and warnings are now underlined in the code editor and structure pane
as you edit an XML document.
Improved Dialogs: Dialogs for
creating and editing XML elements have been improved, and new dialogs
for adding and editing comments, text, and processing instructions have
been added.
Simplified Schema Validation: An XML
schema doesn't have to be registered with the system in order to
validate an XML document against it.
JDeveloper provides a preview implementation of JSR-198 (A
Standard
Extension API for Integrated Development Environments). This
specification is still under development, but JDeveloper is expected to
provide a reference implementation of the
specification once it is finalized. JSR-198 allows third party
extension writers to use a common, standard API to integrate
functionality with any IDE supporting JSR-198.
The bundling and delivery of extensions in JDeveloper conforms
with the latest revision
of the JSR-198 specification. Extensions are now self-contained units;
an extension can
now provide all its functionality via a simple zip file extracted into
<jdev_install>\jdeveloper\extensions. JDeveloper persists
settings for extensions in
separate directories in the user's system directory.
JDeveloper's Help > Check for Updates
command has been improved.
The JDeveloper team plans to rely more on the Check for Updates tool to
provide extensions
and updates to users, and third party extension developers can take
advantage of this as
well.
XML-based update center: Update
centers are now simple XML documents reachable via a URL. This
simplified approach makes it easier for teams to host their own update
centers. You can even point to an update center XML document on your
local file system.
Multiple update centers: You can
configure JDeveloper to remember multiple update center URLs, and
search for updates from any of them.
UI improvements: Various UI
improvements to the wizard make the tool easier to use as well as look
a whole lot better!
Installation into Oracle home:
Previously extensions installed from the update center always resided
in <jdev_install>\jdev\lib\ext. Now
extension developers can specify to install the extension into the
Oracle home (<jdev_install>).
Custom Installation Code: Code may
now be executed programmatically during the installation steps of the Check
for Updates wizard.
Automatic Restart: JDeveloper will
now automatically restart after using Check for Updated
if a restart is required.
Authenticate for OTN: JDeveloper only
prompts for an OTN login if an update from OTN is selected for
installation
Proxy Settings Help: If JDeveloper
can not connect to the Check for Updates
servers, you are guided to setting the proxy server.
General
Extensions Improvements
About Box Improvements: The
Extensions page in the About Box displays the reason an extension is
disabled (for example: a failed dependency on another
extension)
Extensions Log Page: When an extension manifest contains an
error, a log page with a hyperlink to the extension.xml file is
displayed at startup.
Command line configuration: You can
now set the system properties ide.extensions
and ide.noextensions to enable or disable
extensions from the command line when JDeveloper starts (in addition to
using the new simplified Extensions page in the IDE's preferences)
Migration of old extension manifests: Create
extension.xml is a context menu item on jdev-ext.xml
documents to migrate the deprecated extension manifest format to
10.1.3/JSR-198
JSR-198 javadoc: The Javadoc for
JSR-198 is included with the JDeveloper Extension SDK.
Simplified Addin class: The Addin
class has been moved to oracle.ide and
streamlined to only include 1 method: initialize().
JDeveloper now supports developing and deploying JSP 2.0 and
Servlet 2.4 applications.
.tag file support: Create and edit
.tag files for improved manageability of JSP tags.
Visual Expression Language (EL) editor:
A new EL editor dialog simplifies the task of creating valid JSP 2.0 EL
expressions.
Visual prelude/coda and include support:
From the Web module editor, you can configure property groups and
specify pages to use for prelude and coda. The JSP Visual editor can
render the prelude and coda content, as well as content derived from a
JSP include. By default prelude and coda are not shown in the editor;
go to Tools > Preferences, JSP and HTML Visual
Editor, Invisible Elements and select the Show
Content Outside the Body Tag option to enable this
feature.
Project-based JSP tag libraries:
JDeveloper is now able to provide full design time support for custom
JSP tag libraries included in your web module.
Visual CSS editor: The CSS editor now
has a Preview tab with sample HTML content. This new feature allows you
to quickly confirm changes made to your style sheet. Code insight is
available from the CSS Source editor.
JSTL 1.1.1 (JSR-52) bundled: The
standard JSP tag library (JSTL) 1.1.1 is now bundled with JDeveloper in
addition to JSTL 1.0 and appears on the Component Palette for easy
access.
JSP debugging (JSR-45): The JSP
debugging offered by JDeveloper and OC4J has been updated to comply
with the new JSR-45 specification for multiple language debugging.
Struts Tiles support.
Improved inspector experience with friendlier custom
dialogs and easier method binding.
Page template support for creating custom master templates
and editing template-based pages.
JSP audits to catch and fix common JSP library
configuration issues.
Refactoring support for web.xml.
Navigation bar for quick selection in a hierarchy.
Improved editing experience of J2EE and OC4J deployment
descriptors
Visual UI component editing: UI
components can be manipulated directly from the new JSF WYSIWYG editor,
from the Structure window and from the Property Inspector. You can also
drop new JSF components onto pages using the Component Palette. You can
optionally request for JDeveloper to automatically create and manage
the backing code for JSF, or you can do so manually. A JSF-aware
Expression Language (EL) editor dramatically simplifies binding the JSF
components to a data source.
Visual JSF navigation development: A
visual diagrammer is provided for rapid development of JSF navigation.
Overview editor: An Overview editor
allows for friendly manipulation of all aspects of the faces-config.xml
file.
The JSF code editor supports collapsible code
blocks.
JDeveloper 10.1.3 supports deployment and management of
Application Servers utilizing the JSR-88 and JSR-77 specifications. You
may now use JSR-88 to connect to Oracle Containers for J2EE (OC4J)
10.1.3. Once connected the newly created connection node functions as
JMX browser to view the existing and newly deployed applications via
MBeans. You can
start, stop and undeploy applications from the connection.
Incremental Deployment: Support for
incremental deployment where existing JARs on the server are updated.
OPMN Deployment: Deploy to OPMN
connection, including support for deployment to clustered environments .
JCA Deployment: JDeveloper will
create and deploy RAR files .
The new UML Sequence modeler helps to document interaction
between classes. A user
friendly interface supports rapid sketching of systems. Additionally,
connect the modeler
to the Debugger to visually debug application.
The Use Case modeler now supports the creation of Subjects in
the form of system boundary and milestone templates. You can create use
cases insides these 'containers' in a
new diagram, or add them to existing diagram, and move use cases inside
them. The images used within the Use Case modeler is also now
configurable.
All of the JDeveloper modelers have benefited from a number of
common usability
enhancements.
Improved Look and Feel: The look and
feel of all modelers has been greatly improved.
Drag and Drop: When moving a shape on
a diagram (for example, a class, an activity) you now see the lines
between shapes (for example, associations, flows) tracking the movement
of a shape. This allows you to see what will happen when you drop the
shape.
Modeling Toolbar: The diagram editor
now boasts a toolbar that supports common visual property editing such
as color, font, zoom and layout.
Drop zone highlighting: When adding
elements to a diagram, or joining two shapes together (for example,
classes to classes with an association) you get visual feedback in the
form of a gray element outline when you move the cursor over a valid
element.
Diagram Preferences: The diagram
preferences sub-system (Tools > Preferences
> Diagrams) has been completely redesigned to
increase usability.
Property Inspector Support: The
modelers now expose properties via the property inspector
Auto Layout improvements: The
automatic layout has been refined to provide a more reasonable layout
for the diagram shapes
As well as being able to import class models from a number of
different source tools,
you can now export UML class models to OMG XMI format XML. The utility
supports XMI 1.1
and UML 1.3, 1.4, and 1.5.
SCM integration with modeling artifacts such as diagrams
elements and the diagrams
themselves has been incrementally improved. As well as better
identification of locked
elements, there is also support for auto-checkout when editing elements
and mergeable
diagram files.
Importing schemas from a database is more performant than in
previous versions, and you may now customize and save a profile to use
when generating SQL scripts.
Foreign Database Support: JDeveloper
can now additionally import and model objects from MS SQL Server,
Sybase, IBM DB2, IBM Informix, MySQL, and TimesTen in
addition to Oracle databases.
Declarative View Builder: JDeveloper
supports creating and editing database Views either from the View
Wizard or from the Database Diagrammer, featuring two-way
synchronization between the UI model and the underlying SQL query.
Additionally, the query builder supports ANSI joins in addition to the
standard Oracle join syntax.
Automatic Scripts: ALTER SQL scripts
are automatically generated when required.
Database Modeling: The database
modeler now supports the creation, generation, capture, and
visualization of the following objects (in addition to tables, columns,
and keys): Views, Sequences, Synonyms, Indexes, PLSQL Packages,
Procedures, Function, User-Defined Types, XML, Spatial, and Media
System-Defined Types.
Graphical Compare: JDeveloper now
offers an UI for visually comparing the offline database objects with
the online schema, allowing changes to be selectively applied instead
of an all-or-nothing approach to database reconciliation.
Dependency Support: A smart
dependency engine analyses interdependent changes, such as columns in
constraints
Live Data Editing: The Data tab in the
table editor now allows you to edit the data and commit the changes to
your database.
This new release of JDeveloper supports developing of J2EE
1.4-compliant Web services, with the ability to create JAX-RPC clients
and services. The Web services creation wizards
have been updated to provide J2EE 1.4-specific choices, and the
navigator has been upgraded to efficiently manage large sets of JAX-RPC
files. In addition JDeveloper
automatically generates web service metadata tag annotations into
implementation classes
(for future compliance with JSR-181). The wizard allow supports
defining custom handlers, serializers and deserializers, and MIME/DIME
attachments.
Web Services Wizards: JDeveloper includes new wizards for
WS-Security, WS-Reliability, and WS-Management allow users to set
security, quality of service, and logging properties for the Web
services before deployment.
SAML Security: Support for SAML
security in the WS Security wizard (e.g. for developing SSO WS
applications)
Now you can develop Web services from the bottom up. New
support for meta data tags in
your source code allow for automatic generation and publication of the
WSDL directly from
the source.
You can now do contract driven development using the new WSDL
Editor. The editor includes support to add WSDL elements from component
palette, to change properties via property inspector, and to navigate
from structure pane.
ADF Data
Binding
JSR 227 Preview
JDeveloper 10.1.3 provides the class libraries, Javadoc and
preview implementations of JSR 227.
The JSR 227 specification, which is currently in the internal review
phase, defines a standard facility for binding clients to data sources.
All ADF data controls and bindings implement the JSR 227 interfaces.
JavaServer
Faces Support
JDeveloper 10.1.3 has full support for creating data-bound
JavaServer Faces (JSF) pages using ADF Data Binding. Available
functionality includes:
Drag and drop data binding: Drag and
drop attributes, collections and operations from the data control
palette onto a JSF page to create databound components.
ADF Faces component library: The ADF
Faces rich component library is seamlessly integrated with ADF
databinding, allowing you to create databound ADF Faces components out
of the box.
New components: New databound components
that were not available in previous component libraries include
editable table, and master table with inline detail.
Custom forms and tables: New editors
allow you to edit the ordering, labels and displayed attributes in
data-bound forms and tables before the components are added to the page.
New data
control types
New data control types make it easy to create data controls
for several new types of data sources:
EJB 3.0 session beans
URL Datasource for XML and CSV (comma separated variable)
files, such as data exported from a spreadsheet.
Create custom
data bindings and data controls (JSR-227)
The JSR 227 APIs and metadata files provide a way to create
custom data controls to new business service types; and to make
additional visual components available for drag and drop databinding.
Support
for multiple TopLink mappings
In projects that have multiple TopLink mappings, you can now
create different data controls for each mapping.
Support
for standard web services security
Using the new web services data control security wizard can
configure security for web services data controls.
Control Hints
Control hints that were previously available only in ADF
Business Components can now be set at the ADF databinding level for any
type of data source. The following control hints are available:
Declarative validation rules
Formatting hints for date and currency
Label text
Show and hide attributes
Sorting hints
"UI first"
binding
Use drag and drop databinding to add bindings to existing
faces components in a page, or change the binding for an existing
databound component. This allows you to build your user interface
before adding databindings.
Find Mode
Find mode is available for data controls other than business
components.
Undo, redo
and refactoring
Full undo and redo support: the undo command changes all files
that were affected by the last operation.
Enhanced
page-level bindings
Control the order in which iterators execute
New variable bindings and page parameters
Simplified method invocation
Null
values in list bindings
The list binding editor has been enhanced to allow the
inclusion of a null or empty value in a selection list.
Databinding authorization
You can now set permissions on iterators and bindings.
ADF
Business Components
Named
bind variables
Define meaningfully named, typed bind variables for VO
queries, provide them with default values, bind values to them
declaratively or programmatically
at runtime as well as in the Business Components Tester.
Declarative
Query Builder
A new declarative query builder makes it easy to build complex
view object queries.
Simplified
Team Development
Some high-contention files have been eliminated, removing team
development bottlenecks. When modifying business components, all
relevant files are seamlessly checked out of version control.
Improved
runtime features
Improved runtime control for in-memory filtering and sorting
of rows, and new control to fetch details for multiple masters in a
single query.
ADF Swing
JGoodies layout
management
ADF Swing developers can now select the JGoodies FormLayout as
the layout manager for their swing containers. FormLayout greatly
simplifies the task of laying out Swing panels easily and consistently.
Simplified
deployment
In the past, deploying an ADF Swing application entailed
deploying the ADF runtime libraries, and then packaging and deploying
your application class files. This process has been simplified so that
you no longer need to deploy the ADF runtime libraries as a separate
step; instead, they are automatically packaged with your application
files.
Reusable
Regions
JDeveloper 10.1.3 makes it easy to create reusable regions:
data-bound panels that can be added to the component palette. These
regions can then be dropped from the component palette into new frames.
Customize
table column renderers
You can now use the databinding editor to declaratively
customize the way columns in a data-bound table are rendered: for
example, as text fields, spinners or dropdown lists.
ADF Faces
Oracle ADF Faces is a rich set of user interface components
based on the JavaServer Faces standard (JSR-127). The ADF Faces
components provide various user-interface components with built-in
functionality - such as data tables, hierarchical tables, and color and
date pickers - that can be customized and re-used in your
application.
ADF Faces ensures a consistent look and feel for your
application, allowing you to focus more on user interface interaction
rather than look and feel compliance. The components support
multi-language and translation implementation as well as accessibility
features. ADF Faces Components use Partial Page Rendering (PPR)
offering superior runtime interactivity. PPR allow the browser to just
render a piece of a page instead of the entire page.
With the release of
Oracle Application Server 10g
R3 (10.1.3), Oracle introduces Application Development Framework Mobile
(ADF Mobile), a new standards-based framework for rapidly developing
enterprise mobile applications. Built upon the component model of Java
Server Faces (JSF), ADF Mobile allows J2EE developers to quickly build
applications for PDA browsers, 2-way messaging devices and industrial
handheld devices running Telnet.
Bookmark
