rest приложение spring boot

, это более гибкий вариант, чем вернуть просто Person, поскольку для ResponseEntity можно установить Http-статус ответа — ResponseEntity.ok() — это 200 или ResponseEntity.status(201).

В методе body() передается возвращаемая сущность — в вышеприведенных методах это Person (либо список Person). Под капотом она конвертируется в JSON благодаря тому, что у нас стоит аннотация @RestController. Для конвертации под капотом Spring Boot использует библиотеку Jackson — она включена благодаря Maven-зависимости spring-boot-starter-web.

Если надо возвратить JSON с описанием ошибки, выбрасываем исключение. Например, если запрос на редактирование содержит id несуществующего Person, то выбрасываем EntityNotFoundException. Как обрабатывать исключения и кастомизировать JSON с ошибкой, описано в следующей статье.

Запуск

Для запуска Spring Boot приложения запускаем main() этого класса:

При этом будет запущен веб-сервер, отдельно его устанавливать и запускать не надо — это одно из преимуществ Spring Boot приложения.

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

Тестирование

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

Добавление Person

Ответ, возвращается вновь добавленный Person с >

Редактирование Person

Ответ, возвращается отредактированный Person с и name=’Jane’:

Получение Person

Ответ, возвращается Person:

Получение списка Person

Ответ, возвращается список, состоящий из одного элемента Person:

Удаление Person

Ответ, возвращается удаленный Person с и name=’Jane’:

Заключение

Мы написали маленькое приложение, предоставляющее REST-сервис. Как обрабатывать исключения описано в следующей части.

Spring Boot REST API: 7 комментариев

Есть ли статья по тестированию?

Будет в ближайшее время

Аесть статья, как кастомизировать response body таким образом, чтобы в нем можно было возвращать не все поля энтити? Например, я хочу исключить из респонза ID. Мне на ум приходит два варианта, оба убогие.
1. В теории, я могу сделать ResponseEntity и исключить из переопределения toString нужное поле, но я не хочу возвращать стринг, я хочу вернуть именно json. Есть возможность дефолтными методами это как-то сделать или необходимо только всякие манипуляции проводить с кастованием стрингов в жсон и обратно?
2. Кастомизировать Query, чтобы он возвращал только нужные поля. Но тогда возвращаемым значением будет Object, которые никак не получится кастовать к моему классу. Да и работать с таким значением невозможно.

1. Заботиться о преобразовании в объекта в JSON не надо, это на совести контроллера. Главное, чтобы у нас был объект с нужными полями.
2. Чтобы он был, надо использовать паттерн DTO — Data Transfer Object; то есть помимо объекта Person, создаете объект PersonDTO специально для передачи — он содержит ровно те поля, которые нужно отправить/принять на фронтенд.
В статье этого нет, т.к. случай рассмотрен примитивный. Но если бы было, возвращаемым значением метода getPerson()был бы:

Источник

Введение в Spring Boot: создание простого REST API на Java

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

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

1. Представляем Spring Boot

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

Spring Boot — это полезный проект, целью которого является упрощение создания приложений на основе Spring. Он позволяет наиболее простым способом создать web-приложение, требуя от разработчиков минимум усилий по его настройке и написанию кода

2. Особенности Spring Boot

Spring Boot обладает большим функционалом, но его наиболее значимыми особенностями являются: управление зависимостями, автоматическая конфигурация и встроенные контейнеры сервлетов

2.1. Простота управления зависимостями

Чтобы ускорить процесс управления зависимостями, Spring Boot неявно упаковывает необходимые сторонние зависимости для каждого типа приложения на основе Spring и предоставляет их разработчику посредством так называемых starter-пакетов (spring-boot-starter-web, spring-boot-starter-data-jpa и т.д.)

