Easy methods to use MyBatis in Spring Boot software in Java? Instance Tutorial

package deal com.pupil.crudapp.mannequin;
import javax.persistence.*;
@Entity
@Desk(title = "STUDENT")
public class Scholar {
@Column(title = "id")
@Id
    @GeneratedValue(technique=GenerationType.AUTO)
non-public int id;
@NotBlank(message = "Identify is necessary")
@Column(title = "title")
non-public String title;
@NotBlank(message = "E mail is necessary")
@Column(title = "e-mail")
non-public String e-mail;
@NotBlank(message = "Grade is necessary")
@Column(title = "grade")
non-public String grade;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return title;
}
public void setName(String title) {
this.title = title;
}
public String getEmail() {
return e-mail;
}
public void setEmail(String e-mail) {
this.e-mail = e-mail;
}
public String getGrade() {
return grade;
}
public void setGrade(String grade) {
this.grade = grade;
}
@Override
    public String toString() {
return "Scholar{" +
"id=" + id +
", title="" + title + "'' +
", e-mail="" + e-mail + "'' +
", grade="" + grade + "'' +
'}';
}
}


When making a persistent pojo class, @Entity is utilized. You'll have a comparable desk within the database for this Java class. @Column is used to hyperlink annotated attributes to their respective desk columns.
So in right here, we will add an equal SQL schema.sql file as under.
CREATE TABLE pupil(
id integer identification NOT NULL ,
title varchar(100) NOT NULL,
e-mail varchar(100) NOT NULL,
grade varchar(100),
CONSTRAINT pk_student_id PRIMARY KEY(id)
);


Then let's add some knowledge to our created desk. In right here, we use the info.sql file which is within the classpath f of the spring boot software so as to add some knowledge. 
INSERT INTO pupil(title,e-mail,grade) values ('Test1','test1@gmail.com', 6);
INSERT INTO pupil(title,e-mail,grade) values ('Test2','test2@gmail.com', 8);
INSERT INTO pupil(title,e-mail,grade) values ('Test3','test3@gmail.com', 10);
INSERT INTO pupil(title,e-mail,grade) values ('Test4','test4@gmail.com', 12);


3. Annotation primarily based configuration
Spring makes it simpler to arrange MyBatis. Solely javax.sql.Datasource, org.apache.ibatis.session.SqlSessionFactory, and at the very least one mapper are required.
@Configuration
@MapperScan("org.mybatis.spring.mapper.MapperFactoryBean")
public class PersistenceConfig {
@Bean
public DataSource dataSource() {
return new EmbeddedDatabaseBuilder()
.setType(EmbeddedDatabaseType.H2)
.addScript("schema.sql")
.addScript("knowledge.sql")
.construct();
}
@Bean
public SqlSessionFactory sqlSessionFactory() throws Exception {
SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean();
factoryBean.setDataSource(dataSource());
return factoryBean.getObject();
}
}



We additionally utilized a @MapperScan annotation from MyBatis-Spring that scans outlined packages and routinely picks up interfaces utilizing any of the mapper annotations, reminiscent of @Choose or @Delete.
Utilizing @MapperScan additionally ensures that any mapper supplied is routinely registered as a Bean and may be utilized with the @Autowired annotation afterwards.

After completion of configuration, we will use MyBatis to create a Mapper to make use of, for instance, StudentMapper can use immediately as follows.

public interface StudentMapper {
@Choose("choose * from pupil")
Record<Scholar> getAllStudents();
@Outcomes({
@End result(property = "id", column = "id"),
@End result(property = "title", column = "n"),
@End result(property = "e-mail", column = "e"),
@End result(property = "grade", column = "g")
})
@Choose("choose e-mail as e,title as n,grade as g,id as id from pupil the place id=#{id}")
Scholar getStudentById(Lengthy id);
@Choose("choose * from pupil the place e-mail like concat('%',#{e-mail},'%')")
Record<Scholar> getStudentsByName(String e-mail);
@Insert({"insert into pupil(e-mail,title,grade) values(#{e-mail},#{title})"})
@SelectKey(assertion = "choose last_insert_id()", keyProperty = "id",
    earlier than = false, resultType = Integer.class)
Integer addStudent(Scholar pupil);
@Replace("replace pupil set e-mail=#{e-mail},title=#{title}, grade=#{grade} the place id=#{id}")
Integer updateStudentById(Scholar pupil);
@Delete("delete from pupil the place id=#{id}")
Integer deleteStudentById(Integer id);
}

This can be a totally annotated method to write SQL, not an XML file. The @Choose, @Insert, @Replace, and @Delete annotations correspond to the XML choose, insert, replace, and delete tags, respectively, whereas the @Outcomes annotation is equal to the XML ResultMap mapping file.

@SelectKey annotation which is used right here is used to implement the first key backfill operate. that’s, when the info is efficiently inserted, the efficiently inserted data-id is assigned to the person object’s id property.

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(courses = PersistenceConfig.class)
public class StudentMapperIntegrationTest {
@Autowired
StudentMapper studentMapper;
@Check
public void whenRecordsInDatabase_shouldReturnArticleWithGivenId() {
Scholar pupil = studentMapper.getStudent(1L);
assertThat(pupil).isNotNull();
assertThat(pupil.getId()).isEqualTo(1L);
assertThat(pupil.getName()).isEqualTo("Check");
assertThat(pupil.getEmail()).isEqualTo("Check@gmail.com");
assertThat(pupil.getGrade()).isEqualTo("6");
}
}

@SpringBootApplication
public class Software implements CommandLineRunner {
non-public Logger logger = LoggerFactory.getLogger(this.getClass());
@Autowired
non-public StudentRepository studentRepository;
@Override
   public void run(String... args) throws Exception {
logger.information("Scholar id 001 -> {}", studentRepository.findById(001));
logger.information("Replace 002 -> {}", 
      studentRepository.replace(new Scholar(001, "studentupdate",
       "studentupdate@gmail.com", "8")));
studentRepository.deleteById(001);
logger.information("All stuednts -> {}", studentRepository.findAll());
}
public static void essential(String[] args) {
SpringApplication.run(Software.class, args);
}
}