Миграция на Eclipse: Руководство разработчика для сравнительной оценки Eclipse и Netbeans

Почему вы должны рассмотреть возможность использования Eclipse, и чем эта среда отличается от Netbeans

В настоящее время большинство Java-программистов слышало об Eclipse, расширяемой платформе разработки с открытыми исходными кодами, быстро ставшей наиболее популярной IDE для Java-программирования. Если вы программируете в Netbeans, но рассматриваете возможность перехода на Eclipse - эта статья для вас. В данной статье рассматриваются важнейшие особенности Eclipse (и как они отличаются от аналогичных в Netbeans, начиная с краткого сравнения функциональных возможностей обеих IDE, простоты их использования и стабильности), для того чтобы вы смогли решить, подходит ли для вас Eclipse.

Дэвид Галлардо, консультант по программному обеспечению

Дэвид Галлардо (David Gallardo), автор Studio B, является независимым автором и консультантом по программному обеспечению, специализирующимся в области интернационализации программного обеспечения, Java Web-приложений и разработки баз данных. Он является профессиональным инженером-программистом с более чем 15-летним опытом во многих операционных системах, языках программирования и сетевых протоколах. Он является ведущим разработчиком баз данных и интернационализации программного обеспечения в TradeAccess, Inc, business-to-business e-commerce компании. Перед этим он работал старшим инженером группы International Product Development в Lotus Development Corporation, в которой участвовал в разработке кросс-платформенной библиотеки, обеспечивающей поддержку Unicode и интернациональных языков для продуктов Lotus, включая Domino. Дэвид является соавтором книги "Eclipse в действии: руководство для Java-разработчиков" (Independent Pub Group, 2003). Информация для контактов - david@gallardo.org.



08.09.2004

Для программистов IntelliJ IDEA и JBuilder

Если вы подумываете о переходе на Eclipse, прочтите другие статьи по миграции Дэвида Галлардо на developerWorks:

Также посетите Web-страницу developerWorks Migration station, на которой можно найти много других советов по миграции на основанные на открытых стандартах средства разработки.

Сравнение IDE с точки зрения потребителя

Проведя большое количество времени за использованием IDE, вы, вероятно, выработали стойкое мнение о том, какая IDE является наилучшей. Некоторые программисты могут считать Emacs пережитком, в то время как другие программисты покинут его только тогда, когда их холодные мертвые пальцы снимут с клавиатуры. Одна IDE лучше другой только в смысле повышения продуктивности вашей работы; для программиста, кодирующего на C в Emacs на протяжении 20 лет, она является продуктивной средой.

Поскольку язык программирования Java относительно молод, нет большого наследия кодирования в какой-либо среде разработки (по крайней мере, пока!). Популярность каждой из различных Java IDE проходит периоды подъема и падения в гонке по предоставлению новых функций, повышению производительности и упрощению использования. Наиболее интересной новой разработкой стали две свободно распространяемые, расширяемые IDE с открытым исходным кодом: Netbeans и Eclipse. Они быстро достигают возможностей коммерческих предложений. Большинство разработчиков не нуждаются больше ни в чем, кроме того, что предлагают две эти отличные платформы разработки.


Сравнение Netbeans и Eclipse

Самые последние версии этих двух IDE (Netbeans 3.6 и Eclipse 3.0) имеют значительно больше сходств, чем различий. Они обе поддерживают проверку синтаксиса, завершение кода и свертывание кода. Они обе позволяют выполнять компилирование, запуск и отладку вашего кода. Обе поддерживают Ant, CVS и JUnit. Также, обе теперь имеют интегрированные GUI-конструкторы, хотя в Eclipse он представлен отдельным компонентом, Visual Editor, который вы должны загрузить отдельно. Более подробная информация по Eclipse Visual Editor приведена в статье "Построение GUI с Eclipse Visual Editor" (см. раздел "Ресурсы").

