[Java] Spring과 Mybatis 연동

BoardServiceImpl -> BoardDAOBatis 로 연동

----------------------- 설명 --------------------------------------

BoardServiceImpl -> DB 연동, BoardDaoMybatis 활용

BoardDaoMyBatis (Autowired로 주입)

[프레임워크로 제공] -> bean 등록 필수

SqlSessionTemplate -> BoardDaoMybatis는 mybatis Container로 활용

SqlSessionFactoryBean -> mybatis Container로 활용하기 위한 공장

BasicDataSource -> 어떻게 연결할지 데이터소스 정보(H2)

BoardServiceImpl: 서비스 레이어에서 비즈니스 로직을 처리하며, BoardDAOMyBatis 객체를 통해 데이터 접근 계층과 연결됩니다. Spring의 @Autowired 어노테이션을 사용하여 DAO가 자동으로 주입됩니다.
BoardDAOMyBatis: MyBatis를 사용하여 데이터베이스와 상호작용하는 DAO(Data Access Object)입니다. SQL 문을 실행하고 결과를 반환하는 역할을 합니다.
SqlSessionTemplate: MyBatis와 Spring을 통합하는 핵심 클래스입니다. 실제로 SQL 쿼리를 실행하고 트랜잭션을 관리하는 역할을 합니다. DAO에서 SqlSessionTemplate을 사용하여 데이터베이스 작업을 수행합니다.
SqlSessionFactoryBean: SqlSessionTemplate이 사용될 수 있도록 SqlSession 객체를 생성하는 팩토리 역할을 합니다. MyBatis 설정 파일 등을 바탕으로 세션을 생성합니다.
BasicDataSource: 실제로 데이터베이스와 연결을 관리하는 데이터 소스입니다. JDBC 연결을 설정하고, 커넥션 풀을 관리하는 역할을 합니다. 여기서 H2 데이터베이스와 연결되어 있는 것을 볼 수 있습니다.

이 과정에서 action-servlet.xml은 Spring MVC에서 기본적인 설정 파일입니다. 이 파일은 Spring 애플리케이션 컨텍스트를 설정하고, 서비스와 DAO 등의 빈(bean)들이 어떻게 주입될지를 정의합니다.

이 흐름에서 주의해야 할 점은, Spring이 의존성 주입(DI)을 통해 각 레이어(Service, DAO 등)를 연결하고, MyBatis가 SQL 문을 실행하는 중간 역할을 한다는 것입니다.

의존성 주입

의존성 주입(Dependency Injection, DI)은 Spring에서 객체 간의 의존 관계를 설정하고 주입하는 방식입니다. 즉, 객체를 직접 생성하는 대신, 필요한 객체를 외부에서 주입받도록 하는 설계 패턴입니다. Spring에서는 주로 XML 설정 파일이나 어노테이션 기반으로 의존성을 주입할 수 있습니다.

다이어그램에서 나타난 의존성 주입 과정과 함께, 간단한 예시로 설명드리겠습니다.

1. XML 설정을 통한 의존성 주입

Spring에서는 applicationContext.xml 또는 action-servlet.xml 같은 설정 파일을 통해 각 빈(Bean)과 그 의존성을 정의할 수 있습니다. 예를 들어, BoardServiceImpl이 BoardDAOMyBatis를 의존할 때 XML에서 이를 다음과 같이 설정할 수 있습니다.

<!-- DAO 빈 정의 -->
<bean id="boardDAOMyBatis" class="com.example.BoardDAOMyBatis">
    <!-- 필요시 DataSource나 SqlSessionTemplate을 주입 -->
</bean>

<!-- 서비스 빈 정의 -->
<bean id="boardServiceImpl" class="com.example.BoardServiceImpl">
    <!-- 의존성 주입 -->
    <property name="boardDAO" ref="boardDAOMyBatis" />
</bean>

위의 XML에서 BoardServiceImpl 클래스는 BoardDAOMyBatis를 의존하고 있으며, ref="boardDAOMyBatis"을 통해 BoardDAOMyBatis 빈이 주입됩니다. 이 방식으로 각 객체가 생성될 때 Spring이 필요한 객체를 자동으로 주입합니다.

2. 어노테이션 기반 의존성 주입

Spring 3.x 이상부터는 어노테이션을 사용한 방식이 많이 사용됩니다. 어노테이션 기반 DI에서는 주로 @Autowired, @Service, @Repository 등을 사용하여 의존성을 주입할 수 있습니다. 각 계층 간의 의존성 주입은 자동으로 이루어지며, XML 설정 없이 간편하게 구현할 수 있습니다.

예시:

// BoardServiceImpl.java
@Service
public class BoardServiceImpl {
    
    // @Autowired 어노테이션으로 의존성 주입
    @Autowired
    private BoardDAOMyBatis boardDAO;

    public void someServiceMethod() {
        // DAO를 통해 데이터베이스 작업 수행
        boardDAO.getData();
    }
}

// BoardDAOMyBatis.java
@Repository
public class BoardDAOMyBatis {

    @Autowired
    private SqlSessionTemplate sqlSessionTemplate;

    public List<Object> getData() {
        // MyBatis를 통해 데이터베이스에서 데이터를 가져옴
        return sqlSessionTemplate.selectList("namespace.queryId");
    }
}

@Service: 해당 클래스를 서비스 레이어로 정의하며 Spring이 관리하는 빈으로 등록됩니다.
@Autowired: Spring이 BoardServiceImpl 객체를 생성할 때 BoardDAOMyBatis를 자동으로 주입해 줍니다. 마찬가지로 BoardDAOMyBatis도 SqlSessionTemplate 객체를 주입받습니다.
@Repository: 해당 클래스를 DAO로 정의하며 데이터 접근 계층으로 사용됩니다.

의존성 주입 과정

Spring 애플리케이션이 시작될 때, Spring 컨테이너는 XML 설정 파일 또는 어노테이션을 기반으로 빈을 생성합니다.
Spring은 빈 간의 의존 관계를 분석하고, 필요한 의존 객체를 자동으로 주입합니다.
- XML에서는 <property> 태그로 명시적으로 주입.
- 어노테이션 방식에서는 @Autowired를 통해 자동으로 의존성을 주입.
각 레이어 간에 필요한 객체들이 자동으로 연결되면서 비즈니스 로직과 데이터 접근 로직이 결합됩니다.

결론

Spring에서의 의존성 주입은 객체 간의 강한 결합을 줄이고, 유연성과 테스트 용이성을 높여줍니다. 특히 어노테이션 기반 DI 방식은 XML 설정을 줄이고, 코드의 가독성과 유지보수성을 향상시킵니다.

	<!-- Spring과 MyBatis를 연동하기 위한 설정 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value=""/>
		<property name="url"             value=""/>
		<property name="username"        value=""/>
		<property name="password"        value=""/>
	</bean>
	
	<bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:sql-map-config.xml"/>
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	<bean class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg ref="sqlSession"/>
	</bean>

BoardServiceImpl.class

// Source code is decompiled from a .class file using FernFlower decompiler.
package com.multicampus.biz.board;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("boardService")
public class BoardServiceImpl implements BoardService {
   @Autowired
   private BoardDAOMyBatis boardDAO;

   public BoardServiceImpl() {
   }

   public void insertBoard(BoardVO vo) {
      this.boardDAO.insertBoard(vo);
   }

   public void updateBoard(BoardVO vo) {
      this.boardDAO.updateBoard(vo);
   }

   public void deleteBoard(BoardVO vo) {
      this.boardDAO.deleteBoard(vo);
   }

   public BoardVO getBoard(BoardVO vo) {
      return this.boardDAO.getBoard(vo);
   }

