Рубрики
Без рубрики

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

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

Автор оригинала: Nilmadhab mondal.

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

Spring – это популярная платформа разработки приложений, разработанная для корпоративной версии языка программирования Java. Согласно веб-сайту Spring : “Spring делает программирование Java быстрее, проще и безопаснее для всех. Акцент Spring на скорости, простоте и производительности сделал его самым популярным в мире Java-фреймворком. “MySQL-это система управления реляционными базами данных с открытым исходным кодом. Это база данных, которую мы будем использовать для хранения наших зарегистрированных пользователей. Swagger-это проект с открытым исходным кодом, используемый для описания и документирования нашего API.

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

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

  • Вам потребуется установить Java JDK в вашей системе. Вы можете найти инструкции по установке JDK здесь .
  • Вам потребуется установить Интегрированную среду разработки. Лично я бы рекомендовал Издание сообщества IntelliJ IDEA .
  • Вам понадобится терминал и интерфейс командной строки Curl. Если вы работаете на macOS или Linux, то вы должны быть охвачены. Если вы работаете в Windows, то вы можете либо попробовать установить Curl или вы можете использовать подсистему Windows для Linux , это просто позволит вам использовать терминал Linux в Windows.
  • Наконец, нам нужно установить MySQL. Вы можете следовать шагам , которые у них есть на их веб-сайте.

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

Мой проект настроен следующим образом:

  • Проект: Проект Maven.
  • Язык: Ява.
  • Пружинный ботинок: 2.4.0
  • Группа: (Оставлено пустым).
  • Артефакт: учебное пособие.
  • Название: учебное пособие.
  • Описание: Базовое приложение для аутентификации пользователей, созданное с использованием Spring и Spring Boot.
  • Имя пакета: .учебник
  • Упаковка: Кувшин
  • Ява: 8
  • Зависимости: Spring Web, драйвер MySQL, Spring Data JPA

Зависимости не так важны, потому что я дам вам список зависимостей, которые мы будем использовать, чтобы убедиться, что мы оба находимся на одной странице с проектом. Как только вы все выбрали, вы можете нажать на кнопку “Создать”. Это создаст zip-файл, который вы должны загрузить и распаковать в папку разработки. Импортируйте проект в выбранную вами среду разработки. Если вы используете IntelliJ, шаги для импорта проекта следующие:

  • Откройте IntelliJ.
  • Нажмите на кнопку “Открыть или импортировать”.
  • Перейдите к файлу, который вы только что распаковали.
  • Нажмите на него один раз, чтобы выделить его, затем нажмите “Хорошо”.

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

Откройте файл под названием “Учебное приложение”. Это ваш основной файл. Когда вы запустите программу, она запустится здесь перед запуском других файлов. Найдите минутку, чтобы просто взглянуть на файл и попытаться понять, можете ли вы понять, что там происходит. Не забывайте также понимать, что вы технически создали свое первое весеннее приложение. Прежде чем мы сможем запустить программу, нам нужно сначала отредактировать некоторые файлы. Поэтому зайдите в “src/основные/ресурсы” и дважды щелкните “приложение.свойства”. Здесь хранятся свойства вашего приложения, как следует из названия. Введите это в файл:

spring.datasource.url = jdbc:mysql://localhost:3306/users
spring.datasource.username = USERNAME
spring.datasource.password = PASSWORD
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5InnoDBDialect
spring.jpa.hibernate.ddl-auto = update

springdoc.api-docs.path=/api-docs

Итак, этот блок кода задает путь к базе данных как “jdbc:mysql://локальный хост:3306/пользователи” (база данных размещена на компьютере по порту 3306, и нас особенно интересует база данных “пользователи”). Мы устанавливаем имя пользователя, вам нужно будет установить имя пользователя, которое вы настроили, обычно это “root”. Далее мы установим пароль для нашей базы данных, вы введете свой пароль здесь. В следующих двух строках мы просто скажем, как фреймворк Spring должен взаимодействовать с базой данных, и что мы хотим иметь возможность обновлять базу данных при работе с ней. Последняя строка намного менее важна, она просто указывает на новый путь нашей документации по API.

Видите, это было не так уж плохо, хотя и не очень интересно. Теперь вы можете закрыть этот файл, мы больше не будем касаться его в этом уроке. Затем откройте “pom.xml” файл в вашей основной папке. Это еще один файл, который обрабатывает настройку вашего проекта. Там же мы указываем, какие зависимости мы будем использовать. Я не собираюсь объяснять, что делает каждая зависимость, так как мы будем здесь весь день, если сделаем это.