Основные отличия между этими двумя IDE: Netbeans имеет интегрированную поддержку Web-разработки, а Eclipse нет; Eclipse поддерживает автоматический рефакторинг, а Netbeans нет. Но даже если для вас это важно, отсутствие конкретной функциональной возможности не должно быть решающим фактором. Поскольку обе IDE являются расширяемыми и используют подключаемые модули, вы найдете свободно распространяемые или недорогие модули, способные заполнить эти пробелы. Статьи, рассматривающие получение, установку и использование подключаемых модулей для разработки Struts и Web-приложений с Tomcat, перечислены в разделе "Ресурсы".

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


Вопрос перспективы

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

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

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

Основная перспектива, с которой Eclipse начинает свою работу, появляется после закрытия начального экрана Welcome и называется перспективой Resource (рисунок 1).

Рисунок 1. Перспектива Eclipse Resource
Рисунок 1. Перспектива Eclipse Resource

Аналогично Netbeans, перспектива Resource имеет окно с древовидным списком в левом верхнем углу (в котором вы можете просматривать и управлять ресурсами), называемое Navigator. Это окно, как и большинство окон в Eclipse, называется видом (view). Первоначально в перспективе Resource находятся еще два вида - Outline ниже Navigator и Task ниже основной области редактора.

Eclipse различает виды и редакторы. Перспектива может иметь несколько видов, но только один редактор, являющийся центральной областью рабочего места. Вообще говоря, если вы открыли файл в редакторе, остальные виды отражают различные аспекты этого файла. Если это Java-файл (и вы находитесь в перспективе Java), один вид, Package Explorer, показывает физическое расположение в файле и иерархии пакета, а другой вид, Outline, показывает (среди прочего) методы и атрибуты класса. Если у вас имеется несколько Java-файлов, эти виды меняются при переключении между различными файлами в редакторе.

Хотя открыть новые перспективы и переключаться между ними легко, в основном в этом нет необходимости, поскольку во время работы перспективы меняются автоматически соответствующим образом (естественно, Eclipse сначала вежливо попросит у вас разрешения). Вы увидите это через минуту, когда мы будем создавать Java-проект, и позднее, когда будем отлаживать Java-программу. После некоторого использования перспектив, вы, возможно, обнаружите, что они предлагают дружественный и естественный способ работы, поскольку удаляют не соответствующие текущей работе кнопки, меню и виды из UI-инструментов. Это значительно облегчает поиск подходящих инструментов.


Создание нового проекта в Eclipse

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

Для понимания использования слова "проект" в Eclipse важно, прежде всего, понимать то, что Eclipse связан с каталогом, называемым workspace (рабочая область). Когда вы запускаете Eclipse в первый раз, отображается запрос на указание месторасположения этого каталога (предполагая, что вы не указали это как параметр командной строки), и Eclipse создает его, если он еще не существует. По умолчанию вся ваша информация (некоторая специфичная для Eclipse информация: ваши файлы с исходным Java-кодом и классами, изображения и т.д.) хранится в подкаталогах (или папках) этого каталога. Каждая папка в этом каталоге соответствует проекту и обычно содержит автономное приложение, Web-приложение или компонент некоторого типа.

Хотя рекомендуется использовать workspace (поскольку это позволяет сохранять лучшую организацию), Eclipse 3.0 предоставляет возможность создавать или указывать существующие каталоги вне каталога workspace для использования в качестве папки проекта. Это может быть особенно полезно при миграции с другой IDE, которая не использует строго организованную структуру каталогов.


Приступим к кодированию

Если вы хотите продолжать и еще не запустили Eclipse, сделайте это сейчас. Если вы еще не установили Eclipse, вы можете обратиться за помощью к статье "Начало работы с платформой Eclipse" (см. раздел "Ресурсы"). При первом запуске Eclipse отображается экран Welcome. Он предлагает перейти к учебным материалам и другим интересным темам, но пока закройте его, нажав кнопку "X" вверху экрана; вы можете вызвать этот экран позже, выбрав Help > Welcome из главного меню.

