Создайте API REST для загрузки Spring с помощью Java - Полное руководство

Вступление

REST расшифровывается как Передача репрезентативного состояния , стандартизированный подход к созданию веб-сервисов.

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

RESTful-наиболее распространенный подход к созданию веб-сервисов из-за того, насколько легко его изучать и создавать.

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

В этом уроке мы рассмотрим как создать REST API на Java с помощью Spring Boot . Он будет принимать ОТПРАВЛЯТЬ и ПОЛУЧАТЬ запрашивать полезную нагрузку для просмотра и добавления записей от сущности – Пользователя .

Требования

Среда разработки или текстовый редактор
JDK 1.8 +
Maven 3+ или Gradle 4+ (в этой статье мы будем полагаться на Maven)

Инициализация проекта весенней загрузки

Использование Spring Initializr

Один из простых способов инициализации нового проекта Spring Boot-это использование Spring Initializr , который автоматически создает для вас проект загрузки с каркасной пружиной:

Мы также добавим здесь несколько зависимостей, так как мы захотим использовать их в нашем проекте:

Spring Web – Для включения Spring MVC и встроенного Tomcat в ваш проект
Spring Data JPA – API сохранения данных Java и спящий режим
Spring Boot DevTools – Очень полезные инструменты разработки
Драйвер MySQL – Драйвер JDBC (может быть любой базой данных, которую вы хотите использовать)

После этого нажмите кнопку создать. Затем будет загружен zip-файл, содержащий созданный проект.

Использование пружинных ЗАЖИМОВ

Если у вас установлен Пружинный ЗАЖИМ , вы можете выбрать использование консоли для создания базового проекта с помощью этой команды:

spring init --build=maven -p=jar UserDemo

Примечание: Spring CLI напрямую вызывает Spring Initializr для выполнения этой операции. Оба варианта приведут к созданию одного и того же проекта.

После создания базового проекта загрузите и импортируйте его в выбранную среду разработки или текстовый редактор. Если вы хотите создать, скомпилировать и запустить приложение через среду IDE, убедитесь, что вы импортировали его как проект Maven или Gradle .

При импорте сгенерированная база pom.xml в вашем проекте будет выглядеть так:



    
        org.springframework.boot
        spring-boot-starter-data-jpa
    
    
        org.springframework.boot
        spring-boot-starter-web
    
    
        org.springframework.boot
        spring-boot-devtools
        runtime
        true
    
    
        mysql
        mysql-connector-java
    
    
        org.springframework.boot
        spring-boot-starter-test
        test
        
            
                org.junit.vintage
                junit-vintage-engine

Все конфигурации, которые вы выполнили, будут отражены в этом файле. Кроме того, автоматически настраиваются зависимости по умолчанию, ваш базовый снимок 0.0.1-СНИМОК и плагин сборки Maven.

Для справки, если вы хотите создать проект Gradle , ваш build.gradle будет выглядеть следующим образом:

plugins {
	id 'org.springframework.boot' version '2.3.5.RELEASE'
	id 'io.spring.dependency-management' version '1.0.10.RELEASE'
	id 'java'
}

group = 'com.howto'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	implementation 'org.springframework.boot:spring-boot-starter-web'
	developmentOnly 'org.springframework.boot:spring-boot-devtools'
	runtimeOnly 'com.mysql:mysql-connector-java'
	testImplementation('org.springframework.boot:spring-boot-starter-test') {
		exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'
	}
}

test {
	useJUnitPlatform()
}

Подключение Spring Boot к базе данных

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

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

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

spring.datasource.url = jdbc:mysql://localhost:3306/user
spring.datasource.username = user
spring.datasource.password = user
spring.jpa.hibernate.ddl-auto = update
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

Здесь мы установили datasource.url для нашего URL-адреса подключения JDBC. Это зависит от вашей базы данных. Мы предоставили имя пользователя и пароль , необходимые для аутентификации в этой базе данных, а также установили для свойства ddl-auto значение обновить . Свойство jpa.hibernate.ddl-auto напрямую влияет на свойство hibernate.hbm2ddl.auto и, по сути, определяет, как Hibernate должен обрабатывать управление инструментами схемы.

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

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

Модель домена – Создание модели пользователя

Теперь, когда подключение к базе данных запущено и запущено, мы можем перейти к модели Домена . Это набор классов, или , скорее, моделей , которые мы будем использовать в нашем приложении. В режиме гибернации они также называются Сущностями , а также аннотируются аннотацией @Entity .

