веб приложение spring boot

Создание приложений с Spring Boot

Этот урок показывает пример того, как Spring Boot помогает вам ускорить и облегчить разработку приложений. Из учебных материалов вы увидите случаи использования Spring Boot. Если вы хотите создать проект на его основе, то посетите Spring Initializr, заполните онформацию о проекте, выберите опции и вы сможете загрузить файл сборки Maven, либо Gradle, либо как проект в виде zip-файла.

Что вы создадите

Вы создадите простое web-приложение с Spring Boot и добавите в него несколько полезных сервисов.

Что вам потребуется

Как проходить этот урок

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

Чтобы начать с нуля, перейдите в Настройка проекта.

Настройка проекта

Для начала вам необходимо настроить базовый скрипт сборки. Вы можете использовать любую систему сборки, которая вам нравится для сборки проетов Spring, но в этом уроке рассмотрим код для работы с Gradle и Maven. Если вы не знакомы ни с одним из них, ознакомьтесь с соответсвующими уроками Сборка Java-проекта с использованием Gradle или Сборка Java-проекта с использованием Maven.

Создание структуры каталогов

Создание файла сборки Gradle

Ниже представлен начальный файл сборки Gradle. Файл pom.xml находится здесь. Если вы используете Spring Tool Suite (STS), то можете импортировать урок прямо из него.

Spring Boot gradle plugin предоставляет множество удобных возможностей:

Узнайте, что вы можете делать с Spring Boot

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

Это лишь несколько примеров, которые предоставляет автоманическая настройка Spring Boot. В то же время, Spring Boot не заработает с вашими настройками. Например, если Thymeleaf в вашем classpath, то Spring Boot добавит SpringTemplateEngine в ваш контекст приложения автоматически. Но если вы определите свой собственный SpringTemplateEngine с вашими настройками, то Spring Boot не добавит его. Это останется под вашим контролем и потребует от вас немного усилий.

Создание простого web приложения

Теперь вы можете создать web контроллер для простого web приложения.

Создание Application класса

Здесь вы создаете Application класс с компонентами:

Метод main() используется Spring Boot методом SpringApplication.run() для запуска приложения. Вы обратили внимание, что нет ни одной строчки на XML? Файла web.xml нет вообще. Это приложение на 100% из чистой Java и вы ничего не делали для настройки какого-либо инструмента или инфраструктуры.

Метод run() возвращает ApplicationContext и этому приложению отдаются все бины, которые были созданы вашим приложением или автоматически добавлены благодаря Spring Boot. Метод сортирует бины и печатает их имена.

Запуск приложения

Для запуска приложения выполните:

Если вы используете Maven, то:

Вы должны увидеть примерно такое:

Добавление сервисов бизнес-уровня

Если вы создаете web-сайт для вашего бизнеса, то вам скорее всего необходимо добавить некоторые сервисы для управления. Spring Boot предоставляет несколько таких «из коробки» в одном из своих модулей, таких как состояние, аудит, бины и другие.

Добавьте это в список зависимостей вашего файла сборки:

Если вы используете Maven, то добавьте это в список зависимостей:

Затем перезапустите приложение:

Если вы используете Maven, то:

Вы увидите новый набор RESTful точек выхода, добавленных в приложение. Это сервисы управления, предоставленные Spring Boot:

это легко проверить по состоянию приложения:

Вы можете попытаться вызвать завершение работы через curl:

Т.к. мы не включили его, запрос блокирован, потому что его не существует.

Просмотр Spring Boot starters

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

ко всему прочему, Spring Boot поддерживает Groovy, позволяя вам создавать Spring MVC приложения в небольшом и единственном файле.

Создайте новый файл app.groovy и поместите в него приведенный ниже код:

Давайте проверим, что получилось:

Spring Boot динамически добавляет аннотации к вашему коду и использует Groovy Grape для подтягивания необходимых для запуска приложения библиотек. Смотрите документацию, если хотите копнуть шлубже.

Поздравляем! Вы только что создали простое web приложени с использованием Spring Boot и изучили как нарастить ваш темп разработки. вы также настроили некоторые удобные сервисы. Это только малая часть того, что может делать Spring Boot.

