SAP HANA Development

Whitepaper
In-Memory optimierte
Java-Anwendungsszenarien
Java-Entwickung mit SAP HANA
und deren Architektur
In-Memory optimierte Java-Anwendungsszenarien
Java-Entwicklung mit SAP HANA und deren Architektur
Autor:
Stefan Kühnlein,
Solution Architect bei
OPITZ CONSULTING
Haben Sie Fragen
zu diesem Thema?
Dann sprechen Sie uns gerne an!
Kontakt:
[email protected]
Inhaltsübersicht
Einleitung
Einleitung
Was hat sich verändert?
Wetteranalyse via Twitter und SAP HANA
Entwicklung einer nativen SAP HANA Anwendung
Entwicklung einer nicht nativen SAP HANA Anwendung mit Java
Auswertung der Tweets mit Textanalyse
Fazit
Links & Literatur
Über OPITZ CONSULTING
Welche Möglichkeiten bietet SAP HANA für Java-Applikationen und wie
können Softwarearchitekten und Entwickler diese nutzen? Neben einer
kurzen Vorstellung der In-Memory optimierten Lösungskomponenten, die
SAP HANA bereitstellt, werden unterschiedliche Szenarien zur Nutzung von
SAP HANA aus einer Java-Anwendung aufgezeigt.
Dabei geht es neben der Darstellung von funktionalen Möglichkeiten,
wie der direkten Analyse transaktionaler Daten, der Verarbeitung unstrukturierter Informationen aus sozialen Medien oder verschiedenen Algorithmen zum Mining großer Datenmengen, auch um die verschiedenen
Schnittstellen, mit denen diese Funktionen aus einer Java-Anwendung
angesprochen werden können.
Texte und Abbildungen wurden mit größter Sorgfalt erarbeitet. OPITZ CONSULTING kann jedoch für eventuell verbleibende fehlerhafte Angaben und
deren Folgen weder eine juristische Verantwortung noch irgendeine Haftung übernehmen. Das Recht an dargestellten Verfahren, Showcases, Implementierungsbeispielen und Sourcecodes liegt ausschließlich bei OPITZ CONSULTING.
© OPITZ CONSULTING GmbH 2014
Whitepaper: In-Memory optimierte Java-Anwendungsszenarien
Seite 2
Für die Entwicklung von Anwendungen auf der SAP HANA Plattform stehen dem Entwickler zwei Programmiermodelle zur Verfügung, mit denen
er die Daten und Funktionen der Plattform nutzen kann:
Was hat sich verändert?
Wirft man einen Blick in heutige Unternehmen, so stellt man fest, dass sich
die Anforderungen erheblich verändert haben. Unternehmen sind stärker
als früher unter Druck, Informationen über verschiedene Kanäle zu sammeln und zeitnah auszuwerten. Bisherige Verfahren und Architekturen
stoßen bei der Speicherung und der zeitnahen Analyse großer, unterschiedlicher Datenmengen an die Grenzen von Machbarkeit und Wirtschaftlichkeit.
Insbesondere die Notwendigkeit zur Voraggregation der Daten führt bei
großen Datenmengen zu einer hohen Redundanz und erschwert die zeitnahe Erstellung von Analyseergebnissen. Dazu kommen die unterschiedlichen Datenformate, die zu verarbeiten sind und die bestehende Architekturen vor neue Herausforderungen stellen.
Um diesen Problemen entgegenzuwirken, wurde mit Polyglot Persistence
ein Architekturpattern entwickelt, dass die Speicherung der Daten je nach
ihrer Herkunft in ein passendes Datenbanksystem übernimmt. Dieses Konzept birgt allerdings neue Risiken, vor allen im Betrieb, da mit Polyglot
Persistence nun nicht nur eine, sondern gleich mehrere Datenbanken betrieben werden müssen.
Allein die Datenmengen, die soziale Medien hervorbringen und die für die
Informationsgewinnung zunehmend wichtiger werden, sind riesig. Wurden
früher via Twitter nur Freunde informiert, wird der Kurznachrichtendienst
heute unter anderem auch für Marketing oder Recruiting eingesetzt. So
wurden beispielsweise bei der vergangenen Weltmeisterschaft in Brasilien
während der gesamten Turnierzeit 672 Millionen Tweets abgesetzt.
Native Anwendungsentwicklung
Die Entwicklung einer nativen Anwendung erfolgt mit den SAP HANA
Entwicklungswerkzeugen (Eclipse- oder webbasiert). Native Anwendungen
werden direkt auf der SAP HANA Plattform ausgeführt und benötigen
keine zusätzliche Laufzeitkomponente wie einen Anwendungsserver. Die
Entwicklung der datenintensiven Geschäfts- und Kontrollflusslogik kann
entweder mit SQLScript oder mit JavaScript im Kontext der Plattformkomponente SAP HANA Extended Application Services (XS) erfolgen.
Nicht native Anwendungsentwicklung
Nicht native Anwendungen werden außerhalb der SAP HANA Entwicklungsplattform (z. B. in Java, C++, ABAP) entwickelt, getestet und bereitgestellt und greifen über einen entsprechenden Treiber (z. B. JDBC, ODBC,
ADBC) auf die Daten und SQL-Funktionen der SAP HANA Plattform zu.
Abbildung 1 zeigt die grundlegende Architektur für native und nicht
native SAP HANA Anwendungen. So zeigt die linke Seite die zweischichtige
Architektur einer nativen Anwendung, bei der mittels eines Browsers über
das HTTP-Protokoll auf die Anwendung zugegriffen wird.
Die rechte Seite zeigt die dreischichtige Architektur einer nicht nativen
Anwendung, bei der der Anwender über einen Browser, Rich Client oder
Fat Client auf die Applikationslogik mit dem jeweiligen Protokoll zugreift.
Mit SAP HANA hat SAP eine Datenbank entwickelt, die neuste HardwareTechnologien mit einem effektiven In-Memory-Datenmanagement verbindet und dadurch neue Chancen für die Entwicklung von Anwendungen
eröffnet. So kann auf die Voraggregation von Daten verzichtet werden und
die Verarbeitung von strukturierten als auch von unstrukturierte Daten
erfolgt in derselben Datenbank. Mit SAP HANA entfällt außerdem die aufwendige Aufbereitung der Daten für OLAP-Systeme. Das reduziert die
Anzahl der Datenbanken sowie ETL-Strecken stark und vereinfacht komplexe Systemlandschaften.
Mit SAP HANA stellt der Hersteller nicht nur eine Datenbank auf einer
dedizierten Hardware zur Verfügung, sondern auch eine Plattform für die
Entwicklung von Echtzeitanwendungen. So liefert SAP HANA funktionale
Komponenten wie GeoSpatial, Text Mining, Bibliotheken für Predictive
Analysis und Data Mining, deren Algorithmen für die In-MemoryVerarbeitung optimiert wurden und eng an die Datenbank gekoppelt sind.
© OPITZ CONSULTING GmbH 2014
Abbildung 1: Gegenüberstellung nativer und nicht nativer SAP HANA
Anwendungen (Quelle: SAP HANA Developer Guide [1])
Whitepaper: In-Memory optimierte Java-Anwendungsszenarien
Seite 3
Abbildung 2 stellt die zur Verfügung stehenden Programmiersprachen und
zugehörigen Umgebungen der SAP HANA Plattform dar. Je nach Anwendungsfall beziehungsweise Architekturausrichtung wird eine der entsprechenden Technologien ausgewählt, um die Leistungsfähigkeit von SAP
HANA optimal für die Anwendungslogik nutzen zu können. So kann z. B.
die Entwicklung der Anwendungslogik einer nativen SAP HANA Anwendung mit Hilfe der Core Data Services (CDS), HDBtable und SQLScript erfolgen. Mit serverseitigem JavaScript (XSJS) wird ebenfalls Anwendungslogik
implementiert, die direkt auf der SAP HANA Plattform ausgeführt wird.
Für die Speicherung der Twitter-Nachrichten wird eine Tabelle „TWEETS“ in
SAP HANA wie folgt angelegt:
Abbildung 3: Definition der Tabelle „TWEETS“ in SAP HANA Studio
Der Zugriff auf die Persistenzschicht erfolgt entweder direkt mittels der
JavaScript Database API oder unter Verwendung des OData-Standards. Für
die Erstellung der User Interfaces, die an die serverseitigen JavaScript- oder
OData Services gebunden werden, kann das integriere SAPUI5 HTML5 SDK
oder auch jede andere Open Source Library verwendet werden.
Für die Anbindung von nicht nativen SAP HANA Anwendungen, stehen je
nach verwendeter Programmiersprache die entsprechenden Treiber zur
Verfügung. So erfolgt der Zugriff auf die SAP HANA Datenbank für JavaAnwendungen via JDBC, für C/C++/.NET Anwendungen via ODBC und
ADO.NET oder für ABAP-Anwendungen via ADBC.
Entwicklung einer nativen
SAP HANA Anwendung
Native SAP HANA Anwendungen nutzen die Technologie und die Services,
die durch die integrierte SAP HANA Extended Application Services (XS)
bereitgestellt werden. Für die Entwicklung von nativen SAP HANA Anwendungen sind folgende Rahmenbedingungen zu berücksichtigen:
■
■
■
Alle Artefakte der Anwendung werden im internen Repository
der SAP HANA Plattform gespeichert.
Serverseitige Anwendungslogik wird entweder mit SQLScript
oder mit Hilfe von serverseitigem (XS) JavaScript erstellt.
Die Darstellung des Benutzerinterfaces erfolgt ausschließlich im Client
(Browser oder Mobile).
Mit den SAP HANA Extended Application Services (XS) wird des Weiteren
ein Satz von serverseitigen JavaScript Application Programming Interfaces
(API) zur Verfügung gestellt, mit denen eigene Anwendungen erweitert
werden können. So erfolgt z. B. mit der ausgelieferten Database API der
Zugriff mittels SQL auf die Tabellen, Views, Analytical- und CalculationViews sowie auf Stored Procedures. Ebenfalls besteht die Möglichkeit,
mittels HTTP-Requests Daten von einem Service abzurufen oder immer
wiederkehrende Aufgaben automatisiert zu starten. Die folgende Tabelle
stellt die zur Verfügung stehenden APIs dar:
Abbildung 2: Techniken für die Entwickung von Anwendungen auf Basis
von SAP HANA (Quelle: SAP HANA Developer Guide [1])
Wetteranalyse via Twitter
und SAP HANA
Im folgenden Beispiel wird die Speicherung und Auswertung mit Hilfe der
integrierten Textanalyse von Wetterdaten aus dem sozialen Netzwerk Twitter in SAP HANA gezeigt. Hierzu wird exemplarisch nach Tweets mit Tags
wie #wetter oder #wetterstation gesucht. Mit Hilfe der integrierten
Textanalyse von SAP HANA sowie den geographischen Daten der Tweets,
kann eine „soziale“ Wetterkarte erstellt werden.
© OPITZ CONSULTING GmbH 2014
API
Beschreibung
Database
Die Database API erlaubt dem Entwickler, eine Verbindung
zur Datenbank aufzubauen. So können z. B. Transaktionen
gestartet, geschlossen oder abgebrochen sowie SQLStatements und -Prozeduren ausgeführt werden.
Outbound
Connectivity
Die Outbound Connectivity API ermöglicht Zugriffe auf
HTTP-Ziele, die Services zur Verfügung stellen, die durch die
SAP HANA XS Anwendung genutzt werden können.
Request Processing
Mit der Request Processing API wird sowohl lesend als auch
schreibend auf den Kontext des aktuellen HTTP-Requests
zugegriffen. So kann der Entwickler den Inhalt des Request
und des Response verändern.
Die zeitliche Steuerung von immer wiederkehrenden Aufgaben, die im Hintergrund ausgeführt werden sollen, kann mit
Hilfe der Job Schedule API realisiert werden.
Job Schedule
Trace
Mit der Trace API wird auf die verschiedensten Trace-Levels
zugegriffen und Traces durch die Anwendung generiert. Die
erzeugten Dateien können im SAP HANA Studio in der
Perspektive Administration unter der Sektion Diagnosis Files
eingesehen werden.
Whitepaper: In-Memory optimierte Java-Anwendungsszenarien
Seite 4
Für das Lesen von Tweets, die mit den HashTag #wetter oder
#wetterstation gekennzeichnet wurden, benötigen wir in unserem Beispiel
sowohl die Outbound Connectivity API als auch die Job Schedule API.
Twitter bietet entsprechende REST-Services an, um nach Tweets zu suchen.
Für die Nutzung der Outbound Connectivity muss dem SAP HANA User,
unter dem die Anwendung läuft, die Rolle HTTPDestViewer zugeordnet
werden. Die Konfiguration der Eigenschaften der HTTP-Verbindung erfolgt
in einer separaten Datei mit einer speziellen Syntax und der Extension .xshttpdest. Für den Zugriff auf den Twitter REST-Service wird folgende
Konfiguration in der wetter.xshttpdest-Datei benötigt:
description = "Wetteranalyse mit Twitter";
host = "api.twitter.com";
Für die Abfrage der Tweets wird Twitter‘s REST-API GET search/tweets
verwendet. Damit die Schnittstelle benutzt werden kann, muss man sich
über OAuth identifizieren. Für die Authentifizierung zur Benutzung der
REST-API für die Suche nach Tweets ist die Application-only-Authentication ausreichend, da für diesen Kontext keine benutzerspezifischen Daten benötigt werden und ein sogenannter „Inhaber-Token“ ausreichend ist.
Mit folgendem Codeabschnitt kann ein Inhaber-Token innerhalb der SAP
HANA XS Engine angefordert werden:
function getTweets(maxId) {
var searchQuery = "/1.1/search/tweets.json?q=%23wetter%
20OR%20%23wetterstation&max=1000";
var dest = $.net.http.readDestination
("opitz.wetteranalyse", "wetter");
var client = new $.net.http.Client();
port = 443;
if (maxId !== null && maxId !== '') {
searchQuery = searchQuery + "&since_id=" + maxId;
}
pathPrefix = "";
useProxy = false;
proxyHost = "";
proxyPort = 0;
var req = new $.web.WebRequest($.net.http.GET,
searchQuery);
authType = none;
useSSL = true;
timeout = 0;
Die Abfrage der neusten Tweets mit den HashTag #wetter oder
#wetterstation erfolgt in einem serverseitigen JavaScript. Damit dieses
Script regelmäßig durch die Job Schedule aufgerufen wird, muss die Abfrage der aktuellsten Tweets in einer JS-Funktion eingebettet sein.
function getTweets(maxId) {
var dest = $.net.http.readDestination
("opitz.wetteranalyse", "wetter");
var tweets = JSON.parse(getTweets(getLastId
(conn)).asString());
if (tweets !== null && tweets.statuses !== null
&& tweets.statuses.length > 0) {
var count = tweets.statuses.length;
for (index = 0; index < count; index++) {
saveTweet(conn, tweets.statuses[index]);
}
conn.commit();
}
}
© OPITZ CONSULTING GmbH 2014
return client.getResponse().body;
}
Nach Erhalt des Inhaber-Token können die neusten Tweets zu den Hashtags #wetter oder #wetterstation wie folgt abgerufen werden:
function collectWetterTweets() {
var conn = $.db.getConnection
("opitz.wetteranalyse::wetteranalyse");
try {
var index = 0;
} catch (ex) {
$.trace.error(ex.message);
} finally {
if (!conn.isClosed()) {
conn.close();
}
}
req.headers.set("Authorization", "Bearer " +
getBearerToken());
client.request(req, dest);
var client = new $.net.http.Client();
var req = new $.web.WebRequest($.net.http.GET,
"/1.1/search/tweets.json?q=%23wetter%
20OR%20%23wetterstation&since_id ="+maxId);
req.headers.set("Authorization", "Bearer " +
getBearerToken());
client.request(req, dest);
return client.getResponse().body;
Zuletzt müssen die Tweets in der Datenbank gespeichert und ausgewertet
werden. Dies kann entweder mittels der Database Library der XS-Engine
oder unter Verwendung des OData Services erfolgen.
Damit die Daten kontinuierlich über die Rest-API ermittelt und in der Datenbank persistiert werden können, wird ein entsprechender Scheduler
aufgesetzt. Hierzu ist in der SAP HANA XS-Engine (siehe Tabelle 1) eine API
implementiert, die es erlaubt, entsprechende Aufgaben zu bestimmten
Zeiten bzw. in bestimmten Zeitabständen durchzuführen. Ein solcher Job
wird über eine spezielle Datei, der *.xsjob-Datei, aufgesetzt.
Whitepaper: In-Memory optimierte Java-Anwendungsszenarien
Seite 5
Zum Lesen und Speichern der Wetter-Tweets in einem Interval von fünf
Minuten wird folgende Job-Definition aufgesetzt:
{
"description": "Wetteranalyse mittels Twitter",
"action":
"opitz.wetteranalyse:wetteranalyse.xsjs::collectWetterTweet
s",
"schedules":
[
{
"description": "Lesen der Tweets mit den
Hashtags #wetter und #wetterstation",
"xscron": "* * * * * */5 *",
"parameter": { }
}
]
}
Nach der Aktivierung der xsjob-Datei wird der Job noch nicht gestartet
und ausgeführt. Das Starten des Jobs erfolgt über das XS HANA Administration Tool. Das Starten des Jobs über das HANA XS Admininstration Tool
kann allerdings nur durch einen Benutzer ausgeführt werden, der über die
Rolle sap.hana.xs.admin.roles::JobAdministrator verfügt.
Entwicklung einer nicht nativen
SAP HANA Anwendung mit Java
Nicht native Anwendungen, die auf die SAP HANA Plattform zugreifen,
können die Services nutzen, die durch die integrierte XS-Technologie bereitgestellt werden. Die nicht native Anwendung wird im Vergleich zur
nativen Anwendung auf einem externen Application Server ausgeführt.
Mit dem Pattern der nicht nativen Anwendung werden alle Szenarien
bezeichnet, bei der die Entwicklung und die Ausführung der Anwendung
außerhalb der SAP HANA Plattform erfolgt. Die Anwendungslogik der nicht
nativen SAP HANA Anwendung läuft auf einem externen Application Server oder als Standalone-Anwendung und greift auf das Datenmodell durch
die Verwendung von z. B. einer JDBC-Verbindung auf die entsprechenden
Tabellen, Views oder Analytical bzw. Calculation Views zu.
Im Java-Umfeld kann dies sowohl direkt mittels der JDBC-API oder indirekt
über die Java Persistence API (JPA) erfolgen. Sowohl die aktuelle Version
von Hibernate 4.3.5 als auch EclipseLink 2.5.2 unterstützen den Zugriff auf
die SAP HANA Datenbank via JPA und JDBC. Jedoch gibt es einige Einschränkungen und bekannte Bugs, die auf den entsprechenden Internetseiten zu finden sind. Die Einschränkungen bei der Verwendung von EclipseLink und SAP HANA sind unter [2] zu finden.
Im Folgenden wird gezeigt, wie die bereits oben entwickelte XS Anwendung zur Speicherung von Twitter-Nachrichten nun mittels einer externen
Java-Anwendung und JPA in der Datenbank persistiert werden können.
Hierzu wird dasselbe Datenbankschema verwendet. Im Gegensatz zur nativen SAP HANA Anwendung werden nun die Daten direkt von der
Streaming API abgegriffen und nicht über einen REST-Service. Durch die
Verwendung der Streaming API können Entwickler auf den globalen Datenstrom der Tweets mit einer geringen Latenz zugreifen.
© OPITZ CONSULTING GmbH 2014
Ein entsprechender Streaming-Client veröffentlicht Nachrichten über
Tweets und weitere Ereignisse, ohne dass ständig über die RESTSchnittstelle eine Abfrage gestartet werden muss. Hierzu stellt Twitter die
folgenden Streaming-API für die unterschiedlichsten Anwendungen bereit:
■
■
■
Public Streams: Streams der öffentlichen Daten innerhalb von Twitter.
Diese Daten können zur Auswertung über Personen, Themen oder Data
Mining verwendet werden.
User Streams: Mit Hilfe dieses Streams können die Daten eines einzelnen Benutzers aufgezeichnet werden.
Site Streams: Site Streams sind die Multi-User-Version der User
Streams. Site-Streams sind für Server gedacht, die sich im Namen von
vielen Usern bei Twitter anmelden.
Im Gegensatz zur Implementierung der Anwendung als native SAP HANA
XS Anwendung, wo die Tweets über die REST-Schnittstelle abgegriffen
werden, kann auf die Public Streams mit Hilfe der Streaming API zugegriffen werden. Zur Speicherung der Tweets wird ein entsprechendes ORMapping der Tabellen für EclipseLink benötigt. Im Rahmen des Mapping
der Tabellen auf die entsprechenden POJOs sind keine Besonderheiten zu
beachten. Lediglich der SAP HANA JDBC Treiber (ngdbc.jar) muss sich zusätzlich zu den obligatorischen Libraries im Classpath der Anwendung
befinden. Damit EclipseLink erkennt, dass es sich um eine SAP HANA Datenbank handelt, muss das Property eclipselink.target-database gesetzt sein. Die persistence.xml stellt sich für unser Beispiel wie folgt dar:
<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.1"
xmlns="http://xmlns.jcp.org/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/
persistence http://xmlns.jcp.org/xml/ns/persistence/
persistence_2_1.xsd">
<persistence-unit name="TwitterJPA" transactiontype="RESOURCE_LOCAL">
<class>de.sap.hana.twitter.entity.Tweets</class>
<properties>
<property name="eclipselink.jdbc.bind-parameters"
value="true" />
<property name="eclipselink.jdbc.native-sql"
value="false" />
<property name="javax.persistence.jdbc.user"
value="TEST_SKU" />
<property name="javax.persistence.jdbc.password"
value="Secret012" />
<property name="javax.persistence.jdbc.url"
value="jdbc:sap://192.168.5.49:30115/?
autocommit=false" />
<property name="javax.persistence.jdbc.driver"
value="com.sap.db.jdbc.Driver" />
<property name="eclipselink.jdbc.cache-statements"
value="false" />
<property name="eclipselink.target-database"
value="HANA" />
<property name="eclipselink.jdbc.batch-writing"
value="JDBC" />
</properties>
</persistence-unit>
</persistence>
Whitepaper: In-Memory optimierte Java-Anwendungsszenarien
Seite 6
Das POJO, das für das Mapping zwischen der Datenbank und Businesslogik
benötigt wird, sieht wie folgt aus:
public class TwitterStatusListener implements
StatusListener {
private EntityManager entityManager = null;
public class Tweets implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE,
generator = "Twitter_Seq")
@SequenceGenerator(name = "Twitter_Seq", sequenceName =
"SEQ_TWEETS_ID", allocationSize = 1)
private long id;
public TwitterStatusListener(EntityManager pEntityManager)
{
entityManager = pEntityManager;
}
@Override
public void onStatus(Status status) {
Tweets tweet = new Tweets();
private long twitter_id;
tweet.setTwitter_id(status.getId());
tweet.setUser(status.getUser().getName());
tweet.setText(status.getText());
tweet.setCreateTime(status.getCreatedAt());
private String text;
@Column(name = "CREATION")
@Temporal(TemporalType.TIMESTAMP)
private Date createTime;
if (status.getGeoLocation() != null) {
tweet.setLatitude(Double.valueOf(status.getGeoLocation
().getLatitude()));
tweet.setLongitude(Double.valueOf(status.getGeoLocation
().getLongitude()));
}
private String user;
private Double latitude;
private Double longitude;
Bis auf das Attribut createTime des POJOs „Tweet“, wurden alle Attribute
analog der Tabellendefinition gewählt. Das Attribute createTime wird
durch die Annotation auf das Datenbankattribut CREATION gemappt. Zur
Erzeugung der eindeutigen ID des Datensatzes wird die Sequence
SEQ_Twitter_ID verwendet. Dieser Wert wird dem Javaobjekt automatisch
über die Java Persistence API (JPA) zugewiesen.
Das Streaming der Tweets zu den oben genannten HashTags erfolgt mit
der twitter4j Library. Diese Library stellt mit der Klasse TwitterStream eine
entsprechende Implementierung bereit, mit der die Tweets gelesen werden
können. Die Klasse TwitterStream wird mit Hilfe der Factory TwitterStreamFactory erzeugt. Um den Stream auf bestimmte HashTags zu begrenzen, wird eine FilterQuery entsprechend initialisiert und der Methode
filter() des TwitterStreams übergeben.
factory = Persistence.createEntityManagerFactory
("TwitterJPA");
entityManager.getTransaction().begin();
entityManager.persist(tweet);
entityManager.getTransaction().commit();
}
@Override
public void onException(Exception ex) {
}
@Override
public void onDeletionNotice(StatusDeletionNotice
statusDeletionNotice) {
}
@Override
public
void onTrackLimitationNotice(int
numberOfLimitedStatuses) {
}
public void onScrubGeo(long userId, long upToStatusId) {
}
@Override
public void onStallWarning(StallWarning warning) {
}
EntityManager em = factory.createEntityManager();
initTwitterFactory();
TwitterStream stream = twitterfactory.getInstance();
Im Gegensatz zur nativen SAP HANA Anwendung wird durch die Verwendung der Streaming-API von Twitter kein Job benötigt, mit dem der Start
der Sammlung und Speicherung von Tweets gesteuert wird.
stream.addListener(new TwitterStatusListener(em));
FilterQuery query = new FilterQuery();
stream.filter(query.track(new String[] { "#wetter",
"#wetterstation" }));
Zum Auswerten der Tweets wird eine Implementierung des Interfaces
TwitterStatusListener benötigt. Die Zerlegung der Tweets in ihre Bestandteile sowie der Speicherung in der SAP HANA Datenbank erfolgt in der zu
implementierenden Methode onStatus(Status status).
© OPITZ CONSULTING GmbH 2014
Whitepaper: In-Memory optimierte Java-Anwendungsszenarien
Seite 7
Auswertung der Tweets
mit Textanalyse
Das Ergebnis der SQL Abfrage zeigt Abbildung 5:
Um nach bestimmten Informationen in den gespeicherten Tweets zu suchen, wird ein Volltextindex in SAP HANA mit folgendem SQL-Ausdruck
angelegt.
CREATE FULLTEXT INDEX "TWEETS_ANALYSIS" ON
"TWEETS"("TEXT") FUZZY SEARCH INDEX ON
CONFIGURATION 'EXTRACTION_CORE_VOICEOFCUSTOMER'
TEXT ANALYSIS ON
Neben der Volltextsuche mittels SQL/MM Standard erlaubt der angelegte
Index, Resultate der Textanalyse bei der Abfrage zu berücksichtigen. Über
unterschiedliche Konfigurationen werden die von SAP HANA durchgeführten linguistischen Analysen definiert. Die Analyseergebnisse stehen in einer
automatisch erstellte Tabelle mit dem Prefix $TA im eigenen Schema. Die
Textanalysen basieren auf bereitgestellten Wörterbüchern, die ebenfalls
inhaltlich erweitert werden können.
Abbildung 5: Mögliches Ergebnis einer SQL Suche in den Twitter Feeds
Bei der Textanalyse werden ebenfalls Stimmungen erkannt, die wie folgt
abgefragt werden können:
SELECT "TWEETS"."ID",
"TWEETS"."TEXT","$TA_TWEETS_ANALYSIS"."TA_TOKEN"
"$TA_TWEETS_ANALYSIS","TWEETS"
FROM
WHERE "$TA_TWEETS_ANALYSIS"."ID" = "TWEETS"."ID" AND
"TA_TYPE" = 'StrongPositiveSentiment';
So sucht obiger SELECT-Ausdruck nach Tweets, die sich positiv über das
Wetter äußern.
Abbildung 4 zeigt die Definition der Tabelle $TA_TWEET_ANALYSIS, in der
die Ergebnisse der Textanalyse abgelegt werden. Die Spalte „TA_TOKEN“
speichert den entsprechend erkannten String, wie z. B. „22.0°C“ oder „Kiel“, Möglich sind auch lokationsbasierte Abfragen auf Basis der SAP HANA
GeoSpatial Engine. In den Spalten LONGITUDE und LATITUDE der Tabelle
und die Spalte „TA_TYPE“ den erkannten Entity-Typ wie z. B. „MEASURE“
TWEETS wird der Längen- und Breitengrad des Tweets gespeichert. Mit
oder „LOCALITY“.
Hilfe des Datentyps ST_POINT Datentyps können so Berechnungen auf
Basis der Lokation durchgeführt werden und auf einer Landkarte dargestellt werden.
Fazit
Für SAP HANA lassen sich im Wesentlichen zwei unterschiedliche Ansätze
zur Entwicklung eigener Anwendungen unterscheiden:
Abbildung 4: Definition der automatisch generierten Tabelle
$TA_TWEETS_ANALYSIS zur Aufnahme der Textanalyse-Ergebnisse
Folgender SELECT Ausdruck sucht Tweets die in ihrem Text eine Kennzahl
(wie z.B. Temperatur), und gleichzeitig den String „Gewitter“ enthalten: SELECT "TWEETS"."ID",
"TWEETS"."TEXT","$TA_TWEETS_ANALYSIS"."TA_TOKEN", snippets
("TEXT") FROM "$TA_TWEETS_ANALYSIS","TWEETS"
WHERE "$TA_TWEETS_ANALYSIS"."ID" = "TWEETS"."ID" AND
"TA_TYPE" = 'MEASURE' AND CONTAINS(TEXT,'Gewitter');
Zum einen native SAP HANA Anwendungen, die direkt auf der SAP HANA
Plattform ausgeführt werden und keinen Applikationsserver benötigen. Bei
der Umsetzung der Geschäftslogik ist man bei nativen Anwendungen allerdings auf JavaScript und datenbanknahes SQLScript beschränkt. PlattformFunktionen wie die GeoSpatial Engine, Textanalyse, Predicitve Analysis oder
auch die Auswertung transaktionaler Daten können ohne Einschränkungen
genutzt werden. Speziell für diese Anwendungen liefert SAP eine eigene
Programmiersprache namens River. Der Zugriff vom Client erfolgt hauptsächlich per OData.
Im Weiteren stehen Standard-Schnittstellen wie JDBC, ODBC und ADO.NET
zur Verfügung, um komplexere Geschäftslogik mit bewährten und bereits
eingesetzten Methoden und Technologien zu entwickeln. Bei der Verwendung von ORM-Technologien ist, wie bei anderen Datenbanksystemen
auch, auf die Spezifika von SAP HANA zu achten.
Wichtig ist dabei zu betonen, dass sich beide Entwicklungsansätze nicht
ausschließen, sondern dass hybride Anwendungen möglich sind, die
Vorteile der nativen Anwendung mit z. B J2EE-Anwendungen verbinden.
© OPITZ CONSULTING GmbH 2014
Whitepaper: In-Memory optimierte Java-Anwendungsszenarien
Seite 8
Links & Literatur
[1]
HANA Developer Guide 1.1–2014-08-21:
http://help.sap.de/hana/SAP_HANA_Developer_Guide_en.pdf
[2]
Eclipselink Development HANA Plattform:
http://wiki.eclipse.org/EclipseLink/Development/DatabasePlatform/
HANAPlatform#Limitations_of_the_Platform
Über OPITZ CONSULTING
Als führender Projektspezialist für ganzheitliche IT-Lösungen tragen wir
zur Wertsteigerung der Organisationen unserer Kunden bei und bringen IT
und Business in Einklang. Unser Leistungsspektrum umfasst ITStrategieberatung, individuelle Anwendungsentwicklung, SystemIntegration, Prozessautomatisierung, Business Intelligence, Betriebsunterstützung der laufenden Systeme sowie Aus- und Weiterbildung im hauseigenen Schulungszentrum. Mit OPITZ CONSULTING als zuverlässigem Partner können sich unsere Kunden auf ihr Kerngeschäft konzentrieren und
ihre Wettbewerbsvorteile nachhaltig absichern und ausbauen.
OPITZ CONSULTING wurde 1990 gegründet und beschäftigt heute an acht
Standorten mehr als 400 Mitarbeiter. Zu unserem Kundenkreis zählen ¾
der DAX30-Unternehmen sowie branchenübergreifend mehr als 600 bedeutende Mittelstandunternehmen.
Folgen Sie uns:
youtube.com/opitzconsulting
@OC_WIRE
slideshare.net/opitzconsulting
xing.com/net/opitzconsulting
© OPITZ CONSULTING GmbH 2014
Whitepaper: In-Memory optimierte Java-Anwendungsszenarien
Seite 9