Intellij idea debug как пользоваться: Debugging in IntelliJ IDEA / Как дебажить Java проект

Debugging in IntelliJ IDEA / Как дебажить Java проект

Написать код — пол дела. Нужно его ещё заставить работать правильно. В этом нам очень сильно помогают IDE и средства отладки.
На примере IntelliJ IDEA предлагаю познакомиться с тем, как мы можем узнать, что же происходит с нашим кодом, когда он работает.

Debug тема обширная, поэтому данный обзор на глубокое погружение, словно дайвер, не предлагает. Но надеюсь снорклинг точно )

Вступление

Часть написания кода – это его отладка, дебаг (англ. debug). А если в задачи входит поддержка кода – отладки будет ещё больше. Ну и кроме того, при помощи отладки можно исследовать работу используемых библиотек и фрэймворков так глубоко, как только сможете погрузиться в дебри чужого кода.

Для нашего погружения нам потребуется:
Для начала, распаковываем скачанный архив с Quick Start Source Code. Запускаем IntelliJ Idea и создаём «New Project from Existing Sources». Выбираем в подкаталоге hibernate4 файл pom. xml. При импорте указываем «Import Maven projects automatically» и завершаем создание проекта оставляя остальные настройки без изменений.

Пока импортируется проект разархивируем скачанный сервер приложений WildFly в какой-нибудь каталог. Запускаем сервер при помощи файла bin\standalone.bat (или standalone.sh для *nix систем).

(!) Важно запуститься с параметром —debug

Ожидаем, когда сервер стартует. Нам напишут, что он started in и укажут время. Выглядеть это будет примерно так:
Далее нужно запустить выбранный нами проект на сервере. Этот процесс описан в небольшой документации, которую можно найти в самом проекте:

\hibernate4\README.adoc

Как и указано в этой документации, нам нужно в каталоге hibernate4 выполнить команду: mvn clean package wildfly:deploy

Ожидаем, когда нам напишут, что сборка выполнена успешно:
После этого в логе сервера мы можем увидеть, как «задеплоился» новый проект:
После этого мы переходим на страницу http://localhost:8080/wildfly-hibernate4 и у нас должна отобразиться страница с формой «Member Registration«.

Итак, наша подготовка к экспериментам выполнена и мы можем начинать )) Впереди для наглядности будет много картинок, так что приготовтесь)

Remote Debug

Итак, нам нужно настроить Debug режим, чтобы наша IDE управляла исполнение кода на сервере приложений.

IntelliJ Idea поставляется в двух вариантах: бесплатный (Community) и платный (Ultimate). Последний можно официально попробовать в виде EAP.

В Ultimate версии всё просто — сервер приложений можно запускать сразу из IDE в режиме дебага. А вот в Community версии надо немного действий сделать вручную. Поэтому, рассмотрим случай посложнее, т.е. настройка в Community версии.

В Community версии есть некоторые ограничения. В частности, из неё нельзя запускать сервер приложений. Но можно настроить удалённую отладку (Remote Debug), когда где-то отдельно есть запущенный сервер с нужным нам приложением.

Воспользуемся описанием настройки отсюда: Remote debug Wildfly in IntelliJ Idea community edition (настройка Remote Run Configuration для 8787 порта).

После настройки запускаем в Debug режиме нашу новую конфигурацию:
Если всё хорошо, то мы увидим внизу об этом сообщение:

Процесс Debug’а

Давайте «отдебажим» сохранение записи. Для этого надо сначала определиться с местом, где мы будем исследовать. Судя по окну, нам нужна кнопка «Register». Давайте найдём её в коде.

Итак, нам нужен элемент, у него должен быть текст: «Register». Или она должна как-то относится к этому.

Нажимаем Ctrl+Shift+F и ищеём Register в кавычках. Видим, что такая есть на index.xhtml.
Нажимаем Enter для перехода в найденный источник:
Итак, мы видим, что при регистрации вызывается memberController.register

Судя по всему, это должен быть некоторый java класс. Нажимаем Ctrl+N, ищем:
Действительно, такой класс есть . Переходим в него. Видимо, тут должен быть метод register. Нажимаем Ctrl+F12 и ищем метод register
Действительно, нашли.

Судя по всему, регистрация происходит тут, в memberRegistration. register. Нажимаем Ctrl и кликаем по методу, чтобы «провалиться» в него:
Давайте теперь поставим «точку остановки» или Break Point. Это такой маркер, который говорит, где выполнение кода должно приостановиться. Мы в этот момент получим возможность узнать много интересного. Чтобы его поставить нужно кликнуть в место правее номера строки.
На странице http://localhost:8080/wildfly-hibernate4 заполняем поля и нажимаем кнопку Register.

Значок идеи на панели мигнёт:
Перейдя в Idea видно, что на панеле отладки много интересной информации:
Здесь можно посмотреть значение полей объекта. Например, из чего состоит регистрируемый Member:
Отлично. Что мы можем ещё сделать?

Мы можем открыть контекстное меню и выбрать там Evaluate Expression (или через меню Run -> Evaluate Expression). А ещё лучше на панели управления дебаггером:
Это супер замечательная возможность в точке останова, имея доступ ко всему, к чему есть доступ к этом месте кода, выполнить любой код, который можно было бы выполнить в этом месте. Например:
На панели управления дебаггером есть также кнопки управления, которые отвечают за то, куда необходимо переместить управление ходом выполнения программы. Не правда ли, магия?)

Нажимая кнопку F8 (Step Out) мы ходим по коду без заходов в методы. Нажав F9 мы прекращаем ходить по строкам кода дебаггером, а отдаём дебаггером управление ходом выполнения программы.

Если мы нажмём F7 (Step Into), то мы пойдём по коду с заходом в каждый метод, который встретим на своём пути. Кстати, обратите особое внимание на вот этот информационный блок:
Тут показан поток, в котором мы находимся и методы в стэке текущего потока. Но и это ещё не всё. Для удобства, можно открыть вкладку фрэймов. Для этого она должна быть включена:
Теперь на вкладке фрэймов мы видим информацию о переходе от метода к методу, т.к. начали ходить по коду при помощи Step Into.
Как мы видим, не всегда нас может перебросить туда, где сейчас выполнение программы. Мы сейчас находимся в «getDelegate:469, AbstractEntityManager (org. jboss.as.jpa.container)». Но на самом деле, мы в реализации. Об этом свидетельствует класс, указанный у this:
Смотрим на this. Как мы знаем, он указывается на текущий объект. Мы в TransactionScopedEntityManager. Почему же Idea нам не может показать код?
Дело в том, что IntelliJ Idea сейчас не знает ни про какой TransactionScopedEntityManager, т.к. он не подключен к нашему проекту (его нет в зависимостях проекта). Когда работает сервер приложений, то внутри него крутится много-много всяких библиотек. А нам про них известно очень мало, т.к. в общем случае нам не нужно копаться во внутренностях, нам нужно чтобы оно просто работало. Но иногда этого требует работа или спортивный интерес.
Тогда, надо об этой библиотеке сообщаить Idea, чтобы она знала, где брать код классов.

Подключение сторонних библиотек для дебага

Для начала нам самим нужно понять, что же это за библиотека, которую нужно подключить.

Первый путь он трудный самый – искать в интернете. Скорость и результат нахождения результата сильно зависят от того, на сколько хорошо вели проект. Например, у WildFly открытый репозиторий. Поэтому, при поиске в гугле «TransactionScopedEntityManager» мы выйдем на https://github.com/wildfly/wildfly/tree/master/jpa/subsystem и найдём, что нам нужен wildfly-jpa.

Второй способ – правильный. Где лежит сервер, там и искать. В этом могут помочь различные средства. Например, на Windows это может быть Far Manager. Далее пример алгоритма поиска приведён на нём.

Установив и запустив его, переключаемся при помощи Tab на одну из вкладок, при помощи Alt+F1 для левой вкладки или Alt+F2 для правой и выбираем нужный нам раздел на жёстком диске. Вполне возможно, что в Far Manager после установки открыт каталог самого Far Manager. Чтобы перейти в корень диска следует нажать Ctrl + \.

При помощи Alt+F открываем окошко поиска, начинаем набирать название каталоге и нажимаем Enter после того, как каталог найден. Этот поиск хитрый и выделяет те каталоги, которые совпадает с текстом поиска. Если вводятся символы, для которых нет папок, то такие символы ввести нельзя. Переходим таким образом в каталог сервера приложений.

Допустим, мы не знаем, где на сервере лежат модули. Возможно, Вы вообще в первый раз в жизни слышите про какой-то там WildFly. Поэтому, нажимаем сразу здесь Alt+F7 для поиска файлов.

