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