BigBastis Blog About Me & my Digital Lifestyle

   ''' <summary>
    ''' Diese Funktion durchläuft den ganzen Treenode bis ein Eintrag gefunden wird der dem Suchbegriff
    ''' gleicht. Danach wird der Pfad der zu diesem TreeNode führt (zur Visualisierung) aufgeklappt
    ''' </summary>
    ''' <param name="tn">Der zu durchsuchende Treenode
    ''' <param name="name">Der Suchbegriff
    Public Sub findNode(ByVal tn As TreeNode, ByVal name As String)
        For Each tnn As TreeNode In tn.Nodes
            If tnn.Text = name Then
                Dim t As TreeNode = tnn
                For i As Integer = tnn.Level To i = 0 Step -1
                    Try
                        t = t.Parent
                        t.Expand()
                    Catch ex As Exception
                    End Try
                Next
                tnn.Parent.Expand()
                Exit Sub
            End If
            findNode(tnn, name)
        Next
    End Sub

    public class DemoController : Controller
    {
        [GET("Ist/Das/Cool/Oder/Was")]
        public ActionResult Start()
        {
            return View();
        }
    }

    public static void RegisterRoutes(RouteCollection routes) {
        routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

        routes.MapAttributeRoutes(); //--- das wars!

        routes.MapRoute(
            "Default", // Route name
            "{controller}/{action}/{id}", // URL with parameters
            new { controller = "Home", action = "Start",
                id = UrlParameter.Optional } // Parameter defaults
        );
    }

    public class DemoController : Controller
    {
        [GET("Artikel/{artikelid}/{version?}")]
        [RouteDefault("artikelid", "120")]
        public ActionResult Start(int artikelid, string version)
        {
            ViewBag.ArtikelId = artikelid;
            ViewBag.Version = version;

            return View();
        }
    }

"mac_address": "01-23-45-67-89-ab",
"signal_strength": 8,
"age": 0,
"SSID": "MyAccessPoint"

if (navigator.geolocation) {
  navigator.geolocation.getCurrentPosition(success, error);
} else {
  alert("Not Supported!");
}

function success(position) {
alert(position.coords.latitude);
alert(position.coords.longitude);
alert(position.address.city);
}

private const string GOOGLE_WEATHER_API_URL =
	"http://www.google.com/ig/api?weather={0}&hl=de";
public WeatherResult GetWeahterData(string city) {

    string api_url = string.Format(GOOGLE_WEATHER_API_URL, city);

    try {
        HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(api_url);
        HttpWebResponse res = (HttpWebResponse)req.GetResponse();
        StreamReader reader = new StreamReader(res.GetResponseStream());

        string response = reader.ReadToEnd();

        XmlDocument xmlDoc = new XmlDocument();
        xmlDoc.LoadXml(response);

        string temp = xmlDoc.SelectSingleNode("xml_api_reply/weather/current_conditions/temp_c").Attributes["data"].Value;
        string icon = xmlDoc.SelectSingleNode("xml_api_reply/weather/current_conditions/icon").Attributes["data"].Value;

        WeatherResult wRes = new WeatherResult(temp, city);
        wRes.Icon = icon;

        return wRes;
    } catch (Exception ex) {
        return null;
    }
}

    public class WeatherResult {
        public string Temperature { get; set; }
        public string City { get; set; }
        public string Icon { get; set; }

        public WeatherResult(string temp, string city) {
            Temperature = temp;
            City = city;
        }
    }

    public class ApiController : Controller
    {
        //
        // GET: /Api/GetWeather

        public JsonResult GetWeather(string id)
        {

            WeatherResult res = new Tools.Weather.WeatherHelper().GetWeahterData(id);

            return Json(res, JsonRequestBehavior.AllowGet);
        }

    }

function get_address(position) {
    var full_url = "/Api/GetWeather/" + position.address.city;

    $.ajax({
        url: full_url,
        success: get_weather,
        error: display_error
    });
}

