Docker + Netbeans + Liferay

Für eine einfache Integration von Docker für die Entwicklung nutze ich Netbeans IDE in Version 8. Die integrierte Docker Unterstützung vereinfacht es, neue Application Server aufzusetzen und für spätere Anwendungen zu verteilen.

Im Vorfeld muss die lokale Docker Installation angepasst werden. Standardmäßig hört Docker auf keinen TCP Socket, das muss customized werden.

Core OS gibt eine einfache Anleitung hierfür vor:

Customizing docker

The Docker systemd unit can be customized by overriding the unit that ships with the default Container Linux settings. Common use-cases for doing this are covered below.

Enable the remote API on a new socket

Create a file called /etc/systemd/system/docker-tcp.socket to make Docker available on a TCP socket on port 2375.

<code><span class="nn">[Unit]</span>
<span class="py">Description</span><span class="p">=</span><span class="s">Docker Socket for the API</span>

<span class="nn">[Socket]</span>
<span class="py">ListenStream</span><span class="p">=</span><span class="s">2375</span>
<span class="py">BindIPv6Only</span><span class="p">=</span><span class="s">both</span>
<span class="py">Service</span><span class="p">=</span><span class="s">docker.service</span>

<span class="nn">[Install]</span>
<span class="py">WantedBy</span><span class="p">=</span><span class="s">sockets.target</span>
</code>

Then enable this new socket:

<code>systemctl <span class="nb">enable </span>docker-tcp.socket
systemctl stop docker
systemctl start docker-tcp.socket
systemctl start docker
</code>

Test that it’s working:

<code>docker -H tcp://127.0.0.1:2375 ps</code>

Quelle: https://coreos.com/os/docs/latest/customizing-docker.html

Netbeans einrichten

Über den Reiter: Services -> Docker könnt ihr mit einem Rechtsklick eine neue Docker Instanz hinzufügen. Hierbei wäre es möglich sogar Remote Systeme anzuschließen, für Teams die auf einer zentralen Installation arbeiten.

Durch die vorhergehende Konfiguration von Docker sollte Successfull beim Test Connection erscheinen.

Docker + Liferay Image

Ich verwende aktuell noch ein Liferay 6.2 Image im Docker Umfeld für ein Projekt.

Daher habe ich auf das bereits erstelle Image von snasello zurück gegriffen.

Das könnt ihr hier https://hub.docker.com/r/snasello/liferay-6.2/

für eure Docker Installation herunterladen.

Liferay in Netbeans

Alle Docker Container werden anschließend im Netbeans gelistet. Ihr könnt den Liferay Container via Rechtsklick „run“ starten. Anschließend wird der Name definiert und das Port- Mapping.

Nachdem ihr „finish“ geklickt habt, wir der Container gestartet. In eurer Console erhaltet ihr dementsprechend den output.

How To Deploy Packages on Liferay Docker Container!

Um Portlets, Themes und Co auf dem Docker Container zu deployen, muss das deployment Verzeichnis lokal gemappt werden. Hierbei könnt ihr folgenden Befehl verwenden:

Laut Docker Dokumentation soll das über den Parameter -v möglich sein.

Quelle: https://docs.docker.com/engine/tutorials/dockervolumes/

Sobald es funktioniert, update ich den Beitrag!

Connect to Docker via Shell

Um den Docker Container zu konfigurieren oder Installationen / Konfigurationen vorzunehmen könnt ihr direkt via Shell auf das System zugreifen.

<code><span class="pln">sudo docker exec </span><span class="pun">-</span><span class="pln">i </span><span class="pun">-</span><span class="pln">t {name-of-docker-container} </span><span class="pun">/</span><span class="pln">bin</span><span class="pun">/</span><span class="pln">bash</span></code>

PayOne + JEE Application

PayOne ist ziemlich umständlich zu integrieren. Für einen der großen Zahlungsdienstleister haben die Macher von PayOne ganz schön was nachzuholen. Ich persönliche finde PayOne vom Aufbau her ziemlich altmodisch. Man merkt, das dass Webportal des Zahlungsdienstleisters schon etwas in die Jahre gekommen ist. Ebenso der Komfort für die Kunden. Einen großen Pluspunkt hat PayOne. Die Integration in bestehende Systeme. Siehe magento – commerce, shopware, oxid, demandware oder intershop. Dadurch das sie in zahlreichen Großen Unternehmen zum Bestand zählen bietet eine feste Kundenbasis ein regelmäßigen Zahlungsfluss.