Starter-пакеты представляют собой набор удобных дескрипторов зависимостей, которые можно включить в свое приложение. Это позволит получить универсальное решение для всех, связанных со Spring технологий, избавляя программиста от лишнего поиска примеров кода и загрузки из них требуемых дескрипторов зависимостей (пример таких дескрипторов и стартовых пакетов будет показан ниже)

Например, если вы хотите начать использовать Spring Data JPA для доступа к базе данных, просто включите в свой проект зависимость spring-boot-starter-data-jpa и все будет готово (вам не придется искать совместимые драйверы баз данных и библиотеки Hibernate)

Если вы хотите создать Spring web-приложение, просто добавьте зависимость spring-boot-starter-web, которая подтянет в проект все библиотеки, необходимые для разработки Spring MVC-приложений, таких как spring-webmvc, jackson-json, validation-api и Tomcat

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

Следовательно, при использовании Spring Boot, файл pom.xml содержит намного меньше строк, чем при использовании его в Spring-приложениях

Обратитесь к документации, чтобы ознакомиться со всеми Spring Boot starter-пакетами

2.2. Автоматическая конфигурация

Второй превосходной возможностью Spring Boot является автоматическая конфигурация приложения

После выбора подходящего starter-пакета, Spring Boot попытается автоматически настроить Spring-приложение на основе добавленных вами jar-зависимостей

Например, если вы добавите Spring-boot-starter-web, Spring Boot автоматически сконфигурирует такие зарегистрированные бины, как DispatcherServlet, ResourceHandlers, MessageSource

Если вы используете spring-boot-starter-jdbc, Spring Boot автоматически регистрирует бины DataSource, EntityManagerFactory, TransactionManager и считывает информацию для подключения к базе данных из файла application.properties

Если вы не собираетесь использовать базу данных, и не предоставляете никаких подробных сведений о подключении в ручном режиме, Spring Boot автоматически настроит базу в памяти, без какой-либо дополнительной конфигурации с вашей стороны (при наличии H2 или HSQL библиотек)

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

2.3. Встроенная поддержка сервера приложений — контейнера сервлетов

Каждое Spring Boot web-приложение включает встроенный web-сервер. Посмотрите на список контейнеров сервлетов, которые поддерживаются «из коробки»

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

Если вам нужно использовать отдельный HTTP-сервер, для этого достаточно исключить зависимости по умолчанию. Spring Boot предоставляет отдельные starter-пакеты для разных HTTP-серверов

Создание автономных web-приложений со встроенными серверами не только удобно для разработки, но и является допустимым решением для приложений корпоративного уровня и становится все более полезно в мире микросервисов. Возможность быстро упаковать весь сервис (например, аутентификацию пользователя) в автономном и полностью развертываемом артефакте, который также предоставляет API — делает установку и развертывание приложения значительно проще

3. Требования к установке Spring Boot

Для настройки и запуска Spring Boot приложений требуется следующее:

4. Создание Spring Boot приложения

Теперь давайте перейдем к практике и реализуем очень простой REST API для приема платежей, используя возможности Spring Boot

4.1. Создание web-проекта с использованием Maven

Создайте Maven-проект в используемой вами IDE, назвав его SpringBootRestService

Обязательно используйте версию Java 8+, поскольку Spring Boot не работает с более ранними версиями

4.2. Конфигурация pom.xml

Вторым шагом необходимо настроить Spring Boot в файле pom.xml

Все приложения Spring Boot конфигурируются от spring-boot-starter-parent, поэтому перед дальнейшим определением зависимостей, добавьте starter-parent следующим образом:

Т.к. мы создаем REST API, то необходимо в качестве зависимости использовать spring-boot-starter-web, которая неявно определяет все остальные зависимости, такие как spring-core, spring-web, spring-webmvc, servlet api, и библиотеку jackson-databind, поэтому просто добавьте в pom.xml следующее:

Теперь следующие jar-библиотеки автоматически импортируются в ваш проект:

Следующий шаг — добавляем Spring Boot плагин:

