SpringBoot implementa el soporte de la capa de persistencia: JPA

Dos, soporte de capa de persistencia SpringBoot

Recomendación del sitio web de aprendizaje: How2java

1. Concepto JPA

JPA (API de persistencia de Java) es una especificación de persistencia de Java propuesta oficialmente por Sun para facilitar el funcionamiento de la base de datos.
El trabajo real puede ser Hibernate, TopLink, etc. diferentes proveedores que implementan la especificación JPA, el valor predeterminado es Hibernate.

2. Configuración de JPA

1. Cree una base de datos y una tabla, prepare los datos

   create database how2java;
   
   use how2java;
   CREATE TABLE category_ (
     id int(11) NOT NULL AUTO_INCREMENT,
     name varchar(30),
     PRIMARY KEY (id)
   ) DEFAULT CHARSET=UTF8;
   
   insert into category_ values(null,'category 1');
   insert into category_ values(null,'category 2');
   insert into category_ values(null,'category 3');
   insert into category_ values(null,'category 4');
   

2. Modificar application.properties

   Configurar elementos relacionados para conectarse a la base de datos

   spring.mvc.view.prefix=/WEB-INF/jsp/
   spring.mvc.view.suffix=.jsp
   spring.datasource.url=jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8
   spring.datasource.username=root
   spring.datasource.password=admin
   spring.datasource.driver-class-name=com.mysql.jdbc.Driver
   spring.jpa.properties.hibernate.hbm2ddl.auto=update
   

3. Modificar pom.xml

   Agregue la configuración a la etiqueta de dependencias en este archivo, agregando soporte para Mysql y Jpa

           <!-- mysql-->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>5.1.21</version>
           </dependency>
           <!-- jpa-->
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-data-jpa</artifactId>
           </dependency> 
   

4. Crear categoría, CategoryDAO, CategoryController respectivamente

   • Categoría

     Agregue un paquete: com.how2java.springboot.pojo, y luego cree la categoría de entidad Categoría.
     La anotación @Entity indica que se trata de una clase de entidad.
     @Table (name = "category_") indica que el nombre de la tabla correspondiente a esta clase es category_. Tenga en cuenta que el subrayado
     @Id indica la clave principal
     @GeneratedValue (estrategia = GenerationType.IDENTITY ) indica el modo de crecimiento propio
     @Column (name = "id") indica el nombre del campo de la base de datos correspondiente

     package com.how2java.springboot.pojo;
      
     import javax.persistence.Column;
     import javax.persistence.Entity;
     import javax.persistence.GeneratedValue;
     import javax.persistence.GenerationType;
     import javax.persistence.Id;
     import javax.persistence.Table;
      
     @Entity
     @Table(name = "category_")
     public class Category {
             
             
      
         @Id
         @GeneratedValue(strategy = GenerationType.IDENTITY)
         @Column(name = "id")
         private int id;
          
         @Column(name = "name")
         private String name;
         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;
         }
          
     }
     

   • CategoryDAO

     Agregue un paquete: com.how2java.springboot.dao, y luego cree la interfaz dao; CategoryDAO hereda JpaRepository y proporciona <Category, Integer> genérico para indicar que se trata de un DAO para la clase Category, y Integer indica que la clave principal es de tipo Integer.
     JpaRepository, la interfaz principal, proporciona una serie de consultas como CRUD, paginación, etc., que se pueden usar directamente sin desarrollo secundario.

     package com.how2java.springboot.dao;
     import org.springframework.data.jpa.repository.JpaRepository;
     import com.how2java.springboot.pojo.Category;
      
     public interface CategoryDAO extends JpaRepository<Category,Integer>{
             
             
      
     }
     

   • CategoryController

     Agregue un paquete: com.how2java.springboot.web y luego cree la clase CategoryController.

     1. Aceptar lista Mapeo de categorías
     2. Luego obtén todos los datos de clasificación
     3. Luego póngalo en el modelo
     4. Ir a listCategory.jsp

     package com.how2java.springboot.web;
     import java.util.List;
     import org.springframework.beans.factory.annotation.Autowired;
     import org.springframework.stereotype.Controller;
     import org.springframework.ui.Model;
     import org.springframework.web.bind.annotation.RequestMapping;
     import com.how2java.springboot.dao.CategoryDAO;
     import com.how2java.springboot.pojo.Category;
       
     @Controller
     public class CategoryController {
             
             
         @Autowired CategoryDAO categoryDAO;
         @RequestMapping("/listCategory")
         public String listCategory(Model m) throws Exception {
             
             
             List<Category> cs=categoryDAO.findAll();
              
             m.addAttribute("cs", cs);
              
             return "listCategory";
         }
          
     }
     

5. Crear listCategory.jsp

   Recorre la colección (cs) pasada por CategoryController

   <%@ page language="java" contentType="text/html; charset=UTF-8"
       pageEncoding="UTF-8"%>
   <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
   <table align='center' border='1' cellspacing='0'>
       <tr>
           <td>id</td>
           <td>name</td>
       </tr>
       <c:forEach items="${cs}" var="c" varStatus="st">
           <tr>
               <td>${c.id}</td>
               <td>${c.name}</td>
           </tr>
       </c:forEach>
   </table>
   

6. Reiniciar prueba

   Dado que la dependencia del paquete jar se agrega a pom.xml y la implementación en caliente de Springboot no puede funcionar, debe reiniciarlo manualmente aquí:

   Luego visite la dirección de prueba: