Comment Spring Boot intègre JdbcTemplate

Integrate JdbcTemplate

JdbcTemplate est un ensemble de framework de modèles JDBC fourni par Spring, qui utilise la technologie AOP pour résoudre le problème d'une grande quantité de code répété lors de l'utilisation directe de JDBC. Bien que JdbcTemplate ne soit pas aussi flexible que Mybatis, il est bien plus pratique que d'utiliser directement JDBC. L'utilisation de JdbcTemplate dans Spring Boot fournit la classe de configuration automatisée JdbcTemplateAutoConfiguration. Une partie du code source est la suivante :

@Configuration
@ConditionalOnClass({DataSource.class, JdbcTemplate.class})
@ConditionalOnSingleCandidate(DataSource.class)
@AutoConfigureAfter({DataSourceAutoConfiguration.class})
@EnableConfigurationProperties({JdbcProperties.class})
public class JdbcTemplateAutoConfiguration {
    public JdbcTemplateAutoConfiguration() {
    }
    @Configuration
    @Import({JdbcTemplateAutoConfiguration.JdbcTemplateConfiguration.class})
    static class NamedParameterJdbcTemplateConfiguration {
        NamedParameterJdbcTemplateConfiguration() {
        }
        @Bean
        @Primary
        @ConditionalOnSingleCandidate(JdbcTemplate.class)
        @ConditionalOnMissingBean({NamedParameterJdbcOperations.class})
        public NamedParameterJdbcTemplate namedParameterJdbcTemplate(JdbcTemplate jdbcTemplate) {
            return new NamedParameterJdbcTemplate(jdbcTemplate);
        }
    }
    @Configuration
    static class JdbcTemplateConfiguration {
        private final DataSource dataSource;
        private final JdbcProperties properties;

        JdbcTemplateConfiguration(DataSource dataSource, JdbcProperties properties) {
            this.dataSource = dataSource;
            this.properties = properties;
        }
        @Bean
        @Primary
        @ConditionalOnMissingBean({JdbcOperations.class})
        public JdbcTemplate jdbcTemplate() {
            JdbcTemplate jdbcTemplate = new JdbcTemplate(this.dataSource);
            Template template = this.properties.getTemplate();
            jdbcTemplate.setFetchSize(template.getFetchSize());
            jdbcTemplate.setMaxRows(template.getMaxRows());
            if (template.getQueryTimeout() != null) {
                jdbcTemplate.setQueryTimeout((int)template.getQueryTimeout().getSeconds());
            }
            return jdbcTemplate;
        }
    }
}

Il ressort du code source que lorsque DataSource et JdbcTemplate existent sous le chemin de classe et. il n'y a qu'une seule instance de DataSource, la configuration automatique peut prendre effet. Si le développeur ne fournit pas JdbcOperations, Spring Boot injectera automatiquement un JdbcTemplate dans le conteneur (JdbcTemplate est une sous-classe de JdbcOperations). Par conséquent, les développeurs qui souhaitent utiliser JdbcTemplate doivent uniquement fournir des dépendances JdbcTemplate et des dépendances DataSource

Créer des bases de données et des tables

Créer des tables dans la base de données, comme suit :

CREATE TABLE `book` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(128) DEFAULT NULL,
  `author` varchar(128) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
INSERT INTO `chapter05`(`id`, `name`, `author`) VALUES (1, '斗罗大陆Ⅰ', '唐家三少');
INSERT INTO `chapter05`(`id`, `name`, `author`) VALUES (2, '斗罗大陆Ⅱ', '唐家三少');

Créer un projet

Créer un projet Spring Boot et ajouter des dépendances

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <scope>runtime</scope>
</dependency>
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.1.9</version>
</dependency>

spring-boot-starter-jdbc fournit spring-jdbc et ajoute également un pilote de base de données dépendances et dépendances du pool de connexion à la base de données

Configuration de la base de données

Configurer les informations de connexion à la base de données de base dans application.properties

spring.datasource .type =com.alibaba.druid.pool.DruidDataSource
spring.datasource.url=jdbc:mysql://localhost:3306/weirdo
spring.datasource.username=root
spring source de données. password=root

Créer une classe d'entité

Créer une classe d'entité Book, le code est le suivant :

