이미 현업에서 자주 사용하지만 따로 정리하지는 않아서 이번 기회에 공식 레퍼런스를 보며 내용을 정리해보았다.

스프링 트랜잭션 처리

스프링 공식 문서: 트랜잭션 관리

@Transactional 애노테이션은 인터페이스, 클래스, 또는 메서드에 트랜잭션의 의미를 부여하는 메타데이터이다. 예를 들어, "이 메서드가 호출될 때 새로운 읽기 전용 트랜잭션을 시작하고, 기존 트랜잭션은 일시 중지한다"는 의미를 가진다. @Transactional의 기본 설정은 다음과 같다:

• 전파(Propagation): PROPAGATION_REQUIRED
• 격리 수준(Isolation Level): ISOLATION_DEFAULT
• 읽기-쓰기(Read-Write) 모드: 트랜잭션은 기본적으로 읽기-쓰기 모드이다.
• 타임아웃(Timeout): 트랜잭션 타임아웃은 기본 트랜잭션 시스템의 기본값을 따르거나, 타임아웃을 지원하지 않을 경우 설정되지 않는다.
• 롤백 규칙(Rollback Rules): RuntimeException이나 그 하위 클래스가 발생하면 롤백이 트리거되며, 체크드 예외는 롤백을 트리거하지 않는다.

스프링 트랜잭션 처리 중 예외가 발생했을 때, 아래의 옵션들을 명시적으로 사용하여 롤백 여부를 결정할 수 있다:

• rollbackFor: 롤백을 실행시키는 예외 클래스 목록
• rollbackForClassName: 롤백을 실행시키는 예외 클래스 이름들
• noRollbackFor: 롤백을 실행시키지 않는 예외 클래스 목록
• noRollbackForClassName: 롤백을 실행시키지 않는 예외 클래스 이름들

예를 들어, 특정 체크드 예외에 대해서도 롤백을 원한다면 rollbackFor 옵션을 사용하여 설정할 수 있다.

자바와 스프링 트랜잭션 처리에 대한 오해

구글에서 "자바 트랜잭션 처리"로 검색해 보면 Checked Exception와 Unchecked Exception 에 대한 비교와 함께, 언체크드 예외에 대해 롤백이 수행된다는 내용을 많이 볼 수 있다.

하지만 이는 정확하지 않다. 자바에서는 기본적으로 트랜잭션에 대한 메커니즘을 제공하지 않으므로, 체크드 예외이든 언체크드 예외이든 트랜잭션의 롤백은 프로그래머가 직접 관리해야 한다. 즉, 언체크드 예외에 롤백하는 메커니즘은 스프링 프레임워크를 사용할 때 적용되는 기본 설정이지, 다른 프레임워크나 순수 자바 SDK만을 사용하여 DB 처리를 할 경우에는 해당되지 않는다.

이러한 오해는 자바와 스프링을 동일시하는 데에서 비롯되며, 자바 개발자들 사이에서 흔히 발생하는 잘못된 인식이라고 생각한다.

추가 설명

• 자바의 예외 처리: 자바는 예외를 체크드 예외와 언체크드 예외로 구분하지만, 이는 컴파일러가 예외 처리를 강제하는지 여부와 관련이 있다. 트랜잭션 롤백과는 직접적인 연관이 없다.
• 트랜잭션 관리: 순수 자바에서는 Connection 객체를 사용하여 수동으로 트랜잭션을 관리하며, 예외 발생 시 롤백을 직접 호출해야 한다.
• 스프링의 트랜잭션 관리: 스프링은 AOP를 활용하여 선언적인 트랜잭션 관리를 제공하며, 기본적으로 RuntimeException 발생 시 롤백을 수행한다. 필요에 따라 설정을 변경하여 체크드 예외에도 롤백이 가능하다.

하이버네이트는 내부적으로 두종류의 캐쉬를 지원하는데 하나는 First-level cache 이고 다른 한종류는 Second-level Cache 이다

First-level cache?

대부분의 ORM (Object Relational Mapping) 프레임워크가 지원하는것처럼 하이버네이트또한 일차적 캐쉬를 지원한다. 

일차캐쉬는 Hibernate 의 Session 단계에서 지원하는 캐쉬로 가장 비싼 연산작업중 하나인 데이터베이스와의 대화를 줄여주기 위해 존재한다. Session 안에서 동작하는 캐쉬이기 때문에 Session 이 종료되면 캐쉬도 같이 사라지게 된다.

