Explication détaillée d'exemples d'opérations de base de données Java via JPA

Aujourd'hui, je vais vous présenter comment vous connecter à la base de données Mysql dans SpringBoot et utiliser JPA pour effectuer des opérations liées à la base de données.

Aujourd'hui, je vais vous présenter comment vous connecter à la base de données Mysql dans SpringBoot et utiliser JPA pour effectuer des opérations liées à la base de données.

Étape 1 : Ajoutez les dépendances du package Jar associées de MYSQl et JPA dans le fichier pom.xml. L'emplacement d'ajout spécifique est dans les dépendances. Le contenu spécifique ajouté est le suivant. .

<!--数据库相关配置-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <dependency>
      <groupId>org.apache.poi</groupId>
      <artifactId>poi</artifactId>
      <version>3.11</version>
    </dependency>

Étape 2 : Ajoutez la configuration appropriée de la base de données au fichier de configuration application.properties. Les informations de configuration sont les suivantes.

spring.datasource.url = jdbc:mysql://localhost:3306/webtest
spring.datasource.username = root
spring.datasource.password = 220316
spring.datasource.driverClassName = com.mysql.jdbc.Driver
# Specify the DBMS
spring.jpa.database = MYSQL
# Show or not log for each sql query
spring.jpa.show-sql = true
# Hibernate ddl auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto = update
# Naming strategy
spring.jpa.hibernate.naming-strategy = org.hibernate.cfg.ImprovedNamingStrategy
# stripped before adding them to the entity manager)
spring.jpa.properties.hibernate.dialect = org.hibernate.dialect.MySQL5Dialect

Voici une explication : webtest représente le nom de la base de données, root est le nom d'utilisateur et 220316 est le mot de passe

Étape 3 : Écrire La classe d'entité de fonctionnement de la base de données , les informations spécifiques de la classe d'entité sont les suivantes :

package example.entity;
import javax.persistence.*;
import javax.validation.constraints.NotNull;
import java.math.BigDecimal;
import java.util.Date;
@Entity
@Table(name = "user")
public class User {
  @Id
  @GeneratedValue(strategy = GenerationType.AUTO)
  private int id;

  @Column(name = "name", nullable = true, length = 30)
  private String name;

  @Column(name = "height", nullable = true, length = 10)
  private int height;

  @Column(name = "sex", nullable = true, length = 2)
  private char sex;

  @Temporal(TemporalType.DATE)
  private Date birthday;

  @Temporal(TemporalType.TIMESTAMP)
  private Date sendtime; // 日期类型，格式：yyyy-MM-dd HH:mm:ss

  @Column(name = "price", nullable = true, length = 10)
  private BigDecimal price;

  @Column(name = "floatprice", nullable = true, length = 10)
  private float floatprice;


  @Column(name = "doubleprice", nullable = true, length = 10)
  private double doubleprice;

  public Date getSendtime() {
    return sendtime;
  }

  public void setSendtime(Date sendtime) {
    this.sendtime = sendtime;
  }

  public BigDecimal getPrice() {
    return price;
  }

  public void setPrice(BigDecimal price) {
    this.price = price;
  }

  public float getFloatprice() {
    return floatprice;
  }

  public void setFloatprice(float floatprice) {
    this.floatprice = floatprice;
  }

  public double getDoubleprice() {
    return doubleprice;
  }

  public void setDoubleprice(double doubleprice) {
    this.doubleprice = doubleprice;
  }

  public User() { }

  public char getSex() {
    return sex;
  }

  public void setSex(char sex) {
    this.sex = sex;
  }

  public Date getBirthday() {
    return birthday;
  }

  public void setBirthday(Date birthday) {
    this.birthday = birthday;
  }

  public User(int id) {
    this.id = id;
  }

  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 int getHeight() {
    return height;
  }

  public void setHeight(int height) {
    this.height = height;
  }
}

Ce à quoi vous devez faire attention ici est : le nom de la classe et le champ L'attribut dans la classe d'entité doit être le même car les tables et les champs de la base de données correspondent les uns aux autres. Ce qui suit est un diagramme de correspondance de divers attributs de MYSQL-JAVA :

Étape 4 : Écrivez la classe d'opération de données de la couche dao, les données dao La classe d'opération est la suivante :

package example.dao;
import example.entity.User;
import org.springframework.data.repository.CrudRepository;
import javax.transaction.Transactional;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;

@Transactional
public interface UserDao extends CrudRepository<User, Integer> {
  public List<User> findByName(String name);
  public List<User> findBySex(char sex);
  public List<User> findByBirthday(Date birthday);
  public List<User> findBySendtime(Date sendtime);
  public List<User> findByPrice(BigDecimal price);
  public List<User> findByFloatprice(float floatprice);
  public List<User> findByDoubleprice(double doubleprice);
}

Vous avez peut-être des questions ici, pourquoi devriez-vous hériter de CrudRepository, et quel est son rôle spécifique ?

Ici, je vais vous donner une brève introduction à quelques directives d'utilisation et d'utilisation courantes dans JPA :

1 La première chose est d'hériter de la méthode CrudRepository, qui contient. DeuxLa signification spécifique des deux paramètres est la suivante : le premier paramètre indique le nom de la classe d'entité exploitée et le deuxième paramètre indique le type de clé primaire dans la classe d'entité.

