Java for Beginner

И ведь правда...🤪😂

https://t.me/Java_for_beginner_dev

#Mems

110 views10:29

Внедрение JWT-аутентификации в Spring Security

JWT (JSON Web Token) аутентификация — это популярный подход к обеспечению безопасности веб-приложений, особенно в REST API. Она позволяет передавать информацию о пользователе в токене и исключает необходимость поддерживать сессии на сервере.

1. Общий процесс JWT-аутентификации

Аутентификация пользователя: Клиент отправляет логин и пароль на сервер.
Генерация токена: После успешной аутентификации сервер создает JWT токен и возвращает его клиенту.
Доступ к защищенным ресурсам: Клиент отправляет токен в заголовке Authorization (Bearer <token>), чтобы получить доступ к ресурсам.
Проверка токена: Сервер проверяет токен при каждом запросе и предоставляет доступ только аутентифицированным пользователям.

2. Необходимые зависимости

Добавьте в pom.xml зависимости:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
    <scope>runtime</scope>
</dependency>

3. Шаги реализации JWT-аутентификации

3.1 Создание конфигурационного класса Spring Security
Создаем класс SecurityConfig для настройки Spring Security:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.configuration.AuthenticationConfiguration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    private final JwtAuthenticationFilter jwtAuthenticationFilter;

    public SecurityConfig(JwtAuthenticationFilter jwtAuthenticationFilter) {
        this.jwtAuthenticationFilter = jwtAuthenticationFilter;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            .and()
            .authorizeRequests()
            .antMatchers("/auth/login", "/auth/register").permitAll()
            .anyRequest().authenticated()
            .and()
            .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);

        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManager(AuthenticationConfiguration configuration) throws Exception {
        return configuration.getAuthenticationManager();
    }
}

#Java #Training #Spring #Security #JWT

103 views13:59

Java for Beginner

3.2 Создание модели пользователя
Создаем сущности User и Role для хранения пользователей и ролей в базе данных.

import javax.persistence.*;
import java.util.Set;

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String username;
    private String password;

    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(
        name = "user_roles",
        joinColumns = @JoinColumn(name = "user_id"),
        inverseJoinColumns = @JoinColumn(name = "role_id")
    )
    private Set<Role> roles;

    // Getters and Setters
}

@Entity
public class Role {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    // Getters and Setters
}

3.3 Создание сервиса для загрузки пользователя
Создаем сервис, который будет находить пользователя в базе данных и предоставлять его данные Spring Security.

import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class CustomUserDetailsService implements UserDetailsService {

    private final UserRepository userRepository;

    public CustomUserDetailsService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = userRepository.findByUsername(username)
            .orElseThrow(() -> new UsernameNotFoundException("User not found"));

        return org.springframework.security.core.userdetails.User.builder()
            .username(user.getUsername())
            .password(user.getPassword())
            .authorities(user.getRoles().stream().map(Role::getName).toArray(String[]::new))
            .build();
    }
}

3.4 Создание утилиты для работы с JWT
Создаем класс JwtUtils для генерации и проверки токенов.

import io.jsonwebtoken.*;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class JwtUtils {

    private final String jwtSecret = "your-secret-key";
    private final long jwtExpirationMs = 86400000; // 24 часа

    public String generateToken(String username) {
        return Jwts.builder()
            .setSubject(username)
            .setIssuedAt(new Date())
            .setExpiration(new Date(System.currentTimeMillis() + jwtExpirationMs))
            .signWith(SignatureAlgorithm.HS256, jwtSecret)
            .compact();
    }

    public String extractUsername(String token) {
        return Jwts.parser()
            .setSigningKey(jwtSecret)
            .parseClaimsJws(token)
            .getBody()
            .getSubject();
    }

    public boolean validateToken(String token) {
        try {
            Jwts.parser().setSigningKey(jwtSecret).parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            return false;
        }
    }
}

#Java #Training #Spring #Security #JWT

99 views13:59

Java for Beginner

3.5 Создание фильтра для проверки JWT
Фильтр проверяет JWT токен в каждом запросе.