Wir sind gerade dabei die Schnittstellen für eine JEE- Anwendung anzubinden. Leider ist mir keine fertige Library im Netz über die Füße gefallen die ich nutzen hätte können. Somit kann ich wieder von vorne anfangen.

PayOne bietet seit einiger Zeit eine „Frontend“ – Lösung an. Hierbei wird über eine dynamische URL ein iFrame inkludiert oder die Seite aufgerufen über der die Zahlung abgewickelt werden kann. Dabei sind mir, im Gegensatz zur Konkurrenz z.B. Adyen wieder einige Nachteile aufgefallen.

  • Es kann lediglich eine Zahlungsart angeboten werden.
  • Die Implementierung ist ziemlich aufwendig da sehr genau Reihenfolgen eingehalten werden müssen.
  • Standard für die Implementierung ist PHP.
  • Relativ langsame Abwicklung des Zahlungsprozesses.

Ich hatte die letze Zeit öfters Gelegenheit einige der Zahlungsdienstleister ausprobieren zu können. Deren Schnittstellen zu testen und wie man darauf reagieren kann. Mir ist aufgefallen das Adyen an dieser Stelle sehr stark ist und mit einfachsten Mechanismen gute Zahlungsmöglichkeiten anbietet.

Unsere Entscheidung ist etwas ungewöhnlich. Wir haben uns trotz der Nachteile für PayOne entschieden. Folgende Gründe haben dafür gesprochen:

  • Unser Sachbearbeiter war stets bemüht alle Informationen die nötig waren zu bekommen
  • Kooperativ mit uns zusammen zu arbeiten
  • Gebühren und Kosten zu minimieren, so das wir als StartUp ebenfalls eine Chance haben
  • Schnelle Reaktion bei Support-Anfragen
  • Unterstützung beim Implementierungsaufwand

Trotz der gestiegenen Aufwände bei der Implementierung sollte es möglich sein in kurzer Zeit eine kleine Library für euch zur Verfügung stellen zu können die die Zahlungsabwicklung mit dem Frontend-Interface abzubilden.

 

Bis dahin

Euer Johannes

Android – HowTo Intent Service

Was ist ein IntentService?

Ein Intent Service ist eine abgekapselte Art des Services. Viel kleiner und schlankter als der ServiceLayer und somit einfacher zu bedienen.

Wozu benötige ich einen IntentService?

Der IntentService wird benötigt um z.B. einfache Downloads bzw. Uploads zu starten. Wenn nur eine Aktion ausgeführt werden soll ohne die Activity zu verlassen. z.B. Downloaden von Bibiliotheken, Bilder oder ähnlichen Aktionen ohne die Applikation dabei zu verlassen. Der Service wird beendet sobald onPause oder onStop ausgeführt wird.

Wie setzte ich einen IntentService ein / HowTo Setup an IntentService?

Prepare ActivityView

Um einen IntentService aufrufen zu können benötigt man relativ wenig Vorbereitung. Da der Service nur gebunden zu einer Activity aufgerufen werden kann wird er ähnlich einer Activity gestartet.

Es können dem Service per Extra werte übergeben werden die anschließend ausgelesen werden.

Intent intent = new Intent(this, IntentTestService.class);
intent.putExtra(IntentTestService.EXTRA_TEST,"test");
startService(intent);

 

Prepare IntentService

 

package de.good.study.app.android.service;

import android.app.Activity;
import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

/**
 * Created by jkoeber on 06.03.14.
 */
public class IntentTestService extends IntentService {
    private static final String CLASS_NAME = IntentTestService .class.getName();
    public static final String CUSTOM_INTENT = IntentTestService .class.getName()+".Receiver";
    public static final String RESULT = "serviceResult";
    public static final String STATUS = "serviceStatus";
    public static final int STATE_FINAL = 20;