Итак, логика подсказывает: нам нужен файл с библиотекой. То есть нам нужен jar. Внутри должен быть класс TransactionScopedEntityManager. Т.к. класс = файл, то ищем по «содержит». То есть как-то так:
Теперь, ждём результат. Он не заставит себя ждать)
Теперь, нам надо где-то найти исходный код для него. И тут есть 2 варианта:
Воспользуемся, пожалуй, вторым. Найдём там:
Теперь же переходим к описанию зависимости. На этой страничке есть возможность скачать исходный код.

Отлично, теперь код у нас скачан. Осталось подключить библиотеку. Подключается она предельно просто. Нам нужно открыть настройки проекта:
Там выбираем «Libraries» и в раздел «Sources» добавляем полученные исходные коды, а в разделе «Classes» указываем сам jar файл библиотеки из каталога WildFly, который нами был найден при помощи Far Manager’а.

После этого мы увидим при переходе по F7 содержимое класса AbstractEntityManager и TransactionScopedEntityManager, а так же станет доступен через поиск по классам через Ctrl+N.

Break Points с условиями

Вернёмся теперь к Break Points. Иногда, мы хотим остановиться не всегда, а только при каком-нибудь условии. Что же делать? И тут нам тоже поможет наша IDE.

Поставив Break Point мы можем назначит ей условие. Например, поставим точку и нажмём по ней правой кнопкой мыши:
Теперь точка остановки сработает только тогда, когда имя будет Maximilian. По кнопке More Вам будут доступны расширенный набор настроек для Break Point’ов.

Break Points на исключения

Иногда мы можем получать ошибку и хочется проследить, откуда она идёт. Тогда мы можем добавить точку остановки не на конкретную строку кода, а на место, где будет брошено исключение. Для этого нужно раскрыть список всех точек остановки:
И создать новое правило для выбранного типа исключения:
Например, для NPE:

HotSwap классов

Дебаггер — удивительная вещь. Она помимо дебага позволяет изменять классы! Да, ресурсы (такие как xhtml стриницы, например) не изменить так просто. Но вот код java классов можно подменить на лету (это и называется Hot Swap). Для этого достаточно при присоединённом дебаггере изменить класс и выполнить Run -> Reload Changed Classes.

Полезный обзор на эту тему: 4 free ways to hot-swap code on the JVM

Заключение

Дебаггер — мощный инструмент, позволяющий разработчику проникнуть в самую глубину выполняемого кода, изучить его во всех деталях. Это позволяет исправлять самые запутанные ошибки. Так же это позволяет лучше понять то, как те или иные библиотеки работают.

Даже такой краткий обзор вышел довольно внушительным, но я надеюсь он будет полезен и интересен.

Если кого-то смог заинтересовать данный материал, то продолжить погружение можно по ссылкам:

#Viacheslav

Всё, что вы хотели знать об отладке в IntelliJ IDEA | by Jenny V | NOP::Nuances of Programming

Отладка — это один из самых важных этапов процесса разработки. И дело не только в том, что устранение ошибок занимает, вероятно, большую часть времени: она также особенно необходима при создании бизнес-логики, написании алгоритмов и тестировании кода.

Давайте начнем с основ. Существуют 4 типа точек останова в IntelliJ IDEA.

Точка останова для строки кода

Останавливает приложение в момент достижения им строки кода, содержащей данную точку. Этот тип точки останова может быть добавлен только в выполняемую строку. Если она содержит лямбда-выражение, то вы можете выбрать: либо установить регулярную точку, либо останавливать программу только при вызове лямбда-выражения.

Точка останова для метода

Останавливает приложение при входе/выходе из указанного метода или одной из его реализаций и позволяет проверять условия этого процесса. Данный вид точки останова может сильно замедлить процесс отладки, так что использовать его следует аккуратно и только в случае необходимости.

Точка останова для исключений

Останавливает приложение при выбрасывании Throwable. class или его подклассов.

Точка останова при доступе к полю класса

Останавливает приложение при обращении к указанному полю или внесении в него изменений, что позволяет вам реагировать на взаимодействия с конкретными переменными экземпляра. Например, просмотр того, как инициализируется свойство, или какой метод изменил свое значение.

Для создания точки останова используйте “горячие” клавиши Ctrl + F8. Тип точки останова (для строки кода, для метода или для доступа к полю класса) будет зависеть от того, где вы ее создаете. Для просмотра списка всех точек останова используйте Ctrl + Shift + F8.

Эта возможность сэкономит вам часы работы, а также избавит вас от необходимости искать точки останова и удалять их вручную в том случае, если они останавливают процесс выполнения кода вопреки вашему намерению. Кроме того, данная опция позволяет вам просто их отключить, в результате чего точки не будут останавливать код во время отладки, но при необходимости вы сможете легко включить их повторно. Поэтому вам не нужно запоминать все важные места в проекте и каждый раз создавать и удалять все точки останова.

Suspend (Приостановка)

Определяет, следует ли остановить выполнение приложения в момент достижения точки останова. Имеет два возможных значения: All/Thread. При выборе all происходит приостановка всех потоков, когда какой-либо из них достигает контрольной точки. При выборе thread приостанавливается лишь один поток, достигший этой точки.

Condition (Условие)

Эта опция позволяет задать условие, подлежащее проверке каждый раз при достижении точки останова. Если условие возвращает значение true, то выполняется заданное действие, в противном же случае контрольная точка пропускается.

В качестве условия вы можете использовать:

• различные инструкции, включающие объявления, циклы, анонимные классы и т. д.;
• this (не используется в статическом контексте), например !(this instanceof User);
• проверка логических типов или выражений.

Опции логирования

При достижении точки останова в консоль может быть выведено следующее:

1.Сообщение о достижении точки останова: лог сообщает нам Breakpoint reached at package.User.main(User.java:10).

2.Трассировка стека для текущего окна Frame. Это удобно, если вы намерены проверить, какие методы были вызваны до момента достижения точки останова.

3.Вычисление выражения и запись результата в консоль: результат произвольного выражения, например "Creating..." или users.size().

Remove once hit (Удаление точки останова при ее достижении)

Определяет, следует ли удалить точку останова из проекта после того, как она была достигнута.

Disable until hitting the following breakpoint (Отключение точки останова до момента достижения другой точки)

Отключает текущую точку останова до тех пор, пока не будет достигнута заданная точка. Вы также можете решить, отключить ли ее после того, как это произошло, или нет.

Filters (Фильтры)

Эта IDE от JetBrains позволяет также настраивать работу с точками, отфильтровывая классы/экземпляры/методы и выполняя остановку только в нужных вам местах.

В вашем распоряжении следующие типы фильтров:

• Catch class filters (классовые фильтры перехвата). Они останавливают приложение при перехвате исключения в заданных классах.
• Instance filters (фильтры экземпляров класса). Эти фильтры указывают на экземпляры объектов, для которых будет срабатывать точка останова.
• Class filters (фильтры классов). Они задают классы, в которых будет срабатывать точка.
• Caller filters (фильтры вызовов). Данный тип фильтров ограничивает действие точки останова в зависимости от вызова текущего метода. Эта опция вам пригодится, если нужно остановиться на точке только в случае вызова этого метода из заданного метода.

Field access/modification (Доступ к полю класса/изменение поля класса)

• Field access. Используйте эту опцию, чтобы точка останова срабатывала при обращении к полю класса.
• Field modification. Если вы хотите, чтобы точка останова срабатывала при внесении изменений в поле класса, то выбирайте данную опцию.

Pass count (Количество проходов)

Определяет, должна ли сработать точка останова после того, как она была пройдена заданное количество раз. Эту опцию удобно применять для циклов отладки или рекурсивных методов.

Caught/uncaught exception (Обработанное/необработанное исключение)

• Caught exception. Опция предназначена для срабатывания точки останова при условии, что заданное исключение было обработано.
• Uncaught exception. Выберите эту опцию для срабатывания точки останова в том случае, если заданное исключение не было обработано. Так вы сможете выявить причины необработанных исключений.

Для логирования отладки используйте точки останова, но не инструкцию System.out.println.

Используйте точки останова для ведения логов вместо добавления в код System.out.print. Это позволит применить более гибкий подход к процессу логирования в приложении, а также избежать написания грязного кода и внесения случайных изменений при выполнении Git-коммитов.

Прибегайте к помощи “горячих” клавиш для добавления точек останова, так вы сэкономите довольно много времени.

Использование “горячих” клавиш открывает прекрасные перспективы более продуктивного программирования. Не забывайте про них.

Объединяйте точки останова в группы.

Вы можете создать группу точек останова, например в том случае, если вам нужно отметить точки для решения какой-либо особой задачи. В диалоговом окне Breakpoints (Ctrl+Shift+F8) выберите сначала точку, которую необходимо добавить в группу, а затем — Move to a group.

