Spring에서 자주는 주는 확장방식들

우리가 Spring하면 IOC(제어반전)와 AOP(절단면 지향 프로그래밍)가 가장 먼저 떠오를 수 있다.

스프링의 base 이고 훌륭한 디자인 덕분에 스프링이 많은 framework들 중에서도 남다른 인기를 장기간 이어 왔었다.

그 외에도 spring을 사용시 유연한 확장력장점 때문에 spring은 스펀지마냥 또다른 제3자 애플리케이션을 품?에 쉽게 끌어안을수 있는것이다. rocketmq, mybatis, redis 등등...

이번 글에서는  spring 에서 가장 많이 쓰이는 11가지 확장점에 대해 알아보자.

---

1. 커스텀 인터셉터(Interceptor)

---

SpringMVC interceptor 는 Spring interceptor에 비해 HttpServletRequest, HttpServletResponse 등 웹 객체 인스턴스를 가져올 수 있다. Spring mvc interceptor의  최상위 인터페이스는 HandlerInterceptor 이며 내무 함수는 아래와 같다.

• preHandle 타겟 메서드가 실행되기 전에
• postHandle 타겟 메서드를 실행한 후
• afterCompletion 요청을 완료할 때 실행.

HandlerInterceptorAdapter 추상 클래스를 오버라이딩하여 구현 . 권한 인증, 로그, 통계구현 등 케이스에서 interceptor를 사용해볼만하다.

• step1: HandlerInterceptorAdapter 정의 

public class AuthInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        String requestUrl = request.getRequestURI();
        if (checkAuth(requestUrl)) {
            return true;
        }

        return false;
    }

    private boolean checkAuth(String requestUrl) {
        System.out.println("권한인증");
        return true;
    }
}

• step2:  정의된 Interceptor 를 빈에 등록

@Configuration
public class WebAuthConfig extends WebMvcConfigurerAdapter {
 
    @Bean
    public AuthInterceptor getAuthInterceptor() {
        return new AuthInterceptor();
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new AuthInterceptor());
    }
}

2. 빈객체 얻는 3가지

BeanFactoryAware 사용하기 

@Service
public class PersonService implements BeanFactoryAware {
    private BeanFactory beanFactory;

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }

    public void add() {
        Person person = (Person) beanFactory.getBean("person");
    }
}

ApplicationContextAwar 사용하기 

@Service
public class PersonService2 implements ApplicationContextAware {
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    public void add() {
        Person person = (Person) applicationContext.getBean("person");
    }
}

ApplicationListener 사용하기

@Service
public class PersonService3 implements ApplicationListener<ContextRefreshedEvent> {
    private ApplicationContext applicationContext;
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        applicationContext = event.getApplicationContext();
    }

    public void add() {
        Person person = (Person) applicationContext.getBean("person");
    }
}

3. global Exception 처리

---

아래의 심플한 코드가 있다.

@RequestMapping("/test")
@RestController
public class TestController {

    @GetMapping("/add")
    public String add() {
        int a = 10 / 0;
        return "성공";
    }
}

성공여부에 따른 분기처리를 아래와같이 자주 한다.

@GetMapping("/add")
public String add() {
    String result = "성공";
    try {
        int a = 10 / 0;
    } catch (Exception e) {
        result = "data exception!";
    }
    return result;
}

 

 

뭐 이거 하나만 처리한다고 치면 괜찮은 코드인듯 싶다. 하지만 controller가 수십개, 수백게 되면 이런 처리를 일일해주기는에는 너무 큰 노가다 일뿐다. Spring에서 기막한 어노테이션을 지원한다. 바로 RestControllerAdvice 이다. 이름만 봐도 어느정도 예측가능하다. 아래 코드를 보자.

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(Exception.class)
    public String handleException(Exception e) {
        if (e instanceof ArithmeticException) {
            return "data Exception!";
        }
        if (e instanceof Exception) {
            return "Service Intenerl Error!";
        }
        retur nnull;
    }
}

처음 이 기능을 보고 1주일 변비가 뻥뚤린 기분이였다.

 

4. 클래스 유형 전환

Spring 은 3가지 타입전환방식이 있다.

Converter<S,T>：S 를 T로 전환.

ConverterFactory<S, R>：S를 R의 자식클래스로 전환

GenericConverter：정교한 Converter구현이 필요한 경우, GenericConverter 사용한다.

step1: 샘플 domain 생성

@Data
public class User {

    private Long id;
    private String name;
    private Date registerDate;
}

step2: 구현

