IntelliJ IDEA 13 debugger don't stop on breakp

问题:

I have a breakpoint on a line where is the System.out.println("test") command. I believe that the command is reached by execution because I see the printed string "test". But the breakpoint is ignored.

Breakpoint is a red circle all the time, without a tick or cross. I think this is an issue when IDEA thinks the class is not loaded, while it is, because the command is executed.

I can reproduce it in various circumstances:

1. When I press debug (with maven configuration install exec:exec -DforkMode=never)

2. Remote debugging - I run maven goal in debug mode in the console:

   mvnDebug install exec:exec -DforkMode=never

   or

   mvnDebug install exec:exec

   remote debug configuration in IDEA:

   • Arguments for running remote JVM:
     -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=8000
   • For JDK 1.4.X:
     -Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000
   • Transport: Socket
   • Debugger mode: Attach
   • Host: localhost
   • Port: 8000

In both cases the debugger only prints "Connected to the target VM, address: 'localhost:8000', transport: 'socket'"

I have also tried File > Invalidate Caches / Restart and clean build, but the breakpoint is still ignored.

Configuration:

Ubuntu 13.10
IntelliJ IDEA Ultimate build 133.944
Apache Maven 3.0.4
Java version: 1.7.0_51, vendor: Oracle Corporation
OS name: "linux", version: "3.11.0-17-generic", arch: "amd64", family: "unix"

EDIT: relevant part of pom.xml:

<plugin>
  <groupId>org.codehaus.mojo</groupId>
  <artifactId>exec-maven-plugin</artifactId>
  <version>1.2.1</version>
  <configuration>
    <executable>java</executable>
      <arguments>
        <argument>-D--secret--.server.configuration=/usr/local/etc</argument>
        <argument>-classpath</argument><classpath/>
        <argument>com.--secret--.Server</argument>
      </arguments>
  </configuration>
</plugin>

回答1:

My solution:

Considering that you have a program that depends on system properties:

package com.mycompany.app;


public class App {

    private static final String GREETING = System.getProperty("greeting", "Hi");

    public static void main(String[] args) {
        int x = 10;
        System.out.println(GREETING);
    }
}

And you are running it with exec:exec:

mvn exec:exec -Dexec.executable=java "-Dexec.args=-classpath %classpath -Dgreeting=\"Hello\" com.mycompany.app.App"

With some "inception magic" we can debug the process started by Mavenexec:exec.

Maven

Change your exec:exec goal to enable remote debugging. I'm using suspend=y and server=n, but feel free to configure the JDWP Agent as you please:

-agentlib:jdwp=transport=dt_socket,server=n,address=127.0.0.1:8000,suspend=y

This will not be passed directly to the maven JVM, instead it will be passed to exec.args which will be used by exec:exec:

mvn exec:exec -Dexec.executable=java "-Dexec.args=-classpath %classpath -agentlib:jdwp=transport=dt_socket,server=n,address=127.0.0.1:8000,suspend=y -Dgreeting=\"Hello\" com.mycompany.app.App"

IntelliJ IDEA

Create a Remote configuration (again I'm using a Listen strategy. You should adjust it according to your process settings):

Now toggle your breakpoints and Debug your remote configuration. Using the settings above it will wait until your process starts:

Finally run the exec:exec line above and debug your application at will:

---

So basically you need two "Run/Debug" configurations for this to work:

1. A Maven configuration for exec:exec with the system properties and JDWP agent configuration:

   

2. The remote configuration acting as a client.

回答2:

The exec goal will execute your program in a separate process, so the debugger may not be connecting to the right JVM. Instead try using the java goal, e.g.:

mvnDebug install exec:java 

This will execute your program in the same process and hopefully you will hit your breakpoint.

回答3:

To debug web applications in maven projects using the Intellij Community Edition, you can add a tomcat or jetty plugin to your WAR pom like this:

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.tomcat.maven</groupId>
            <artifactId>tomcat7-maven-plugin</artifactId>
            <configuration>
                <port>8080</port>
                <path>/yourapp</path>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.mortbay.jetty</groupId>
            <artifactId>maven-jetty-plugin</artifactId>
        </plugin>
    </plugins>
</build>

It's possible if needed to add database drivers like this:

<plugin>
    <groupId>org.mortbay.jetty</groupId>
    <artifactId>maven-jetty-plugin</artifactId>
    <dependencies>
        <dependency>
           ... your database driver groupId and artifactId ...
        </dependency>
    </dependencies>
</plugin>

Then using these plugins the application can be started in the command line (from the pom directory):

mvnDebug clean install tomcat7:run-war

Or for jetty:

mvnDebug clean install jetty:run-war

With the application running in debug mode from the command line (you don't need to run it from Intellij), do a remote debugging configuration similar to what you posted and the breakpoint should be hit.

If you use Intellij Ultimate Edition then this is not necessary, because you can create a server configuration for Tomcat or any other server and deploy the application in a fully integrated way, with debugging and hot deployment handled transparently.

There is a 30 day trial where you can evaluate this feature and others.