Источник

Spring Boot: быстрое знакомство и старт на примере простого веб-приложения

Авторизуйтесь

Spring Boot: быстрое знакомство и старт на примере простого веб-приложения

Senior Software Developer

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

Первоначальная настройка приложения

Переходим на сайт Spring Initializr и подготавливаем минимальный шаблон для нашего будущего приложения:

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

В левой части оставляем настройки по умолчанию, кроме версии Java (будет достаточно 8), и заполняем Project Metadata.

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

Всё готово, нажимаем GENERATE и получаем архив с исходным кодом проекта. Это минимальный каркас, который импортируем в используемую IDE.

В этом проекте используется IntelliJ IDEA.

В следующих диалоговых окнах все настройки оставляем по умолчанию. Единственное, в одном из окон удостоверимся, что имеем ранее установленную JDK соответствующей версии, в данном случае 8.

Если JDK не была установлена ранее, её можно скачать с официального сайта.

Все остальные окна кликаем Next и в последнем — Finish.

Кратко рассмотрим структуру проекта. В первую очередь интересны:

Создадим дополнительные пакеты :

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

Создадим класс Task в пакете entity

Класс помечен аннотацией @Entity. Она указывает на то, что данный класс является сущностью и будет сохраняться в БД.

Данная сущность имеет первичный ключ поле id. Поле помечено аннотацией @Id и аннотацией @GeneratedValue, которая задает стратегию генерации первичного ключа как автоматическую генерацию, в этой сущности – целые числа в порядке возрастания.

Создадим интерфейс TaskRepository в пакете repository

Класс унаследован от JpaRepository – интерфейса фреймворка Spring Data, предоставляющего набор стандартных методов JPA для работы с БД. Для данного приложения нет необходимости создавать дополнительные методы.

Создадим класс TaskService в пакете service

Класс содержит три метода для работы с задачами:

Создадим контроллер TaskController в пакете controller

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

Замечание. Более правильно было бы добавить еще один интерфейс TaskService, который будет реализовывать существующий класс TaskService (изменим название на TaskServiceImpl), но в рамках этого приложения делать это не будем.

Создадим index.ftlh – шаблон для Freemarker в каталоге resources/templates

Добавим простой CSS-файл style.css в каталоге resources/static/css:

Структура проекта:

Проект готов к запуску и работе

Запускаем первое приложение на Spring Boot

Переходим к классу OrganizerApplication.class. Он был сформирован автоматически на первом шаге конфигурации каркаса проекта. Его содержимое:

Переходим в меню >Run-> Run ‘OrganizerApplication’ или запускаем через сочетание клавиш Shift+F10. Процесс запуска отобразится в консоли ниже.

Переходим в браузер, набираем в адресной строке адрес localhost:8080 и наблюдаем работающий прототип приложения Organizer.

Органайзер на Spring Boot

Так с помощью Spring Boot с минимальным набором классов менее чем за час можно создать работающее веб-приложение или основу для будущих проектов. Это уже тема другой статьи.

Посмотрите также 10 шпаргалок для веб-разработчика. Там есть видеокурс по Spring Boot.

Источник

Spring boot: маленькое приложение для самых маленьких

В этой статье мы научимся создавать простые REST приложения. Напишем свое приложение с использованием SpringBoot, создадим свои контроллеры, воспользуемся JPA, подключим PostgreSQL.

Мы будем разрабатывать приложение в 3 этапа:

Создадим и запустим простое REST приложение на SpringBoot

Напишем приложение с сущностями, создадим контроллеры и подключим JPA

Создадим сущности и репозиторий

Напишем сервисную часть приложения

Запустим и протестируем наше приложение, удивимся, что все работает и порадуемся, что провели время с пользой и узнали что-то новое

1. Создадим и запустим простое REST приложение на SpringBoot

Мы пойдем по простому пути, а точнее зайдем на сайт-стартер проектов на SpringBoot: https://start.spring.io/. Выберем сборку gradle + Java. Запустим и соберем проект локально. Для этого через консоль используем команды, и ждем пока погдрузятся все библиотечки и соберется проект.