Отобразится перспектива Resource (рисунок 1). Всегда существует более одного способа сделать что-либо в Eclipse (используя клавиатурные сокращения, инструментальные панели или пункты меню), но в данной статье мы будем использовать меню. Сейчас мы создадим проект, используя контекстное меню следующим образом:

  • В перспективе Resource нажмите правой кнопкой мыши в виде Navigator и выберите New>Project.
  • Выберите Java Project в мастере New Project.
  • Введите название проекта, например "Hello".
  • Обратите внимание на то, что в секции Location есть вариант создания проекта в любом месте, но выберите значение по умолчанию "Create project in workspace" (Создать проект в рабочей области).
  • В секции Project Layout тоже примите значения по умолчанию "Use project folder as root for sources and class files" (Использовать папку проекта в качестве корневой для исходных файлов и файлов классов). Как правило, лучше использовать отдельные каталоги (обычно src и bin), но для простоты мы пока просто выберем значение по умолчанию.
  • Нажатие Next позволяет сконфигурировать библиотеки и добавить другие проекты в classpath, от которых данный проект зависит, но нам не нужно этого делать. Поэтому, нажмите Finish.
  • Через мгновение Eclipse спросит: "This kind of project is associated with the Java Perspective. Do you want to switch to this perspective now?" (Этот тип проекта связан с перспективой Java. Хотите перейти в эту перспективу сейчас?). Отметьте флажок "Remember my decision" (Запомнить мой выбор) и нажмите кнопку Yes.

Теперь, когда у нас есть проект, мы можем создать класс. Мы создадим вариант стандартной программы "Hello, world".

  • Нажмите правой кнопкой мыши на проект Hello и выберите New>Class. Это вызовет появление мастера New Class.
  • Введите com.example.hello в качестве названия пакета.
  • Введите HelloObject в качестве названия класса.
  • Оставьте java.lang.Object в качестве суперкласса.
  • Проверьте, что отмечен вариант создания заглушки (stub) для метода main().
  • Нажмите кнопку Finish (см. рисунок 2).
Рисунок 2. Класс HelloObject
Рисунок 2. Класс HelloObject

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

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

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

Рисунок 3. Свертывание кода в Java-редакторе
Рисунок 3. Свертывание кода в Java-редакторе

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

Теперь мы добавим некоторый код, для того чтобы поработать с ним. Добавьте строку в метод main(), создавая Vector с названием names. Поскольку вы не импортировали тип Vector, на левой границе редактора появится символ, красный прямоугольник со знаком "X", объединенным с желтой лампочкой (рисунок 4).

Рисунок 4. Проблема с QuickFix
Рисунок 4. Проблема с QuickFix

"X", естественно, обозначает проблему, но лампочка означает, что Eclipse имеет QuickFix - одно или несколько предложений по решению проблемы. Нажмите либо символ лампочки, либо Vector и комбинацию Ctrl-1 (клавиатурное сокращение QuickFix). Появится всплывающее окно, перечисляющее возможные исправления, включая "Import Vector", "Rename in File" и "Create Class Vector". Вы можете выполнить двойной щелчок мышкой по первому предложению, для того чтобы Eclipse добавил оператор import вместо вас.

Интересной особенностью Eclipse является использование инкрементного компилятора для компилирования вашего кода во время его ввода. Если имеются синтаксические ошибки, компилятор не может интерпретировать ваш код корректно и не может предоставить вам функцию QuickFix. Например, если вы не исправите указанную выше ошибку импорта, а продолжите вводить names в следующей строке, names будет подчеркиваться красной волнистой линией, указывающей на синтаксическую ошибку. Больше не будет указаний о том, что эта проблема связана с предыдущей строкой, где была определена переменная.

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

После правильного импорта Vector начните следующую строку снова, вводя names. Вы можете использовать функцию завершения кода для поиска нужного метода для добавления элементов в Vector names. Функция завершения кода в Eclipse работает точно также, как и в Netbeans - после ввода первой части типа или идентификатора нажмите Ctrl-Space и увидите список вариантов. Это особенно полезно, если вы забыли название требуемого метода (например, put() или add()?).

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

Зеленая линия - это точка вставки, и вы можете переместить курсор в эту точку, нажав клавишу Tab. Эта функция предоставлена потому, что после добавления аргумента для add() вы, по-видимому, захотите переместиться за скобки и добавить код или точку с запятой.