import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final JwtUtils jwtUtils;
    private final CustomUserDetailsService userDetailsService;

    public JwtAuthenticationFilter(JwtUtils jwtUtils, CustomUserDetailsService userDetailsService) {
        this.jwtUtils = jwtUtils;
        this.userDetailsService = userDetailsService;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {

        String authHeader = request.getHeader("Authorization");
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String jwt = authHeader.substring(7);
            if (jwtUtils.validateToken(jwt)) {
                String username = jwtUtils.extractUsername(jwt);
                UserDetails userDetails = userDetailsService.loadUserByUsername(username);
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                        userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        filterChain.doFilter(request, response);
    }
}

3.6 Контроллер для аутентификации
Создаем контроллер для входа и регистрации пользователей.

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/auth")
public class AuthController {

    private final AuthenticationManager authenticationManager;
    private final JwtUtils jwtUtils;

    public AuthController(AuthenticationManager authenticationManager, JwtUtils jwtUtils) {
        this.authenticationManager = authenticationManager;
        this.jwtUtils = jwtUtils;
    }

    @PostMapping("/login")
    public String login(@RequestBody AuthRequest authRequest) {
        Authentication authentication = authenticationManager.authenticate(
            new UsernamePasswordAuthenticationToken(authRequest.getUsername(), authRequest.getPassword())
        );
        SecurityContextHolder.getContext().setAuthentication(authentication);
        return jwtUtils.generateToken(authRequest.getUsername());
    }
}

#Java #Training #Spring #Security #JWT

109 views13:59

Java for Beginner

Обработка исключений в Spring Security

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

1. Виды исключений в Spring Security

1.1 Исключения аутентификации
Эти исключения возникают, когда пользователь пытается пройти аутентификацию, но предоставленные данные неверны:
BadCredentialsException — неверный логин или пароль.
UsernameNotFoundException — пользователь не найден.
AccountExpiredException — учетная запись пользователя истекла.
DisabledException — учетная запись отключена.
LockedException — учетная запись заблокирована.
CredentialsExpiredException — срок действия учетных данных истек.

1.2 Исключения авторизации
Эти исключения связаны с попытками доступа к ресурсам без соответствующих прав:
AccessDeniedException — у пользователя недостаточно прав для доступа.
InsufficientAuthenticationException — аутентификация отсутствует или недостаточна.

1.3 Исключения токенов (в случае использования JWT)
JwtException — ошибки валидации JWT токена.
ExpiredJwtException — токен истек.
SignatureException — подпись токена неверна.

2. Как Spring Security обрабатывает исключения?

Spring Security предоставляет встроенные обработчики для исключений:
AuthenticationEntryPoint — используется для обработки ошибок аутентификации. Например, если пользователь не аутентифицирован, возвращается HTTP-статус 401 (Unauthorized).
AccessDeniedHandler — обрабатывает ошибки авторизации (HTTP-статус 403, Forbidden).

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

3. Настройка обработки исключений в Spring Security

3.1 Обработка ошибок аутентификации
Создаем собственный AuthenticationEntryPoint:

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
                         AuthenticationException authException) throws IOException {
        response.setContentType("application/json");
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.getWriter().write("{\"error\": \"Unauthorized\", \"message\": \"" + authException.getMessage() + "\"}");
    }
}
Этот обработчик возвращает 401 Unauthorized с описанием ошибки в формате JSON.

3.2 Обработка ошибок авторизации
Создаем собственный AccessDeniedHandler:

import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response,
                       AccessDeniedException accessDeniedException) throws IOException {
        response.setContentType("application/json");
        response.setStatus(HttpServletResponse.SC_FORBIDDEN);
        response.getWriter().write("{\"error\": \"Forbidden\", \"message\": \"" + accessDeniedException.getMessage() + "\"}");
    }
}
Этот обработчик возвращает 403 Forbidden с описанием причины отказа.

#Java #Training #Spring #Security #Security_Exceptions

90 views05:29

Java for Beginner

