PostgreSQL, Spring Framework и Android для начинающего разработчика

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

В статье будут затронуты такие важные темы, как теория баз данных, реляционная база данных PostgreSQL, Spring Framework и Android разработка. Также будет рассмотрен базовый, не очень сложный пример, который поможет разобраться во всех этих темах и «потрогать» их руками.

Статья предназначена для начинающего разработчика, но имеющего базовые знания о разработке программного обеспечения и языках программирования Java и Kotlin.

Все материалы и исходный код можно найти здесь.

Данная статья была написана вместе с Java-backend разработчиком — аккаунт.

Что должно получиться?

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

Основная тема приложения: интернет-магазин, который продаёт какой-то товар.
У конечного пользователя должна быть возможность зарегистрироваться и авторизоваться в интернет-магазине, редактировать свои персональные данные, выбирать и заказывать товар.

Теория баз данных

Перед тем как изучать PostgreSQL, Spring Framework и Android необходимо разобраться с основными понятиями баз данных.

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

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

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

Атрибут базы данных — конкретная характеристика или свойство, которое определяет определенный аспект сущности базы данных, такой как сущность, таблица или класс. Атрибуты представляют собой конкретные данные, которые хранятся в базе данных.

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

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

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

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

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

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

Существует несколько типов связей в реляционных базах данных, таких как:

Источники, которые могут расширить кругозор по теории баз данных можно найти здесь, здесь и здесь.

PostgreSQL и создание базы данных

Теперь следует поговорить о PostgreSQL.

PostgreSQL — это свободная объектно-реляционная система управления базами данных (СУБД), которая является одной из наиболее мощных и распространенных СУБД в мире.

PostgreSQL предоставляет множество возможностей, включая поддержку SQL (Structured Query Language), транзакции с поддержкой ACID (атомарность, согласованность, изолированность, долговечность), индексы, хранимые процедуры, триггеры и многое другое. Она также обладает высокой степенью надежности, масштабируемости и производительности, что делает ее популярным выбором для различных приложений, включая веб-сайты, системы управления контентом, финансовые приложения и т.д.

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

Ниже приведен SQL-скрипт, который создаёт базу данных:

create table _user (     id          bigserial not null,     email       varchar(255),     first_name  varchar(255),     last_name   varchar(255),     middle_name varchar(255),     password    varchar(255),     primary key (id) )  create table cart (     id      bigserial not null,     user_id bigint,     primary key (id) )  create table cart_products (     cart_id     bigint not null,     products_id bigint not null )  create table product (     id    bigserial not null,     image varchar(255),     name  varchar(255),     price float(53),     primary key (id) )  alter table if exists cart_products     add constraint UK_3kg5kx19f8oy0lo76hdhc1uw1 unique (products_id)  alter table if exists cart     add constraint FKil7wc86wc3xs4je2ghfenn854 foreign key (user_id) references _user  alter table if exists cart_products     add constraint FKhyhnx21758m3wmbi4ps96m0yw foreign key (products_id) references product  alter table if exists cart_products     add constraint FKnlhjc091rdu9k5c8u9xwp280w foreign key (cart_id) references cart 

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

insert into product values (default,         'https://static.wikia.nocookie.net/fnaf-fanon-animatronics/images/4/40/%D0%91%D0%B0%D0%BD%D0%B0%D0%BD.png/revision/latest?cb=20190614113143&path-prefix=ru',         'Banana', 179.90),        (default,         'https://m.dom-eda.com/uploads/images/catalog/item/86df51de21/c25c94fe96_1000.jpg',         'Apple', 199.90),        (default,         'https://media.vprok.ru/products/x700/tn/u6/uyt2yc2e337ofqf7vsfm4cdomdxwu6tn.jpeg',         'Strawberry', 250.00),        (default,         'https://foodcity.ru/storage/products/October2018/8No9uQ14ycYG7UluJEaM.jpg',         'Pineapple', 419.90),        (default,         'https://eden-g.com/assets/images/products/1645/gridjpgbigest/qiwi-m.jpg',         'Kiwi', 315.90),        (default,         'https://fruit-berries.ru/images/cms/thumbs/3a031f89ff2849f64a5233c90f77a8ac353f35bb/durian-800x1000_483_483_jpg_5_92.jpg',         'Durian', 899.00),        (default,         'https://ecomarket.ru/imgs/products/13647/mango-sochnoe---600-g-1.1632501465.JPG',         'Mango', 510.90) 

Spring Framework

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

Spring Framework построен на основе паттерна «Inversion of Control» (IoC), что позволяет сосредоточиться на разработке бизнес-логики приложения, а не заботиться о решении технических задач, связанных с управлением зависимостями и ресурсами. Кроме того, Spring Framework также поддерживает паттерн «Aspect Oriented Programming» (AOP), который позволяет разделять общую функциональность на отдельные аспекты, чтобы упростить их использование и повторное использование.

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

Составим «поэтапный план действий», которому будем придерживаться для создания backend’a приложения:

1. Подключение зависимостей.

В качестве сборщика следует использовать Gradle, подробнее про работу с ним можно прочитать здесь.

Нам необходимо добавить следующие модули Spring: Data JPA, Web и Security. Также, необходимо подключить драйвер базы данных PostgreSQL.

dependencies {     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'     implementation 'org.springframework.boot:spring-boot-starter-web'     implementation 'org.springframework.boot:spring-boot-starter-security'     implementation 'com.auth0:java-jwt:4.4.0'     compileOnly 'org.projectlombok:lombok'     runtimeOnly 'org.postgresql:postgresql'     annotationProcessor 'org.projectlombok:lombok'     testImplementation 'org.springframework.boot:spring-boot-starter-test' } 

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

Необходимо создать 3 класса сущностей: User, Product и Cart, пометим их аннотацией @Entity. Про механизм ORM, который использует Spring Data JPA подробнее можно прочитать здесь.

@Entity @Getter @Setter @AllArgsConstructor @NoArgsConstructor @Table(name = "_user") public class User {     @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Long id;     private String email;     private String password;     private String firstName;     private String lastName;     private String middleName; } 

@Entity @Getter @Setter @AllArgsConstructor @NoArgsConstructor public class Product {     @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Long id;     private String name;     private Double price;     private String image;  } 

@Entity @Getter @Setter @AllArgsConstructor @NoArgsConstructor public class Cart {     @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Long id;     @OneToOne     private User user;     @OneToMany     private List<Product> products; } 

Аналогичным образом создадим репозитории:

public interface CartRepository extends JpaRepository<Cart, Long> { } 

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

public interface CartRepository extends JpaRepository<Cart, Long> {     Cart findByUser(User user); } 

Для более глубокого понимания как работает Spring Data — рекомендую посмотреть данный источник.

3. Создание контроллеров.

Создадим контроллеры, в которых происходит обработка входящих запросов. В качестве примера разберем UserController:

@RestController @RequestMapping("/users") @RequiredArgsConstructor public class UserController {     private final UserService userService;      @GetMapping("/{id}")     public ResponseEntity<User> findUser(@PathVariable Long id) {         User user = userService.findUser(id);         return ResponseEntity.ok(user);     }      @PatchMapping("/edit/{id}")     public ResponseEntity<User> editUser(@PathVariable Long id, @RequestBody UserEditDTO userEditDTO) {         User user = userService.editUser(id, userEditDTO);         return ResponseEntity.ok(user);     } } 

В нем представлены 2 конечные точки: /users/{id} и /users/edit/{id}.
Аннотация @RestController сообщает Spring, что ответы на запросы неоходимо возвращать в формате JSON. @RequestMapping("/users") позволяет использовать один префикс для всех запросов. @GetMapping и @PatchMapping сообщают о том, какие HTTP методы использовать для запросов: GET и PATCH соответственно.

4. Создание бизнес-логики.

@Service @RequiredArgsConstructor public class UserService {     private final UserRepository userRepository;      public User findUser(Long id) {         Optional<User> optionalUser = userRepository.findById(id);         return optionalUser.orElseThrow();     }      public User editUser(Long id, UserEditDTO userEditDTO) {         User user = userRepository.findById(id).orElseThrow();         user.setFirstName(userEditDTO.firstName());         user.setLastName(userEditDTO.lastName());         user.setMiddleName(userEditDTO.middleName());          return userRepository.save(user);     } } 

В сервисе присутствует 2 метода с простой логикой: поиск пользователя по ID, в котором используется метод репозитория findById(Long id) с реализацией, поставляемой Spring Data по умолчанию, а также editUser(Long id, UserEditDTO userEditDTO) (что такое DTO), который обновляет ФИО пользователя в базе данных с помощью метода save(User user) UserRepository.

5. Безопасность.

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

@Configuration @EnableWebSecurity @EnableMethodSecurity @RequiredArgsConstructor public class SecurityConfig {     private final JwtFilter jwtFilter;      @Bean     public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {         http                 .csrf().disable()                 .authorizeHttpRequests().requestMatchers("/auth/**").permitAll()                 .anyRequest().hasRole("USER")                 .and().sessionManagement().disable()                 .logout().logoutUrl("/logout")                 .and().sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS);         http.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);          return http.build();     }      @Bean     public AuthenticationManager authenticationManager(AuthenticationConfiguration authenticationConfiguration)             throws Exception {         return authenticationConfiguration.getAuthenticationManager();     }      @Bean     public PasswordEncoder getPasswordEncoder() {         return new BCryptPasswordEncoder();     } }