Добавьте строку "Moe" к Vector names. Когда вы введете открывающую кавычку, Eclipse предоставит закрывающую кавычку, переместив курсор между ними и предоставив новую точку вставки после закрывающей кавычки. После ввода "Moe" нажмите клавишу Tab для перемещения за закрывающую кавычку. Первая точка вставки после закрывающей круглой скобки появляется снова. Опять нажмите Tab для перемещения в конец оператора и введите точку с запятой.

Аналогичным способом добавьте еще два имени в Vector names: Curly и Larry. Код должен выглядеть следующим образом:

Листинг 1. Вставка кода
    public static void main(String[] args) {
        Vector names = new Vector();
        names.add("Moe");
        names.add("Curly");
        names.add("Larry");
        }
    }

Одной из прекрасных особенностей функции завершения кода в Eclipse является то, что она зависит от контекста. Здесь, если вы введете for и нажмете Ctrl-Space, вам будет предоставлено несколько вариантов, один из которых предназначен для итерации по коллекции. Выберите его, и вставится код, показанный на рисунке 5.

Рисунок 5. Цикл for для итерации по коллекции
A for loop that iterates over a collection

Обратите внимание на то, что первый экземпляр каждого идентификатора, который добавляет Eclipse, заключен в прямоугольник. Вы можете изменить его, Eclipse изменит идентификатор во всех других местах, где он появляется. Если вы переименуете iter в i, остальные экземпляры тоже автоматически переименуются. Единственное изменение, которое вы должны здесь сделать - поменять type на String, но вы можете также изменить element на name. Можно нажать Tab и Shift-Tab для перемещения между каждым из них. Вот как выглядит код после всех этих изменений и добавления вызова пока несуществующего метода greet():

Листинг 2. Переименование экземпляров
        for (Iterator i = names.iterator(); i.hasNext();) {
                String name = (String) i.next();
                greet(name);
        }

Затем используйте Eclipse QuickFix (например, указав на greet и нажав Ctrl-1) для генерирования метода-заглушки (stub) для greet() и добавьте в него следующий код:

Листинг 3. Использование QuickFix
    private static void greet(String name) {
          System.out.println("Hello, " + name);
    }

На данный момент времени код не содержит ошибок. Нажмите правую кнопку мыши в редакторе и выберите пункт Save из контекстного меню.


Выполнение и отладка ваших программ

Как уже упоминалось, Eclipse использует инкрементный компилятор, следовательно, нет необходимости явно компилировать ваши Java-файлы. Откомпилированные файлы классов сохраняются там, где вы храните ваши Java-файлы. Для выполнения вашей программы выберите Java-файл либо в редакторе, либо в Package Explorer, и выберите Run > Run As > Java Application из основного меню Eclipse (обратите внимание на то, что это отличается от варианта меню Run > Run..., который мы рассмотрим позднее). При этом в виде Console ниже Editor должна отобразиться следующая информация:

Листинг 4. Отображаемая в виде Console информация
Hello, Moe
Hello, Curly
Hello, Larry

В отладчике программа выполняется аналогично. Сначала установите точку прерывания на вызове greet() в методе main(), выполнив двойной щелчок (а не одинарный, как в Netbeans) на левой границе. Если вы хотите установить условную точку прерывания (которая останавливает выполнение программы при истинности конкретного выражения, например, i==2, или при прохождении этой точки указанное число раз), то можете нажать правой кнопкой мыши на точке прерывания и выбрать пункт Breakpoint properties из контекстного меню.

Для начала отладки выберите Run > Debug As > Java Application в основном меню. Поскольку Eclipse имеет перспективу Debug, которая лучше приспособлена для отладки, чем перспектива Java, Eclipse запросит вас подтвердить смену перспективы. Отметьте флажок "Remember my decision" и нажмите кнопку Yes, как показано на рисунке 6:

Рисунок 6. Перспектива Debug
Рисунок 6. Перспектива Debug

Большая часть видов перспективы Debug должна вам быть более или менее знакома по окнам в Netbeans, хотя они могут иметь различные названия. Вид Debug (не путайте с перспективой Debug) отображает стек вызовов, вид Variables отображает текущее состояние переменных программы, а вид Console отображает программу.

Вы также обнаружите наличие инструментальных кнопок (Step over, Step into и т.д.) для управления выполнением в инструментальной панели вида Debug. Причиной расположения здесь этих кнопок (вместе со стеком вызовов) является то, что при отладке нескольких программ (или экземпляров программы) или программы с несколькими потоками вы можете выбирать управляемую программу или поток, нажимая на нее в стеке вызовов. Если хотите, можете попробовать запустить этот пример программы повторно, не прерывая первый экземпляр.

Иногда вы не хотите (или не можете) запускать программу, используя выбор меню Run > Run As > Java Application. Если вам нужно передать аргументы либо в программу, либо в VM, на которой она работает, вы должны использовать вариант меню Run > Run.... Это вызовет появление диалогового окна, которое вы можете использовать для установки этих и других параметров, как показано на рисунке 7.

Рисунок 7. Конфигурация запуска Java
Рисунок 7. Конфигурация запуска Java

Повторный обзор перспективы Resource

Одной из полезных функций перспектив является то, что они предохраняют ваш экран от беспорядка. Вы, возможно, заметили, что, например, файлы классов не появляются в Package Explorer в перспективе Java. Предполагая, что Eclipse способен компилировать ваши Java-файлы (а я дам вам знать в противном случае), действительно не нужно ничего делать с ними для компоновки, запуска и отладки программы. Но, завершив работу, вы можете захотеть скопировать файлы классов в другой каталог или заархивировать их для передачи кому-нибудь по электронной почте.

Один из способов сделать это - выйти из Eclipse, поскольку вы знаете, где расположен ваш каталог workspace (нет ничего особенного в этом каталоге или каталоге Hello, в котором хранятся файлы вашего проекта). Но вы можете также сделать это и в Eclipse, выбрав File > Export из основного меню. Но сначала вы должны будете вернуться в перспективу Resource, для того чтобы увидеть все ваши файлы. Легче всего сделать это, нажимая кнопку перспективы Resource в верхнем правом углу рабочей области (рисунок 8).

Рисунок 8. Переключение на перспективу Resource
Рисунок 8. Переключение на перспективу Resource

Здесь вы увидите несколько файлов, который были скрыты в перспективе Java: ваш файл класса, HelloObject.obj и два файла метаданных, которые Eclipse использует для хранения информации о вашем проекте (.project и .classfile). Для архивирования вашего файла класса:

  • Выберите HelloObject.class.
  • Выберите File > Export в основном меню.
  • Выберите Zip file в качестве назначения экспорта и нажмите Next.
  • Файл для архивирования должен быть уже выбран на следующем экране; в поле "To zip file:" выберите или введите путь и имя zip-файла, который хотите создать, и нажмите кнопку Finish.

Рефакторинг

Netbeans имеет некоторые возможности генерирования кода, аналогичные рефакторингу, например способность генерировать методы getters и setters для атрибутов класса. Однако они отличаются от рефакторинга тем, что добавляют новую функциональность. Рефакторинг отличается от автоматического генерирования кода тем, что он реструктуризирует код без изменения его функциональности.

Если ваш код прошел полный набор JUnit-тестов, он должен продолжать проходить эти же тесты и после рефакторинга (в некоторых ситуациях модульные тесты и сами могут быть изменены при рефакторинге, но дело в том, что это тоже должно выполняться автоматически). Дополнительную информацию о рефакторинге и введение во многие функции рефакторинга, доступные в Eclipse, можно найти в статье "Рефакторинг для всех", ссылка на которую приведена в разделе "Ресурсы".

