Ешь, двигайся, спи Жесткий подход Дэна Кеннеди Телефоны Бизбук - c 10 до 18 по будним дням
 
Наши проекты:
Вход для зарегистрированных пользователей
Регистрация нового пользователя
Каталог книг Новинки Анонсы Заказы / Корзина Рассылка Оплата и Доставка Контакты
Вы находитесь в разделе каталога:
• Java Persistence API и Hibernate, Бауэр К., Кинг Г., Грегори Г.


Java Persistence API и Hibernate
Java Persistence API и Hibernate
Бауэр К., Кинг Г., Грегори Г.
Год выпуска: 2016
Изд-во: ДМК
ISBN: 978-5-97060-180-8
Переплёт: твердый
632 страниц
Цена: 1225.00 грн.
Временно отсутствует     Оставить заявку
Java Persistence – механизм, помогающий обеспечить сохранность данных после завершения программы, что является главной чертой современных приложений. Hibernate – наиболее популярный инструмент Java для работы с базами данных, предоставляющим автоматическое прозрачное объектно-реляционное отображение, что значительно упрощает работу с SQL-базами данных в приложениях Java. Данная книга описывает разработку приложения с использованием Hibernate, связывая воедино сотни отдельных примеров. Вы сразу окунетесь в богатую моделями программирования среду Hibernate, которая основывается на отображениях, запросах, стратегиях выборки, транзакциях, диалогах, кэшировании и многом другом.

В книге "Java Persistence API и Hibernate" вы найдете хорошо иллюстрированное обсуждение лучших методик проектирования баз данных и методов оптимизации. Во втором издании авторы подробно описывают версию Hibernate 5 совместимый со стандартом Java Persistence 2.1.

Все примеры обновлены для последних версий спецификаций Hibernate и Java EE.

Из книги "Java Persistence API и Hibernate" вы узнаете:

- идея объектно-реляционного отображения;
- быстрая разработка приложений баз данных;
- исчерпывающее описание Hibernate и Java Persistence;
- интеграция Java Persistence с EJB, CDI, JSF и JAX-RS;
- непревзойденная широта и глубина охвата темы.

Отзывы экспертов:

«Самая полная книга о Hibernate! Одновременно и учебник, и руководство».
– Серхио Фернандес Гонсалес, Accenture Software

«Основной путеводитель по тонкостям Hibernate».
– Джоси Диас, OptumHealth

«Должна быть у каждого пользователя Hibernate».
- Стефан Хеффнер, SPIEGEL-Verlag Rudolf Augstein GmbH & Co. KG




Содержание книги "Java Persistence API и Hibernate"



Предисловие к первому изданию.............................................................................16
Введение............................................................................................................................................18
Благодарности.............................................................................................................................19
Об этой книге.................................................................................................................................21
Об изображении на обложке..........................................................................................24
Часть I. Начинаем работать с ORM...........................................................................25
Глава 1. Основы объектно-реляционного отображения.....................26
1.1. Что такое долговременное хранение?....................................................................................27
1.1.1. Реляционные базы данных................................................................................................28
1.1.2. Разбираемся с SQL...............................................................................................................29
1.1.3. Использование SQL в Java................................................................................................30
1.2. Несоответствие парадигм...........................................................................................................32
1.2.1. Проблема детализации.......................................................................................................33
1.2.2. Проблема подтипов..............................................................................................................35
1.2.3. Проблема идентичности.....................................................................................................37
1.2.4. Проблемы, связанные с ассоциациями.........................................................................38
1.2.5. Проблемы навигации по данным....................................................................................39
1.3. ORM и JPA.......................................................................................................................................41
1.4. Резюме...............................................................................................................................................43
Глава 2. Создаем проект....................................................................................................44
2.1. Представляем Hibernate.............................................................................................................44
2.2. «HELLO WORLD» и JPA...........................................................................................................45
2.2.1. Настройка единицы хранения..........................................................................................46
2.2.2. Хранимый класс....................................................................................................................47
2.2.3. Сохранение и загрузка сообщений.................................................................................49
2.3. Оригинальная конфигурация Hibernate...............................................................................51
2.4. Резюме...............................................................................................................................................54
Глава 3. Модели предметной области и метаданные...........................55
3.1. Учебное приложение CaveatEmptor.......................................................................................56
3.1.1. Многоуровневая архитектура..........................................................................................56
3.1.2. Анализ предметной области.............................................................................................58
3.1.3. Предметная модель приложения CaveatEmptor.......................................................59
3.2. Реализация предметной модели..............................................................................................61
3.2.1. Предотвращение утечек функциональности..............................................................61
3.2.2. Прозрачность сохранения и его автоматизация........................................................62
3.2.3. Создание классов с возможностью сохранения.........................................................64
3.2.4. Реализация ассоциаций в POJO....................................................................................67
3.3. Метаданные предметной модели.............................................................................................72
3.3.1. Определение метаданных с помощью аннотаций.....................................................73
3.3.2. Применение правил валидации компонентов............................................................75
3.3.3. Метаданные во внешних XML-файлах.........................................................................78
3.3.4. Доступ к метаданным во время выполнения..............................................................82
3.4. Резюме...............................................................................................................................................86
Часть II. Стратегии отображения...............................................................................87
Глава 4. Отображение персистентных классов...........................................88
4.1. Понятие сущностей и типов-значений..................................................................................88
4.1.1. Хорошо детализированные модели предметной области.......................................89
4.1.2. Определение сущностей приложения...........................................................................89
4.1.3. Разделение сущностей и типов-значений....................................................................91
4.2. Отображение сущностей с идентичностью..........................................................................93
4.2.1. Идентичность и равенство в Java....................................................................................93
4.2.2. Первый класс сущности и его отображение................................................................94
4.2.3. Выбор первичного ключа...................................................................................................95
4.2.4. Настройка генераторов ключей.......................................................................................97
4.2.5. Стратегии генерации идентификаторов.......................................................................99
4.3. Способы отображений сущностей.........................................................................................103
4.3.1. Управление именами.........................................................................................................103
4.3.2. Динамическое формирование SQL..............................................................................106
4.3.3. Неизменяемые сущности.................................................................................................107
4.3.4. Отображение сущности в подзапрос............................................................................108
4.4. Резюме.............................................................................................................................................110
Глава 5. Отображение типов-значений..............................................................111
5.1. Отображение полей основных типов...................................................................................112
5.1.1. Переопределение настроек по умолчанию для свойств основных типов.......112
5.1.2. Настройка доступа к свойствам.....................................................................................114
5.1.3. Работа с вычисляемыми полями...................................................................................116
5.1.4. Преобразование значений столбцов............................................................................117
5.1.5. Значения свойств, генерируемые по умолчанию....................................................118
5.1.6. Свойства для представления времени.........................................................................119
5.1.7. Отображение перечислений...........................................................................................120
5.2. Отображение встраиваемых компонентов....................................................................121
5.2.1. Схема базы данных.............................................................................................................121
5.2.2. Встраиваемые классы........................................................................................................122
5.2.3. Переопределение встроенных атрибутов...................................................................125
5.2.4. Отображение вложенных встраиваемых компонентов.........................................126
5.3. Отображение типов Java и SQL с применением конвертеров.....................................128
5.3.1. Встроенные типы................................................................................................................128
5.3.2. Создание собственных конвертеров JPA....................................................................135
5.3.3. Расширение Hibernate с помощью пользовательских типов..............................141
5.4. Резюме.............................................................................................................................................148
Глава 6. Отображение наследования..................................................................150
6.1. Одна таблица для каждого конкретного класса и неявный полиморфизм............151
6.2. Одна таблица для каждого конкретного класса с объединениями............................153
6.3. Единая таблица для целой иерархии классов...................................................................156
6.4. Одна таблица для каждого подкласса с использованием соединений.....................159
6.5. Смешение стратегий отображения наследования...........................................................163
6.6. Наследование и встраиваемые классы................................................................................165
6.7. Выбор стратегии..........................................................................................................................168
6.8. Полиморфные ассоциации.......................................................................................................170
6.8.1. Полиморфная ассоциация многие к одному (many-to-one)..................................170
6.8.2. Полиморфные коллекции................................................................................................173
6.9. Резюме.............................................................................................................................................174
Глава 7. Отображение коллекций и связей
между сущностями................................................................................................................175
7.1. Множества, контейнеры, списки и словари с типами-значениями............................176
7.1.1. Схема базы данных..............................................................................................................176
7.1.2. Создание и отображение поля коллекции..................................................................176
7.1.3. Выбор интерфейса коллекции........................................................................................178
7.1.4. Отображение множества...................................................................................................180
7.1.5. Отображение контейнера идентификаторов.............................................................181
7.1.6. Отображение списка...........................................................................................................182
7.1.7. Отображение словаря.........................................................................................................184
7.1.8. Отсортированные и упорядоченные коллекции.......................................................185
7.2. Коллекции компонентов...........................................................................................................188
7.2.1. Равенство экземпляров компонентов...........................................................................189
7.2.2. Множество компонентов...................................................................................................191
7.2.3. Контейнер компонентов....................................................................................................193
7.2.4. Словарь с компонентами в качестве значений.........................................................194
7.2.5. Компоненты в роли ключей словаря............................................................................195
7.2.6. Коллекции во встраиваемых компонентах.................................................................197
7.3. Отображение связей между сущностями............................................................................198
7.3.1. Самая простая связь............................................................................................................199
7.3.2. Определение двунаправленной связи..........................................................................200
7.3.3. Каскадная передача состояния.......................................................................................202
7.4. Резюме..............................................................................................................................................209
Глава 8. Продвинутые приемы отображения связей
между сущностями................................................................................................................211
8.1. Связи один к одному....................................................................................................................212
8.1.1. Общий первичный ключ...................................................................................................212
8.1.2. Генератор внешнего первичного ключа........................................................................215
8.1.3. Соединение с помощью столбца внешнего ключа...................................................218
8.1.4. Использование таблицы соединения............................................................................220
8.2. Связь один ко многим..................................................................................................................222
8.2.1. Применение контейнеров в связях один ко многим.................................................223
8.2.2. Однонаправленное и двунаправленное отображения списка..............................224
8.2.3. Необязательная связь один ко многим с таблицей соединения............................227
8.2.4. Связь один ко многим во встраиваемых классах........................................................229
8.3. Тройные связи и связи многие ко многим.............................................................................231
8.3.1. Однонаправленные и двунаправленные связи многие ко многим.......................232
8.3.2. Связь многие ко многим с промежуточной сущностью...........................................234
8.3.3. Тройные связи с компонентами......................................................................................239
8.4. Связи между сущностями с использованием словарей..................................................242
8.4.1. Связь один ко многим со свойством для ключа..........................................................242
8.4.2. Тройное отношение вида ключ/значение...................................................................243
8.5. Резюме..............................................................................................................................................245
Глава 9. Сложные и унаследованные схемы................................................246
9.1. Улучшаем схему базы данных..................................................................................................247
9.1.1. Добавление вспомогательных объектов базы данных............................................248
9.1.2. Ограничения SQL................................................................................................................251
9.1.3. Создание индексов..............................................................................................................258
9.2. Унаследованные первичные ключи......................................................................................259
9.2.1. Отображение естественных первичных ключей.......................................................259
9.2.2. Отображение составных первичных ключей.............................................................260
9.2.3. Внешние ключи внутри составных первичных ключей.........................................262
9.2.4. Внешний ключ, ссылающийся на составной первичный ключ...........................266
9.2.5. Внешние ключи, ссылающиеся на непервичные ключи........................................267
9.3. Отображение свойств во вторичные таблицы...................................................................268
9.4. Резюме..............................................................................................................................................270
Часть III. Транзакционная обработка данных..............................................271
Глава 10. Управление данными.................................................................................272
10.1. Жизненный цикл хранения...................................................................................................273
10.1.1. Состояния экземпляров сущностей..........................................................................273
10.1.2. Контекст хранения...........................................................................................................275
10.2. Интерфейс EntityManager.....................................................................................................277
10.2.1. Каноническая форма единицы работы.....................................................................277
10.2.2. Сохранение данных.........................................................................................................279
10.2.3. Извлечение и модификация хранимых данных....................................................280
10.2.4. Получение ссылки на объект.......................................................................................282
10.2.5. Переход данных во временное состояние................................................................283
10.2.6. Изменение данных в памяти........................................................................................285
10.2.7. Репликация данных.........................................................................................................285
10.2.8. Кэширование в контексте хранения..........................................................................286
10.2.9. Выталкивание контекста хранения...........................................................................288
10.3. Работа с отсоединенным состоянием...........................................................................289
10.3.1. Идентичность отсоединенных экземпляров..........................................................289
10.3.2. Реализация метода проверки равенства...................................................................292
10.3.3. Отсоединение экземпляров сущностей....................................................................295
10.3.4. Слияние экземпляров сущностей..............................................................................296
10.4. Резюме..........................................................................................................................................298
Глава 11. Транзакции и многопоточность.......................................................299
11.1. Основы транзакций..................................................................................................................300
11.1.1. Атрибуты ACID................................................................................................................300
11.1.2. Транзакции в базе данных и системные транзакции...........................................300
11.1.3. Программные транзакции с JTA.................................................................................301
11.1.4. Обработка исключений..................................................................................................303
11.1.5. Декларативное определение границ транзакции..................................................306
11.2. Управление параллельным доступом.................................................................................307
11.2.1. Многопоточность на уровне базы данных...............................................................307
11.2.2. Оптимистическое управление параллельным доступом...................................313
11.2.3. Явные пессимистические блокировки.....................................................................322
11.2.4. Как избежать взаимоблокировок...............................................................................325
11.3. Доступ к данным вне транзакции.........................................................................................327
11.3.1. Чтение данных в режиме автоматического подтверждения.............................328
11.3.2. Создание очереди изменений......................................................................................330
11.4. Резюме...........................................................................................................................................332
Глава 12. Планы извлечения, стратегии и профили.............................333
12.1. Отложенная и немедленная загрузка................................................................................334
12.1.1. Прокси-объекты................................................................................................................335
12.1.2. Отложенная загрузка хранимых коллекций...........................................................339
12.1.3. Реализация отложенной загрузки путем перехвата вызовов...........................342
12.1.4. Немедленная загрузка коллекций и ассоциаций..................................................345
12.2. Выбор стратегии извлечения................................................................................................347
12.2.1. Проблема n + 1 выражений SELECT........................................................................347
12.2.2. Проблема декартова произведения............................................................................348
12.2.3. Массовая предварительная выборка данных.........................................................351
12.2.4. Предварительное извлечение коллекций с помощью подзапросов...............354
12.2.5. Отложенное извлечение с несколькими выражениями SELECT...................355
12.2.6. Динамическое немедленное извлечение..................................................................356
12.3. Профили извлечения...............................................................................................................358
12.3.1. Определение профилей извлечения Hibernate......................................................359
12.3.2. Графы сущностей..............................................................................................................360
12.4. Резюме..........................................................................................................................................364
Глава 13. Фильтрация данных.....................................................................................365
13.1. Каскадная передача изменений состояния......................................................................366
13.1.1. Доступные способы каскадирования........................................................................367
13.1.2. Транзитивное отсоединение и слияние....................................................................367
13.1.3. Каскадное обновление....................................................................................................370
13.1.4. Каскадная репликация...................................................................................................372
13.1.5. Глобальное каскадное сохранение..............................................................................373
13.2. Прием и обработка событий............................................................................................374
13.2.1. Приемники событий JPA и обратные вызовы........................................................374
13.2.2. Реализация перехватчиков Hibernate.......................................................................378
13.2.3. Базовый механизм событий..........................................................................................383
13.3. Аудит и версионирование с помощью Hibernate Envers.............................................384
13.3.1. Включение ведения журнала аудита.........................................................................384
13.3.2. Ведение аудита..................................................................................................................386
13.3.3. Поиск версий......................................................................................................................387
13.3.4. Получение архивных данных.......................................................................................388
13.4. Динамическая фильтрация данных....................................................................................391
13.4.1. Создание динамических фильтров.............................................................................392
13.4.2. Применение фильтра.......................................................................................................392
13.4.3. Активация фильтра..........................................................................................................393
13.4.4. Фильтрация коллекций..................................................................................................394
13.5. Резюме..........................................................................................................................................395
Часть IV. Создание запросов........................................................................................397
Глава 14. Создание и выполнение запросов................................................398
14.1. Создание запросов....................................................................................................................399
14.1.1. Интерфейсы запросов JPA............................................................................................399
14.1.2. Результаты типизированных запросов.....................................................................402
14.1.3. Интерфейсы Hibernate для работы с запросами...................................................402
14.2. Подготовка запросов................................................................................................................404
14.2.1. Защита от атак на основе внедрения SQL-кода.....................................................404
14.2.2. Связывание именованных параметров.....................................................................405
14.2.3. Связывание позиционных параметров.....................................................................406
14.2.4. Постраничная выборка больших наборов с результатами.................................407
14.3. Выполнение запросов..............................................................................................................409
14.3.1. Извлечение полного списка результатов.................................................................409
14.3.2. Получение единичных результатов...........................................................................409
14.3.3. Прокрутка с помощью курсоров базы данных.......................................................411
14.3.4. Обход результатов с применением итератора........................................................412
14.4. Обращение к запросам по именам и их удаление из программного кода.............413
14.4.1. Вызов именованных запросов......................................................................................414
14.4.2. Хранение запросов в метаданных XML...................................................................414
14.4.3. Хранение запросов в аннотациях................................................................................416
14.4.4. Программное создание именованных запросов.....................................................416
14.5. Подсказки для запросов.........................................................................................................417
14.5.1. Установка предельного времени выполнения........................................................418
14.5.2. Установка режима выталкивания контекста хранения.......................................419
14.5.3. Установка режима только для чтения.......................................................................419
14.5.4. Определение количества одновременно извлекаемых записей.......................420
14.5.5. Управление комментариями SQL...............................................................................420
14.5.6. Подсказки для именованных запросов.....................................................................421
14.6. Резюме..........................................................................................................................................422
Глава 15. Языки запросов...............................................................................................424
15.1. Выборка........................................................................................................................................425
15.1.1. Назначение псевдонимов и определение корневых источников
запроса...............................................................................................................................................426
15.1.2. Полиморфные запросы...................................................................................................427
15.2. Ограничения...............................................................................................................................428
15.2.1. Выражения сравнения....................................................................................................430
15.2.2. Выражения с коллекциями...........................................................................................434
15.2.3. Вызовы функций..............................................................................................................435
15.2.4. Упорядочение результатов запроса............................................................................438
15.3. Проекции.....................................................................................................................................439
15.3.1. Проекция сущностей и скалярных значений.........................................................439
15.3.2. Динамическое создание экземпляров.......................................................................441
15.3.3. Извлечение уникальных результатов........................................................................443
15.3.4. Вызов функций в проекциях........................................................................................443
15.3.5. Агрегирующие функции................................................................................................446
15.3.6. Группировка данных........................................................................................................447
15.4. Соединения.................................................................................................................................449
15.4.1. Соединения в SQL...........................................................................................................449
15.4.2. Соединение таблиц в JPA..............................................................................................452
15.4.3. Неявные соединения по связи.....................................................................................452
15.4.4. Явные соединения............................................................................................................454
15.4.5. Динамическое извлечение с помощью соединений.............................................456
15.4.6. Тета-соединения................................................................................................................460
15.4.7. Сравнение идентификаторов.......................................................................................461
15.5. Подзапросы.................................................................................................................................463
15.5.1. Коррелированные и некореллированные подзапросы........................................463
15.5.2. Кванторы.............................................................................................................................464
15.6. Резюме..........................................................................................................................................466
Глава 16. Дополнительные возможности запросов..............................467
16.1. Преобразование результатов запросов..............................................................................467
16.1.1. Получение списка списков............................................................................................469
16.1.2. Получение списка словарей..........................................................................................469
16.1.3. Отображение атрибутов в свойства компонента JavaBean................................470
16.1.4. Создание преобразователя ResultTransformer.......................................................471
16.2. Фильтрация коллекций..........................................................................................................472
16.3. Интерфейс запросов на основе критериев в Hibernate................................................475
16.3.1. Выборка и упорядочение...............................................................................................475
16.3.2. Ограничения......................................................................................................................476
16.3.3. Проекция и агрегирование............................................................................................478
16.3.4. Соединения.........................................................................................................................479
16.3.5. Подзапросы.........................................................................................................................481
16.3.6. Запросы по образцу.........................................................................................................482
16.4. Резюме..........................................................................................................................................484
Глава 17. Настройка SQL-запросов.......................................................................485
17.1. Назад к JDBC.............................................................................................................................486
17.2. Отображение результатов SQL-запросов.........................................................................488
17.2.1. Проекции в SQL-запросах.............................................................................................489
17.2.2. Отображение в классы сущностей.............................................................................490
17.2.3. Настройка отображения запросов..............................................................................492
17.2.4. Размещение обычных запросов в отдельных файлах..........................................504
17.3. Настройка операций CRUD..................................................................................................509
17.3.1. Подключение собственных загрузчиков..................................................................509
17.3.2. Настройка операций создания, изменения, удаления.........................................510
17.3.3. Настройка операций над коллекциями....................................................................512
17.3.4. Немедленное извлечение в собственном загрузчике...........................................514
17.4. Вызов хранимых процедур....................................................................................................517
17.4.1. Возврат результата запроса...........................................................................................518
17.4.2. Возврат нескольких результатов и количества изменений...............................519
17.4.3. Передача входных и выходных аргументов............................................................521
17.4.4. Возвращение курсора......................................................................................................524
17.5. Применение хранимых процедур для операций CRUD.............................................526
17.5.1. Загрузчик, вызывающий процедуру..........................................................................526
17.5.2. Использование процедур в операциях CUD..........................................................527
17.6. Резюме..........................................................................................................................................529
Часть V. Создание приложений.................................................................................531
Глава 18. Проектирование клиент-серверных приложений.........532
18.1. Разработка уровня хранения.................................................................................................533
18.1.1. Обобщенный шаблон «объект доступа к данным»....................................................535
18.1.2. Реализация обобщенных интерфейсов.....................................................................537
18.1.3. Реализация интерфейсов DAO....................................................................................539
18.1.4. Тестирование уровня хранения...................................................................................541
18.2. Создание сервера без состояния..........................................................................................543
18.2.1. Редактирование информации о товаре.....................................................................543
18.2.2. Размещение ставки..........................................................................................................546
18.2.3. Анализ приложения без состояния............................................................................550
18.3. Разработка сервера с сохранением состояния................................................................552
18.3.1. Редактирование информации о товаре.....................................................................553
18.3.2. Анализ приложений с сохранением состояния.....................................................558
18.4. Резюме..........................................................................................................................................561
Глава 19. Создание веб-приложений..................................................................562
19.1. Интеграция JPA и CDI............................................................................................................563
19.1.1. Создание экземпляра EntityManager........................................................................563
19.1.2. Присоединение экземпляра EntityManager к транзакциям..............................565
19.1.3. Внедрение экземпляра EntityManager......................................................................565
19.2. Сортировка и постраничная выборка данных................................................................567
19.2.1. Реализация постраничной выборки с помощью смещения или поиска.......567
19.2.2. Реализация постраничной выборки в уровне хранения.....................................570
19.2.3. Постраничная выборка...................................................................................................576
19.3. Создание JSF-приложений....................................................................................................577
19.3.1. Службы с областью видимости запроса...................................................................578
19.3.2. Службы с областью видимости диалога...................................................................581
19.4. Сериализация данных предметной модели.....................................................................590
19.4.1. Создание JAX-RS-службы.............................................................................................591
19.4.2. Применение JAXB-отображений................................................................................592
19.4.3. Сериализация прокси-объектов Hibernate..............................................................595
19.5. Резюме..........................................................................................................................................598
Глава 20. Масштабирование Hibernate..............................................................599
20.1. Массовые и пакетные операции обработки данных.....................................................600
20.1.1. Массовые операции в запросах на основе критериев и JPQL..........................600
20.1.2. Массовые операции в SQL............................................................................................605
20.1.3. Пакетная обработка данных.........................................................................................606
20.1.4. Интерфейс StatelessSession ..........................................................................................610
20.2. Кэширование данных..............................................................................................................612
20.2.1. Архтектура общего кэша в Hibernate........................................................................613
20.2.2. Настройка общего кэша.................................................................................................618
20.2.3. Кэширование коллекций и сущностей.....................................................................619
20.2.4. Проверка работы разделяемого кэша........................................................................623
20.2.5. Установка режимов кэширования..............................................................................625
20.2.6. Управление разделяемым кэшем................................................................................627
20.2.7. Кэш результатов запросов.............................................................................................627
20.3. Резюме..........................................................................................................................................630
Библиография............................................................................................................................631


Хотите оставить отзыв? У Вас возникли вопросы о книге "Java Persistence API и Hibernate, Бауэр К., Кинг Г., Грегори Г." ? Пишите:

* Текст сообщения:
 
  Отправить
Поиск по каталогу
 поиск в аннотациях
Искать

* Подробнее об условиях доставки смотрите в разделе "Оплата и Доставка" нашего магазина.
Если у Вас возникли вопросы как подобрать и купить книги в нашем интернет-магазине звоните с 9 до 18 по будним дням: Киев 331-04-53, Водафон (050) 809-56-66, Киевстар (067) 408-26-36, Лайф (063) 227-24-47, Интертелеком (094) 831-04-53 или пишите нам

 
   
  Programming - Dmitriy Kotov & Andrey Kotov