Найдите скобку “<зависимости>, она должна быть между строками 21 и 41. Как только вы его нашли, вы можете заменить его этим блоком кода:


    
        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
  runtime
    
    
  org.springframework.boot
  spring-boot-starter-test
  test
    
    
  javax.validation
  validation-api
  2.0.1.Final
    
    
  org.springdoc
  springdoc-openapi-ui
  1.2.32

Как только вы сохраните свой проект, на нем появится значок “m” со значком перезагрузки. Нажмите на нее. Он загрузит зависимости и убедится, что все правильно. Последнее, что нам нужно сделать, это создать базу данных “пользователи”. Откройте свой терминал и введите эту команду:

mysql -u root -p

Он запросит у вас ваш пароль, введите пароль. Теперь вы должны увидеть что-то вроде этого:

Затем введите эту команду, чтобы отобразить все ваши активные базы данных:

SHOW DATABASES;

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

CREATE DATABASE users;

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

exit

чтобы выйти из терминала MySQL. Вернитесь в свою среду разработки и откройте “Учебное приложение”, оно находится в разделе “src/main/java/учебник”. Щелкните правой кнопкой мыши в файле и нажмите на зеленый треугольник с надписью “Запустить TutorialApplic…main()” рядом с ним. Откроется нижний терминал, и вы увидите много распечатываемого текста.

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

На вкладке “Проект” слева щелкните правой кнопкой мыши пакет “учебник”, а затем нажмите “создать”, а затем “пакет”. Назовите этот новый пакет “пользователь”. Щелкните правой кнопкой мыши на только что созданном пакете “пользователь”, а затем нажмите “создать” и “Класс Java”. Первый класс будет называться “Пользователь”.:

Теперь у вас должен быть новый файл, класс Java, в вашем пользовательском пакете, называемый User, с содержимым, подобным этому:

package tutorial.user;

public class User {
    
}

Нам также понадобится другой класс Java, называемый “UserController”, поэтому выполните те же действия, которые вы выполняли ранее, чтобы создать класс Java. Далее нам нужно будет создать интерфейс, называемый “Пользовательское хранилище”. Шаги аналогичны созданию класса, но вместо нажатия на класс вы нажмете на Интерфейс:

Последняя часть нашей головоломки-это перечисление, называемое “Статус”. Так же, как и раньше, создайте перечисление в пакете “пользователь”.

Мы начнем с редактирования класса “Пользователь”. Сначала я введу код, а затем пройдусь по нему, чтобы вы могли скопировать и вставить его в свою среду разработки и делать заметки с помощью комментариев.

tutorial/src/main/java/tutorial/user/User.java:

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.validation.constraints.NotBlank;
import java.util.Objects;

@Entity
@Table(name = "users")
public class User {
    private @Id @GeneratedValue long id;
    private @NotBlank String username;
    private @NotBlank String password;
    private @NotBlank boolean loggedIn;

    public User() {
    }

    public User(@NotBlank String username, 
                @NotBlank String password) {
        this.username = username;
        this.password = password;
        this.loggedIn = false;
    }

    public long getId() {
        return id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public boolean isLoggedIn() {
        return loggedIn;
    }

    public void setLoggedIn(boolean loggedIn) {
        this.loggedIn = loggedIn;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(username, user.username) &&
                Objects.equals(password, user.password);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, username, password, 
                            loggedIn);
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", loggedIn=" + loggedIn +
                '}';
    }
}

Итак, начиная с самого верха:

  • @Сущность: Эта аннотация позволяет сериализовать и десериализовать наш класс в JSON и из него. Это также позволяет нам создать таблицу в базе данных, которую мы создали ранее.
  • @Таблица(имя): Эта аннотация указывает программе называть таблицу “пользователи”.
  • Переменные: Каждая переменная является репрезентативной для поля в нашей базе данных. Таким образом, в нашей таблице базы данных будут содержаться записи. Каждая запись будет содержать поле идентификатора (длинное), поле имени пользователя (строка), поле пароля (строка) и поле входа в систему (логическое значение).
  • @Идентификатор: Это устанавливает переменную id в качестве поля id в базе данных. Базы данных записей работают с детьми.
  • @GeneratedValue: Это указывает программе генерировать значение идентификатора при добавлении новой записи, таким образом, нам не придется беспокоиться о случайном переопределении записей в нашей базе данных.
  • @NotBlank: Это гарантирует, что мы не сможем добавить в базу данных запись, в которой нет имени, пароля или значения для входа в систему.
  • Пользователь (имя пользователя в строке@NotBlank, пароль в строке @NotBlank): Это конструктор. Это функция, которая будет запущена при создании этого объекта класса. Он принимает имя пользователя и пароль, а затем устанавливает имя пользователя и пароль на те, которые были указаны, он также устанавливает значение LoggedIn как false, чтобы пользователь не входил автоматически при добавлении своего профиля.
  • Геттеры и сеттеры: Они используются для установки и возврата различных переменных в нашем классе. Причина этого в большей степени связана с Java и предпочтительным методом обработки данных, а не с фреймворком Spring.
  • равно(объект o): Это будет использовано позже, когда мы захотим сравнить объект, переданный программе, с объектом из нашей базы данных.
  • hashCode(): Эта функция используется для генерации хэш-значения нашего объекта.
  • toString(): Эта функция, название которой можно предположить, используется для возврата некоторой информации об объекте нашего класса в виде строки. Это особенно полезно во время отладки. Я часто использовал его, когда изначально создавал эту программу, так как у меня была проблема со сравнением объектов друг с другом.