Последний шаг — сделать так, чтобы Maven генерировал исполняемый jar-файл при сборке:

Ниже приведен полный файл pom.xml:

Как видите, используя одну зависимость, мы можем создать полностью функциональное web-приложение

4.3. Создание ресурсов REST

Теперь мы собираемся создать контроллер платежей вместе с POJO-классами для запросов и ответов

Напишем класс запроса платежа:

А также класс, обрабатывающий базовый ответ, возвращаемый нашим сервисом:

А теперь создадим контроллер:

4.4. Создание основного класса приложения

Этот последний шаг заключается в создании класса конфигурации и запуска приложения. Spring Boot поддерживает новую аннотацию @SpringBootApplication, которая эквивалентна использованию @Configuration, @EnableAutoConfiguration и @ComponentScan с их атрибутами по умолчанию

Таким образом, вам просто нужно создать класс, аннотированный с помощью @SpringBootApplication, а Spring Boot включит автоматическую настройку и отсканирует ваши ресурсы в текущем пакете:

5. Развертывание приложения Spring Boot

Теперь давайте воспользуемся третьей замечательной особенностью Spring Boot — это встроенный сервер. Все, что нам нужно сделать — это создать исполняемый jar-файл с помощью Maven и запустить его, как обычное автономное приложение:

Наш REST API запущен и готов обслуживать запросы через порт 8080 (по умолчанию)

В этой статье мы рассмотрели возможности Spring Boot и создали полностью рабочий пример с использованием встроенного сервера

В переводе обновили информацию:

UPDATE:

Как заметил Lure_of_Chaos, теперь уже все можно сделать автоматически через SPRING INITIALIZR. Причем не выходя из любимой JetBrains IntelliJ IDEA.

Источник

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.

Источник

Как создать Rest API с помощью Spring Boot, используя MySQL и JPA

В этом случае я нашел очень чистый и элегантный фреймворк под названием Spring Boot для создания серверной части.

Ранее при разработке JavaScript я использовал:

Для разработки, связанной с Java, существует множество ORM, таких как Hibernate, JPA (Java Persistence API) и Java Object-Oriented Querying.

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

Это было очень интересно, и мне потребовалось около недели, чтобы закончить, так как мне пришлось выучить Spring Boot (есть много аннотаций “@” и других интересных вещей), JPA и Hibernate.

Вся эта магия в основном делается с помощью аннотаций (символ «@»), используемых в Spring Boot.

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

Давайте создадим приложение проекта Spring Boot Maven по этой ссылке.

У нас есть package.json в NodeJS для управления зависимостями и pom.xml в Spring Boot для управления зависимостями.

В Group напишите любое имя, которое вы хотите. Обычно доменное имя организации пишется справа налево.

Например, наше доменное имя www.javaAPI.com, поэтому имя группы может быть com.javaAPI.www

Затем в Artifact введите имя нужной вам папки.

На правой стороне добавьте следующие зависимости:

Нажмите на com.rest.API, и вы найдете файл ApiApplication.java с примерно следующим содержанием:

Этого кода достаточно для запуска вашего сервера. Обычно spring boot выполняется на localhost:8080.

Введите в свой терминал, как показано ниже:

Посмотрите, как ваш localhost работает в веб-браузере на порту 8080. Он выглядит пустым, поскольку мы еще ничего не сделали.

Давайте рассмотрим файлы и их теги

Зависимости для начинающего и тестирующего являются ядром для создания приложения Spring Boot для обслуживания на сервере.

Теперь перейдем к APIApplication.java, который является основным файлом.

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

После этого два модуля импортируются из пакета «org.springframework.boot».

Поскольку Spring boot является обновленной средой разработки приложений Spring, ему нужны пакеты Spring Application, а также его специальные пакеты.

После этого используется аннотация @SpringBootApplication. Эта аннотация состоит из аннотации, которая используется в Spring:

Это аннотации, используемые для запуска Spring Boot Application для запуска на сервере.

Давайте создадим модель для наших данных

Давайте создадим класс Model для сохранения, извлечения, обновления и удаления сведений о книге.

Для этого мне нужно создать новый пакет с именем model, а внутри него создать класс Book.java для размещения моего кода.

Здесь я использую JPA (Java Persistence API), который представляет собой набор классов и методов для постоянного хранения данных в базе данных.

Кроме этого есть пустой конструктор, который имеет супер метод для удовлетворения таможенных правил JPA. Методы получения и установки обычно находятся в классе POJO (обычный старый объект Java).

Создание Repository

Далее мы собираемся создать пакет репозитория для управления базой данных в Java.

Создайте интерфейс с именем BookRepository.java внутри пакета repository.

Я импортировал пакет JpaRepository для использования этого репозитория в интерфейсе BookRepository, подключив мою последнюю модель Book для выполнения CRUD операций.

В этих репозиториях уже есть встроенные методы для выполнения операций CRUD.

Внутри тега <> мы берем имя модели, которую мы будем использовать, и тип данных первичного ключа.

@Repository: аннотация, используемая для обозначения компонента DAO (объекта доступа к данным) на постоянном уровне.

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

Создание контроллера и обработка исключений

Создайте новый пакет с именем controller, и внутри него создайте файл BookController.java, который содержит следующее.

Первый импортированный пакет предназначен для исключений BookNotFound (для которого мы собираемся позже создать файл).

Объяснение аннотаций которые мы здесь использовали:

1. RestController: эта аннотация используется для обозначения каждого метода в аннотированном классе как объект домена.

Так что же такое объект доменна.

Это просто говорит о том, что Domain Object == Business Object.

Они обычно представлены сущностями и объектами значений, относящимися к конечной точке, которую мы даем для получения данных из базы данных.

2. Autowired: эта аннотация используется для автоматической связи bean классов.

Для этого вам нужно знать, что такое bean класс.

3. GetMapping: это интерфейс, который содержит путь конечной точки (uri) для выполнения метода Get. Этот интерфейс GetMapping использует интерфейс RequestMapping, который может иметь метод «path, value, params, headers» для выполнения метода Get в более ранних версиях Spring.

Теперь его использование упрощено с помощью GetMapping.

4. PostMapping: это интерфейс, который содержит путь к конечной точке (uri) для выполнения метода Post.

5. PutMapping: это интерфейс, который содержит путь конечной точки (uri) для выполнения метода Put для обновления записей.

6. DeleteMapping: это интерфейс, который содержит путь конечной точки (uri) для выполнения метода Delete.

В последних строках вы, вероятно, заметили ключевое слово «ResponseEntity».

Это класс Java, который наследует класс HttpEntity для манипулирования ответами HTTP. Независимо от того, является ли статус запроса соединения «200 ОК» или если есть какие-либо проблемы, выведите исключение из класса HttpEntity.

orElseThrow(): это метод, найденный в классе Optional в Java8, который был введен для обработки исключений. Необязательный класс предоставляет различные служебные методы для проверки наличия или отсутствия объекта, что помогает работать с NullPointerException.

Создание NotFoundException, если такого book_id не существует

Так как метод orElseThrow создает исключение NotFound. Ниже приведена часть обработки исключений. Создайте файл BookNotFoundException.java внутри пакета exception.

Созданный класс расширяет суперкласс Exception. В конструкторе я передаю book_id и печатаю исключение.

Мы закончили часть REST API. Теперь вы можете создать приложение (которое было объяснено в части 1) и провести несколько тестирований с Postman.

Соединение с базой данных MySql

Внутри application.properties вашей папки ресурсов добавьте следующее:

Мы создали базовый REST API в Spring Boot!

Если что-то не так или нужно исправить, пожалуйста, дайте мне знать в комментариях.

Источник