Давайте кратко рассмотрим относительно простой вид рефакторинга Change Method Signature (изменение сигнатуры метода). Мы используем его для изменения типа параметра String в методе greet() примера программы на тип Object, а также для добавления дополнительного параметра типа String для выводимого сообщения. Для этого:

  • Выберите метод greet(), нажав правой кнопкой мыши на его имени в редакторе или в виде Outline.
  • Выберите Refactor > Change Method Signature... из контекстного меню (см. рисунок 9).
  • В таблице Parameters нажмите тип String и измените его на Object.
  • Измените имя параметра на Object.
  • Нажмите кнопку Add справа; при этом добавится новая запись ниже существующего параметра. Измените тип этого нового параметра на String, его имя на greeting и значение по умолчанию на "Welcome,".
  • Мы хотим, чтобы новый параметр greeting был первым параметром; выделите его и нажмите кнопку Up (или выберите оригинальный параметр и нажмите кнопку Down).
Рисунок 9. Изменение сигнатуры метода
Рисунок 9. Изменение сигнатуры метода

Как и в случае со всеми функциями рефакторинга, у вас есть два варианта. Первый - вариант "Just Do It" (Посто выполнить). Обычно Eclipse выполняет рефакторинг корректно; в редких случаях, когда это не так, вы всегда можете отменить изменения, используя пункт меню Refactor > Undo (хотя это предложение полезно лишь ограниченное время после рефакторинга - если вы измените какие-либо файлы, то больше не сможете отменить рефакторинг.) Если вам это подходит, вы просто можете нажать OK. Обычно это самое простое действие, но не совершайте его сейчас.

Вторым вариантом является вариант "I want to micromanage" (Я хочу настроить); его интересно посмотреть, по крайней мере, один раз. Когда вы нажимаете Preview, Eclipse показывает диалоговое окно, позволяющее выбрать конкретные изменения во всех участвующих в проекте файлах в верхней части, сравнивая ниже файлы до и после рефакторинга (в данном случае, естественно, есть только один файл). Здесь вы можете контролировать предложенный рефакторинг файл за файлом, изменение за изменением, и подтвердить или отклонить изменение в индивидуальном порядке (рисунок 10). Оставьте все изменения отмеченными и нажмите OK.

Рисунок 10. Сравнение исходных Java-файлов: до и после рефакторинга
Рисунок 10. Сравнение исходных Java-файлов: до и после рефакторинга

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

Листинг 5. Код после рефакторинга
    public static void main(String[] args) {
        int x = 100;

        Vector names = new Vector();
        names.add("Moe");
        names.add("Curly");
        names.add("Larry");
        for (Iterator i = names.iterator(); i.hasNext();) {
            String name = (String) i.next();
            greet("Welcome, ", name);
        }
    }

    /**
     * @param greeting TODO
     * @param object
     */
    private static void greet(String greeting, Object object) {
            System.out.println("Hello, " + object);
    }

Обратите внимание на то, что рефакторинг обновил вызов метода greet() в методе main(), использовал значение по умолчанию Welcome для первого параметра, кроме изменения самого метода. Если бы в проекте присутствовали другие файлы, которые тоже вызывали бы greet(), они изменились бы аналогичным способом.

Если вы запустите программу сейчас, она выдаст точно такие же результаты, что и прежде, как и должно быть при любой процедуре рефакторинга. Таким образом, мы выиграли в способность выводить и использовать различные приветствия каждый раз при вызове метода greet(), но это функциональное изменение кода, которое мы должны сделать самостоятельно, изменяя вызов System.out.println() следующим образом:

System.out.println(greeting + Object);


Использование CVS

Хотя и Netbeans и Eclipse поддерживают CVS и другие системы управления версиями, Eclipse предоставляет значительно более проработанный интерфейс с использованием двух перспектив. Первая - это перспектива CVS Repository Exploring для выбора CVS-репозиториев и модулей для подключения к ним и просмотра содержащихся в них файлов. Вторая - это перспектива Team Synchronizing для объединения изменений в репозитории. Хотя это немного усложняет использование CVS на первом этапе, такой подход способствует дисциплинированному и структурированному рабочему процессу. Кроме того, Eclipse поддерживает больше типов соединений клиент-сервер, чем Netbeans. В частности, Netbeans имеет встроенную поддержку только протокола pserver, являющегося в своей основе незащищенным, поскольку передает пароли в открытом виде. Eclipse поддерживает и pserver, и ssh, который мы рассмотрим далее.

