본문 바로가기
Spring/JPA

[JPA] MyBatis와 동시 사용 (DTO/엔티티 통합, 연관관계 매핑)

by J4J 2021. 3. 31.
300x250
반응형

안녕하세요. J4J입니다.

 

이번 포스팅은 DTO/엔티티를 통합하여 JPA와 MyBatis를 동시 사용하는 설정에 대해 적어보는 시간을 가져보려고 합니다.

 

 

 

 

이전 포스팅에서는 DTO/엔티티를 분리하여 JPA와 MyBatis를 위한 클래스들이 독립적으로 되어있도록 구현해봤습니다.

 

하지만 이런 방법으로 구현했을 땐 데이터베이스에 매핑되는 클래스들을 JPA와 MyBatis 각각 1개씩 생성해줘야 됩니다.

 

그렇기 때문에 이번 포스팅에서는 DTO와 엔티티를 통합하여 하나의 클래스만 생성해보도록 하겠습니다.

 

 

추가적으로 MyBatis를 간단하게 사용해보신 분들은 엔티티끼리 연관관계 매핑이 되어 클래스 변수에 객체가 있을 경우 mapper에서 객체를 조회하는 방법에 대해 모르실 수 있습니다.

 

연관관계 매핑이 되어있을 때 설정방법까지 다뤄보도록 하겠습니다.

 

 

이번 주제도 이전 포스팅에 사용했던 도서로 할 것이고 추가적으로 도서를 소유하고 있는 사용자도 생성해보겠습니다.

 

도서와 사용자의 관계는 n:1로 사용자마다 한 개의 도서를 소유하고 있다고 가정하겠습니다.

 

 

프로젝트 설정 (공통)

 

[ 1. MySQL에 테이블 / 데이터 생성 ]

 

create table book (
    book_id int auto_increment,
    name varchar(50),
    price int, 
    publisher varchar(50),
    primary key(book_id)
);

insert into book(name, price, publisher) values ('자바 ORM 표준 JPA 프로그래밍', 38700, '에어콘출판');
insert into book(name, price, publisher) values ('배워서 바로 쓰는 스프링 프레임워크', 45000, '한빛미디어');


create table person (
    person_id int auto_increment,
    name varchar(50),
    book_id int,
    primary key(person_id)
);

insert into person(name, book_id) values('김꺽정', 3);
insert into person(name, book_id) values('김계란', 4);
insert into person(name, book_id) values('정바보', 3);
insert into person(name, book_id) values('이사용', 4);
insert into person(name, book_id) values('사이다', 3);

 

 

[ 2. pom.xml에 maven 설정 ]

 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">

	...
    
	<properties>
        <java-version>1.8</java-version>
        <org.springframework-version>5.2.11.RELEASE</org.springframework-version>
        <org.aspectj-version>1.9.6</org.aspectj-version>
        <org.slf4j-version>1.7.30</org.slf4j-version>
	</properties>
	<dependencies>
		<!-- DB Dependency -->
		<dependency> <!-- 스프링에서 DB처리를 위한 dependency -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		
		<dependency> <!-- MySQL 사용을 위한 dependency -->
		    <groupId>mysql</groupId>
		    <artifactId>mysql-connector-java</artifactId>
		    <version>8.0.22</version>
		</dependency>
		
		<dependency> <!-- 커넥션풀을 위한 dependency -->
		    <groupId>org.apache.commons</groupId>
		    <artifactId>commons-dbcp2</artifactId>
		    <version>2.8.0</version>
		</dependency>
		
		<dependency> <!-- JPA 사용을 위한 Dependency -->
		    <groupId>org.springframework.data</groupId>
		    <artifactId>spring-data-jpa</artifactId>
		    <version>2.2.5.RELEASE</version>
		</dependency>
		
		<dependency> <!-- JPA 사용을 위한 Dependency -->
		    <groupId>org.hibernate</groupId>
		    <artifactId>hibernate-entitymanager</artifactId>
		    <version>5.4.10.Final</version>
		</dependency>
		
		<dependency> <!-- MyBatis 사용을 위한 dependency -->
		    <groupId>org.mybatis</groupId>
		    <artifactId>mybatis</artifactId>
		    <version>3.5.6</version>
		</dependency>
		
		<dependency> <!-- 스프링에서 MyBatis 사용을 위한 dependency -->
		    <groupId>org.mybatis</groupId>
		    <artifactId>mybatis-spring</artifactId>
		    <version>2.0.6</version>
		</dependency>
		
		<dependency> <!-- 트랜잭션 처리를 위한 dependency -->
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		
		<!-- Lombok -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<version>1.18.12</version>
			<scope>provided</scope>
		</dependency>
		
		<!-- Test -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>
	
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${org.springframework-version}</version>
			<scope>test</scope>
		</dependency>   
				
		...
        
	</dependencies>

	...
    