./gradlew wrapper — загрузка нужной версии wrapper.

Когда мы используем утилиту gradlew (по сути это оболочка, которая использует gradle), нам не нужно иметь заранее установленный Gradle на своем ПК. Эта оболочка может сама скачать и установить нужную версию, разобрать аргументы и выполнить задачи. По сути, используя gradlew, мы можем распространять/делиться проектом со всеми, чтобы использовать одну и ту же версию и функциональность Gradle. Gradlew читает информацию из файла gradle/wrapper/gradle-wrapper.properties.

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

Добавим в dependencies следующую зависимости для работы с PEST API:

@RestController = @Controller + @ResponseBody. Аннотация @Controller умеет слушать, получать и отвечать на запросы. А @ResponseBody дает фреймворку понять, что объект, который вы вернули из метода надо прогнать через HttpMessageConverter, чтобы получить готовое к отправке клиенту представление.

В файл application.properties добавим строку:

Вуаля! Теперь наше приложение не только запускается, но и выводит сообщение «spring_boot_example» по адресу: http://localhost:8080/.

2. Напишем приложение с сущностями, создадим контроллеры и подключим JPA

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

2.1. Создадим сущности и репозиторий

Аннотируем классы следующим образом:

Поле Address в классе User выглядит следующим образом:

Осталось сгенерировать методы hashCode, equals и toString. Для User мы генерируем hashCode и equals только по полю login, этого достаточно, так как мы сделали это поле уникальным и отличным от null. Так же для User при переопределении toString мы не используем поле address. Ранее упоминалось, что инициализация ленивая, и значение для этого поля не подтягивается сразу, а если мы попробуем обратиться к hibernate и попросить достать сущность без @Transactional, то упадем с ошибкой.

Полный код сущностей:

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

JpaRepository – это интерфейс фреймворка Spring Data предоставляющий набор стандартных методов JPA для работы с БД.

2.2. Добавим контроллеры.

Аннотация @Data добавляет get, set, toString, equals, hashCode, конструктор по всем полям, т.е. практически полностью генерирует POJO класс.

Теперь можно создать наш полноценный контроллер. Помечаем класс аннотациями @RestController и @RequestMapping(«/api/v1/users»).

У нашего приложения будет 5 контроллеров. Два на получение данных: всех пользователей и по id, на создание, изменение и удаление данных о пользователе.

Получаем список пользователей:

На аннотацию @GetMapping мы уже смотрели ранее. Свойство produces = APPLICATION_JSON_VALUE говорит о том, что данные возвращаются в формате json. В данном методе мы возвращаем лист с данными UserResponse.

Получаем пользователя по id:

Этот метод аналогичен предыдущему, за исключением того, что мы также получаем id пользователя. Аннотация @PathVariable говорит о том что информация извлекается из адреса и передается в переменную указанную в <>.

Обновляем пользователя по id:

Удаляем пользователя по id:

2.3. Напишем сервисную часть приложения.

Теперь посмотрим на логику сервиса. Для начала создадим интерфейс с пятью методами, а затем унаследуемся от него. Наш интерфейс выглядит так:

Создадим новый класс имплементирующий созданный выше интерфейс:

Теперь добавим логику в каждый метод.

Получаем список пользователей:

Хочу обратить внимание, что раньше мы говорили, что если мы обращаемся к сущности address вне @Transactional метода, то упадем с ошибкой. Так вот, тут такое не произойдет, т.к. метод как раз имеет эту аннотацию, hibernate ее видит и поднимает это поле из БД.

Получаем пользователя по id:

По аналогии с buildUserResponse создадим дополнительный метод buildUserRequest.

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

Обновляем пользователя по id:

В этом методе мы находим пользователя, по аналогии с методом findById, если такой объект нашелся, то сетим ему поля в методе userUpdate.

Удаляем пользователя по id:

Теперь добавим свой обработчик ошибок. Spring умеет перехватывать ошибки и возвращать вместо них то, что мы захотим. Для этого создадим объект ExceptionResponse, который будет возвращать только сообщение из ошибки.

3. Запустим и протестируем наше приложение, удивимся что все работает и порадуемся, что провели время с пользой и узнали что-то новое.