3.3 Подключение обработчиков в конфигурации Spring Security
Подключаем наши обработчики в конфигурационном классе:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

    private final CustomAuthenticationEntryPoint authenticationEntryPoint;
    private final CustomAccessDeniedHandler accessDeniedHandler;

    public SecurityConfig(CustomAuthenticationEntryPoint authenticationEntryPoint,
                          CustomAccessDeniedHandler accessDeniedHandler) {
        this.authenticationEntryPoint = authenticationEntryPoint;
        this.accessDeniedHandler = accessDeniedHandler;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .exceptionHandling()
            .authenticationEntryPoint(authenticationEntryPoint)
            .accessDeniedHandler(accessDeniedHandler);

        return http.build();
    }
}

4. Обработка исключений для JWT токенов

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

Пример обработки ошибок JWT

import io.jsonwebtoken.ExpiredJwtException;
import io.jsonwebtoken.SignatureException;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class JwtAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
                         AuthenticationException authException) throws IOException {
        String errorMessage = "Unauthorized access";
        
        Throwable cause = authException.getCause();
        if (cause instanceof ExpiredJwtException) {
            errorMessage = "JWT token expired";
        } else if (cause instanceof SignatureException) {
            errorMessage = "JWT signature invalid";
        }

        response.setContentType("application/json");
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.getWriter().write("{\"error\": \"" + errorMessage + "\"}");
    }
}
Подключите JwtAuthenticationEntryPoint вместо стандартного обработчика ошибок аутентификации.

5. Дополнительная обработка исключений

Spring Security позволяет также настроить:
Обработчики неудачной аутентификации: Используйте AuthenticationFailureHandler.
Обработчики успешной аутентификации: Используйте AuthenticationSuccessHandler.

Пример настройки AuthenticationFailureHandler:

import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class CustomAuthenticationFailureHandler implements AuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
                                        AuthenticationException exception) throws IOException {
        response.setContentType("application/json");
        response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        response.getWriter().write("{\"error\": \"Authentication failed\", \"message\": \"" + exception.getMessage() + "\"}");
    }
}

Добавьте его в цепочку фильтров:

http.formLogin()
    .failureHandler(customAuthenticationFailureHandler);

#Java #Training #Spring #Security #Security_Exceptions

89 views05:29

Java for Beginner

6. Глобальная обработка исключений

Для обработки всех исключений в приложении (не только Spring Security), можно использовать аннотацию @ControllerAdvice:

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(AccessDeniedException.class)
    public void handleAccessDeniedException(AccessDeniedException ex, HttpServletResponse response) throws IOException {
        response.setStatus(HttpStatus.FORBIDDEN.value());
        response.getWriter().write("{\"error\": \"Access Denied\", \"message\": \"" + ex.getMessage() + "\"}");
    }

    @ExceptionHandler(AuthenticationException.class)
    public void handleAuthenticationException(AuthenticationException ex, HttpServletResponse response) throws IOException {
        response.setStatus(HttpStatus.UNAUTHORIZED.value());
        response.getWriter().write("{\"error\": \"Authentication Failed\", \"message\": \"" + ex.getMessage() + "\"}");
    }
}

7. Тестирование обработки исключений

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

Пример теста с использованием MockMvc:

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.web.servlet.MockMvc;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class SecurityExceptionTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void accessDeniedShouldReturn403() throws Exception {
        mockMvc.perform(get("/protected-resource"))
            .andExpect(status().isForbidden());
    }
}

#Java #Training #Spring #Security #Security_Exceptions

109 views05:29

Java for Beginner

Что выведет код?

public class Task171224_1 {
    public static void main(String[] args) {
        Integer a = 1000; 
        Integer b = 1000;
        Integer c = 127; 
        Integer d = 127;

        System.out.println(a == b);
        System.out.println(c == d);
        System.out.println(a.equals(b));
        System.out.println(c.equals(d));
    }
}

#Tasks

115 views08:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

10%

false true false true

24%

false false true true

21 voters116 views08:48

Java for Beginner

🧐 заставляет задуматься

https://t.me/Java_for_beginner_dev

#Mems

