Crud java что это

Что такое CRUD простыми словами: функции, преимущества и примеры

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

Освітній курс від laba: PR-комунікації.
Побудуйте успішний образ вашого бренду.

В целом, работа с информацией сводится как раз к четырем основным операциям:

Інтенсивний курс від skvot: Ретуш фотографій.
Перетворіть свої знімки у шедеври.

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

Что такое CRUD

CRUD — это сокращение от английских слов, обозначающих эти четыре операции:

Функции CRUD

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

Рассмотрим эти функции и примеры их использования подробнее.

Освітній курс від mate.academy: UI/UX Design.
Творчий розвиток навичок дизайну.

Create

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

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

После нажатия этой кнопки отправляется HTTP-запрос POST к API нашего приложения. В приложении выполняется функция, которая отправляет к базе данных запрос на добавление новой записи.

Мы используем операцию Create , чтобы создать:

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

Творчий курс від skvot: 3D-художник персонажів.
Створюйте світ персонажів.

Read

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

Операция Read позволяет просматривать записи. Она не изменяет данные, но над ее результатами можно производить действия, например фильтровать список продуктов по указанным критериям.

Операция Read используется чтобы прочитать:

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

Update

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

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

Операция Update применяется, чтобы:

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

Delete

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

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

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

Операция Delete используется, например, когда:

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

Преимущества CRUD

Быстрое управление данными

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

Повышенная производительность

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

Масштабируемость решений

По мере роста организации растет и количество операций CRUD. Их универсальность упрощает масштабирование в соответствии с потребностями растущего бизнеса.

Удобный интерфейс

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

Безопасность данных

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

Удобство совместной работы

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

Оптимизация рабочего процесса

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

Упрощение резервного копирования и восстановления данных

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

В чем разница между CRUD и REST?

CRUD и REST — это два разных подхода к управлению данными в веб-приложениях.

Основное различие между CRUD и REST в том, что:

• CRUD определяет набор основных операций с данными (Create, Read, Update, Delete);
• а REST определяет стандарты для обмена данными между клиентом и сервером с использованием различных методов HTTP-запросов.

CRUD — это цикл из четырех основных команд для работы с базой данных. Это не архитектурная система.

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

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

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

Эти сайты создаются с помощью специальных платформ для разных языков программирования, в том числе:

• Java (iBAtis, JOOQ);
• Python (Django);
• PHP (Doctrine, Propel);
• .NET (LLBLGEN Pro, NHibernate).

REST (Representational State Transfer) — это архитектурный стиль, который используется для создания веб-сервисов. Он основан на протоколе HTTP и устанавливает стандарты для обмена данными между клиентом и сервером.

История создания REST

Создатель REST Рой Филдинг (Roy Fielding) определяет этот протокол как «абстракцию архитектурных элементов в распределенной системе гипермедиа».

Принципы REST были изложены в его кандидатской диссертации в 2000 году. До этого у веб-разработчиков не было стандарта, в соответствии с которым можно было бы разработать интернет-API и даже воспользоваться им.

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

Системы, совместимые с REST, называются RESTful-системами. Они характеризуются отделением работы сервера от работы клиента и действуют без сохранения состояния.

REST опирается на архитектуру RESTful, которая поддерживает HTTP для реализации веб-интерфейса, а CRUD можно соотнести с DDS, SQL или HTTP-методами.

Сейчас протоколом REST пользуется множество компаний, в том числе такие гиганты, как eBay и Amazon.

Что выбрать: CRUD или REST?

CRUD — это действие, которое выполняют для записи данных в базу данных, а REST совместим с любым объектом или ресурсом: от медиафайла до веб-сайта или документа и так далее.

REST-сервисы могут реализовывать CRUD-операции, используя различные HTTP методы, такие как:

• POST ( Create );
• GET ( Read );
• PUT ( Update );
• DELETE ( Delete ).

Но REST также поддерживает другие методы, например, HEAD, OPTIONS, PATCH и т.д.

REST — это надежная архитектура, охватывающую ресурсы и гипермедиа по протоколу HTTP. CRUD — это цикл обслуживания записей, которые хранятся в системах управления базами данных.