Second-level cache?

First level cache 이 세션 단계에서의 캐쉬라면 second level cache 는 session factory 단계에서 지원하는 캐쉬로 session factory 에서 생성되는 session 간에 공유가 된다. 

표로 다시 정리하면

동시성 캐쉬 전략

Entity 에 대해 캐쉬 사용할때 샘플코드

@Entity(name = "Company")
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
public static class Company {

}

참조: 

1. https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html#caching

JPA를 사용해서 엔티티간의 관계를 설정할때 아래와 어노테이션을 작성하는 일이 많은데 어떤 의미를 가지고 있는지 알아보자

@OneToMany(cascade={CascadeType.REFRESH, CascadeType.MERGE}, fetch = FetchType.LAZY)

먼저 각각의 CaseType에 들어가기전에 영속성 컨텍스트와 JPA의 상태에 대한 선행지식이 필요하다

Persistence Conxtet (영속성 컨텍스트)

공식문서의 정의를 참조해보자 

A persistence context is a set of entity instances in which for any persistent entity identity there is a unique entity instance. Within the persistence context, the entity instances and their lifecycle are managed. The 
EntityManager
 API is used to create and remove persistent entity instances, to find entities by their primary key, and to query over entities.

어렵게 정의되어 있지만 간단하게 요약하자면 영속성 컨텍스트가 영속성 컨텍스트안에 있는 엔티티들의 변화를 추적하고 관리한다는 이야기다.

엔티티 객체의 상태

JPA의 동작들

Cascade 종류

JPA 표준에 사용하면 아래와 같이 6가지 Cascade Type 있다

하이버네이트에만 존재하는 CaseCade Type

참조:

1. https://docs.jboss.org/hibernate/orm/5.6/userguide/html_single/Hibernate_User_Guide.html

2. https://stackoverflow.com/questions/161224/what-are-the-differences-between-the-different-saving-methods-in-hibernate

어플리케이션을 구동하기 위해 사용되는 설정값들을 어플리케이션이 돌아가는 플랫폼안에서 보통 환경변수 혹은 파일안에 저장해두고 쓰는데 어플리케이션 설정값을 Zookeepr, AWS Secrets 과 같은 외부 서비스에서 불러들이거나 보안을 위해 설정값들을 메모리 안에서만 저장이 필요한 경우에 활용 가능한 방법이다.

Spring boot 에서 만 활용 가능한 방법

EnvironmentPostProcessor 를 활용

public class PriceCalculationEnvironmentPostProcessor implements EnvironmentPostProcessor {

    @Override
    public void postProcessEnvironment(ConfigurableEnvironment environment, 
      SpringApplication application) {
        PropertySource<?> system = environment.getPropertySources()
          .get(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME);

        Map<String, Object> prefixed = names.stream()
          .collect(Collectors.toMap(this::rename, system::getProperty));
        environment.getPropertySources()
          .addAfter(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, new MapPropertySource("prefixer", prefixed));
    }

}

Spring boot 와 Spring boot를 사용하지 않는 환경에서 활용 가능한 방법

ApplicationContextInitializer 를 활용한 방법

먼저 아래와 같이 프로퍼티 값을 오버라이드 하는 코드를 작성해준다.

public class PropertyOverrideContextInitializer
  implements ApplicationContextInitializer<ConfigurableApplicationContext> {
    @Override
    public void initialize(ConfigurableWebApplicationContext applicationContext) {
        ConfigurableEnvironment environment = applicationContext.getEnvironment();
        MyConfigProps configProps = Binder.get(environment).bind("my-config", MyConfigProps);
        System.out.println(configProps.getHomekey());
    }
  }

여기서 네가지 방법으로 어플리케이션에 적용 가능하다

1. web.xml 안에 있는 contextInitializerClasses 에 추가 혹은 상응하는 Java Config (Spring MVC)

    <context-param>
        <param-name>contextInitializerClasses</param-name>
        <param-value>com.xxxx.PropertyOverrideContextInitializer</param-value>
    </context-param>

자바로 설정시에 

@ContextConfiguration(initializers = PropertyOverrideContextInitializer.class)
public class AppConfig {

}