Следующий файл, над которым мы будем работать, – это файл UserRepository.

tutorial/src/main/java/tutorial/user/UserRepository.java:

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends 
                                JpaRepository {
}

Теперь я признаю, что этот файл выглядит немного пустым, особенно по сравнению с User.java файл, но не позволяйте простоте обмануть вас, это очень мощный файл. Фреймворк выполняет большую работу под капотом, поэтому вы не обязательно видите его, но этот файл позволит нам взаимодействовать с нашей базой данных.

  • @Репозиторий: Это говорит Spring о том, что это интерфейс для использования в наших функциях управления базами данных.
  • JpaRepository<Пользователь, длинный>: Это связывает интерфейс с нашей таблицей базы данных. Мы говорим ему, чтобы он посмотрел на нашу таблицу пользователей, и мы говорим ему, что значение нашего поля идентификатора Длинное.

Далее идет перечисление нашего статуса:

tutorial/src/main/java/tutorial/user/Status.java:

public enum Status {
    SUCCESS,
    USER_ALREADY_EXISTS,
    FAILURE
}

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

Наконец, класс UserController:

tutorial/src/main/java/tutorial/user/UserController.java:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

@RestController
public class UserController {
    @Autowired
    UserRepository userRepository;

    @PostMapping("/users/register")
    public Status registerUser(@Valid @RequestBody User newUser) {
        List users = userRepository.findAll();

        System.out.println("New user: " + newUser.toString());

        for (User user : users) {
            System.out.println("Registered user: " + newUser.toString());

            if (user.equals(newUser)) {
                System.out.println("User Already exists!");
                return Status.USER_ALREADY_EXISTS;
            }
        }

        userRepository.save(newUser);
        return Status.SUCCESS;
    }

    @PostMapping("/users/login")
    public Status loginUser(@Valid @RequestBody User user) {
        List users = userRepository.findAll();

        for (User other : users) {
            if (other.equals(user)) {
                user.setLoggedIn(true);
                userRepository.save(user);
                return Status.SUCCESS;
            }
        }

        return Status.FAILURE;
    }

    @PostMapping("/users/logout")
    public Status logUserOut(@Valid @RequestBody User user) {
        List users = userRepository.findAll();

        for (User other : users) {
            if (other.equals(user)) {
                user.setLoggedIn(false);
                userRepository.save(user);
                return Status.SUCCESS;
            }
        }

        return Status.FAILURE;
    }

    @DeleteMapping("/users/all")
    public Status deleteUsers() {
        userRepository.deleteAll();
        return Status.SUCCESS;
    }
}