Добавим креды для подключения к БД в application.properties:

Теперь поднимем базу (для этого я использую докер) и добавляем таблички в БД.

Ура! Наше приложение написано и полностью работает, теперь его можно тестировать.

Подведем итог. Мы написали простое приложение и затронули несколько важных тем. Разработали контроллеры для разных REST методов, написали сервисную частью, включая свой обработчик ошибок. Подключили JPA и воспользовались методами интерфейса JpaRepository.

Источник

Building an Application with Spring Boot

This guide provides a sampling of how Spring Boot helps you accelerate application development. As you read more Spring Getting Started guides, you will see more use cases for Spring Boot. This guide is meant to give you a quick taste of Spring Boot. If you want to create your own Spring Boot-based project, visit Spring Initializr, fill in your project details, pick your options, and download a bundled up project as a zip file.

What You Will build

You will build a simple web application with Spring Boot and add some useful services to it.

What You Need

A favorite text editor or IDE

You can also import the code straight into your IDE:

How to complete this guide

Like most Spring Getting Started guides, you can start from scratch and complete each step or you can bypass basic setup steps that are already familiar to you. Either way, you end up with working code.

To start from scratch, move on to Starting with Spring Initializr.

To skip the basics, do the following:

Download and unzip the source repository for this guide, or clone it using Git: git clone https://github.com/spring-guides/gs-spring-boot.git

cd into gs-spring-boot/initial

Learn What You Can Do with Spring Boot

Spring Boot offers a fast way to build applications. It looks at your classpath and at the beans you have configured, makes reasonable assumptions about what you are missing, and adds those items. With Spring Boot, you can focus more on business features and less on infrastructure.

The following examples show what Spring Boot can do for you:

Is Spring MVC on the classpath? There are several specific beans you almost always need, and Spring Boot adds them automatically. A Spring MVC application also needs a servlet container, so Spring Boot automatically configures embedded Tomcat.

Is Jetty on the classpath? If so, you probably do NOT want Tomcat but instead want embedded Jetty. Spring Boot handles that for you.

Is Thymeleaf on the classpath? If so, there are a few beans that must always be added to your application context. Spring Boot adds them for you.

These are just a few examples of the automatic configuration Spring Boot provides. At the same time, Spring Boot does not get in your way. For example, if Thymeleaf is on your path, Spring Boot automatically adds a SpringTemplateEngine to your application context. But if you define your own SpringTemplateEngine with your own settings, Spring Boot does not add one. This leaves you in control with little effort on your part.

Starting with Spring Initializr

You can use this pre-initialized project and click Generate to download a ZIP file. This project is configured to fit the examples in this tutorial.

To manually initialize the project:

Navigate to https://start.spring.io. This service pulls in all the dependencies you need for an application and does most of the setup for you.

Choose either Gradle or Maven and the language you want to use. This guide assumes that you chose Java.

Click Dependencies and select Spring Web.

Click Generate.

Download the resulting ZIP file, which is an archive of a web application that is configured with your choices.

Create a Simple Web Application

Now you can create a web controller for a simple web application, as the following listing (from src/main/java/com/example/springboot/HelloController.java ) shows:

Create an Application class

The Spring Initializr creates a simple application class for you. However, in this case, it is too simple. You need to modify the application class to match the following listing (from src/main/java/com/example/springboot/Application.java ):

@SpringBootApplication is a convenience annotation that adds all of the following:

@Configuration : Tags the class as a source of bean definitions for the application context.

@ComponentScan : Tells Spring to look for other components, configurations, and services in the com/example package, letting it find the controllers.

The main() method uses Spring Boot’s SpringApplication.run() method to launch an application. Did you notice that there was not a single line of XML? There is no web.xml file, either. This web application is 100% pure Java and you did not have to deal with configuring any plumbing or infrastructure.

Run the Application

To run the application, run the following command in a terminal window (in the complete ) directory:

If you use Maven, run the following command in a terminal window (in the complete ) directory:

You should see output similar to the following:

Now run the service with curl (in a separate terminal window), by running the following command (shown with its output):

Add Unit Tests

