import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.*;
​
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.util.Date;
​
@SpringBootApplication
@RestController
public class AuthApplication {
​
    private final String SECRET_KEY = "secretkey123"; // Ключ шифрования JWT
​
    public static void main(String[] args) {
        SpringApplication.run(AuthApplication.class, args);
    }
​
    @GetMapping("/setCookie")
    public String setCookie(HttpServletResponse response) {
        Cookie cookie = new Cookie("user", "john_doe");
        cookie.setMaxAge(3600); // 设置Cookieизжизненный цикл 1 час
        response.addCookie(cookie);
        return «Настройка файлов cookie прошла успешно!»;
    }
​
    @GetMapping("/setSession")
    public String setSession(HttpServletRequest request) {
        HttpSession session = request.getSession();
        session.setAttribute("user", "john_doe");
        return "Сессия успешно установлена!";
    }
​
    @GetMapping("/getCookie")
    public String getCookie(HttpServletRequest request) {
        Cookie[] cookies = request.getCookies();
        if (cookies != null) {
            for (Cookie cookie : cookies) {
                if (cookie.getName().equals("user")) {
                    return «Получить информацию о пользователе из файлов cookie:» + cookie.getValue();
                }
            }
        }
        return «Куки не найден!»;
    }
​
    @GetMapping("/getSession")
    public String getSession(HttpServletRequest request) {
        HttpSession session = request.getSession();
        String user = (String) session.getAttribute("user");
        if (user != null) {
            return «Получить информацию о пользователе из сеанса:» + user;
        }
        return «Сессия не найдена!»;
    }
​
    @PostMapping("/login")
    public String login(@RequestBody UserCredentials credentials) {
        // В практических приложениях пользователи должны проходить аутентификацию здесь, например, проверять совпадение имени пользователя и пароля в базе данных.
        if (credentials.getUsername().equals("john_doe") && credentials.getPassword().equals("password123")) {
            // Создать токен
            String token = Jwts.builder()
                    .setSubject(credentials.getUsername())
                    .setIssuedAt(new Date())
                    .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // Установите срок действия токена на 1 час.
                    .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                    .compact();
            return «Вход успешен! Сгенерирован токен:» + token;
        } else {
            return «Неверное имя пользователя или пароль!»;
        }
    }
​
    @GetMapping("/secure")
    public String secure(HttpServletRequest request) {
        // В практических приложениях валидность токена должна быть проверена здесь.
        String token = request.getHeader("Authorization").replace("Bearer ", "");
        String user = Jwts.parser().setSigningKey(SECRET_KEY).parseClaimsJws(token).getBody().getSubject();
        return «Доступ к защищенной конечной точке успешен, пользователь:» + user;
    }
​
    static class UserCredentials {
        private String username;
        private String password;
​
        // Getters and setters
        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;
        }
    }
}
​

<dependencies>
    <!-- Spring Security -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <!-- JSON Web Token Support -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt</artifactId>
        <version>0.9.1</version>
    </dependency>
</dependencies>

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.stereotype.Component;
​
import java.util.Date;
import java.util.function.Function;
​
@Component
public class JwtUtils {
    private String secret = "yourSecretKey"; // твой ключ
​
    public String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date(System.currentTimeMillis()))
                .setExpiration(new Date(System.currentTimeMillis() + 3600000)) // Срок действия истекает через 1 час
                .signWith(SignatureAlgorithm.HS256, secret)
                .compact();
    }
​
    public Boolean validateToken(String token, String username) {
        final String usernameFromToken = getUsernameFromToken(token);
        return (usernameFromToken.equals(username) && !isTokenExpired(token));
    }
​
    public String getUsernameFromToken(String token) {
        return getClaimFromToken(token, Claims::getSubject);
    }
​
    public Date getExpirationDateFromToken(String token) {
        return getClaimFromToken(token, Claims::getExpiration);
    }
​
    public <T> T getClaimFromToken(String token, Function<Claims, T> claimsResolver) {
        final Claims claims = getAllClaimsFromToken(token);
        return claimsResolver.apply(claims);
    }
​
    private Claims getAllClaimsFromToken(String token) {
        return Jwts.parser().setSigningKey(secret).parseClaimsJws(token).getBody();
    }
​
    private Boolean isTokenExpired(String token) {
        final Date expiration = getExpirationDateFromToken(token);
        return expiration.before(new Date());
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.core.userdetails.User;
import org.springframework.web.bind.annotation.*;
​
@RestController
@RequestMapping("/auth")
public class AuthController {
​
    @Autowired
    private AuthenticationManager authenticationManager;
​
    @Autowired
    private JwtUtils jwtUtils;
​
    @PostMapping("/signin")
    public String signin(@RequestBody User user) throws AuthenticationException {
        authenticationManager.authenticate(
                new UsernamePasswordAuthenticationToken(user.getUsername(), user.getPassword())
        );
        return jwtUtils.generateToken(user.getUsername());
    }
​
    @GetMapping("/info")
    public String info(@RequestParam String token) {
        if (jwtUtils.validateToken(token, "user")) {
            return "Token is valid!";
        } else {
            return "Token is not valid!";
        }
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
​
@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
​
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .antMatchers("/auth/**").permitAll()
            .anyRequest().authenticated()
            .and()
            .httpBasic(); // Используйте базовую аутентификацию
    }
​
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("user")
            .password("password")
            .roles("USER");
    }
}

server.port=8443
server.ssl.key-store=classpath:keystore.jks
server.ssl.key-store-password=yourpassword
server.ssl.key-password=yourkeypassword

@PostMapping("/some-protected-action")
@csrfProtection
public String someProtectedAction(@ModelAttribute SomeData data, @RequestParam("csrfToken") String csrfToken) {
    // твоя бизнес-логика
}