# est-spi-security

**Repository Path**: est-spi/security

## Basic Information

- **Project Name**: est-spi-security
- **Description**: No description available
- **Primary Language**: Java
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-03-15
- **Last Updated**: 2026-03-21

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# EST SPI Security

[English Version](README.en.md)

## EST SPI 安全模块

est-spi-security 是 EST SPI 框架的安全模块，提供用户认证和权限授权功能。

### 核心功能

#### User - 用户接口
定义用户的接口，包含用户ID、用户名、密码、角色、权限等信息。

#### Role - 角色接口
定义角色的接口，包含角色ID、名称、描述和权限集合。

#### Permission - 权限接口
定义权限的接口，包含权限ID、名称、描述、资源和操作。

#### Authentication - 认证接口
定义认证的接口，包含用户信息、认证状态、凭证等。

#### AuthenticationManager - 认证管理器接口
定义认证管理器的接口，负责用户认证。

#### AuthenticationException - 认证异常
认证过程中的异常类。

#### Authorization - 授权接口
定义授权的接口，负责权限检查。

#### SimpleUser - 简单用户实现
用户接口的简单实现。

#### SimpleRole - 简单角色实现
角色接口的简单实现。

#### SimplePermission - 简单权限实现
权限接口的简单实现。

#### SimpleAuthentication - 简单认证实现
认证接口的简单实现。

#### SimpleAuthenticationManager - 简单认证管理器实现
认证管理器接口的简单实现。

#### SimpleAuthorization - 简单授权实现
授权接口的简单实现。

### 快速开始

#### 创建权限

```java
import ltd.idcu.est.spi.security.Permission;
import ltd.idcu.est.spi.security.SimplePermission;

public class Example {
    public static void main(String[] args) {
        Permission readUser = new SimplePermission(
            "perm-1", "read:user", "Read user data", "user", "read"
        );
        
        Permission writeUser = new SimplePermission(
            "perm-2", "write:user", "Write user data", "user", "write"
        );
        
        System.out.println("Permission: " + readUser.getName());
    }
}
```

#### 创建角色

```java
import ltd.idcu.est.spi.security.Role;
import ltd.idcu.est.spi.security.SimpleRole;
import java.util.HashSet;
import java.util.Set;

public class Example {
    public static void main(String[] args) {
        Set<Permission> permissions = new HashSet<>();
        permissions.add(readUser);
        permissions.add(writeUser);
        
        Role adminRole = new SimpleRole(
            "role-1", "ADMIN", "Administrator role", permissions
        );
        
        System.out.println("Role: " + adminRole.getName());
    }
}
```

#### 创建用户

```java
import ltd.idcu.est.spi.security.User;
import ltd.idcu.est.spi.security.SimpleUser;
import java.util.HashSet;
import java.util.Set;

public class Example {
    public static void main(String[] args) {
        Set<Role> roles = new HashSet<>();
        roles.add(adminRole);
        
        User user = new SimpleUser(
            "user-1", "admin", "password123", roles, null
        );
        
        System.out.println("User: " + user.getUsername());
        System.out.println("Enabled: " + user.isEnabled());
    }
}
```

#### 用户认证

```java
import ltd.idcu.est.spi.security.Authentication;
import ltd.idcu.est.spi.security.AuthenticationManager;
import ltd.idcu.est.spi.security.SimpleAuthentication;
import ltd.idcu.est.spi.security.SimpleAuthenticationManager;

public class Example {
    public static void main(String[] args) throws Exception {
        AuthenticationManager authManager = new SimpleAuthenticationManager();
        
        User user = new SimpleUser("user-1", "admin", "password123");
        ((SimpleAuthenticationManager) authManager).addUser(user);
        
        User loginUser = new SimpleUser(null, "admin", null);
        Authentication auth = new SimpleAuthentication(loginUser, "password123");
        
        Authentication result = authManager.authenticate(auth);
        
        System.out.println("Authenticated: " + result.isAuthenticated());
        System.out.println("User: " + result.getUser().getUsername());
    }
}
```

#### 权限检查

```java
import ltd.idcu.est.spi.security.Authorization;
import ltd.idcu.est.spi.security.SimpleAuthorization;

public class Example {
    public static void main(String[] args) {
        Authorization authz = new SimpleAuthorization();
        
        User user = ...;
        
        boolean canRead = authz.hasPermission(user, "read:user");
        System.out.println("Can read user: " + canRead);
        
        boolean isAdmin = authz.hasRole(user, "ADMIN");
        System.out.println("Is admin: " + isAdmin);
        
        boolean hasAny = authz.hasAnyPermission(user, "read:user", "write:user");
        System.out.println("Has any permission: " + hasAny);
        
        boolean hasAll = authz.hasAllPermissions(user, "read:user", "write:user");
        System.out.println("Has all permissions: " + hasAll);
    }
}
```

#### 动态添加角色和权限

```java
import ltd.idcu.est.spi.security.SimpleUser;
import ltd.idcu.est.spi.security.SimpleRole;
import ltd.idcu.est.spi.security.SimplePermission;

public class Example {
    public static void main(String[] args) {
        SimpleUser user = new SimpleUser("user-1", "testuser", "password123");
        
        Permission deletePerm = new SimplePermission(
            "perm-3", "delete:user", "Delete user data", "user", "delete"
        );
        user.addPermission(deletePerm);
        
        Role moderatorRole = new SimpleRole("role-2", "MODERATOR", "Moderator role", null);
        user.addRole(moderatorRole);
        
        System.out.println("Permissions: " + user.getPermissions().size());
        System.out.println("Roles: " + user.getRoles().size());
    }
}
```

### Maven 依赖

```xml
<dependency>
    <groupId>ltd.idcu.est.spi</groupId>
    <artifactId>est-spi-security</artifactId>
    <version>1.0.0</version>
</dependency>
```

### 许可证

MIT License