스프링만 사용시 

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
MyAppContextInitializer initializer = new MyAppContextInitializer();
initializer.initialize( ctx );

ctx.register( com.my.classpath.StackOverflowConfiguration.class );
ctx.refresh()

JobLauncher launcher = context.getBean(JobLauncher.class);

2. META-INF/spring.factories 추가하여 자동 설정 추가 (Spring Boot) 

org.springframework.context.ApplicationContextInitializer=
org.springframework.boot.context.PropertyOverrideContextInitializer

3. 어플리케이션 추가 실행코드에 추가코드에 추가하는 방법 (Spring boot)

application.addInitializers(PropertyOverrideContextInitializer.class);
application.run(args);

혹은

new SpringApplicationBuilder(YourApp.class)
    .initializers(PropertyOverrideContextInitializer.class);
    .run(args);

4. context.initializer.classes 프라퍼티 설정 (Spring boot)

context.initializer.classes=com.xxxx.PropertyOverrideContextInitializer

참조

1. https://www.baeldung.com/spring-tests-override-properties
2. https://stackoverflow.com/questions/35217354/how-to-add-custom-applicationcontextinitializer-to-a-spring-boot-application
3. https://stackoverflow.com/questions/35048164/spring-applicationcontextinitializer-and-properties
4. https://stackoverflow.com/questions/13288841/applicationcontextinitializer-in-a-non-web-spring-context

3.x 버전대가 2016년 12월을 기준으로 종료된다기에 기존 3.2.9 버전의 스프링에서 4.x 버전대로 마이그레이션을 시도하였다.

다행히도 기존 진행하는 프로젝트에서 3.x 

Pom.xml 에서 주의해서 

       <properties>
            <java-version>1.8</java-version>
            <org.springframework-version>4.3.5.RELEASE</org.springframework-version>
            <org.springframework-security-version>4.2.0.RELEASE</org.springframework-security-version>
        </properties>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>javax.servlet.jsp-api</artifactId>
            <version>2.3.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- MappingJacksonJsonView -->
<!--         <dependency> -->
<!--             <groupId>org.codehaus.jackson</groupId> -->
<!--             <artifactId>jackson-mapper-asl</artifactId> -->
<!--             <version>1.9.13</version> -->
<!--         </dependency> -->
         
<!--         <dependency> -->
<!--             <groupId>org.codehaus.jackson</groupId> -->
<!--             <artifactId>jackson-core-asl</artifactId> -->
<!--             <version>1.9.13</version> -->
<!--         </dependency> -->

다른 Configuration  파일들도 schemaLocation 부분에 수정을 해주었다. xxx-3.0.xsd 로 로된부분을

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    					http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context 
                        http://www.springframework.org/schema/context/spring-context-3.0.xsd">
        
</beans>

자동으로 인식하도록 숫자부분을 아래와 같이 변경했다.

http://www.springframework.org/schema/context/spring-context.xsd

resources 부분도 아래와 같이 변경했다.

<mvc:resources location="/public/" mapping="public/**"/>
<mvc:resources location="/css/" mapping="css/**"/>
<mvc:resources location="/images/" mapping="images/**"/>
<mvc:resources location="/js/" mapping="js/**"/>

JacksonJsonView를 사용하지 않기때문에 주석처리하였다 사용하기 위해서는 2버전을 사용해야한다.

<!--     <bean id="jsonView" class="org.springframework.web.servlet.view.json.MappingJacksonJsonView" />          -->

이렇게 하여 마이그레이션이 완료되었다.

마이그레이션은 프로젝트 마다 케이스바이 케이스기 떄문에 스프링버전에 의존하는 라이브러리가 없나 살펴보아야한다.

더 자세한 마이그레이션 관련은 아래에 링크된 스프링 공식홈페이지의 깃허브를 참조한다. 

참조:

1. https://github.com/spring-projects/spring-framework/wiki/Migrating-from-earlier-versions-of-the-spring-framework

Spring Profiles를 통한 환경별 설정

Spring에서는 spring.profiles.active라는 프로퍼티를 이용해 현재 활성화된 프로파일(환경)을 지정할 수 있습니다. 이를 활용하면 개발(development), 운영(production), 로컬(local) 등 다양한 환경마다 다른 설정파일을 로드하거나 다양한 빈 설정을 적용할 수 있습니다.