Выясните исходную причину критических ошибок.

Точки останова для исключений работают с Throwable.class. Вы можете добавить условие, которое поможет вам останавливать выполнение кода только при выбрасывании Error.class, или вы можете свести всё к MyCustomException.class.

Не используйте точки останова для метода без необходимости.

Эти точки могут чрезвычайно замедлить выполнение кода, что приведет к значительным потерям времени.

Не удаляйте точки останова полностью.

Если в настоящий момент вам не нужна какая-то отдельная точка, то не удаляйте ее полностью, а просто отключите. Это позволит сэкономить время в будущем, когда вам понадобится протестировать такой же блок кода, поскольку отпадет необходимость искать ее в огромном проекте, и вы просто включите ее повторно.

Добавьте описание к точке останова.

Это поможет вам вспомнить, почему вам нужна именно эта точка из числа многих других.

Степпинг (stepping)— это пошаговое выполнение программы.

Когда выполнение кода останавливается на вашей точке, вы можете передвигаться по нему с помощью разных типов шагов. Ниже представлена панель шагов.

Рассмотрим каждый из них подробнее.

Step over (F8) — Шаг с обходом

Данная команда позволяет перешагнуть через текущую строку кода и перейти к следующей. Реализация методов пропускается, и вы переходите к следующей строке текущего метода.

Step into (F7) — Шаг с заходом

Благодаря этому шагу вы переходите внутрь метода для просмотра его кода. Эта опция подходит для тех случаев, когда вы не уверены, что метод возвращает правильное значение.

Step out (Shift + F8) — Шаг с выходом

При помощи этой команды вы выходите из текущего метода и переходите к вызывающему методу.

Run to cursor(Alt + F9) — Выполнение до курсора

Данная команда продолжает выполнение приложения до текущей позиции курсора.

Force step over (Shift+Alt+F8) — Принудительный шаг с обходом

Используя эту команду, вы обходите текущую строку кода и переходите к следующей. Если в вызываемых методах есть точки останова, то они игнорируются.

Drop frame — Возврат к предыдущему фрейму

Эта команда позволяет отменить последний фрейм стека и восстановить предыдущий. Это удобно, например, если вы по ошибке слишком далеко “прошагали” или хотите зайти в функцию, где пропустили важный блок кода.

Resume program (Ctrl + F9) — Возобновление программы

Эта команда возобновляет выполнение приложения до следующей точки останова.

Когда вы начинаете отладку, перед вами открывается соответствующее окно инструментов (Debug). Оно используется для контроля за сеансом отладки, отображением и анализом данных программы, а также для выполнения различных действий данного процесса.

В этом окне вы можете видеть созданные объекты, свойства, исключения, значения и т. д. Данная опция удобна для тех случаев, когда вам нужно: 1) убедиться в том, что все свойства инициализированы правильно; 2) уточнить, какие параметры получил метод; 3) посмотреть на трассировку стека исключений.

Step Into (шаг с заходом) применим даже для методов из внешних библиотек.

Иногда внешние библиотеки также могут содержать ошибки. Отладка внешней библиотеки может помочь вам обнаружить неверный код и сообщить о нем ее разработчикам. Или может возникнуть другая проблема. Например, если метод из внешней библиотеки возвращает неожиданное значение, войдите в него для выяснения причины подобного поведения. Возможно, это произошло из-за ошибки в методе объекта equals/hashcode и т. д. или по причине переопределения некоторых классов данной библиотеки в вашем проекте.

Используйте Show Execution Point (Отображение точки выполнения)

Если вы потеряли место, где остановилось выполнение кода, используйте Show Execution Point (Alt + F10) для перехода к достигнутой точке останова.

Просматривайте стек вызовов.

Иногда причина неожиданного поведения может затаиться там, где у вас нет точек останова. Обратитесь к стеку вызовов и посмотрите, какие методы были выполнены. Это поможет вам найти среди них ошибочный. Кроме того, если вы перейдете к другому методу через стек вызовов, вы сможете увидеть предварительно полученные им параметры.

IntelliJ IDEA также предоставляет возможность вычислять выражения в точке останова. Это удобный способ посмотреть, как поведет себя метод с другими значениями.

Для вычисления выражения используйте клавиши Alt + F8 или кнопку Evaluate.

Вычисляйте все.

Если вам необходимо протестировать метод с разными значениями, не нужно создавать объекты вручную и перезапускать приложение. Можете просто вычислить эти значения в имеющемся методе. Это поможет сэкономить время, а также увидеть все свойства возвращаемого объекта.

Вычислитель выражений может выполнять все.

IntelliJ IDEA позволяет вам вычислять не только локальные, но и различные внешние методы или методы java.*. Вычислитель выражений способен даже выполнять методы, отправляющие запрос к другому сервису, давая вам возможность просмотреть подробный ответ.

Будьте аккуратнее с потоками данных (Streams).

Если вы уже один раз прочитали поток данных вычислителем выражений, то он считается прочитанным, поэтому при попытке приложения прочитать его еще раз могут возникнуть ошибки.

Отладка иногда является весьма раздражающим и длительным, но при этом необходимым процессом в работе каждого разработчика. И IntelliJ IDEA предоставляет возможности и опции для того, чтобы сделать ее более удобной, простой и эффективной. Можно любить или не любить процесс отладки, но это не меняет то обстоятельство, что он является значимым этапом разработки.

Напоследок поделюсь самым важным практическим советом:

Если вы истинный разработчик, то забудьте о кнопке Run (Запуск) и используйте только Debug.

Читайте также:

Читайте нас в Telegram, VK и Яндекс.Дзен

отладка — Как и какими средствами находить ошибки в коде Java?

Вчера всё работало, а сегодня не работает / Код не работает как задумано

или

В чем заключается процесс отладки? Что это такое?

Процесс отладки состоит в том, что мы останавливаем выполнения скрипта в любом месте, смотрим, что находится в переменных, в функциях, анализируем и переходим в другие места; ищем те места, где поведение отклоняется от правильного.

Заметка: Отладка производится как правило в IDE (Интегрированная среда разработки). Что это такое можно чуть подробнее ознакомиться в вопросе

Какие есть способы предупреждения ошибок, их нахождения и устранения?

В данном случае будет рассмотрен пример с Intellij IDEA, но отладить код можно и в любой другой IDE.

Подготовка

Достаточно иметь в наличии IDE, например Intellij IDEA

Запуск

Для начала в левой части панели с кодом на любой строке можно кликнуть ЛКМ, тем самым поставив точку останова (breakpoint — брейкпойнт). Это то место, где отладчик автоматически остановит выполнение Java, как только до него дойдёт. Количество breakpoint’ов не ограничено. Можно ставить везде и много.

Отладка запускается сочетанием Shift+F9 или выбором в верхнем меню Run → Debug или нажатием зеленого «жучка»:

В данном случае, т.к. функция вызывается сразу на той же странице, то при нажатии кнопки Debug — отладчик моментально вызовет метод, выполнение «заморозится» на первом же брейкпойнте. В ином случае, для активации требуется исполнить действие, при котором произойдет исполнение нужного участка кода (клик на кнопку в UI, передача POST запроса с данными и прочие другие действия)

Цифрами обозначены:

1. Стэк вызовов, все вложенные вызовы, которые привели к текущему месту кода.
2. Переменные. На текущий момент строки ниже номера 24 ещё не выполнилась, поэтому определена лишь data и numsStringArr
3. Показывает текущие значения любых переменных и выражений. В любой момент здесь можно нажать на +, вписать имя любой переменной и посмотреть её значение в реальном времени. Например data или nums[0], а можно и nums[i] и item.test.data.name[5].info[key[1]] и т.д. На текущий момент строки ниже номера 24 ещё не выполнилась, поэтому sum и output во вкладке Watchers обозначены красным цветом с надписью «cannot find local variable».

Процесс

Для самого процесса используются элементы управления (см. изображение выше, выделено зеленым прямоугольником) и немного из дополнительно (см. изображение выше, выделено оранжевым прямоугольником)

Show Execution Point (Alt+F10) — переносит в файл и текущую линию отлаживаемого скрипта. Например если файлов много, решили посмотреть что в других вкладках, а потом забыли где у вас отладка 🙂

Step Over (F8) — делает один шаг не заходя внутрь функции. Т.е. если на текущей линии есть какая-то функция, а не просто переменная со значением, то при клике данной кнопки, отладчик не будет заходить внутрь неё.

Step Into (F7) — делает шаг. Но в отличие от предыдущей, если есть вложенный вызов (например функция), то заходит внутрь неё.