Таким образом, CRUD и REST — две разные концепции, но REST-сервисы могут использовать CRUD-операции для управления данными, что делает их взаимосвязанными.

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

• Масштабируемость. Архитектура REST привязана к единообразному интерфейсу и запрещает использовать различные интерфейсы для определенного API. Этот механизм обеспечивает масштабируемость REST.
• Простота. REST работает без сохранения состояния и отделяет клиент от сервера. Вся необходимая информация передается в запросе.
• Систематизация. REST эффективно использует механизм кэширования, определяя ответы, которые отправляет сервер.

Пример работы с пользователем в CRUD

Рассмотрим, как может выглядеть пример работы с пользователем в CRUD.

Допустим, есть сайт example.com, который принимает запросы к API и отправляет ответы в виде кода JSON.

Просмотр пользователей

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

Для этого отправляется запрос GET на URL-адрес http://example.com/users. При его успешном выполнении сервер отправляет HTTP-ответ 200 с данными:

< "users": [ < "id": 1, "name": "John Doe", "email": "[email protected]", "password": "Qw12h%63h" >, < "id": 2, "name": "Jane Doe", "email": "[email protected]", "password": "Ue7^4ls7$6" >, . ] >

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

Например, для получения пользователя с идентификатором 1 отправляется запрос GET на URL-адрес http://example.com/users/1. При его успешном выполнении сервер отправляет HTTP-ответ 200 с данными:

< "id": 1, "name": "John Doe", "email": "[email protected]", "password": "Qw12h%63h" >

Добавление пользователя

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

Например, чтобы добавить пользователя с именем Jack Smith , адресом [email protected] и паролем hKP*%8b3; , отправляется запрос POST на URL-адрес http://example.com/users/add с соответствующими данными:

< "name": "Jack Smith", "email": "[email protected]", "password": "hKP*%8b3;"

Обновление пользователя

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

Например, чтобы изменить адрес электронной почты пользователя с идентификатором 1 на [email protected] , на адрес http://example.com/users/1 отправляется запрос PUT с измененными данными:

Удаление пользователя

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

Например, для удаления пользователя с идентификатором 3 отправляется запрос DELETE по адресу http://example.com/users/3.

Если после этой операции отправить по данному адресу запрос GET, будет получен код 404, который означает, что запрошенных данных нет.

Заключение

CRUD ( Create , Read , Update , Delete ) — это основные операции, которые используются для управления данными в большинстве веб-приложений и систем управления информацией. Эти операции позволяют работать с базой данных, то есть создавать, читать, обновлять и удалять данные.

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

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

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

Операции CRUD — важный и неотъемлемый элемент при разработке веб-приложений и систем управления информацией, который обеспечивают простоту и универсальность управления данными.

Просто о сложном: API, его типы и CRUD-операции

На первый взгляд API и CRUD – сложные понятия, известные только профессиональным программистам. Но мы объясним их с помощью нескольких предложений. Давайте приступим.

API: определение

Application Programming Interface или API – переводится с английского как интерфейс программирования приложений, который позволяет двум программам взаимодействовать друг с другом. Его создают как для внутренних задач компании, так и для пользователей, а используют для получения и передачи информации с любой платформы.

Передаваемые данные получают, благодаря API-запросам, которые состоят из:

• места, принимающего его – endpoint;
• заголовка – header;
• способа передачи – method;
• самих данных – data.

Само взаимодействие между программными системами и сервером производится при помощи JSON – JavaScript Object Notation. Это текстовый формат передачи данных, который сможет прочитать любой пользователь и машина. Он имеет следующий вид:

Типы API

Существуют 4 основных типа API:

• открытый – не имеет ограничений на доступ;
• партнерский – открыт только отдельным клиентам и требует лицензию или права доступа;
• приватный – используется внутри компании для различных операций;
• составной – представлен комбинацией нескольких типов для ускорения процессов выполнения задач.

