Je veux en faire une bibliothèque, mais je ne sais pas quoi faire ... Pour ceux qui ont de tels problèmes, je vais expliquer en utilisant DAO (Data Access Object) comme exemple.
Autrement dit, ne pensez pas soudainement à la logique du contenu. Penser aux choses de l'extérieur. Cela conduit également à l'orientation de l'objet.
Plus précisément, je pense que ce qui suit devrait être considéré du point de vue de l'utilisateur de la bibliothèque.
Je voudrais faire de DAO (Data Access Object) le thème.
Tout d'abord, jetez un œil au code ci-dessous Ensuite, réfléchissons au type de constructeur et de méthode faciles à utiliser.
Code d'accès DB
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
/**Maître utilisateur DAO*/
public class UserMstDao{
private Connection connection;
public UserMstDao(Connection connection){
this.connection = connection;
}
/**Obtenez 1 enregistrement d'utilisateur*/
* @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;
}
/**Obtenez tous les enregistrements d'utilisateurs*/
* @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;
}
/**Maître des utilisateurs*/
public static class UserMst{
//Il n'y a pas de setter getter car il s'agit d'une implémentation découpée.
public Integer userId;
public String userName;
}
}
Si vous l'écrivez sans utiliser la bibliothèque, presque tout le monde écrira le code comme celui-ci. Utilisation de ResultSet # getObject au lieu de ResultSet # getInt Étant donné que la valeur de retour de getInt est un type primitif, il existe une interruption indiquant qu'elle devient 0 si la valeur de la base de données est nulle, il s'agit donc d'une prévention. Pour plus de détails, voir ci-dessous ResultSet getXxxx était accro au type primitif (Java) --Qiita
Basé sur ce que vous avez dit dans "Le secret pour créer une bibliothèque" ensemble Réfléchissons à ce qu'il faut faire avec les deux points suivants.
Tout le monde aura probablement des réponses différentes, mais ne vous inquiétez pas des bibliothèques comme ça.
Tout d'abord, j'ai inventé ce genre de code.
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);
Si vous ne transmettez que des informations SQL et de classe et des paramètres SQL à la méthode, le résultat sera renvoyé! Sur la base des informations de classe, créez un objet de cette classe, et si le nom du champ et le nom de l'élément de base de données correspondent, définissez-le dans ce champ! C'est beaucoup moins de code que le code précédent!
Vous pouvez utiliser pleinement le moteur de modèle pour créer un fichier SQL externe, ou vous pouvez décrire des variables dans des instructions SQL, L'échelle sera énorme, alors n'allons pas aussi loin cette fois.
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;
/**
*Rendre Jdbc facile à utiliser.
*/
public class Jdbc {
private Connection conn;
public Jdbc(Connection conn) {
this.conn = conn;
}
/**
*Définir les paramètres sur PreparedStatement.
* @relevé param Relevé prépayé
* @param paramètre params
* @throws SQLException
*/
private void setParams(PreparedStatement statement, Object... params) throws SQLException {
int paramNo = 1;
for( Object param : params ) {
statement.setObject(paramNo++, param);
}
}
/**
*Convertir des données de base de données en un objet de la classe spécifiée.
*Si vous spécifiez une classe sous le package java pour clazz, définissez un seul élément
* @jeu de résultats param rs
* @classe de haricots clazz param
* @haricot de retour
* @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;
}
/**
*Conversion des données DB en une liste d'objets de la classe spécifiée.
* @jeu de résultats param rs
* @classe de haricots clazz param
* @retourner la liste des grains
* @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;
}
/**
*Gestion des erreurs SQL
* @exception de param e
* @instruction SQL param sql
* @exception de retour
*/
private SQLException sqlErr(Throwable e, CharSequence sql) {
return new SQLException("sql error!\nerror occurred sql="+sql, e);
}
/**
*Exécutez l'insertion, la mise à jour, etc..
* @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);
}
}
/**
*Obtenez seulement 1 enregistrement ou 1 colonne.
* @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);
}
}
}
/**
*Obtenez plusieurs enregistrements.
* @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);
}
}
}
}
Le but de ce code est
Vous obtenez le tableau de java.lang.reflect.Field de Class et vous le tournez.
C'est ce qu'on appelle la réflexion.
Utilisé dans de nombreux FW / bibliothèques.
Recommended Posts