</project>

 

 

반응형

 

 

[ 3. 자바 설정을 위해 web.xml에서 context-param 수정 ]

 

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee https://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

	<!-- 자바설정으로 변경 -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>com.spring.jpa_mybatis.config.RootContext</param-value>
	</context-param>

	<context-param>
		<param-name>contextClass</param-name>
		<param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
	</context-param>
    
	...
    
</web-app>

 

 

[ 4. RootContext 클래스 생성 ]

 

package com.spring.jpa_mybatis.config;

import org.apache.commons.dbcp2.BasicDataSource;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.data.transaction.ChainedTransactionManager;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableJpaRepositories("com.spring.jpa_mybatis.repository") // JPA 사용을 위한 패키지 탐색
@MapperScan("com.spring.jpa_mybatis.repository") // MyBatis 사용을 위한 패키지 탐색
public class RootContext {
	
	// DB 정보
	@Bean
	public BasicDataSource dataSource() {
		BasicDataSource datasource = new BasicDataSource();
		datasource.setDriverClassName("com.mysql.cj.jdbc.Driver");
		datasource.setUrl("jdbc:mysql://localhost:3306/jpa?serverTimezone=UTC");
		datasource.setUsername("root");
		datasource.setPassword("root");
		
		return datasource;
	}
	
	// jpa 설정
	@Bean
	public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
		LocalContainerEntityManagerFactoryBean entityManagerFactory = new LocalContainerEntityManagerFactoryBean();
		entityManagerFactory.setDataSource(dataSource());
		entityManagerFactory.setPersistenceUnitName("jpa-mysql"); // persistence.xml의 설정 정의된 이름
		entityManagerFactory.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
		
		return entityManagerFactory;
	}
	
	// mybatis 사용을 위한 sessionFactory bean 등록
	@Bean
	public SqlSessionFactoryBean sqlSessionFactory() throws Exception {
		SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
		sqlSessionFactory.setDataSource(dataSource());
		sqlSessionFactory.setConfigLocation(new PathMatchingResourcePatternResolver().getResource("classpath:mybatis-config.xml")); // mybatis 설정파일 등록
		return sqlSessionFactory;
	}
   
	// mybatis 사용을 위한 sqlSession bean 등록
	@Bean
	public SqlSessionTemplate sqlSession(SqlSessionFactoryBean sqlsessionFactory) throws Exception {
		return new SqlSessionTemplate(sqlsessionFactory.getObject());
	}
	
	// transactional 설정
	@Bean
	public PlatformTransactionManager transactionManager() throws Exception {
		// MyBatis transactional
		DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
		dataSourceTransactionManager.setDataSource(dataSource());
		
		// JPA transactional
		JpaTransactionManager jpaTransactionManager = new JpaTransactionManager();
		jpaTransactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
		
		// Chained transaction manager (MyBatis X JPA)
		ChainedTransactionManager transactionManager = new ChainedTransactionManager(jpaTransactionManager, dataSourceTransactionManager);
		return transactionManager;
	}
}

 

 

[ 5. Book, Person 엔티티 클래스 생성 ]

 

package com.spring.jpa_mybatis.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "book")
public class Book implements Serializable {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "book_id")
	private int id;
	
	private String name;
	private int price;
	private String publisher;
}

 

package com.spring.jpa_mybatis.entity;

import java.io.Serializable;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
@Table(name = "person")
public class Person implements Serializable {
	
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "person_id")
	private int id;
	private String name;
	
	@ManyToOne
	@JoinColumn(name = "book_id")
	private Book book;
}

 

 

728x90

 

 

프로젝트 설정 (JPA)

 