Application Programming Interface – это мощный инструмент, используемый повсеместно для повседневных и рабочих задач. Например, когда пользователь открывает приложение, оно подключается к сети Интернет и отправляет запрос на сервер. После происходит его выполнение и возвращение полученной информации на устройство в удобном для прочтения виде. Этот путь и есть API – полностью защищенный и высокопроизводительный способ передачи данных на стороне клиента и сервера.

CRUD-операции

Наиболее простые функции, которые должно выполнять любое завершенное приложение – это CRUD-операции. К ним относятся:

1. Create – создание;
2. Read – чтение;
3. Update – редактирование;
4. Delete – удаление.

Их используют для работы с базами данных. Если функции они применяются для получения доступа к информации через API подобно REST - их можно реализовать через стандартные HTTP-методы: PUT, POST, GET, PATCH и DELETE.

Больше интересных новостей

В чем секрет языка Go?

Сравниваем Java и Python или с чего лучше начать?

Как получить профессию разработчик игр?

Проблема специфичности CSS и ключевое слово !important

Что такое CRUD-приложение, и для чего он нужен?

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

Ответ написан более трёх лет назад
Нравится 8 1 комментарий

ThunderCat @ThunderCat Куратор тега Веб-разработка

Практически любой сайт можно назвать CRUD-приложением.
CREATE, UPDATE, DELETE — например, комментарии пользователей, или наполнение сайта информацией контент-менеджером через админку. READ, соответственно, самая базовая операция по получению информации из БД. Открыли главную страницу — вот и READ.

Ответ написан более трёх лет назад
Комментировать
Нравится 4 Комментировать

Если утрировать и свести к частному, то CRUD - это набор функций для работы с базой данных. Чтобы при каждом обращении к базе не писать громоздкие и неудобные всякие селекты на SQL, используется CRUD, который уже есть в современных фреймворках. При работе с базой как раз и применяются эти четыре операции - создание (create), чтение (read), обновление (update), удаление (delete). Иногда новичкам советуют самостоятельно написать CRUD-интерфейс (например, на "голом" PHP), так сказать, изобрести свой велосипед, чтобы лучше разобраться в самом языке и его тонкостях.

Ответ написан более трёх лет назад
Комментировать
Нравится 4 Комментировать
Php Developer

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

Ответ написан более трёх лет назад
Комментировать
Нравится Комментировать

Люблю программирование и IT-бизнес в частности =)
CRUD это система управления базами данных. Позволяет создавать, читать, изменять и удалять таблицы.
Ответ написан более трёх лет назад
Комментировать
Нравится Комментировать
Ваш ответ на вопрос

Войдите, чтобы написать ответ

• Веб-разработка

Как web.telegram.org сделал, что не видно в Network запросов?

• 1 подписчик
• 5 часов назад
• 62 просмотра

Знакомство с Maven, Spring, MySQL, Hibernate и первое CRUD приложение (часть 1)

Добрый день. В этой статье я хотел бы поделиться своим первым знакомством с такими вещами как Maven, Spring, Hibernate, MySQL и Tomcat в процессе создания простого CRUD приложения. Это первая часть из 4. Статья рассчитана в первую очередь на тех, кто уже прошел здесь 30-40 уровней, но за пределы чистой джавы пока не выбирался и только начинает (или собирается начинать) выходить в открытый мир со всеми этими технологиями, фреймворками и прочими незнакомыми словами.

Введение

Знакомство с новыми для меня технологиями и фреймворками я начинал с изучения различных примеров, в которых они использовались, потому что обычно я лучше всего что-то понимаю, когда вижу работу на примере полноценного приложения. Обычно в качестве таких примеров выступают CRUD-приложения (Create, Read, Update, Delete), в интернете полно таких примеров разной степени сложности. Проблема в том, что там обычно не объясняют подробно как, что и зачем там сделано, почему добавлена такая-то зависимость, почему нужен именно такой класс и т.д. В большинстве случаев берут уже полностью готовое приложение, с итоговым POM файлом, с конечными вариантами классов и просто пробегают по каждому, не заостряя внимания на мелочах, которые для опытного человека, наверное, кажутся очевидными. Я много таких примеров разобрал и обычно вроде как и понятно, как там все работает, но вот как к этому пришли не совсем ясно. Поэтому я решил будет не лишним такой пример не с позиции опытного разработчика, а с позиции новичка, который ни разу не имел дело со Spring, Hibernate и прочими вещами.

