Postmapping spring как работает

Обработка данных формы

Этот урок освещает процесс использования Spring для создания и отправки web формы.

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

В этом уроке вы создадите web форму, которая будет доступна по URL:

http://localhost:8080/greeting

При просмотре этой страницы отобразится форма. Вы сможете отправить сообщение, заполнив поля id и content . Результирующая страница будет отображена, когда форма будет отправлена.

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

• Примерно 15 минут свободного времени
• Любимый текстовый редактор или IDE
• JDK 6 и выше
• Gradle 1.11+ или Maven 3.0+
• Вы также можете импортировать код этого урока, а также просматривать web-страницы прямо из Spring Tool Suite (STS), собственно как и работать дальше из него.

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

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

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

• Загрузите и распакуйте архив с кодом этого урока, либо кнонируйте из репозитория с помощью Git: git clone https://github.com/spring-guides/gs-handling-form-submission.git
• Перейдите в каталог gs-handling-form-submission/initial
• Забегая вперед, создайте web контроллер

Когда вы закончите, можете сравнить получившийся результат с образцом в gs-handling-form-submission/complete .

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

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

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

В выбранном вами каталоге проекта создайте следующую структуру каталогов; к примеру, командой mkdir -p src/main/java/hello для *nix систем:

└── src └── main └── java └── hello

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

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

Если вы посмотрите на pom.xml , вы найдете, что указана версия для maven-compiler-plugin. В общем, это не рекомендуется делать. В данном случае он предназначен для решения проблем с нашей CI системы, которая по умолчанию имеет старую(до Java 5) версию этого плагина.

buildscript < repositories < maven < url "http://repo.spring.io/libs-release" >mavenLocal() mavenCentral() > dependencies < classpath("org.springframework.boot:spring-boot-gradle-plugin:1.1.8.RELEASE") >> apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'idea' apply plugin: 'spring-boot' jar < baseName = 'gs-handling-form-submission' version = '0.1.0' >repositories < mavenLocal() mavenCentral() maven < url "http://repo.spring.io/libs-release" >> dependencies < compile("org.springframework.boot:spring-boot-starter-thymeleaf") testCompile("junit:junit") >task wrapper(type: Wrapper)

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

• Он собирает все jar’ы в classpath и собирает единое, исполняемое «über-jar», что делает более удобным выполнение и доставку вашего сервиса
• Он ищет public static void main() метод, как признак исполняемого класса
• Он предоставляет встроенное разрешение зависимостей, с определенными номерами версий для соответсвующих Spring Boot зависимостей. Вы можете переопределить на любые версии, какие захотите, но он будет по умолчанию для Boot выбранным набором версий

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

В подходе Spring к построению web сайтов, HTTP запросы обрабатываются контроллером. Эти компоненты легко идентифицируются по @Controller аннотации. Ниже представленный GreetingController обрабатывает GET запросы для /greeting , возвращая название View , в данном случае это «greeting». View ответственнен за рендеринг HTML контента.

package hello; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.ModelAttribute; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RequestParam; @Controller public class GreetingController < @RequestMapping(value="/greeting", method=RequestMethod.GET) public String greetingForm(Model model) < model.addAttribute("greeting", new Greeting()); return "greeting"; >@RequestMapping(value="/greeting", method=RequestMethod.POST) public String greetingSubmit(@ModelAttribute Greeting greeting, Model model) < model.addAttribute("greeting", greeting); return "result"; >>

Этот контроллер лаконичен и прост, но в нем много чего происходит. Давайте подробнее рассмотрим шаг за шагом.

Аннотация @RequestMapping позволяет вам связать HTTP запросы с определенными методами контроллера. В этом контроллере два метода и оба они относятся к /greeting . По умолчанию, @RequestMapping соответствует всем HTTP операциям, таким как GET , POST и так далее. Но в данном случае метод greetingForm() явно связан с GET , используя @RequestMapping(method=GET) , в то время как greetingSubmit() связан с POST через @RequestMapping(method=POST) . Эти соответствия позволяют контроллеру различать типы запросов к /greeting .

Метод greetingForm() использует объект Model для предоставления доступа к новому Greeting в шаблоне представления. Greeting объект в приведенном ниже коде содержит поля id и content , соответствующие полям формы в greeting представлении, и которые будут использованы для извлечения информации из формы.

package hello; public class Greeting < private long id; private String content; public long getId() < return id; >public void setId(long id) < this.id = id; >public String getContent() < return content; >public void setContent(String content) < this.content = content; >>

Реализация тела метода основана на View Technology, в данном случае на Thymeleaf, чтобы выполнять рендеринг HTML на стороне сервера. Thymeleaf парсит шаблон greeting.html , приведенный ниже, и вычисляет различные выражения для рендеринга формы.

     
Form
 
 
Id: " />
 
