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.
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
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:
SessionAuthenticationStrategyLoginService(Redis dual-index) → Sa-Token: SaTokenDao (Redis impl); Spring Security:
SessionRegistryAuthInterceptor(verify interceptor) → Sa-Token: SaInterceptor; Spring Security:
FilterChainProxyUserContext(ThreadLocal) → Sa-Token: StpUtil (ThreadLocal); Spring Security:
SecurityContextHolderkickOut(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 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:
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
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
Signed-in readers can open the original source through BestHub's protected redirect.
This article has been distilled and summarized from source material, then republished for learning and reference. If you believe it infringes your rights, please contactand we will review it promptly.
How this landed with the community
Was this worth your time?
0 Comments
Thoughtful readers leave field notes, pushback, and hard-won operational detail here.