2. Après l'héritage, vous pouvez utiliser certaines méthodes héritées de la classe parent. Par exemple, comme indiqué ci-dessus, vous pouvez utiliser findBy+ "Vous souhaitez interroger le nom du champ de <🎜. >", Grâce à cela, la méthode peut facilement réaliser la fonction de requête SQL.

Vous êtes peut-être encore un peu confus ici. Laissez-moi vous donner un exemple :

Par exemple, le findByName (nom de chaîne) ci-dessus est en fait équivalent au SQL. instruction L'instruction select *from userwhere name=? . Après une telle comparaison, vous comprendrez immédiatement ce que signifie cette méthode.

Étape 5 : Écrivez le contrôleur de la classe de contrôle Les informations spécifiques de la classe de contrôle sont les suivantes :

package example.controller;
import example.dao.UserDao;
import example.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.math.BigDecimal;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
@Controller
public class UserController {
  @Autowired
  private UserDao userDao;
  @RequestMapping("/getName")
  @ResponseBody
  public String getByName(String name) {
    List<User> userList = userDao.findByName(name);
    if (userList != null && userList.size()!=0) {
      return "The user length is: " + userList.size();
    }
    return "user " + name + " is not exist.";
  }

  @RequestMapping("/getSex")
  @ResponseBody
  public String getBySex(char sex) {
    List<User> userList = userDao.findBySex(sex);
    if (userList != null && userList.size()!=0) {
      return "The user length is: " + userList.size();
    }
    return "user " + sex + " is not exist.";
  }

  @RequestMapping("/getBirthday")
  @ResponseBody
  public String findByBirthday(String birthday) {
    System.out.println("birthday:"+birthday);
    SimpleDateFormat formate=new SimpleDateFormat("yyyy-MM-dd");
    List<User> userList = null;
    try {
      userList = userDao.findByBirthday(formate.parse(birthday));
    } catch (ParseException e) {
      e.printStackTrace();
    }
    if (userList != null && userList.size()!=0) {
      return "The user length is: " + userList.size();
    }
    return "user " + birthday + " is not exist.";
  }

  @RequestMapping("/getSendtime")
  @ResponseBody
  public String findBySendtime(String sendtime) {
    System.out.println("sendtime:"+sendtime);
    SimpleDateFormat formate=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    List<User> userList = null;
    try {
      userList = userDao.findBySendtime(formate.parse(sendtime));
    } catch (ParseException e) {
      e.printStackTrace();
    }
    if (userList != null && userList.size()!=0) {
      return "The user length is: " + userList.size();
    }
    return "user " + sendtime + " is not exist.";
  }

  @RequestMapping("/getPrice")
  @ResponseBody
  public String findByPrice(BigDecimal price) {
    List<User> userList = null;
    userList = userDao.findByPrice(price);
    if (userList != null && userList.size()!=0) {
      return "The user length is: " + userList.size();
    }
    return "user " + price + " is not exist.";
  }

  @RequestMapping("/getFloatprice")
  @ResponseBody
  public String findFloatprice(float floatprice) {
    List<User> userList = null;
    userList = userDao.findByFloatprice(floatprice);
    if (userList != null && userList.size()!=0) {
      return "The user length is: " + userList.size();
    }
    return "user " + floatprice + " is not exist.";
  }

  @RequestMapping("/getDoubleprice")
  @ResponseBody
  public String findByPrice(double doubleprice) {
    List<User> userList = null;
    userList = userDao.findByDoubleprice(doubleprice);
    if (userList != null && userList.size()!=0) {
      return "The user length is: " + userList.size();
    }
    return "user " + doubleprice + " is not exist.";
  }
}

Vous avez peut-être un gros problème. ici Question, j'ai aussi profondément ignoré ce problème au début, c'est-à-dire pourquoi userDao peut-il être utilisé directement sans instanciation ?

Maintenant je vais vous expliquer pourquoi c'est le cas :

En fait, ce n'est pas que cet userDao n'est pas instancié, mais l'instanciation est automatiquement complétée par le système

de. Tant que vous ajoutez l'attribut @Autowired au-dessus de userDao, vous pouvez réaliser l'instanciation automatique de l'interface. Il n'est pas nécessaire d'écrire des classes d'implémentation telles que userDaoImp ​​​​comme auparavant. Cela peut grandement améliorer la simplicité du code et la vitesse de développement.

Je sais que certaines personnes peuvent encore poser cette question : c'est une instanciation automatique, mais comment l'instanciation sait-elle quelles fonctions d'ajout, de suppression, de modification et de vérification la classe dao doit implémenter ? une telle chose dans le code tao. Tu n'as pas dit ça ? En fait, ceux qui sont intéressés l'ont peut-être découvert. Dans l'étape précédente, nous avons expliqué la fonction spécifique de findBy+"field name". En fait, les différentes méthodes de la couche dao sont les commandes SQL des différentes classes d'implémentation dans daoimp. Je vais vous donner une introduction détaillée sur la façon dont elles correspondent les unes aux autres dans la section suivante, mais je vais maintenant vous donner une brève introduction. .

Étape 6 : Le nom de la table et les informations sur les champs de la base de données sont les suivants :

[ Recommandations associées]

1.

Tutoriel vidéo gratuit Java

2

Tutoriel vidéo Java de la Geek Academy

3. >Manuel de développement Java Ali Baba

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!