devkuma – MyBatis

MyBatis | What Is MyBatis?

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

MyBatis is a persistence framework that connects SQL and Java objects.

It was previously developed as one of the Apache projects under the name iBATIS. However, development by the Apache Software Foundation stopped in June 2010, and it is now developed under the name MyBatis.

It is useful when you want complete control over SQL statements.

Reference Site

http://www.mybatis.org/mybatis-3/ko/

MyBatis | Configuration File

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

MyBatis | Output Executed SQL to the Log

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

When you add the logback dependency, SQL is output at the DEBUG level.

build.gradle

compile 'ch.qos.logback:logback-classic:1.1.3'

Log output

18:10:01.123 [main] DEBUG sample.mybatis.selectTest - ==>  Preparing: select * from test_table where id=? and id=? 
18:10:01.151 [main] DEBUG sample.mybatis.selectTest - ==> Parameters: 1(Integer), 1(Integer)
18:10:01.165 [main] DEBUG sample.mybatis.selectTest - <==      Total: 1

The executed SQL and the bound parameters are output.

Because the executed SQL statement ID (sample.mybatis.selectTest) is used as the logger name, log output can be controlled by using the statement ID.

MyBatis

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

MyBatis is a development framework that helps make relational database programming in Java, an object-oriented language, easier. This section explains its basic usage.

MyBatis SELECT Queries

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

This section explains SELECT, which is used to retrieve data.

MyBatis | Map Search Results to an Arbitrary Java Object

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

MyBatis | INSERT Registration

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

This section explains INSERT, which is used to register data.

MyBatis | UPDATE Changes

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

Database Table Before the Change

test_table

id	value
1	hoge
2	fuga
3	piyo

Source Code

TestTable.java

package sample.mybatis;

public class TestTable {
    private int id;
    private String value;

    public TestTable(int id, String value) {
        this.id = id;
        this.value = value;
    }
}

sample_mapper.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="sample.mybatis">

  <update id="updateTest">
    update test_table
       set value = #{value}
     where id = #{id}
  </update>
</mapper>

Main.java

package sample.mybatis;

import java.io.InputStream;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Main {

    public static void main(String[] args) throws Exception {
        try (InputStream in = Main.class.getResourceAsStream("/mybatis-config.xml")) {
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

            try (SqlSession session = factory.openSession()) {
                TestTable table = new TestTable(1, "update");

                session.insert("sample.mybatis.updateTest", table);
                session.commit();
            }
        }
    }
}

Execution Result

[DEBUG] s.m.updateTest  - ==>  Preparing: update test_table set value = ? where id = ? 
[DEBUG] s.m.updateTest  - ==> Parameters: update(String), 1(Integer)
[DEBUG] s.m.updateTest  - <==    Updates: 1

test_table

id	value
1	update
2	fuga
3	piyo

Description

UPDATE can be defined with the <update> tag.

MyBatis | DELETE

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

Database Table Before Deletion

test_table

id	value
1	hoge
2	fuga
3	piyo

Source Code

TestTable.java

package sample.mybatis;

public class TestTable {
    private int id;
    private String value;

    public TestTable(int id) {
        this.id = id;
    }
}

sample_mapper.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="sample.mybatis">

  <delete id="deleteTest">
    delete from test_table where id = #{id}
  </delete>
</mapper>

Main.java

package sample.mybatis;

import java.io.InputStream;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Main {

    public static void main(String[] args) throws Exception {
        try (InputStream in = Main.class.getResourceAsStream("/mybatis-config.xml")) {
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

            try (SqlSession session = factory.openSession()) {
                TestTable table = new TestTable(2);

                session.insert("sample.mybatis.deleteTest", table);
                session.commit();
            }
        }
    }
}

Execution Result

[DEBUG] s.m.deleteTest  - ==>  Preparing: delete from test_table where id = ? 
[DEBUG] s.m.deleteTest  - ==> Parameters: 2(Integer)
[DEBUG] s.m.deleteTest  - <==    Updates: 1

test_table

id	value
1	hoge
3	piyo

Description

A DELETE statement can be defined with the <delete> tag.

MyBatis | Batch Updates

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

By default, each time SQL is executed, a PreparedStatement is created and the SQL is sent to the database.

When there are many updates, this is very inefficient.

Depending on the configuration, MyBatis can reuse PreparedStatement instances and perform batch updates.

Default Behavior

Source Code

sample_mapper.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="sample.mybatis">

  <insert id="insertTest">
    insert into test_table (value) values (#{value})
  </insert>
</mapper>

Main.java

package sample.mybatis;

import java.io.InputStream;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Main {

    public static void main(String[] args) throws Exception {
        try (InputStream in = Main.class.getResourceAsStream("/mybatis-config.xml")) {
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

            try (SqlSession session = factory.openSession()) {
                for (int i=0; i<3; i++) {
                    TestTable t = new TestTable("value-" + i);
                    int updateCount = session.insert("sample.mybatis.insertTest", t);
                    System.out.println("updateCount = " + updateCount);
                }

                session.commit();
            }
        }
    }
}

This implementation repeats INSERT three times.

Execution Result

[DEBUG] s.m.insertTest  - ==>  Preparing: insert into test_table (value) values (?) 
[DEBUG] s.m.insertTest  - ==> Parameters: value-0(String)
[DEBUG] s.m.insertTest  - <==    Updates: 1
updateCount = 1
[DEBUG] s.m.insertTest  - ==>  Preparing: insert into test_table (value) values (?) 
[DEBUG] s.m.insertTest  - ==> Parameters: value-1(String)
[DEBUG] s.m.insertTest  - <==    Updates: 1
updateCount = 1
[DEBUG] s.m.insertTest  - ==>  Preparing: insert into test_table (value) values (?) 
[DEBUG] s.m.insertTest  - ==> Parameters: value-2(String)
[DEBUG] s.m.insertTest  - <==    Updates: 1
updateCount = 1

Description

A PreparedStatement is created and SQL is sent every time.

Reuse PreparedStatement

Source Code

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="defaultExecutorType" value="REUSE"/>
  </settings>

  ...
</configuration>

Execution Result

[DEBUG] s.m.insertTest  - ==>  Preparing: insert into test_table (value) values (?) 
[DEBUG] s.m.insertTest  - ==> Parameters: value-0(String)
[DEBUG] s.m.insertTest  - <==    Updates: 1
updateCount = 1
[DEBUG] s.m.insertTest  - ==> Parameters: value-1(String)
[DEBUG] s.m.insertTest  - <==    Updates: 1
updateCount = 1
[DEBUG] s.m.insertTest  - ==> Parameters: value-2(String)
[DEBUG] s.m.insertTest  - <==    Updates: 1
updateCount = 1

Description

Set defaultExecutorType to REUSE in the configuration file.
The PreparedStatement is created only once.
SQL is still sent every time.

Batch Execution

Source Code

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="defaultExecutorType" value="BATCH"/>
  </settings>

  ...
</configuration>

Execution Result

[DEBUG] s.m.insertTest  - ==>  Preparing: insert into test_table (value) values (?) 
[DEBUG] s.m.insertTest  - ==> Parameters: value-0(String)
updateCount = -2147482646
[DEBUG] s.m.insertTest  - ==> Parameters: value-1(String)
updateCount = -2147482646
[DEBUG] s.m.insertTest  - ==> Parameters: value-2(String)
updateCount = -2147482646

Description

Setting defaultExecutorType to BATCH performs batch updates.
SQL is sent together at the end.
As a result, the update count cannot be obtained.

Specify It When Obtaining SqlSession

The setting that determines whether to use batch updates can be specified as an argument when obtaining a SqlSession.

import org.apache.ibatis.session.ExecutorType;

...

SqlSession session = factory.openSession(ExecutorType.BATCH);

You can specify it by passing ExecutorType to the argument of openSession(). The condition specified here takes precedence over the configuration file.

MyBatis | Mapper

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

So far, SQL has been executed by passing the statement ID and parameters directly to SqlSession.

Separately from this, MyBatis also provides a structure called Mapper. Using Mapper is safer than using SqlSession directly.

In general, it is better to use Mapper. Because mapping files are automatically grouped by Mapper, they are also easier to manage.

MyBatis | Dynamic SQL

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

SQL that matches the conditions can be generated dynamically.

MyBatis | Dynamically Generate SQL in a Program

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

MyBatis provides a way to define SQL by using annotations.

However, when assembling SQL through string concatenation, there are many details to watch for, such as comma separation and AND or OR separation.

MyBatis provides an API that hides those tedious details.

Source Code

sample_mapper.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="sample.mybatis.TestTableMapper"> <!-- Specify Mapper in the namespace -->
</mapper>

TestTableMapper.java

package sample.mybatis;

import java.util.List;

import org.apache.ibatis.annotations.SelectProvider;

// Create it as a Mapper interface
public interface TestTableMapper {
    // Specify the class method that generates SQL with @SelectProvider
    @SelectProvider(type=TestTableSqlProvider.class, method="getSelectTestSql")
    List<TestTable> selectTest();
}

TestTableSqlProvider.java

package sample.mybatis;

import org.apache.ibatis.jdbc.SQL;

// Class that generates SQL
public class TestTableSqlProvider {

    // Method that generates SQL
    public String getSelectTestSql() {
        // Generate SQL by using the SQL class.
        SQL sql = new SQL() {{ // Create an anonymous class
            SELECT("id, hoge_value");
            SELECT("fuga_value");
            SELECT("piyo_value");
            FROM("test_table");
        }};

        return sql.toString();
    }
}

Main.java

package sample.mybatis;

import java.io.InputStream;

import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class Main {

    public static void main(String[] args) throws Exception {
        try (InputStream in = Main.class.getResourceAsStream("/mybatis-config.xml")) {
            SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);

            try (SqlSession session = factory.openSession()) {
                TestTableMapper mapper = session.getMapper(TestTableMapper.class);
                mapper.selectTest();
            }
        }
    }
}