[ 1. JPA설정을 위한 persistence.xml 파일 생성 (src/main/resources/META-INF/persistence.xml) ]

 

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
	xmlns="http://xmlns.jcp.org/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
	<persistence-unit name="jpa-mysql"> <!-- 이름 -->
		<properties>
			<property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect" /> <!-- DB고유 기능 사용 -->
			<property name="hibernate.show_sql" value="true" /> <!-- 콘솔창에 실행되는 SQL문 출력 -->
			<property name="hibernate.format_sql" value="true" /> <!-- SQL출력시 보기 쉽게 정렬 -->
			<property name="hibernate.use_sql_comments" value="true" /> <!-- SQL출력 시 주석도 같이 출력 -->
			<property name="hibernate.id.new_generator_mappings" value="true" /> <!-- JPA표준에 맞춘 새로운 키 생성 전략 설정 -->
		</properties>
	</persistence-unit>
</persistence>

 

 

[ 2. JpaRepositry 생성 ]

 

package com.spring.jpa_mybatis.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import com.spring.jpa_mybatis.entity.Book;

public interface BookJpaRepository extends JpaRepository<Book, Integer>{
	
}

 

 

package com.spring.jpa_mybatis.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import com.spring.jpa_mybatis.entity.Person;

public interface PersonJpaRepository extends JpaRepository<Person, Integer>{

}

 

 

프로젝트 설정 (MyBatis)

 

[ 1. MyBatis설정을 위한 mybatis-config.xml 파일 생성 (src/main/resources/mybatis-config.xml) ]

 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<settings>
		<setting name="mapUnderscoreToCamelCase" value="true"/> <!-- 카멜케이스 적용 -->
	</settings>

	<typeAliases>
		<typeAlias type="com.spring.jpa_mybatis.entity.Book" alias="book"/> <!-- Book클래스 alias 등록 -->
		<typeAlias type="com.spring.jpa_mybatis.entity.Person" alias="person"/> <!-- Person클래스 alias 등록 -->
	</typeAliases>
	
	<mappers>
		<mapper resource="mapper/bookmapper.xml" /> <!-- book 매퍼 등록 -->
		<mapper resource="mapper/personmapper.xml" /> <!-- person 매퍼 등록 -->
	</mappers>
</configuration>

 

 

[ 2. bookmapper 생성 (src/main/resources/mapper/bookmapper.xml) ]

 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.spring.jpa_mybatis.repository.BookRepository">
	<select id="selectAll" resultType="book">
		select book_id as id, 
			   name as name,
			   price as price,
			   publisher as publisher
		from book
	</select>

	<select id="selectByBookId" parameterType="int" resultType="book">
		select book_id as id, 
			   name as name,
			   price as price,
			   publisher as publisher
		from book
		where book_id = #{value}
	</select>
</mapper>

 

 

[ 3. personmapper 생성 (src/main/resources/mapper/personmapper.xml) ]

 

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.spring.jpa_mybatis.repository.PersonRepository">
	<select id="selectAll" resultMap="selectMap">
		select person_id as id,
			   name as name,
			   book_id as book_id
		from person
	</select>

	<resultMap type="person" id="selectMap">
		<id property="id" column="id"/> <!-- DB에서 조회된 id(column)를 클래스 변수 id(property)에 매핑 -->
		<id property="name" column="name"/> <!-- DB에서 조회된 name(column)을 클래스 변수 name(property)에 매핑 -->
		<collection property="book" column="book_id" select="com.spring.jpa_mybatis.repository.BookRepository.selectByBookId" /> <!-- DB에서 조회된 book_id(column)를 select로 조회하여 book(property)에 매핑 -->
	</resultMap>
</mapper>

 

 

엔티티 클래스의 변수로 되어 있는 Book클래스에 대한 값을 조회하기 위해서는 위와 같이 resultMap을 이용하시면 됩니다.

 

만약 select구문의 쿼리에 사용되는 파라미터 값이 2개 이상일 때는 다음과 같이 하시면 됩니다.

 

// bookmapper.xml
<!-- 파라미터타입은 없어도 되지만 재사용을 위해 기입, 또한 변수명도 book에 들어있는 변수와 통일해주기 -->
<select id="selectByBook" parameterType="book" resultType="book">
	select book_id as id, 
		   name as name,
		   price as price,
		   publisher as publisher
	from book
	where book_id = #{id}
	  and name = #{name}
</select>


// personmapper.xml
<resultMap type="person" id="selectMap">
	<id property="id" column="id"/> <!-- DB에서 조회된 id(column)를 클래스 변수 id(property)에 매핑 -->
	<!-- name이 book의 name이 아니라 person의 name이라고 가정한다면 -->
	<collection property="book" column="{id=book_id, name=name}" select="com.spring.jpa_mybatis.repository.BookRepository.selectByBook" /> DB에서 조회된 book_id, name(column)을 select로 조회하여 book(property)에 매핑
