🌍 실제 사례: 간단한 사용자 관리 시스템

이론은 충분히 알아봤으니, 이제 Shiro를 사용한 실제 예제를 살펴볼게요. 간단한 사용자 관리 시스템을 만들어볼 거예요!

1. 프로젝트 구조

Spring Boot와 Shiro를 함께 사용한 예제예요:

src/
  ├── main/
  │   ├── java/
  │   │   └── com/example/usermgmt/
  │   │       ├── config/
  │   │       │   └── ShiroConfig.java
  │   │       ├── controller/
  │   │       │   ├── UserController.java
  │   │       │   └── AuthController.java
  │   │       ├── model/
  │   │       │   ├── User.java
  │   │       │   └── Role.java
  │   │       ├── repository/
  │   │       │   ├── UserRepository.java
  │   │       │   └── RoleRepository.java
  │   │       ├── service/
  │   │       │   └── UserService.java
  │   │       ├── shiro/
  │   │       │   └── DatabaseRealm.java
  │   │       └── UserManagementApplication.java
  │   └── resources/
  │       ├── application.properties
  │       └── templates/
  │           ├── login.html
  │           ├── register.html
  │           ├── user/
  │           │   └── list.html
  │           └── admin/
  │               └── dashboard.html
  └── test/

2. 의존성 설정

build.gradle 파일에 필요한 의존성을 추가해요:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-web'
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'
    implementation 'org.apache.shiro:shiro-spring-boot-web-starter:1.10.1'
    implementation 'com.h2database:h2'
    implementation 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
}

3. 모델 클래스

사용자와 역할을 표현하는 모델 클래스를 만들어요:

// User.java
@Entity
@Data
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true)
    private String username;
    
    private String password;
    private String salt;
    
    @ManyToMany(fetch = FetchType.EAGER)
    private Set<Role> roles = new HashSet<>();
}

// Role.java
@Entity
@Data
public class Role {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    
    @Column(unique = true)
    private String name;
    
    private String description;
    
    @ElementCollection(fetch = FetchType.EAGER)
    private Set<String> permissions = new HashSet<>();
}

4. 커스텀 Realm 구현

데이터베이스에서 사용자 정보를 가져오는 Realm을 구현해요:

// DatabaseRealm.java
@Component
public class DatabaseRealm extends AuthorizingRealm {
    
    @Autowired
    private UserService userService;
    
    @Override
    protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) 
            throws AuthenticationException {
        
        UsernamePasswordToken upToken = (UsernamePasswordToken) token;
        String username = upToken.getUsername();
        
        // 사용자 조회
        User user = userService.findByUsername(username);
        
        if (user == null) {
            throw new UnknownAccountException("사용자를 찾을 수 없습니다: " + username);
        }
        
        // AuthenticationInfo 객체 생성 및 반환
        return new SimpleAuthenticationInfo(
            username,                 // principal
            user.getPassword(),       // credentials
            ByteSource.Util.bytes(user.getSalt()), // salt
            getName()                 // realm name
        );
    }
    
    @Override
    protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
        String username = (String) getAvailablePrincipal(principals);
        User user = userService.findByUsername(username);
        
        SimpleAuthorizationInfo info = new SimpleAuthorizationInfo();
        
        // 역할 추가
        for (Role role : user.getRoles()) {
            info.addRole(role.getName());
            
            // 권한 추가
            for (String permission : role.getPermissions()) {
                info.addStringPermission(permission);
            }
        }
        
        return info;
    }
}

5. Shiro 설정

Shiro 설정 클래스를 만들어요:

// ShiroConfig.java
@Configuration
public class ShiroConfig {
    
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
        shiroFilterFactoryBean.setSecurityManager(securityManager);
        
        // 로그인 관련 URL 설정
        shiroFilterFactoryBean.setLoginUrl("/login");
        shiroFilterFactoryBean.setSuccessUrl("/");
        shiroFilterFactoryBean.setUnauthorizedUrl("/unauthorized");
        
        // URL 패턴별 필터 체인 설정
        Map<String, String> filterChainDefinitionMap = new LinkedHashMap<>();
        filterChainDefinitionMap.put("/login", "anon");
        filterChainDefinitionMap.put("/register", "anon");
        filterChainDefinitionMap.put("/logout", "logout");
        filterChainDefinitionMap.put("/admin/**", "authc, roles[admin]");
        filterChainDefinitionMap.put("/user/**", "authc, roles[user]");
        filterChainDefinitionMap.put("/**", "authc");
        
        shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
        return shiroFilterFactoryBean;
    }
    
    @Bean
    public SecurityManager securityManager(DatabaseRealm databaseRealm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(databaseRealm);
        return securityManager;
    }
    
    @Bean
    public HashedCredentialsMatcher hashedCredentialsMatcher() {
        HashedCredentialsMatcher matcher = new HashedCredentialsMatcher();
        matcher.setHashAlgorithmName("SHA-256");
        matcher.setHashIterations(1024);
        matcher.setStoredCredentialsHexEncoded(false);
        return matcher;
    }
    
    @Bean
    public static LifecycleBeanPostProcessor lifecycleBeanPostProcessor() {
        return new LifecycleBeanPostProcessor();
    }
    
    @Bean
    public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
        AuthorizationAttributeSourceAdvisor advisor = new AuthorizationAttributeSourceAdvisor();
        advisor.setSecurityManager(securityManager);
        return advisor;
    }
}

6. 컨트롤러 구현

인증 및 사용자 관리 컨트롤러를 구현해요:

// AuthController.java
@Controller
public class AuthController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/login")
    public String login() {
        // 이미 로그인한 사용자는 홈으로 리다이렉트
        if (SecurityUtils.getSubject().isAuthenticated()) {
            return "redirect:/";
        }
        return "login";
    }
    
    @PostMapping("/login")
    public String doLogin(String username, String password, boolean rememberMe, Model model) {
        Subject subject = SecurityUtils.getSubject();
        
        if (!subject.isAuthenticated()) {
            UsernamePasswordToken token = new UsernamePasswordToken(username, password);
            token.setRememberMe(rememberMe);
            
            try {
                subject.login(token);
                return "redirect:/";
            } catch (AuthenticationException e) {
                model.addAttribute("error", "아이디 또는 비밀번호가 올바르지 않습니다.");
                return "login";
            }
        }
        
        return "redirect:/";
    }
    
    @GetMapping("/logout")
    public String logout() {
        SecurityUtils.getSubject().logout();
        return "redirect:/login";
    }
    
    @GetMapping("/register")
    public String register() {
        return "register";
    }
    
    @PostMapping("/register")
    public String doRegister(User user, Model model) {
        try {
            userService.registerUser(user);
            return "redirect:/login?registered=true";
        } catch (Exception e) {
            model.addAttribute("error", e.getMessage());
            return "register";
        }
    }
    
    @GetMapping("/unauthorized")
    public String unauthorized() {
        return "unauthorized";
    }
}

// UserController.java
@Controller
@RequestMapping("/user")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @RequiresRoles("admin")
    @GetMapping("/list")
    public String listUsers(Model model) {
        model.addAttribute("users", userService.findAllUsers());
        return "user/list";
    }
    
    @RequiresPermissions("user:create")
    @GetMapping("/create")
    public String createUserForm() {
        return "user/create";
    }
    
    @RequiresPermissions("user:create")
    @PostMapping("/create")
    public String createUser(User user) {
        userService.createUser(user);
        return "redirect:/user/list";
    }
}

7. 서비스 레이어 구현

사용자 관련 비즈니스 로직을 담당하는 서비스를 구현해요:

// UserService.java
@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Autowired
    private RoleRepository roleRepository;
    
    public User findByUsername(String username) {
        return userRepository.findByUsername(username);
    }
    
    public List<User> findAllUsers() {
        return userRepository.findAll();
    }
    
    public void registerUser(User user) {
        // 사용자 이름 중복 체크
        if (userRepository.findByUsername(user.getUsername()) != null) {
            throw new RuntimeException("이미 존재하는 사용자 이름입니다.");
        }
        
        // 솔트 생성
        String salt = RandomStringUtils.randomAlphanumeric(16);
        user.setSalt(salt);
        
        // 비밀번호 해싱
        Sha256Hash hashedPassword = new Sha256Hash(user.getPassword(), salt, 1024);
        user.setPassword(hashedPassword.toBase64());
        
        // 기본 역할 할당
        Role userRole = roleRepository.findByName("user");
        user.getRoles().add(userRole);
        
        userRepository.save(user);
    }
    
    public void createUser(User user) {
        // 관리자가 생성하는 사용자 로직
        registerUser(user);
    }
}

이렇게 구현하면 Shiro를 사용한 간단한 사용자 관리 시스템이 완성돼요! 로그인, 로그아웃, 사용자 등록, 권한 관리 등의 기능을 모두 구현했어요.

이 예제는 실제 프로젝트에서 바로 활용할 수 있는 기본 구조를 보여줘요. 재능넷 같은 서비스에서도 이런 방식으로 사용자 인증과 권한 관리를 구현할 수 있을 거예요! 😊