Ich möchte es in eine Bibliothek schaffen, weiß aber nicht, was ich tun soll ... Für diejenigen, die solche Probleme haben, werde ich die Verwendung von DAO (Data Access Object) als Beispiel erläutern.
Denken Sie also nicht plötzlich an die Logik des Inhalts. Von außen an Dinge denken. Dies führt auch zur Objektorientierung.
Insbesondere denke ich, dass das Folgende aus der Sicht des Bibliotheksbenutzers betrachtet werden sollte.
Ich möchte DAO (Data Access Object) zum Thema machen.
Schauen Sie sich zunächst den folgenden Code an Lassen Sie uns dann darüber nachdenken, welche Art von Konstruktor und Methode einfach zu verwenden sind.
DB-Zugangscode
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
/**User Master DAO*/
public class UserMstDao{
private Connection connection;
public UserMstDao(Connection connection){
this.connection = connection;
}
/**Holen Sie sich 1 Benutzerdatensatz*/
* @throws SQLException */
public UserMst selectUser(String userId) throws SQLException{
PreparedStatement ps = connection.prepareStatement("select * from UserMst where userId = ?");
ps.setObject(1, userId);
ResultSet rs = ps.executeQuery();
UserMst bean = null;
if (rs.next()) {
bean= new UserMst();
bean.userId = (Integer)rs.getObject("userId");
bean.userName = (String)rs.getObject("userName");
}
return bean;
}
/**Holen Sie sich alle Benutzerdatensätze*/
* @throws SQLException */
public List<UserMst> selectUserList() throws SQLException{
PreparedStatement ps = connection.prepareStatement("select * from UserMst");
ResultSet rs = ps.executeQuery();
List<UserMst> list = new ArrayList<>();
while (rs.next()) {
UserMst bean = new UserMst();
bean.userId = (Integer)rs.getObject("userId");
bean.userName = (String)rs.getObject("userName");
list.add(bean);
}
return list;
}
/**Benutzerstamm*/
public static class UserMst{
//Es gibt keinen Getter-Setter, da es sich um eine ausgeschnittene Implementierung handelt.
public Integer userId;
public String userName;
}
}
Wenn Sie es schreiben, ohne die Bibliothek zu verwenden, schreibt fast jeder den Code so. Verwenden von ResultSet # getObject anstelle von ResultSet # getInt Da der Rückgabewert von getInt ein primitiver Typ ist, gibt es einen Trap, der 0 wird, wenn der DB-Wert null ist. Dies ist also eine Verhinderung. Einzelheiten finden Sie unten Ich war süchtig nach getXxxx von ResultSet wegen des primitiven Typs (Java) --Qiita
Basierend auf dem, was Sie in "Das Geheimnis zum Erstellen einer Bibliothek" gemeinsam gesagt haben Überlegen wir uns, was wir mit den folgenden beiden Punkten tun sollen.
Wahrscheinlich wird jeder unterschiedliche Antworten erhalten, aber machen Sie sich keine Sorgen über solche Bibliotheken.
Zunächst habe ich mir diese Art von Code ausgedacht.
Jdbc jdbc = new Jdbc(connection);
List<UserMst> userList = jdbc.selectList("select * from UserMst", UserMst.class);
UserMst user = jdbc.selectOne("select * from UserMst where userId = ?", UserMst.class, 0);
Wenn Sie nur SQL- und Klasseninformationen sowie SQL-Parameter an die Methode übergeben, wird das Ergebnis zurückgegeben! Erstellen Sie basierend auf den Klasseninformationen ein Objekt dieser Klasse. Wenn der Feldname und der Name des DB-Elements übereinstimmen, legen Sie es in diesem Feld fest! Es ist viel weniger Code als der vorherige Code!
Sie können die Vorlagen-Engine vollständig zum Erstellen einer externen SQL-Datei verwenden oder Variablen in SQL-Anweisungen beschreiben. Der Maßstab wird riesig sein, also gehen wir diesmal nicht so weit.
import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
/**
*Machen Sie es einfach, mit Jdbc zu arbeiten.
*/
public class Jdbc {
private Connection conn;
public Jdbc(Connection conn) {
this.conn = conn;
}
/**
*Setzen Sie die Parameter auf PreparedStatement.
* @param-Kontoauszug Prepaid-Kontoauszug
* @param params parameter
* @throws SQLException
*/
private void setParams(PreparedStatement statement, Object... params) throws SQLException {
int paramNo = 1;
for( Object param : params ) {
statement.setObject(paramNo++, param);
}
}
/**
*Konvertieren Sie von DB-Daten in ein Objekt der angegebenen Klasse.
*Wenn Sie im Java-Paket eine Klasse für clazz angeben, legen Sie nur ein Element fest.
* @param rs Ergebnismenge
* @param clazz bean klasse
* @Bohne zurückgeben
* @throws IllegalAccessException
* @throws InstantiationException
* @throws SQLException
*/
private <E> E toObject(ResultSet rs, Class<E> clazz) throws InstantiationException, IllegalAccessException, SQLException {
E bean = null;
if( rs.next() ) {
Field[] fields = clazz.getFields();
bean = clazz.newInstance();
for( Field f: fields ) {
Object val = rs.getObject( f.getName() );
f.set(bean, val);
}
}
return bean;
}
/**
*Konvertieren Sie von DB-Daten in eine Liste von Objekten der angegebenen Klasse.
* @param rs Ergebnismenge
* @param clazz bean klasse
* @Bean-Liste zurückgeben
* @throws SQLException
* @throws IllegalAccessException
* @throws InstantiationException
*/
private <E> List<E> toObjectList(ResultSet rs, Class<E> clazz) throws SQLException, InstantiationException, IllegalAccessException {
List<E> rsList = new ArrayList<>();
while (rs.next()) {
Field[] fields = clazz.getFields();
E bean = clazz.newInstance();
for( Field f: fields ) {
Object val = rs.getObject( f.getName() );
f.set(bean, val);
}
rsList.add(bean);
}
return rsList;
}
/**
*SQL-Fehlerbehandlung
* @Parameter Ausnahme
* @param SQL SQL-Anweisung
* @Ausnahme zurückgeben
*/
private SQLException sqlErr(Throwable e, CharSequence sql) {
return new SQLException("sql error!\nerror occurred sql="+sql, e);
}
/**
*Einfügen, Aktualisieren usw. ausführen..
* @param sql
* @param params
* @return
* @throws SQLException
*/
public int update(String sql, Object...params) throws SQLException {
try (PreparedStatement statement = conn.prepareStatement(sql.toString())){
setParams(statement,
params);
return statement.executeUpdate();
}catch (SQLException e){
throw sqlErr(e, sql);
}
}
/**
*Holen Sie sich nur 1 Datensatz oder 1 Spalte.
* @param sql
* @param clazz
* @param params
* @return
* @throws SQLException
*/
public <E> E selectOne(String sql, Class<E> clazz, Object...params) throws SQLException {
ResultSet rs = null;
try (PreparedStatement statement = conn.prepareStatement(sql.toString())){
setParams(statement,
params);
rs = statement.executeQuery();
E val = toObject(rs, clazz);
return val;
}catch(SQLException | InstantiationException | IllegalAccessException e) {
throw sqlErr(e, sql);
}finally {
try {
if( rs != null ) {
rs.close();
}
} catch (SQLException e) {
throw sqlErr(e, sql);
}
}
}
/**
*Holen Sie sich mehrere Datensätze.
* @param sql
* @param clazz
* @param params
* @return
* @throws SQLException
*/
public <E> List<E> selectList(String sql, Class<E> clazz, Object...params) throws SQLException {
ResultSet rs = null;
try (PreparedStatement statement = conn.prepareStatement(sql.toString())){
setParams(statement,
params);
rs = statement.executeQuery();
List<E> rsList = toObjectList(rs, clazz);
return rsList;
}catch(SQLException | InstantiationException | IllegalAccessException e) {
throw sqlErr(e, sql);
}finally {
try {
if( rs != null ) {
rs.close();
}
} catch (SQLException e) {
throw sqlErr(e, sql);
}
}
}
}
Der Punkt dieses Codes ist Sie erhalten das Array "java.lang.reflect.Field" von Class und drehen es um. Dies nennt man Reflexion. Wird in vielen FW / Bibliotheken verwendet.
Recommended Posts