You will want to add a test for the endpoint you added, and Spring Test provides some machinery for that.

If you use Gradle, add the following dependency to your build.gradle file:

If you use Maven, add the following to your pom.xml file:

Now write a simple unit test that mocks the servlet request and response through your endpoint, as the following listing (from src/test/java/com/example/springboot/HelloControllerTest.java ) shows:

As well as mocking the HTTP request cycle, you can also use Spring Boot to write a simple full-stack integration test. For example, instead of (or as well as) the mock test shown earlier, we could create the following test (from src/test/java/com/example/springboot/HelloControllerIT.java ):

Add Production-grade Services

If you are building a web site for your business, you probably need to add some management services. Spring Boot provides several such services (such as health, audits, beans, and more) with its actuator module.

If you use Gradle, add the following dependency to your build.gradle file:

If you use Maven, add the following dependency to your pom.xml file:

Then restart the application. If you use Gradle, run the following command in a terminal window (in the complete directory):

If you use Maven, run the following command in a terminal window (in the complete directory):

You should see that a new set of RESTful end points have been added to the application. These are management services provided by Spring Boot. The following listing shows typical output:

Источник

Spring Boot веб приложение с нуля

Сегодня я покажу Вам как создать java веб приложение используя возможности фреймворка Spring Boot. Будем писать и бекенд и фронтенд с нуля. Для тех, кто хотел начать изучать Spring, данная статья может послужить очень хорошим началом. В ней я даю ссылки на другие статьи где определенные технологии описаны более детально.

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

Для тех, кому лень читать: видео в конце страницы; код в описании к видео.

Технологии, которые мы будем использовать:

Первое, что я делаю когда мне нужно создать Spring приложение — захожу на сайт start.spring.io. Данный ресурс позволяет создавать типичный макет для джава приложений используя сборщик приложений мавен или gradle. Вышеуказанный ресурс также позволяет сразу подключить необходимые зависимости чтобы потом не искать их по всему Интернету.

Создание простого Spring Boot приложения

Как видно на скрине выше — сам инструмент интуитивно понятен: выбираем нужные зависимости (для данного проекта я выбрал Spring Web, PosgreSQL Driver, Spring Data JPA, Thymeleaf, Lombok), меняем название и описание если нужно (я назвал проект spring_crud и поменял group на com.java-master); жмем большую зеленую кнопку Generate. После должна начаться загрузка архива с каркасом проекта. Архив нужно распаковать, проект поместить в удобную папку на компьютере.

Дальше нужно открыть проект в любом удобном java редакторе. В этой статье я использую intellij idea. Как я пишу в каждой статье: выбирайте такой редактор, который удобен именно Вам.

После вышеперечисленных шагов у Вас должен быть открыт проект с одним единственным классом SpringCrudApplication. Название этого класса спринг берет частично с названия самого проекта. Поэтому у Вас он может иметь другое название. Это не принципиально.

Структура Spring Boot приложения

Данный класс имеет main метод, который является точкой входа в приложение. Аннотация SpringBootApplication указывает что приложение будет запускаться как Spring Boot приложение. Она также указывает спрингу, что для всего что у нас есть в файле зависимостей pom.xml нужно подключить авто конфигурацию. Если Вам нужно кастомизировать конфигурацию под определенные зависимости, то автоконфигурацию можно легко отключить, указав в списке exclude внутри аннотации SpringBootApplication:

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

Spring Boot дает нам возможность избежать написания сложных классов настроек. Будь-то настройки к базе данных, MVC шаблонов или других слоев приложения. НО! Для того, чтобы пользоваться преимуществами автоконфигураций нужно уметь «скармливать» фреймворку то, что он ожидает от нас.

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

Spring Boot возьмет вышеуказанные данные и на их основании сделает пул соединений (стандартный).

Теперь, приложение должно запускаться. По умолчанию оно использует порт 8080, который тоже можно поменять указав нужный в конфигурационном файле (application.properties).

Если мы перейдем по адресу http://localhost:8080 то увидем страницу с ошибкой. Все дело в том, что мы еще не создали ни единой страницы.

Страница с ошибкой