public class DateConverter implements Converter<String, Date> {

    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Override
    public Date convert(String source) {
        if (source != null && !"".equals(source)) {
            try {
                simpleDateFormat.parse(source);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

step3: 정의된 클래스 전화객체를 빈에 등록한다.

@Configuration
public class WebConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addFormatters(FormatterRegistry registry) {
        registry.addConverter(new DateConverter());
    }
}

step4: 사용해보기 

@RequestMapping("/user")
@RestController
public class UserController {

    @RequestMapping("/save")
    public String save(@RequestBody User user) {
        return "success";
    }
}

---

5. Config import 하기

5.1 일반클래스

public class A {
}

@Import(A.class)
@Configuration
public class TestConfiguration {
}

@Import 로 A 클래스를 주입하면 , spring은 자동으로 A클래스에 대하여 객체를 생성할것이고. 따라서 @Autowired 를 이용하여 주입하면 된다.

@Autowired
private A a;

어 ? @Bean 하지 않고도 객체 생성 가능하네...

5.2 config 클래스

해당 import 방식은 제일 복잡하다. 왜냐면 @Configuration 주입은 기타 다른 주입방식을 겹쳐서 사용하는걸 지원하기 때문이다. 아래처럼 말이다.

public class A {
}

public class B {
}

@Import(B.class)
@Configuration
public class AConfiguration {

    @Bean
    public A a() {
        return new A();
    }
}

@Import(AConfiguration.class)
@Configuration
public class TestConfiguration {
}

5.3 ImportSelector

해당방식은 ImportSelector 인터페이스를 구현해야 한다.

public class AImportSelector implements ImportSelector {

private static final String CLASS_NAME = "com.sue.cache.service.test13.A";
    
 public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{CLASS_NAME};
    }
}

@Import(AImportSelector.class)
@Configuration
public class TestConfiguration {
}

이 방식의 장점은 리턴이 배열로 되어 있어 여러개를 동시에 import 할수 있다는것.

5.4 ImportBeanDefinitionRegistrar

해당방식은 ImportBeanDefinitionRegistrar 인터페이스를 구현한다.

public class AImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(A.class);
        registry.registerBeanDefinition("a", rootBeanDefinition);
    }
}

@Import(AImportBeanDefinitionRegistrar.class)
@Configuration
public class TestConfiguration {
}

registerBeanDefinitions 에서 BeanDefinitionRegistry 의 등록객체를 얻을수 있다. 때문에 BeanDefinition 수동으로 생성 & 등록을 조작할수 있다.

---

6. 프로젝트 실행시

일반적으로 우리는 그냥 기본 실행을 하지만 필요시 해당 프로젝트의 설정대로 시작해야 하는 경도 있다 . 예를 들ㅇ면 시스템설정,로컬캐쉬 , 초기화 등 설정을 해야 하는 경우도 있다. Spring은 CommandLineRunner 과 ApplicationRunner 를 제공한다.

@Component
public class TestRunner implements ApplicationRunner {

    @Autowired
    private LoadDataService loadDataService;

    public void run(ApplicationArguments args) throws Exception {
        loadDataService.load();
    }
}

ApplicationRunner 를 구현하여 run() 메서드를 재정의 하면 된다.

만일 프로젝트에 ApplicationRunner 가 여러개 면 @Order(n) 나 @Priority 로 순서를 지정할수 있다.

---

7.BeanDefinition

Spring IOC 에서 bean을 초기화 하기전에 BeanDefinitionReader가  bean 들의 정보를 읽는다. 이때 BeanDefinition 객체에 저장하고 이것을 이용해 bean 을 생성하게 된다.

그럼 BeanDefinition 의 속성를 수정하려면??

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory) configurableListableBeanFactory;
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);
        beanDefinitionBuilder.addPropertyValue("id", 123);
        beanDefinitionBuilder.addPropertyValue("name", "hi this kim");
        defaultListableBeanFactory.registerBeanDefinition("user", beanDefinitionBuilder.getBeanDefinition());
    }
}

postProcessBeanFactory 메서드에서 BeanDefinition 관련 객체를 얻을수 있고 그걸 수정하면 된다.

8. Bean 초기화

가끔 Bean 들이 초기화 되고 난후 나의 로직을 끼워넣고 싶다 .이럴때 사용하는것이 바로 BeanPostProcessor 이다.

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof User) {
            ((User) bean).setUserName("hi this kim!");
        }
        return bean;
    }
}

• postProcessBeforeInitialization 초기화 전 호출 됨.
• postProcessAfterInitialization  초기화 후 호출 됨.

9. 초기화 방법

9.1 @PostConstruct 사용하기

@Service
public class AService {
    @PostConstruct
    public void init() {
        System.out.println("===초기화===");
    }
}

9.2 InitializingBean 인터페이스 구현

@Service
public class BService implements InitializingBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("===초기화===");
    }
}

10. 컨테이너 닫기

DisposableBean 인터페이스를 구현하고 destroy()를 재정의 한다.

@Service
public class DService implements InitializingBean, DisposableBean {
 
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean destroy");
    }
 
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean afterPropertiesSet");
    }
}

11. 사용자 정의 도메인

동일 스레드의 spring 컨테이너에서 생성도니 빈은 하나! 로 하고 싶을 경우??

step1: scope 인터페이스 구현 

public class ThreadLocalScope implements Scope {
    private static final ThreadLocal THREAD_LOCAL_SCOPE = new ThreadLocal();

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Object value = THREAD_LOCAL_SCOPE.get();
        if (value != null) {
            return value;
        }

        Object object = objectFactory.getObject();
        THREAD_LOCAL_SCOPE.set(object);
        return object;
    }

    @Override
    public Object remove(String name) {
        THREAD_LOCAL_SCOPE.remove();
        return null;
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
    }

    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }

    @Override
    public String getConversationId() {
        return null;
    }
}

step2: 새로 정의한 scope를 spring 컨테이너에 등록

@Component
public class ThreadLocalBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        beanFactory.registerScope("threadLocalScope", new ThreadLocalScope());
    }
}

setp3: 새로정의한 scope 사용

@Scope("threadLocalScope")
@Service
public class CService {
    public void add() {
    }
}

 

끝!