JetBrains IntelliJ IDEA Blog

In IntelliJ IDEA 10 a new JPA Console is added to existing Hibernate and Database consoles. Now you can run and test your JPA queries in a target environment of your application.

Both Hibernate and JPA consoles are available if applicable.

Note the new “Run Query in Console” Intention Action that is now available on all the supported types of queries: JPA QL, Hibernate QL and SQL. It allows you to quickly run a query directly from the editor in a corresponding console either new or already running.

Feature branches have simple life cycle, they usually consume trunk changes and are merged back into trunk after the work is completed.

In IntelliJ IDEA 9.0.3 EAP, take all trunk changes into feature branch and reintegrate back into trunk using new “Merge from…” action:

You can merge all changes in one shot or select a subset of them. Changelist with merged changes is created and offered for commit.

Sometimes I find myself writing repetitive code constructs without being able to extract common code due to Java syntax hmm… let’s call them peculiarities. ‘Sounds like a job for a live template’, I think, and I simply create it. Here’s how. The documentation has it too, but a good example never hurts.

Let’s suppose you have read/write synchronization in your project, and from time to time you need to wrap a bunch of statements in, say, a read action. This involves putting them into a Runnable and giving the latter to some runReadAction method. Do you still do this manually? You don’t need to, IntelliJ IDEA will help you!

First, find an existing code which already invokes the read action and select it:

Go to Tools menu and choose Save as Live Template there:

You’ll see a typical Edit Live Template dialog with the text you’ve selected. Note that all the class references are qualified there and Shorten FQ names checkbox is on, so the mentioned classes will remain the same no matter where you choose to insert it.

What we want to keep is the external syntax: the method call and the runnable. So remove everything inside the run() method braces and replace it with a $SELECTION$ on a single line. It means that you may select something and it’ll be wrapped in this particular construct.

Enter some abbreviation to easily invoke it each time, and some description (optional, but useful). Finally, the formatting looks not quite pretty, so turn on the Reformat according to style checkbox.

That’s all! Click OK and start using it. Find a fragment you want to wrap into a read-action, select it and invoke Surround With… action (Ctrl+Alt+T). You’ll see the read action template in the list:

Select it and the read action is in there:

If you’re an IntelliJ IDEA plugin developer, you’re surely going to enjoy IntelliJ IDEA PSI Viewer (Tools -> View PSI Structure), which displays internal structure of various files, as they’re interpreted by IntelliJ IDEA. If you’re implementing a new language support, or trying to add some cool new features to what’s already supported — this viewer is what you’re gonna need a lot.

As you see, PSI Viewer is made up of of tree parts:

• An editor with file content
• PSI structure view with parent-child tree of its elements
• Area that displays references of element selected in PSI structure view.

Note that references marked as red resolve to null.

Available since build 92.35

Most of applications initially are single threaded, and IntelliJ IDEA was no different; though luckily, now it isn’t — but we had to adapt our code to use multiple threads. In this post I’m going to tell you how.

In our example we see SAXBuilder, which is too expensive to be created every time we need it, so it is stored in a static final field.

Because SAXBuilder is not thread safe, multiple calls to loadDocument from different threads cause a lot of interesting exceptions. This is why we need either to make access to this field synchronized, or to make the field ThreadLocal. In our case, we’re choosing the latter. We encapsulate the field, change its type and initializer, then fix a generated getter. Quite a lot of work, right? Luckily in Maia you can do it all in just one click. Just place caret on a field and press Alt+Enter to smoothly migrate it to ThreadLocal.

In IntelliJ IDEA 9 (Maia), we’ve slightly changed the way you run and debug your applications. You’re still able to quickly run or debug a previous configuration (Shift+F10/F9), as well as to create and run/debug a temporary configuration in a context-dependent manner (Ctrl+Shift+F10/F9). However, it’s now much easier to select and run/debug different configurations from the keyboard.

In IntelliJ IDEA 9, you can choose a configuration that you wish to run with one of the following shortcuts:

• Alt+Shift+F9 to debug your application.
• Alt+Shift+F10 to run it.

Invoking any of these actions displays a pop-up window with available configurations, like this:

You can edit a configuration before launch (press F4) or show a configuration dialog box to edit all your configurations and their default settings (press 0). You can also instantly delete a temporary configuration by pressing Delete.

That’s not the end of the story: you’re now able to temporary switch to an opposite action directly from this pop-up window by pressing and holding Shift. When you do that, Run becomes Debug and vice versa.

And even more: we’ve extended the pop-up window with context-dependent configurations. That means whenever you press Alt+Shift+F10 right in a test method’s body, the pop-up displays a temporary configuration to run the current method only or all tests from the current test class.

We’ve also added a number of quick access shortcuts:

• 1 for a previously selected configuration.
• 2 and 3 for context-dependent configurations.
• 0 to display the Edit Configuration dialog box.

One more tip: we’ve mapped this pop-up to F9 (debugger’s Resume Program action). The pop-up now displays on pressing F9 when you’re unable to actually resume anything - that is, when you’re not yet running any debug session.

Do you find yourself copying and pasting parts of bodies between different methods and then facing broken code?

Unfortunately, parameter names tend to differ — like in this (very simplified) example:

Nothing is easier than fixing this problem with a few keystrokes in IntelliJ IDEA!

First, move caret on any red reference (highlighted with red color), or simply press F2, and then invoke available Quick-Fixes via Alt+Enter:

Now select Rename Reference (again, you can use arrow keys or just start typing Ren.. + Enter) and… IntelliJ IDEA fixes code for you!

See, sometimes it’s just the small features making it possible to achieve maximum productivity.

There’s a lot of useful actions in IntelliJ IDEA that don’t have shortcuts for many different reasons: they’re not used too often or there’s simply no more convenient key combinations left.

For example, I often want to get access to VCS actions like Compare with latest repository version or Revert current file or even submit a single file with a quick NPE fix without opening a menu or going to Changes view.

So how can I call any of these actions with a single shortcut? That’s really easy: I just need to define my own Quick List and map it to a shortcut (Control-X in my case). After I’ve done that, every time I press Control-X I will get a pop-up like this:

Quick List in action

Now I can press 5 to quickly commit the current file or 2 to revert all my changes. OK, now let’s see how to create a Quick List and assign it a shortcut.

(more…)

In the upcoming Maia EAP you will find a slightly different Commit Changes dialog.

• Automatic use of JobView filter on search results.
• Support for Perforce native search query syntax (in an example below we’re looking for Job in any field)