주의사항

• Maven Profile과는 별개의 개념이므로 혼동하지 않도록 주의하세요. Maven Profile은 빌드 시점에 적용되는 것이며, Spring Profile은 런타임 시점에 활성화되는 설정입니다.
  Maven Profile 설정은 관련 문서를 참고하세요.

프로파일 설정 방법

다음은 spring.profiles.active 값을 설정하는 여러 가지 방법입니다.

1. 빌드 시 JVM 프로퍼티를 통한 설정

    java -jar -Dspring.profiles.active=dev my-app.jar

   위와 같이 실행 시에 -D 옵션으로 프로파일을 지정할 수 있습니다.

2. web.xml을 통한 설정

   web.xml 파일 내 context-param을 통해 프로파일을 지정할 수 있습니다.

    <context-param>
        <param-name>spring.profiles.active</param-name>
        <param-value>production</param-value>
    </context-param>

3. Tomcat 기동 스크립트(catalina.sh)에서 설정

   catalina.sh 내 JAVA_OPTS 설정에 프로파일을 추가합니다.

    JAVA_OPTS="$JAVA_OPTS -Dspring.profiles.active=local"

4. Tomcat의 catalina.properties를 통한 설정

   catalina.properties 파일에 다음과 같이 추가할 수 있습니다. 이때 -D를 빼고 작성해야 합니다.

    spring.profiles.active=dev

중복된 설정에 대한 우선순위

경험적으로 확인한 결과, web.xml에 설정한 프로파일이 최우선적으로 적용됩니다. 즉, Tomcat 설정 파일 등에 프로파일이 지정되어 있더라도 web.xml이 우선하기 때문에, 웹 애플리케이션 내부에 지정된 프로파일이 있다면 외부 설정은 무시될 수 있습니다.

프로파일별 Properties 파일 로딩

spring.profiles.active에 따라 다른 properties 파일을 읽도록 설정할 수 있습니다. 예를 들어 development.properties, production.properties를 classpath 아래에 두고, 활성화된 프로파일에 따라 알맞은 파일을 로드하도록 할 수 있습니다.

아래 예제에서는 PropertiesFactoryBean을 사용하여 활성화된 프로파일에 맞춰 프로퍼티를 동적으로 로딩합니다.

<bean id="config" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
    <property name="locations">
        <list>
            <value>classpath:/#{systemProperties['spring.profiles.active']}.properties</value>
        </list>
    </property>
</bean>

예를 들어, spring.profiles.active=dev로 설정되어 있다면 dev.properties 파일을 로딩하게 됩니다.

추가 팁: 로컬(Spring) 환경 설정을 Tomcat에서 사용할 경우

로컬 개발 환경에서 Tomcat을 이용해 어플리케이션을 기동하는 경우에도 spring.profiles.active를 적용할 수 있습니다. 이 경우 Eclipse IDE에서 Tomcat 실행 환경 설정을 통해 프로파일을 지정하거나, 위에서 언급한 catalina.sh, catalina.properties 등을 활용할 수 있습니다.

참고 자료:

1. Setting spring.profile variable (StackOverflow)
2. jdm.kr 블로그 포스팅

위와 같이 Spring Profiles를 활용하면 환경별로 서로 다른 설정을 간편하게 관리할 수 있으며, 개발-테스트-운영 환경 전환 시 유연한 대응이 가능합니다.

스프링을 사용하다보면 webapps 폴더안에 파일들에 대해 접근해야할 필요가 있다. 

Servletcontext 를 이용한 접근 방법이 있으나 이방법은 Servletcontext 에 의존적이라는 단점이 있다. 

특정 동작만을 위한 모듈을 덧붙일 경우 다른 방법이 필요한데 스프링에서는 이방법 또한 제공한다. 바로 코드로 보자 

import java.io.IOException;
import java.io.InputStream;

import org.springframework.context.ResourceLoaderAware;
import org.springframework.core.io.Resource;
import org.springframework.core.io.ResourceLoader;

public class ArbitraryResourceLoader implements ResourceLoaderAware {
    private ResourceLoader resourceLoader;