Каждая @Сущность выбирается Hibernate, для нее создается таблица, поля сопоставляются, и она становится управляемой сущностью для настроенной вами базы данных.

Во-первых, давайте создадим простую пользовательскую сущность. Мы будем аннотировать класс с помощью @Entity и необязательной @Таблицы аннотации, чтобы указать имя нашей таблицы.

Если не задано, он будет просто использовать то же имя, что и класс:

@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;
    private String name;

    // Constructor, getters and setters   
}

Чтобы аннотировать поле как идентификатор сущности, вы используете аннотацию @Id , и она будет установлена в качестве автоматически увеличивающегося первичного ключа таблицы. Кроме того, вы можете дополнительно указать, что это @GeneratedValue , и установить Тип генерации в АВТО .

Это значение по умолчанию, если вы опустите @GeneratedValue аннотацию. Другими значениями, которые вы можете задать, являются ИДЕНТИФИКАТОР , ПОСЛЕДОВАТЕЛЬНОСТЬ и ТАБЛИЦА . Они заслуживают отдельной статьи о гибернации.

Кроме того, вы можете установить @Столбец аннотации для каждого из полей, указав имя для каждого из них , если вам нужны пользовательские имена – @Столбец(имя) , сохранит идентификатор поле как идентификатор пользователя вместо просто идентификатор .

Если вы хотите автоматизировать генерацию конструкторов, геттеров и сеттеров и просто избежать шаблонного кода в целом, вы можете использовать отличные инструменты, такие как Lombok .

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

Уровень Сохраняемости – Создание Классов Репозитория

Далее давайте поработаем над уровнем сохраняемости. Мы захотим иметь UserRepository для выполнения операций CRUD с нашими пользовательскими сущностями. Для этого мы укажем интерфейс, который расширяет CrudRepository , и снабдим его аннотацией @Репозиторий .

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

Расширение CrudRepository принимает класс сущности, а также тип данных id , который он должен использовать для запроса:

@Repository
public interface UserRepository extends CrudRepository {}

CrudRepository объявляет такие методы, как findAll () , findOne () и save () , которые составляют основную функциональность CRUD репозитория. Вы можете использовать этот UserRepository как есть для выполнения операций CRUD над Пользователями сущностями прямо сейчас, без дополнительной настройки.

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

Бизнес – уровень- Создание контроллера

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

Git Essentials

Ознакомьтесь с этим практическим руководством по изучению Git, содержащим лучшие практики и принятые в отрасли стандарты. Прекратите гуглить команды Git и на самом деле изучите это!

Давайте создадим контроллер, пометим его как @RestController , поскольку мы создаем REST API, и добавим в него @RequestMapping . @RestController – это просто комбинация @Controller и @ResponseBody , что означает, что вместо отображения страниц он будет просто отвечать данными, которые мы ему предоставили. Это естественно для API REST – возврат информации после попадания в конечную точку API.

Если вы хотите узнать больше о @RequestMapping и его производных вариантах , у нас есть отличная статья, посвященная именно этой теме!

Давайте продолжим и создадим UserController :

@RestController
@RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserRepository userRepository;
        
    @GetMapping
    public List findAllUsers() {
        // Implement
    }

    @GetMapping("/{id}")
    public ResponseEntity findUserById(@PathVariable(value = "id") long id) {
       // Implement
    }

    @PostMapping
    public User saveUser(@Validated @RequestBody User user) {
        // Implement
    }
}

Мы @Autowired наша Учетная запись пользователя . Он используется для внедрения зависимостей, так как класс репозитория здесь является зависимостью. Если вы хотите узнать больше о Аннотациях основных фреймворков Spring , ознакомьтесь с нашим руководством!

Мы также использовали аннотации @GetMapping и @PostMapping , чтобы указать, какие типы HTTP-запросов принимают и обрабатывают наши методы. Это производные варианты аннотации @RequestMapping с использованием метода .МЕТОД устанавливается для соответствующих типов.

Давайте начнем с реализации конечной точки final() :

@GetMapping
public List findAllUsers() {
    return userRepository.findAll();
}

Этот метод просто вызывает UserRepository для поиска всех() пользователей и возвращает список в качестве ответа.

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

@GetMapping("/{id}")
public ResponseEntity findUserById(@PathVariable(value = "id") long id) {
    Optional user = userRepository.findById(id);

    if(user.isPresent()) {
        return ResponseEntity.ok().body(user.get());
    } else {
        return ResponseEntity.notFound().build();
    }
}

A с заданным идентификатором может отсутствовать в базе данных, поэтому мы помещаем возвращенного Пользователя в Необязательный . Если вы хотите прочитать больше о Необязательно в Java 8 , у нас есть подробное руководство!