Мы указали в файле зависимостей (pom.xml) что будем использовать Thymeleaf в качестве джава серверного движка. В папке resources у Вас должна быть еще одна папка: static. Если ее нет — нужно создать. В нее нужно добавить Thymeleaf-файл. Это обычный html файл. Если назвать этот файл index.html, Spring Boot будет автоматически открывать этот файл при переходе по адресу http://localhost:8080. Никаких дополнительных настроек или классов создавать не нужно. Чтобы добавить другие страницы и отображать их в зависимости от адреса, просто создайте класс навешав на него аннотацию @Controller с методами как Вы это делали в обычных Spring MVC контроллерах. Только на этот раз не нужно писать файлы настроек.

Я создал простую страницу с приветствием:

Страница с приветствием

После того, как Вы создали у себя index.hmtl, перезапустите приложение и еще раз перейдите по адресу http://localhost:8080. Теперь Вы увидите ваше приветствие:

Страница с приветствием

Первое с чего начинается разработка любого приложения: проектирование структуры базы данных: Наше приложение будет работать с пользователями. Оно позволит их добавлять и удалять. Вы можете заменить пользователей на любую сущность которая вам нужна или интересна. Первое — создаем таблицу в базе данных. Как это делать решать Вам. Я пользуюсь инструментом intellij idea (доступно в платной версии). Для новичков, я настоятельно рекомендую создавать таблицы через скрипты. Чтобы Вы еще и SQL тренировали. Наша база данных будет иметь таблицу users_table с полями id, name, login, email.

Дальше, когда все приготовления с базой готовы, нужно написать слой доступа к базе данных. Создаем сперва класс отображения сущности. Если у нас таблица users_table нужно создать класс который будет ее отображением в java. Сначала создадим пакет entity, в который и поместим наш класс сущность. Назовем его Users. В данном классе создадим поля, которые есть в базе и навешаем на наш класс и поля аннотации java persistence: Table, Entity, Column, Id. Если для Вас эти термины новы, советую почитать статью по хибернейт и персистенс. Чтобы избежать написание геттеров, сеттеров, equals, hashCode, toString, я воспользуюсь аннотациями библиотеки Lombok.

В результате всех манипуляций, мой класс Users имеет вид:

Дальше на очереди JPA репозиторий. Подробнее о Spring Data JPA я писал раньше. Теперь, пришло время все это соединить в один проект.

Создадим пакет repository в который поместим интерфейс UsersRepository. Унаследуем этот интерфейс от JpaRepository указав в треугольных скобках нашу сущность с которой будет работать репозиторий и тип первичного ключа (Users, Integer). Предлагаю сразу добавить в репозиторий метод findByLogin. Чтобы можно было искать пользователя по логину. Напоминаю, что CRUD методы по работе с сущностью уже встроенны в JpaRepository и писать их самому не нужно. Такие методы как save(), saveAll(), delete(), findById() готовы к использованию. Использовать их мы будем в слое сервиса. Наш репозиторий выглядит следующим образом:

После работы с jdbc этот код выглядит как магия.

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

Наше приложение будет иметь слой доступа к базе данных. Который мы к стати, уже написали. Оно будет иметь слой сервисов, где будет происходить вся логика по обработке данных. И еще будет слой контроллер который будет принимать запросы от клиента. Будь то браузер, мобильное приложение и т.д. Для нас это не важно. У нас REST API которое отдает наружу определенные ендпоинты (урлы), которые будут вызывать наши потребители. В рамках нашего задания — мы и есть потребители нашего API.

Через слои нашего приложения будут передаваться данные. В нашем случае — это данные об сущности User. Очень важно, чтобы данные с клиента правильно фильтровались и валидировались перед записью в базу данных. И не менее важно, проверять данные на наличие секретной информации перед тем как вернуть их на запросы клиента. Например: у пользователя может быть поле пароль, которое он использует для авторизации на сайт. Нам нужно это поле во время регистрации пользователя и авторизации. Но если это запрос на получение информации о пользователе, пароль возвращать совсем не обязательно.