    public DatabaseService() {
        super("IntentTestService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        int i = 0;

        Log.i(CLASS_NAME,"==> Service Started!");
        long endTime = 2*1000;
        while (i < STATE_FINAL) {
            synchronized (this) {
                try {
                    i += 1;
                    publishStatus(i);
                    wait(endTime);
                } catch (Exception e) {
                    Log.e(this.getClass().getName(),"Error by executing the service");
                }
            }
        }
    }

    /**
     * publish status
     * @param status
     */
    private void publishStatus(int status) {
        Intent intent = new Intent(CUSTOM_INTENT);
        intent.putExtra(STATUS, status);

        if(status == STATE_FINAL) {
            intent.putExtra(RESULT, Activity.RESULT_OK);
        } else {
            intent.putExtra(RESULT, Activity.RESULT_CANCELED);
        }

        sendBroadcast(intent);
    }
}

 

Response konsumieren

 

Die Activity kann anschließend den Response vom Service verarbeiten und abfangen über einen BroadcastListener. Hier ein Beispiel

    /**
     * BroadcastReceiver will execute IntentService and handle Reponse
     */
    private BroadcastReceiver mReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            Bundle bundle = intent.getExtras();
            Log.i(CLASS_NAME,"Receive from Broadcast!");
            if (bundle != null) {
                int resultCode = bundle.getInt(IntentTestService.RESULT);
                int resultStatus = bundle.getInt(IntentTestService.STATUS);

                mProgressbar.setProgress(resultStatus);
                if (resultCode == RESULT_OK) {
                    Log.i(CLASS_NAME, "RESULT IS 100%, redirect to next Activity!");
                    Intent overviewIntent = new Intent(MainActivity.this, NextActivity.class);
                    startActivity(overviewIntent);
                }
            }
        }
    };

Android: setOnClickListener

Aufbauend auf dem ersten Tutorial (Wie fange ich an?) werde ich euch jetzt zeigen wie man seine MainActivity Class richtig befüllt und die erste Aktion über den Button ausführt.

Vorher machen wir noch einen kleinen Ausflug in den Lifecycle einer Android Activity. In der MainActivity werdet ihr ein onCreate(); finden. Diese „Mastermethode“ wird dazu verwendet Buttons und andere Elemente zu initialisieren und evtl. auch mit Leben zu befüllen. Es gibt noch andere Statusse in denen sich die Activity befinden kann. z.B. onView(); Es wird nicht empfohlen in der onView intensive Aufgaben zu initialisieren da sich sonst die ganze Activity in einem stehenden Zustand verwendet. Erst wenn der komplette Prozess abgerufen wäre würde sich die Oberfläche wieder bedienen lassen. Hier noch eine kleine Übersicht des Android Activity Lifecycles.

 

Zurück zu unseren Aktionen die wir auf unseren Button setzen wollen. Per klick soll die nächste Aktivität gestartet werden. Somit wird ein neuer Intent aufgerufen.

Um eine neue Activity aufzurufen müssen wir erstmal eine neue Activity erstellen. Dazu machen wir einen Rechtsklick auf unser Package in dem die MainActivity liegt und erstellen eine neue Klasse, hierbei geben wir als SuperClass Activity an.

Nachdem wir die Events.class erstellt haben benötigen wir noch eine neue LayoutFile für die Events Klasse. Also werden wir das machen. Rechtsklick auf den Ordner layout unter res und schon könnt ihr bei Other auf Android Layout xml File.

Das neue XML File habe ich activity_events.xml getauft. Jetzt könnt ihr gerne meinen Code kopieren. Hierbei wird lediglich eine TextView und eine ListView verwendet.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >
    

    <TextView
        android:id="@+id/textViewURL"
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="TextView" />
    
    <ListView 
    android:layout_width="match_parent"
    android:layout_height="match_parent" />
</LinearLayout>

So, anschließend bearbeiten wir jetzt noch unsere Events.class folgendermaßen:

private static String _URL = "url";

@Override
protected void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.activity_events);

	Intent intent = super.getIntent();
	Bundle extras = intent.getExtras();
	String url = (String) extras.get(_URL);

	TextView textViewURL = (TextView) findViewById(R.id.textViewURL);
	textViewURL.setText(url);
}