112 views10:29

Java for Beginner

Настройка кастомных страниц ошибок в Spring Security

Spring Security позволяет заменить стандартные страницы ошибок на пользовательские. Это улучшает пользовательский опыт и делает интерфейс приложения более профессиональным.

1. Общие страницы ошибок Spring Security

По умолчанию Spring Security использует встроенные страницы ошибок:
401 Unauthorized: для неудачной аутентификации.
403 Forbidden: для попыток доступа без соответствующих прав.

Эти страницы достаточно просты и не подходят для продакшн-приложений. Их можно заменить на кастомные.

2. Подходы к настройке кастомных страниц ошибок

Использование обработчиков (handler):
Настройка обработчиков AuthenticationEntryPoint и AccessDeniedHandler для возврата кастомных страниц.

Глобальная обработка исключений:
Настройка глобального обработчика через @ControllerAdvice.

Перенаправление на HTML-страницы:
Использование механизма перенаправления на заранее подготовленные HTML-страницы.

3. Настройка кастомных страниц ошибок в Spring Security

3.1 Замена страницы для ошибки 403 (Forbidden)
Настраиваем кастомный AccessDeniedHandler:

import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.web.access.AccessDeniedHandler;
import org.springframework.stereotype.Component;

import javax.servlet.RequestDispatcher;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response,
                       AccessDeniedException accessDeniedException) throws IOException {
        // Перенаправление на кастомную страницу
        response.sendRedirect("/error/403");
    }
}

Добавляем обработчик в конфигурацию Spring Security:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

    private final CustomAccessDeniedHandler accessDeniedHandler;

    public SecurityConfig(CustomAccessDeniedHandler accessDeniedHandler) {
        this.accessDeniedHandler = accessDeniedHandler;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .anyRequest().authenticated()
            .and()
            .exceptionHandling()
            .accessDeniedHandler(accessDeniedHandler); // Подключение кастомного обработчика

        return http.build();
    }
}

Создаем контроллер для обработки ошибок:

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class ErrorController {

    @GetMapping("/error/403")
    public String error403() {
        return "error/403"; // Возвращаем HTML-страницу
    }
}

Добавляем страницу src/main/resources/templates/error/403.html (например, для Thymeleaf):

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Access Denied</title>
</head>
<body>
    <h1>403 - Access Denied</h1>
    <p>Sorry, you don't have permission to access this page.</p>
</body>
</html>

#Java #Training #Spring #Security #Security_Exceptions

105 views13:59

Java for Beginner

3.2 Замена страницы для ошибки 401 (Unauthorized)

Настраиваем кастомный AuthenticationEntryPoint:

import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.AuthenticationEntryPoint;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {

    @Override
    public void commence(HttpServletRequest request, HttpServletResponse response,
                         AuthenticationException authException) throws IOException {
        response.sendRedirect("/error/401");
    }
}

Добавляем обработчик в конфигурацию Spring Security:

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        .authorizeRequests()
        .anyRequest().authenticated()
        .and()
        .exceptionHandling()
        .authenticationEntryPoint(customAuthenticationEntryPoint); // Подключение кастомного обработчика

    return http.build();
}

Создаем контроллер для обработки ошибок:

@Controller
public class ErrorController {

    @GetMapping("/error/401")
    public String error401() {
        return "error/401"; // Возвращаем HTML-страницу
    }
}

Создаем страницу src/main/resources/templates/error/401.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Unauthorized</title>
</head>
<body>
    <h1>401 - Unauthorized</h1>
    <p>Please log in to access this page.</p>
</body>
</html>

4. Обработка всех ошибок через глобальный контроллер

Если нужно обрабатывать все исключения централизованно, можно использовать @ControllerAdvice:

import org.springframework.http.HttpStatus;
import org.springframework.security.access.AccessDeniedException;
import org.springframework.security.core.AuthenticationException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;

@ControllerAdvice
public class GlobalErrorController {

    @ExceptionHandler(AccessDeniedException.class)
    @ResponseStatus(HttpStatus.FORBIDDEN)
    public String handleAccessDeniedException() {
        return "error/403";
    }

