We will need two different components to interconnect IntelliJ with Jira successfully. First, we will need to create an API token in Jira. Consequently, we need to interconnect IntelliJ IDEA with Jira.

Jira API token creation

We need to generate the API token in Jira, which will secure communication between IntelliJ and Jira.

1. In Jira, go to your profile and go to the option to change your password. This link should move you to Jira Security Profile at https://id.atlassian.com/manage-profile/security link.

2. Click on the Create and manage API tokens link from the API token section.

3. Here at the page https://id.atlassian.com/manage-profile/security/api-tokens we can create API tokens.

Go to blue Create new token bottom and click it.

4. New pop-up window will show up. Type a rememberable name for the token into the input field.

Hit Create button. A new API token will be generated (You should also get an email notification). You can see token plaintext when clicking on the icon of an eye in the field.

Copy the token to some save location. You will need it later.

Be aware that if you close the window, the token will be lost, and it will be not possible to see it again.

Note: If you made a mistake and want to display the token again, it is not possible. Instead, you need to create a new token and go through the procedure of the new token generation again.

Remove the invalid token from the token list by clicking on Revoke bottom for individual token.

Revoke API token pop-up window will close, and after successful removal, a new pop-up Notification will show in Jira to display successful removal.

Connecting IntelliJ IDEA with Jira

1. Open your desired project in IntelliJ IDEA.

2. Go to IntelliJ IDEA settings (Ctrl + Alt + S) and under Tools > Task > Servers add new Jira configuration. New Jira configuration is possible to add by hitting a + (plus sign) in the bottom left corner of Configurated servers list. Select JIRA option.

3. Add the following information to the Jira server settings:

Server URL – URL of your Jira

Email – Add your Jira account email

API token – Provide API token generated in Jira.

Search – assignee = currentUser() and project = XXXX and resolution = Unresolved order by updated.

The code in the search input field will give you your most recent task assigned to you at the top of the menu.

Test your connection with Jira with the Test button.

If your connection to the Jira server was successful hit Apply and OK and close the Settings window. Now you can go into the right corner of the IntelliJ window, and you should see a drop-down menu showing you all connected tasks with Jira.

Checking out a new task

When checking out a new task, we can create immediately a new branch on which the task will be built.

Go to section Tasks and set up the settings according to the image below.

Changelist name format: ${id} ${summary}

Feature branch name format: feature/${id} ${summary}

Settings like the picture above will secure that a new feature branch will be created when we check out a new task in the IntelliJ IDEA window.

Conclusion

In this short tutorial, we followed the steps to interconnect IntelliJ IDEA with your Jira account. One of the most critical parts is to keep the Jira API token. If you consider using them in other projects, keep the token in a separate secured file. Otherwise, do not be afraid to revoke tokens, if necessary, and create a new one.

Spring Boot application default port

When you develop long enough with Spring Boot, you know the error very well. You work on your Spring Boot application, and you use a console for running the application. Or you use your favourite IDE runner for starting your application (my preferred IDE is IntelliJ IDEA). Your Spring Boot application in the running embedded in servlet container when suddenly you need to do something else. Instead of adequately terminating the embedded servlet container with your application, you detach from the servlet by a closing terminal window or switching to a different project in IDE. However, because you did not correctly terminate your IDE runner and did not correctly kill the terminal’s application process, the servlet with the application is still running. After that, you might, of course, start developing something else. Surprise, surprise, you cannot. Any Spring Boot application port, by default number 8080, is still occupied with the unterminated process of your Spring Boot servlet container. (In the tutorial, we assume you are using the Spring Boot application port on default port number 8080).

I guess you might be a little bit confused by all the wording describing the issue. Let’s take a look first at some terminology to understand the problem here fully:

What is process?

We are aware that readers of this blog are pretty skilled in computers. So, we will provide a brief description of what is computer process without going to further details.

Every time you start a program on your computer, it requires a certain amount of resource. Your Central Processor Unit, known as CPU, add to this program its process.

If you open task manager on your Windows, you will see a list of all process your CPU is trying to manage at once.

What is process ID?

The process ID, also known as PID, is the number assigned by the operating system to each new process.

What is port number?