Я постараюсь как можно подробнее (насколько позволит мне мое понимание) описать весь свой путь создания CRUD приложения, начиная с чего-то простейшего уровня Hello World. В первую очередь я это делаю для самого себя, ибо когда что-то пытаешься описать, рассказать, объяснить, оно и в своей голове гораздо лучше усваивается и упорядочивается. Но если кому-то это будет полезно и поможет с чем-нибудь разобраться буду очень рад. В этом примере попробуем создать простое CRUD приложение с использованием Maven, Tomcat, Spring, Hibernate и MySQL. Предварительные шаги, такие как установка Maven, MySQL, использование Ultimate версии идеи и т.д. думаю нет нужды подробно расписывать, с этим проблем возникнуть не должно. Стоит отметить, что в этом примере настройка конфигурации будет происходить при помощи джава классов (что называется JavaConfig) без использования xml.

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

Итак, поскольку я новичек, то использовать какие-то непонятные архетипы не будем. Spring initializr так и вовсе пока звучит слишком страшно. Поэтому создадим самый обычный простой Maven проект. У меня нет доменного имени, так что в groupid напишу просто testgroup , а в artifactid напишу название, ну например, filmography (это будет список фильмов). Создаем проект и выбираем Enable auto-import когда идея это предложит. Благодаря этому каждый раз, когда мы будем вносить какие-либо изменения в POM файл (Project Object Model, в этом файле описывается вся структура Maven проекта) все сразу же автоматически будем применяться к проекту. Библиотеки будут браться из нашего локального репозитория, если они уже имеются у нас в наличии, либо, если будем использовать какие-то новые зависимости, с которыми раньше дел не имели, то Maven просто скачает их через интернет из центрального репозитория. Еще у Maven есть функция загружать исходники и документацию (Download Sources and/or Documentation). Тоже очень удобно, если что-то не понятно с каким-то классом или методом, можно зайти в исходники и посмотреть, как оно там все внутри устроено. Добавим пару деталей. Это будет веб-приложение, и мы будем использовать Tomcat. Для развертывания (deploy) приложения в Tomcat нужно передать его туда в виде war архива (Web Application Resource, специальный формат для веб-приложений). Для этого добавим в POM файл такую строчку, чтобы приложение собиралось в war архив:

Ну и еще понадобится специальная директория для веб-исходников, в нашем случае там будут лежать jsp страницы, какие-то веб-ресурсы. Создадим в main директорию webapp . Она должна называться именно так и находиться именно в main , так же как java и resources , потому что это стандартная структура каталогов Maven. Когда мы установили упаковку в war и тем самым определили, что это веб-проект, директория webapp будет автоматически помечена как Web application sources (на ней будет голубая точка) и все, что касается веб, будет искаться в этой папке. И еще один момент. По-умолчанию Maven использует версию языка 1.5, но я хочу использовать, например, версию 1.8 – Java 8 (Можно и 10 взять, или 11, но все равно никакие фишки оттуда использовать не планируется, так что пускай 8 будет). Решается это очень просто, пишем в гугле что-то вроде "Maven java 8" и смотрим что нужно добавить в POM файл, чтобы Maven компилировал наши классы для нужной версии. В итоге имеем следующее:

Подключение Spring MVC

Нужно с чего-то начать. По плану мы будем подключать базу данных, использовать Hibernate, но это все пока звучит как-то слишком страшно. Нужно сперва заняться чем-нибудь попроще. Spring MVC, это уже получше, с MVC паттерном уже давным-давно знакомы, он использовался в половине больших задач курса. Отсюда и начнем плясать. Для создания веб приложения со Spring MVC нам также понадобится Servlet-API, т.е. та штука, с помощью которой будет происходить взаимодействие запрос-ответ. Попробуем подключить это. Заходим в гугл, ищем нужные зависимости в репозитории Maven и добавляем их в pom.xml . В разделе External Libraries видно, что подгрузилась не только spring-webmvc, но и куча чего еще. Т.е. нам не нужно дополнительно подключать зависимости для spring core, context, beans и т.д. которые нам понадобятся, все необходимое подтянулось само вместе со spring-webmvc.

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