Очень распространенным подходом для решения подобной проблемы является использование классов DTO. Если кратко, то DTO — это простой java класс, который служит для передачи данных между слоями. В нашем примере мы можем создать класс UsersDto, у которого будут такие же поля как и в нашей сущности User. Я даже поместил его в отдельный пакет: dto:

Я добавил аннотацию Lombok, чтобы с этим объектом было удобнее работать: @Data — генерирует геттеры, сеттеры и др.

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

На очереди слой сервисов. Сначала создаем пакет service. В него добавляем интерфейс UsersService. Далее в интерфейсе добавляем методы которые нам нужны для работы:

Далее, создаем класс, в котором будет реализация данных методов. Назовем его DefaultUsersService. Первый метод, который мы будем реализовывать — saveUser. На вход будет приходить UsersDto объект. Мы должны провалидировать данные, создать объект Users и переместить данные из UsersDto в Users. Только после этого мы можем сохранить нового польозвателя в базу данных.

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

Я вынес валидацию в отдельный метод, чтобы было легче читать код:

Как видно выше — метод довольно простой: если объект Null — выбрасываем ValidationException с информацией, если логин нул или пустой — выбрасываем ValidationException и указываем что логин пустой. Класс ValidationException — это просто написанный мною свой класс исключения. Его код довольно простой:

После того как UsersDto пройдет валидацию, переконвертируем его в Users:

Для того, чтобы не писать весь код в одном классе я вынесу конвертацию из класса сервиса в другой класс. Назову его UsersConverter. В этот класс я и помещу метод fromUserDtoToUser. Предлагаю сразу написать конвертацию из UsersDto в Users. И, для демонстрации Вам еще одной фишки библиотеки Lombok я воспользусь встроенным в ломбок паттерном билдер. Для начала я добавлю в класс UsersDto аннотацию @Builder. Она реализовывает в данном классе паттерн билдер. Теперь я могу создавать объекты UsersDto через builder. Это достаточно популярный паттерн проектирования. Советую ознакомиться с ним.

Мой метод по конвертации из Users в UsersDto будет выглядеть так:

Если не нравиться паттерн builder можно делать по аналогии с методом fromUserDtoToUser.

Для того, чтобы спринг создал бин моего класса UsersConverter я навешу на него аннотацию @Component. Это позволит мне использовать внедрение зависимостей (dependency injection) и подлючить этот класс в мой класс DefaultUsersService используя Spring Dependency Injection.

Теперь, вернемся в наш класс DefaultUsersService и подключим к нему UsersRepository и UsersConverter. Я будут использовать внедрение зависимостей через конструктор. А Lombok поможет мне с конструктором. Для начала я объявляю переменные классов:

Мой компилятор ругается что нужно проинициализировать данные переменные используя конструктор. И правда: ведь мои переменные имеют final модификатор, что говорит о том что они должны быть проинициализированы. Компилятор предлагает инициализировать их в констукторе. Так я и сделаю. Только чтобы не писать его руками я воспользуюсь аннотацией @AllArgsConstructor из библиотеки ломбок. Заодно и навешаю на свой класс аннотацию @Service чтобы потом внедрить его в контроллер.

Дальше приступаю за оформление saveUser:

В методе deleteUser я просто удаляю пользователя по айди:

Метод findByLogin тоже достаточно простой: если пользователь в базе найден — переконвертируем его в дто. Если не найден — вернем нул:

Метод findAll похож на findByLogin с той лишь разницей что мы винимаем всех пользователей из базы и потом конвертируем их в список дто. Для обхода списка и конвертации я воспользовался стримами java. Но Вы может пользоваться простым циклом если сложно по началу разобраться со stream.

Наш класс DefaultUsersService после всех преобразований имеет такой вид:

На очереди слой контроллер. Создадим новый пакет controller в который поместим новый класс UsersController. Данный класс будет отвечать за обработку запросов по работе с сущностью User. Чтобы вызывать методы по созданию, удалению и выборке пользователей подключим в наш контроллер только что созданный UsersService таким же образом как мы подключали репозиторий и конвертор компонент: внедрение зависимостей через конструктор.

Чтобы наш класс стал контроллером простого названия мало. Нужно навешать на него аннотацию @RestController которая укажет спринг что данный класс предоставляет REST API.

