Die benutzerdefinierte Namenskonvertierung von BeetlSQL entfernt Pojo und Tabellenpräfix

Manchmal stimmt unser Datenbankdesign möglicherweise nicht vollständig mit der Codesprache überein. Beispielsweise fügen wir vor jeder Tabelle in der Datenbank ein bestimmtes Präfix hinzu, um sie in BeetlSQL vom Namen des Codes zu unterscheiden Tabelle Die entsprechenden Namen werden mit NameConversion konvertiert. BeetlSQL verfügt über integrierte Konverter wie DefaultNameConversion und JPANameConversion, die grundsätzlich die meisten Anforderungen erfüllen können.

Vorwort

Um den Inhalt dieses Artikels zu verstehen, müssen Sie zunächst die beiden Projekte Beetl und BeetlSQL verstehen. Es handelt sich um Java-Template-Engines und die Java-Datenbank ist ein voll funktionsfähiges Dao Derzeit hat der Beamte Integrationslösungen für Beetl und BeetlSQL mit verschiedenen Mainstream-MVC-Frameworks auf dem Markt bereitgestellt

Ich wage nicht zu sagen, dass Beetl besser ist als einige bekannte Template-Engines wie JSP, FreeMarker, Velocity usw. Wie gut es ist, aber ich möchte sagen, dass Beetl aufgrund meiner persönlichen Erfahrung definitiv nicht schlechter sein wird als sie und BeetlSQL nicht schlechter sein wird als Hibernate und MyBatis

Wenn Sie interessiert sind, würden Sie es tun Wenn Sie mehr über Beetl und BeetlSQL erfahren möchten, können Sie das offizielle Beetl-Forum für Details besuchen.

Warum gibst du Beetl nicht die Chance, dich zu beweisen und dir selbst die Chance zu geben, zu lernen und zu arbeiten? Vielleicht wirst du dich wie ich in es verlieben.

Text

In diesem Artikel wird das Problem des Entfernens des Namenspräfixes der Zuordnungstabelle durch einen benutzerdefinierten Konverter bei der Verwendung von BeetlSQL zum automatischen Generieren von Pojo-Objekten erläutert.

Sehen wir uns zunächst eine Reihe von Entwicklungssituationen an:

Angenommen, es gibt derzeit ein Projekt beetl. Beim Entwerfen der Datenbank haben alle Tabellennamen das Projektpräfix bt_, also alle Tabellen Beginnen wir mit bt_, wie bt_user, bt_role, bt_user_role. Wenn wir ein solches Tabellennamendesign sehen, denken wir vielleicht zuerst daran, UnderlinedNameConversion für die Konvertierung zu verwenden, also:

bt_user-> 🎜>

bt_role -> BtRole

bt_user_role -> BtUserRole

Ich glaube, dass viele Leute, wie ich, eine solche Benennung nicht akzeptieren können, deshalb müssen wir selbst eine Namensumwandlung definieren Konvertierung. Entfernen Sie das Bt-Präfix, das automatisch hinzugefügt wird, wenn Table Pojo generiert.

Die Kernmethoden getPropertyName, getColName, getTableName und getClassName in NameConversion sind anhand der Methodennamen und Parameter leicht zu verstehen

Wir müssen also nur eine NameConversion-Methode erneut implementieren, um Tabellennamen in Klassennamen und Klassennamen in Tabellennamen gemäß unseren eigenen tatsächlichen Anforderungen umzuwandeln.

Spezifische Methode: Zuerst erstellen wir eine neue Klasse, die von der DefaultNameConversion-Klasse erbt, überschreiben die Methoden getClassName bzw. getTableName und aktivieren schließlich unsere eigene Conversion

@Override

@Overridepublic String getTableName(Class<?> c) {    //遵循BeetlSQL规范，@Table拥有最高优先级
    Table table = (Table)c.getAnnotation(Table.class);    if(table!=null){        return table.name();
    }    //UserRole -> user_role
    String tableName = StringKit.enCodeUnderlined(c.getSimpleName());    //user_role -> bt_user_role
    return "bt_"+tableName;
}@Overridepublic  String getClassName(String tableName){    //假定所有表都是以bt_开头
    //bt_user_role -> user_role
    tableName = tableName.substring(tableName.indexOf("_")+1);    //user_role -> userRole
    String clsName = StringKit.deCodeUnderlined(tableName);    //userRole -> UserRole
    return StringKit.toUpperCaseFirstOne(clsName);
}

Auf diese Weise können Sie die Präfixe ganz einfach aus den Tabellennamen der gesamten Datenbank entfernen.

Es ging nach hinten los! ! ! Wir können oft auf speziellere Situationen stoßen. Schauen wir uns eine Reihe von Situationen an, denen die Entwicklung begegnen kann:

Derzeit gibt es ein Projekt mit einigen Benutzerdatentabellen (z. B. Benutzer) im Hintergrund. Um sie während der Entwicklung zu unterscheiden, wurden den Tabellen verschiedener Funktionsmodule schließlich unterschiedliche Präfixe hinzugefügt Es kann in der Form usr_user, mgr_admin und base_city vorliegen. Wenn wir die oben beschriebene Methode verwenden, um das Präfix einheitlich zu entfernen und dann das Präfix einheitlich hinzuzufügen, ist dies der Fall Es ist schwierig, sie nach dem Entfernen des Präfixes direkt wiederherzustellen.

Ursprünglich war ich auf dieses Problem gestoßen und habe das Präfix entfernt und automatisch @Table-Anmerkungen zu allen Pojos hinzugefügt, wie z. B. usr_user und mgr_admin im Beispiel und base_city Generieren Sie abschließend das folgende Formular:

usr_user -> @Table(name="usr_user") User

mgr_admin -> @Table(name="mgr_admin") Admin

base_city -> @Table(name="base_city") Stadt

理想是丰满的，现实是骨感的。在QQ上与作者沟通遇到这种情况时的解决方案时发现可能会出现这样的情况： 前台用户使用的数据表可能是 usr_user，而后台管理员也属于用户呀，因此可能后台管理员的数据表为mgr_user，最后这样会导致两个类冲突了，生成代码的时候可能会被覆盖一个类，是有问题的。好在机智如我~遇到这样的根据功能模块给不同的表加上不同的前缀，我们在Java程序开发时也经常会使用不同的包名来区分不同的模块，我可以将不同前缀的实体放到对应的包下面，还原表名的时候读取一下包名即可反向解析出表名，下面是我的具体实现：

@Overridepublic  String getClassName(String tableName){   
 //为了安全起见，做了个判断，理论上项目数据库设计好了应该是无需判断直接截取所有前缀
    //usr_user_role -> user_role
    if(tableName.matches("^(usr_|base_|mgr_).*")){
        tableName = tableName.substring(tableName.indexOf("_")+1);
    }    //user_role -> UserRole
    String clsName = StringKit.deCodeUnderlined(tableName);    return StringKit.toUpperCaseFirstOne(clsName);
}@Overridepublic String getTableName(Class<?> c) {
    Table table = (Table)c.getAnnotation(Table.class);    if(table!=null){        return table.name();
    }    //获取Package 最后一层 xxx.pojo.usr  ->  Usr
    String pkg = c.getPackage().getName();
    pkg = pkg.substring(pkg.lastIndexOf(".")+1);
    pkg = Character.toUpperCase(pkg.charAt(0))+pkg.substring(1);    //Usr+User -> UsrUser -> usr_user
    return StringKit.enCodeUnderlined(pkg+c.getSimpleName());
}

然后在使用BeetlSQL反向生成Pojo的时候，使用Filter将数据表分门别类的生成到不同的包下面

//记得初始化SQLManager时要使用自己写好的NameConvertionSQLManager sql = initSQLManager();
GenConfig config = new GenConfig();
sql.genALL("xxxx.pojo.usr", config, new GenFilter(){    @Override
    public boolean accept(String tableName) {        return tableName.startsWith("usr_");
    }
});
sql.genALL("xxxx.pojo.mgr", config, new GenFilter(){    @Override
    public boolean accept(String tableName) {        return tableName.startsWith("mgr_");
    }
});
sql.genALL("xxxx.pojo.base", config, new GenFilter(){    @Override
    public boolean accept(String tableName) {        return tableName.startsWith("base_");
    }
});

最终会在项目中会生成以下Pojo

usr_user -> xxxx.pojo.usr.User.java

mgr_admin -> xxxx.pojo.mgr.Admin.java

base_city -> xxxx.pojo.base.City.java

即便是有类名冲突的，因为在不同的包下，所以也不会影响

就这样一次轻松而又愉快的BeetlSQL自定义去除Pojo和表前缀被解决啦~

最后

之前所有项目的开发都是Jsp，几乎没使用过其他第三方模板库，因为一次误打误撞让我认识了Beetl，它的轻巧，它独特的语法都深深的吸引了我，因为Beetl又让我认识了BeetlSQL，抱着试一试的心态尝试过之后总有一种把当前项目（使用的Hibernate）推倒重来的冲动，虽然最后因为项目的工程量和工期原因，当前的这个项目最终还是使用了Hibernate，但是我可以确定的是，在以后的开发道路上，如果允许，如果没有能让我更心动的通用Dao，BeetlSQL将会是我不二的选择。

今天在这里分享这篇自定义NameConvertion的功能，其实并没有多少技术含量，更多的是想做一次简单的推广，让更多人知道Beetl，让更多人爱上Beetl~