Это бизнес – класс вашей программы. Здесь мы обрабатываем запросы, отправленные в нашу программу.

  • @RestController: Это говорит Spring, что это будет использоваться для управления функциональностью нашего API и любыми запросами, отправляемыми в нашу программу.
  • @Autowired: Это просто обрабатывает ввод кода для нашего пользовательского хранилища, так что нам не придется настраивать конструктор.
  • @PostMapping(“/пользователи/регистрация”): Это говорит Spring о том, что всякий раз, когда наша программа получает запрос на/пользователей/регистрацию, следует вызывать функцию registerUser а затем он вставляет полученные данные в функцию registerUser.
  • Пользователь регистрации(@Действительный пользователь @RequestBody Новый пользователь): Для этой функции требуется действительный объект json, аналогичный нашему пользовательскому классу, таким образом, мы будем уверены, что полученный объект пригоден для использования в нашей программе. Функция начинается с создания списка пользователей в нашей базе данных, называемых пользователями. Обратите внимание на часть “UserRepository.findAll()”, которая запрашивает нашу базу данных и возвращает всех пользователей, которых мы в настоящее время сохранили. Затем функция перебирает всех пользователей в нашей базе данных и сравнивает их с пользователем, которого мы только что получили, это делается для того, чтобы убедиться, что пользователь еще не является частью нашей базы данных. Если он обнаружит, что пользователь уже находится в нашей базе данных, он вернет статус. USER_ALREADY_СУЩЕСТВУЕТ. В противном случае он добавит нового пользователя в нашу базу данных и вернет статус УСПЕШНОГО.
  • Пользователь входа(@Действительный пользователь @RequestBody): Как и раньше, эта функция получает объект пользователя, а затем сравнивает его с пользователями в нашей базе данных. Если он обнаружит, что этот пользователь находится в нашей базе данных, он установит для переменной LoggedIn значение true, чтобы указать, что наш пользователь только что вошел в систему. Если пользователь успешно вошел в систему, он возвращает статус УСПЕШНОГО входа. В случае сбоя он возвращает статус СБОЯ.
  • logUserOut(@Valid @RequestBody User пользователь): Эта функция аналогична LoginUser, за исключением того, что на этот раз мы установили для переменной LoggedIn пользователя значение false, чтобы указать, что пользователь в данный момент не вошел в систему. Если выход был успешным, мы возвращаем статус “УСПЕШНО”, в противном случае мы возвращаем статус “СБОЙ”.
  • @DeleteMapping(“/пользователи/все”): Это указывает Spring вызывать следующую функцию всякий раз, когда запрос на удаление был отправлен/пользователям/всем.
  • удалить все(): Эта функция просто удаляет всех пользователей из нашей базы данных. Это полезная функция, которую можно использовать во время тестирования.

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

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

curl -H "Content-Type: application/json" -X POST -d '{
    "username": "test",
    "password": "test"
}' http://localhost:8080/users/register

Эта команда отправляет запрос post в нашу программу с пакетом json. Пакет json содержит имя пользователя и пароль, возможно, вы заметили, что в нашем конструкторе пользовательских классов мы специально запросили имя пользователя и пароль. Мы специально отправляем этот Почтовый запрос по адресу http://localhost:8080/users/register. Наша программа работает на локальном хосте на порту 8080, и у нас есть сопоставление записей, прослушивающее, когда данные отправляются в “/пользователи/регистрация”. Если мы запустим это в нашем терминале (пока наше приложение работает в фоновом режиме), мы увидим что-то вроде этого:

Обратите внимание, что мы получили обратно строку с содержанием “УСПЕШНО”, что означает, что ваше приложение получило нового пользователя и добавило его в нашу базу данных. Что произойдет, когда мы снова запустим ту же команду?

На этот раз мы получили сообщение “USER_ALREADY_EXISTS”, поэтому наша программа позаботилась о том, чтобы не добавлять в нашу базу данных несколько пользователей одного и того же пользователя. Далее давайте посмотрим, сможем ли мы войти в систему нашего нового пользователя, вы можете запустить эту команду в своем терминале:

curl -H "Content-Type: application/json" -X POST -d '{
    "username": "test",
    "password": "test"
}' http://localhost:8080/users/login

Так же, как и раньше, он отправляет объект json с нашими учетными данными пользователя в “/users/login”, ту часть нашей программы, которая специально обрабатывает вход пользователя. Вот как это выглядит, когда мы выполняем команду:

Мы получаем ответное сообщение “УСПЕШНО”, так что теперь наш пользователь вошел в систему, но что бы произошло, если бы мы отправили неправильные учетные данные пользователя? Давайте проверим это, выполнив эту команду:

curl -H "Content-Type: application/json" -X POST -d '{
    "username": "hello",
    "password": "world"
}' http://localhost:8080/users/login

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

Как видно здесь, наша программа отправляет обратно сообщение “СБОЙ”, указывающее, что она смогла остановить незарегистрированного пользователя при входе в систему. Вот и все, вот и вся наша программа. Мы смогли создать систему регистрации и аутентификации пользователей с использованием Java и Spring. Если вы хотите навести порядок после себя, вы можете очистить базу данных с помощью этой команды:

curl -X DELETE http://localhost:8080/users/all

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

mysql -u root -p

а затем введите свой пароль. Теперь вы должны вернуться в свой терминал MySQL, и теперь, если вы хотите удалить базу данных “пользователи”, вы можете выполнить эту команду:

DROP DATABASE users;

И последнее, прежде чем мы закончим этот урок, вы можете посмотреть настройки своего API, если откроете вкладку браузера, а затем перейдете к: http://localhost:8080/api-docs. Это откроет некоторые JSON о вашем API.

Полный код для этого проекта можно найти в bitbucket .

Хорошего вам дня!

Оригинал: “https://www.codementor.io/@nilmadhab/a-simple-user-authentication-api-made-with-spring-boot-1cm8u94x56”

Читайте ещё по теме: