Wie der Titel schon sagt, habe ich diesmal eine App erstellt, die Java-Dateien der Entity-Klasse generiert! Es wurde bestätigt, dass es mit OracleDB11g2R und MySQL funktioniert.
Test.java
import java.util.ArrayList;
import annotation.Entity;
import annotation.Table;
import annotation.column;
import annotation.id;
@Entity
@Table("test")//Der in der Datenbank registrierte Tabellenname wird angezeigt.
public class Test {
@id//Primärschlüssel
@column//Säule
private String num;
@column//Säule
private String namename;
public void setNum(String num) {
this.num = num;
}
public String getNum() {
return this.num;
}
public void setNamename(String namename) {
this.namename = namename;
}
public String getNamename() {
return this.namename;
}
}
| Name der Klasse | Erläuterung |
|---|---|
| EntityGenerator | Eine Klasse, die JavaFile erstellt und den Inhalt der Datei schreibt, während die folgende Klasse aufgerufen wird |
| DBReader | Klassen, die eine Verbindung zur Datenbank herstellen und Metadaten abrufen (Tabellenliste, Spaltenname, Primärschlüssel usw.)..） |
| DataTypeMapper | Klasse, die den Spaltendatentyp in den DB-Datentyp → Java-Datentyp konvertiert |
| EntityInfo | Eine Klasse, die die von DBReader erfassten Informationen speichert |
| Anmerkungsgruppe | @Table, @Id, @column |
EntityGenerator
interface
EntityGenerator.java
package entityCreater.generator;
public interface EntityGenerator {
void generateEntity();
}
Implementierungsklasse
EntityGeneratorImplements.java
package entityCreater.generator;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import entityCreater.info.EntityInfo;
import entityCreater.reader.DBReaderImplements;
public class EntityGeneratorImplements implements EntityGenerator{
//Wo soll die Datei gespeichert werden?
String filePlace;
/**
*Konstrukteur
*/
public EntityGeneratorImplements(String filePlace) {
this.filePlace = filePlace;
}
/**
*Methode zur Erstellung von Entitäten
*/
@Override
public void generateEntity() {
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Starten Sie die EntityFile-Erstellungsmethode");
ArrayList<EntityInfo> entityInfos = new DBReaderImplements().read();
for(EntityInfo ei : entityInfos) {
createFile(ei);
}
}
/**
*EntityFile-Erstellungsmethode
* @param entityInfo
*/
private void createFile(EntityInfo entityInfo) {
//Informationen zur DB-Tabelle abrufen
String tableName = entityInfo.getTableName();
String id = entityInfo.getId();
List<String[]> columns = entityInfo.getColumns();
//Klassennamen generieren
String className = tableName.substring(0, 1).toUpperCase() + tableName.substring(1).toLowerCase();
//EntityFile-Klasse
File entityFile = new File(filePlace + "/" + className + ".java");
try{
if (entityFile.createNewFile()){
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Die Datei wurde erfolgreich erstellt.");
}else{
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Erstellen der Datei fehlgeschlagen");
}
}catch(IOException e){
System.out.println(e);
}
//Erstellen Sie den Inhalt der Datei
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Erstellen Sie den Inhalt der Datei.");
try(PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(entityFile, true)));) {
//Anmerkungsimportanweisung
pw.println("import annotation.Entity;");
pw.println("import annotation.Table;");
pw.println("import annotation.id;");
pw.println("import annotation.column;");
pw.println("");
//Klassenerklärung(Start)
pw.println("@Entity");
pw.println("@Table(\"" + tableName + "\")");
pw.println("public class " + className + " {");
pw.println("");
//Spaltendeklaration
Iterator<String[]> it = columns.iterator();
while(it.hasNext()) {
String[] colum = it.next();
//Spaltendeklaration
if(colum[1].equals(id)) {
pw.println(" @id");
}
pw.println(" @column");
pw.println(" private " + colum[0] + " " + colum[1] + ";");
pw.println("");
}
//Setter.Getter Erklärung
//Bringen Sie Iterator zum Anfang zurück
it = columns.iterator();
while(it.hasNext()) {
String[] colum = it.next();
//Setter-Erklärung
pw.println(" public void set" + colum[1].substring(0, 1).toUpperCase() + colum[1].substring(1).toLowerCase() + "(" + colum[0] + " " + colum[1] + ") {");
pw.println(" this." + colum[1] + " = " + colum[1] + ";");
pw.println(" }");
pw.println("");
//Getter Erklärung
pw.println(" public " + colum[0] + " get" + colum[1].substring(0, 1).toUpperCase() + colum[1].substring(1).toLowerCase() + "() {");
pw.println(" return this." + colum[1] + ";");
pw.println(" }");
pw.println("");
}
//Klassenerklärung(Ende)
pw.println("}");
//Anzeige beenden
System.out.println(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("*************************************************************");
System.out.println("***Fügen Sie die SUCCESS-Paketdeklaration und die Multiplizitätsdeklaration hinzu.***");
System.out.println("*************************************************************");
} catch (IOException e) {
e.printStackTrace();
}finally {
}
}
}
DBReader interface
DBReader.java
package entityCreater.reader;
import java.util.ArrayList;
import entityCreater.info.EntityInfo;
public interface DBReader {
ArrayList<EntityInfo> read();
}
Implementierungsklasse
DBReaderImplements.java
package entityCreater.reader;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Iterator;
import container.DBConfig;
import container.EnvironmentConfigReader;
import db_access.DBAccess;
import entityCreater.dataTypeMapper.DataTypeMapper;
import entityCreater.info.EntityInfo;
public class DBReaderImplements implements DBReader{
@Override
public ArrayList<EntityInfo> read() {
//Zum Speichern von Metadaten
ResultSet rs = null;
//Zum Speichern von Tabelleninformationen
ArrayList<String> tableNames = new ArrayList<>();
//Zum Speichern von Entitätsinformationen
ArrayList<EntityInfo> entityInfos = new ArrayList<>();
//DB-Einstellungen abrufen
/*
*Sorgen Sie sich nicht zu sehr um die folgenden Bereiche.
*Rufen Sie die DB-Verbindungsinformationen (URL, PASSWORT usw.) aus Ihrer eigenen yaml-Datei ab.
*Ich erhalte gerade die Verbindung mit der Datenbank in der DBAccess-Klasse.
*Die Quellen von EnvironmentConfigReader und DBAccess werden als Referenz aufgelistet.
*/
/*
*von hier
*/
EnvironmentConfigReader ecr = new EnvironmentConfigReader();
DBConfig dbc = ecr.read();
String dbName = dbc.getDbName();
//Verbindung herstellen
DBAccess dba = new DBAccess(dbc);
/*
*Bisher
*/
try {
//Verbindung mit der Datenbank
Connection con = dba.getConnection();
//Datenbank-Metadaten abrufen
DatabaseMetaData dbmd = con.getMetaData();
//Tabellennamen abrufen
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Holen Sie sich die Tabellenliste");
String[] types = { "TABLE", "VIEW", "SYSTEM TABLE" };
rs = dbmd.getTables(dbName, null, "%", types);
while (rs.next()) {
String tableName = rs.getString("TABLE_NAME");
//Speicherung des Tabellennamens
tableNames.add(tableName);
}
//Klassen zum Speichern von Tabelleninformationen
Iterator<String> tableNameList = tableNames.iterator();
String tableName;
String id = null;
ArrayList<String[]> columns;
while (tableNameList.hasNext()) {
//Holen Sie sich TableName
tableName = tableNameList.next();
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Tabellenname:" + tableName + "Entitätsklasse wird generiert");
//Holen Sie sich alle Spalteninformationen der Tabelle
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Tabellenname:" + tableName + "Holen Sie sich alle Spalteninformationen von");
rs = dbmd.getColumns(dbName, null, tableName, "%");
//Zur Spaltenspeicherung
columns = new ArrayList<>();
while (rs.next()) {
//Konvertieren Sie vom SQL-Datentyp in den Java-Datentyp
String dataType = DataTypeMapper.dataTypeChange(rs.getString("TYPE_NAME"));
//Konvertieren Sie Variablennamen in Kleinbuchstaben
String columnName = rs.getString("COLUMN_NAME").toLowerCase();
String[] column = { dataType, columnName };
columns.add(column);
}
//Primärschlüssel abrufen
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Tabellenname:" + tableName + "Holen Sie sich den Primärschlüssel für");
ResultSet primaryKeys = dbmd.getPrimaryKeys(dbName, null, tableName);
if (primaryKeys.next()) {
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Tabellenname:" + tableName + "Primärschlüssel ist" + primaryKeys.getString("COLUMN_NAME") + "ist");
id = primaryKeys.getString("COLUMN_NAME").toLowerCase();
}
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Tabelleninformationen werden in der EntityInfo-Klasse gespeichert");
//Speicherklasse für Tabelleninformationen
EntityInfo ei = new EntityInfo();
//Legen Sie TableName in der Tabelleninformationsspeicherklasse fest
ei.setTableName(tableName);
//Legen Sie die ID in der Speicherklasse für Tabelleninformationen fest
ei.setId(id);
//Legen Sie die Spalteninformationen in der Speicherklasse für Tabelleninformationen fest
ei.setColumns(columns);
entityInfos.add(ei);
}
rs.close();
//Datenbank schließen
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Verwerfen Sie die Verbindung mit der DB");
con.close();
} catch (Exception e) {
System.out.println("Ausnahme aufgetreten");
e.printStackTrace();
}
return entityInfos;
}
}
DataTypeMapper
DataTypeMapper.java
package entityCreater.dataTypeMapper;
public class DataTypeMapper {
/**
*Klasse zum Konvertieren vom SQL-Datentyp in den Java-Datentyp
* @param sqlDataType
* @return
*/
public static String dataTypeChange(String sqlDataType) {
String javaDataType = null;
switch (sqlDataType) {
case "CHAR":
case "VARCHAR":
case "LONGVARCHAR":
javaDataType = "String";
break;
case "NUMERIC":
case "DECIMAL":
javaDataType = "java.math.BigDecimal";
break;
case "BIT":
javaDataType = "boolean";
break;
case "TINYINT":
javaDataType = "byte";
break;
case "SMALLINT":
javaDataType = "short";
break;
case "INTEGER":
case "INT":
javaDataType = "Integer";
break;
case "BIGINT":
javaDataType = "long";
break;
case "REAL":
javaDataType = "float";
break;
case "FLOAT":
case "DOUBLE":
javaDataType = "double";
break;
case "BINARY":
case "VARBINARY":
case "LONGVARBINARY":
javaDataType = "byte[]";
break;
case "DATE":
javaDataType = "java.sql.Date";
break;
case "TIME":
javaDataType = "java.sql.Time";
break;
case "TIMESTAMP":
javaDataType = "java.sql.Timestamp";
break;
default:
break;
}
return javaDataType;
}
}
EntityInfo
EntityInfo.java
package entityCreater.info;
import java.util.List;
/**
*
*Speicherklasse für Entitätsinformationen
* @author okamotoyuuma
*
*/
public class EntityInfo {
//Tabellenname
private String tableName;
//Primärschlüsselname
private String id;
//Alle Spaltennamen und -typen
private List<String[]> columns;
/**
* (non-javadoc)
* getter setter
* @return
*/
public String getTableName() {
return tableName;
}
public void setTableName(String tableName) {
this.tableName = tableName;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public List<String[]> getColumns() {
return columns;
}
public void setColumns(List<String[]> columns) {
this.columns = columns;
}
}
@ Table Annotation (Klasse, die den Tabellennamen im Attribut speichert)
Table.java
package annotation;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
@Target(TYPE)
@Retention(RUNTIME)
public @interface Table {
String value();
}
@ ID Annotation (dem Primärschlüsselfeld zugewiesen)
id.java
package annotation;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
@Retention(RUNTIME)
@Target(FIELD)
public @interface id {
}
@ columnn-Annotation (zum Spaltenwert der Tabelle hinzugefügt)
column.java
package annotation;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.*;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
@Retention(RUNTIME)
@Target(FIELD)
public @interface column {
}
Erstellen Sie eine Hauptmethode und geben Sie den Speicherort für die generierte Entitätsklasse wie unten gezeigt an.
main.java
public class main {
public static void main(String[] args) {
EntityGenerator eg = new EntityGeneratorImplements("Weg zum Ziel");
eg.generateEntity();
}
}
Dieses Mal habe ich versucht, die Entitätsklasse automatisch zu generieren. Die Quelle und Logik sind noch unreif und kindisch, aber es war eine sehr gute Erfahrung, weil ich nie eine Datei erstellt hatte! Wenn Sie Vorschläge zu Punkten haben, die nicht berücksichtigt wurden, oder Verbesserungen in der Quelle, würden wir uns freuen, wenn Sie dies kommentieren könnten.
Im folgenden Referenzabschnitt werden DB-Einstellungsdateien, zu lesende Klassen usw. aufgeführt, die in der obigen Quelle nicht aufgeführt sind. Wenn Sie interessiert sind, schauen Sie bitte.
DB-Einstellungsdatei
DBProfile.yaml
#
!!container.DBConfig #Klassenpfad für die Einstellung der DB-Definition
driver: com.mysql.cj.jdbc.Driver #Fahrername
url: jdbc:mysql://localhost:3306/DB-Name#DB URL
user:DB-Benutzername#DB-Benutzer
password: password #DB-Passwort
numberOfAccess: 10 #Anzahl der Verbindungen
dbName:Name der Datenbank#DB-Name
dbType: MySQL #DB-Typ (diesmal werden nur MySQL und Oracle DB unterstützt)
schema:Schemaname
Klasse zum Speichern von Einstellungsinformationen
DBConfig.java
package container;
//Datenbankkonfigurationsdatei
public class DBConfig {
//Fahrername
String driver;
//DB URL
String url;
//DB-Benutzer
String user;
//Passwort
String password;
//Schemaname
String schema;
//Anzahl der hergestellten Verbindungen
int numberOfAccess;
//DBName
String dbName;
//DBType
String dbType;
public String getDriver() {
return driver;
}
public void setDriver(String driver) {
this.driver = driver;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUser() {
return user;
}
public void setUser(String user) {
this.user = user;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getSchema() {
return schema;
}
public void setSchema(String schema) {
this.schema = schema;
}
public int getNumberOfAccess() {
return numberOfAccess;
}
public void setNumberOfAccess(int numberOfAccess) {
this.numberOfAccess = numberOfAccess;
}
public String getDbName() {
return dbName;
}
public void setDbName(String dbName) {
this.dbName = dbName;
}
public String getDbType() {
return dbType;
}
public void setDbType(String dbType) {
this.dbType = dbType;
}
}
EnvironmentConfigReader-Klasse, die die obige Konfigurationsdatei liest
EnvironmentConfigReader.java
package container;
import org.yaml.snakeyaml.Yaml;
public class EnvironmentConfigReader implements Reader<DBConfig>{
//DB-Konfigurationsdatei
static String configFileName = "DBProfile.yaml";
//Methode zum Abrufen der DB-Einstellungen aus der Yaml-Datei(Keine Argumente)
@Override
public DBConfig read() {
//Speicherort für die Protokollgenerierung
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
//Inhalte verarbeiten
System.out.println(configFileName + "Wird geladen.");
Yaml yaml = new Yaml();
DBConfig dbc = (DBConfig) yaml.load(getClass().getResourceAsStream(configFileName));
//Speicherort für die Protokollgenerierung
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
//Inhalte verarbeiten
System.out.println(configFileName + "Wurde geladen.");
return dbc;
}
//Methode zum Abrufen der DB-Einstellungen aus der Yaml-Datei(Mit Argument)
@Override
public DBConfig read(String setConfigFileName) {
//Speicherort für die Protokollgenerierung
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
//Inhalte verarbeiten
System.out.println(configFileName + "Wird geladen.");
//Legen Sie den angegebenen Dateinamen fest
if (configFileName != null) {
configFileName = setConfigFileName;
}
Yaml yaml = new Yaml();
DBConfig dbc = (DBConfig) yaml.load(getClass().getResourceAsStream(configFileName));
//Speicherort für die Protokollgenerierung
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
//Inhalte verarbeiten
System.out.println(configFileName + "Wurde geladen.");
return dbc;
}
}
Klasse, die die Verbindung mit DB speichert
DBAccess.java
package db_access;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import container.DBConfig;
public class DBAccess {
//Mitglied
private Connection conn = null;
public DBAccess(DBConfig dbc) {
try {
Class.forName(dbc.getDriver());
conn = DriverManager.getConnection(dbc.getUrl(), dbc.getUser(), dbc.getPassword());
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Verbunden mit DB");
//Auto Commit OFF
conn.setAutoCommit(false);
} catch (SQLException | ClassNotFoundException e) {//Verbindung konnte nicht hergestellt werden
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Verbindung zur Datenbank fehlgeschlagen");
e.printStackTrace();
}
}
//Verteilen Sie die Verbindung
public Connection getConnection() {
return conn;
}
//Verbindung trennen
public void closeConnection() {
try {
conn.close();
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Von der DB getrennt");
} catch (SQLException e) {
//TODO automatisch generierter Fangblock
System.out.print(Thread.currentThread().getStackTrace()[1].getClassName() + ":");
System.out.println("Verbindung zur Datenbank konnte nicht getrennt werden");
e.printStackTrace();
}
}
}
Recommended Posts