Skip to content
Authentication & Authorization Selection Guide: Cost Models, Migration Paths & Architecture Decisions

Authentication & Authorization Selection Guide: Cost Models, Migration Paths & Architecture Decisions

This comprehensive guide analyzes authentication and authorization framework selection across five dimensions, comparing Sa-Token, Keycloak, Spring Security, and JWT with cost models, migration strategies, source code insights, and scenario-based recommendations for startups to enterprises.

CodeSmart Hoops
CodeSmart Hoops
CodeSmart Hoops

9. Cost Model

Selection must consider Total Cost of Ownership (TCO), not just features.

9.1 Four Cost Categories

Development Cost: Custom (Medium), Sa-Token (Low), Spring Security+AS (High), Keycloak (Medium), JWT (Low)

Ops Cost: Custom (Redis), Sa-Token (Redis), Spring Security+AS (Redis+AS), Keycloak (Standalone Cluster), JWT (None)

Learning Cost: Custom (Low), Sa-Token (Low), Spring Security+AS (High), Keycloak (Medium), JWT (Medium)

Migration Cost (Out): Custom (High), Sa-Token (Medium), Spring Security+AS (Medium), Keycloak (Medium), JWT (Low)

9.2 Cost Interpretation

Development Cost: Sa-Token lowest (one-line login); Spring Security + AS highest (login page, user management, filter chain config).

Ops Cost: JWT lowest (stateless, no storage); Keycloak highest (standalone cluster + DB).

Learning Cost: Spring Security steepest (many concepts, complex config); Sa-Token most friendly.

Migration Cost: Custom solutions hardest to migrate (private protocol lock-in); JWT easiest (standard format).

9.3 Hidden Costs

Security Vulnerability Cost: Custom fixes own vulnerabilities; mature frameworks have community backing.

Extension Cost: Private protocol requires rewrite for external integration.

Personnel Turnover Cost: More obscure solutions slow new hires.

Compliance Cost: Meeting regulations (e.g., China's MLPS) may need extra development.

9.4 Cost vs Scale Trade-offs

Small scale: Development cost sensitive → choose Sa-Token / Custom; ops and extension costs acceptable.

Large scale: Ops and extension costs dominate → choose Keycloak / standard solutions; development cost amortized.

Key Insight: Smaller scale → higher weight on development cost (pick simple); larger scale → higher weight on ops/extension cost (pick standard, mature).

9.5 Cost Quantification Example

Comparing "100-user single system" vs "10,000-user multi-system":

Sa-Token Development: Small: 1 week; Large: 4 weeks (multi-system SSO complexity)

Sa-Token Ops: Small: Single Redis; Large: Redis cluster + private protocol maintenance

Keycloak Development: Small: 3 weeks (overkill); Large: 2 weeks (out-of-the-box)

Keycloak Ops: Small: Cluster + DB (overkill); Large: Cluster + DB (reasonable)

Small scale: Sa-Token lower total cost; Large scale: Keycloak cheaper due to standardization and out-of-the-box features.

10. Migration Paths

Selection is not a one-time purchase; consider evolution path from current to target solution.

10.1 Typical Evolution Routes

Evolution routes diagram
Evolution routes diagram

10.2 Key Designs for Smooth Migration

Abstract Auth Interface: Business code depends on AuthService interface, not concrete framework, enabling swap.

Progressive Migration: Old and new coexist, canary switch, dual-login session compatibility.

User Identity Alignment: Map old/new user IDs during migration to keep historical data continuous.

Protocol First: Even if phase 1 uses private protocol, design token flow with OAuth2 mindset to reduce future migration cost.

Abstract Interface Example:

// Business depends on interface, not framework
public interface AuthService {
    SessionInfo login(String username, String password);
    SessionInfo verify(String token);
    void logout(String token);
}

// Sa-Token implementation (Phase 1)
@Service
public class SaTokenAuthServiceImpl implements AuthService {
    public SessionInfo login(String u, String p) {
        StpUtil.login(u); // Sa-Token
        ...
    }
}

// Keycloak implementation (Phase 3 migration)
@Service
public class KeycloakAuthServiceImpl implements AuthService {
    public SessionInfo login(String u, String p) {
        // OIDC Authorization Code flow
        ...
    }
}

Migration only swaps implementation class; business code unchanged.

10.3 Migration Anti-patterns

Big-bang migration: All-at-once cutover, extremely high risk, any issue causes full outage.

No abstraction, direct coupling: Business code scattered with StpUtil.login() calls; migration requires changes everywhere.

Ignoring user sessions: Clearing all sessions during migration kicks all users, disastrous experience.

10.4 Dual-Login Session Compatibility

During migration, old and new coexist; ensure sessions from old system recognized by new, or vice versa:

Dual Write: Write session to both old and new on login.

Dual Read: Verify: check new first, fallback to old on miss.

Canary: Gradually shift users/tenants to new solution.

11. Source Code Analysis

11.1 Spring Security Filter Chain Architecture

Core is FilterChainProxy composed of multiple SecurityFilterChain:

Request → FilterChainProxy
 ├─ SecurityContextHolderFilter (stores auth context)
 ├─ UsernamePasswordAuthenticationFilter (form login)
 ├─ OAuth2LoginAuthenticationFilter (OIDC login)
 ├─ AuthorizationFilter (authorization check)
 └─ ExceptionTranslationFilter (exception handling)

Key Classes: SecurityContextHolder: ThreadLocal stores current auth context AuthenticationManager: Authentication decision AuthorizationManager: Authorization decision SecurityFilterChain: Filter chain matching

Relation to Selection: Highly customizable filter chain suits fine-grained security control; but complex config, high learning curve, hard for small teams.

11.2 Keycloak Architecture

Core components:

Keycloak Server
 ├─ Realm (tenant isolation)
 ├─ Client (business system registration)
 ├─ User/Role/Group (identity & permissions)
 ├─ User Federation (LDAP/AD federation)
 ├─ Identity Provider (social login / external IdP)
 ├─ Token Service (OAuth2/OIDC endpoints)
 └─ Event/audit Log (audit)

Key Designs:

Realm Isolation: Each tenant independent Realm, users/clients/sessions fully isolated.

Token uses RS256 signed JWT: Public key exposed via JWKS, SP verifies locally.

User Federation: LDAP/AD integration without user sync, federated query.

Multi-protocol: OIDC + SAML2 simultaneously.

Relation to Selection: Keycloak bundles auth/token/federation/audit, but high ops cost as standalone service; suits large enterprises.

11.3 Sa-Token Design Philosophy

Core is StpUtil static facade + SaTokenDao storage abstraction:

// Sa-Token source (simplified)
public class StpLogic {
    public void login(Object id) {
        String token = createToken(id);
        SaTokenDao.set("satoken:" + token, id, timeout); // Redis store
        // Write cookie or return token
    }
    public Object getLoginId() {
        String token = getTokenFromRequest();
        return SaTokenDao.get("satoken:" + token);
    }
}

Design Philosophy:

Static Facade: StpUtil.login() one-liner,极高易用性.

Storage Abstraction: SaTokenDao swappable Redis/Memory/DB, decouples storage.

Private Protocol: Token is random string + Redis lookup, not standard JWT/OAuth2.

Relation to Selection: Sa-Token trades usability for standard compliance — fast dev friendly, but weak for external standard integration.

11.4 JWT Self-contained Verification

JWT statelessness comes from self-contained + verification:

// JWT verification (no network IO, pure local)
public Claims verify(String jwt) {
    Jws<Claims> jws = Jwts.parserBuilder()
        .setSigningKey(publicKey) // verification public key
        .build()
        .parseClaimsJws(jwt); // verify + parse
    return jws.getBody();
}

Relation to Selection: JWT needs no storage lookup, highest performance, but cannot actively revoke — the cost of "stateless".

11.5 Spring Authorization Server Architecture

Spring official OAuth2 Authorization Server core components:

Spring Authorization Server
 ├─ AuthorizationServerSettings (endpoint config)
 ├─ RegisteredClientRepository (client registration)
 ├─ AuthorizationGrantHandler (grant type handling)
 │   ├─ AuthorizationCodeAuthenticationProvider
 │   ├─ ClientCredentialsAuthenticationProvider
 │   └─ RefreshTokenAuthenticationProvider
 ├─ OAuth2TokenGenerator (token generation, JWT / self-contained)
 └─ JWKSource (signing keys)

Key Designs:

Multiple Grant Types: Auth code, client credentials, refresh token, password mode, dispatched by AuthorizationGrantType.

Two Token Forms: JWT (self-contained) or opaque token (self-referential, requires introspection endpoint).

Key Management: JWKSource exposes JWKS, SP pulls public key for local verification.

Key Differences vs Keycloak:

Form: Spring Boot library (embedded in business) vs Standalone service

User Management: Not provided (self-implement) vs Built-in + LDAP/AD federation

Login Page: Self-implement vs Out-of-the-box

Audit: Self-implement vs Built-in

SAML: Not supported vs Supported

Suits: Self-built AS, embedded in Spring stack vs Enterprise unified identity, out-of-the-box

Relation to Selection: Spring AS is "self-built AS" — lighter than Keycloak (embedded, no standalone service), but must write login page/user management/audit. Suits Spring stack, avoids Keycloak cluster, but needs standard OIDC.

11.6 Token Verification Performance Comparison

Custom Redis: Query Redis hash, 1 Redis, ~1ms

Sa-Token: Query Redis, 1 Redis, ~1ms

Keycloak (Opaque): Call introspection, 1 HTTP, ~5-10ms

Keycloak (JWT): Local verify, 0 network IO, ~0.1ms

JWT: Local verify, 0 network IO, ~0.1ms

Key Insights:

Opaque token + introspection: Every verify calls IdP, worst performance, but instant revocation.

JWT local verify: Best performance, but no instant revocation.

Keycloak defaults to JWT: Balances performance and standard — advantage over CAS.

Selection Impact: High QPS (gateway verification) prefer JWT local verify; strong session management (finance, immediate ban) accept ~1ms Redis cost for kick capability.

11.7 Custom vs Framework Source Code Mapping

Understanding custom implementation reveals frameworks are essentially engineered wrappers: TokenGenerator (SecureRandom) → Sa-Token: SaTokenDao + StpLogic.createToken; Spring Security:

SessionAuthenticationStrategy
LoginService

(Redis dual-index) → Sa-Token: SaTokenDao (Redis impl); Spring Security:

SessionRegistry
AuthInterceptor

(verify interceptor) → Sa-Token: SaInterceptor; Spring Security:

FilterChainProxy
UserContext

(ThreadLocal) → Sa-Token: StpUtil (ThreadLocal); Spring Security:

SecurityContextHolder
kickOut

(delete session) → Sa-Token: StpUtil.kickout; Spring Security: SessionRegistry.expireNow Conclusion: Sa-Token internals essentially mirror custom solution engineering — dual-index, Redis storage, kick, ThreadLocal context, same thinking. Spring Security adds filter chain and authentication manager abstractions, more generic but more complex.

Selection Insight: Understanding custom principles makes frameworks transparent — debuggable, extensible. This is the value of "principles before frameworks".

12. Unit Tests

12.1 Auth Abstraction Interface Tests

@SpringBootTest
class AuthServiceTest {
    @Autowired
    private AuthService authService;

    @Test
    void testLoginSuccess() {
        SessionInfo session = authService.login("admin", "correct-password");
        assertNotNull(session);
        assertEquals("admin", session.getUsername());
    }

    @Test
    void testLoginWrongPassword() {
        assertThrows(AuthException.class, () -> authService.login("admin", "wrong-password"));
    }

    @Test
    void testVerifyValidToken() {
        SessionInfo session = authService.login("admin", "correct-password");
        SessionInfo verified = authService.verify(session.getToken());
        assertNotNull(verified);
    }

    @Test
    void testVerifyInvalidToken() {
        assertThrows(AuthException.class, () -> authService.verify("invalid-token"));
    }

    @Test
    void testLogoutInvalidatesToken() {
        SessionInfo session = authService.login("admin", "correct-password");
        authService.logout(session.getToken());
        assertThrows(AuthException.class, () -> authService.verify(session.getToken()));
    }
}

12.2 Framework Independence Tests (Migration Guarantee)

@Test
void testBusinessCodeIndependentOfFramework() {
    // Business code only depends on AuthService interface, not StpUtil/SecurityContextHolder
    // Migration does not require changing this test
    SessionInfo session = authService.login("admin", "123456");
    UserContext.set(session);
    assertEquals("admin", orderService.getMyOrders().get(0).getOwner());
    UserContext.clear();
}

12.3 Permission Enforcement Tests

@Test
void testPermissionEnforced() {
    // User lacks user:delete permission
    loginAs("operator", "123456");
    assertThrows(ForbiddenException.class, () -> userService.delete(1L));

    // Admin has permission
    loginAs("admin", "123456");
    assertDoesNotThrow(() -> userService.delete(1L));
}

12.4 Selection Scenario Validation Tests

@Test
void testScenarioSingleAppSaToken() {
    // Scenario: Single backend + Sa-Token, verify one-week launch
    // 1. Login returns token
    String token = given().formParam("username", "admin").formParam("password", "123456")
        .when().post("/login").then().extract().header("X-Token");
    // 2. Access protected endpoint with token
    given().header("X-Token", token).when().get("/user/profile").then().statusCode(200);
}

13. Scenario Discussions

Applying five-dimension model to real scenarios.

13.1 Scenario 1: Startup Single Product

Team: 1-3 person small team

System: Single product (Web + App)

External: No

Compliance: No special requirements

Ops: No dedicated ops

Recommended: Sa-Token (Redis Token).

Reasons:

Small team, need speed → development cost primary factor.

Sa-Token one-line login, low learning curve.

Single system no SSO needed, Keycloak capabilities unused.

App uses token passing, Sa-Token built-in support.

Evolution Reserve: Business code isolated via AuthService interface; future SSO or external integration can migrate to standard solution without business changes.

13.2 Scenario 2: Medium Multi-Business Line

Team: Medium team, has ops

System: OA, CRM, Ticketing multiple internal systems

External: No (internal)

Compliance: Basic audit needed

Ops: Middleware ops capability

Recommended: Spring Security + Self-built AS, or Sa-Token SSO.

Reasons:

Multi-system needs SSO to avoid repeated login.

Internal systems, private protocol acceptable (Sa-Token SSO).

If future standard protocol needed (possible external), use Spring Security + Spring Authorization Server.

Ops capability can maintain self-built AS.

Key Trade-off: Need standard protocol? If definitely internal only, Sa-Token SSO cheapest; if may open externally, standard OIDC (Spring AS) reserves extensibility.

13.3 Scenario 3: Large Enterprise Group

Team: Large team, dedicated ops/security

System: Group OA/CRM/ERP/HR multi-system

External: Need integrate subsidiaries, partners

Compliance: MLPS, audit, identity federation

Ops: Full DevOps

Recommended: Keycloak Unified Identity Platform.

Reasons:

Many systems need unified identity, Keycloak out-of-the-box SSO.

Subsidiary/partner integration requires standard protocols, Keycloak full OIDC + SAML2.

MLPS/audit requires centralized logs, Keycloak built-in audit.

Identity federation (subsidiary AD), Keycloak native support.

Ops capability can maintain Keycloak cluster.

Typical Architecture:

Keycloak architecture for enterprise
Keycloak architecture for enterprise

Keycloak supports both OIDC and SAML; new systems use OIDC, legacy ERP uses SAML, unified user management.

13.4 Scenario 4: External Open Platform (SaaS)

Team: Medium-large team

System: SaaS platform + Open API

External: Multi-tenant, open API to partners

Compliance: Multi-tenant isolation, audit

Ops: Full DevOps

Recommended: Keycloak Multi-Realm (one Realm per tenant) + Business RBAC/ABAC.

Reasons:

Multi-tenant SSO, each tenant isolated Realm, users/sessions fully isolated.

Open API to partners must use standard OIDC (partners won't accept private protocol).

Enterprise customer AD integration via Keycloak User Federation.

Fine-grained business permissions (per-tenant button/data) implemented by business system RBAC/ABAC.

Key Design:

Auth: Keycloak (one Realm per tenant)

Token: OIDC (standard JWT)

Authorization: Business RBAC/ABAC (token carries tenant_id)

Isolation: Realm isolation + tenant_id double insurance

Audit: Keycloak login logs + business operation logs

13.5 Scenario 5: Microservices Stateless Architecture

Team: Medium-large team

System: Microservices cluster

External: Service-to-service calls

Compliance: General

Ops: Has DevOps

Recommended: Gateway stateful session + Microservices JWT.

Reasons:

Gateway uses stateful session (Sa-Token/Custom), easy kick, unified auth entry.

Gateway verifies, then signs user identity into short-TTL JWT for downstream microservices.

Microservices locally verify JWT, no network IO, high performance.

Microservices stateless, horizontally scalable.

Architecture:

Gateway stateful + microservices stateless
Gateway stateful + microservices stateless

This "stateful + stateless" hybrid — gateway stateful manages sessions, microservices stateless manage performance. Balances kick capability and performance.

14. Case Study: Selection Review Meeting Transcript

Applying methodology to a real review meeting.

14.1 Background

A medium company has existing OA and Ticketing (both Sa-Token separate login), building new CRM, plans to open API to partners in 6 months. Tech director calls review: "How to choose auth for new CRM and future open API?"

14.2 Review Process

Step 1: Apply Five Dimensions

Team: 8 backend, 1 ops

System: OA + Ticketing (existing) + CRM (new), future open API

External: Open API to partners in 6 months

Compliance: Basic audit needed

Ops: Middleware ops, no standalone service ops

Step 2: Identify Key Constraints

"Open API in 6 months" → external need → must use standard protocol eventually.

"OA + Ticketing + CRM" multi-system → needs SSO.

"Has ops but no standalone service ops" → Keycloak cluster ops strain.

Step 3: Candidate Filtering

Custom Redis: ❌ No external capability, rework in 6 months

Sa-Token SSO: ⚠️ Internal SSO works, but standard compliance insufficient for open API

Spring Security + Spring AS: ✅ Standard OIDC, supports SSO + open API, but self-build AS

Keycloak: ⚠️ Full features, but ops capability can't handle standalone cluster

Step 4: Decision

Choose Spring Security + Spring Authorization Server :

Standard OIDC, open API ready (no rework).

Self-built AS integrates into existing Spring Boot stack, no standalone Keycloak cluster.

Three-system SSO via standard OIDC, more evolvable than Sa-Token private protocol.

Ops only maintains one extra Spring Boot service (self-built AS), team already familiar.

Step 5: Migration Path

Migration path diagram
Migration path diagram

Phase 1: Build AS + onboard new CRM, legacy systems untouched.

Phase 2: Gradually migrate OA, Ticketing to AS SSO (coexistence, dual-login compatibility).

Phase 3: Open API to partners (Client Credentials mode).

Step 6: Abstraction Isolation

All business code depends on AuthService interface; Sa-Token and AS implementations coexist, migration swaps implementation only.

14.3 Review Lessons

Methodology over answer: Five dimensions + key constraints → decision emerges naturally.

Look at evolution, not just now: 6-month open API constraint eliminated Sa-Token (works now but rework later).

Ops capability is hard constraint: Keycloak features irrelevant if ops can't support.

Reserve migration path: Abstract interface + progressive migration reduces risk.

15. Common Pitfalls

15.1 Pitfall: Picking "Which is Best"

Pitfall: Seeking "best auth framework".

Correction: No best, only most suitable. Keycloak feature-rich but overkill for small projects; Sa-Token easy but weak externally. Selection matches scenario.

15.2 Pitfall: Business Code Directly Couples Framework

Pitfall: Business code scattered with StpUtil / SecurityContextHolder calls.

Correction: Abstract AuthService interface; business depends on interface, migration only changes implementation. See 10.2.

15.3 Pitfall: Keycloak Does Everything

Pitfall: Assuming Keycloak handles button-level permissions too.

Correction: Keycloak only handles auth and scope-level authorization; fine-grained business permissions (button, data) implemented by business system via RBAC/ABAC. Auth and AuthZ layered.

15.4 Pitfall: JWT Is Universal

Pitfall: Microservices all use JWT, stateless is most elegant.

Correction: JWT cannot actively revoke (unless blocklist). Strong session management (finance, immediate ban) better served by stateful solutions.

15.5 Pitfall: Ignoring Migration Cost

Pitfall: Selection only considers present, ignores future migration.

Correction: Selection must consider evolution path, reserve migration space. Abstract interface + protocol first reduces future migration cost.

15.6 Pitfall: Hardcoded Secrets

Pitfall: JWT secret, OAuth2 client_secret in code.

Correction: Secrets into Vault, rotate regularly, different per environment.

15.7 Pitfall: Auth Service Single Point

Pitfall: Keycloak/Redis single-node deployment.

Correction: Auth is lifeline, must be HA — Keycloak cluster, Redis master-sentinel.

16. Best Practices

16.1 Selection Principles

Good Enough: Solves current + satisfies 1-2 year evolution = good solution.

Progressive by Scale: Small use simple, large use standard.

External Must Be Standard: Open API / external integration use OIDC.

Internal Can Be Private: Internal systems can use Sa-Token/Custom.

16.2 Architecture Principles

Abstract Isolation: Business depends on AuthService interface, no framework coupling.

Auth/AuthZ Layering: Auth layer (IdP) + AuthZ layer (Business RBAC/ABAC).

Protocol First: Token flow designed with OAuth2 mindset, reduces migration cost.

High Availability: Auth service clustered, no bare metal.

16.3 Security Principles

Secrets in Vault: No hardcoding, regular rotation.

Audit Logs: Login/logout/permission changes fully logged.

Token Revocation: JWT with blocklist or short TTL + Refresh Token.

HTTPS Enforced: Full encryption on auth paths.

16.4 Migration Principles

Progressive: Old and new coexist, canary switch.

Dual-Login Compatibility: Session dual-write/dual-read.

User Identity Alignment: Old/new ID mapping.

No Bare Metal: Auth service HA during migration.

17. Selection Decision Checklist

Turn methodology into executable checklist for review meetings.

17.1 Requirements Confirmation Checklist

Single or multi-system? Need SSO?

Users internal employees or external?

Open API to third parties?

Integrate enterprise AD/LDAP?

MLPS/Audit/Compliance requirements?

Team size? Dedicated ops?

New requirements in 6 months / 1 year?

17.2 Solution Matching Checklist

External need → Must use standard protocol → Choose OIDC (Keycloak / Spring AS)

Multi-system SSO → Must have SSO capability → Keycloak / Spring AS / Sa-Token SSO

Small team → Dev cost priority → Sa-Token / Custom

Strong session management (kick) → Stateful → Custom / Sa-Token (JWT needs blocklist)

Microservices stateless → JWT → JWT local verify

Weak ops → Avoid standalone service → Sa-Token (embedded) not Keycloak

17.3 Architecture Compliance Checklist

Business code isolated via AuthService interface?

Auth (IdP) and AuthZ (Business RBAC/ABAC) layered?

Secrets in Vault, not hardcoded?

Auth service HA (cluster/sentinel)?

Migration path to next phase reserved?

Audit logs (login/logout/permission changes)?

17.4 Anti-pattern Self-check

Single system forced Keycloak

External platform uses private protocol

Business code directly calls framework API

JWT secret hardcoded

Auth service single-node deployment

No migration path, future rework

Running through this checklist ensures selection rationality, compliance, and evolvability.

18. Summary — Core Cheatsheet

AuthN vs AuthZ: Authentication (who you are) vs Authorization (what you can do)

Stateful vs Stateless: Redis session easy kick vs JWT self-contained hard revoke

Five Dimensions: Team / System count / External / Compliance / Ops

External Must Standard: OIDC/OAuth2 is hard currency

Internal Can Private: Sa-Token/Custom sufficient

Abstract Isolation: Business depends on AuthService interface, no framework coupling

Auth/AuthZ Layering: IdP handles auth, business handles RBAC/ABAC

Cost Trade-off: Small scale dev cost dominates, large scale ops/extension dominates

Migration Path: Progressive, coexistence, dual-login compatibility

JWT Revocation Blind Spot: Blocklist or short TTL + Refresh

Keycloak Fits: Enterprise multi-system, unified identity, external

Sa-Token Fits: Small-medium teams, fast internal

Secrets Management: Into Vault, rotate regularly

Auth High Availability: Lifeline service clustered

19. Interview Self-test & Answers

👉 Authentication & Authorization Architecture Selection Deep Dive (Interview Self-test & Answers)

Q1: Difference between Authentication (AuthN) and Authorization (AuthZ)? Why separate first? (Section 2)

Q2: Stateful vs Stateless session differences? Pros/cons each? (Section 2.2)

Q3: Five dimensions of selection? Why not just look at framework capabilities? (Section 6)

Q4: Single backend, ~10 users, what to choose? Why not Keycloak? (Sections 5,6)

Q5: Open API platform, why must use standard protocol (OIDC)? (Sections 5,7)

Q6: How to choose among Custom Redis Session, Sa-Token, Keycloak, JWT? (Sections 7,8)

Q7: Four cost categories of selection? How scale affects cost weights? (Section 9)

Q8: Evolving from Custom Session to Unified Identity Platform, migration considerations? Why abstract isolation matters? (Section 10)

Q9: What is JWT stateless "token revocation blind spot"? How to solve? (Section 13)

Q10: Keycloak handles auth, who handles business button permissions? Why? (Sections 11,13.3)

Q11: What is "protocol mixing" anti-pattern? How avoid? Problems with business coupling framework? (Sections 13,5.3)

Q12: What is layered auth/authz architecture? Why IdP shouldn't own business permissions? (Sections 2.5,14.2)

References

Custom Redis Distributed Session Deep Dive — Custom Solution Details

Sa-Token Auth Framework Deep Dive — Sa-Token Solution

Spring Security Deep Dive — Spring Security Solution

OAuth2 & OIDC Deep Dive — Standard Protocol Basics

JWT Deep Dive & Practice — Stateless Solution

SSO Single Sign-On Deep Dive — SSO & Keycloak

Permission Models & RBAC-ABAC Deep Dive — AuthZ Layer Solutions

OAuth 2.0 Security Best Current Practice (RFC 9700) — OAuth2 Security Best Practices

NIST SP 800-63B — Digital Identity Guidelines

Original Source

Signed-in readers can open the original source through BestHub's protected redirect.

Sign in to view source
Republication Notice

This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactadmin@besthub.devand we will review it promptly.

migrationarchitecturemicroservicesAuthenticationJWTOAuth2authorizationRBACSSOcost-modelABACSpring Securityframework-selectionSa-TokenKeycloakOIDC
Reader feedback

How this landed with the community

Sign in to like

Rate this article

Was this worth your time?

Sign in to rate
Discussion

0 Comments

Thoughtful readers leave field notes, pushback, and hard-won operational detail here.