function get_weather(address) {

    $(".weather_info").html(address.Temperature == "" ? "N/A" : address.Temperature + "°C");
    $(".location_info").html(address.City);

}

http://maps.google.com/maps/api/geocode/json?latlng=[KOORDINATEN]sensor=true 

private const string GOOGLE_MAPS_REVERSE_LOOKUP_URL =
	"http://maps.google.com/maps/api/geocode/json?latlng={0}&sensor=true";
public static string GetCityFromCoords(string coords) {
    string api_url = String.Format(GOOGLE_MAPS_REVERSE_LOOKUP_URL, coords);

    try {
        HttpWebRequest req = (HttpWebRequest)HttpWebRequest.Create(api_url);
        HttpWebResponse res = (HttpWebResponse)req.GetResponse();
        StreamReader reader = new StreamReader(res.GetResponseStream());

        string response = reader.ReadToEnd();

        var serializer = new JavaScriptSerializer();
        serializer.RegisterConverters(new[] { new DynamicJsonConverter() });

        dynamic obj = serializer.Deserialize(response, typeof(object));

        string city = obj.results[0].address_components[3].long_name;

        return city;
    } catch (Exception ex) {
        return "";
    }
}

//Registrierung
this.button1.Click += new System.EventHandler(this.button1_Click);
//Verweis / Nutzung
private void button1_Click(object sender, EventArgs e) { }

this.button1.Click += delegate(object sender, EventArgs e) {
    //hier steht mein Code
};

//Registrierung des EventHandler zum anderen Thread
man.NewInformationUpdate += new NewInformationUpdateArrived(update_received);

//Handlermethode
public void update_received(object sender, TestInformationUpdateEventArgs ev) {
    //Aufruf zu dem eigenen Thread deligieren
    this.BeginInvoke(new delegateupdate(update), new object[] { ev });
}

//Definition der delegaten Methode
public delegate void delegateupdate(TestInformationUpdateEventArgs ev);

//Eigentliche Methode zum Verarbeiten des Events
private void update(TestInformationUpdateEventArgs msg) {
//...
}

