What's New in Oracle JDeveloper 10g Release 3 (10.1.3) Early Access 1
 Oracle JDeveloper 10g Release 3 (10.1.3) Early Access 1 marks a huge step forward for JDeveloper in terms of developer productivity, user interface and standards support. This document lists the new features in the Production release. This is not intended to replace the documentation for the product, but rather be your tour guide as you explore the many exciting new features. Note that features new since the preview release are indicated with: (new).
Note: All the keyboard shortcuts mentioned in this document are based on the default key mapping. You can map individual commands to specific key combinations, or choose from one of several preset keymaps from Tools > Preferences, Accelerators.
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 are being 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
- Help Center/Welcome Page: The Welcome page has been transformed into the JDeveloper Help Center, revamped to provide the user with quick access to help and common tasks. Links on the Help Center can now directly activate dialogs and wizards in the product. (new)
- 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.(new)
- 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. (new)
- 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. (new)
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. (new)
- Generate Local Patch: Generate Patch now works with all VCS systems, and also from local history when not using a VCS system.(new)
- Perforce Import Project: You can now import a project into Perforce .(new)
- Character Diff: The internal difference viewer now optionally supports character-by-character difference display in addition to line-by-line display.(new)
- Customizable History Filters: The local and VCS history UI now supports customizable filters.(new)
- Implicit Sandbox Connections: JDeveloper can create a connection from your CVS sandbox automatically.(new)
- UI for CVS HTTP Proxy: The settings for enabling HTTP proxy in CVS 1.12 and CVSNT is now exposed in the CVS connection UI.(new)
- Internal SSH over HTTP: The Internal CVS-SSH support now supports HTTP proxy servers.(new)
- Internal SSH-password Supports: The internal SSH support now supports passwords in addition to public-private key pairs. (new)
- Internal 3-way CVS merge: JDeveloper provides an internal 3-way merge for CVS .(new)
- CVS Replace With: You can replace your working copy with another version from CVS in the UI. (new)
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. (new)
- Collapsible Code Regions: Code regions can be collapsed to hide the details in the code editor. (new)
- Anti-aliased text support: The code editor can use Anti-aliased fonts for improved readability on some displays. (new)
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. (new)
- 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.(new)
- Authenticated proxy server support: JDeveloper now supports authenticated (basic and NTLM on Windows) proxy servers. (new)
- Improved source import: You can now use File > Import to import source code into an existing project.(new)
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 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. (new)
- 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. (new)
- Use Supertype Where Possible: Replaces all occurrences of a type with one of its supertype's 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. (new)
- Change Method: You can now change the signature of any method, and can combine 2 overloaded methods into one method. (new)
- Multiple Selection refactoring: You can select multiple classes in the navigator and refactor them all. (new)
- Inline Constant: Replaces a constant with the literal value. (new)
- Inline Variable: Replaces a local variable with the literal value. (new)
- Inline Method: Replaces a method call with the contents of the method. (new)
- Make Static: Transforms an instance method to a static method, optionally adding a parameter for the class instance, if required. (new)
- Convert variable to field: Introduce variable will convert a local variable to a class field. (new)
- Move to top level: Changes a secondary or inner class to a top level class. (new)
- Encapsulate Fields: Encapsulates the access of fields with accessor functions. (new)
- Convert Anonymous to Inner: Converts an anonymous inner class to a named inner class. (new)
- Replace Constructor with Factory Method: Adds a factory method to create a class and makes the existing constructor private. (new)
- 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. (new)
- Usages working set: You can create a working set from the results of a Find Usages execution. (new)
- Searchable Class and Package Dialogs: The class and package browser dialogs are now fully searchable and support camel case naming. (new)
- Hyperlink Navigation: You can now use ctrl+left mouse click to perform a goto declaration. (new)
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. (new)
- Implement Interface: Suggestion to add method or make class abstract when missing methods from an implemented interface are encountered. (new)
- Use JDK 5 loop: Converts for loops to use the new JDK 5 syntax. (new)
- Expand Statement: Adds semicolons to statements, code blocks for loops, and any other missing constructs around a section of code. (new)
- Use JDK 5 autoboxing: Removes unneeded calls to Integer and other Object primitives. (new)
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. (new)
- 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. (new)
- Automatic imports on copy-paste: When you copy and paste code between code editors, JDeveloper automatically adds the required imports to the new location. (new)
- Automatic indention: When you paste code, it is now automatically indented into your file. (new)
- Smart Paste: When you paste a string literal into you code, it is automatically wrapped with double-quotes and escaped when needed. (new)
- Smart Insight: Code insight that restricts the results to members that can be used specifically in the given context. [invoked with control-alt-space](new)
Projects may now have multiple run/debug configurations.
JDeveloper 10.1.3 runs on J2SE 5.0, and J2SE 5.0 is the default J2SE for compiling, running, debugging and profiling.
- 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. (new)
- 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. (new)
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. (new)
- Input Support: While running an Ant build script, GUI dialogs are used to provide values from the ant input task. (new)
- Improved Structure Pane: You can sort and filter targets and properties, as well as directly execute a target from the structure pane. (new)
- Ant Toolbar: A customizable list of targets is available from the drop down on the Ant toolbar button. (new)
- External Tool Support: You can now run an ant task as an external tool in JDeveloper, making it available from any context menu. (new)
- OC4J JSR-88 Support: OC4J's JSR-88 ant tasks are now included with JDeveloper. (new)
- Execute imported tasks: You can now execute a task imported from another build file. (new)
- Automatic add-to-ant-classpath support: Jar files located in ${user.home}/.ant/lib are now automatically added to Ant's classpath if desired. (new)
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. (new)
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 in the following areas:
- Multiple Struts configurations: Now you can effectively manage multiple struts configuration files in the same project. (new)
- 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. (new)
- Tiles integration: A tiles definitions file (tiles-defs.xml) can be created from the New gallery and is automatically registered in the web.xml. (new)
- Support for large projects: Improved speed in opening large diagrams, and an option to edit in XML for quick edits. (new)
With this new release, you can generate EJBs using XDoclet 1.2. The option to use XDoclet is specified as a step in the EJB creation wizards.
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.
Use Search > XPath Search to search an XML document using an XPath expression.
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.
XQuery Support
JDeveloper now supports creating XQuery files, syntax hilighting of XQuery syntax in the code editor, and executing XQuery from within the IDE. (new)
- Display Error and Warnings in code editor: Errors and warnings are now underlined in the code editor and structur pane as you edit an XML document. (new)
- 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. (new)
- Simplified Schema Validation: An XML schema doesn't have to be registered with the system in order to validate an XML document against it. (new)
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. (new)
- Automatic Restart: JDeveloper will now automatically restart after using Check for Updated if a restart is required.(new)
- Authenticate for OTN: JDeveloper only prompts for an OTN login if an update from OTN is selected for installation (new)
- Proxy Settings Help: If JDeveloper can not connect to the Check for Updates servers, you are guided to setting the proxy server. (new)
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) (new)
- 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.(new)
- Commandline configuration: You can now set the system properties ide.extensions and ide.noextensions to enable or disable extensions from the commandline when JDeveloper starts (in addition to using the new simplified Extensions page in the IDE's preferences)(new)
- 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(new)
- JSR-198 javadoc: The Javadoc for JSR-198 is included with the JDeveloper Extension SDK. (new)
- Simplified Addin class: The Addin class has been moved to oracle.ide and streamlined to only include 1 method: initialize(). (new)
This new release of JDeveloper provides support for developing EJB 3.0 and 2.1 applications.
- New Web Services Wizards: JDeveloper includes a new wizard simplifies exposing an EJB Session Bean as a Web service end point. (new)
- EJB 3.0 Support: wizards to generate EJB 3.0 and 2.1 components and the EJB Module Editor has been updated to support EJB 3.0 and 2.1. (new)
- JSR 175/181: JDeveloper includes support for JSR 175 and 181 tags, including auto-import of tags. (new)
- Session Facade Method: JDeveloper supports session facade method generation for EJB 2.x and 3.0. (new)
- Enhanced DTO Support: Creating a Data Transfer Object for EJB 2.x has been improved in this release. (new)
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. (new)
- Improved inspector experience with friendlier custom dialogs and easier method binding. (new)
- Page template support for creating custom master templates and editing template-based pages. (new)
- JSP audits to catch and fix common JSP library configuration issues. (new)
- Refactoring support for web.xml. (new)
- Navigation bar for quick selection in a hierarchy. (new)
- Improved editing experience of J2EE and OC4J deployment descriptors (new)
- Source code folding of tags. (new)
- 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 collapsable code blocks. (new)
- Wireless JSF development support. (new)
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. (new)
- OPMN Deployment: Deploy to OPMN connection, including support for deployment to clustered environments .(new)
- JCA Deployment: JDeveloper will create and deploy RAR files .(new)
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. (new)
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. (new)
- 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 (new)
- Auto Layout improvements: The automatic layout has been refined to provide a more reasonable layout for the diagram shapes (new)
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.
Database Development
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 MySQL, MS SQL Server, Sybase, IBM DB2, and IBM Informix in addition to Oracle databases. (new)
- 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. (new)
- 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. (new)
- 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. (new)
- Dependency Support: A smart dependency engine analyses interdependent changes, such as columns in constraints (new)
- Live Data Editing: The Data tab in the table editor now allows you to edit the data and commit the changes to your database. (new)
JDeveloper includes many new features for web services development, and supports the J2EE 1.4 standards.
- WSIF bindings: Support for WSIF bindings on top of SOAP 1.1 and SOAP 1.2. (new)
- REST Services: JDeveloper supports building REST style services. (new)
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. (new)
- 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)(new)
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 amd drop attributes, collections and operations from the data control palette onto a JSF page to create databound components. (new)
- 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)
- New components: New databound components that were not available in previous component libraries include editable table, and master table with inline detail. (new)
- 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)
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 (new)
- URL Datasource for XML and CSV (comma separated variable) files, such as data exported from a spreadsheet. (new)
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. (new)
Support for multiple TopLink mappings
In projects that have multiple TopLink mappings, you can now create different data controls for each mapping. (new)
Support for standard web services security
Using the new web services data control security wizard can configure security for web services data controls. (new)
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 (new)
- Formatting hints for date and currency (new)
- Label text (new)
- Show and hide attributes (new)
- Sorting hints (new)
"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. (new)
Find Mode
Find mode is available for data controls other than business components. (new)
Undo, redo and refactoring
Full undo and redo support: the undo command changes all files that were affected by the last operation. (new)
Enhanced page-level bindings
- Control the order in which iterators execute (new)
- New variable bindings and page parameters (new)
- Simplified method invocation (new)
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. (new)
Databinding authorization
You can now set permissions on iterators and bindings. (new)
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. (new)
Declarative Query Builder
A new declarative query builder makes it easy to build complex view object queries. (new)
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. (new)
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. (new)
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. (new)
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. (new)
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. (new)
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. (new)
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. (new)
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.
For more information on ADF Faces, see the ADF Faces site on OTN. |
Bookmark