    @ExceptionHandler(AuthenticationException.class)
    @ResponseStatus(HttpStatus.UNAUTHORIZED)
    public String handleAuthenticationException() {
        return "error/401";
    }
}

#Java #Training #Spring #Security #Security_Exceptions

95 views13:59

Java for Beginner

5. Использование встроенного механизма Spring Boot для ошибок

Spring Boot предоставляет удобный способ настройки кастомных страниц через файл application.properties:

server.error.whitelabel.enabled=false
server.error.path=/error

Затем создаем контроллер для обработки пути /error:

@Controller
public class CustomErrorController {

    @GetMapping("/error")
    public String handleError() {
        return "error/custom";
    }
}

Добавляем страницу src/main/resources/templates/error/custom.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Error</title>
</head>
<body>
    <h1>An error occurred</h1>
    <p>We are sorry, something went wrong.</p>
</body>
</html>

6. Обработка JSON-ответов для API

Для REST API ошибки обычно возвращаются в формате JSON. Пример глобального обработчика для API:

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class ApiErrorController {

    @ExceptionHandler(AccessDeniedException.class)
    public ResponseEntity<?> handleAccessDeniedException(AccessDeniedException ex) {
        return ResponseEntity.status(HttpStatus.FORBIDDEN).body(Map.of(
            "error", "Forbidden",
            "message", ex.getMessage()
        ));
    }
@ExceptionHandler(AuthenticationException.class)
    public ResponseEntity<?> handleAuthenticationException(AuthenticationException ex) {
        return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(Map.of(
            "error", "Unauthorized",
            "message", ex.getMessage()
        ));
    }
}

#Java #Training #Spring #Security #Security_Exceptions

114 views13:59

Java for Beginner

REST и его архитектура

REST (Representational State Transfer) — это архитектурный стиль взаимодействия компонентов в распределенных системах, наиболее часто используемый для построения веб-сервисов. REST был предложен Роем Филдингом в его докторской диссертации в 2000 году.

REST основывается на простых принципах, обеспечивающих масштабируемость, производительность и простоту использования.

Принципы REST

Клиент-серверная архитектура
Разделение ответственности между клиентом (пользовательский интерфейс) и сервером (хранение данных и логика обработки). Это упрощает масштабирование и развитие каждого компонента.

Отсутствие состояния (Stateless)
Каждое взаимодействие между клиентом и сервером является независимым. Сервер не хранит информацию о состоянии клиента между запросами. Это упрощает обработку запросов и масштабирование.

Единый интерфейс (Uniform Interface)
REST-сервисы используют единообразные соглашения для взаимодействия. Это включает использование стандартных HTTP-методов и определенную структуру URL.

Кэшируемость (Cacheable)
Ответы сервера могут быть кэшируемыми, что улучшает производительность и снижает нагрузку на сервер.

Многоуровневая система (Layered System)
Компоненты системы могут быть разделены на уровни, например, клиент, балансировщик нагрузки, сервер приложений, сервер базы данных.

Код по требованию (Code on Demand)
(Необязательный принцип). Сервер может отправлять исполняемый код клиенту, чтобы расширить функциональность клиента.

Основные элементы REST

Ресурсы
В REST ресурс — это объект или информация, доступ к которым можно получить через URL.
Например, пользовательская информация может быть представлена как /users.

HTTP-методы REST-сервисы используют стандартные HTTP-методы для выполнения операций:
GET: Получение данных (например, список пользователей).
POST: Создание нового ресурса.
PUT: Полное обновление ресурса.
PATCH: Частичное обновление ресурса.
DELETE: Удаление ресурса.

Статусы HTTP-ответов

REST использует стандартные коды статуса HTTP для указания результата операции:
200 OK — Успешная операция.
201 Created — Ресурс создан.
204 No Content — Успешно, но без контента.
400 Bad Request — Неверный запрос.
401 Unauthorized — Необходима авторизация.
403 Forbidden — Нет прав доступа.
404 Not Found — Ресурс не найден.
500 Internal Server Error — Ошибка на сервере.