</resultMap>

 

 

[ 4. Repository 생성 ]

 

package com.spring.jpa_mybatis.repository;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.spring.jpa_mybatis.entity.Book;

@Mapper
public interface BookRepository {

	public List<Book> selectAll();
	
	public Book selectByBookId(int bookId);
	
}

 

package com.spring.jpa_mybatis.repository;

import java.util.List;

import org.apache.ibatis.annotations.Mapper;

import com.spring.jpa_mybatis.entity.Person;

@Mapper
public interface PersonRepository {
	
	public List<Person> selectAll();
}

 

 

 

 

단위 테스트

 

우선 MyBatis에서 실행되는 쿼리문을 출력하기 위해 테스트를 위한 로그 출력 단계를 debug로 설정하겠습니다.

 

테스트용이니 src/test/resources/log4j.xml에서 수정하시면 됩니다.

 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration PUBLIC "-//APACHE//DTD LOG4J 1.2//EN" "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">

	...
    
	<!-- Application Loggers -->
	<logger name="com.spring.jpa_mybatis">
		<level value="debug" /> <!-- 로그 출력 단계 변경 -->
	</logger>
    
	...
    
</log4j:configuration>

 

 

먼저 book에 대한 정보를 조회해보겠습니다.

 

package com.spring.jpa_mybatis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import com.spring.jpa_mybatis.config.RootContext;
import com.spring.jpa_mybatis.repository.BookJpaRepository;
import com.spring.jpa_mybatis.repository.BookRepository;

import lombok.extern.slf4j.Slf4j;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = RootContext.class)
@Slf4j
public class bookTest {
	
	@Autowired
	BookJpaRepository bookJpaRepository; // jpa
	
	@Autowired
	BookRepository bookRepository; // mybatis
	
	@Test
	public void combine_test() {
		log.debug(bookJpaRepository.findAll().toString());
		log.debug(bookRepository.selectAll().toString());
	}
}

 

 

위와 같이 코드를 작성하고 테스트를 진행하면 다음과 같이 조회되는것을 확인할 수 있습니다.

 

Hibernate: 
    /* select
        generatedAlias0 
    from
        Book as generatedAlias0 */ select
            book0_.book_id as book_id1_0_,
            book0_.name as name2_0_,
            book0_.price as price3_0_,
            book0_.publisher as publishe4_0_ 
        from
            book book0_
DEBUG: com.spring.jpa_mybatis.bookTest - [Book(id=3, name=자바 ORM 표준 JPA 프로그래밍, price=38700, publisher=에어콘출판), Book(id=4, name=배워서 바로 쓰는 스프링 프레임워크, price=45000, publisher=한빛미디어)]
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectAll - ==>  Preparing: select book_id as id, name as name, price as price, publisher as publisher from book
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectAll - ==> Parameters: 
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectAll - <==      Total: 2
DEBUG: com.spring.jpa_mybatis.bookTest - [Book(id=3, name=자바 ORM 표준 JPA 프로그래밍, price=38700, publisher=에어콘출판), Book(id=4, name=배워서 바로 쓰는 스프링 프레임워크, price=45000, publisher=한빛미디어)]

 

 

이번엔 person에 대한 정보를 조회해보겠습니다.

 

package com.spring.jpa_mybatis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import com.spring.jpa_mybatis.config.RootContext;
import com.spring.jpa_mybatis.repository.PersonJpaRepository;
import com.spring.jpa_mybatis.repository.PersonRepository;

import lombok.extern.slf4j.Slf4j;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = RootContext.class)
@Slf4j
public class bookTest {

	@Autowired
	PersonJpaRepository personJpaRepository; // jpa
	
	@Autowired
	PersonRepository personRepository; // mybatis
	
	@Test
	public void combine_test() {
		log.debug(personJpaRepository.findAll().toString());
		log.debug(personRepository.selectAll().toString());
	}
}

 

 

코드를 작성하고 실행하면 다음과 같이 MyBatis도 JPA와 동일하게 Person안에 Book객체가 같이 조회되는 것을 확인할 수 있습니다.

 

Hibernate: 
    /* select
        generatedAlias0 
    from
        Person as generatedAlias0 */ select
            person0_.person_id as person_i1_1_,
            person0_.book_id as book_id3_1_,
            person0_.name as name2_1_ 
        from
            person person0_