Для начала вы должны иметь доступ к CVS-репозиторию и информации, необходимой для подключения к нему. Откройте перспективу CVS Repository Exploring, выбрав Window > Open Perspective > Other в основном меню Eclipse и выбрав CVS Repository Exploring. Эта перспектива имеет несколько интересных видов, но главным является вид CVS Repositories, расположенный слева в верхней части. Нажатие здесь правой кнопкой мыши и выбор New > Repository Location позволяет вам ввести информацию, требующуюся для подключения к CVS-серверу (см. рисунок 11). Обратите внимание на то, что для использования ssh вам необходимо выбрать тип соединения extssh.

Рисунок 11. Создание соединения с CVS-репозиторием
Рисунок 11. Создание соединения с CVS-репозиторием

Для создания нового CVS-модуля из проекта Eclipse:

  • Перейдите в перспективу Java или Resource.
  • Нажмите правой кнопкой мыши на названии проекта и выберите Team > Share Project... из контекстного меню.
  • Появится диалоговое окно с отмеченным флажком "Use existing repository location selection" (Использовать существующий выбор месторасположения репозитория). Ниже него выбран репозиторий, который вы ввели раннее. Нажмите кнопку Next.
  • В следующем диалоговом окне выберите вариант использования названия проекта в качестве названия модуля и нажмите кнопку Next.
  • Следующее диалоговое окно позволяет вам просмотреть, что вы собираетесь зарегистрировать; если нет ошибок, нажмите кнопку Finish.
  • Последнее диалоговое окно предупреждает вас о том, что вы еще не подтвердили ваши изменения, и запросит их подтверждение. Нажмите кнопку Yes.

Теперь вы предупреждены о том, что шесть ресурсов еще не находятся под контролем системы управления версиями. Вы можете просто ответить Yes, если хотите, но если вам интересно знать, где находятся эти ресурсы, нажмите сначала кнопку Details. Вы обнаружите, что это два файла метаданных Eclipse (.project и .classpath), исходный Java-файл (HelloObject.java), и вложенные папки (/Hello/com, /Hello/com/example и Hello/com/example/hello), в которых хранятся исходные Java-файлы (в соответствии с их пакетом).

  • Нажмите Yes, если еще не сделали этого.
  • Отобразится запрос на ввод комментария. Введите "Первоначальная версия".

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

Вы можете разрешить и объединить ваш код с репозиторием двумя способами. Простейшим, и наиболее опасным, является простое обновление ваших локальных файлов изменениями из CVS-репозитория путем нажатия правой кнопки мыши на вашем проекте и выбора Team > Update из контекстного меню. Если изменения есть, они автоматически будут объединены с вашими файлами с использованием формата diff (большое количество знаков больше и меньше, отмечающих, какие строки есть в вашем коде, а каких нет в репозитории, и наоборот). Попытки исправить результаты такой операции могут быть трудоемкими и подвержены ошибкам.

Лучше использовать перспективу Eclipse Team Synchronizing, которая представляет вам измененные файлы в построчном режиме, что позволяет просмотреть и принять или отклонить изменения в любом файле. Для этого:

  • Нажмите правой кнопкой мыши на названии проекта и выберите Team > Synchronize with Repository из контекстного меню.
  • Вы будете предупреждены о том, что эта задача связана с перспективой Team Synchronizing, и сможете выбрать, переключаться в нее или нет. Отметьте "Remember my decision" и нажмите Yes.

Как и в большинстве других перспектив, первым представляемым вам видом является расположенный в левом верхнем углу рабочей области вид, в данном случае Synchronize. Сверху он имеет несколько инструментальных кнопок, включая Incoming Mode, Outgoing Mode, Incoming/Outgoing Mode и Conflicts Mode. Выбор режима главным образом зависит от того, где находятся изменения: в репозитории, в вашем локальном коде или в обоих местах (и конфликтуют или нет эти изменения между собой). Режим определяет, какие файлы показываются в этом виде: измененные локальные файлы, измененные файлы репозитория, или те и другие. Может показаться странным, но на практике вам не нужно беспокоиться о деталях; важным здесь является то, что ненужная информация отфильтровывается. Вы будете видеть только те файлы, которые должны просмотреть для синхронизации вашего кода с репозиторием.