Hier wird lediglich die neue Activity dargestellt und der übergeben Parameter im TextView wieder ausgegeben.
Um auch die MainActivity dementsprechend anzupassen und eine Aktion auszuführen gibt es jetzt den CodeSnippet für die MainActivity.class

public class MainActivity extends Activity {

	private static String _URL = "url";
	private String url = "http://www.infranken.de/storage/rss/rss/2.0/lokales.xml";

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        Button btnShowNext = (Button) findViewById(R.id.btnGo);
        btnShowNext.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				Intent itn = new Intent(v.getContext(), Events.class);
				itn.putExtra(_URL, url);
				v.getContext().startActivity(itn);
			}
		});

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

}

Bevor ihr die App nun starten könnt für einen ersten Testlauf müsstest ihr noch die Manifest File anpassen. Dank dem Sicherheitskonzept von Android, können Activities nicht willkürlich aufgerufen werden.

 

Android: Wie fange ich an?

Ein kleines Tutorial für alle die sich mit Android noch nicht zu sehr auseinander gesetzt haben und einen einfachen Einstig suchen. Wie gehe ich mit einem Button um und wie kann ich die Seite wechseln um neuen Content aufzurufen.

Bevor ich alles in einer Seite reinpack und immer nur gegen neuen Content austausche baue ich lieber neue komplette Seiten auf, inkludiere fertige Elemente und binnen ein paar Minuten läuft die Anwendung super stabil.

Meine alten Tutorials und HowTos haben sich alle auf Android 1.6 – 2.3 bezogen. Jetzt werde ich versuchen euch kleine Starthilfe Tipps für die Versionen 3.0 – 4.1 zu geben. Im Grunde genommen hat sich nicht viel verändert. Es sind nur jede Menge neue Funktionen und Gadget dazu gekommen. Siling Tabviews z.B. ist doch mal richtig cool! Aber back to Basics.

Wir erstellen eine kleine Andorid Applikation, nachdem Bilder mehr sagen als 1000 Worte werde ich versuchen viele Bilder zu verwenden.

Gebt eurer Android App einen guten Namen, den ihr auch weiter verwenden wollt 😉 Ich bin mittlerweile richtig begeistert von dem Werkzeug Version 2.3 zu 4.1 ist ein Meilenstein der sich sehen lässt. Es wird so viel Unterstützung geboten was wir früher umständlich implementieren mussten.

Die Screenshot’s 4 und 5 Zeigen euch den gleichen Step, lediglich die Auswahl ist unterschiedlich. Wollt ihr  vorgefertigtes Layout nutzen um direkt die Kompatibilität mit Tablets zu gewährleisten oder wollt ihr euch frei entfalten und ein blankes Layout verwenden. Ich werde für unser kleines Beispiel das blanke Layout wählen.

Anschließend muss lediglich noch die MainActivity erstellt werden. das geht fix wenn ihr none wählt. Wenn ihr jedoch für Android Versionen jenseits der 11 entwickelt könnt ihr euch sehr schöne Vorlagen, mal wieder zusammen bauen lassen. Da kann man immer etwas experimentieren.

Anschließend läd Android alle notwendigen Daten und fügt sich euch schon zusammen. Es werden alle Ordner erstellt die fürs vernünftige und flotte Entwickeln benötigt werden. Seid froh, das war in den Vorgängerversionen auch nicht so. Da dürfte man stundenlang Dokumentationen wälzen bevor man den richtigen Ordner gefunden hat.

Auf der Linken Seite seht ihr jetzt eure Ordnerstruktur. Hierbei werden im Ordner: r

es/values alle Standardwerte gepflegt. z.b. in der strings.xml alle Werte die später per ID auf Buttons, Texte und alle anderen möglichen Elemente übergeben werden.

Der mittlere Contentbereich in eurer IDE zeigt den ganz normalen Designbereich. Hierbei hat sich auch einiges geändert. Erstellen von Dialogen ist um ein vielfaches erleichtert worden und auch übersichtlicher gestaltet. In meinem kleinen Beispiel habe ich bereits das HelloWorld gegen einen kleinen Standardbutton getauscht. Diesen werde ich in meinem nächsten Kurztutorial mit leben füllen und eine andere Aktivität – setOnClickListener – damit aufrufen.