Hibernate: 
    select
        book0_.book_id as book_id1_0_0_,
        book0_.name as name2_0_0_,
        book0_.price as price3_0_0_,
        book0_.publisher as publishe4_0_0_ 
    from
        book book0_ 
    where
        book0_.book_id=?
Hibernate: 
    select
        book0_.book_id as book_id1_0_0_,
        book0_.name as name2_0_0_,
        book0_.price as price3_0_0_,
        book0_.publisher as publishe4_0_0_ 
    from
        book book0_ 
    where
        book0_.book_id=?
DEBUG: com.spring.jpa_mybatis.bookTest - [Person(id=1, name=김꺽정, book=Book(id=3, name=자바 ORM 표준 JPA 프로그래밍, price=38700, publisher=에어콘출판)), Person(id=2, name=김계란, book=Book(id=4, name=배워서 바로 쓰는 스프링 프레임워크, price=45000, publisher=한빛미디어)), Person(id=3, name=정바보, book=Book(id=3, name=자바 ORM 표준 JPA 프로그래밍, price=38700, publisher=에어콘출판)), Person(id=4, name=이사용, book=Book(id=4, name=배워서 바로 쓰는 스프링 프레임워크, price=45000, publisher=한빛미디어)), Person(id=5, name=사이다, book=Book(id=3, name=자바 ORM 표준 JPA 프로그래밍, price=38700, publisher=에어콘출판))]
DEBUG: com.spring.jpa_mybatis.repository.PersonRepository.selectAll - ==>  Preparing: select person_id as id, name as name, book_id as book_id from person
DEBUG: com.spring.jpa_mybatis.repository.PersonRepository.selectAll - ==> Parameters: 
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectByBookId - ====>  Preparing: select book_id as id, name as name, price as price, publisher as publisher from book where book_id = ?
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectByBookId - ====> Parameters: 3(Integer)
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectByBookId - <====      Total: 1
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectByBookId - ====>  Preparing: select book_id as id, name as name, price as price, publisher as publisher from book where book_id = ?
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectByBookId - ====> Parameters: 4(Integer)
DEBUG: com.spring.jpa_mybatis.repository.BookRepository.selectByBookId - <====      Total: 1
DEBUG: com.spring.jpa_mybatis.repository.PersonRepository.selectAll - <==      Total: 5
DEBUG: com.spring.jpa_mybatis.bookTest - [Person(id=1, name=김꺽정, book=Book(id=3, name=자바 ORM 표준 JPA 프로그래밍, price=38700, publisher=에어콘출판)), Person(id=2, name=김계란, book=Book(id=4, name=배워서 바로 쓰는 스프링 프레임워크, price=45000, publisher=한빛미디어)), Person(id=3, name=정바보, book=Book(id=3, name=자바 ORM 표준 JPA 프로그래밍, price=38700, publisher=에어콘출판)), Person(id=4, name=이사용, book=Book(id=4, name=배워서 바로 쓰는 스프링 프레임워크, price=45000, publisher=한빛미디어)), Person(id=5, name=사이다, book=Book(id=3, name=자바 ORM 표준 JPA 프로그래밍, price=38700, publisher=에어콘출판))]

 

 

 

 

이상으로 DTO/엔티티를 통합하여 JPA와 MyBatis를 동시 사용하는 설정에 대해 간단하게 알아보는 시간이었습니다.

 

읽어주셔서 감사합니다.

 

728x90
반응형
저작자표시 비영리 변경금지

'Spring > JPA' 카테고리의 다른 글

[JPA] MapStruct, Entity ↔ DTO 변환  (1) 2021.04.03
[JPA] ModelMapper, Entity ↔ DTO 변환  (0) 2021.04.01
[JPA] MyBatis와 동시 사용 (DTO/엔티티 분리)  (7) 2021.03.30
[JPA] @Query, 직접 쿼리 작성  (1) 2021.03.29
[JPA] 연관관계 매핑 (양방향)  (0) 2021.03.28

관련글

  • [JPA] MapStruct, Entity ↔ DTO 변환
  • [JPA] ModelMapper, Entity ↔ DTO 변환
  • [JPA] MyBatis와 동시 사용 (DTO/엔티티 분리)
  • [JPA] @Query, 직접 쿼리 작성

댓글

티스토리툴바