Поскольку мы будем работать с юзерами, будет очень удобно начать наши урл адреса для юзера с частицы users. Для этого на класс нужно навешать аннотацию @RequestMapping(«/users»). Она указывает что адреса всех методов которые есть в этом классе будут начинаться с users.

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

Я использую @Log аннотацию из ломбок библиотеки чтобы выводить логи. @PostMapping, @GetMapping, @DeleteMapping отвечают за http методы POST, GET, DELETE соответственно. Внутри аннотации указан путь за который отвечают эти методы.

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

Тестирование API используя Postman

Я просмотрел постманом все урлы моего приложения и убедился что они работают. На скрине выше пример запроса:

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

Сохраненный пользователь в базе данных

Теперь, когда я проверил что мой код работает так как я и ожидал, можно приступить к фронтенду.

Перед написанием фронтенд части — обязательно убедитесь, что Ваши сервисы работают.

Переходим в наш index.html и создаем простую таблицу которая будет содержать наших пользователей. Если знания HTML еще не позволяют или нет желания делать таблицу самому — есть множество готовых решений. Просто перекопируйте готовую таблицу с Интернета. Загуглите simple html table и у Вас будет множество вариантов готовых HTML таблиц.

Дальше нужно сделать запрос на сервер используя технологию AJAX (Asynchronous JavaScript and XML). Данная технология позволяет делать запросы без перезагрузки веб страницы. Это значительно приятней пользователям и смотрится современней.

Есть множество реализация AJAX на разных фреймворках. Но в данной статье мы разберем пример на Javascript не используя сторонние библиотеки и фреймворки.

Сначала создается объект XMLHttpRequest. Дальше идет вызов метода open в который передают тип запроса (GET, POST, DELETE), асинхронный это будет запрос или нет. Если true — то асинхронный, false — синхронный. Синхронные запросы делать не рекомендую поскольку джаваскрипт прекратит выполнение пока не получит ответ от сервера. Объект XMLHttpRequest также принимает хедеры которые нужно засетить перед отправкой. Так как мы передаем данные в JSON формате нужно указать xmlhttp.setRequestHeader(«Content-Type», «application/json»); чтобы данные отправились в нужном формате.

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

Чтобы принять ответ от сервера, обект XMLHttpRequest имеет обработчик onreadystatechange который реагирует на изменение состояния запроса. onreadystatechange — это просто функция в которой доступно несколько переменных: readyState, status, statusText, responseText.

ReadyState может иметь 5 состояний. Для нас важным является когда у него состояние 4 (request finished and response is ready). Это означает что когда ответ от сервера готов — мы можем начать с ним работать.

После того как мы получим положительный ответ от нашего сервера (200 статус), то сможем отобразить полученные данные так как мы пожелаем.

Первое, что мы сделаем — отобразим всех имеющихся пользователей в системе. Делаем запрос для получения всех пользователей. В ответе мы получим список обьектов дто пользователей. Обойдем этот список с помощью цикла и сформируем ряд таблицы из пользователя. Дальше добавим ряд в нашу таблицу. Звучит сложно, а на деле — пара строк кода:

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

Чтобы функция loadUsers отработала ее нужно запустить. Просто вызовите ее после всех функций loadUsers();

Дальше добавим логику для создания нового пользователя. Для этого нам нужна простая html форма:

При нажатии на кнопку Create user будет работать функция createUser, которую мы еще должны сооздать:

Берем значения полей формы, формируем запрос JSON, делаем запрос на сервер. После этого вызываем функцию loadUsers чтобы наш вновь созданный пользователь отобразился на странице.

Подобно до сохранения делаем удаление пользователя. И также как и загрузка всех пользователей делаем поиск по логину.

Вот такой вот финальный файл получился после всех манипуляций:

Я советую вынести Javascript и CSS в отдельные файлы, чтобы Ваш код приобрел читабельный вид.

Наше простое веб приложение на Spring Boot готово.

Результат работы приложения

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

Сейчас открыт набор на java mentor где мы по похожему сценарию только под моим руководством пишем немного усложненные варианты подобных проектов.

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

Ссылка на код гитхаб в описании к видео.

Источник