Step Out (Shift+F8) — выполняет команды до завершения текущей функции. Удобна, если случайно вошли во вложенный вызов и нужно быстро из него выйти, не завершая при этом отладку.

Rerun (Ctrl+F5) — Перезапустить отладку

Resume Program(F9) — Продолжает выполнения скрипта с текущего момента. Если больше нет других точек останова, то отладка заканчивается и скрипт продолжает работу. В ином случае работа прерывается на следующей точке останова.

Stop (Ctrl+F2) — Завершить отладку

View Breakpoints (Ctrl+Shift+F8) — Посмотреть все установленные брейкпойнты

Mute Breakpoints — Отключить брейкпойнты.

…

Итак, в текущем коде видно значение входного параметра:

• data = "23 24 11 18" — строка с данными через пробел
• numsStringArr = {"23", "24", "11", "18"} — массив строк, который получился из входной переменной.

Если нажмем F8 2 раза, то окажемся на строке 27; во вкладках Watches и Variables и в самой странице с кодом увидим, что переменная sum была инициализирована и значение равно 0, а также nums инициализирована и в ней лежит массив целых чисел {23, 24, 11, 18} .

Если теперь нажмем F8, то попадем внутрь цикла for и нажимая теперь F8 пока не окончится цикл, можно будет наблюдать на каждой итерации, как значение num и sum постоянно изменяются. Тем самым мы можем проследить шаг за шагом весь процесс изменения любых переменных и значений на любом этапе, который интересует.

Дальнейшие нажатия F8 переместит линию кода на строки 31, 32 и, наконец, 36.

Дополнительно

Если нажать на View Breakpoints в левой панели, то можно не только посмотреть все брейкпойнты, но в появившемся окно можно еще более тонко настроить условие, при котором на данной отметке надо остановиться. В методе выше, например, нужно остановиться только когда sum превысит значение 20.

Это удобно, если останов нужен только при определённом значении, а не всегда (особенно в случае с циклами).

Больше информации об отладке можно посмотреть в http://learn.javajoy.net/debug-intellij-idea, а также в официальной документации к IDE

Удаленная отладка с помощью Intellij Idea

Недавно я узнал о процедуре удаленной отладки в рамках Idea. Что я делаю, так это копирую конфигурацию удаленной отладки в разделе Run | Debug Configuration в Idea в параметры выполнения командной строки java. Фактическими параметрами командной строки являются:

-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=8000

Если это сценарий, я добавляю к нему эти команды. При этом в командной строке отображается сообщение:

Listening for transport dt_socket at address: 8000

Таким образом, отладка может происходить с использованием локального исходного кода. Однако я не совсем понимаю, как работает удаленная отладка. Любой, кто знает, как на самом деле работает удаленная отладка, пожалуйста, дайте мне объяснение.

Спасибо!

java

intellij-idea

remote-debugging

9

Удаленная отладка означает, что вы можете запустить свой код Java в любом месте, как на локальной, так и на удаленной машине. Когда он работает в режиме отладки, вы можете подключиться к нему из IDE с помощью сетевого подключения TCP и выполнить отладку. IDE должен иметь исходный код для запущенных классов, чтобы вы могли размещать точки останова внутри этого кода и выполнять пошаговые действия,проверку переменных и т. д.

Если вас интересуют технические детали, обратитесь к документации JPDA .

0

Это лучший способ проверить ваш код, который находится в другой среде .

мы должны иметь следующие пункты наверняка, прежде чем вы будете использовать удаленную отладку .

1. мы используем JBOSS на наших серверах.

2. настройка — JBOSS_HOME/bin/run.conf
   JAVA_OPTS=»${JAVA_OPTS} -отладчик xdebug -Xnoagent -Xrunjdwp:transport=dt_socket,address=Москва 8787,сервер=г,приостановить=Н»

3. теперь добавьте сервер IP и номер порта в удаленную отладку intellij .
   4.your должен иметь последнюю версию проекта в локальной среде, которая синхронизирована с сервером, иначе отладка не будет разрешена.

4. вам нужно запустить сервер intellij для проекта .
5. Затем запустите удаленную отладку .
6. поместите точку отладки в локальную, и когда мы начнем тестирование на сервере, когда она достигнет точки отладки, она остановится и будет ждать, пока вы ее не обработаете .

Другой момент заключается в том, что он будет держать весь запрос в очереди и не позволит никому пройти через точку останова, которая может помешать другим пользователям протестировать его .

Настройка дебага контейнеризированного приложения в InelliJ Idea · GitHub

Добавляем конфигурацию запуска

Переходим Run → Edit configurations → Add → Python Remote Debug

Указываем номер порта, например 11122.

Выключаем галку Suspend after connect.

В Path mappings нажимаем справа кнопку … и указываем Local path — путь до папки с проектом на локальной машине, Remote path — путь до папки с проектом в контейнере, например: /opt/local/path/to/project=/opt/remote/path/to/project.

Нажимаем OK.

Подготовка кода

Копируем архив pycharm-debug.egg в папку с проектом (для макосовской IntelliJ Idea его можно найти в ~/Library/Application\ Support/IntelliJIdea2016. 2/python/pycharm-debug.egg).

Чтобы можно было импортировать pydevd , нужно добавить его в PYTHONPATH:

import sys
sys.path.append('/opt/remote/path/to/project/pycharm-debug.egg')

Теперь в месте кода, в котором хотим остановиться дебагером, добавляем:

import pydevd
pydevd.settrace('dockerhost', port=11122, stdoutToServer=True, stderrToServer=True)

Дальше можно пользоваться стандартными брейкпойнтами.

Обратите внимание – порт должен быть то же самый, что и в Python Remote Debug конфигурации.

Docker

В docker-compose добавляем

volumes:
  - /opt/local/path/to/project:/opt/remote/path/to/project
extra_hosts:
  - "dockerhost:$DOCKERHOST"

Запуск дебаг сервера

Запускаем созданную Python Remote Debug конфигурацию. В консоли вы должны увидеть:

Starting debug server at port 11122

Теперь дебаг сервер запущен и ждет подключений клиентов.

Запуск удаленного дебага

В терминале выполняем

set -x DOCKERHOST (ifconfig | grep -E "([0-9]{1,3}\.){3}[0-9]{1,3}" | grep -v 127.0.0.1 | awk '{ print $2 }' | cut -f2 -d: | head -n1)

И запускаем контейнер или докер-компоуз

docker-compose up

Программа, запущенная в контейнере должна подключиться к дебаг серверу.

Как сделать удобный интерфейс для повседневного инструмента — Дизайн на vc.ru

Принципы проектирования интерфейсов от команды дизайнеров IntelliJ IDEA.

9862

просмотров

Среда разработки — такой же важный инструмент для разработчиков, как графический редактор для дизайнеров. Это именно то приложение, где можно написать код и собрать из него любое другое приложение или сайт.

IntelliJ IDEA — популярная среда разработки (IDE) для языка программирования Java. Возможно, вы и сами пользуетесь ей или одной из десяти IDE компании JetBrains: WebStorm, PyCharm, GoLand, Rider и так далее. Все эти продукты построены на платформе IntelliJ и имеют общий пользовательский интерфейс.

UX-, UI-дизайнеры в команде разработки IntelliJ IDEA помогают делать интерфейс удобнее для наших пользователей. Чтобы определить, что такое «удобнее» для самих себя, коллег-разработчиков и пользователей, мы используем принципы проектирования.

Главный экран IntelliJ IDEA: слева все файлы проекта, справа код

Откуда берутся принципы

Люди довольны продуктом, если чувствуют, что движутся к своей цели, и не испытывают эстетических противоречий. Попросту, должно быть удобно и красиво.

«Красиво» — это соответствие современным визуальным нормам. Наши IDE десктопные, решения в этой области ограничены интерфейсами операционных систем. Поэтому мы чаще думаем про «удобно».

Думаю, что «удобно» можно сформулировать так: большинство пользователей решает задачу максимально быстро.

Эта формулировка слишком абстрактная, и её сложно применять на практике. Проще использовать конкретные принципы, которые в сумме обеспечивают то же самое. Эти принципы:

• Скорость доступа к элементам интерфейса.
• Экономия внимания.
• Информативность.
• Находимость.
• Привычки.
• Сложность разработки.

В списке нет таких понятий как «соответствие целям и сценариям пользователя», «теория близости» или «скорость работы приложения» — всё это должно работать по умолчанию.

Принципы оставляют пространство для решений. Разберу способы принятия таких решений на примерах пользовательских интерфейсов в IntelliJ IDEA.

Принципы

Скорость доступа к элементам интерфейса