Особое внимание в коде выше стоит уделить созданию бина filterChain, в нем описывается основная логика работы Spring Security. В качестве принципа, по которому мы создаем этот бин, выступает паттерн chain of responsibility. Так, запрос поступающий нашему приложению поэтапно проходит валидацию через каждый метод, например: с помощью .requestMatchers("/auth/**").permitAll() мы сообщаем Spring-у пропускать все запросы начинающиеся на /auth/ без авторизации, нужно это для того, чтобы пользователи могли зарегистрироваться/авторизоваться в приложении. Строкой .anyRequest().hasRole("USER") мы описываем, что ко всем остальным эндпоинтам имеют доступ только авторизованные пользователи с ролью «USER» (в соответствии с логикой нашего приложения, она выдается всем при регистрации). Также, стоит обратить внимание на строку http.addFilterBefore(jwtFilter, UsernamePasswordAuthenticationFilter.class);, в ней мы добавляем фильтр проверки валидности JWT токена.

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

Android-приложение

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

В данной статье не будут рассмотрены основы разработки приложения — верстка layot’ов, связь с классами и т.д. Основное внимание будет уделено библиотеке Retrofit2.

Важное уточнение! В данном приложении используется небольшое «ядро» с архитектурой MVVM. Данное «ядро» используется для быстрого и качественного расширения приложения, а также для удобства разработки приложения с шаблоном проектирования MVVM. Более детально с «ядром» можно ознакомиться здесь.

MVVM (Model-View-ViewModel) — паттерн проектирования для разработки пользовательского интерфейса, который помогает разделить приложение на три отдельных компонента: Model, View и viewModel. Более подробно — здесь.

Retrofit2 — это библиотека для работы с сетевыми запросами в приложениях для Android. Она предоставляет удобный интерфейс для взаимодействия с API удаленных серверов с использованием HTTP-запросов.

С помощью данной библиотеки можно определить интерфейс для взаимодействия с сервером и использовать аннотации для указания конечной точки URL, параметров запроса, тела запроса и типа запроса (например, GET, POST, PUT и т.д.). Также библиотека может автоматически преобразовывать ответы в Java/Kotlin-объекты с помощью специализированных конвертеров.

Библиотека упрощает процесс работы с сетевыми запросами и позволяет сосредоточиться на более важных аспектах разработки приложения. Retrofit2 обладает хорошей производительностью и является одной из наиболее популярных библиотек для работы с сетью в Android-разработке.

В первую очередь необходимо импортировать саму библиотеку и JSON-конвертер, который будет преобразовывать JSON-файлы в data-классы. Для этого в файле build.gradle уровня приложения, в тэге dependencies:

    implementation 'com.squareup.retrofit2:retrofit:2.9.0'     implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

Также добавим другие зависимости, которые потребуются в процессе разработки:

dependencies {     ---     // !!! - Retrofit 2 & GSON-converter     implementation 'com.squareup.retrofit2:retrofit:2.9.0'     implementation 'com.squareup.retrofit2:converter-gson:2.9.0'     // !!! - Glide     implementation 'com.github.bumptech.glide:glide:4.15.1'     // !!! - Fragment Ktx     implementation 'androidx.fragment:fragment-ktx:1.5.6'     // !!! - Kotlin Coroutines     implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.4'     // !!! - JWT decode     implementation 'com.auth0.android:jwtdecode:2.0.2'     --- } 

Для работы библиотеки необходимы разрешения, которые следует прописать в AndroidManifest:

    <uses-permission android:name="android.permission.INTERNET" />     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" /> 

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

• @GET, @POST, @PUT, @DELETE, @PATCH — используются для указания типа HTTP-запроса, который должен быть отправлен на сервер.

• @Body — используется для передачи тела запроса. Тело запроса может быть представлено объектом модели или строкой.

• @Path — используется для передачи динамических параметров запроса. Значение параметра будет извлечено из URL-адреса запроса.

• @Url — используется для указания URL-адреса запроса. Эта аннотация может использоваться вместо параметра baseURL, который указывается в Retrofit.Builder().

• @Header, @Headers — используются для передачи заголовков запроса. @Header используется для передачи одного заголовка, а @Headers — для передачи нескольких заголовков.

• @JsonAdapter — используется для указания пользовательского адаптера для сериализации и десериализации объектов в JSON.

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

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

data class AuthEntity(     @SerializedName("email") var email: String,     @SerializedName("password") var password: String )  data class TokenEntity(     @SerializedName("accessToken") var accessToken: String? = null,     @SerializedName("refreshToken") var refreshToken: String? = null )

Для реализации авторизации создадим интерфейс UserAPI, в котором, с помощью аннотаций, пропишем метод, который будет связываться с эндпоинтом «auth/login». Данный метод, в качестве тела запроса будет получать сущность AuthEntity, а возвращать — TokenEntity:

interface UserAPI {      @POST("auth/login")     suspend fun authorization(@Body body: AuthEntity): TokenEntity  }

Теперь создадим класс UserServerRepository, который будет вызывать методы связи с сервером. Данный класс имеет один метод signIn, принимающий e-mail и пароль как авторизационные данные пользователя.
Важно отметить — метод signIn будет вызываться из корутины, соответсвенно, данный метод помечен ключевым словом suspend. Также в данном методе переопределен Dispatcher для корректной работы приложения. Подробнее про корутины можно почитать здесь и здесь.

class UserServerRepository(retrofit: Retrofit) : UserRepository {      private val userAPI = retrofit.create(UserAPI::class.java)      override suspend fun signIn(email: String, password: String): TokenEntity {         return withContext(Dispatchers.IO) {             val authEntity = AuthEntity(email, password)              return@withContext userAPI.authorization(authEntity)         }     }      }

В AuthViewModel создадим метод authorization, который будет принимать e-mail и пароль от пользователя со стороны фрагмента. Данный метод запускает новую корутину и вызывает метод signIn из UserServerRepository.
В случае, если данные (два токена) будут получены успешно, то токены сохраняться в хранилище устройства, а после будет запущен основной экран.

    fun authorization(email: String, password: String) {         viewModelScope.launch() {             try {                 val tokenEntity = userRepository.signIn(email, password)                 tokenService.setTokens(tokenEntity)                  launchMainScreen()             } catch (exception: Exception) {                 Log.d("Auth Error", exception.toString())             }         }     }

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

Рассмотрим еще один запрос к серверу — получение персональных данных пользователя. В данном запросе необходимо передать в параметре запроса уникальный номер пользователя и провести авторизацию с помощью JWT. Создадим метод:

    @GET("users/{user_id}")     suspend fun getUserPersonalData(         @Header("Authorization") accessToken: String,         @Path("user_id") userId: Long     ): PersonalDataEntity

В параметрах данного метода находятся две переменные с соответсвующими аннотациями. Как уже было сказано, аннотация @Header используются для передачи заголовков запроса, в данном случае — авторизация. Аннотация @Path используется для передачи id пользователя в URL (например, если у пользователя id = 7, то получаем путь: «…/users/7»).

Аналогично сущностям авторизации и регистрации создадим сущность с персональными данными пользователя:

data class PersonalDataEntity(     @SerializedName("id") var id: Long? = null,     @SerializedName("email") var email: String? = null,     @SerializedName("firstName") var firstName: String? = null,     @SerializedName("lastName") var lastName: String? = null,     @SerializedName("middleName") var middleName: String? = null ) 

Идентично регистрации и авторизации получим данные о пользователе из userRepository, в котором создадим метод getPersonalData, принимающий токен и уникальный номер:

    override suspend fun getPersonalData(accessToken: String, userId: Long): PersonalDataEntity {         return withContext(Dispatchers.IO) {             return@withContext userAPI.getUserPersonalData("Bearer $accessToken", userId)         }     }

Обратимся к этому методу из PersonalDataViewModel. Функция во ViewModel создает новую корутину, в которой вытаскивает из хранилища устройства JWT, расшифровывает его (библиотека «JWT-Decode») и отправляет в репозиторий:

    private val _personalData = MutableStateFlow(PersonalDataEntity.emptyPersonalDataEntity)     val personalData: StateFlow<PersonalDataEntity> = _personalData      fun getPersonalData() {         viewModelScope.launch {             try {                 val accessToken = tokenService.getAccessToken()!!                 val jwt = JWT(accessToken)                 val id = jwt.getClaim("id").asString()?.toLong() ?: -1                  val personalDataEntity = userRepository.getPersonalData(accessToken, id)                 _personalData.value = personalDataEntity             } catch (exception: Exception) {                 Log.d("PersonalData Error", exception.toString())             }         }     }

Я надеюсь, основная концепция работы библиотеки понятна. Далее в данной статье будут приводиться только сущности, которые приходят с сервера, API-методы и методы репозиториев.

Редактирование персональных данных пользователя.

// Сущность для редактирования персональных данных пользователя: data class EditPersonalDataEntity(     @SerializedName("firstName") var firstName: String,     @SerializedName("lastName") var lastName: String? = null,     @SerializedName("middleName") var middleName: String? = null )

    // API-метод, который делает запрос на редактирование:     @PATCH("users/edit/{user_id}")     suspend fun editUserPersonalData(         @Header("Authorization") accessToken: String,         @Path("user_id") userId: Long,         @Body newUserData: EditPersonalDataEntity     ): PersonalDataEntity

    // Метод UserServerRepository, который связывается с сервером:     override suspend fun editPersonalData(         accessToken: String, firstName: String, lastName: String?, middleName: String?, userId: Long     ): PersonalDataEntity {         return withContext(Dispatchers.IO) {             val newUserData = EditPersonalDataEntity(                 firstName = firstName, lastName = lastName, middleName = middleName             )              return@withContext userAPI.editUserPersonalData(                 accessToken = "Bearer $accessToken", userId = userId, newUserData = newUserData             )         }     }

Получение всех существующих продуктов для вкладки «Магазин.»

// Сущность одного продукта магазина: data class ProductEntity(     @SerializedName("id") var id: Long,     @SerializedName("name") var name: String,     @SerializedName("price") var price: Double,     @SerializedName("image") var image: String )

    // API-метод, который возвращает список объектов-продуктов:     @GET("products")     suspend fun getAllProducts(@Header("Authorization") accessToken: String): List<ProductEntity>

    // Метод ProductsServerRepository, который связывается с сервером:     override suspend fun getAllProducts(accessToken: String): List<ProductEntity> {         return withContext(Dispatchers.IO) {             return@withContext productsAPI.getAllProducts("Bearer $accessToken")         }     }

Добавление нового продукта в корзину.

// Сущность "нового продукта", добавленного в корзину: data class NewProductEntity(     @SerializedName("userId") var userId: Long,     @SerializedName("productId") var productId: Long )

    // API-метод, который добавляет новый продукт в корзину:     @POST("carts/add")     suspend fun addNewProductInBasket(         @Header("Authorization") accessToken: String,         @Body body: NewProductEntity     )

    // Метод ProductsServerRepository, который связывается с сервером:     override suspend fun addNewProductInBasket(accessToken: String, userId: Long, productId: Long) {         withContext(Dispatchers.IO) {             productsAPI.addNewProductInBasket(                 accessToken = "Bearer $accessToken",                 body = NewProductEntity(                     userId = userId,                     productId = productId                 )             )         }     }

Заключение

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

• Metanit — Руководство по PostgreSQL — ссылка.

• Что такое База Данных (БД) — ссылка.

• Metanit — Программирование под Android — ссылка.

• Retrofit 2 в Android — ссылка.

• Spring | Learn — ссылка.

• Learn Spring Boot — ссылка.