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

Почему вы должны обратить внимание на Eclipse и чем он отличается от Borland JBuilder Foundation

Эта статья предназначена для программистов, знакомых со свободно распространяемой средой разработки Borland JBuilder X Foundation edition. В статье приведено краткое сравнение функциональных возможностей обеих IDE, простоты их использования и стабильности, а также демонстрируются основные задачи в Eclipse и как их выполнение отличается от JBuilder, так что вы сможете принять решение о том, подходит ли вам Eclipse.

David Gallardo, Консультант по программному обеспечению

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



08.09.2004

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

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

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

Eclipse - альтернатива с открытым исходным кодом

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

Интересный факт - многие первые пользователи Eclipse мигрировали с текстовых редакторов, а не с IDE. Это объясняет, почему они не переживали по поводу отсутствии какой-либо функциональности. Для многих это была первая IDE, которая не стояла на их пути, а просто давала возможность делать свою работу.

Более интересный вопрос - также ли хороша Eclipse, как платные IDE? Ответ - "да", но с некоторыми ограничениями. Прежде всего, это зависит от того, для чего вы намереваетесь использовать Eclipse. Если вам необходимо выполнить только основные этапы разработки - не нужно искать что-либо еще. Для кодирования, отладки, рефакторинга, тестирования модулей и т.п. Eclipse подходит лучше, чем что-либо еще. Так же как и свободно распространяемая JBuilder X Foundation edition, Eclipse имеет функции завершения кода, шаблоны кода и интегрированную поддержку рефакторинга, Ant, CVS, и JUnit. В действительности вы, возможно, найдете лучшую поддержку многих из этих функций в Eclipse, чем в JBuilder. Например, Eclipse имеет лучшую поддержку рефакторинга и слияния локального кода с кодом на CVS-сервере.

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

Кроме свободно распространяемых подключаемых модулей для Eclipse вы можете найти множество коммерческих модулей по приемлемой цене. Если вам необходимы некоторые продвинутые функции и вы считаете, что бесплатные подключаемые модули реализуют их не достаточно полно, вы, возможно, найдете более выгодным приобрести эти модули по отдельности у стороннего поставщика, чем покупать полный пакет корпоративной IDE. По причине своей популярности и открытости Eclipse имеет преимущество перед другими IDE - сотни доступных подключаемых модулей, бесплатных и коммерческих. Большинство из них вы можете найти, посетив Web-страницу Eclipse plug-ins, ссылка на которую приведена в разделе "Ресурсы".

Одной из отсутствующих (на момент написания статьи) в Eclipse 3.0 функциональных возможностей, которую давно имеет Jbuilder, является визуальное средство построения пользовательского интерфейса. Этот недостаток активно исправляется. Для Eclipse 2.1.x в данный момент доступен Eclipse Visual Editor (VE) версии 0.5, поддерживающий AWT/Swing, а для Eclipse 3.0 вскоре будет доступен VE версии 1.0. VE 1.0 будет доступен в виде отдельного пакета для загрузки на Web-сайте Eclipse и будет поддерживать не только AWT/Swing, но и SWT. Более подробный обзор VE и другую информацию вы можете найти в статье "Visual Editor", ссылка на которую приведена в разделе "Ресурсы".


Начало работы с Eclipse

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

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

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

Основная перспектива, с которой Eclipse начинает свою работу после закрытия окна приветствия, называется перспективой Resource. Она изображена на рисунке 1.

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

Сущность перспективы

Как и в JBuilder перспектива Resource в Eclipse имеет вид древовидной структуры; в верхней левой части расположен Navigator (который не показан на рисунке очевидно из-за того, что мы еще ничего не создали), позволяющий перемещаться по ресурсам и управлять ими. По умолчанию Resource Perspective содержит два других вида - вид Outline ниже Navigator и вид Task ниже основной области редактора.

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

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


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

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

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

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

Как было показано на рисунке 1, отобразится перспектива Resource. Всегда существует более одного способа что-либо сделать в 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 Perspective. Хотите ли вы перейти в эту перспективу сейчас?") Отметьте флажок "Remember my decision" ("Запомнить мое решение") и нажмите кнопку Yes.

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

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

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

Рисунок 2. Класс HelloObject
Класс HelloObject

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

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

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

Рисунок 3. Скрытие блоков кода и элементов To-do
Скрытие блоков кода и элементов To-do

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

Проверка синтаксиса и завершение кода

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

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

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

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

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

Функция завершения кода в Eclipse работает почти также как и в JBuilder, но по умолчанию она немного медленнее. Введя точку после названия, вы должны полсекунды подождать появления списка названий методов. (Потому что Eclipse старается не мешать вам при быстром вводе кода. Вы можете изменить это поведение, выбрав пункт Windows > Preferences > Java > Editor в основном меню и изменив поле "Auto activation delay" ("Задержка автоактивации") на другое значение в миллисекундах.) Если вы хотите увидеть варианты предложений, но не хотите ждать, можете нажать комбинацию клавиш Ctrl-Space для немедленного появления списка вариантов. Такое завершение кода особенно полезно в ситуации, когда вы забыли название необходимого метода: то ли put(), то ли add().

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

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