Простой пример. Допустим мы добавили зависимость, которая использует какое-то API, и заодно она подтянет для этого API какую-то реализацию. А потом мы добавили другую зависимость, которая использует тоже самое API и тоже подтягивает для этого какую-то его реализацию, но уже другую. Таким образом у нас в наличие будет 2 разные реализации одного и того же API. И если мы сами захотим где-то использовать какие-то методы этого API, тогда и возникнет проблема, ведь система не будет знать, какую именно реализацию нужно использовать, она выберет случайно, возможно не ту, что мы ожидали. А если явно указать зависимость для одной из реализаций, то приоритет будет отдан именно ей.

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

Еще одно замечание. Что означает provided в зависимости javax.servlet-api . Scope — это область действия зависимости, provided означает что зависимость будет доступна на этапе компиляции и тестирования приложения, но в архив она помещена не будет. Дело в том, что для развертывания (deploy) приложения мы будем использовать контейнер сервлетов, Tomcat, а у него внутри уже есть такие библиотеки, поэтому нет нужды передавать их туда и утяжелять архив лишним грузом. Забегая вперед, по той же причине мы обойдемся без привычного метода main , потому что он уже есть внутри Tomcat.

Создание страниц и контроллера

Попробуем теперь состряпать что-нибудь простенькое. Для начала создадим в webapp дополнительную директорию, например pages , в которой будут храниться наши представления (view), т.е. jsp-страницы, и создадим пару страниц. Нам понадобится страница, на которой в будущем будет отображаться список фильмов, допустим films.jsp , и еще, пожалуй, можно сделать отдельную страницу для редактирования, пускай это будет editPage.jsp . Пока ничем серьезным их заполнять не будем, просто для пробы сделаем на одной странице ссылку на другую. Теперь нужен класс, который будет обрабатывать запросы, т.е. контроллер. Добавим новый пакет controller и создадим в нем класс FilmController (вообще не обязательно расфасовывать все по разным пакетам, это приложение будет очень маленькое и простое, но в нормальном проекте может быть много контроллеров, классов конфигурации, моделей и т.д., поэтому даже начиная с маленьких проектов лучше сразу привыкать делать все упорядоченно и структурировано, чтобы не было каши). В этом классе создадим методы, которые будут возвращать наши представления в ответ на запросы.

 package testgroup.filmography.controller; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.servlet.ModelAndView; @Controller public class FilmController < @RequestMapping(value = "/", method = RequestMethod.GET) public ModelAndView allFilms() < ModelAndView modelAndView = new ModelAndView(); modelAndView.setViewName("films"); return modelAndView; >@RequestMapping(value = "/edit", method = RequestMethod.GET) public ModelAndView editPage() < ModelAndView modelAndView = new ModelAndView(); modelAndView.setViewName("editPage"); return modelAndView; >> 

Что тут к чему. У Spring MVC есть такая штука, как DispatcherServlet . Это как бы главный контроллер, все входящие запросы проходят через него и он уже дальше передает их конкретному контроллеру. Аннотация @Controller как раз и сообщает Spring MVC, что данный класс является контроллером (ну логично в общем-то), диспетчер будет проверять аннотации @RequestMapping чтобы вызвать подходящий метод. Аннотация @RequestMapping позволяет задать адреса методам контроллера, по которым они будут доступны в клиенте (браузер). Ее можно применять также и к классу контроллера, чтобы задать, так сказать, корневой адрес для всех методов. Для метода allFilms() параметр value установлен " / ", поэтому он будет вызван сразу, когда в браузере будет набрана комбинация http://host:port/ (т.е. по-умолчанию это http://localhost:8080/ или http://127.0.0.1:8080/). Параметр method указывает кокой тип запроса поддерживается (GET, POST, PUT и т.д.). Поскольку тут мы только получаем данные то используется GET. Позднее, когда появятся методы для добавления и редактирования там уже будут POST запросы. (Кстати вместо аннотации @RequestMapping с указанием метода, можно использовать аннотации @GetMapping , @PostMapping и т.д. @GetMapping эквивалентно @RequestMapping(method = RequestMethod.GET )). В наших методах создаем объект ModelAndView и устанавливаем имя представления, которое нужно вернуть.