public class Book {
    private int id;
    private String name;
    private String author;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAuthor() {
        return author;
    }
    public void setAuthor(String author) {
        this.author = author;
    }
}

Créer une couche d'accès à la base de données # 🎜🎜#

Create BookDao, le code est le suivant :

@Repository
public class BookDao {
    @Autowired
    JdbcTemplate jdbcTemplate;
    public int addBook(Book book) {
        return jdbcTemplate.update("INSERT INTO book(name,author) VALUES (?,?)",
                book.getName(), book.getAuthor());
    }
    public int updateBook(Book book) {
        return jdbcTemplate.update("UPDATE book SET name=?,author=? WHERE id=?",
                book.getName(), book.getAuthor(), book.getId());
    }
    public int deleteBookById(Integer id) {
        return jdbcTemplate.update("DELETE FROM book WHERE id=?", id);
    }
    public Book getBookById(Integer id) {
        return jdbcTemplate.queryForObject("select * from book where id=?",
                new BeanPropertyRowMapper<>(Book.class), id);
    }
    public List<Book> getAllBooks() {
        return jdbcTemplate.query("select * from book",
                new BeanPropertyRowMapper<>(Book.class));
    }
}

Explication du code :

• Créez BookDao et injectez jdbcTemplate . Depuis que les dépendances liées à spring-jdbc ont été ajoutées, JdbcTemplate sera automatiquement enregistré dans le conteneur Spring, donc JdbcTemplate peut être directement injecté ici en utilisant

• Dans JdbcTemplate, ajoutez, supprimez , et modifier trois. Ce type d'opération est principalement effectué à l'aide des méthodes update et batchUpdate, et les méthodes query et queryForObject sont principalement utilisées pour compléter la fonction de requête. De plus, il existe une méthode d'exécution qui peut être utilisée pour exécuter du SQL arbitraire, une méthode d'appel qui est utilisée pour appeler des procédures stockées, etc. Les colonnes qui sortent correspondent aux attributs de la classe d'entité un à un. Si le nom de la colonne et le nom de l'attribut sont identiques, vous pouvez utiliser BeanPropertyRowMapper directement ; si le nom de la colonne et le nom de l'attribut sont différents, le développeur doit implémenter l'interface RowMapper pour mapper les colonnes et les attributs de la classe d'entité un à un #🎜 🎜#

  #🎜 🎜#

  Créer un service et un contrôleur
• Créer BookService et BooKController

  @Service
  public class BookService {
      @Autowired
      BookDao bookDao;
      public int addBook(Book book) {
          return bookDao.addBook(book);
      }
      public int updateBook(Book book) {
          return bookDao.updateBook(book);
      }
      public int deleteBookById(Integer id) {
          return bookDao.deleteBookById(id);
      }
      public Book getBookById(Integer id) {
          return bookDao.getBookById(id);
      }
      public List<Book> getAllBooks() {
          return bookDao.getAllBooks();
      }
  }

  @RestController
  public class BookController {
      @Autowired
      BookService bookService;
      @GetMapping("/bookOps")
      public void bookOps() {
          Book b1 = new Book();
          b1.setId(99);
          b1.setName("西厢记");
          b1.setAuthor("王实甫");
          int i = bookService.addBook(b1);
          System.out.println("addBook>>>" + i);
          Book b2 = new Book();
          b2.setId(1);
          b2.setName("朝花夕拾");
          b2.setAuthor("鲁迅");
          int updateBook = bookService.updateBook(b2);
          System.out.println("updateBook>>>"+updateBook);
          Book b3 = bookService.getBookById(1);
          System.out.println("getBookById>>>"+b3);
          int delete = bookService.deleteBookById(2);
          System.out.println("deleteBookById>>>"+delete);
          List<Book> allBooks = bookService.getAllBooks();
          System.out.println("getAllBooks>>>"+allBooks);
      }
  }

  Enfin, visitez http://localhost:8081/bookOps adresse, console dans le navigateur Le journal d'impression est le suivant :

addBook>>>1

updateBook>>>1

getBookById>> ;>com.sang.Book@ 35e33288

deleteBookById>>>1

getAllBooks>>>[com.sang.Book@2f7c2d6d, com.sang.Book@32db4b36]#🎜 🎜#

#🎜 🎜 #Les données dans la base de données sont les suivantes :

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!