Скорость доступа — насколько быстро можно подвести курсор к элементу, насколько быстро прицелиться. Здесь действует Закон Фиттса: время прицеливания прямо пропорционально расстоянию, обратно пропорционально размеру объекта прицеливания. То есть в большую кнопку рядом с курсором прицелиться быстрее, чем в маленькую кнопку далеко.

Такая маленькая кнопка как раз была на тулбаре в главном окне IntelliJ IDEA — кнопка с треугольником на скриншоте:

Добавили кнопке лейбл «Add Configuration». Кнопка стала большая, и целиться стало удобнее:

Часто для достижения цели нужно прицелиться к нескольким объектам подряд. Чем больше объектов, тем медленнее доступ. Та же кнопка с треугольником сначала открывала меню, в котором нужно было прицелиться в единственный пункт:

В варианте с кнопкой прицелиться нужно только один раз к самой кнопке.

Экономия внимания

Внимание человека — ресурс, не нужно расходовать его зазря. В интерфейсах внимание часто расходуется на переключение контекста.

Например, раньше сообщение о валидации полей отображалось внизу диалога. Часто поле с ошибкой оказывалось далеко от сообщения, пользователю приходилось бегать глазами от одного места к другому:

До: поле с ошибкой наверху диалога, сообщение об ошибке внизу

Исправили, чтобы ошибка показывалась у поля, где она произошла. Теперь внимание не расходуется на переключение между разными областями диалога:

После: поле с проблемой и сообщение об ошибке в одном месте

Переключение контекста ещё часто происходит в модальных диалогах. Модальный диалог заставляет тратить внимание, чтобы сориентироваться в новом интерфейсе. В IntelliJ IDEA обычным подходом было открыть модальный диалог, если нужно увеличить область ввода:

До: кнопка открывает модальный диалог

Чтобы внимание не тратилось, решили расширять само поле:

После: кнопка разворачивает немодальное поле

Ещё внимание можно потратить на слишком заметный элемент интерфейса, когда заметным он быть не должен. Хотели объяснить в нотификации, зачем она появляется, и добавили серый текст:

До: длинный отвлекающий серый текст

Но нотификация появляется часто, зачем каждый раз отвлекать людей подсказкой, которую они уже, возможно, изучили. Можно спрятать ее под менее заметный вопросительный знак и сэкономить внимание:

После: не отвлекающая иконка со знаком вопроса

Информативность

Информативность — это доля полезной информации в общем объеме сообщения, то есть соотношение сигнал/шум. Улучшать информативность можно двумя способами: добавить сигнал или уменьшить шум.

Пример с добавлением сигнала. В IntelliJ IDEA есть возможность перемещаться назад / вперед по местам кода, где находился курсор (действия Navigate Back / Forward). Не всегда легко вспомнить, в каком месте кода каретка была некоторое время назад, и непонятно, нужно ли туда возвращаться. Добавили информацию для решения этой проблемы — показали кусочки кода, где был курсор, в отдельном попапе:

Попап наглядно показывает, в каком месте кода недавно находился курсор

Другой пример, когда убираем шум. Несколько версий назад у нас было много тулбаров с 10–20 иконками. В таком количестве иконок сложно найти нужную. Мы собрали статистику кликов на тулбарах. Те действия, которые использовали меньше 0,1% пользователей (темно-красный), мы убрали с тулбаров, другие действия сгруппировали или переместили, наиболее используемые вынесли в начало тулбара. Теперь шума меньше, найти нужную иконку проще:

Когда иконок меньше, найти нужную проще

Находимость

Фича может быть полезной, но если пользователи про неё не знают — всё равно, что нет фичи.

В IntelliJ IDEA можно искать файлы, классы и другие сущности проекта или действия самой IDE. Раньше было пять похожих интерфейсов поиска: свой для каждой категории и один поиск для всех. Нужно было знать, как вызывать каждый в отдельности.

Пять попапов для поиска разных сущностей, нужно знать про каждый

Чтобы не нужно было находить каждый из попапов, совместили их в один. Теперь достаточно одного шортката (Shift + Shift), чтобы узнать, какие объекты можно искать — все они перечислены в заголовке попапа, и между ними можно легко переключаться клавишей Tab:

Один попап для поиска всех сущностей. Проще найти, чем пять отдельных

Или ещё случай. Одно из самых полезных действий в IntelliJ IDEA — Show Context Actions с шорткатом Alt + Enter. Оно подсказывает, как сделать код правильнее, позволяет запустить его, снавигироваться в связанные сущности и многое другое. Например, можно поставить курсор на код с проблемой, нажать Alt + Enter и увидеть список действий, которые исправят код автоматически:

Контекстные действия в IntelliJ IDEA подсказывают, как исправить код

Но узнать про Show Context Actions можно, но только если заметишь и нажмёшь иконку–лампочку (она открывает это же меню) или откроешь контекстное меню. Оба способа легко пропустить. Зато по наведению курсора мыши на код с проблемой появляется тултип с описанием ошибки, найти его намного проще:

До: тултип с проблемой в коде

Логично связать описание ошибки с действиями для ее исправления. Добавили действия в тултип, и количество использований Show Context Actions в IntelliJ IDEA выросло с 60% до 70%.

После: тултип с проблемой и с контекстными действиями — проблема и как исправить в одном месте

Привычки

Соблюдение привычек пользователей помогает всем предыдущим пунктам — привычные элементы быстрее и найти, и понять. Как мы сохраняем привычку:

1. Используем важные интерфейсные шаблоны из операционных систем. Например, в macOS кнопка «OK» справа, а в Windows — слева.

Кнопки OK и Cancel в разном порядке в macOS и Windows

2. Используем один шаблон взаимодействия для одинаковых задач. Например, раньше клавиатурные раскладки, цветовые схемы редактора кода и профили инспекций кода управлялись тремя разными интерфейсами, хотя для всех действия были почти одинаковые:

До: три разных интерфейса для одного способа взаимодействия

Заменили на одинаковый интерфейс, чтобы пользователям было проще разобраться с управлением новой сущностью, если уже сталкивались с похожей раньше. У всех действия теперь в меню под шестеренкой:

После: одинаковый интерфейс для одного способа взаимодействия

3. Используем знакомые решения из окружающего мира, если ничего подходящего нет в нашем собственном интерфейсе или операционных системах. Недавно появилась возможность делать плагины к нашим IDE платными. Теперь у платных плагинов есть своя лицензия, и если она не активирована, нужно как-то это показать. Как это сделать?

Можно нарисовать иконки продукта и плагинов неактивными, но тогда выглядит, будто пункт списка целиком недоступен:

Иконка выглядит недоступной (disabled)

Можно сделать иконки полупрозрачными, передать метафору «чего-то не хватает». Но такой прием не используется в IntelliJ IDEA, вид непривычный, и метафору могут не понять:

Метафору полупрозрачной иконки сложно понять

Поэтому решили использовать привычный символ знака «стоп» для значения «стой, что-то не так»:

Дополнительная иконка «стоп» быстрее передает смысл «что-то не так»

Сложность разработки

Дизайнер может придумать интерфейс, разрабатывать который придется год. Все это время проблема пользователей не будет решена. Поэтому лучше придумать что-то проще и принести пользу быстрее.

Пример. Тексты для пользовательского интерфейса удобно записывать в отдельных файлах, а не в файле с кодом. Например, это полезно для перевода на разные языки — всё, что нужно перевести, видно в одном месте:

Пример файла с текстами для пользовательского интерфейса. Тексты — зеленые, их идентификаторы — синие

В файле с кодом, показывающим текст, указываем обращение к идентификатору текста:

Тут идентификатор стал зеленым, это корректное поведение, но для примера неважное

Вместо идентификатора удобно показать превью текста — понятно, что именно будет выведено в интерфейс. Такое превью отображается в IntelliJ IDEA автоматически:

В файле с кодом вместо непонятного идентификатора показываем понятный текст

Иногда сам текст нужно отредактировать. Чтобы не переходить в файл, где хранится текст, дизайнеры предложили редактировать превью текста (раньше редактировать было нельзя):

Удаляем слово Toggle

Но оказалось, что разработать редактирование текста, который на самом деле хранится в другом файле — сложно и долго. Поэтому решили обойтись существующими компонентами: показать поверх кода поле ввода с текстом из другого файла, а в тултипе подсказать, как запустить редактирование.

Нажимаем ссылку Edit Property Value, запускается редактирование

Задача решена, пусть и менее элегантно, но гораздо быстрее.

Все принципы вместе

Чтобы понять, хороший ли интерфейс, нужно оценить, как на нем выполняются все принципы. Возьмем для примера ту же кнопку на тулбаре главного окна и оценим новый вариант по принципам:

• Скорость доступа: как уже говорилось, в большую кнопку прицелиться быстрее, чем в маленькую кнопку, а потом в меню под ней.
• Экономия внимания: кнопка стала заметнее, но это небольшая проблема, потому что кнопка важная — с нее можно начать работу, если требуется запустить код.
• Информативность: теперь на кнопке написано, что она делает — это полезная информация, стало понятно, зачем нужна кнопка.
• Находимость: теперь людям проще найти, как создать run/debug конфигурацию, чтобы запустить код — текст на кнопке явно на это указывает.
• Привычка и сложность разработки: кнопка — стандартный элемент, проблем нет.

Вариант с кнопкой — сравнительно простой. Обычно для такого интерфейса достаточно умозрительной оценки. Для вариантов посложнее не всегда получается оценить в уме.

Рассмотрим вариант посложнее: диалог создания класса, интерфейса или элемента другого типа данных (класс и интерфейс — понятия из программирования). В диалоге можно записать имя элемента и выбрать его тип в списке Kind:

Диалог создания класса и других абстрактных типов данных в коде

По умолчанию список типов скрыт, и может быть сложно понять, какие есть варианты. Если курсор находится в поле Name, то Kind можно переключать кнопками Вверх/Вниз на клавиатуре, на что намекает иконка ↑↓ справа от Name. Но этот способ подсказки непривычный, метафора иконки непонятная, и в результате найти эту функциональность сложно.

В одной из команд предложили вручную вводить тип элемента в поле Name, чтобы не нужно было переключаться в комбобокс Kind и выбирать из длинного списка. Дизайнеры предложили ещё два решения: использовать попап с подсказкой и показывать все типы в списке под полем Name. Все варианты вместе:

Чтобы не забыть ни один из принципов в процессе сравнения, запишем в табличку. Цветом отмечена оценка, насколько хорошо выполняется принцип. Цвет помогает взглядом оценить наиболее удачный вариант:

По табличке видно, что у варианта со всеми типами в списке под полем (4) больше всего зеленого, но он всё равно не идеальный. Это обычная ситуация, потому что примирить все принципы сложно. В таком случае можно выбрать самый выигрышный вариант и отдельно решить его проблемы.

Принципы помогают выбрать лучший вариант интерфейса на этапе проектирования и разработки. Но они не гарантируют, что решение будет идеальным — пользователей много, цели и способы решения задач у них могут быть разными, сложно учесть всё сразу.

Поэтому после разработки мы всегда следим, как наши коллеги и люди за пределами компании пользуются новым интерфейсом, проводим UX-исследования, и дорабатываем, если что-то осталось неудобным.

Основы работы с IntelliJ IDEA. Интерфейс программы

Для написания Java-программы по большому счету достаточно обыкновенного текстового редактора, но, конечно же, такой вариант просто несопоставим с использованием профессиональных сред разработки приложений, так называемых IDE (Integrated Development Environment).

IntelliJ IDEA – это интегрированная среда разработки программного обеспечения на Java от компании JetBrains. Кстати, не только на Java. Среда с успехом используется и для других языков программирования, например, Scala. Первая версия программы появилась в 2001 г. и с тех пор программа неуклонно повышает свой рейтинг популярности. IntelliJ IDEA выпускается в двух редакциях: Community Edition и Ultimate Edition. Первая версия является полностью бесплатной. Вторая версия распространяется под различными лицензиями и, как декларируется, может использоваться бесплатно для разработки проектов с открытым программным кодом. Впрочем, и даже без этого по окончанию использования мною версии Ultimate Edition, я получил просто уведомление, что могу работать с ней непрерывно на протяжении только получаса.

Версии отличаются также поддерживаемыми технологиями.

1. Ultimate Edition:
   • полнофункциональная среда разработки под JVM и разработке на различных языках: Java, PHP, JavaScript, HTML, CSS, SQL, Ruby, Python;
   • поддержка технологий Java EE, Spring/Hibernate и других;
   • внедрение и отладка с большинством серверов приложений.
2. Community Edition:
   • полнофункциональная среда разработки для Java SE, Groovy и Scala;
   • мощная среда для разработки под Google Android.

Ознакомиться с отличиями между версиями можно на сайте компании JetBrains по ссылке http://www.jetbrains.com/idea/features/editions_comparison_matrix.html.

Программа содержит полный набор необходимых для создания полноценных приложений компонент: редактор, среда компиляции и выполнения, а также отладчик.

Естественно, IntelliJ IDEA – не единственная среда создания приложений для Java, достаточно припомнить популярную Eclipse или NetBeans, так что разработчику есть из чего выбирать, а его предпочтения зачастую обусловлены субъективными факторами, например, он – начиная программировать на Java – прочитал статью про конкретную среду, что и обусловило его последующий выбор. Вполне возможно, что и данный цикл статей послужит для кого-то началом работы с IntelliJ IDEA, тем более что система, на мой взгляд, более чем удобная.