Аналогичным образом добавьте еще два названия к вектору - 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, вы увидите несколько вариантов, одним из которых является итерация по коллекции. Выберите этот вариант и вставится код для итерации по вектору names, как показано на рисунке 5:

Рисунок 5. Цикл for с итерацией по коллекции
Цикл for с итерацией по коллекции

Обратите внимание на то, что Eclipse окружил рамкой первый экземпляр каждого добавленного им идентификатора. Если вы измените один из них, Eclipse поменяет все остальные идентификаторы. При переименовании iter в i все остальные экземпляры iter автоматически переименуются в i. Единственное, что необходимо изменить, - это тип на 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, расположенном ниже редактора, должна появиться следующая информация:

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

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

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

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

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

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

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

Рисунок 7. Запуск Java-программы с настройками
Запуск Java-программы с настройками

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

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

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

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

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

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

Рефакторинг

Как и в JBuilder, одной из самых мощных возможностей Eclipse является способность выполнять рефакторинг кода. И хотя Eclipse имеет больше функций рефакторинга, чем JBuilder, а Jbuilder, в свою очередь, имеет одну или две функции, отсутствующие в Eclipse, в обеих программах присутствуют наиболее важные функции. Более подробную информацию о рефакторинге в Eclipse (и вообще о рефакторинге) можно найти в статье "Рефакторинг для всех", ссылка на которую приведена в разделе "Ресурсы".

Если вы использовали рефакторинг в JBuilder, вы заметите, что в Eclipse он почти такой же, за исключением того, что Eclipse использует мастер, который проведет вас по процессу. Используя этот мастер, вы имеете возможность использовать мощные диалоговые окна Eclipse для перемещения между изменениями, предложенными вам 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. Изменение сигнатуры метода
Изменение сигнатуры метода

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

Второй вариант "Я хочу управлять" более интересен. Он стоит того, чтобы быть увиденным хотя бы один раз. После нажатия кнопки Preview Eclipse отобразит диалоговое окно, которое дает возможность выбирать конкретные изменения во всех необходимых файлах сразу, или шаг за шагом, сравнивая результат с исходным вариантом в нижней части окна. (В этом случае, естественно, только в одном файле.) Сейчас вы можете попробовать рекомендуемый рефакторинг файл за файлом, изменение за изменением, и принять или отменить каждое изменение индивидуально, как показано на рисунке 10. Оставьте все изменения отмеченными и нажмите OK.

Рисунок 10. Диалог сравнения исходных кодов: рефакторинг типа "до и после"
Диалог сравнения исходных кодов: рефакторинг типа

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

Листинг 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);

Возможно позднее мы захотим изменить способ вывода object в зависимости от его типа. Сейчас вывод хорошо работает для строк, но для чего-нибудь другого object должен быть преобразован в строку при помощи метода toString(). Иногда это приводит к нежелательным результатам.


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

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

Другое отличие состоит в том, что Eclipse в некоторой степени ограничен в типе поддерживаемых им CVS-репозиториев. Прежде всего, он не поддерживает локального репозитория; то есть он не подключается к расположенному на диске CVS-репозиторию прямо, а должен использовать соединение клиент-сервер, а именно - pserver или ssh-протокол. Рекомендуется применять ssh, поскольку он более безопасен, чем pserver (последний передает пароль в текстовом незашифрованном виде). Для удобства Eclipse предоставляет встроенные клиенты для обоих протоколов.

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

Рисунок 11. Создание соединения с CVS-репозиторием
Создание соединения с 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 и вложенные папки, в которых находятся файлы с исходным Java-кодом (соответсвующие их пакетам): /Hello/com, /Hello/com/example и Hello/com/example/hello.

  • Нажмите кнопку Yes, если еще этого не сделали.
  • Появится запрос о вводе комментария; введите "Initial version".

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

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

Лучше использовать перспективу 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. Объединение локальных изменений с кодом из репозитория
Объединение локальных изменений с кодом из репозитория

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

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

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

Итоги

И Eclipse 3.0 и IntelliJ IDEA 4 предоставляют Java IDE с очень богатыми возможностями, обеспечивающими контроль синтаксиса, помощь при кодировании и генерацию исходного кода. Кроме того, оба приложения поддерживают рефакторинг, Ant, тестирование модулей и CVS. Вскоре будет доступна версия 1.0 Eclipse Visual Editor для построения GUI с использованием либо AWT/Swing, либо SWT. Но между ними существуют также и важные отличия.

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

Другим важным отличием является то, что Eclipse - это проект с открытым исходным кодом. Именно это привлекло большое сообщество разработчиков, проектирующих для Eclipse подключаемые модули, как свободно распространяемые, так и коммерческие. Если вам необходима какая-то функциональность (начиная с поддержки аспектно-ориентированной разработки и заканчивая встроенным MP3-проигрывателем - вы с большой степенью вероятности найдете бесплатный подключаемый модуль, обеспечивающий эту функциональность в 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=96414
ArticleTitle=Миграция на Eclipse: Руководство разработчика по сравнительной оценке Eclipse и JBuilder
publish-date=09082004