Spring Security

Su Suriya Ravichandran Updated 18 Nov 2026
11 min read ·Lesson 281 of 306

Spring Security is the standard library for authentication (who are you?) and authorization (what are you allowed to do?) in Spring applications. You add one starter, declare which URLs need which roles, and Spring Security checks every request before it reaches your controller. It also stores passwords safely, protects forms against CSRF attacks and lets you secure individual service methods.

This lesson uses Spring Boot 4.1 with Spring Security 7, building on the Spring Boot tutorial. All examples are tested with curl against http://localhost:8080.


How Spring Security Works

Spring Security is a chain of servlet filters that runs before the DispatcherServlet. Each filter does one job, such as reading a username and password or checking a role.

PieceJob
SecurityFilterChainThe list of rules and filters applied to matching requests
UserDetailsServiceLoads a user (username, password hash, roles) by username
PasswordEncoderHashes new passwords and checks login attempts against the hash
AuthenticationThe logged-in user for the current request
SecurityContextHolderHolds the Authentication while the request runs
Request -> [Security filters: authenticate -> authorize] -> DispatcherServlet -> @RestController
                     |
                     +-> 401 Unauthorized (not logged in) or 403 Forbidden (wrong role)

How it works:

  • A request that fails a check never reaches your controller, so your business code stays free of security if statements.
  • 401 means "we don't know who you are". 403 means "we know who you are, but you may not do this".

Add Spring Security to a Spring Boot App

Add the security starter next to the web starter:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webmvc</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
</dependencies>

Create a small controller to protect:

package com.gocourse.secure;

import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api")
public class HelloController {

    @GetMapping("/public/hello")
    public String hello() {
        return "Hello, guest!";
    }

    @GetMapping("/me")
    public String me(@AuthenticationPrincipal UserDetails user) {
        return "Hello, " + user.getUsername() + " " + user.getAuthorities();
    }

    @GetMapping("/admin/stats")
    public String stats() {
        return "Total students: 1250";
    }
}

Start the application without any security configuration. The log shows a generated password:

Using generated security password: 6b1f0c2e-8d4a-4c3e-9a51-2f7d3e9b8c10

This generated password is for development use only. Your security configuration must be updated before running your application in production.
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8080/api/public/hello
401

How it works:

  • With the starter on the classpath, Spring Boot secures every URL by default. Even the "public" endpoint returns 401.
  • Boot creates one user named user with a random password printed at startup. You could call curl -u user:<password> ..., but this default exists only so nothing is left open by accident.
  • Your real setup always replaces it with a SecurityFilterChain and your own users, as shown next.

Configure a SecurityFilterChain

A SecurityFilterChain bean tells Spring Security which requests are public, which need a login and which need a role. Spring Security 7 only supports the lambda DSL, where each part is configured inside its own lambda.