Предположим, что вы добавили некоторый код в HelloObject (который, например, обрабатывает String не так, как другие объекты), и в то же время кто-то еще выполнил исходящую проверку кода в репозитории и сделал другие изменения (например, в методе main()). Возможно вы не знали, но перед входящей проверкой вашего файла в репозитории можно нажать правой кнопкой мыши на нем и выбрать Team > Synchronize with Repository.... При этом откроется перспектива Repository Synchronizing (по вашему разрешению, конечно) и покажет вам построчное сравнение вашего локального файла и файла в репозитории (см. рисунок 12).

Рисунок 12. Объединение локальных изменений с кодом в репозитории
Рисунок 12. Объединение локальных изменений с кодом в репозитории

Здесь вы можете просмотреть каждое изменение в каждом файле и либо скопировать его в ваш исходный код при помощи нажатия инструментальной кнопки Copy Right to Left в виде Java Source Compare, либо отредактировать локальный файл вручную соответствующим образом. Когда вы завершите объединение, отметьте файл как прошедший операцию объединения, нажав правой кнопкой мыши на имя файла в виде Synchronize и выбрав "Mark as Merged" из контекстного меню.

После разрешения всех конфликтов и объединения всех файлов в виде Synchronize вы должны вернуться в вид Java и проверить корректность компоновки и выполнения кода перед входящим контролем вашего кода в репозитории следующим образом:

  • Нажмите правой кнопкой мыши на названии проекта (или имени файла для предоставления одиночного файла) и выберите Team > Commit из меню проекта.
  • Введите комментарий при его запросе (обратите внимание на то, что при выполнении входящего контроля в репозитории проекта и изменении нескольких файлов эти комментарии будут применены для всех файлов; если вы пожелаете ввести комментарии для каждого файла по отдельности, то должны будете выполнить входящий контроль каждого файла индивидуально).

Резюме

По отдельным функциональным возможностям Eclipse и Netbeans хорошо соответствуют друг другу. Фактически, поскольку они обе являются расширяемыми, любой пробел в возможностях между ними может быть заполнен сторонними подключаемыми модулями. Важное отличие между этими двумя системами основано на дизайне пользовательского интерфейса. Eclipse организована вокруг концепции перспективы, облегчающей выполнение работы, поскольку соответствующие инструментальные средства (и только соответствующие инструментальные средства) находятся под рукой. Несколько дополнительных возможностей в Eclipse делают ее более эффективным средством для Java-программистов, например, такие как QuickFix, QuickDiff и легкая навигация по исходному коду при помощи закладок или схем классов. Также в Eclipse 3.0 полностью поддерживается CVS и рефакторинг, чего вы не найдете в Netbeans. Все это - достаточные причины для любого программиста, включая приверженцев Netbeans, попробовать и освоить Eclipse.

Ресурсы

Комментарии

developerWorks: Войти

Обязательные поля отмечены звездочкой (*).


Нужен IBM ID?
Забыли Ваш IBM ID?


Забыли Ваш пароль?
Изменить пароль

Нажимая Отправить, Вы принимаете Условия использования developerWorks.

 


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

Вся введенная информация защищена.

Выберите имя, которое будет отображаться на экране



При первом входе в developerWorks для Вас будет создан профиль и Вам нужно будет выбрать Отображаемое имя. Оно будет выводиться рядом с контентом, опубликованным Вами в developerWorks.

Отображаемое имя должно иметь длину от 3 символов до 31 символа. Ваше Имя в системе должно быть уникальным. В качестве имени по соображениям приватности нельзя использовать контактный e-mail.

Обязательные поля отмечены звездочкой (*).

(Отображаемое имя должно иметь длину от 3 символов до 31 символа.)

Нажимая Отправить, Вы принимаете Условия использования developerWorks.

 


Вся введенная информация защищена.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=40
Zone=Open source, Технология Java
ArticleID=145521
ArticleTitle=Миграция на Eclipse: Руководство разработчика для сравнительной оценки Eclipse и Netbeans
publish-date=09082004