Репрезентация ресурсов
Ресурсы могут быть представлены в разных форматах: JSON, XML, HTML, текст.
Наиболее часто используется JSON, так как он легковесный и легко читаемый.

URI (Уникальный идентификатор ресурса)
Каждый ресурс имеет уникальный URI. Например:
/users — Список всех пользователей.
/users/1 — Информация о пользователе с ID 1.

Преимущества REST

Простота
REST базируется на стандартных и широко известных HTTP-методах.

Масштабируемость
Из-за отсутствия состояния и кэшируемости REST-сервисы легко масштабируются.

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

Независимость клиента и сервера
Обе стороны могут развиваться независимо друг от друга.

RESTful API в Spring Framework
Spring предоставляет мощные средства для разработки RESTful сервисов через модуль Spring Web. Основные элементы включают:

1. Контроллеры REST
Контроллеры в Spring создаются с помощью аннотации @RestController. Пример простого REST-контроллера:

import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.ArrayList;

@RestController
@RequestMapping("/users")
public class UserController {

    private List<String> users = new ArrayList<>(List.of("Alice", "Bob", "Charlie"));

    @GetMapping
    public List<String> getAllUsers() {
        return users;
    }

    @GetMapping("/{id}")
    public String getUserById(@PathVariable int id) {
        return users.get(id);
    }

    @PostMapping
    public void createUser(@RequestBody String user) {
        users.add(user);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable int id) {
        users.remove(id);
    }
}

#Java #Training #Spring #REST

103 views05:29

Java for Beginner

2. Обработка ошибок
Spring позволяет обрабатывать исключения централизованно. Например, если пользователь не найден, можно вернуть 404 Not Found:

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(IndexOutOfBoundsException.class)
    @ResponseStatus(HttpStatus.NOT_FOUND)
    public String handleIndexOutOfBounds(IndexOutOfBoundsException ex) {
        return "User not found";
    }
}

3. Использование DTO
Для передачи данных рекомендуется использовать объекты DTO (Data Transfer Objects):

public class UserDTO {
    private String name;
    private int age;

    // Getters и Setters
}

Контроллер:

@PostMapping
public void createUser(@RequestBody UserDTO user) {
    System.out.println("User created: " + user.getName());
}

4. Валидация
Spring поддерживает валидацию входных данных с помощью аннотации @Valid:

import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.Min;

public class UserDTO {
    @NotEmpty(message = "Name cannot be empty")
    private String name;

    @Min(value = 18, message = "Age must be at least 18")
    private int age;

    // Getters и Setters
}

Контроллер:

@PostMapping
public void createUser(@Valid @RequestBody UserDTO user) {
    // Логика создания
}

#Java #Training #Spring #REST

105 views05:29

Java for Beginner

Что выведет код?

import java.io.*;

class Person1812 implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private transient int age;

    public Person1812(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + "}";
    }
}