Execution Result

[DEBUG] s.m.T.selectTest - ==>  Preparing: SELECT id, hoge_value, fuga_value, piyo_value FROM test_table WHERE (hoge_value is not null) 
[DEBUG] s.m.T.selectTest - ==> Parameters:

Description

Specify the annotation on the Mapper method with @SelectProvider.
- Set type to the class that generates SQL, and set method to the name of the method that generates SQL.
- For INSERT or UPDATE, there are @InsertProvider and @UpdateProvider.
Use the org.apache.ibatis.jdbc.SQL class to generate SQL.
Create an SQL class instance as an anonymous class and generate SQL by using the SELECT() and FROM() methods in the instance initialization block.
- Each argument passes a SQL item as a string.
- At this point, comma separation and similar formatting are added as needed.
The generated SQL can be retrieved as a string from the toString() method of the generated SQL instance.

Dynamically generate SQL in a program
- How to use each method

MyBatis | Integration with Spring Boot

kc@example.com (kc kim) — Sun, 01 Oct 2017 07:57:27 +0900

Because a plugin for Spring Boot is included, it can be integrated easily by using it.

DB Table

test_table

id	value
1	hoge
2	fuga
3	piyo

Folder Structure

├── build.gradle
├── src/main/
│   └── java/
│   └── sample/mybatis/springboot/
│       └── Main.java
│       └── TestTableMapper.java
└── resources/
    └── application.properties
    └── mybatis-config.xml
    └── TestTableMapper.xml

Source Code

build.gradle

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.springframework.boot:spring-boot-gradle-plugin:1.3.1.RELEASE'
    }
}

apply plugin: 'java'
apply plugin: 'spring-boot'

sourceCompatibility = '1.8'
targetCompatibility = '1.8'
compileJava.options.encoding = 'UTF-8'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.springframework.boot:spring-boot-starter'
    // Include the dependency library file for MyBatis Spring Boot.
    compile 'org.mybatis.spring.boot:mybatis-spring-boot-starter:1.0.0'
    compile 'mysql:mysql-connector-java:5.1.38'
}

application.properties

# Load the MyBatis configuration file.
mybatis.config=mybatis-config.xml

# Configure the data source.
spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=test
spring.datasource.password=test
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

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>
 <!-- Data source management is handled by Spring Boot, so it is not written here. -->
  <mappers>
    <mapper resource="TestTableMapper.xml"/>
  </mappers>
</configuration>

TestTableMapper.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="sample.mybatis.springboot.TestTableMapper">

  <select id="selectTest" resultType="map">
    select * from test_table
  </select>
</mapper>

TestTableMapper.java

package sample.mybatis.springboot;

import java.util.List;
import java.util.Map;

public interface TestTableMapper {

    List<Map<String, Object>> selectTest();
}

Main.java

package sample.mybatis.springboot;

import java.io.IOException;

import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication
public class Main {

    public static void main(String[] args) throws IOException {
        try (ConfigurableApplicationContext ctx = SpringApplication.run(Main.class, args)) {
            Main m = ctx.getBean(Main.class);
            m.method();
        }
    }

    @Autowired
    private SqlSessionTemplate sqlSession;
    @Autowired
    private TestTableMapper mapper;

    public void method() throws IOException {
        System.out.println("[SqlSessionTemplate]");
        this.sqlSession
            .selectList("sample.mybatis.springboot.TestTableMapper.selectTest")
            .forEach(System.out::println);

        System.out.println("[TestTableMapper]");
        this.mapper
            .selectTest()
            .forEach(System.out::println);
    }
}

Execution Result

[SqlSessionTemplate]
{id=1, value=hoge}
{id=2, value=fuga}
{id=3, value=piyo}

[TestTableMapper]
{id=1, value=hoge}
{id=2, value=fuga}
{id=3, value=piyo}

Description

When using MyBatis with Spring Boot, add mybatis-spring-boot-starter as a dependency.
Next, specify the MyBatis configuration file with the name mybatis.config in the Spring Boot configuration file (application.properties).
Because the data source is managed by Spring Boot, configure it in the Spring Boot settings and do not define it separately in MyBatis.
To access SqlSession, inject SqlSessionTemplate with @Autowired.
- The API of SqlSessionTemplate is the same as SqlSession.
- Unlike SqlSession, it is thread-safe, so it can be used from other threads or DAOs without issue.
If you define a Mapper interface, it can be injected with @Autowired.
- Place the interface in a location scanned by Spring.
- If you annotate the Main class with @MapperScan, you can scan Mapper interfaces in all packages, for example @MapperScan("foo.bar").
- This also injects a thread-safe instance, so it can be used from other threads or DAOs without issue.