Message: " />
 
  

Выражение th:action=»@» направляет форму к POST запросу /greeting , в то время как выражение th:object=»$» описывает модель объекта для сбора данных. Два поля формы, выраженные в th:field=»*» и th:field=»*» , соответствуют полям объекта Greeting .

Это то, за что отвечает контроллер, модель и представление для отображения формы. Теперь давайте рассмотрим процесс отправки формы. Как уже отмечалось выше, форма отправляется на /greeting , используя POST . Метод greetingSubmit() получает объект Greeting , который был заполнен формой. Затем он добавляет этот объект в модель для того, чтобы отправленные данные могли быть отображены в представлении result , как показано ниже. id представлен в выражении

» />

     
Result
 " /> " /> Submit another message  

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

Создание приложения исполняемым

Несмотря на то, что пакет этого сервиса может быть в составе web-приложения и WAR файлов, более простой подход, продемонстрированный ниже создает отдельное самостоятельное приложение. Вы упаковываете все в единый, исполняемый JAR-файл, который запускается через хорошо знакомый старый main() Java-метод. Попутно, вы используете поддержку Spring для встроенного Tomcat контейнера сервлетов как HTTP среду выполнения вместо развертывания на сторонний экземпляр.

package hello; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.EnableAutoConfiguration; import org.springframework.context.annotation.ComponentScan; @ComponentScan @EnableAutoConfiguration public class Application < public static void main(String[] args) < SpringApplication.run(Application.class, args); >>

Метод main() передает управление вспомогательному классу SpringApplication , предоставляя Application.class как аргумент его run() методу. Это говорит Spring о том, чтобы прочитать аннотацию метаданных из Application и управлять им как компонентом в Spring Application Context.

Аннотация @ComponentScan сообщает Spring о запуске рекурсивного поиска в пакете hello и потомках классов, отмеченных прямо или косвенно Spring аннотацией @Component . При этом гарантируется, что Spring найдет и зарегистрирует GreetingController , потому что он отмечен @Controller , что в свою очередь является своего рода @Component аннотацией.

@EnableAutoConfiguration аннотация переключает на доступные по умолчанию настройки, основанные на содержимом вашего classpath. К примеру, т.к. приложение зависит от встраиваемой версии Tomcat(tomcat-embed-core.jar), то Tomcat сервер установлен и настроен по умолчанию от вашего имени. И также, т.к. приложение зависит от Spring MVC (spring-webmvc.jar), Spring MVC DispatcherServlet настроен и зарегистрирован за вас — web.xml не нужен! Автонастройка является мощным и гибким механизмом. Более подробно вы можете ознакомиться в API документации.

Сборка исполняемого JAR

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

./gradlew build

Затем вы можете запустить JAR-файл:

java -jar build/libs/gs-handling-form-submission-0.1.0.jar

Если вы используете Maven, вы можете запустить приложение, используя mvn spring-boot:run , либо вы можете собрать приложение с mvn clean package и запустить JAR примерно так:

java -jar target/gs-handling-form-submission-0.1.0.jar

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

Если вы используете Gradle, вы можете запустить ваш сервис из командной строки:

./gradlew clean build && java -jar build/libs/gs-handling-form-submission-0.1.0.jar

Если вы используете Maven, то можете запустить ваш сервис таким образом: mvn clean package && java -jar target/gs-handling-form-submission-0.1.0.jar .

Как вариант, вы можете запустить ваш сервис напрямую из Gradle примерно так:

./gradlew bootRun

С mvn — mvn spring-boot:run .

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

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

Теперь, когда web сайт запущен, перейдите по адресу http://localhost:8080/greeting, где вы увидите форму:

Отправьте id и message, чтобы посмотреть на результат:

Итог

Поздравляем! Вы только что использовали Spring для создания и отправки формы.

С оригинальным текстом урока вы можете ознакомиться на spring.io.

Добавление записи через POST-запрос в Spring Boot

В статье Работа с БД в Spring Boot на примере postgresql мы узнали как читать данные из БД. Но чтение данных – это лишь малая часть всех операций, которые встречаются в типичном java-приложении. Теперь попробуем создать полноценный rest-интерфейс для добавления новых записей, их модификации и удаления.

За основу возьмём наше приложение из указанной статьи. Оно состоит из трёх слоёв: работа с БД (repository), бизнес-логика приложения (service) и сам rest-интерфейс (controller), который обрабатывает входящий json и генерирует исходящий.

Репозиторий

Начнём с доработки репозитория (интерфейс ProfileRepository), где до сих пор был только один метод чтения данных. Добавим метод вставки записи в БД:

void insertProfile(String firstName, String secondName, int age);

При добавлении новой записи нам достаточно всего три поля. id будет сгенерирован в БД автоматически.

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

private static final String SQL_INSERT_PROFILE =
«insert into profile (first_name, last_name, age) values (:firstName, :lastName, :age)» ;

Имена параметров, которые мы будем подставлять в sql-запрос, начинаются с двоеточия.

Вот реализация добавления записи в БД:

@Override
public void insertProfile(String firstName, String lastName, int age) var params = new MapSqlParameterSource();
params.addValue( «firstName» , firstName);
params.addValue( «lastName» , lastName);
params.addValue( «age» , age);
jdbcTemplate.update( SQL_INSERT_PROFILE , params);
>

Всё предельно просто: сначала собираем параметры, затем передаём их вместе с запросом в метод jdbcTemplate.update(), который вопреки своему названию отвечает вообще за любые изменения данных (и insert, и update, и delete). Обратите внимание, что jdbcTemplate у нас имеет тип NamedParameterJdbcTemplate – именно он позволяет использовать именованные параметры. Иначе пришлось бы писать знаки вопроса.

Сервисный слой

Перейдём к сервисному слою. Интерфейс ProfileService не отличается оригинальностью:

void createProfile(String firstName, String secondName, int age);

Его реализация в ProfileServiceImpl. Здесь по сути только вызываем метод репозитория:

@Override
public void createProfile(String firstName, String secondName, int age) profileRepository.insertProfile(firstName, secondName, age);
>

Контроллер

Согласно архитектуре restful-сервисов, чтение данных мы делаем при помощи GET-запросов, а создание – при помощи POST. Также хотелось бы отметить, что у GET-запроса не может быть тела запроса (body), все его параметры перечисляются в строке запроса. А POST-запрос может иметь тело, в которое мы будем помещать целевой json.

Сперва нам нужно добавить в проект ещё одну зависимость spring-boot-starter-validation, которая позволяет валидировать входящие запросы:

org.springframework.boot
spring-boot-starter-validation

Перейдём к нашему контроллеру ProfileController и добавим в него метод создания профиля.

@PostMapping
@ResponseStatus (HttpStatus. CREATED )
public void createProfile( @Valid @RequestBody ProfileRequest request) profileService.createProfile(
request.firstName(),
request.lastName(),
request.age()
);
>

В качестве аргумента метод принимает объект ProfileRequest, реализованный как record-class:

public record ProfileRequest(
@NotNull
String firstName,
@NotNull
String lastName,
@NotNull
@Min ( 1 )
Integer age
) >

Эта модель представляет собой ровно тот объект, который мы ожидаем в теле запроса. Имена полей в json должны совпадать с именами полей в классе (при желании это можно переопределить дополнительной аннотацией). Дополнительно накладываем ограничения из пакета javax.validation.constraints на каждое поле.

Аннотация @NotNull применима для ссылочных типов и означает обязательность этого поля в запросе. Обратите внимание, что тут мы специально используем ссылочный Integer, который допускает null, а не примитивный int, который по умолчанию равен нулю. Ссылочный числовой тип вместе с @NotNull позволяет проверять обязательность числовых типов.

Аннотация @Min говорит сама за себя и ограничивает числовые типы снизу. Тем самым мы никогда не допустим, чтобы нам передали отрицательное число в качестве возраста.

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

Аннотация @PostMapping указывает на то, что это обработчик POST-запроса. В скобках можно указать относительный урл, но в данном случае мы его не указали, поэтому запрос надо будет кидать по тому адресу, который указан на уровне контроллера, то есть /profiles. @ResponseStatus показывает, какой http-код нужно вернуть в ответ. В данном случае мы опять следуем rest-соглашениям и возвращаем код 201 – «Created».

Теперь мы готовы к тому, чтобы выполнить rest-запрос на создание новой записи в БД. Запускаем приложение и отравляем указанный POST-запрос по адресу http://127.0.0.1:8080/profiles. В http-заголовках обязательно указываем Content-Type: application/json.

<
«firstName» : «Петр» ,
«lastName» : «Сидоров» ,
«age» : 14
>

В ответ в случае успеха получаем http-статус 201. Если же мы попытаемся нарушить наши ограничения по полям, то получим json с подробным описанием ошибки.

Таким образом, Spring Boot позволяет буквально за 5 минут создать полноценный обработчик POST-запроса с валидацией входящих параметров.

В следующей статье Обновление записи через PUT-запрос в Spring Boot рассмотрим как можно обновлять записи.

REST API с использованием Spring