Затем, если user.is Present() , мы возвращаем 200 OK HTTP-ответ и устанавливаем пользователя экземпляр в качестве тела ответа. В противном случае мы возвращаем ResponseEntity.not Found() .

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

@PostMapping
public User saveUser(@Validated @RequestBody User user) {
    return userRepository.save(user);
}

Метод save() из репозитория пользователей сохраняет нового пользователя, если он еще не существует. Если пользователь с заданным идентификатором уже существует, он создает исключение. В случае успеха он возвращает сохраненного пользователя.

Аннотация @Validated является средством проверки данных, которые мы предоставляем о пользователе, и обеспечивает базовую достоверность. Если информация о пользователе неверна, данные не сохраняются. Кроме того, @RequestBody аннотация отображает тело СООБЩЕНИЯ запроса, отправленного в конечную точку, на экземпляр Пользователя , который мы хотели бы сохранить.

Если вы хотите узнать больше о том , как получить тело HTTP в Spring Boot, мы вас накроем!

Теперь пришло время запустить приложение и проверить, работает ли оно.

Компиляция, сборка и запуск

Порт по умолчанию, в котором выполняется Spring Boot, является 8080 . Если вы хотите изменить порт по какой-либо причине, вы можете настроить его в своем файле application.properties :

server.port = 9090

Если у вас есть IDE, например IntelliJ , которая имеет обширную поддержку для запуска проектов Spring Boot, вы можете продолжить и запустить ее таким образом.

Если нет, мы будем использовать командную строку для запуска нашего проекта. Мы можем запустить приложение напрямую, выполнив ./mvn spring-boot:запустите (или ./gradlew bootRun , если вы используете Gradle ) в командной строке из папки базового проекта, где pom.xml находится.

Другой вариант-упаковать ваше приложение в файл jar и запустить его таким образом.

Для этого нам просто нужно выполнить ./mvn чистый пакет ( .gradlew сборка в Gradle) и запустить файл jar, выполнив эту команду:

$ java -jar target/DemoUser-0.0.1-SNAPSHOT.jar

Если вы используете Gradle, путь к файлу jar будет другим:

$ java -jar build/libs/DemoUser-0.0.1-SNAPSHOT.jar

Вы узнаете, когда ваше приложение успешно запущено, если увидите эти журналы аудита в конце командной строки:

2020-11-05 13:27:05.073  INFO 21796 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2020-11-05 13:27:05.108  INFO 21796 --- [  restartedMain] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2020-11-05 13:27:05.121  INFO 21796 --- [  restartedMain] com.howto.DemoUser.DemoUserApplication   : Started DemoUserApplication in 1.765 seconds (JVM running for 2.236)

Тестирование API-интерфейсов

Теперь, когда ваше приложение запущено и запущено http://localhost:8080/ , теперь мы можем проверить конечные точки, чтобы увидеть, работают ли они.

Для запросов GET мы можем использовать браузеры, curl или Postman – все, что вам наиболее удобно.

Давайте ударим по http://localhost:8080/api/user конечная точка с запросом GET :

$ curl http://localhost:8080/api/user

Или в адресной строке вашего браузера посетите http://localhost:8080/api/user , и ваш браузер отобразит ответ JSON:

[
   {
      "id": 1,
      "name":"John"
   },
   {
      "id": 2,
      "name":"Jane"
   },
   {
      "id": 3,
      "name": "Juan"
   }
]

Мы можем изменить этот URL-адрес, чтобы включить параметр пути, id , чтобы получить конкретного пользователя. Давайте отправим запрос HTTP GET на http://localhost:8080/api/user/3 :

{
    "id": 3,
    "name": "Juan"
}

Наконец, давайте отправим запрос HTTP POST и добавим пользователя в нашу базу данных, предоставив данные, необходимые в нашей модели. Поля в полезной нагрузке JSON должны соответствовать именам полей в нашей базе данных/модели:

$ curl --location --request POST 'http://localhost:8080/api/user' \
--header 'Content-Type: application/json' \
--data-raw '{ "id": 4, "name": "Jason" }'

API вернет 200 в качестве ответа с этим в качестве тела ответа сохраненного пользователя:

{
    "id": 4,
    "name": "Jason"
}

Вывод

Вот оно у вас есть. Вы успешно создали свой собственный API Spring Boot REST!

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

Мы рассмотрели Модель домена , Уровень сохраняемости , а также Бизнес-уровень после настройки подключения к базе данных и настройки проекта.