[JAVA] Méthode de configuration de la connexion Spring + MyBatis

Quel est mon batis

Une structure qui accède indirectement à la base de données à partir de Java en mappant des objets SQL et Java. En tant que fonctionnalité, en définissant de manière déclarative SQL dans le fichier de configuration et les annotations, Être capable de cacher l'existence de SQL lui-même à la logique métier écrite en Java.

L'interface Mapper masque le SQL et MyBatis lie les méthodes de l'interface Mapper au SQL. Par conséquent, à partir de la logique métier Java, vous pouvez exécuter le SQL lié en appelant simplement l'interface Mapper.

Conditions préalables

・ Éclipse 09/2018 (4.9.0) ・ Windows10 ・ H2 -Il existe deux façons de spécifier SQL pour MyBatis: "fichier de mappage" et "annotation". Cette fois, nous utiliserons un "fichier de mappage".

Réglage initial

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 {

	//Méthode de démarrage Spring Boot
	public static void main(String[] args) {
		SpringApplication.run(MybatisTestApplication.class, args);
	}

	//Source de données de définition de bean ①
	@Bean
	public DataSource dataSource() {
		return new EmbeddedDatabaseBuilder()
				.setType(EmbeddedDatabaseType.H2)
				.addDefaultScripts()
				.build();
	}

	//Définition de bean PlatformTransactionManager②
	@Bean
	public PlatformTransactionManager transactionManager() {
		return new DataSourceTransactionManager(dataSource());
	}

	//Définition du bean SqlSessionFactoryBean ③
	@Bean
	public SqlSessionFactoryBean sqlSessionFactory() {
		SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
		sessionFactoryBean.setDataSource(dataSource());
		return sessionFactoryBean;
	}

** ① Source de données ** Définissez un bean pour la source de données.

②PlatformTransactionManager Définissez un bean gestionnaire de transactions.

③SqlSessionFactoryBean SqlSessionFactory est généré à l'aide de SqlSessionFactoryBean. Si vous définissez la source de données et émettez SQL dans le traitement de MyBatis, à partir de la source de données spécifiée ici La connexion est acquise.

Accès à la base de données via MyBatis

-Création d'une interface Mapper ・ Création d'un fichier de cartographie

MyBatisMapper.java

package com.mybatis.test.domain;

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

//En ajoutant cette annotation, elle sera reconnue comme une interface Mapper par le programme.
@Mapper
public interface MyBatisMapper {

	//Pour tester SELECT
	public PlayerEntity selectTest(String id);

	//Pour tester INSERT
	public void insertTest(@Param("id")String id, @Param("name")String name, @Param("age")String age);

	//Pour tester UPDATE
	public void updateTest(@Param("id")String id, @Param("name")String name);

	//Pour tester 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">
	<!--L'attribut id est le nom de la méthode défini dans l'interface Mapper-->
	<!--L'attribut parameterType est la classe des arguments de méthode-->
	<!--L'attribut resultType est une classe qui mappe les résultats de la recherche-->
  	<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 se trouve au même emplacement que le dossier où se trouve l'interface Mapper dans src / main / resources. Placez-les avec le même nom! ** ** En faisant cela, MyBatis lira automatiquement le fichier de mappage. **

Utilisation de l'objet Mapper

-Classe de service ・ Classe de contrôleur ・ Classe d'entité

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;

	//Appelez la méthode Mapper pour effectuer SELECT
	@Transactional
	public PlayerEntity selectTest(String id) {
		return mapper.selectTest(id);
	}

	//Appelez la méthode Mapper qui effectue INSERT
	@Transactional
	public void insertTest(String id, String name, String age) {
		mapper.insertTest(id, name, age);
	}

	//Appelez la méthode Mapper pour effectuer UPDATE
	@Transactional
	public void updateTest(String id, String name) {
		mapper.updateTest(id, name);
	}

	//Appelez la méthode de Mapper pour faire DELETE
	@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";
	}
Omis ci-dessous

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 omis

À la fin

Ensuite, j'aimerais rendre les instructions JOIN et SQL plus compliquées et jouer avec elles.