package com.gocourse.secure;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

    @Bean
    SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/api/public/**", "/error").permitAll()
                .requestMatchers("/api/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated())
            .httpBasic(Customizer.withDefaults());
        return http.build();
    }

    @Bean
    PasswordEncoder passwordEncoder() {
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }

    @Bean
    UserDetailsService users(PasswordEncoder encoder) {
        UserDetails asha = User.withUsername("asha")
                .password(encoder.encode("asha-pass"))
                .roles("STUDENT")
                .build();
        UserDetails ravi = User.withUsername("ravi")
                .password(encoder.encode("ravi-pass"))
                .roles("STUDENT", "ADMIN")
                .build();
        return new InMemoryUserDetailsManager(asha, ravi);
    }
}
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8080/api/public/hello
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8080/api/me
curl -s -u asha:asha-pass http://localhost:8080/api/me; echo
curl -s -o /dev/null -w "%{http_code}\n" -u asha:wrong http://localhost:8080/api/me
curl -s -o /dev/null -w "%{http_code}\n" -u asha:asha-pass http://localhost:8080/api/admin/stats
curl -s -u ravi:ravi-pass http://localhost:8080/api/admin/stats; echo
200
401
Hello, asha [ROLE_STUDENT]
401
403
Total students: 1250

How it works:

  • Rules are checked top to bottom, and the first match wins. Put specific paths first and finish with anyRequest().
  • httpBasic reads the Authorization: Basic ... header that curl -u sends. Asha has no ADMIN role, so she gets 403 on /api/admin/stats; Ravi gets the data.
  • roles("STUDENT") is stored as the authority ROLE_STUDENT. hasRole("ADMIN") adds the ROLE_ prefix for you.
  • /error is public so that error responses (401, 403, 404) are not blocked by the security rules themselves.

Authorization Rules Reference

RuleAllows
permitAll()Everyone, logged in or not
authenticated()Any logged-in user
hasRole("ADMIN")Users with authority ROLE_ADMIN
hasAnyRole("ADMIN", "TEACHER")Users with at least one of the roles
hasAuthority("course:write")Users with that exact authority string
denyAll()Nobody

You can also limit a rule to one HTTP method, for example .requestMatchers(HttpMethod.GET, "/api/courses/**").permitAll() lets anyone read courses while other methods still need a login.


Store Passwords With a PasswordEncoder

Never store plain passwords. A PasswordEncoder turns a password into a salted, slow hash and later checks login attempts against it, as explained in Java password hashing.

@Bean
CommandLineRunner encoderDemo(PasswordEncoder encoder) {
    return args -> {
        String stored = encoder.encode("asha-pass");
        System.out.println("Stored value: " + stored);
        System.out.println("Correct password? " + encoder.matches("asha-pass", stored));
        System.out.println("Wrong password?   " + encoder.matches("asha-pas", stored));
        System.out.println("Same hash twice?  " + stored.equals(encoder.encode("asha-pass")));
    };
}
Stored value: {bcrypt}$2a$10$Yq0yK7c3mN9yH2bqvQe8me0b1lH3cQm4uJ1x7gq6r2kq8yYbqv5aW
Correct password? true
Wrong password?   false
Same hash twice?  false

How it works:

  • The delegating encoder writes the algorithm id in braces before the hash. Later you can switch to a stronger default and old hashes still verify, because each one names its own algorithm.
  • Every call to encode uses a new random salt, so the same password never produces the same stored value. That is why you compare with matches, never with equals.
  • Your hash will differ from the one shown; only the {bcrypt} prefix and the true/false/false lines stay the same.

Read the Logged-In User in a Controller

Controllers can receive the current user directly as a parameter.

@GetMapping("/api/profile")
public Map<String, Object> profile(@AuthenticationPrincipal UserDetails user, Authentication authentication) {
    boolean isAdmin = user.getAuthorities().stream()
            .anyMatch(authority -> authority.getAuthority().equals("ROLE_ADMIN"));
    return Map.of(
            "username", authentication.getName(),
            "admin", isAdmin);
}
curl -s -u ravi:ravi-pass http://localhost:8080/api/profile; echo
{"admin":true,"username":"ravi"}

How it works:

  • @AuthenticationPrincipal injects the UserDetails object that the UserDetailsService loaded. Authentication gives the same user in a more general form, with getName() returning the username.
  • Outside a controller you can call SecurityContextHolder.getContext().getAuthentication() to reach the same object.
  • The key order in the printed JSON may differ, because Map.of has no fixed order.

Form Login and Logout for Web Pages

Browser apps built with Spring MVC usually use a login form and a session cookie instead of HTTP Basic.

@Bean
SecurityFilterChain webSecurity(HttpSecurity http) throws Exception {
    http
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/", "/courses/**", "/css/**", "/error").permitAll()
            .requestMatchers("/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated())
        .formLogin(form -> form
            .defaultSuccessUrl("/dashboard", true))  // where to go after login
        .logout(logout -> logout
            .logoutSuccessUrl("/"));                 // where to go after logout
    return http.build();
}
curl -s -o /dev/null -w "%{http_code} %{redirect_url}\n" http://localhost:8080/dashboard
302 http://localhost:8080/login

How it works:

  • An anonymous browser request to a protected page is redirected to /login. Spring Security generates a simple login page there until you provide your own template.
  • After a successful login the user ID is kept in the HTTP session, so the browser sends only the session cookie on later requests.
  • CSRF protection stays on for form-based apps. Spring adds a hidden _csrf token to forms rendered with Thymeleaf, and POST, PUT and DELETE requests without a valid token get 403.

Method Security With @PreAuthorize

URL rules protect endpoints. Method security protects service methods, so the rule holds no matter which controller calls them.

package com.gocourse.secure;

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableMethodSecurity;

@Configuration
@EnableMethodSecurity
public class MethodSecurityConfig {
}
package com.gocourse.secure;

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;

@Service
public class ReportService {

    @PreAuthorize("hasRole('ADMIN')")
    public String revenueReport() {
        return "Revenue this month: INR 4,82,000";
    }

    // a student may read only their own progress; admins may read anyone's
    @PreAuthorize("#username == authentication.name or hasRole('ADMIN')")
    public String progressOf(String username) {
        return username + " has finished 12 of 20 lessons";
    }
}
@RestController
@RequestMapping("/api")
public class ReportController {

    private final ReportService reports;

    public ReportController(ReportService reports) {
        this.reports = reports;
    }

    @GetMapping("/reports/revenue")
    public String revenue() {
        return reports.revenueReport();
    }

    @GetMapping("/progress/{username}")
    public String progress(@PathVariable String username) {
        return reports.progressOf(username);
    }
}
curl -s -o /dev/null -w "%{http_code}\n" -u asha:asha-pass http://localhost:8080/api/reports/revenue
curl -s -u asha:asha-pass http://localhost:8080/api/progress/asha; echo
curl -s -o /dev/null -w "%{http_code}\n" -u asha:asha-pass http://localhost:8080/api/progress/ravi
curl -s -u ravi:ravi-pass http://localhost:8080/api/progress/asha; echo
403
asha has finished 12 of 20 lessons
403
asha has finished 12 of 20 lessons

How it works:

  • @EnableMethodSecurity wraps beans that use @PreAuthorize in a proxy. The expression is checked before the method runs; if it is false, an AccessDeniedException becomes a 403 response.
  • #username refers to the method parameter and authentication.name to the logged-in user, so the rule compares them.

Note: #username works because Spring Boot's Maven and Gradle setup compiles with the -parameters flag, which keeps parameter names in the class file.


Secure a Stateless REST API: CSRF and Sessions

A REST API called by mobile apps or scripts sends credentials (or a token) with every request and has no login form. For such an API you turn off sessions and CSRF.

@Bean
SecurityFilterChain apiSecurity(HttpSecurity http) throws Exception {
    http
        .csrf(csrf -> csrf.disable())
        .sessionManagement(session -> session
            .sessionCreationPolicy(SessionCreationPolicy.STATELESS))
        .authorizeHttpRequests(auth -> auth
            .requestMatchers(HttpMethod.POST, "/api/register").permitAll()
            .requestMatchers("/api/public/**", "/error").permitAll()
            .requestMatchers("/api/admin/**").hasRole("ADMIN")
            .anyRequest().authenticated())
        .httpBasic(Customizer.withDefaults());
    return http.build();
}
SettingBrowser app with login formStateless REST API
LoginformLoginhttpBasic or a bearer token
SessionCreated after loginSTATELESS, none
CSRFEnabledDisabled

How it works:

  • CSRF attacks trick a browser into sending its cookie to your site. A stateless API does not use cookies for login, so the attack has nothing to steal and the protection can be turned off.
  • STATELESS stops Spring Security from creating an HttpSession, so every request is authenticated on its own.

Note: Keep CSRF enabled whenever authentication travels in a cookie. Disabling it in a session-based web app opens a real security hole.


Real-World Example: Spring Security With Database Users

Real applications keep users in a database. This example stores them with Spring Data JPA, lets students register, blocks disabled accounts and gives admins a user list. It uses the stateless apiSecurity chain above (as the only SecurityFilterChain), the PasswordEncoder bean, and H2 as in the previous lesson.

package com.gocourse.secure.user;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class AppUser {

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

    @Column(nullable = false, unique = true, length = 40)
    private String username;

    @Column(nullable = false)
    private String password; // always a hash, never plain text

    @Column(nullable = false)
    private String role;     // STUDENT or ADMIN

    private boolean enabled = true;

    protected AppUser() {}

    public AppUser(String username, String passwordHash, String role, boolean enabled) {
        this.username = username;
        this.password = passwordHash;
        this.role = role;
        this.enabled = enabled;
    }

    public String getUsername() { return username; }
    public String getPassword() { return password; }
    public String getRole() { return role; }
    public boolean isEnabled() { return enabled; }
}
package com.gocourse.secure.user;

import java.util.Optional;
import org.springframework.data.jpa.repository.JpaRepository;

public interface AppUserRepository extends JpaRepository<AppUser, Long> {

    Optional<AppUser> findByUsername(String username);

    boolean existsByUsername(String username);
}
package com.gocourse.secure.user;

import org.springframework.boot.CommandLineRunner;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class UserConfig {

    // Spring Security calls this on every login attempt
    @Bean
    UserDetailsService userDetailsService(AppUserRepository users) {
        return username -> users.findByUsername(username)
                .map(user -> User.withUsername(user.getUsername())
                        .password(user.getPassword())
                        .roles(user.getRole())
                        .disabled(!user.isEnabled())
                        .build())
                .orElseThrow(() -> new UsernameNotFoundException("No user " + username));
    }

    @Bean
    CommandLineRunner seedUsers(AppUserRepository users, PasswordEncoder encoder) {
        return args -> {
            users.save(new AppUser("ravi", encoder.encode("ravi-pass"), "ADMIN", true));
            users.save(new AppUser("old", encoder.encode("old-pass"), "STUDENT", false));
        };
    }
}
package com.gocourse.secure.user;

import java.util.List;
import org.springframework.data.domain.Sort;
import org.springframework.http.HttpStatus;
import org.springframework.security.core.annotation.AuthenticationPrincipal;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;

@RestController
@RequestMapping("/api")
public class AccountController {

    record RegisterRequest(String username, String password) {}

    private final AppUserRepository users;
    private final PasswordEncoder encoder;

    public AccountController(AppUserRepository users, PasswordEncoder encoder) {
        this.users = users;
        this.encoder = encoder;
    }

    @PostMapping("/register")
    @ResponseStatus(HttpStatus.CREATED)
    public void register(@RequestBody RegisterRequest request) {
        if (users.existsByUsername(request.username())) {
            throw new ResponseStatusException(HttpStatus.CONFLICT, "Username taken");
        }
        users.save(new AppUser(request.username(), encoder.encode(request.password()), "STUDENT", true));
    }

    @GetMapping("/me")
    public String me(@AuthenticationPrincipal UserDetails user) {
        return "Hello, " + user.getUsername() + " " + user.getAuthorities();
    }

    @GetMapping("/admin/users")
    public List<String> allUsers() {
        return users.findAll(Sort.by("username")).stream()
                .map(AppUser::getUsername)
                .toList();
    }
}
# register a new student (public endpoint)
curl -s -o /dev/null -w "%{http_code}\n" -X POST -H "Content-Type: application/json" \
     -d '{"username":"meena","password":"meena-pass"}' http://localhost:8080/api/register
# same username again
curl -s -o /dev/null -w "%{http_code}\n" -X POST -H "Content-Type: application/json" \
     -d '{"username":"meena","password":"other"}' http://localhost:8080/api/register
curl -s -u meena:meena-pass http://localhost:8080/api/me; echo
curl -s -o /dev/null -w "%{http_code}\n" -u old:old-pass http://localhost:8080/api/me
curl -s -o /dev/null -w "%{http_code}\n" -u meena:meena-pass http://localhost:8080/api/admin/users
curl -s -u ravi:ravi-pass http://localhost:8080/api/admin/users; echo
201
409
Hello, meena [ROLE_STUDENT]
401
403
["meena","old","ravi"]

How it works:

  1. Registration. /api/register is public for POST. The controller hashes the password with the PasswordEncoder before saving, so the app_user table never holds plain text. A duplicate username returns 409 Conflict.
  2. Login on every request. Because the chain is stateless, each curl -u call runs the UserDetailsService, which loads the row by username. Spring Security then checks the password with encoder.matches and the role rules.
  3. Disabled accounts. disabled(!user.isEnabled()) makes Spring Security reject the old account with 401 even though its password is correct. Admins can block a user by flipping one column instead of deleting the row.
  4. Role checks. Meena is a STUDENT, so /api/admin/users returns 403. Ravi has ADMIN and gets the sorted user list.
  5. Clear layering. Security rules live in the SecurityFilterChain, user loading in the UserDetailsService, and business logic in the controller. Building a full REST API in Java on top of this only means adding controllers; the security setup stays the same.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about Spring Security and get answers drawn from it.

Signed-in readers only.