public class Task181224_1 {
    public static void main(String[] args) {
        Person1812 person = new Person1812("Alice", 30);

        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.ser"));
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.ser"))) {

            oos.writeObject(person);
            Person1812 deserializedPerson = (Person1812) ois.readObject();

            System.out.println(deserializedPerson);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

#Tasks

131 views08:44

Java for Beginner

Варианты ответа:

Anonymous Quiz

31%

Person{name='Alice', age=30}

46%

Person{name='Alice', age=0}

15%

Ошибка компиляции

Исключение времени выполнения

13 voters110 views08:48

Java for Beginner

Чистая правда!😜

https://t.me/Java_for_beginner_dev

#Mems

133 views10:29

Java for Beginner

Принципы построения RESTful API

RESTful API (Representational State Transfer API) следует архитектурным принципам REST, которые обеспечивают масштабируемость, простоту, производительность и легкость использования. Соблюдение этих принципов помогает создавать API, которые легко понимаются, поддерживаются и используются разработчиками.

Основные принципы построения RESTful API

1. Идентификация ресурсов

В REST каждый ресурс должен быть уникально идентифицирован с помощью URI (Uniform Resource Identifier).
Ресурсы представляют данные (например, пользователей, заказы, товары).

Используйте понятные и предсказуемые URI:
GET /users — получить список всех пользователей.
GET /users/1 — получить данные пользователя с ID = 1.
POST /users — создать нового пользователя.
DELETE /users/1 — удалить пользователя с ID = 1.

Советы:
Используйте имена существительные вместо глаголов в URI (например, /products, а не /getProducts).
Следуйте единообразию в структуре URI.

2. Использование стандартных HTTP-методов

RESTful API основывается на семантике HTTP-методов:
GET — получение ресурса или коллекции.
POST — создание нового ресурса.
PUT — обновление существующего ресурса (полное).
PATCH — частичное обновление ресурса.
DELETE — удаление ресурса.

Пример:
GET /orders — получить все заказы.
POST /orders — создать новый заказ.
PUT /orders/123 — обновить заказ с ID = 123.
DELETE /orders/123 — удалить заказ с ID = 123.

3. Использование кодов состояния HTTP

RESTful API должен возвращать коды состояния HTTP для обозначения результата запроса:
200 OK — успешный запрос.
201 Created — ресурс создан.
204 No Content — запрос выполнен, но тело ответа пустое (например, при удалении).
400 Bad Request — ошибка в запросе клиента.
401 Unauthorized — требуется авторизация.
403 Forbidden — доступ запрещен.
404 Not Found — ресурс не найден.
500 Internal Server Error — ошибка на стороне сервера.

4. Поддержка разных форматов данных

RESTful API должен поддерживать универсальные форматы данных:
JSON — наиболее популярный формат, легковесный и легко читаемый.
XML — используется в некоторых корпоративных системах.
Plain Text — для простых данных.

Клиенты могут указывать желаемый формат данных через заголовок Accept:
Accept: application/json
Accept: application/xml
API должен возвращать данные в соответствии с этим заголовком.

5. Единообразный интерфейс

RESTful API должен иметь предсказуемую и интуитивно понятную структуру.
В URI не следует указывать действия (/getUser, /deleteUser), так как действия задаются через HTTP-методы.

6. Безопасность и отсутствие состояния (Statelessness)

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

Пример заголовка для авторизации:

Authorization: Bearer <JWT_TOKEN>

7. Кэшируемость

Ответы API должны быть кэшируемыми, если это возможно.

Используйте заголовки HTTP для управления кэшированием:
Cache-Control: max-age=3600 — ответ кэшируется на 1 час.
ETag — уникальный идентификатор ресурса, помогает определить, изменился ли ресурс.
Кэширование ускоряет доступ к данным и снижает нагрузку на сервер.

#Java #Training #Spring #REST #RESTful_API

114 views13:59

Java for Beginner

8. HATEOAS (Hypermedia as the Engine of Application State)

В RESTful API ссылки (hyperlinks) должны быть частью ответа, чтобы клиент мог легко перемещаться между связанными ресурсами.

Пример ответа с HATEOAS:

{
  "id": 1,
  "name": "John Doe",
  "links": [
    { "rel": "self", "href": "/users/1" },
    { "rel": "orders", "href": "/users/1/orders" }
  ]
}

Хотя HATEOAS улучшает гибкость, он реже используется в реальных API.

9. Иерархическая структура ресурсов

Ресурсы с отношениями (например, пользователь и его заказы) должны отражаться в URI.

Пример:
GET /users/1/orders — получить заказы пользователя с ID = 1.
GET /users/1/orders/2 — получить конкретный заказ пользователя.

10. Пагинация, фильтрация и сортировка

При работе с большими объемами данных API должен поддерживать:

Пагинацию:
Параметры: ?page=1&size=20.
Заголовки: X-Total-Count (общее количество ресурсов).

Фильтрацию:
Параметры: ?status=active.

Сортировку:
Параметры: ?sort=name,asc.
Пример ответа для пагинации:

{
  "data": [
    { "id": 1, "name": "Alice" },
    { "id": 2, "name": "Bob" }
  ],
  "page": 1,
  "size": 2,
  "total": 100
}

11. Версионирование API

Версионирование помогает избежать проблем при изменении API.

Подходы к версионированию:
В URI: /v1/users, /v2/users.
В заголовках: Accept: application/vnd.example.v1+json.

12. Обработка ошибок

RESTful API должен предоставлять информативные и структурированные сообщения об ошибках.

Пример ошибки:

{
  "timestamp": "2024-12-11T12:34:56Z",
  "status": 400,
  "error": "Bad Request",
  "message": "Invalid email format",
  "path": "/users"
}

13. Документация

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

#Java #Training #Spring #REST #RESTful_API

107 views13:59

Java for Beginner

Форматы данных: JSON и XML

JSON (JavaScript Object Notation) и XML (eXtensible Markup Language) — это два популярных формата для обмена данными между клиентом и сервером. В рамках Spring оба формата поддерживаются для сериализации и десериализации данных, что делает их основными выбором для RESTful API и других интеграций.

JSON (JavaScript Object Notation)

JSON — это легковесный текстовый формат для обмена данными, основанный на синтаксисе JavaScript. Он разработан для передачи структурированных данных в человекочитаемой форме.

Пример JSON:

{
  "id": 1,
  "name": "John Doe",
  "age": 30,
  "isActive": true,
  "roles": ["admin", "user"],
  "address": {
    "street": "123 Main St",
    "city": "Springfield"
  }
}

Преимущества JSON

Простота и читаемость:
JSON компактен и легко читается человеком.

Широкая поддержка:
JSON поддерживается большинством языков программирования.

Легковесность:
JSON менее объемный, чем XML, что снижает нагрузку на сеть.

Совместимость:
Он может быть легко интегрирован в JavaScript и другие языки.

Ограничения JSON

Ограниченный синтаксис:
Нет встроенной поддержки атрибутов, как в XML.

Менее строгий стандарт:
Возможны несовместимости при использовании сложных структур.

XML (eXtensible Markup Language)

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

Пример XML:

<user>
  <id>1</id>
  <name>John Doe</name>
  <age>30</age>
  <isActive>true</isActive>
  <roles>
    <role>admin</role>
    <role>user</role>
  </roles>
  <address>
    <street>123 Main St</street>
    <city>Springfield</city>
  </address>
</user>

Преимущества XML

Гибкость:
XML позволяет использовать как элементы, так и атрибуты для представления данных.

Самоописываемость:
Схемы XML (DTD, XSD) помогают проверять структуру и формат данных.

Поддержка сложных структур:
XML идеально подходит для иерархических данных.

Поддержка метаданных:
Атрибуты позволяют добавлять дополнительную информацию к элементам.

Ограничения XML

Больший размер:
XML более громоздкий по сравнению с JSON.

Сложность обработки:
XML требует большего количества ресурсов для парсинга.

Менее читаемый:
Из-за объема разметки XML менее удобен для восприятия человеком.

Поддержка JSON и XML в Spring

Spring поддерживает оба формата через модули Jackson (для JSON) и JAXB или другие парсеры (для XML).

Для работы с JSON используется библиотека Jackson. Она автоматически преобразует объекты Java в JSON и обратно.

Пример сериализации объекта в JSON:

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public User getUser(@PathVariable int id) {
        return new User(1, "John Doe", 30, true);
    }
}

Ответ:

{
  "id": 1,
  "name": "John Doe",
  "age": 30,
  "isActive": true
}

XML в Spring

Для работы с XML можно использовать библиотеку JAXB (Java Architecture for XML Binding) или другие парсеры.

Пример работы с XML:

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping(value = "/{id}", produces = MediaType.APPLICATION_XML_VALUE)
    public User getUser(@PathVariable int id) {
        return new User(1, "John Doe", 30, true);
    }
}

Ответ:

<user>
  <id>1</id>
  <name>John Doe</name>
  <age>30</age>
  <isActive>true</isActive>
</user>

#Java #Training #Spring #Json #Xml

115 views05:29

About

Blog

Apps

Platform