    public void test() throws IOException {
        Resource resource = resourceLoader.getResource("file:webapps/config.txt");
    	InputStream is = resource.getInputStream();
    	try{
    		int i=0;
            while((i=is.read())!=-1)
            {
               char c=(char)i;
               System.out.print(c);
            }
        }catch(IOException e){
        	 e.printStackTrace();
         }finally{
            
           if(is!=null)
            is.close();
         }
    }

	@Override
	public void setResourceLoader( ResourceLoader resourceLoader) {
		this.resourceLoader = resourceLoader;		
	}

}

그리고 빈설정 파일에 아래와 같이 설정해준다 class 경로 같은 경우는 자기자신의 프로젝트에 따라 바뀔것이다

<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
 http://www.springframework.org/schema/context
 http://www.springframework.org/schema/context/spring-context-4.0.xsd">
 
	 <bean id="arbitraryResourceLoader" class="org.test.sample.ArbitraryResourceLoader"/>

</beans>

JavaConfig로도 쉽게 응용할수 있으리라 생각한다. 

프로젝트를 진행하다보면 파일안에 Properties 파일들을 저장해놓고 사용하는 일들이 자주 생긴다. 

가장 간단하게 사용하는 방법은 XML 혹은 JSON을 특정 경로에 넣고 파싱하는 방법이 있으나 설정파일을 사용하는 곳이 많아질 경우 복잡하다. 

스프링 프레임워크는 프레임워크 단에서 Properties 를 설정하는 방법을 가지고 있다.

Spring 설정 xml 안에 아래와 같은 설정을 추가한다. 

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc 
      http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
      http://www.springframework.org/schema/beans 
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
      http://www.springframework.org/schema/context 
      http://www.springframework.org/schema/context/spring-context-3.2.xsd">
	<context:component-scan base-package="com.tutorialspoint" />

	 <!-- context:property-placeholder location="classpath:database.properties"  /!-->
	<context:property-placeholder location="/WEB-INF/*.properties" />

</beans>

그럼 자동으로 WEB-INF 경로 아래에 있는 *.properties 밸류들이 로드된다.

스프링 내에서 사용하기 위해선 아래와 같이 사용한다.

@Component
class MyClass {
  @Value("${my.property.name}")
  private String[] myValues;
}

만약 위의 설정 방법이 안된다면 수동으로 빈을 생성해준다. 

<bean id="myProperties"
      class="org.springframework.beans.factory.config.PropertiesFactoryBean">
  <property name="locations">
    <list>
      <value>classpath*:my.properties</value>
    </list>
  </property>
</bean>

그리고 Resource 파일을 이용해서 불러들인다. 

@Component
class MyClass {
  @Resource(name="myProperties")
  private Properties myProperties;

  @PostConstruct
  public void init() {
    // do whatever you need with properties
  }
}

* 추가 

Project 진행시에 보통 개발, 테스트, 프로덕션 서버별로 배포를 다르게한다. 

각각의 환경마다 다른 설정값을 가지므로 배포시마다 사용하는 property 의 이름을 변경해주는 것은 여간 귀찮은 일이 아니다

다행이 스프링에서는 Profile 이라고 환경마다 다른 설정을 사용할수 있는 기능이 이미 내장되어있다. 

경로 부분을 지정해주고 ${spring.profiles.active} 코드를 넣어주면 Profile에 따라 설정값이 다르게 쓰인다. 

아래는 예제코드를 보면 profile 을 사용하시는 분들이라면 바로 이해가 갈것이다. 

<context:property-placeholder location="classpath:${spring.profiles.active}.properties" />

참고: 

1. http://jijs.tistory.com/entry/spring-%EC%84%A4%EC%A0%95-xml%EA%B3%BC-%EC%86%8C%EC%8A%A4%EC%BD%94%EB%93%9C%EC%97%90%EC%84%9C-properties-%EC%82%AC%EC%9A%A9%ED%95%98%EA%B8%B0

2. http://stackoverflow.com/questions/9259819/how-to-read-values-from-properties-file

3. http://nkjava.blogspot.kr/2013/07/springmvc-read-property-in-jsp.html

4. http://stackoverflow.com/questions/10669474/load-properties-file-in-spring-depending-on-profile

MyBatis를 Spring과 함께 사용할 경우, 기본 설정만으로도 대부분의 상황에 충분히 대응할 수 있습니다. 별도의 세부 설정이 필요한 경우를 제외하고는 디폴트 설정을 활용하는 편이 일반적입니다.