A port number is how to identify individual processes for network message when they arrive on a server. In a real sense, a port number is the logical address of each application or process that helps identify the sender and receiver of processed messages.

You can imagine port numbers as doors in the hallway into which message flows through the networks. It leaves one door and enters another.

What is Spring Boot server container?

Spring Boot is a Spring project which makes Spring development fast. Without going too much into the Spring Boot project details, your Spring Boot application runs in a server container, better known as a servlet. This servlet runs in one computer process and lister on port 8080 for traffic.

Restart computer

One way how to solve this is to restart your computer. During the restart of Windows OS, start all the fresh, and port 8080 will be empty. But this is not the fastest and definitely not the right way for developers to solve this.

Set different port number

Another way is to solve this issue by assigning the Spring Boot application a different port number. When we set a different port number for the application, we will not kill the existing process with the application servlet container. However, we will create a new-different process for the servlet container, which will be listening on a different port. In this way, port 8080 will be still occupied, but we will at least be able to continue to develop.

Go to Spring Boot application.properties file and set different port number for server.port .

Despite this quick workaround, there is a much more mature way to solve this problem. I would like you to show a better way to kill a Spring Boot servlet container listening on port 8080.

Kill the process listening at port 8080

To kill the process listening at port 8080 in the Windows environment, we need only go through a few steps. First, check the image below to get the idea.

Find the process occupying port 8080

On the Windows, open your CMD terminal. With simple command netstat -ano | findstr PORT_NUMBER, where for PORT_NUMBER add port number 8080, and on command prompt output (hit enter), we will get the process id of process listening on port 8080.

Kill the process with command prompt

Now, all we need to do is just type the following command taskkill /F /PID PROCESS_ID and replace PROCESS_ID by the process id we got from the previous command result.

If you have typed everything correctly, process listening on port 8080 should be terminated.

Prerequisites

Let me give you some essential tips for prerequisites to get successful and smooth remote debugging.

Debug same version as on the remote server

To debug a remote server-side application in your IntelliJ IDEA, you need to have the same version of your application or component on your side in IntelliJ IDEA as on the server-side. To do so, you shall first finish all the changes you want to test on the remote server. Then build your application and deploy it to the remote server. Only then you should run remote debug mode against your remote environment.

In reverse, if you can not change what is on the server, rebase your code repository on the commit of the JAR or WAR file set on the server. Then, build the application with the build tool of your choice (Maven/Gradle), and only then can you remotely debug.

Don’t make any additional changes before remote debug

Writing the following note might be unnecessary, yet it is better to say it aloud as a reminder. If you make any changes in your code between deployment on the remote server and running the application in remote debug mode, remote debug will not work. Even on the slightest change, remote debug will not decompile your breakpoint on the desired code line because Java bytecode will be different.

Build faster without tests

Just a tip – for a fast Maven build you can use mvn clean install -DskipTests.

For more information regarding running a Maven build without tests, check the article about how to build Java application with Maven without running tests.

Coordination your work with the rest of the team

If you are working in a team and want to be a good team player (or working on something very sensitive), let your teammates know you want to deploy and remotely debug your application. First, ask your colleagues, e.g. in Slack publicly, if it is OK to occupy test instance for a while. Then, coordinate your debugging according to the response or your organization’s policy. For example, let’s say you are clear to go if nobody responds in 15 minutes.

Adjustment of other parts

For more complex changes through the stack, changing and adjusting different system parts might be necessary. E.g., if you are working on the monolith, you might need to adjust the front-end client for testing purposes. In other cases, it might be necessary to change the database.

Adjusting other parts of the system might be necessary for the system to work and for you to be able to test changes through the whole stack.

In every case, do not forget to clean after yourself when leaving (check the last point of this tutorial for more info).

1. In IntelliJ IDEA, create new Run/Debug Configuration for Remote JVM Debug

Example of setup in IntelliJ IDEA

You can change host and port configurations based on the remote environment you want to debug.

If using a multi-module project, select a module in Use module classpath.

2. Run remote debug configuration in debug mode

Connecting to the host should be nearly instant. So now, all you need to do is place the breakpoints in your code.

Then, when the application code executes in a connected environment, the line you set as the breakpoint should be reached, and IntelliJ IDEA will show you the stack trace. That is it, simple as that.

3. Do not forget to close your debug session

Do not forget to close your debug session. Unclosed sessions cause port/socket exhaustion and lead to server restart. Also, try not to keep the session open and be stuck on the breakpoint for too long. TimeOutException and other exceptions might occur which will lead to further server resource consumption.

4. Clean up

After successful testing, returning the testing environment to its original state might be necessary. For example, build your current master/develop branch and place it back in the test environment. Then, if your colleagues do not notice that the testing environment does not work as it should, you did a good job cleaning after yourself and placing the project back in a stable state.

If you are on your own, I highly recommend cleaning after yourself too. You will never know when you will need to return to your projects again, and you might not remember why the testing environment is in a different state at that time.

As I am a software developer, IntelliJ IDE is, for me, a must. IDE is in front of me opened all the time. Therefore it is a chance for me to write a lot of content in the IDE. It is a better choice to use IDE instead of switching to another text editor or using another means of word processing.

Since I am also aiming to work on several articles or documents simultaneously, every decrease in ambiguity and complexity counts towards faster results. The creative process is not possible to automatize. But what it is possible to automatize are redundant tasks during text handling and editing.

Why turn IntelliJ Idea IDE into your word processor?

First of all, IntelliJ Idea IDE already comes in its 2020 version with very, very good support for English vocabulary. So writing in English in IDE was never easier than now.

Plus, when implementing the advantage of multiple IntelliJ shortcuts, the word processing is swift. Especially if you write your text in .html, .adoc or .md format.

Overall, IntelliJ IDE comes in all versions with Git support, which is an additional advantage against traditional word processors. You can easily version your articles’ state and keep a history of your edits in one place. Article versioning is a feature that is available only in very advanced mode in cloud SaaS.

However, what I have found very tedious was text formatting in IntelliJ. As expected, I was using IntelliJ Idea IDE for coding, mostly Java, and thus the text was supposed to be wrapped automatically after 120 characters. When I then copied my articles to other word processors in my pipelines, such as Microsoft Word or Grammarly, I always needed painfully deleted every single break line to make a single continuous line of text. That was also one of the most common mistakes I had after publishing articles through WordPress – linebreaks were always in places where they should not be.

After enough time spent doing this pointless work, fixing many wrong break lines, I have decided to end it and figure out how to speed up the process. Because every second I spend editing an article is second, I could use it towards another article’s creative process.

How to turn IntelliJ Idea into text editor?

First of all, go to Settings > Editor > General and check all checkboxes in Soft Wraps section.

Then go to Settings > Code Style and select Scheme Project. Here unselect the checkbox “Wrap on typing”.

I would recommend this change be saved under the current project scheme, not under the IDE scheme. If you are using the same IntelliJ for coding, wrapping will conflict with your code clarity if you save the change under the IDE scheme.

Hit Apply button to apply all the changes.

Initialize soft-wrap in IntelliJ code editor

In the active editor tab, on the left side of the text line panel, after the right-click, there is an option soft-wrap to initiate the wrapping. Soft-wrap is not initialized automatically on every new file open. Therefore you will need to initialize soft-wrap on every new file open.

Tip for shortcut

When you open a new file, the text is, by default, unwrapped. You can either right-click on the newly opened line meter on the left side and hit Soft-Wrap from the menu option. Or you can set up a special shortcut for soft-wrapping, while the shortcut is not set by default.

To set up your shortcut, go to File > Settings > Keymap and search for “Soft-Wrap” in Main Menu > View > Active Editor. Add to action key shortcut. I personally use Alt + P key shortcut. That is not a conflicting key shortcut with keys combinations easy to remember.

The result of the problem is the red underling of all lines using Lombok functionality. The warning occurs after IntelliJ start-up on the button right side and looks like this:

Lombok plugin incompatible with 2018.1 Intellij Idea

A solution to this problem is straightforward. Just follow the instructions below:

1. Open settings and select plugin options.
2. Search or select the Lombok plugin, right-click and reload the list of plugins.
3. Then there will be Update button instead of Uninstallbutton. Press the Update button.
4. After re-installation of the plugin, restart IntelliJ Idea for updating its internal dependencies. That is it.