   public List<BoardVO> getBoardList(BoardVO vo) {
      return this.boardDAO.getBoardList(vo);
   }
}

BoardDAOMybatis.class

package com.multicampus.controller.user;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import com.multicampus.biz.user.UserDAO;
import com.multicampus.biz.user.UserVO;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

public class LoginController implements Controller {
	
	@Override
	public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
		System.out.println("로그인 처리");
		
		// 1. 사용자 입력정보 추출
		String id = request.getParameter("id");
		String password = request.getParameter("password");
		
		// 2. DB 연동 처리
		UserVO vo = new UserVO();
		vo.setId(id);
		vo.setPassword(password);
		
		UserDAO dao = new UserDAO();
		UserVO user = dao.getUser(vo);
		
		// 3. 화면 이동
		// 이동할 화면 정보를 ModelAndView에 담아서 리턴하면 해당 화면으로 이동한다.
		ModelAndView mav = new ModelAndView();
		if(user != null) {
			mav.setViewName("getBoardList.do");
		} else {
			mav.setViewName("login.jsp");
		}
		return mav;
	}

}

board-mapper.xml

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "https://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="Board">

	<insert id="insertBoard" parameterType="board">
		insert into board(seq, title, writer, content) 
		values((select nvl(max(seq), 0)+1 from board), #{title}, #{writer}, #{content})
	</insert>
	
	<update id="updateBoard" parameterType="board">
		update board set title=#{title}, content=#{content} where seq=#{seq}
	</update>
	
	<delete id="deleteBoard" parameterType="board">
		delete board where seq=#{seq}
	</delete>
	
	<select id="getBoard" parameterType="board" resultType="board">
		select * from board where seq=#{seq}
	</select>
	
	<select id="getBoardList" resultType="board">
		select * from board order by seq desc
	</select>
</mapper>

sql-map-config

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "https://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

	<!-- mapper XML 파일에서 사용할 Alias들을 등록한다. -->
	<typeAliases>
		<typeAlias type="com.multicampus.biz.board.BoardVO" alias="board"/>
	</typeAliases>

	<!-- 작성된 모든 mapper XML 파일들을 등록한다. -->
	<mappers>
		<mapper resource="mappers/board-mapper.xml" />
	</mappers>
</configuration>

action-servlet.xml

<?xml version="1.0" encoding="UTF-8"?>
<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.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

	<context:component-scan base-package="com.multicampus"/>
	
	<!-- Spring과 MyBatis를 연동하기 위한 설정 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
		<property name="driverClassName" value="org.h2.Driver"/>
		<property name="url"             value="jdbc:h2:tcp://localhost/~/test"/>
		<property name="username"        value="sa"/>
		<property name="password"        value=""/>
	</bean>
	
	<bean id="sqlSession" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="configLocation" value="classpath:sql-map-config.xml"/>
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	<bean class="org.mybatis.spring.SqlSessionTemplate">
		<constructor-arg ref="sqlSession"/>
	</bean>
	
	<!-- ViewResolver 클래스를 등록한다 
		ViewResolver는 Controller 메소드가 리턴하는 View 이름 앞에 접두사(prefix)를 붙여준다.
	-->
	<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/board/"/>
	</bean>

	<!-- 모든 Controller 클래스를 등록한다 
	<bean id="login"        class="com.multicampus.controller.user.LoginController"/>
	<bean id="insertBoard"  class="com.multicampus.controller.board.InsertBoardController"/>
	<bean id="updateBoard"  class="com.multicampus.controller.board.UpdateBoardController"/>
	<bean id="deleteBoard"  class="com.multicampus.controller.board.DeleteBoardController"/>
	<bean id="getBoard"     class="com.multicampus.controller.board.GetBoardController"/>
	<bean id="getBoardList" class="com.multicampus.controller.board.GetBoardListController"/>
	-->
	
	<!-- HandlerMapping을 등록한다 
	<bean id="handlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
		<property name="mappings">
			<props>
				<prop key="/login.do">login</prop>
				<prop key="/insertBoard.do">insertBoard</prop>
				<prop key="/updateBoard.do">updateBoard</prop>
				<prop key="/deleteBoard.do">deleteBoard</prop>
				<prop key="/getBoard.do">getBoard</prop>
				<prop key="/getBoardList.do">getBoardList</prop>
			</props>
		</property>
	</bean>
	-->
	
</beans>

action-servlet.xml -> bean 등록

action-servlet.xml 파일은 Spring MVC에서 DispatcherServlet에 의해 로드되는 Spring Web MVC 설정 파일입니다. 이 파일은 Spring MVC에서 URL 요청을 처리하는 여러 컴포넌트(컨트롤러, 뷰 리졸버, 빈 설정 등)를 정의하는 데 사용됩니다. 주로 Spring MVC 애플리케이션에서 **컨트롤러(Controller)**와 뷰(View) 간의 연결을 설정하는 역할을 합니다.

이 파일은 주로 XML 기반 설정을 사용할 때 쓰이며, Spring 4.x 이상부터는 Java 기반 설정을 권장하고 있지만, 여전히 XML 설정 방식도 많이 사용되고 있습니다.

기본적인 action-servlet.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:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       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
           http://www.springframework.org/schema/mvc
           http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- Spring MVC의 기본 설정 -->
    <mvc:annotation-driven />

    <!-- 컨트롤러 컴포넌트 스캔 -->
    <context:component-scan base-package="com.example.controller" />

    <!-- View Resolver 설정 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/views/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <!-- 메시지 리소스 설정 (다국어 처리 시 사용) -->
    <bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
        <property name="basename" value="messages" />
    </bean>

    <!-- 정적 자원 핸들러 설정 (CSS, JS, 이미지 등) -->
    <mvc:resources mapping="/resources/**" location="/resources/" />

</beans>

구성 요소 설명

<mvc:annotation-driven />:
- Spring MVC의 애노테이션 기반 설정을 활성화합니다.
- @Controller, @RequestMapping 등을 사용하여 컨트롤러를 설정할 때 필요합니다.
- 요청을 처리하는 다양한 핸들러 매핑과 어댑터를 등록하고, 데이터 바인딩, 포맷팅, 유효성 검사 등의 기능을 활성화합니다.
<context:component-scan base-package="com.example.controller" />:
- 스프링이 컨트롤러를 스캔하는 패키지를 지정합니다.
- 지정한 패키지 내의 @Controller, @Service, @Repository 등 애노테이션이 붙은 클래스를 자동으로 Bean으로 등록합니다.
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">:
- View Resolver 설정입니다. 이 설정을 통해 뷰 파일(예: JSP)의 경로와 파일 확장자를 정의합니다.
- prefix는 뷰 파일이 위치한 디렉터리 경로를 설정하고, suffix는 파일 확장자를 설정합니다.
- 예를 들어, 컨트롤러에서 return "home";을 하면, Spring은 /WEB-INF/views/home.jsp 파일을 찾아서 렌더링합니다.
메시지 리소스 설정 (messageSource):
- 다국어 처리를 위해 메시지 파일(messages.properties)을 로드할 수 있도록 설정합니다.
- 여러 나라의 언어로 애플리케이션을 지원할 때, 이 설정을 통해 메시지를 적절히 변경할 수 있습니다.
정적 자원 핸들러 (<mvc:resources />):
- CSS, JavaScript, 이미지 파일 등 정적 자원을 요청할 때 매핑하는 경로를 설정합니다.
- 예를 들어, /resources/**로 들어오는 모든 요청을 /resources/ 디렉터리에서 찾도록 설정됩니다.

Spring MVC 설정 구조 설명

1. DispatcherServlet과 action-servlet.xml

DispatcherServlet은 Spring MVC의 핵심 서블릿으로, 모든 요청을 처리하는 중앙 제어 역할을 합니다.
action-servlet.xml은 이 DispatcherServlet에 의해 로드되며, 애플리케이션에서 URL 요청을 처리하는 데 필요한 설정(컨트롤러, 뷰 리졸버 등)이 정의됩니다.

2. 컨트롤러와 뷰 설정

컨트롤러: @Controller 애노테이션을 사용해 컨트롤러 클래스를 정의합니다. 이때 Spring은 action-servlet.xml에서 정의된 패키지(com.example.controller)를 스캔해 자동으로 컨트롤러를 Bean으로 등록합니다.
뷰 리졸버: 사용자가 요청한 경로에 해당하는 뷰 파일을 찾고 렌더링하는 역할을 합니다. 예를 들어, 사용자가 /home으로 요청하면, InternalResourceViewResolver는 /WEB-INF/views/home.jsp 파일을 찾아 반환합니다.

3. 애노테이션 기반 설정 (<mvc:annotation-driven />)

애노테이션 기반 요청 처리를 활성화합니다. @Controller, @RequestMapping, @GetMapping, @PostMapping 등을 사용할 수 있게 해줍니다.
Spring MVC는 이 설정을 통해 URL 요청을 적절한 컨트롤러 메서드에 매핑하고, 요청/응답을 처리할 수 있습니다.

action-servlet.xml과 Java Config 방식의 차이

Spring 3.x 이상에서는 Java Config 방식이 많이 사용됩니다. Java Config 방식에서는 XML 파일 대신 Java 클래스를 사용하여 Spring 설정을 합니다.

Java Config 방식 예시

@Configuration
@EnableWebMvc
@ComponentScan(basePackages = "com.example.controller")
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }

    @Bean
    public ResourceBundleMessageSource messageSource() {
        ResourceBundleMessageSource messageSource = new ResourceBundleMessageSource();
        messageSource.setBasename("messages");
        return messageSource;
    }

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/resources/**").addResourceLocations("/resources/");
    }
}

@Configuration: 이 클래스가 Spring 설정 클래스를 의미함을 나타냅니다.
@EnableWebMvc: 애노테이션 기반 Spring MVC 설정을 활성화합니다.
@ComponentScan: 지정한 패키지에서 Spring Bean을 스캔하여 등록합니다.
뷰 리졸버, 메시지 소스, 정적 자원 처리 등도 Java Config 방식으로 설정할 수 있습니다.

결론

action-servlet.xml은 Spring MVC 애플리케이션의 URL 요청을 처리하고, 컨트롤러와 뷰 간의 연결을 설정하는 데 사용되는 설정 파일입니다.
Spring에서는 XML 기반 설정과 Java Config 방식을 모두 지원하며, Java Config 방식이 더 선호되는 추세입니다.
Spring 4.x 이상에서는 Java Config 방식을 사용하면 XML 파일 없이도 유연하게 Spring 설정을 할 수 있으며, 코드 기반 설정이므로 유지보수와 관리가 더 용이합니다.

Bean 등록

Bean 등록은 Spring Framework에서 핵심적인 역할을 하는 개념으로, 애플리케이션에서 사용할 객체들을 Spring 컨테이너에서 관리하고, 필요한 곳에 주입해주는 역할을 합니다. Spring에서는 애플리케이션 내의 객체를 Bean이라고 부르며, Spring 컨테이너에 Bean 등록을 통해 객체의 생명 주기와 의존성을 관리할 수 있습니다.

Bean이란?

Bean은 Spring IoC (Inversion of Control) 컨테이너에서 관리되는 객체를 말합니다.
애플리케이션에서 필요한 객체(예: 서비스 클래스, DAO 클래스 등)를 Bean으로 등록해두면 Spring이 이를 자동으로 생성하고 관리합니다.
Spring 컨테이너는 Bean을 필요에 따라 생성, 초기화, 소멸 등의 과정을 제어합니다.

Bean 등록의 역할

Bean 등록의 주요 역할은 다음과 같습니다:

객체 생성 및 관리:
- Spring은 Bean으로 등록된 객체를 관리합니다. 즉, 객체를 필요에 따라 생성하고, 애플리케이션 전반에서 공유할 수 있게 합니다.
- 이를 통해 개발자는 직접 객체를 생성하지 않아도 되고, 객체 간의 의존성을 관리할 수 있습니다.
의존성 주입 (Dependency Injection):
- Bean으로 등록된 객체는 다른 Bean과의 의존성을 갖고 있을 수 있습니다. Spring은 필요한 의존성을 자동으로 주입하여 객체 간의 상호작용을 관리합니다.
- 예를 들어, 컨트롤러는 서비스 객체에 의존하고, 서비스는 DAO 객체에 의존하는 경우, Spring이 필요한 Bean들을 알아서 주입해줍니다.
IoC (Inversion of Control) 적용:
- Bean 등록을 통해 IoC 개념이 구현됩니다. IoC는 객체의 생성과 생명 주기를 애플리케이션 코드에서 직접 관리하는 대신, Spring 컨테이너가 관리하도록 하는 개념입니다.
- IoC를 통해 객체 간의 결합도를 낮추고, 유지보수와 테스트가 용이한 구조를 만들 수 있습니다.
Bean의 생명 주기 관리:
- Spring 컨테이너는 Bean의 생성부터 소멸까지의 생명 주기를 관리합니다.
- Bean은 생성될 때 초기화 메서드가 실행되고, 애플리케이션이 종료될 때 소멸 메서드를 호출하여 자원을 정리할 수 있습니다.

Bean 등록 방식

Bean 등록은 주로 세 가지 방식으로 이루어집니다:

XML 설정을 통한 Bean 등록:
- Spring의 초기 버전에서 사용되었던 방식으로, applicationContext.xml 같은 XML 파일에 Bean을 정의합니다.
- XML 파일에서 클래스와 의존성을 명시적으로 정의하는 방식입니다.
어노테이션을 통한 Bean 등록:
- Spring 2.5 이후로 도입된 방식으로, 클래스에 어노테이션을 사용하여 Bean으로 등록할 수 있습니다.
- 주로 @Component, @Service, @Repository, @Controller 등의 어노테이션을 사용합니다.
Java Config를 통한 Bean 등록:
- Spring 3.0 이후로 등장한 방식으로, Java 클래스를 사용하여 Bean을 등록할 수 있습니다.
- @Configuration과 @Bean 어노테이션을 사용하여 Bean을 정의합니다.

<bean id="myService" class="com.example.MyService">
    <property name="myDao" ref="myDao"/>
</bean>

<bean id="myDao" class="com.example.MyDao"/>

@Service
public class MyService {
    @Autowired
    private MyDao myDao;
}

@Configuration
public class AppConfig {

    @Bean
    public MyService myService() {
        return new MyService(myDao());
    }

    @Bean
    public MyDao myDao() {
        return new MyDao();
    }
}

Bean 등록의 예시

1. 의존성 주입 없이 객체 생성

Spring을 사용하지 않는 경우, 개발자가 객체를 직접 생성하고 의존성을 주입해야 합니다:

public class MyApp {
    public static void main(String[] args) {
        MyDao myDao = new MyDao();
        MyService myService = new MyService(myDao);
        myService.performTask();
    }
}

2. Bean 등록과 의존성 주입을 활용한 예시 (Spring 사용)

Spring을 사용하면 Bean 등록과 의존성 주입을 통해 객체 생성을 자동화할 수 있습니다:

@Service
public class MyService {
    @Autowired
    private MyDao myDao;

    public void performTask() {
        myDao.doSomething();
    }
}

@Repository
public class MyDao {
    public void doSomething() {
        System.out.println("Task performed.");
    }
}

// Application 설정 클래스
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

// 실행 클래스
public class MyApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.performTask();
    }
}

위 예시에서는 @Service, @Repository, @Autowired를 사용하여 MyService가 MyDao에 의존성을 갖고 있는 객체 관계를 설정하고, Spring 컨테이너가 이를 자동으로 관리합니다.

Bean 등록을 통한 장점

유지보수성: 의존성 주입을 통해 객체 간 결합도를 낮출 수 있어, 유지보수가 쉬워집니다.
재사용성: Spring 컨테이너가 관리하는 Bean은 싱글톤으로 동작하여 여러 곳에서 재사용 가능합니다.
확장성: 새로운 Bean을 쉽게 추가하고, 의존성을 유연하게 설정할 수 있어 애플리케이션 확장이 용이합니다.
테스트 용이성: Spring의 IoC와 의존성 주입은 테스트할 때 모의 객체(Mock)를 사용하기 쉽게 해줍니다.

결론

Bean 등록은 Spring이 객체의 생명 주기와 의존성을 관리할 수 있도록 돕는 중요한 메커니즘입니다. 이를 통해 애플리케이션이 더 유연하고 유지보수가 쉬운 구조로 변환되며, 객체 간 결합도를 낮추어 코드의 재사용성을 높입니다.

'개인 프로젝트 > Java Spring 프레임워크' 카테고리의 다른 글

[Board Project] Mybatis 활용, 기존 JDBC 방식과 비교 (0)	2024.10.18
[Board Project] Command 객체 활용 -> MVC 패턴 적용 (0)	2024.10.18
[Board Project] 테이블 구조 ->MVC 패턴 적용 (2)	2024.10.18
[Board Project] 테이블 구조 -> ServiceImpl, DAO, VO (0)	2024.10.17
[Java Spring] Login_Controller (0)	2024.10.17

Learning_EunBi

[Java] Spring과 Mybatis 연동

의존성 주입

1. XML 설정을 통한 의존성 주입

2. 어노테이션 기반 의존성 주입

예시:

의존성 주입 과정

결론

action-servlet.xml -> bean 등록

기본적인 action-servlet.xml 예시

구성 요소 설명

Spring MVC 설정 구조 설명

1. DispatcherServlet과 action-servlet.xml

2. 컨트롤러와 뷰 설정

3. 애노테이션 기반 설정 (<mvc:annotation-driven />)

action-servlet.xml과 Java Config 방식의 차이

Java Config 방식 예시

결론

Bean 등록

Bean이란?

Bean 등록의 역할

Bean 등록 방식

Bean 등록의 예시

1. 의존성 주입 없이 객체 생성

2. Bean 등록과 의존성 주입을 활용한 예시 (Spring 사용)

Bean 등록을 통한 장점

결론

'개인 프로젝트 > Java Spring 프레임워크' 카테고리의 다른 글

댓글

티스토리툴바

[Java] Spring과 Mybatis 연동

의존성 주입

1. XML 설정을 통한 의존성 주입

2. 어노테이션 기반 의존성 주입

예시:

의존성 주입 과정

결론

action-servlet.xml -> bean 등록

기본적인 action-servlet.xml 예시

구성 요소 설명

Spring MVC 설정 구조 설명

1. DispatcherServlet과 action-servlet.xml

2. 컨트롤러와 뷰 설정

3. 애노테이션 기반 설정 (<mvc:annotation-driven />)

action-servlet.xml과 Java Config 방식의 차이

Java Config 방식 예시

결론

Bean 등록

Bean이란?

Bean 등록의 역할

Bean 등록 방식

Bean 등록의 예시

1. 의존성 주입 없이 객체 생성

2. Bean 등록과 의존성 주입을 활용한 예시 (Spring 사용)

Bean 등록을 통한 장점

결론

'개인 프로젝트 > Java Spring 프레임워크' 카테고리의 다른 글

관련글

댓글

티스토리툴바