Конфигурация

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

 package testgroup.filmography.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.ViewResolver; import org.springframework.web.servlet.config.annotation.EnableWebMvc; import org.springframework.web.servlet.view.InternalResourceViewResolver; @Configuration @EnableWebMvc @ComponentScan(basePackages = "testgroup.filmography") public class WebConfig < @Bean ViewResolver viewResolver() < InternalResourceViewResolver viewResolver = new InternalResourceViewResolver(); viewResolver.setPrefix("/pages/"); viewResolver.setSuffix(".jsp"); return viewResolver; >> 

@Configuration сообщает Spring что данный класс является конфигурационным и содержит определения и зависимости bean -компонентов. Бины (bean) — это объекты, которые управляются Spring'ом. Для определения бина используется аннотация @Bean . @EnableWebMvc позволяет импортировать конфигурацию Spring MVC из класса WebMvcConfigurationSupport . Можно также реализовать, например, интерфейс WebMvcConfigurer , у которого есть целая куча методов, и настроить все по своему вкусу, но нам незачем пока в это углубляться, хватит и стандартных настроек. @ComponentScan сообщает Spring где искать компоненты, которыми он должен управлять, т.е. классы, помеченные аннотацией @Component или ее производными, такими как @Controller , @Repository , @Service . Эти аннотации автоматически определяют бин класса. В методе viewResolver() мы создаем его реализацию и определяем где именно искать представления в webapp . Поэтому когда в методе контроллера мы устанавливали имя " films " представление найдется как " /pages/films.jsp " Итак, класс конфигурации у нас есть, но пока что это просто какой-то отдельный класс, он сам по себе и на наше приложение никак не влияет. Нам нужно зарегистрировать эту конфигурацию в контексте Spring. Для этого нужен класс AbstractAnnotationConfigDispatcherServletInitializer . В пакете config создаем его наследника, допустим AppInitializer, и реализуем его методы.

 package testgroup.filmography.config; import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer; public class AppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer < @Override protected Class[] getRootConfigClasses() < return new Class[0]; >@Override protected Class[] getServletConfigClasses() < return new Class[]; > @Override protected String[] getServletMappings() < return new String[]; > > 

В последнем методе регистрируются адреса и еще есть 2 метода для регистрации классов конфигурации. Веб-конфигурации, где определяются ViewResolver 'ы и тому подобное, помещаем в getServletConfigClasses() . Обо всем этом лучше почитать в документации и разных гайдах, но в нашем случае не обязательно пока в это углубляться, наш WebConfig в принципе можно и в RootClasses определить, можно даже и в оба сразу, все равно будет работать. Еще один момент. Возможно будут проблемы с кодировкой, когда при отправке с формы значений с русскими символами в результате будут получаться каракули. Для решения этой проблемы добавим фильтр, который будет заниматься предварительной обработкой запросов. Заходим в класс AppInitializer и переопределяем метод getServletFilters , в котором укажем нужную кодировку, она разумеется должна быть такой же как и везде, как на страницах и в базе данных:

 protected Filter[] getServletFilters() < CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter(); characterEncodingFilter.setEncoding("UTF-8"); characterEncodingFilter.setForceEncoding(true); return new Filter[] ; > 

