Изучение системы Java прежней версии
Мне кажется, что вы должны избавиться от переменной flight_d и блока IF и переместить логику в сам запрос, например:
CREATE OR REPLACE FUNCTION flightFunc(
flight_identificator INTEGER,
new_timestamp timestamp with time zone)
RETURNS TABLE(
flight_id INTEGER,
flight_no CHARACTER(6),
departure_airport character(3),
scheduled_departure timestamp with time zone,
arrival_airport character(3),
scheduled_arrival timestamp with time zone
)
LANGUAGE plpgsql
AS $
BEGIN
UPDATE flights SET
scheduled_departure = $2,
scheduled_arrival = $2 + flights.scheduled_arrival - flights.scheduled_departure
WHERE flights.flight_id = $1 AND flights.scheduled_departure < $2
RETURNING
flights.flight_id,
flights.flight_no,
flights.departure_airport,
flights.scheduled_departure,
flights.arrival_airport,
flights.scheduled_arrival;
END;
$;
10 ответов
Первой вещью, которую я делаю с любым новым кодом, который мне вручают, является взгляд на существующие модульные тесты. Запись новых тестов обычно является второй вещью.
Одна вещь, которая помогает мне работать с кодом, который плохо мне знаком - это намного менее необходимо для правильно написанного кода - должен в широком масштабе осуществить рефакторинг его в течение дня или два и затем отменить все мои изменения. Этот процесс помогает мне понять то, что делает код; работа с кодом помогает мне понять это. Это также начинает учить меня, какие части кода хрупки.
Если у Вас есть возможность миграции на более новый выпуск Java, то genericizing, все наборы помогут понять, какие типы данных розданы.
Конечно, я делаю это после установки программного обеспечения в тестовой лаборатории и проигрывании с нею немного для понимания то, что она делает.
Править: Размышление на моем ответе, также полезном, должно включить всю диагностическую трассировку и вход, чтобы использовать систему и затем изучить журналы. Если трассировка протокола связи будет существовать, то рассмотрение этой трассировки поможет понять протокол связи, используемый кодом, возможно, с трассировкой Wireshark того же тестирования.
Другая полезная миграция должна переместить от старой библиотеки Concurrency до нового Java 5 (и 6) библиотеку параллелизма. Это поможет Вам понять, где потоки и когда они запускаются и когда они закроются.
Конечно, с любым кодом изменяется на незнакомой кодовой базе, я предполагаю, что надлежащее тестирование сделано, чтобы гарантировать, что ничто не повреждается! Однако для балансировки этого я узнал, что после рефакторинга плохо записанного кода, ошибки, недавно представленные, часто намного легче найти, чем ошибки, которые существовали до рефакторинга.
Был разговор, который я посетил Mike Hill, в котором он говорил о процессе, который он использует для контакта с плохим унаследованным кодом. Он назвал это "микротестированием", и это в основном изолирует каждую вещь, которую Вы хотите протестировать (в ее собственном функциональном или маленьком объекте), и пишущие тесты вокруг этого. Эти тесты не означают утверждать вещи в деловом чутье - они просто предназначены для получения состояния, система оставлена внутри после того, как строки под тестом выполняются. Как правило, он утверждал бы, что переменные имели значения, которые они имели в отладчике. Естественно, эти тесты передали бы первоначально, но после того, как он записал достаточному количеству из них, у него эффективно будет снимок системы.
После того как те тесты существовали, он мог начать осуществлять рефакторинг тот бит кода, чтобы попытаться понять то, что он пытался сделать. Он мог сделать так безопасно, потому что его "микротесты" перестали бы работать, если бы он изменил способ, которым функция (или объект) вела себя даже немного. В то время как это означало, что он не мог сделать большие конструктивные изменения, он мог устранить много шума, и он мог получить изображение относительно того, что делала система. После того как у него было четкое представление относительно того, чего достигал код, он мог начать улучшать его, найдя ошибки, и т.д.
Нет многих бесплатных ресурсов на этом, которое является, почему я не предоставляю ссылки. Надо надеяться, мне удалось описать достаточно для давания Вам некоторое представление.
Это очень зависит от качества кодовой базы. На самом деле Вы могли определить его еще более узко - это зависит от того, насколько ясный код, и как хорошо прокомментированный это (и я пишу это как кто-то чей неоднократно в положении наследования плохо зарегистрированных кодовых баз прежней версии).
Чем хуже кодовая база, тем больше Вы испытываете необходимость для выведения ее функционирования из внешней стороны в - если Вы не можете выяснить то, что делает функция, можно, по крайней мере, смочь выяснить то, что GUI, кажется, подразумевает, что это делает. Наличие интерфейса RMI может быть благословением, в котором оно дает Вам упрощенное изображение того, что GUI должен видеть - абстрагирующий от удаленного интерфейса, очень хорошая идея.
Если кодовая база будет действительно плохими модульными тестами, то вероятно, не помогут Вам, поскольку можно тестировать что-то, что неправильно даже если правильно реализованный. Пример от последней вещи я наследовался: (имена и описания, удаленные намеренно - они не были полезны в оригинале в любом случае),
public static int[] a (List<int[]> input){
... lots of opaque rubbish
return b(input);
}
public static List<int[]> b{ List<int[]> input)
{
... more crap....
return some horribly mangled list of int[];
}
Как оказалось, какое выполненное должно было отсортировать массивы по значению их второго элемента. Тестирование b для поведения правильно было бы бесполезно в этом случае.
Предложения, чтобы помочь Вам сохранить свою исправность:
- удалите код, это ясно не используемо.
- Попытайтесь факторизовать любые "магические числа"
- найдите любой hardcode файл, путь или ссылки ресурса и факторизуйте их в свойства или любой другой центральный, универсальный способ иметь дело с ними.
- попытайтесь установить, выполняет ли приложение действительно способ, к которому оно предполагается - для некоторой действительно сложной функции весьма обычно, что Вы не можете сделать головы, или хвост на самом деле представляют что-то, что пользователи, которых чувствуют "никогда действительно, работали правильно".
- Найдите любую исходную документацию или спецификации от того, когда вещь была сначала разработана.
- Так как Вы упоминаете 1.4, genericizing карты может разъяснить, какие виды объектов становятся переданными. если у Вас есть объект, поддержанный HashMap, и как это становится заполненным, тайна, он может действительно упростить Вашу жизнь, чтобы решить, что это - на самом деле Карта Строк к Целым числам - это часто намного легче выяснить, чем, что он, как на самом деле предполагается, делает.
Конечно, большая часть из этого является ненужной, если кодовая база правильно написана, но затем Ваше задание будет намного легче в любом случае. И удача.
Первой вещью, которую я делаю при получении нового кода, является "попытка заставить его работать"! Этим я имею в виду:
сначала установите его (согласно примечаниям установки если таковые имеются)
затем ознакомьтесь с ним (путем чтения руководства пользователя и выполнения некоторых важных вариантов использования)
затем некоторый инженерный анализ для обнаружения основных слоев. классы и зависимости
затем я могу думать о записи новых тестовых сценариев (на приемном уровне сначала, который будет полезен для регрессионного тестирования позже),
затем я даю мне некоторые "проблемы" о добавлении этой опции (даже если это не требуется), или улучшение производительности той существующей функции: это - хороший способ вырыть в существующую кодовую базу
конечно, если будут некоторые известные незаконченные ошибки/RFE, то я буду работать над ними сначала
В Вашем конкретном случае я также попытался бы зарегистрировать вызовы RMI, что вызов или последовательность вызовов, чтобы сделать то, что, и связывают его с функциями уровня использования, если это возможно.
Кроме того (и это должно быть на первом месте на самом деле), одной важной вещью знать являются основные цели этой системы (почему у Вашего клиента есть эта система для?). Знание целей и имение в виду их избегут Вас отделяющийся далеко от этих целей при поддержании кода.
Опыт показал мне, что существует 3 главных цели, которые Вы имеете при изучении унаследованной системы.
- Изучите то, что код, как предполагается, делает
- Изучите, как это делает их
- (кардинально) Изучите, почему это делает их способ, которым это делает
Все три из тех частей очень важны, и существует несколько приемов, чтобы помочь Вам начать.
Во-первых, сопротивляйтесь искушению просто щелкнуть при нажатой клавише Ctrl (или безотносительно Вашего использования IDE) по Вашему пути вокруг кода для понимания всего. Вы, вероятно, не сможете сохранить все в перспективе в Вашем уме этим путем, особенно когда каждая строка вынудит Вас посмотреть на несколько других классов для понимания, каково это.
Прочитайте документацию где возможный; это обычно помогает Вам быстро получить умственную платформу, на которой можно создать все, что следует.
Выполните тестовые сценарии, если это возможно.
Не бойтесь спросить кого-то, кто знает, есть ли у Вас вопрос. Предоставленный, Вы не должны тратить впустую время других сотрудников с глупыми запросами, но если существует что-то, что Вы просто не понимаете (это особенно верно с большим количеством концептуальных вопросов как, "Не был бы он иметь намного больше смысла реализовать это как ___" или что-то), вероятно, стоит узнать ответ, прежде чем Вы испортите что-то и не будете знать почему.
При действительно окончательном переходе к чтению кода запустите в логическом "основном" месте и пойдите оттуда. Только прочитайте код, от начала до конца, или в алфавитном порядке, или что-либо (это, вероятно, очевидно).
Java 1.4 с RMI не является наследием, это является практически новым по некоторым стандартам!
Сделайте то, что можно сделать для ознакомления с тем, где вещи - модульные тесты, прослеживая код/вызовы, обрабатывая некоторые диаграммы UML, и т.д.
Попытайтесь запуститься с меньшего раздела его и проследить пути выполнения кода, чтобы познакомиться с тем, где вещи - или присваивают себе некоторых маленькие меры/улучшения, которые требуют просмотра кода.
Сначала скользите через код для понимания его структуры. Затем запустите приложение в режиме отладки и пробегите его пару раз. Это покажет Вам поток и структуру.
Используйте Netbeans для инженерного анализа диаграмм классов.
Сборка и выполненный это была бы моя первая вещь. Начните получать смысл для проблемы, которую он пытался решить.
Возможно, можно импортировать его в инструмент UML как JUDE и получить изображение того, как классы взаимодействуют.
Запись, которую тестирует JUnit, является превосходным предложением. Я хотел бы видеть, насколько многоуровневый приложение было. Если трудно протестировать, возможно, это слишком связано. Модульные тесты скажут Вам это. Они также дадут Вам систему поддержки, если Вы решите, что некоторый рефакторинг в порядке.
JDK 1.4? Это проходит конец своей жизни поддержки. Я также хотел бы видеть, будет ли код создавать и работать под JDK 5 как минимум, предпочтительно JDK 6. Возможно, Вы могли хлопнуть несколько из тех тестов JUnit в JMeter и сделать нагрузочный тест быстрого бедного человека с 5 одновременными пользователями.
Если у Вас есть модель данных, вытяните это в ERWin и начните видеть, как таблицы, объекты и экраны текут вместе.
Конечно, Вы могли попробовать шаг через. Ее медленное, но потраченный обход дня через код могло бы сохранить неделю ошибки, ищущей позже...
Вы могли также попробовать подход охоты на мусор, составить список каждой функции и пойти, ищут код для него...