[JAVA] Spring + MyBatis-Verbindungseinstellungsmethode

Was ist mein Batis?

Ein Framework, das indirekt über Java auf die Datenbank zugreift, indem SQL- und Java-Objekte zugeordnet werden. Als Funktion können Sie SQL deklarativ in der Konfigurationsdatei und in den Anmerkungen definieren. In der Lage sein, die Existenz von SQL selbst vor der in Java geschriebenen Geschäftslogik zu verbergen.

Die Mapper-Schnittstelle verbirgt das SQL, und MyBatis verknüpft die Methoden der Mapper-Schnittstelle mit dem SQL. Daher können Sie aus der Java-Geschäftslogik das verknüpfte SQL einfach durch Aufrufen der Mapper-Schnittstelle ausführen.

Voraussetzungen

・ Eclipse 2018-09 (4.9.0) ・ Windows10 ・ H2

• Es gibt zwei Möglichkeiten, SQL für MyBatis anzugeben: "Zuordnungsdatei" und "Anmerkung". Dieses Mal werden wir eine "Mapping-Datei" verwenden.

Grundeinstellung

pom.xml

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.2</version>
        </dependency>
        <dependency>
		    <groupId>org.mybatis</groupId>
		    <artifactId>mybatis</artifactId>
		    <version>3.4.0</version>
		</dependency>

MybatisTestApplication.java

@SpringBootApplication
@EnableTransactionManagement
@MapperScan("com.mybatis.test.domain")
public class MybatisTestApplication {

	//Spring Boot-Startmethode
	public static void main(String[] args) {
		SpringApplication.run(MybatisTestApplication.class, args);
	}

	//Bean-Definitionsdatenquelle ①
	@Bean
	public DataSource dataSource() {
		return new EmbeddedDatabaseBuilder()
				.setType(EmbeddedDatabaseType.H2)
				.addDefaultScripts()
				.build();
	}

	//Bean-Definition PlatformTransactionManager②
	@Bean
	public PlatformTransactionManager transactionManager() {
		return new DataSourceTransactionManager(dataSource());
	}

	//Bean-Definition SqlSessionFactoryBean ③
	@Bean
	public SqlSessionFactoryBean sqlSessionFactory() {
		SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
		sessionFactoryBean.setDataSource(dataSource());
		return sessionFactoryBean;
	}

** ① Datenquelle ** Definieren Sie eine Bean für die Datenquelle.

②PlatformTransactionManager Definieren Sie eine Transaktionsmanager-Bean.

③SqlSessionFactoryBean SqlSessionFactory wird mit SqlSessionFactoryBean generiert. Wenn Sie die Datenquelle festlegen und SQL bei der Verarbeitung von MyBatis ausgeben, verwenden Sie die hier angegebene Datenquelle Die Verbindung wird hergestellt.

DB-Zugriff über MyBatis

-Erstellen einer Mapper-Schnittstelle ・ Erstellung einer Mapping-Datei

MyBatisMapper.java

package com.mybatis.test.domain;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

//Durch Hinzufügen dieser Anmerkung wird sie vom Programm als Mapper-Schnittstelle erkannt.
@Mapper
public interface MyBatisMapper {

	//Zum Testen von SELECT
	public PlayerEntity selectTest(String id);

	//Zum Testen von INSERT
	public void insertTest(@Param("id")String id, @Param("name")String name, @Param("age")String age);

	//Zum Testen von UPDATE
	public void updateTest(@Param("id")String id, @Param("name")String name);

	//Zum Testen von DELETE
	public void deleteTest(String id);
}

MyBatisMapper.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.mybatis.test.domain.MyBatisMapper">
	<!--Das id-Attribut ist der in der Mapper-Schnittstelle definierte Methodenname-->
	<!--Das parameterType-Attribut ist die Klasse der Methodenargumente-->
	<!--Das Attribut resultType ist eine Klasse, die Suchergebnisse abbildet-->
  	<select id="selectTest" parameterType="string" resultType="com.mybatis.test.domain.PlayerEntity">
  	  SELECT
  	   id,name,age
   	  FROM
   	   player
   	  WHERE
   	   id=#{id}
  	</select>

  	<insert id="insertTest" parameterType="string" >
  	  INSERT INTO
  	   player (id, name, age)
  	  VALUES
  	   (#{id}, #{name}, #{age})
  	</insert>

  	<update id="updateTest" parameterType="string">
  	 UPDATE
  	  player
  	 SET
  	  name=#{name}
  	 WHERE
  	  id=#{id}
  	</update>

  	<delete id="deleteTest" parameterType="string">
  	 DELETE FROM player WHERE id=#{id}
  	</delete>
</mapper>

** XML befindet sich am selben Speicherort wie der Ordner, in dem sich die Mapper-Schnittstelle in src / main / resources befindet. Platziere sie mit dem gleichen Namen! ** ** Auf diese Weise liest MyBatis automatisch die Zuordnungsdatei. **

Verwendung des Mapper-Objekts

-Serviceklasse ・ Controller-Klasse ・ Entitätsklasse

Service

package com.mybatis.test.domain;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class MyBatisService {

	@Autowired
	MyBatisMapper mapper;

	@Autowired
	PlayerRepository playerRepository;

	//Rufen Sie die Mapper-Methode auf, um SELECT auszuführen
	@Transactional
	public PlayerEntity selectTest(String id) {
		return mapper.selectTest(id);
	}

	//Rufen Sie die Mapper-Methode auf, die INSERT ausführt
	@Transactional
	public void insertTest(String id, String name, String age) {
		mapper.insertTest(id, name, age);
	}

	//Rufen Sie die Mapper-Methode auf, die UPDATE ausführt
	@Transactional
	public void updateTest(String id, String name) {
		mapper.updateTest(id, name);
	}

	//Rufen Sie die Mapper-Methode auf, um DELETE auszuführen
	@Transactional
	public void deleteTest(String id) {
		mapper.deleteTest(id);
	}

Controller

package com.mybatis.test.domain;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class MybatisController {

	@Autowired
	MyBatisService myBatisService;

	@GetMapping()
	public String index(Model model) {

		PlayerEntity playerService = new PlayerEntity();
		playerService = myBatisService.selectTest("004");
		model.addAttribute("play", playerService);
		myBatisService.insertTest("010", "XXXX", "65");
		myBatisService.updateTest("004", "SSSSSS");
		myBatisService.deleteTest("001");
		return "index";
	}
Unten weggelassen

Entity

package com.mybatis.test.domain;

import javax.persistence.Entity;
import javax.persistence.Id;

@Entity
public class PlayerEntity {

	@Id
	private String id;

	private String name;
	private String age;
getter,Setter weggelassen

Am Ende

Als nächstes möchte ich JOIN- und SQL-Anweisungen komplizierter machen und damit herumspielen.