Protože JavaFX získává půdu pod nohama jako de-facto GUI framework Java, dříve nebo později nahradí Swing. JavaFX UI a JDBC mohou být efektivní kombinací při vytváření databázových aplikací, zejména v offline nebo vestavěném systému. Tento článek v podstatě ukazuje, jak to lze provést pomocí příkladu scénáře.
Přehled aplikací JDBC
Vývoj frameworku Java GUI nyní spočívá na knihovně JavaFX. Poskytuje výkonnou, ale flexibilní alternativu k vývoji GUI, na rozdíl od stávajícího rámce Swing a AWT. JavaFX dodává velké pole ovládacích prvků a komponent, které pomáhají rychle a efektivně vytvářet rozhraní GUI. Je velmi snadné vyvinout desktopovou aplikaci, která spolupracuje s back-end databází. JDBC (Java Database Connectivity) aplikace má primárně back-end databázový systém, jako je MySQL, Derby, Oracle nebo jakákoli jiná databáze. Java kód je zapsán pro načtení záznamů z jedné nebo více tabulek v databázi. SQL (Structured Query Language) dotazy jsou vyvolány z kódu Java a odeslány do databázového stroje ke zpracování. Ovladač JDBC funguje jako prostředník mezi Java programem a databází a interpretuje salvu informací sem a tam, takže jak nesrovnatelná strana, jako je databáze, tak Java program se mohou sladit s funkčním řešením. Databáze nemá absolutně žádnou představu o kódu Java, jeho syntaxi ani o ničem jiném. Jednoduše rozumí SQL a může komunikovat pouze s ním. Java je na druhé straně OOP (Object Oriented Programming) a nemá ani ponětí o SQL nebo jeho syntaxi. Aby byla komunikace možná, dodává dodavatel databáze spolu s databází nativní ovladače. Toto se nazývá ovladač JDBC. Všimněte si, že jsou k dispozici čtyři typy ovladačů. Hovorově se jim říká řidiči Type-1, Type-2, Type-3 a Type-4. Nativní ovladače jsou ovladače typu 4 a jsou nejčastěji používané. Jsou také účinnější než jiné typy. Program Java může tyto ovladače JDBC zahrnout jako externí knihovnu do programu Java, protože se běžně vyskytují v archivních souborech JAR.
JavaFX do scény
Každá databázová aplikace vyžaduje rozhraní, aby uživatel mohl pracovat s databázovými informacemi. Lepší, pokud se jedná o rozhraní GUI, kde se nemusíme snižovat k nízkoúrovňovému, zastrašujícímu příkazovému rozhraní, ale kliknutím na tlačítko získáme, co chceme. V tomto aspektu může být JavaFX s JDBC vražednou kombinací, protože má řadu vizuálně vzrušujících GUI komponent, které lze použít k reprezentaci databázových záznamů smysluplnějším způsobem. Záznamy lze například zobrazit v tabulkové formě pomocí TableView řízení. Nebo můžeme vytvořit formulář pro přidání nových záznamů do databázové tabulky. Data vložená uživatelem lze před odesláním do databáze ověřit pomocí kódu Java. Databázový stroj typu back-end získá úlevu od ověřování dat a pozastavení zpracování kvůli chybě vstupu. Navíc může být koncovým uživatelem laik s malou nebo žádnou představou o omezeních vstupních dat. To se ideálně provádí, když je vstupní formulář vytvořen pomocí TextField , Štítek , ComboBox a ListView ovládání v JavaFX. Události generované Buttonem a další ovládací prvky jsou zpracovány takovým způsobem, že uživatel je při interakci s rozhraním GUI v pohodě.
Do příkladu scénáře
V následujícím ilustrovaném příkladu implementujeme ListView operace vyhledávání zadáním textu do TextField . Vybraná položka v ListView je načtena z back-end databáze a zobrazena v TableView řízení. Jde tedy především o aplikaci typu načítání a zobrazování. Jiné databázové operace – jako je vkládání, mazání a aktualizace záznamů – nejsou implementovány kvůli omezením velikosti. Bylo by hezké cvičení je implementovat sami.
Než tedy začneme, musíme vytvořit databázovou tabulku a Java projekt. Jako back-end databázi použijeme MySQL; můžete si vybrat jakýkoli jiný, ale ujistěte se, že jste do pom.xml zahrnuli vhodné ovladače soubor. Zde je část kódu SQL pro vytvoření tabulky, vložení některých fiktivních dat a některé další operace.
CREATE DATABASE addressbook;
USE DATABASE addressbook;
DROP TABLE IF EXISTS contact;
CREATE TABLE contact(
id INT UNSIGNED NOT NULL AUTO_INCREMENT,
name VARCHAR(100) NOT NULL,
nick_name VARCHAR(20),
address VARCHAR(128),
home_phone VARCHAR(10),
work_phone VARCHAR(10),
cell_phone VARCHAR(10),
email VARCHAR(100),
birthday date,
web_site VARCHAR(100),
profession VARCHAR(100),
PRIMARY KEY (id)
);
INSERT INTO contact (name, nick_name, address, home_phone,
work_phone, cell_phone, email, birthday, web_site,profession)
VALUES ('Bruce Wayne', 'batman', 'XYZ Batcave', '9876543210',
'6278287326', '9182872363', '[email protected]',
'1976/02/03', 'batblog.com', 'Super Hero');
...
INSERT INTO contact (...) VALUES (...);
Maven Project: pom.xml
<project
xmlns_xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.mano.jdbc.examples</groupId>
<artifactId>JavaFXJDBCApp</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>JavaFXJDBCApp</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>
UTF-8
</project.build.sourceEncoding>
</properties>
<build>
<plugins>
<plugin>
<groupId>
org.apache.maven.plugins
</groupId>
<artifactId>
maven-compiler-plugin
</artifactId>
<version>2.5.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/
mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
</dependencies>
</project>
Nyní vytvoříme objekt domény, který použijeme v obou ListView a TableView protože oba spolu souvisí, jak je uvedeno v našem případě. TableView bude obsahovat pozorovatelný seznam lidí (Kontaktní osoba ) na základě jména vybrané osoby z ListView řízení. Máme také TextField pro rychlé vyhledávání položek (Kontaktní osoba name) obsažené v ListView . Při výběru konkrétní položky z ListView , spustí se dotaz SQL a načtou se relevantní záznamy pro naplnění TableView podle toho řídit.
Objekt domény:Kontaktní osoba
Kontaktní osoba třída není nic jiného než POJO reprezentace kontaktu atributy tabulky. Obsahuje konstruktor a jednoduchý get-setter metody.
package org.mano.jdbc.examples;
import java.util.Date;
public class ContactPerson {
private int id;
private String name;
private String nickName;
private String address;
private String homePhone;
private String workPhone;
private String cellPhone;
private String email;
private Date birthDate;
private String webSite;
private String profession;
public ContactPerson() {
}
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 getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
public String getHomePhone() {
return homePhone;
}<
public void setHomePhone(String homePhone) {
this.homePhone = homePhone;
}
public String getWorkPhone() {
return workPhone;
}
public void setWorkPhone(String workPhone) {
this.workPhone = workPhone;
}
public String getCellPhone() {
return cellPhone;
}
public void setCellPhone(String cellPhone) {
this.cellPhone = cellPhone;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public Date getBirthDate() {
return birthDate;
}
public void setBirthDate(Date birthDate) {
this.birthDate = birthDate;
}
public String getWebSite() {
return webSite;
}
public void setWebSite(String webSite) {
this.webSite = webSite;
}
public String getProfession() {
return profession;
}
public void setProfession(String profession) {
this.profession = profession;
}
}
Objekt přístupu k datům:ContactDAO
ContactDAO je třída objektů pro přístup k datům, která primárně zahrnuje operace přístupu k databázi. Implementuje DAO rozhraní. Toto rozhraní nemusí být v našem příkladu důležité, ale může být užitečné, pokud je aplikace rozšířena o více tříd objektů pro přístup k datům. Zde je DAO rozhraní obsahuje připojovací řetězec, ovladač a uživatelské jméno a heslo pro přístup k databázi MySQL.
DAO.java
package org.mano.jdbc.examples;
public interface DAO {
public static final String DB_URL =
"jdbc:mysql://localhost:3306/"+
"addressbook?zeroDateTimeBehavior=convertToNull";
public static final String DRIVER =
"com.mysql.jdbc.Driver";
public static final String USER = "root";
public static final String PASS = "secret";
}
Kontaktujte DAO.java
package org.mano.jdbc.examples;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
public class ContactDAO implements DAO {
private ontactPerson createContactPerson(ResultSet rs) {
ContactPerson p = new ContactPerson();
try {
p.setId(rs.getInt("id"));
p.setName(rs.getString("name"));
p.setNickName(rs.getString("nick_name"));
p.setAddress(rs.getString("address"));
p.setHomePhone(rs.getString("home_phone"));
p.setWorkPhone(rs.getString("work_phone"));
p.setCellPhone(rs.getString("cell_phone"));
p.setEmail(rs.getString("email"));
p.setBirthDate(rs.getDate("birthday"));
p.setWebSite(rs.getString("web_site"));
p.setProfession(rs.getString("profession"));
} catch (SQLException ex) {
}
return p;
}
public List<ContactPerson> getContacts() {
String sql = "Select * from contact order by name";
List<ContactPerson> list = new ArrayList<>();
try {
Class.forName(DRIVER);
Connection con = DriverManager.getConnection
(DB_URL, USER, PASS);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);
while (rs.next()) {
ContactPerson p = createContactPerson(rs);
list.add(p);
}
rs.close();
con.close();
} catch (ClassNotFoundException | SQLException ex) {
}
return list;
}
public List<ContactPerson> getContactsForName(String name) {
String sql = "Select * from contact where name like '%" +
name + "%'";
List<ContactPerson> list = new ArrayList<>();
try {
Class.forName(DRIVER);
Connection con = DriverManager.getConnection
(DB_URL, USER, PASS);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(sql);
while (rs.next()) {
ContactPerson p = createContactPerson(rs);
list.add(p);
}
rs.close();
con.close();
} catch (ClassNotFoundException | SQLException ex) {
}
return list;
}
}
Rozhraní JavaFX GUI:ContactBrowser
V aplikaci JavaFX s názvem ContactBrowser , všechny ovládací prvky jsme nastavili programově. To lze také nastavit pomocí FXML nebo nástrojů pro stavitele, jako je Scene Builder. Ale podle názoru písaře je lze použít, jakmile člověk získá dostatek zkušeností s tím, co se děje v zákulisí JavaFX. GUI je primárně souhra tří ovládacích prvků, jako je TextField (vyhledávací pole ), ListView (listView ) a TableView (contactTableView ). Kód je samovysvětlující, s komentáři uvedenými na vhodných místech. Lambda výraz se používá všude tam, kde je to možné, aby byl kód stručný. Kdekoli je potřeba, nahlédněte do dokumentace rozhraní JavaFX API.
package org.mano.jdbc.examples;
import javafx.application.Application;
import javafx.beans.value.*;
import javafx.collections.*;
import javafx.collections.transformation.*;
import javafx.geometry.Insets;
import javafx.scene.Scene;
import javafx.scene.control.*;
import javafx.scene.control.cell.PropertyValueFactory;
import javafx.scene.layout.*;
import javafx.scene.paint.Color;
import javafx.stage.Stage;
public class ContactBrowser extends Application {
// List of contact table properties
private String[] propertyName = {"id",
"name", "nickName", "address",
"homePhone", "workPhone", "cellPhone",
"email", "birthDate", "webSite",
"profession"};
private String[] propertyLabel = {"ID",
"Name", "Nick Name", "Address",
"Home Phone", "Work Phone", "Cell Phone",
"Email", "Birth Date", "Website",
"Profession"};
private ContactDAO contact = new ContactDAO();
private final GridPane gridPane = new GridPane();
private final Label lblName = new Label("Search by Name");
private final TextField searchField = new TextField();
private ObservableList<ContactPerson> observableNames;
private FilteredList<ContactPerson> filteredData;
private SortedList<ContactPerson> sortedData;
private final ListView<ContactPerson> listView;
TableView<ContactPerson> contactTableView =
new TableView<>();
public ContactBrowser2() {
lblName.setTextFill(Color.web("#0076a3"));
observableNames = FXCollections.observableArrayList
(contact.getContacts());
filteredData = new FilteredList<>
(observableNames, p -> true);
sortedData = new SortedList<>(filteredData);
listView = new ListView<>(sortedData);
}
@Override
public void start(Stage primaryStage) {
primaryStage.setTitle("Address Book");
primaryStage.setMaximized(true);
BorderPane borderPane = new BorderPane();
Scene scene = new Scene(borderPane,650,400,true);
gridPane.setPadding(new Insets(10));
gridPane.setHgap(5);
gridPane.setVgap(5);
gridPane.add(lblName, 0, 0);
gridPane.add(searchField, 0, 1);
// Search TextField event handling
searchField.textProperty()
.addListener((observable, oldValue, newValue) ->
filteredData.setPredicate(str -> {
if (newValue == null || newValue.isEmpty())
return true;
if (str.getName().toLowerCase().contains
(newValue.toLowerCase()))
return true;
return false;
}));
listView.getSelectionModel().setSelectionMode
(SelectionMode.SINGLE);
listView.setPrefHeight(Integer.MAX_VALUE);
// Sets a new cell factory to use in the ListView.
// This throws away all old list cells and new ListCells
// created with the new cell factory.
listView.setCellFactory(listView-> {
Tooltip tooltip = new Tooltip();
ListCell<ContactPerson> cell = new
ListCell<ContactPerson>() {
@Override
public voidupdateItem(ContactPerson contactPerson,
Boolean empty) {
super.updateItem(contactPerson, empty);
if (contactPerson != null) {
setText(contactPerson.getName());
tooltip.setText(contactPerson.getNickName());
setTooltip(tooltip);
} else
setText(null);
}
};
return cell;
});
gridPane.add(listView, 0, 2);
// Create and initializing TableView
ObservableList<ContactPerson> contactPeopleList
= FXCollections.observableArrayList();
contactTableView.setItems(contactPeopleList);
contactTableView.setColumnResizePolicy(
TableView.CONSTRAINED_RESIZE_POLICY);
for (int i = 0; i <
propertyLabel.length; i++) {
TableColumn<ContactPerson, Object> col
= new TableColumn<>(propertyLabel[i]);
col.setCellValueFactory(new
PropertyValueFactory<>(propertyName[i]));
contactTableView.getColumns().add(col);
}
borderPane.setCenter(contactTableView)
borderPane.setLeft(gridPane);
// TableView will populate from the contactPeopleList
// contactPeopleList will have value according to the
// item selected in the ListView
listView.getSelectionModel()
.selectedItemProperty()
.addListener(new ChangeListener<ContactPerson>() {
@Override
public void changed(
ObservableValue<? extends
ContactPerson> observable,
ContactPerson oldValue, ContactPerson newValue) {
if (observable != null &&
observable.getValue() != null) {
contactPeopleList.clear();
contactPeopleList.addAll(
contact.getContactsForName
(newValue.getName()));
}
}
});
primaryStage.setScene(scene);
primaryStage.show();
}
public static void main(String[] args) {
launch (args);
}
}
Výstup
Obrázek 1: Výstup kódu
Závěr
Aplikace JDBC s JavaFX v podstatě znamená, že rozhraní JavaFX GUI bylo použito jako front-end vývojový engine a JDBC bylo použito pro interakci s back-end databází. Mohou být různých typů s N počet v nich definovaných funkcí. Základem je aplikace CRUD. Implementovali jsme část operace vyhledávání a zobrazení. Zde je to, co můžete udělat pro jeho rozšíření:implementujte Vytvořit , Smazat a Aktualizovat operace; také můžete přidat názvy s obrázky v ListView . Hodně štěstí při kódování 😉