Cet article est un article qui libère le stress d'un SE. Selon le contenu, cela peut être utile pour quelqu'un.
Pour le SGBDR qui n'a pas réussi à se normaliser, utilisez la réflexion ~~ pour actualiser la source afin de soulager le stress. Je ne pense pas à la performance.
Tout d'abord, je voudrais dire que je ne veux pas critiquer les technologies héritées telles que les hôtes. Segment chez l'hôte? Il semble qu'il soit courant d'ajouter un suffixe à. Il semble que le nombre de cas de réduction de la taille des hôtes Web diminue ces jours-ci, mais c'est une libération de stress personnel pour l'échec de la normalisation que j'ai vu récemment dans le cas de la réduction de la taille.
Au moment de la réduction des effectifs, des éléments tels que les éléments 01 à 05 ont été placés dans une seule table, comme le pensait l'hôte, ce qui est la racine de tout mal.
Exemple) Nom TBL Table de magasin de gestion de compte Colonne Code de magasin (PK) Branche 01 Branche 02 Branche 03 Branche 04 Branche 05
Je voulais avoir une succursale suspendue sous le magasin parent qui gère le compte. Cependant, il doit être normalisé correctement pour créer une «table de branche qui se bloque à partir du code de magasin parent». Il est très vulnérable aux changements lorsque le nombre de succursales augmente.
Je suis également ingénieur. Et depuis que je suis embauché, je suis un adulte (30 ans environ) qui essaie d'avaler ce qui ne peut pas être changé et vise à bien réagir.
Tout d'abord, préparez un getter avec le suffixe. C'est juste long, alors pliez-le.
suffixMethods.java
package suffixMethodsCall;
public class suffixMethods {
private static String RETURN_CODE_A = "A";
private static String RETURN_CODE_B = "B";
private static String RETURN_CODE_C = "C";
private static String RETURN_CODE_D = "D";
private static String RETURN_CODE_E = "E";
private static String RETURN_CODE_F = "F";
private static String RETURN_CODE_G = "G";
private static String RETURN_CODE_H = "H";
private static String RETURN_CODE_I = "I";
private static String RETURN_CODE_J = "J";
public String getReturnCode01() {
return RETURN_CODE_A;
}
public String getReturnCode02() {
return RETURN_CODE_B;
}
public String getReturnCode03() {
return RETURN_CODE_C;
}
public String getReturnCode04() {
return RETURN_CODE_D;
}
public String getReturnCode05() {
return RETURN_CODE_E;
}
public String getReturnCode06() {
return RETURN_CODE_F;
}
public String getReturnCode07() {
return RETURN_CODE_G;
}
public String getReturnCode08() {
return RETURN_CODE_H;
}
public String getReturnCode09() {
return RETURN_CODE_I;
}
public String getReturnCode10() {
return RETURN_CODE_J;
}
}
J'ai fait un cours d'exécution.
suffixMethodsCaller.java
package suffixMethodsCall;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
public class suffixMethodsCaller {
/**
* <pre>
*Exécutez tous les getters avec le suffixe inclus dans suffixMethods,
*Vérifiez que le matchTargetCode au début est inclus.
* </pre>
*/
public static void main(String[] args) {
//Chaîne de caractères à mettre en correspondance
String matchTargetCode = "J";
//Liste de codes obtenue à partir de la méthode avec suffixe
List<String> codeList = new ArrayList<String>();
//Spécifiez la classe et la méthode sous forme de chaîne de caractères
suffixMethods sm = new suffixMethods();
String clazz = sm.getClass().getName();
String baseSuffixMethod = "getReturnCode";
int suffixPartStart = 1;
int suffixPartEnd = 10;
//Exécuter une méthode avec suffixe en utilisant la réflexion
try {
Class<?> c = Class.forName(clazz);
Object myObj = c.newInstance();
//Bouclez la partie suffixe et plongez dans la liste de codes
for ( ; suffixPartStart <= suffixPartEnd; suffixPartStart++) {
//Paramètres de la méthode d'exécution
Method m = c.getMethod(baseSuffixMethod + String.format("%02d", suffixPartStart));
//Pack dans la liste de codes
codeList.add(m.invoke(myObj).toString());
}
} catch(ReflectiveOperationException e) {
e.printStackTrace();
}
//Sortie avec booléen si la chaîne de caractères à mettre en correspondance est incluse dans la liste des résultats d'exécution de la méthode avec suffixe
System.out.println(codeList.contains(matchTargetCode));
}
}
C'est encore un peu sale, mais j'ai atteint mon objectif pour le moment.
Dans ce cas, j'ai utilisé 10 méthodes avec suffixe comme exemple, mais si le nombre augmente, les performances seront un problème.
Vous pouvez découper la partie d'exécution selon une autre méthode et la rendre plus rafraîchissante.
Cependant, si vous accédez à l'API de réflexion ou au code en dur et que vous faites correspondre tout avec String.equals, lequel est le meilleur?
Je vais le vérifier à nouveau.
Cette fois, je l'ai codé dans le but de soulager le stress, mais je n'ai pas eu beaucoup d'occasions d'utiliser la réflexion jusqu'à présent, donc cela a pris plus de temps que prévu.
La réduction des effectifs et la migration des PJ sont toujours très ennuyeuses. Vous pouvez le faire honnêtement, mais il y a beaucoup de choses comme ça.
Recommended Posts