Morphium based Blog software Jblog

Ich habe ja schon vor einiger Zeit den Sprung weg von Wordpress "gewagt" und auch darüber berichtet. Jetzt ist das schon über 2 Jahre () her und da ist es doch an der Zeit mal ein Fazit zu ziehen und ein wenig zu berichten, wie es so lief.

Jblog - the good the bad the ugly

Das gute vorweg: gehackt wurde der Server damit nicht. Die Zugriffe, die auf irgendwelche PHP-Lücken oder so abzielten sind alle wirkungslos "abgeprallt" - genau das wollte ich ja erreichen. Das Update Thema ist auch gelöst: es gab keine Ich habe mich selbst um die Weiterentwicklung gekümmert. Allerdings hatten und haben wir da schon auch den ein oder anderen Bug, und einige sind doch ein wenig nervig. Auch haben sich einige Dinge als nicht so ganz praktikabel herausgestellt. Die recht aufwändige Versionierung der einzelnen Blog-Posts ist eigentlich unnötig und verkompliziert alles nur.

Aber an Sonsten...

Technik

Was steckt aktuell hinter Jblog:

• Morphium V4.0.6
• Spring Boot
• Apache Freemarker
• Bootstrap 4
• JDK11
• MongoDB 4.0

ja, das war es eigentlich schon, ist recht übersichtlich geworden. D.h. die Anwendung läuft im Moment als Spring-Boot-App hinter einem Nginx.

Features

Ich habe mir mein Blog so gestrickt, wie ich es haben wollte. Also sehr stark auf meine Art des Bloggens ausgelegt, was vielleicht auch der Grund ist, warum es auf Github niemand geforked hat und ich das Projekt jetzt auf privat umgestellt habe.

Mehrsprachigkeit

Jblog ist durchweg zweisprachig ausgelegt. Theoretisch wären auch mehr möglich, aber ich wollte mich auf Deutsch und Englisch konzentrieren. D.h. jedes Element auf der Webseite wird übersetzt, alle Blog-Einträge müssen in 2 Sprachen erfasst werden.

Dafür wird eine MessageSource verwendet, die die Daten aus der Mongo liest. Das schöne: wird eine Übersetzung nicht gefunden, wird dafür ein Link auf die Übersetzungsmaske ausgegeben. D.h. wenn ich Jblog mal auf einer leeren Übersetzungsdatenbank laufen lasse, bekomme ich einen Screen voller links, die mich zum Übersetzungstool bringen. Nach und nach wird das dann korrigiert.

Dadurch, dass wir Morphium für den Zugriff auf die Mongo nutzen, können diese Übersetzungen auch gecached werden (man muss nur die @Cache-Annotation an die Klassse schreiben).

Das Schöne daran ist, dass der Cache, wenn gewollt, clusterfähig ist. D.h. ich kann mehrere Instanzen von Jblog laufen lassen und über einen Loadbalancer zugreifen. Und diese würden ihre Caches über die Mongo synchron halten, d.h. es gibt selbst bei Round-Robin Einstellung keine Dirty Reads!

Markdown

Markdown ist ja der Hit in letzter Zeit um Text einzugeben. Ich finde das auch recht cool, vor allem, da ich ja auch recht gut tippe und mich der Griff zur Maus immer ausbremst. Deswegen ist das sehr angenehm einfach alles tippen zu können. (und wer so wie ich früher Textverarbeitung mit LaTeX gemacht hat, kennt das .)

Jblog ist komplett auf Markdown ausgelegt. D.h. man gibt seine Blogs in Markdown ein und sieht dann gleich den Preview. Ich habe auch einige Erweiterungen gemacht, insbesondere um einfach Emojis ( ) einzubinden oder einen schön formatierten Java Code-Block einbinden zu können.

Auch das einbetten von Bildern habe ich darüber implementiert.

Ich habe dafür eine Markdown-Implementierung namens Markingbird benutzt und etwas angepasst. So habe ich etwas eingebaut, um die Emojis einfacher einbetten zu können und um Bilder leichter anzuzeigen.

Jeder Blog-Post ist in Markdown geschrieben und wird erst beim ersten Zugriff gerendert. Und das Ergebnis wird gecached, natürlich

Beim Tippen habe ich einen Live-Preview und kann genau sehen, wie der Post dann am Schluss aussehen wird.

Twitter Anbindung

neue Artikel werden via Twitter veröffentlicht. Dabei wurden einige Dinge berücksichtigt: Zeit des Tweet vorgeben, nur für neue Artikel etc.

Und es wird gleich in 2 Sprachen getwittert, deutsch und englisch

Mehrbenutzerfähigkeit

Ja, eigentlich kann man Jblog auch mit mehreren Usern benutzen. Ich habe zwar auch ein paar Freunde und Bekannte, die hier mal von Zeit zu Zeit reinschneien und evtl. was posten, aber sonst... Ist also ein sehr wenig genutztes Feature, weshalb ich das dann auch daktiviert habe.

Im Moment kann man sich nicht registrieren, der Registrierungsprozess ist De-Aktiviert. Möchte man einen Kommentar hinterlassen, so kann man das via Disqus tun.

Implementierung

Die Implementierung hat sich ein wenig geändert in den letzten 2 Jahren. Gestartet mit JDK1.8 als klassisches Spring-Web Projekt mit WAR-Deployment, haben wir jetzt eine Spring-Boot Anwendung mit integriertem Tomcat 9 auf JDK11.

Ich nutze hier AdaptOpenJdk V11 weil ich den Longtermsupport benötige, damit ich nicht alle 6 Monate mein Blog neu aufsetzen muss.

Morphium

Natürlich soll das auch ein kleiner "Showcase" für Morphium sein, deswegen hier ein paar Beispiele:

Translations

Um die Anwendung einfach mehrsprachig zu halten, empfiehlt es sich, die Übersetzungsdaten in der Datenbank zu halten. Das hat viele Vorteile:

• man kann die Übersetzungen zur Laufzeit ändern
• man kann auch Zahlenformate etc. zur Laufzeit anpassen und damit auch das Aussehen der Anwendung verändern
• wenn man es zulässt, kann man auch Links, IMG-Tags etc in die Übersetzungstabelle einbauen und so noch mehr Flexibilität erreichen

Allerdings kommen diese Features natürlich mit einem Preisschild:

• ein wenige Programmieraufwand
• die Performance könnte leiden, weil für jeden Seitenaufbau, mehrere Daten aus der Datenbank gelesen werden müssen. Hier hilft uns das Caching-Feature von Morphium
• Man benötigt immer eine Datenbank, um eine Seite zu Gesicht zu bekommen, sonst kommt unsinn raus. Und die Pflege kann etwas umständlich sein.

Gerade der letzte Punkt hat mich genervt, also habe ich Localization so geschrieben, dass in dem Fall, dass keine Übesetzung gefunden wird, der Link auf die entsprechende Pflege-Oberfläche ausgegeben wird. Das hatte zwar auch so seine seltsamen Effekte (link in einem Link, link im Title etc), war im Großen und Ganzen aber wirklich einfach.

Ein wichtiger Punkt war auch, dass ich in der Übersetzungsmaske durch einen Mausklick nur die Einträge anzeigen lassen kann, bei denen noch eine Übersetzung fehlt. So kommt man recht schell zu einer vollständigen Übersetzung.

Das hier ist die MessageSource... ´´´java @Service public class LocalizationMessageSource extends AbstractMessageSource { @Autowired private LocalizationService localizationService;

@Override
protected MessageFormat resolveCode(String s, Locale locale) {

    String lang = locale.getLanguage();
    if (!LocalizationService.supportedLangs.contains(lang)) {
        return null;
    }
    return createMessageFormat(localizationService.getText(lang, s), locale);
}

} ´´´

Und hier der zugehörige Service, der den entsprechenden HTML-Link rausgibt, wenn es keine Übersetzung gibt.

´´´java @Service public class LocalizationService { public final static List supportedLangs = Arrays.asList("de", "en");

@Autowired
private Morphium morphium;


public String getText(String locale, String key) {
    key = key.replaceAll("[ \"'?!`´<>(){}-]", "_");
    Localization lz = morphium.findById(Localization.class, key);
    if (lz == null) {
        lz = new Localization();
        lz.setKey(key);
        for (String l : supportedLangs) {

            lz.getTxt().put(l, l + "_" + key);

        }
        morphium.store(lz);
    }

    if (key.startsWith("format_") && lz.getTxt().get(locale).equals(locale + "_" + key)) {
        lz.getTxt().put(locale, "yyyy-MM-dd HH:mm:ss 'default'");
        morphium.store(lz);
        return lz.getTxt().get(locale);
    }

    if (lz.getTxt().get(locale).equals(locale+"_"+key)){
        return "<a href=/admin/translations/query?queryKey="+key+">"+key+"</a>";
    }
    return lz.getTxt().get(locale);
}

} ´´´

Das ist super praktisch wenn man neue Features rein bringt.

Würde man das für eine größere Webseite machen, könnte das schnell umständlich sein. Vor allem, wenn man auch noch mehr als 2 Sprachen unterstützen will. Deswegen empfiehlt sich in so einem Fall ein Im-/Export der Daten, am besten in einem für Übersetzungsagenturen lesbaren Format!

Es gibt noch ein weiteres "Problem" bei den übersetzungen: Waisen! Es passiert relativ häufig, dass man während der Entwicklung übersetzungen für irgendetwas anlegt, was im Laufe der Zeit aber obsolet wird. Dann hat man Übersetzungen in der Datenbank, die keiner mehr benötigt. Diese zu identifizieren ist nicht so einfach möglich, da die Schlüssel für die Übersetzungen teilweise abhängig von Daten sind und diese erst zu Laufzeit bereit stehen.

Morphium bietet für so einen Fall die Option in einem Feld einen lastAccessTimestamp abzulegen. Damit kann man sehen, wann einträge zuletzt gelesen wurden. (Achtung: das nur in Verbindung mit Caching nutzen, da jeder Lesezugriff auf diese Elemente einen Schreibzugriff zur Folge hat!).

Wenn man das alles zusammenwirft, kommt folgende Entity raus:

´´´ @Entity @Cache(maxEntries = 10000, timeout = 60 * 60 * 1000, clearOnWrite = true, strategy = Cache.ClearStrategy.FIFO, syncCache = Cache.SyncCacheStrategy.CLEAR_TYPE_CACHE) @LastAccess public class Localization { @Id private String key; @LastAccess @Index private long lastAccess; private Map<String, String> txt;

public String getKey() {
    return key;
}

public void setKey(String key) {
    this.key = key;
}

public Map<String, String> getTxt() {
    if (txt == null) txt = new HashMap<>();
    return txt;
}

public void setTxt(Map<String, String> txt) {
    this.txt = txt;
}

public long getLastAccess() {
    return lastAccess;
}

public void setLastAccess(long lastAccess) {
    this.lastAccess = lastAccess;
}

} ´´´

Der Cache hier behält seine Einträge für eine Stunde (60x60x1000ms) und darf maximal 10000 Einträge haben. Elemente werden aus dem Cache entfernt, wenn sie entweder länger als eine Stunde im Cache sind, oder die 10000 Einträge erreicht werden. IM letzteren Fall werden Elemente gemäß der Strategy entfernt. Diese ist per default ClearStrategy.FIFO (d.h. das am längsten im Cache befindliche Object wird entfernt um eines hinzuzufügen). Es gibt auch noch die Strategien ClearStrategy.LRU (Least Recently Used - also am längsten nicht benutzt) sowie ClearStrategy.RANDOM welches einen Zufälligen entry entfernt.

Sollte es einen Schreibzugriff auf die Übersetzungen geben, wird der Cache komplett geleert.

Falls man Jblog im Cluster verwendet, benötigt man eine Möglichkeit die Caches auf den Knoten synchron zu halten. Dafür definiert man eine SyncCacheStrategy. Dabei passiert folgendes:

• alle Jblog instanzen initialisieren ein Messagingsystem in Morphium
• jedes update auf gecachten Elementen sendet eine Update-Nachricht über das Messaging
• je nach Strategie aktualisieren die einzelnen Knoten ihren cache.
  • SyncCacheStrategy.CLEAR_TYPE_CACHE löscht den ganzen Cache für dieses Entity
  • SyncCacheStrategy.REMOVE_ENTRY_FROM_TYPE_CACHE entfernt den Eintrag aus allen Suchergebnissen im Cache (Achtung: das Element wird dann in gecachten Suchergebnissen nicht mit ausgegeben, obwohl es evtl. dazu passen würde)
  • SyncCacheStrategy.UPDATE_ENTRY updated den Eintrag im Cache (Achtung: kann dazu führen, dass das Element im Cache zu Suchergebnissen gezählt wird, obwohl es eigentlich nicht mehr auf die Kriterien passt - dirty read!)
  • SyncCacheStrategy.NONE - naja... eben nicht syncen

Damit das aber sauber funktioniert, muss die Anwendung wissen, welche Sprache verwendet wird. Dazu werden verschiedene Schritte benutzt:

• steht in der URL ein lang-Parameter drin, überschreibt der alles, was gesetzt ist
• gibt es ein Cookie mit der Language, dann nehmen wir das
• Sendet der Browser Info über die unterstützten Sprachen, nutzen wir das.
• wenn alles fehl schlägt, nimm englisch

Implementiert wurde das mit einem Interceptor:

´´´java @Component public class ValidLocaleCheckInterceptor extends HandlerInterceptorAdapter { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { String lang = "de"; if (request.getParameter("lang") != null) { String ln = request.getParameter("lang"); if (ln.contains("")) { ln = ln.substring(0, ln.indexOf("")); } ln = ln.toLowerCase(); if (ln.isEmpty()) { ln = "de"; }

        if (!LocalizationService.supportedLangs.contains(ln)) {
            StringBuilder url = new StringBuilder();
            url.append(request.getRequestURI());
            Map<String, String[]> map = request.getParameterMap();
            String sep = "?";
            for (String n : map.keySet()) {
                if (n.equals("lang")) {
                    continue;
                }
                for (String v : map.get(n)) {
                    url.append(sep);
                    sep = "&";
                    url.append(n);
                    url.append("=");
                    url.append(v);
                }

            }
            url.append(sep);
            url.append("lang=de"); //Default locale
            response.sendRedirect(url.toString());
            //Utils.showError(404,"unsupported language",response);
            return false;
        }
        lang = ln;
    } else {
        Cookie[] cookies = request.getCookies();
        boolean found = false;
        if (cookies != null) {
            for (int i = 0; i < cookies.length; i++) {
                if (cookies[i].getName().equals("lang")) {
                    lang = cookies[i].getValue();
                    found = true;
                    break;
                }
            }
        }
        if (!found) {
            LocaleResolver localeResolver = RequestContextUtils.getLocaleResolver(request);
            Locale l = localeResolver.resolveLocale(request);
            if (l != null) {
                lang = l.getLanguage();
            }
        }
    }
    request.getSession().setAttribute("lang", lang);
    Cookie c = new Cookie("lang", lang);
    c.setPath("/");
    c.setMaxAge(365 * 24 * 60 * 60);
    response.addCookie(c);
    return true;
}

´´´

Tag Cloud

Um die Tag Cloud zu berechnen nutzen wir einfach den in Mongo befindlichen Aggregator, und dafür gibt es natürlich auch eine Unterstüztung in Morphium:

´´´java Aggregator<BlogEntry,WordCloud> a=morphium.createAggregator(BlogEntry.class,WordCloud.class); a.match(morphium.createQueryFor(BlogEntry.class).f(BlogEntry.Fields.state).eq(Status.LIVE).f("wl").eq(wl));

Map<String,Object> projection=new HashMap<>(); Map<String,Object> arrayElemAt=new HashMap<>(); ArrayList