Ну вроде все настроили, можно попробовать запустить и посмотреть, что получилось. Run -> Run -> Edit Configurations -> Add New Configuration -> Tomcat Server -> Local Далее нужно выбрать артефакт для развертывания. Идея сама даст подсказку Warning: No artifacts marked for deployment. Жмем кнопку fix и выбираем . war exploded. Либо можно зайти в Deployment -> add -> Artifact -> . war exploded. И еще нужно зайти в Deployment и установить в поле Applecation context (это будет частью url адреса, по которому приложение будет доступно в браузере) значение " / ". Тогда наше приложение будет сразу доступно по адресу http://localhost:8080/ (но также можно указать там что-то, ну например " /filmography ", и тогда просто нужно будет добавлять это ко всем адресам, т.е. например будет не "http://localhost:8080/edit", а будет "http://localhost:8080/filmography/edit"). Нажимаем Run и ждем пока запустится. Вот что у меня получилось: Вроде бы все хорошо, но есть тут один нюанс. Дело в том, что наши страницы сейчас общедоступны и доступ к ним можно получить напрямую, написав путь в адресной строке. Вводим http://localhost:8080/pages/films.jsp и вот мы без ведома контроллера получили нашу страницу. Как-то это не очень правильно, поэтому мы создадим в webapp специальную директорию WEB-INF . То, что внутри, будет скрыто для публики и получить доступ можно будет только через контроллер. Помещаем директорию с нашими представлениями ( pages ) в WEB-INF , а в ViewResolver соответственно добавляем ее в префикс:

 viewResolver.setPrefix("/WEB-INF/pages/"); 

Теперь по адресу http://localhost:8080 получаем нашу страницу, а если попытаться напрямую http://localhost:8080/WEB-INF/pages/films.jsp то получим ошибку 404. Ну вот, замечательно, у нас получилось простейшее веб-приложение, Hello World что называется. Структура проекта на данный момент выглядит так:

Модель

У нас уже есть представления и контроллер, но в MVC есть еще и 3-я буква, поэтому для полноты картины добавим еще и модель. В пакете model создадим класс Film ну, например, c такими полями: int id , String title (название), int year (год выхода), String genre (жанр) и boolean watched (т.е. смотрели уже этот фильм или нет).

 package testgroup.filmography.model; public class Film < private int id; private String title; private int year; private String genre; private boolean watched; // + Getters and setters >

Ничего особенного, самый обыкновенный класс, приватные поля, геттеры и сеттеры. Объекты таких классов еще называют POJO (Plain Old Java Object), ну т.е. "простой джава объект". Попробуем теперь создать такой объект и вывести его на странице. Пока не будем особо париться как его создавать, инициализировать. Для пробы просто тупо создадим его прямо в контроллере, например, вот так:

 public class FilmController

И добавим этот объект в наш ModelAndView с помощью метода addObject :

 @RequestMapping(method = RequestMethod.GET) public ModelAndView allFilms() < ModelAndView modelAndView = new ModelAndView(); modelAndView.setViewName("films"); modelAndView.addObject("film", film); return modelAndView; > 

Теперь мы сможем на нашей странице вывести этот объект. В films.jsp вместо Hello World напишем $ и сюда подставится объект, которому соответствует имя атрибута " film ". Попробуем запустить и посмотреть что получилось (для понятного вывода объекта у класса Film был переопределен toString() ):

Model-View-Controller

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

Когда мы пишем в строке браузера запрос, его принимает Dispatcher Servlet , далее он находит для обработки этого запроса подходящий контроллер с помощью HandlerMapping (это такой интерфейс для выбора контроллера, проверяет в каком из имеющихся контроллеров есть метод, принимающий такой адрес), вызывается подходящий метод и Controller возвращает информацию о представлении, затем диспетчер находит нужное представления по имени при помощи ViewResolver 'а, после чего на это представление передаются данные модели и на выход мы получаем нашу страничку. Как-то так. Продолжение следует. Знакомство с Maven, Spring, MySQL, Hibernate и первое CRUD приложение (часть 1) Знакомство с Maven, Spring, MySQL, Hibernate и первое CRUD приложение (часть 2) Знакомство с Maven, Spring, MySQL, Hibernate и первое CRUD приложение (часть 3) Знакомство с Maven, Spring, MySQL, Hibernate и первое CRUD приложение (часть 4)