Detaillierte Erläuterung von Beispielen für Java-Datenbankoperationen über JPA

Heute werde ich Ihnen vorstellen, wie Sie in SpringBoot eine Verbindung zur MySQL-Datenbank herstellen und JPA verwenden, um datenbankbezogene Vorgänge auszuführen.

Heute werde ich Ihnen vorstellen, wie Sie in SpringBoot eine Verbindung zur MySQL-Datenbank herstellen und JPA verwenden, um datenbankbezogene Vorgänge auszuführen.

Schritt 1: Fügen Sie die zugehörigen Jar-Paketabhängigkeiten von MYSQl und JPA in die pom.xml-Datei ein. Der spezifische hinzugefügte Inhalt ist wie folgt .

<!--数据库相关配置--> 
    <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>

Schritt 2: Fügen Sie die relevante Konfiguration der Datenbank zur Konfigurationsdatei application.properties hinzu. Die Konfigurationsinformationen lauten wie folgt.

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

Hier ist eine Erklärung: webtest stellt den Datenbanknamen dar, root ist der Benutzername und 220316 ist das Passwort

Schritt 3: Schreiben Die Entitätsklasse des Datenbankbetriebs , die spezifischen Informationen der Entitätsklasse lauten wie folgt:

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; 
  } 
}

Was Sie hier beachten müssen, ist: der Klassenname und das Feld Das Attribut in der Entitätsklasse muss mit Tabellen und Feldern in der Datenbank übereinstimmen, die einander entsprechen. Das Folgende ist ein Korrespondenzdiagramm verschiedener Attribute von MYSQL-JAVA:

Schritt 4: Schreiben Sie die Datenoperationsklasse der Dao-Schicht, Dao-Daten Die Operationsklasse lautet wie folgt:

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); 
}

Möglicherweise haben Sie hier Fragen: Warum sollten Sie CrudRepository erben und was ist ihre spezifische Rolle?

Hier gebe ich Ihnen eine kurze Einführung in einige allgemeine Verwendungs- und Nutzungsrichtlinien in JPA:

1 Das erste ist, die CrudRepository-Methode zu erben, die enthält zwei Die spezifische Bedeutung der beiden Parameter ist: Der erste Parameter gibt den Namen der Entitätsklasse an, die betrieben wird, und der zweite Parameter gibt den Typ des Primärschlüssels in der Entitätsklasse an.

2. Nach der Vererbung können Sie einige von der übergeordneten Klasse geerbte Methoden verwenden. Beispielsweise können Sie, wie oben gezeigt, „findBy+“ verwenden, um den Feldnamen von <🎜 abzufragen >“, dadurch Die Methode kann die Funktion einer SQL-Abfrage leicht realisieren.
Hier sind Sie möglicherweise immer noch etwas verwirrt:

Zum Beispiel entspricht der obige findByName (String-Name) tatsächlich dem SQL Anweisung Die select *from user where name=? . Nach einem solchen Vergleich werden Sie sofort verstehen, was diese Methode bedeutet.

Schritt 5:

Schreiben Sie den Kontrollklassen-Controller. Die spezifischen Informationen der Kontrollklasse lauten wie folgt:

Möglicherweise liegt ein großes Problem vor Hier Frage, ich habe dieses Problem am Anfang auch völlig ignoriert, das heißt, warum kann userDao direkt ohne Instanziierung verwendet werden?

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."; 
  } 
}

Jetzt erkläre ich Ihnen, warum das so ist:

Tatsächlich ist es nicht so, dass dieses userDao nicht instanziiert wird, aber die Instanziierung wird automatisch abgeschlossen das System

. Solange das @Autowired-Attribut über userDao hinzugefügt wird, kann die Schnittstelle automatisch instanziiert werden. Es ist nicht erforderlich, wie zuvor Implementierungsklassen wie userDaoImp ​​​​zu schreiben. Dies kann die Einfachheit des Codes und die Entwicklungsgeschwindigkeit erheblich verbessern.
Ich weiß, dass einige Leute vielleicht immer noch diese Frage stellen: Das ist automatische Instanziierung, aber woher weiß die Instanziierung, welche Hinzufügungs-, Lösch-, Änderungs- und Prüffunktionen die Dao-Klasse implementieren muss? so etwas im Dao-Code, hast du das nicht gesagt? Tatsächlich haben Interessierte es möglicherweise entdeckt. Im vorherigen Schritt haben wir die spezifische Funktion von findBy + „Feldname“ erklärt. Tatsächlich sind die verschiedenen Methoden in der Dao-Schicht die SQL-Befehle in den verschiedenen Implementierungsklassen in Daoimp. Ich werde Ihnen im nächsten Abschnitt eine detaillierte Einführung in ihre Korrelation geben, aber jetzt werde ich Ihnen eine kurze Einführung geben .

Schritt 6:

Der Tabellenname und die Feldinformationen der Datenbank lauten wie folgt:

[ Verwandte Empfehlungen]

1.

Kostenloses Java-Video-Tutorial

2

Geek Academy Java-Video-Tutorial

3 >Ali Baba Java-Entwicklungshandbuch

Das obige ist der detaillierte Inhalt vonDetaillierte Erläuterung von Beispielen für Java-Datenbankoperationen über JPA. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!