Кстати, в интернете можно найти много информации по миграции с того же Eclipse на IntelliJ IDEA (смотри, например, информацию на сайте компании JetBrains по ссылке https://www.jetbrains.com/help/idea/2016.2/eclipse.html).

Я предпочитаю работать с новой версией IntelliJ IDEA, поэтому периодически ее обновляю. Предлагаемые же читателю статьи писались на протяжении более года, поэтому я не исключаю, что некоторые screenshots относятся к каким-то старым версиям и изменились в новых версиях, за что заранее приношу извинения читателям.

Инсталляция системы

Скопировать инсталляционный пакет можно с сайта разработчика компании JetBrains по ссылке http://www.jetbrains.com/idea/. Установка IntelliJ IDEA проблем не вызывает. Отмечу только, что если в дальнейшем вы предполагаете работу с программным кодом именно в среде программы, то при инсталляции установите ассоциацию программы (Create associations) с файлами Java.

Справочная система

Для IntelliJ IDEA имеется документация достаточно большого объема на английском языке. Поэтому при щелчке пункта Help в главном меню открывается не встроенная, а on-line справка на сайте компании JetBrains.

Имеется также возможность получить документацию по конкретному элементу кода, для чего нужно установить на нем курсор и нажать комбинацию <Ctrl>+<Q>.

Более того, вообще можно закрепить окно с документацией на боковой панели (по умолчанию – на правой), сделав его инструментальным, щелкнув кнопку прикрепления на заголовке окна документации. Правда, на мой взгляд, это мало что дает, поскольку при открытии этого окна оно будет отображать только последнюю выведенную документацию.

Интерфейс программы

Как было отмечено ранее, продукт пользуется заслуженной популярностью разработчиков, хотя и есть «маленькое но»: отсутствие русской локализации, хотя для разработчиков это отнюдь не является препятствием для работы.

Стартовое окно

После установки при первоначальной загрузке IntelliJ IDEA появляется стартовое окно «Welcome to IntelliJ IDEA», позволяющее загрузить либо открыть проект, импортировать проект, выполнить его загрузку из репозитория нескольких систем контроля версий («Check out from Version Control»). При наличии в проекте файлов настройки сборки для Maven или Gradle, IntelliJ IDEA предложит вам использовать их для конфигурации.

После работы с определенным проектом, он запоминается, и при последующем запуске программы происходит загрузка последнего открытого проекта. Впрочем, это происходит при настройках программы по умолчанию, когда в группе Appearance & Behavior (Внешний вид и поведение), System Setting (Настройки программы) установлен флажок для поля-метки “Reopen last project on startup” (Открывать последний проект при загрузке).

Основное окно

Основное окно программы в общем виде состоит из трех областей, называемых также инструментальными окнами и окна редактора. Инструментальные окна располагаются по периметру окна редактора, то есть слева, справа и внизу от него на полях главного окна, которые в дальнейшем будем называть боковыми панелями (sidebar в терминологии программы). Поскольку инструментальные окна отображают разноплановую информацию, то каждая боковая панель содержит ряд вкладок, которые открываются при выполнении определенной команды. Переход к нужной вкладке (инструментальному окну) осуществляется щелчком на ее названии, которые располагаются на боковых панелях главного окна. Названию некоторых вкладок инструментальных окон предваряет цифра. Используя клавишу <Alt> совместно с этой цифрой, можно быстро перейти к этой вкладке, попутно открыв ее, если она находится в свернутом положении, либо, наоборот, свернуть ее. Кроме того, любое инструментальное окно можно отобразить в основном окне командой ViewTool Windows либо воспользовавшись ее комбинацией клавиш быстрого вызова.

Перед кратким описанием инструментальных окон оговорюсь, что рассматриваемая структура расположения предлагается такой, какой она является после установки программы по умолчанию. Именно такое расположение я и буду рассматривать далее. Однако это вовсе не означает, что инструментальные окна нельзя расположить в других местах главного окна, о чем речь пойдет ниже.

Цветовую палитру IntelliJ IDEA можно настраивать, правда, таких палитр немного. Выбор палитры осуществляется в настройках, где следует раскрыть последовательно пункты Appearance & Behavior (Внешний вид и поведение), Appearance и выбрать тему из раскрывающегося списка «Theme».

Окно редактора

Окно редактора отображается постоянно, занимая большую часть основного окна. Оно может содержать несколько вкладок, отображающих программный код класса, содержимое pom-файла и другие файлы проекта. О содержимом вкладки сигнализирует как расширение файла в названии вкладки, так и пиктограмма перед названием, например, для класса: . Переход к нужному файлу осуществляется щелчком на его имени на вкладке окна либо выбором в инструментальном окне проекта.

Программа содержит внушительный инструментарий управления вкладками окна. Так, расположение вкладок можно произвольно изменять, располагая их, например, горизонтально, перебрасывая файлы из одной группы вкладок в другую, что достигается при помощи группы команд WindowsEditor Tabs либо из контекстного меню, вызываемого на вкладке окна редактирования. При необходимости конкретную вкладку можно закрепить, что бывает полезным при большом количестве вкладок, когда все они не помещаются в окне редактирования, для чего используем команду Pin Tab, о чем речь пойдет ниже.

С правого края окна могут находятся горизонтальные линии, отмечающие проблемные блоки кода, содержащие ошибки и предупреждения. Подробнее об этом также позже.

По левому краю окна редактирования расположены метки блоков кода, при помощи которых можно быстро свернуть блок за ненадобностью либо вновь его развернуть. С этой же стороны окна располагаются точки останова (при их наличии), советы по модификации кода и некоторая другая информация.

Для отображения нумерации строк программного кода следует вызвать контекстное меню на вертикальной полосе в левой части окна редактирования и выбрать “Show Lines Numbers” (Отображать нумерацию строк). Однако при таком действии отображение строк осуществляется только в текущем сеансе. Для постоянного же отображения нумерации строк программного кода следует в настройках раскрыть последовательно пункты Editor (Редактор), General (Общие настройки), Appearance (Внешний вид) и установить флажок для поля-метки «Show line numbers» (Отображать номера строк).

Сам программный код (подсветка текста, шрифты) оформляются в соответствии с настройками программы, о чем речь пойдет позже.

Инструментальные окна

Инструментальное окно проекта

На левой боковой панели отображается инструментальное окно проекта. Оно содержит вкладку иерархической структуры проекта (Project) и вкладку структуры (списка метода) класса (Structure).

Выбор во вкладке структуры проекта приводит к отображению его содержимого в окне редактора. Поскольку код практически любого класса содержит множество методов, то вкладка «Structure» как раз и отображает их список. Он может быть упорядочен как по алфавиту ( Sort by Alphabetically), так и в порядке их расположения в классе ( Sort by Visibility). Щелчок на имени класса инициирует переход на начало модуля в классе в окне редактора.

Информация вкладки «Structure» вообще довольно информативна. Рядом с именем модуля выводятся также ряд его свойств, например, модификатор класса, а ее панель инструментов позволяет быстро изменить характер отображаемой информации, например, дополняя ее содержимое не-public переменными, упорядочивая по названию либо в порядке нахождения в коде и т.п.

При наличии в проекте нескольких классов целесообразно в окне проекта раскрыть меню кнопки настройки  и установить флажки возле пунктов «Autoscroll to Source» и «Autoscroll from Source». 

Такой вариант полезен, если в окне редактора открыто две вкладки и более (а это, конечно, практически всегда имеет место). В этом случае переход в окне проекта с одного объекта на другой приводит к отображению в окне редактора кода выбранного объекта. И, наоборот, при переходе с одной вкладки на другую в окне редактирования курсор в окне проекта переходит на имя класса, код которого отображается во вкладке окна редактора.

Вкладки в данном окне могут добавляться после установки некоторых расширений (plug-ins). Например, после установки расширения «Database Navigator» в окно проекта добавляется вкладка «DB Browser».

Инструментальное окно «Избранное»

В нижней части левой боковой панели основного окна можно вывести инструментальное окно «Favorites» (Избранное), содержащее, например, список точек останова и закладок, обеспечивая тем самым к ним быстрый доступ.

Инструментальное окно с инструментами сборки проектов

Данное окно располагается на правой боковой панели. Оно изначально содержит две вкладки для двух наиболее распространенных инструментов сборки проектов Java – Maven и Ant.

Инструментальное окно вывода

 Окно располагается на нижней боковой панели. В нем в зависимости от характера информации отображаются, например, сообщения компиляции («Messages»), консольный ввод/вывод («Terminal»), контроль изменений проекта («Version Control»), результаты работы отладчика («Debug») и некоторые другие.

Управление инструментальными окнами

IntelliJ IDEA предлагает мощные средства управления инструментальными окнами, позволяющие расположить их в основном окне практически в любом месте.

Любое открытое инструментальное окно в заголовке содержит две кнопки: настройки  и  «Hide» (Скрыть) (такой вид она имеет на левой панели).

Любое инструментальное окно можно свернуть (спрятать), щелкнув кнопку «Hide». В этом случае в основном окне программы отображается только боковая панель, содержащая наименования вкладок, что, соответственно, увеличивает площадь рабочего окна редактора. В дальнейшем свернутое окно можно просто и быстро отобразить, щелкнув на названии инструментального окна на боковой панели.

Кнопка настройки содержит меню, в котором содержатся команды управления окном.

Окно может содержать собственную панель инструментов. Для ее отображения или, наоборот, удаления, следует раскрыть меню кнопки настройки и установить/снять флажок возле пункта меню Show Toolbar (Отображать панель).

Инструментальные окна могут отображаться как в фиксированном режиме, в определенных местах основного окна, так и в плавающем режиме, то есть в произвольном месте основного окна. Для переключения между режимами следует раскрыть меню кнопки настройки  и установить/снять флажок возле пункта меню Floating Mode (Плавающий режим).

Если окно отображается в фиксированном режиме, то возможны два его состояния, устанавливаемые в пункте меню Docked Mode (Режим способа стыковки). При наличии флажка возле этого пункта окно находится в состоянии смешения, сдвигая окно редактора. Если же снять флажок, то окно переходит в состояние перекрытия, при котором окно перекрывает окно редактора.

И, наконец, если окно отображается в фиксированном режиме в состоянии смешения, то становится доступным режим (пункт меню) Pinned Mode (Закрепленный режим). При наличии флажка возле этого пункта окно постоянно отображается в основном окне. Если же снять флажок, то окно будет автоматически убираться с экрана при потере фокуса.

Выше было отмечено, что инструментальные окна можно расположить на разных боковых панелях главного окна. Но и местонахождение конкретного окна можно также изменить, включив его в состав другой боковой панели. Для этого следует вызвать контекстное меню на названии инструментального окна на боковой панели, выбрать из него пункт Move (Переместить), а затем направление перемещения. На приведенном ниже screenshot видим, например, что инструментальное окно с правой боковой панели можно переместить на нижнюю (Top), левую (Left) и верхнюю (Bottom) боковую панель.

Инструментальное окно может быть и вовсе удалено, для чего также следует вызвать контекстное меню на названии инструментального окна на боковой панели и выбрать из него пункт Remove from Sidebar (Удалить с боковой панели).

В главном меню основного окна имеется также пункт меню Windows, содержащий команды для управления ее окнами.

Панели

На мой взгляд, целесообразно оставить на экране все основные панели программы (при отсутствии какой-то из них выполните команду Viewназвание панели):

1. Toolbar (Главная панель инструментов).
2. Status Bar (Панель статуса), которую можно разделить на три части.
   • Левая часть панели содержит кнопку быстрого доступа к инструментальным окнам .
   • Центральная (и большая) часть панели предназначена для вывода различных сообщений.
   • Правая часть содержит информацию о месте нахождения курсора в программном коде (номера строки и колонки), кодировку файла, формат символов (CRLF для Windows),  атрибут файла «Только чтение» (Read Only), иконку «Гектор» (Hektor) , щелчок на которой открывает окно для переключения уровня отображения синтаксических ошибок (о котором речь пойдет позже). Здесь также может содержаться дополнительная информация, например, при работе с системами контроля версий. При этом из панели статуса можно не только получать информацию, но еще и выполнять некоторые действия. Например, если щелкнуть на поле о месте нахождения курсора, то откроется окошко для быстрого перехода на нужную строку / позицию, а инструмент  позволяет установить (либо снять) для файла атрибут «Только чтение».
3. Navigation Bar (панель навигации).

Отключение / включение панелей производится также в меню команды View.

Выше я писал, что целесообразно оставить на экране все основные панели программы. Однако, при работе в окне редактора с программным кодом одного класса многим, возможно, как раз удобным покажется работа со всеми отключенными панелями, когда ничто не отвлекает от работы.

Настройки

Обращение к настройкам программы осуществляется командой FileSetting или щелчком кнопки  на главной панели инструментов.

Все настройки в окне настроек сведены по функциональному назначению в несколько групп: Appearance & Behavior (Внешний вид и поведение), Keymap («Горячие» клавиши), Editor (Редактор) и др.  

Количество настроек программы очень велико, и, по мере работы с нею, а, следовательно, накопления опыта, вы сами будете изменять необходимые опции. Учитывая это, я не буду рассматривать их детально, поскольку это займет очень много времени. При этом замечу, что некоторые настройки уже упоминались выше, а о некоторых других будет рассказано позже.

Пока же ограничусь буквально несколькими общими настройками.

Важным моментом при написании программы является ее документирование, в том числе комментирование фрагментов кода (об этом позже). Естественно, русскоязычные разработчики будут писать комментарии на русском (белорусском, украинском) языках, что потребует в программе соответствующей кодировки. Оптимальным вариантом, на мой взгляд, будет использование UTF-8, которая является универсальной и имеет ряд преимуществ перед Windows 1251. Например, большинство современных веб-платформ по умолчанию работают именно на ней, а еще ее удобно использовать для создания мультиязычных проектов. Для установки этой кодировки следует последовательно выбрать пункты Editor, File Encodings (Редактор, Кодировка) и в списке «Project Encoding» (Кодировка файлов проекта) выбрать «UTF-8». Впрочем, некоторые разработчики говорят, что беспроблемно также работает значение «<System Default>».

Ну и, наконец, сообщения о появлении новой версии, которые будут у вас регулярно появляться, пока вы не откажетесь автоматически проверять обновления. В принципе установка новых версий вещь полезная и нужная, но если вы желаете производить обновление не по указанию программы, а самостоятельно, то это делается так. Раскройте последовательно пункты Appearance & Behavior, System Setting, щелкните пункт Updates (Обновления) и снимите флажок возле пункта “Automatically check updates for” (Автоматически проверять обновления). Впрочем, и при включенном режиме автоматических обновлений можно просто игнорировать установку новой версии.

У меня сложилось очень высокое мнение о IntelliJ IDEA, однако возможности ее совершенствования практически безграничны. И немалый вклад в этот процесс могут внести и сами пользователи, что, например, может осуществляться на основе собираемой о работе программы статистики. Для этого нужно позволить программе осуществлять такой сбор. С этой целью в настройках следует последовательно раскрыть пункты Appearance & Behavior, System Setting, выбрать пункт Usage Statistics (Статистика использования), установить флажок для поля-метки “Allow sending usage statistics to JetBrains s.r.o.” (Позволить собирать пользовательскую статистику JetBrains), а затем установить флажок возле периодичности отправки такой информации (день, неделя, месяц).

Поскольку настроек очень много, то разработчики предусмотрели их поиск по контексту. Набрав, например, в поле поиска окна настроек текст «save», получим в нем вот такой список:

И последнее. В IntelliJ IDEA предусмотрена возможность сохранения настроек (FileExport Setting) и их восстановления (FileImport Setting).

Расширение системы

 Под IntelliJ IDEA разработано множество plug-ins (расширений), позволяющих заметно расширять ее возможности и функциональность. Доступ к ним осуществляется в настройках системы в пункте Plugins. Из списка «Show» (Показ) осуществляется фильтрация списка расширений. Для добавления нового расширения следует выполнить такие действия:

1. В списке «Show» (Отображение) выбрать пункт «Custom» (Пользовательский).
2. Щелкнуть ссылку «Browse» (Click Browse to search for non-bundied pugins, Щелкните на сообщении для отображения неустановленных plug-in), что приведет к появлению окна «Browse Repositories» со списком plug-ins с репозитория расширений JetBrains.
3. Выбрать из списка нужное расширение и щелкнуть кнопку «Install plugin» (Установить расширение).
4. Подтвердить установку в окне подтверждения.
5. По завершению процесса установки в том же окне «Browse Repositories» щелкнуть кнопку «Restart IntelliJ IDEA» (Перезапуск IntelliJ IDEA) для перезагрузки программы.

Удаление расширений осуществляется также очень просто. Опять же в настройках в списке «Show» выбирается пункт «Custom», после чего в окне настроек отображаются только установленные расширения.

Щелчок кнопки «Uninstall» инициирует процесс удаления.

Код отладки | IntelliJ IDEA

IntelliJ IDEA предоставляет отладчик для кода Java. В зависимости от установленных / включенных плагинов вы также можете отлаживать код, написанный на других языках.

Во время сеанса отладки вы запускаете свою программу с прикрепленным к ней отладчиком. Цель отладчика — вмешаться в выполнение программы и предоставить вам информацию о том, что происходит под капотом. Это облегчает процесс обнаружения и исправления ошибок в вашей программе.

Существует множество способов запуска сеанса отладки, однако для простоты в этой документации предполагается, что вы создаете и запускаете свой проект из IntelliJ IDEA. Это наиболее распространенный случай, и он имеет меньше ограничений по сравнению с более продвинутыми методами. Процедуры подключения к процессу и отладки удаленного приложения рассматриваются в отдельных разделах.

Перед отладкой

1. Убедитесь, что в.

   Этот параметр не является обязательным для отладки, однако мы рекомендуем оставить его включенным. Отключение позволяет сэкономить место на диске за счет некоторых функций отладчика.

2. Настройте общие свойства и поведение отладки в.

   Если вы новичок в отладке, готовая конфигурация подойдет вам. В разделах о каждой функции отладчика даются ссылки и объясняются соответствующие настройки, где это применимо. Если вы опытный пользователь и ищете какое-то конкретное свойство, см. Раздел справки по отладчику.

3. Определите конфигурацию запуска / отладки, если вы собираетесь использовать настраиваемую. Это необходимо, если вам нужно передать в программу какие-то аргументы или выполнить какие-то особые действия перед запуском. Дополнительные сведения о настройке конфигураций запуска / отладки см. В разделе «Конфигурации запуска / отладки». В большинстве случаев это не требуется для отладки простой программы, которая не ожидает аргументов или имеет какие-либо особые требования.

Общая процедура отладки

Не существует универсальной процедуры отладки приложений.В зависимости от реальных требований вам, возможно, придется использовать разные действия в разном порядке. В этом разделе представлены общие рекомендации, представляющие типичные шаги отладки. Подробные сведения о том, как и когда использовать определенные функции, приведены в соответствующих разделах.

1. Определите, где программа должна быть остановлена. Это делается с помощью точек останова. Точки останова — это специальные маркеры, которые представляют места и / или условия, когда отладчику необходимо вмешаться и зафиксировать состояние программы.Программа, которая была заморожена отладчиком, называется приостановленной.

   Альтернативой использованию точек останова является приостановка программы вручную в произвольный момент, однако этот метод накладывает некоторые ограничения на функциональность отладчика и не позволяет точно определить, когда приостановить программу.

2. Запустите вашу программу в режиме отладки.

   Как и при обычном запуске программы, вы можете запускать несколько сеансов отладки одновременно.

3. После приостановки программы используйте отладчик, чтобы получить информацию о состоянии программы и о том, как оно изменяется во время выполнения.

   Отладчик предоставляет вам информацию о значениях переменных, текущем состоянии потоков, структуре объектов, которые в данный момент находятся в куче, и так далее. Это также позволяет вам тестировать вашу программу в различных условиях, генерируя исключения (например, чтобы проверить, как они обрабатываются) или запускать произвольный код прямо в середине выполнения программы.

   Хотя эти инструменты позволяют вам исследовать состояние программы в определенный момент, пошаговая функция дает вам контроль над пошаговым выполнением программы. Комбинируя инструменты, вы можете определить, откуда исходит ошибка, и протестировать свою программу на надежность.

4. Когда вы определили, что нужно исправить, вы можете сделать это, не прерывая сеанс. Для этой цели IntelliJ IDEA предоставляет функциональные возможности, позволяющие настраивать и перезагружать фрагменты кода на лету.Этот подход описан в теме «Перезагрузка модифицированных классов».

Если вы новичок в отладке, мы рекомендуем вам изучить учебник «Отладка вашего первого приложения Java».

Обновления отладчика

Если вы уже знакомы с отладчиком IntelliJ IDEA и хотите получить обзор различных полезных функций и подходов, посмотрите серию видеороликов «Обновление отладчика».

Debugger Essentials охватывает основные темы, такие как точки останова на строке, пошаговое выполнение, управление сеансом отладки, отслеживание, оценка выражений и условия точки останова.