Spring에서는 MyBatis 설정을 자동으로 처리해주는 부분이 많기 때문에, SqlSessionFactoryBean에 mapper 위치 정도만 지정한 뒤 사용하는 경우가 잦습니다. 예를 들어, Spring의 기본 설정 파일을 아래와 같이 작성한 뒤, 매퍼 파일들을 resources/mapper 혹은 resources/mybatis와 같은 디렉토리에 배치할 수 있습니다. 여기서는 mapper 폴더 아래에 mybatis-config.xml을 두는 예시를 들어보겠습니다.

예시 설정 (mapper-config.xml)

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context.xsd">

    <!-- SqlSessionFactoryBean 설정 -->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <!-- MyBatis 기본 설정 파일 경로 지정 -->
        <property name="configLocation" value="classpath:/mapper/mybatis-config.xml"/>
        <!-- 매퍼 XML 파일 위치 지정 -->
        <property name="mapperLocations" value="classpath*:/mapper/**/*_SQL.xml"/>
    </bean>

    <!-- SqlSessionTemplate 설정 -->
    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSession"/>
    </bean>

    <!-- 매퍼 인터페이스 자동 스캐닝 설정 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="매퍼 인터페이스들이 위치한 패키지 경로"/>
    </bean>

</beans>

위 설정을 통해 Spring은 mybatis-config.xml을 기본 설정으로 사용하고, 해당 설정을 기반으로 매퍼 XML 파일(*_SQL.xml)들을 자동으로 로딩합니다. 또한, MapperScannerConfigurer를 이용해 매퍼 인터페이스를 빈으로 등록하므로, @Autowired 등을 통해 손쉽게 매퍼를 주입받아 사용할 수 있습니다.

mybatis-config.xml 예시

아래는 classpath:/mapper 디렉토리 하위에 mybatis-config.xml을 두고, 추가적인 설정(예: 타입 핸들러 등록)을 하는 예시입니다.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:mybatis="http://mybatis.org/schema/mybatis-spring"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="configLocation" value="classpath:/mapper/mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath*:/mapper/**/*_SQL.xml"/>
    </bean>

    <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg index="0" ref="sqlSession"/>
    </bean>

    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="매퍼 인터페이스 패키지"/>
    </bean>

    <!-- 타입 핸들러 등록 예시 -->
    <typeHandlers>
        <typeHandler handler="org.mybatis.example.ExampleTypeHandler"/>
    </typeHandlers>

</beans>

위와 같이 설정을 완료하면 Spring과 MyBatis를 연동하는 과정이 간소화되며, 기본 설정과 자동화된 매퍼 스캔 기능을 통해 빠르고 간편한 개발 환경을 구축할 수 있습니다.

이클립스 기준 톰캣 7.x 버전으로 설정

CENTOS 기준

$CATALINA_HOME/catalina.bat 파일 안에 

CATALINA_OPTS="-Xdebug -Xrunjdwp:transport=dt_socket,address=8000,server=y,suspend=n"

JPDA_OPTS="-agentlib:jdwp=transport=dt_socket,address=8000,server=y,suspend=n"

* 중요 

카탈리나 아래명령어와 함께 재실행

catalina.sh jpda start

안에 위에것을 추가해주고 톰캣을 재시작해준다. 

* 8000은 자기 포트번호에 맞게 변경한다.

* 당연한 이야기지만 서버측에서도 포트번호 8000번을 열어주어야한다. 보안이 강화된 환경에서 라우터 또는 방화벽에서 포트번호를 막을수도 있다. 필자는 이것때문에 원인을 찾지 못하고 삽질을.. 

이제 이클립스를 설정해주어야한다.

Run - Debug Configurations 

Remote Java Application 항목에서 오른쪽 클릭후 New를 클릭해준다

Project를 디버깅하고자는 프로젝트를 선택하고

서버가 존재하는 아이피를 클릭하고

위에 카탈리나 bat파일에서 입력한 포트번호를 입력한다

설정완료 후 Debug 버튼을 클릭하면 디버깅 Perspective 로 전환되는 것을 볼수 있다.

참고자료:

http://wonzopein.com/56

http://bryan7.tistory.com/143

http://stackoverflow.com/questions/3835612/remote-debugging-tomcat-with-eclipse