Spring Framework WebMVC позволяет разрабатывать не только классические веб-приложения, но и реализовывать REST API. В этой статье я опишу процесс разработки REST API простого проекта на Java с использованием Spring Boot и Spring Framework.

О REST и его поддержке в Spring

REST — это архитектурный стиль взаимодействия приложений в сети. Но в отличии от SOAP, у REST отсутствует какой-либо стандарт, а данные между клиентом и сервером могут предаваться в любом виде, будь то JSON, XML, YAML и т.д.

Spring Framework предоставляет богатый набор инструментов, упрощающий разработку REST API: инструменты для маршрутизации запросов, классы-кодеки для преобразования JSON/XML в объекты требуемых типов и т.д.

HTTP-методы

В отличии от классических веб-приложений, в которых используются только методы GET и POST, в REST API используются практически все HTTP-методы, например:

• GET — для получения объекта или списка объектов
• HEAD — проверка существования объекта
• OPTIONS — проверка доступных методов для указанного пути
• POST — для создания нового объекта
• PUT — для полного изменения объекта или помещения объекта в список
• PATCH — для частичного изменения объекта
• DELETE — для удаления объекта

Стоит помнить, что хорошей практикой является использование GET только для запросов, которые не изменяют состояние объекта. Если запрос должен изменить состояние объекта, то должен использоваться соответствующий HTTP-метод, хотя бы POST.

Для маршрутизации запросов в Spring Framework используется аннотация @RequestMapping с указанием HTTP-метода при помощи свойства method или более простые аннотации вроде
@GetMapping, @PostMapping, @DeleteMapping и т.д.

HTTP-заголовки

Очень важными при разработке REST API являются и HTTP-заголовки. Например, клиент может, указывать MIME-тип содержимого отправляемого запроса при помощи заголовка Content-type или ожидаемый MIME-тип ответа или даже его версию при помощи заголовка Accept.

Возможности Spring Framework WebMVC позволяют маршрутизировать запросы в зависимости не только от их пути или методов, но и в зависимости от заголовков:

Базовый проект

Проект будет реализовывать REST API списка задач. В проекте мы будем использовать Spring Boot, из которого нам понадобятся стартеры:

• Web — для поддержки веб
• JDBC — для работы с базой данных
• H2 — в качестве тестовой базы данных

Код pom.xml приведён ниже:

Поскольку в проекте будет использоваться реляционная база данных, нам потребуется описать SQL-схему таблицы, в которой будут храниться задачи:

Класс, описывающий эту структуру:

REST контроллер

Теперь, когда у нас есть вся необходимая структура, мы можем приступить непосредственно к разработке REST API. Для этого создадим заготовку класса TodoRestController:

• Контекст приложения создаст и зарегистрирует экземпляр класса, поскольку указана аннотация @RestController. Кроме этого аннотация подсказывает, что возвращаемые методами значения являются телом ответов на запросы. Эта аннотация заменяет собой пару @Controller + @ResponseBody.
• Аннотация @RequestMapping указывает на маршрутизацию запросов: все запросы, начинающиеся с api/todo будут обрабатываться этим контроллером.
• Объект типа JdbcOperations будет внедрён через конструктор.

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

Метод получения списка задач должен быть вызван при GET-запросе по пути /api/todo, он должен обратиться к базе данных и вернуть полученный список с HTTP-кодом 200 OK.

• @GetMapping указывает, что метод getTodoList должен обрабатывать GET-запросы с путём /api/todo. Альтернативно может быть использована аннотация @RequestMapping(method = RequestMethod.GET).
• При помощи объекта типа ResponseEntity, возвращаемого методом, можно тонко настроить ответ, включая коди заголовки ответа. Фактически можно просто вернуть список задач, не оборачивая его в ResponseEntity.

Получение одной задачи

Метод получения одной задачи по её идентификатору должен быть вызван при GET-запросе по пути /api/todo/ ; он должен обратиться к базе данных и вернуть задачу с HTTP-кодом 200 OK или 404 Not Found, если задачи нет в БД.

@Controller @ResponseBody public interface RestController

@GetMapping("getByName") public User getUserByName(@RequestParam("name") String name) < //some logic >

@GetMapping("getById/") public User getUserById(@PathVariable("id") String id) < //some logic >

@PostMapping @ResponseStatus(HttpStatus.CREATED) public void add(. )

@GetMapping("/hello") ResponseEntity hello()

@PostMapping("accounts") //Например, запрос с JSON конвертируется в объект Account public void handle(@RequestBody Account account)

RestTemplate restTemplate = new RestTemplate(); String fooResourceUrl = "http://localhost:8080/spring-rest/foos"; ResponseEntity response = restTemplate.getForEntity(fooResourceUrl + "/1", String.class);