Java 기초 제네릭(Generics)이란?

1. 제네릭(Generics)이란?

제네릭은 클래스, 인터페이스, 메서드에서 사용할 데이터 타입을 컴파일 시에 미리 지정하지 않고, 실제 사용 시점에 타입을 지정할 수 있게 하는 기능입니다. 이를 통해 코드 재사용성을 높이고, 컴파일 시 타입 안전성을 보장할 수 있습니다.

2. 제네릭 클래스와 메서드

제네릭 클래스

타입 매개변수를 정의하여 다양한 타입을 다룰 수 있습니다.

public class Box<T> {
    private T item;

    public void setItem(T item) {
        this.item = item;
    }

    public T getItem() {
        return item;
    }
}

제네릭 클래스는 여러 타입을 유연하게 처리할 수 있는 데이터 구조나 기능이 필요할 때 사용됩니다. 예를 들어, List, Map, Set과 같은 컬렉션 클래스들은 제네릭을 사용해 다양한 타입의 객체를 처리할 수 있습니다.

Box<String> stringBox = new Box<>();
stringBox.setItem("Hello");
System.out.println(stringBox.getItem());

Box<Integer> integerBox = new Box<>();
integerBox.setItem(123);
System.out.println(integerBox.getItem());

제네릭 메서드

메서드 수준에서 타입 매개변수를 정의합니다.

public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.print(element + " ");
    }
    System.out.println();
}

클래스 전체가 아닌 특정 메서드에서만 제네릭 타입이 필요할 때 사용됩니다. 같은 기능을 하는 메서드가 여러 타입의 인자를 받아야 할 경우 유용합니다.

Integer[] intArray = {1, 2, 3};
String[] stringArray = {"Hello", "World"};
printArray(intArray);
printArray(stringArray);

3. 와일드카드와 경계 설정

상한 경계 (<? extends T>): T 또는 그 하위 타입만 허용
하한 경계 (<? super T>): T 또는 그 상위 타입만 허용
무제한 와일드카드 (<?>): 모든 타입 허용

List<? extends Number> list = new ArrayList<Integer>();

4. 제네릭의 제한사항

기본 타입(primitive type) 사용 불가 (int 대신 Integer 사용)
정적(static) 멤버에 제네릭 타입 매개변수 사용 불가
타입 소거(Type Erasure)로 인해 런타임에 제네릭 타입 정보가 유지되지 않음
제네릭 타입의 배열 생성 불가 (new T[] 형태 사용 불가)

5. 예시

DAO (Data Access Object)

DAO 계층에서 제네릭을 사용하면 여러 엔티티 타입에 대해 재사용 가능한 데이터 접근 메서드를 구현할 수 있습니다.

public interface GenericDAO<T, ID> {
    T findById(ID id);
    List<T> findAll();
    void save(T entity);
    void update(T entity);
    void delete(ID id);
}

public class UserDAO implements GenericDAO<User, Long> {
    @Override
    public User findById(Long id) {
        // 구현 내용
    }

    @Override
    public List<User> findAll() {
        // 구현 내용
    }

    @Override
    public void save(User entity) {
        // 구현 내용
    }

    @Override
    public void update(User entity) {
        // 구현 내용
    }

    @Override
    public void delete(Long id) {
        // 구현 내용
    }
}

Service

서비스 계층에서 제네릭을 사용하면 다양한 비즈니스 엔티티에 대해 일관된 서비스 인터페이스를 제공할 수 있습니다.

public interface CRUDService<T, ID> {
    T findById(ID id);
    List<T> findAll();
    T save(T entity);
    T update(T entity);
    void delete(ID id);
}

public class UserService implements CRUDService<User, Long> {
    private final UserDAO userDAO;
    public UserService(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @Override
    public User findById(Long id) {
        return userDAO.findById(id);
    }

    @Override
    public List<User> findAll() {
        return userDAO.findAll();
    }

    @Override
    public User save(User entity) {
        userDAO.save(entity);
        return entity;
    }

    @Override
    public User update(User entity) {
        userDAO.update(entity);
        return entity;
    }

    @Override
    public void delete(Long id) {
        userDAO.delete(id);
    }
}

RestController

RestController에서 제네릭을 사용하면 다양한 타입의 요청과 응답을 처리하는 범용 컨트롤러를 구현할 수 있습니다.

@RestController
@RequestMapping("/api")
public class GenericController<T, ID> {

    private final CRUDService<T, ID> service;

    public GenericController(CRUDService<T, ID> service) {
        this.service = service;
    }

    @GetMapping("/{id}")
    public ResponseEntity<T> getById(@PathVariable ID id) {
        T entity = service.findById(id);
        return ResponseEntity.ok(entity);
    }

    @GetMapping
    public ResponseEntity<List<T>> getAll() {
        List<T> entities = service.findAll();
        return ResponseEntity.ok(entities);
    }

    @PostMapping
    public ResponseEntity<T> create(@RequestBody T entity) {
        T savedEntity = service.save(entity);
        return ResponseEntity.status(HttpStatus.CREATED).body(savedEntity);
    }

    @PutMapping("/{id}")
    public ResponseEntity<T> update(@PathVariable ID id, @RequestBody T entity) {
        T updatedEntity = service.update(entity);
        return ResponseEntity.ok(updatedEntity);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> delete(@PathVariable ID id) {
        service.delete(id);
        return ResponseEntity.noContent().build();
    }
}

// 사용 예시
@RestController
@RequestMapping("/api/users")
public class UserController extends GenericController<User, Long> {
    public UserController(UserService userService) {
        super(userService);
    }
}

각 계층에서 제네릭을 적절히 활용하면 더 유연하고 확장 가능한 코드를 작성할 수 있습니다. 하지만 예시코드와 같이 제네릭의 사용은 코드의 복잡성을 증가시킵니다.

Future Engineering