fd1.CompletionInformation += delegate(object se, CompletionInformationArgs ci) {
    this.BeginInvoke(new EventHandler(delegate(object obj, EventArgs ea) {
        CompletionInformationArgs cea = (CompletionInformationArgs)ea;

        //Unser verabeitungs Code hier

    }), new object[] { se, ci });
};

    var handler = new EventHandler(delegate(object o, EventArgs e)
    {
        //handler Logik
    };

    Subject.NewEvent += handler;

    //Diesen können wir später dann auch entfernen
    Subject.NewEvent -= handler;

        public event EventHandler SomeEvent;

        public void ClearEventHandlers() {
            Delegate[] delegates = SomeEvent.GetInvocationList();
            foreach (Delegate delegate in delegates) {
                SomeEvent -= (EventHandler) delegate;
            }
        }

/**
 * Teilt die Informationen aus dem X509Certificate.SubjectDN in die
 * einzelnen Bestandteile auf und macht diese einzeln verfügbar
 * @author sebastian gross blog.bigbasti.com
 */
public class CertificateDataSeperator {

    private String _C = "";
    private String _ST = "";
    private String _L = "";
    private String _O = "";
    private String _OU = "";
    private String _CN = "";
    private String _EMAILADRESS = "";

    /**
     * Erstellt eine neue instanz
     * @param cert Das Zwetifikat aus dem die Daten gelesen werden sollen
     * @param seperator Die Zeichenfolge ander die parameter
     *        getrennt werden sollen, bei Java ist Standard ", "
     */
    public CertificateDataSeperator(X509Certificate cert, String seperator){
        String [] subjectDNData;

        subjectDNData = cert.getSubjectDN().getName().split(seperator);

        seperateData(subjectDNData);
    }

    /**
     * Duchläuft das Array und ordnet die Informationen
     * @param data Array mit dem SubjectDN String
     */
    private void seperateData(String [] data){
        for(String s : data){
            if((s.toUpperCase()).startsWith("C=")){
                _C = s;
            }else if((s.toUpperCase()).startsWith("ST=")){
                _ST = s;
            }else if((s.toUpperCase()).startsWith("L=")){
                _L = s;
            }else if((s.toUpperCase()).startsWith("O=")){
                _O = s;
            }else if((s.toUpperCase()).startsWith("OU=")){
                _OU = s;
            }else if((s.toUpperCase()).startsWith("CN=")){
                _CN = s;
            }else if((s.toUpperCase()).startsWith("EMAILADRESS=")){
                _EMAILADRESS = s;
            }
        }
    }

    /**
     * Generiert einen angepassten SubjectDN String
     * @param params Die gewünschten Werte in der gewünschten Reihenfolge als Array
     * @param seperator Die Zeichenfolge, die zum Trennen der Parameter genutzt werden soll
     * @return Einen angepassten SubjectDN String
     */
    public String getNewDNString(String [] params, String seperator){
        StringBuilder sb = new StringBuilder();

        for(String s : params){
            if((s.toUpperCase()).equals("C")){
                sb.append(_C);
            }else if((s.toUpperCase()).equals("ST")){
                sb.append(_ST);
            }else if((s.toUpperCase()).equals("L")){
                sb.append(_L);
            }else if((s.toUpperCase()).equals("O")){
                sb.append(_O);
            }else if((s.toUpperCase()).equals("OU")){
                sb.append(_OU);
            }else if((s.toUpperCase()).equals("CN")){
                sb.append(_CN);
            }else if((s.toUpperCase()).equals("EMAILADRESS")){
                sb.append(_EMAILADRESS);
            }

            if(!s.equals(params[params.length-1])){
                sb.append(seperator);
            }
        }

        return sb.toString();
    }

    /**
     * Erzeugt einen DN String in dem Format, wie ihn auch die
     * X509_NAME_oneline Methode von OpenSSL generiert, dies ist
     * auch das Format, welches von dem Exim Email Server genutzt wird.
     * Das Forman ist wiefolgt: /C=$/ST=$/L=$/O=$/OU=$/CN=$
     * @return OpenSSL
     */
    public String getOpenSSLCompatibleDNString(){
        StringBuilder sb = new StringBuilder();

        sb.append("/").append(_C).append("/").append(_ST).append("/").append(_L).append("/")
          .append(_O).append("/").append(_OU).append("/").append(_CN);

        //EMAILADRESS Ist ein optionales Feld und könnte nicht gesetzt sein
        if(_EMAILADRESS != null){
            sb.append("/").append(_EMAILADRESS);
        }

        return sb.toString();
    }

    public String getC() {
        return _C;
    }

    public String getCN() {
        return _CN;
    }

    public String getEMAILADRESS() {
        return _EMAILADRESS;
    }

    public String getL() {
        return _L;
    }

    public String getO() {
        return _O;
    }

    public String getOU() {
        return _OU;
    }

    public String getST() {
        return _ST;
    }
}

X509Certificate myCert = session.getClientCertificate();
CertificateDataSeperator sep = new CertificateDataSeperator(myCert, ", ");
String dn = sep.getOpenSSLCompatibleDNString();

X509Certificate myCert = session.getClientCertificate();
String [] myParams = new String[]{"O", "CN", "L"};
CertificateDataSeperator sep = new CertificateDataSeperator(myCert, ", ");
String dn = sep.getNewDNString(myParams, "|");

Java: Webservice anlegen und konsumieren

Aus gegebenen Anlass gibt es heute mal ein kleines Tutorial wie man in Java ein WebService anlegt und diesen dann benutzt. Das ganze wird mit NetBeans 9.6.1 als IDE und einem Glassfish als Application Server realisiert.

Erstmal kurz: was ist ein WebService?
Ein WebService unter Java ist (vergleichbar mit RMI) eine Art Dienst, der sowohl von anderen Anwendungen als auch von Webseiten genutzt werden kann. Anders als eine gewöhnliche Webseite besitzt ein WebService kein eigenes Benutzerinterface sondern stellt nur in einer Schnittstellenbeschreibung seine Dienste nach außen zur Verfügung.

Diese Schnittstellenbeschreibungen werden in WSDL Dateien (Web Service Description Language) gespeichert, diese sind XML Dokumente, die genau beschreiben, welche Methoden der WebService bietet und wie diese angesprochen werden. Glücklicherweise müssen wir diese WSDL Dateien nicht selbst erstellen sondern können uns diese generieren lassen, aber dazu gleich mehr.

Kommunikation mit dem WebService
Unser WebService wird dann später über das SOAP Protokoll (Simple Object Access Protocol) kommunizieren, dieses ist ebenfalls XML basierend und auch hier müssen wir nicht selbst Hand anlegen sondern lassen alles für uns generieren

In diesem Beispiel werden wir einen einfachen WebService erstellen und eine gewöhnliche App, die dann mit dem WebService kommunizieren wird. Wir werden hier die NetBeans IDE 6.9.1 benutzen, diese wird uns hierbei viel Arbeit abnehmen, sodass der unangenehme Teil der Arbeit klein gehalten wird

Downloads - falls nicht bereits vorhanden
NetBeans - Download
Glassfish - Download
JDK - Download

Legen wir mal los

Als Erstes sollten wir damit starten den WebService zu erstellen. Dazu legen wir ein neues Web Application Projekt an und nennes es "CheckUser" die Restlichen Dialoge könnt ihr unverändert lassen und schließlich auf Fertigstellen klicken.

Nun sollte das Projekt angelegt sein und ihr solltet den Quelltext der index.jsp vor euch haben. Diese Datei benötigen wir nicht da wir einen WebService erstellen wollen, deswegen könnt ihr diese Löschen, wenn ihr mögt.

Nun müssen wir einen neuen WebService anlegen, das machen wir, indem wir auf unser Projekt rechtsklicken und über "New -> WebService" wählen. Nennt den Service "UserDB" und packt es in das "com.bigbasti.db.user.service" Package rein. Zum Schluss macht ihr noch den Haken bei "Implement Web Service as Stateless Session Bean" rein und klickt auf Fertig.

Was ist nun passiert? NetBeans hat für uns nun einen neuen Ordner im Projekt namens "Web Services" angelegt und auch eine neue Enterprise Bean die so heißt wie unser Service ist im Projekt aufgetaucht. NetBeans kümmert sich größtenteils selbst um diese automatisch generierten Beans so sollten wir erst einmal die Finger davon lassen.

Nun solltet ihr die UserDB.java vor euch aufgeklappt sehen, diese Klasse ist mit der Annotation Stateless und WebService markiert. Da ein WebService mindestens eine Methode (Operation besitzen muss wird euch wahrscheinlich ein Fehler angezeigt. Das wollen wir nun ändern und fügen dem Service eine neue Operation hinzu.

Macht dazu einen Rechtsklick innerhalb der UserDB Klasse und klickt auf "Insert Code..." wählt hier nun "Add Web Service Operation...". In dem nun angezeigten Fenster solltet ihr eure Operation "checkUserName" nennen und den Rückgabetyp auf Boolean stellen. Desweiteren fügt ihr einen Parameter hinzu und tauft ihn "userName".

Bestätigt das Fenster mit "OK" und ihr solltet folgendes zu sehen bekommen:

Diese neue Methode ist mit "WebMethod" annotiert und weist so darauf hin, dass auf diese von außen zugegriffen werden darf. Alle Parameter sind ebenfalls annotiert sodass diese zugreifbar sind. Diese Annotation ist wichtig, damit wir später WSDLs und Requests generieren können. Beim Arbeiten mit dieser Methode könnt ihr diese aber für euch ausblenden

Diese erzeugte Methode funktioniert genauso wie jede andere Java Methode, somit könnt ihr mit ihr wie gewohnt arbeiten. Diese Methode soll für uns prüfen, ob ein Benutzername bereits von jemandem verwendet wird. Da wir das simel halten wollen nutzen wir eine LinkedList als Datenbank So können wir eine einfache Prüffunktion implementieren:

Nun haben wir einen WebService mit einer Operation. Diese wollen wir nun mal testen. Dazu verwenden wir zunächst die Test-Tools vom Glassfish Server. Dazu müssen wir unsere Web Application zunächst Deployen (Veröffentlichen), das machen wir ganz einfach indem wir das Projekt rechts-klicken und dann "Deploy" wählen. Nun wird der Glassfish Server gestartet, die Anwendung kompiliert und auf dem Server veröffentlicht.

Wenn dieser Vorgang erfolgreich war könnt ihr im "Services"-Tab unter "Servers->GlassFish Server 3" euere Web App sehen (Siehe Bild 11). Nun wollen wir mal gucken ob unsere Operation funktioniert, dazu macht ihr einen Rechtsklick auf dem "GlassFish Server 3" und wählt View Admin Console (Bild 12).

Nun könnt ihr euch einen Kaffee holen...

Wenn die Admin Console irgendwann offen ist, und es kann dauern, klickt ihr auf "Anwendungen" und wählt eure "CheckUser" App. In dem "Allgemein"-Tab seht ihr nun unten eine Tabelle mit allen Komponenten eurer App, sucht hier unseren Service "UserDB" und klickt auf "Endpunkt anzeigen".

Hier seht ihr nun alle wichtigen Informationen zu eurem Web Service, für uns ist im Moment die Tester URL wichtig (Roter Pfeil) Diese öffnen wir mal in einem neuen Tab.

Was wir hier sehen ist die Testseite für unseren Dienst. Hier hat der Glassfish für jede von uns erstellte Operation (momentan haben wir nur eine) eine Testmethode erstellt. Diese Testmethode macht nichts anderes, als eine SOAP Nachricht zu generieren und an unseren Dienst zu senden und uns die Antwort von diesem anzuzeigen.

Probieren wir das Ganze mal aus, probiert einfach mal ein paar Namen durch und verwendet auch ab und zu einen der von uns Reservierten Namen, ihr werdet feststellen, dass unsere Methode super funktioniert.

Dabei zeigt das Test-Tool auch an welche SOAP Requests es generiert und welche Antworten unser Service gibt, so wird folgender SOAP Aufruf getätigt um zu prüfen, ob der Name vorhanden ist:

Hier finden wir alle unsere Werte aus der Klasse wieder. Der Name der Operation die wir mit diesem Request aufrufen wollen (Rot), diese Operation benötigt einen Parameter namens "userName" den wir hier angeben (Blau) und der Wert für diesen Parameter (Orange). Das Ganze ist dann noch in einen SOAP Envelope verpackt und wird so zum Server geschickt.

Dieser führt die gewünschte Operation aus und gibt uns eine Antwort:

Die Response ist weitestgehend genauso aufgebaut die der Request. Der Knoten hat nun noch "Response" an den Namen der Methode/Operation angehängt bekommen (Rot) und auch das Ergebnis der Operation ist angegeben (Blau).

Das Ergebnis können wir nun mit Hilfe eines Parsers auslesen, aber dazu gleich mehr. Nach dem Test wissen wir nun, dass unser dienst läuft und auch dass die Operation zuverlässig arbeitet, Zeit unsere "Consumer"-Applikation zu bauen.

Web Service benutzen (konsumieren)

Nun haben wir also einen Web Service laufen, und natürlich wollen wir diesen nun auch nutzen (konsumieren ist das Fachwort), aus einer App mit der sich Benutzer irgendwo registrieren können. Diese App muss natürlich irgendwie prüfen, ob der gewünschte Benutzername schon vorhanden (bzw. bereits benutzt) ist, das wird die App über unseren Web Service UserDB erledigen.

Legen wir zunächst ein neues Projekt in NetBeans an, diesmal eine normale Java Application, die wir "RegisterUser" nennen.

Nun müssen wir unserer frischen Applikation beibringen mit einem WebService zusammen zuarbeiten. Das macht man über so genannte Schnittstellen, denn diese beschreiben genau was möglich ist und wie man da dran kommt. Schnittstellen haben hier das Format WSDL, und wenn ihr gut aufgepasst habt habt ihr sicher schon gesehen dass der GlassFish für unser Service eine WSDL erstellt hat.

Geht die Schritte in den Bildern 13,14 und 15 durch (falls ihr den Tab schon geschlossen habt), sodass ihr wieder die URLs des Services angezeigt bekommt. Der Blaue Pfeil im Bild 15 zeigt euch die URL der WSDL, diesen link klickt ihr bitte an, sodass ihr die XML Datei zu Gesicht bekommt.

Auf den Inhalt werde ich hier nicht weiter eingehen, das könnt ihr euch ja bei Wiki durchlesen Die URL zu der WSDL sieht bei mir wie folgt aus:

http://localhost:8080/UserDBService/UserDB?wsdl

Diese könnt ihr mal in die Zwischenablage kopieren, da wir diese gleich benötigen um einen Web Service Client zu erstellen. Das machen wir mit einem Rechtsklick auf das Projekt und wählen "New->Web Service Client". Hier wählt ihr als Bezugsort für die WSDL "URL" aus und fügt die URL ein. Als Paketnamen habe ich "com.bigbasti.user.register" gewählt.

NetBeans lädt nun die WSDL herunter und erzeugt daraus für euch die nötigen Klassen für den Zugriff auf diese Schnittstelle, deswegen sind einige neue Dateien bei euch im Projektordner aufgetaucht (Bild 24). Der etwas ausgegraute Ordner "Generated Sources" enthält hierbei die wichtigen Klassen und Methoden für das Erzeugen von SOAP Requests und für das Lesen von Responses. Diese Dateien solltet ihr auch möglichst nicht anfassen.

Nun sind wir komplett gerüstet um unseren Web Service zu nutzen. Der Code der dafür geschrieben werden muss ist auch nicht weltbewegend:

Als Erstes sind die imports wichtig, damit wir Zugriff auf die generierten Klassen haben. Mit denen können wir nun (Blaue Pfeile) die nötigen Instanzen der Service Objekte anlegen. Ist das erst geschafft können wir mit unserem UserDB Objekt, das den Service repräsentiert bequem arbeiten und die Service Operationen aufrufen, als ob es eine gewöhnliche kleine Klasse wäre (Oranger Pfeil).

Nachdem wir unsere Operation aufgerufen haben bekommen wir eine Antwort ob der Name schon benutzt wird oder nicht. So könnte es aussehen wenn man das obige Programm startet:

Wie man sieht funktioniert das Ganze sehr gut und es hat gerade mal ein paar Minuten gedauert diesen Service zu erstellen. Ihr könnt natürlich selber weiter herumspielen und weitere komplexere Operationen hinzufügen, die mit echten Datenbanken kommunizieren.

Aus gegebenen Anlass gibt es heute mal ein kleines Tutorial wie man in Java ein WebService anlegt und diesen dann benutzt. Das ganze wird mit NetBeans 9.6.1 als IDE und einem Glassfish als Application Server realisiert. Erstmal kurz: was ist ein WebService? Ein WebService unter Java ist (vergleichbar mit RMI) eine Art Dienst, der sowohl von ...