Tervezői És Fejlesztői Környezetek (Maven, Ant, Gradle, GCP, OSGI, RCP)

Tervezői és fejlesztői
környezetek
Jakab Hunor
Bevezetõ
Build rendszerek
Apache Ant
Tervezői és fejlesztői környezetek Apache Maven
Repository
Management
Nexus
Jakab Hunor
Babeş–Bolyai Tudományegyetem
Matematika és Informatika Kar
1/42
Tematika
A tantárgy során érintett főbb témák:

I Általános tudnivalók
I Build rendszerek
I Repository management, annotációk, tervezési minták
I Reflection
I ORM (object relational mapping)
I OSGI (open service gateway initiative)
I IOC-DI (inversion of control és megvalósításai)
I Paas, Saas, Iaas (google cloud tech)
Modern fejlesztői környezetek környezetek
1
Meghatározás Jakab Hunor
Bevezetõ
Olyan programozási eszközök, könyvtárak és beállítások Fejlesztői környezetek
csoportja, melyekkel a szoftverfejlesztés során a felhasznált Build rendszerek
programozási nyelven vagy nyelveken létrehozott Apache Ant
forráskódokat futáskész állapotba lehet hozni és azokat Apache Maven
Repository
tesztelni. Management
Nexus
Főbb funkciók
I Szövegszerkesztés ( természetesen szintax
highlighting-gal )
I Help, context help, source code navigation
I Valamilyen build rendszer, sajátos projekt formátummal
I Hibakeresés ( debugging )
I Tesztelés
I Taszk és projekt menedzsment
8/42
Fejlesztői környezetek fejlődése környezetek
1
Célkitűzések Jakab Hunor
Bevezetõ
I Kényelem, szoftver fejlesztési folyamat leegyszerűsítése Fejlesztői környezetek
I If you build something even an idiot can use, only an idiot Build rendszerek
Apache Ant
will use it.
Apache Maven
Repository
Korlátozó tényezők: Management
Nexus
I Számítógépek kapacitása
I Grafikus felületek hiánya
Néhány említésreméltó korai IDE
I 1983 Turbo Pascal
I Emacs, Lisp env, Smalltalk

I 90-es évek, windows grafikus felület -> Visual basic
I Delphi (Borland)
I HTML elterjedése -> Front page
9/42
Ms Visual Studio környezetek
A Microsoft által fejlesztett IDE Főbb jellemzői:

1
Jakab Hunor
I c/c++, VB.NET, C#, F#, Asp Bevezetõ
I Támogat más programozási nyelveket is „language Fejlesztői környezetek
Build rendszerek
service”-eken keresztül
Apache Ant
I Intellisense, beépített vizuális debugger, refactoring Apache Maven
I .Net framework, Ms Silverlight, Ms Windows, Windows CE Repository

Management
Nexus
Kiegészítők
Visual assist ( Whole Tomato), Resharper stb.
Kiegészítők
I A Ms ökoszisztémán belüli fejlesztésre ösztönöz
I Verziókövetés, taszk menedzsment, hibajelentés és
javítás a Ms Team Foundation Service köré épül
I (Tight bounding) Visual Studio - TFS - Windows Server
10/42
Közösségi projektek, Eclipse környezetek
1
Eclipse Jakab Hunor
Bevezetõ
I Nyílt forráskodú projekteken dolgozó közösség Fejlesztői környezetek
I Kiterjeszthető fejlesztői platform és keretrendszer Build rendszerek
fejlesztése Apache Ant
Apache Maven
I Eclipse projektek legismertebb tagja az Eclipse fejlesztői Repository
környezet Management
Nexus
Több mint 100 open source projekt az alábbi kategóriákból:

I CORE (Equinox, RCP, JDT)
I Vállalati fejlesztés (Enterprise Development)
I Keretrendszerek (Application Frameworks)
I Integrált fejlesztői környezetek
I Felhő alapú fejlesztés ( Che, Orion )
I Fejlesztéssel, modellezéssel, verifikációval és validációval
kapcsolatos eszközök
I Beágyazott rendszerek fejlesztése
I Projektek életciklusának managementje
I Szolgáltatás orientált architektúrák (Service Oriented
11/42
Eclipse Java IDE környezetek
Legfrissebb verziója: 4.7 Oxygen

1
Jakab Hunor
Alapvető funkcionalitások:
Bevezetõ
I Szintakszis szerinti színezés (syntax highlight), java Fejlesztői környezetek
forrásfájlokra Build rendszerek
I Kódkiegészítés, lehetőségek felajánlása Apache Ant
I Beépített és saját kódsablonok Apache Maven
Repository
I Automatikus kódformázás Management
I Erős refactoring támogatás (osztály, metódus Nexus
átnevezések, áthelyezések)
I Automatikus kódgenerálás (getter/setter-ek,
konstruktorok, absztrakt metódusok, try-catch blokkok)
I Forrás részletek elrejtése, megjelenítése (folding)
I Java dokumentáció megmutatás popup ablakban
I Hívási fa és fordított hívási fa megjelenítése (melyik
metódust honnan hívják)
I Potenciális programozási problémák jelzése,
csoportosítása
I JUnit teszt futtatási lehetőségek
I Ant, Maven, Git támogatás (Kepler)
12/42
Plugin szerkezet környezetek
1
Eclipse Jakab Hunor
Bevezetõ
I Nincs telepítője, nem tartalmazza a Java futási Fejlesztői környezetek
környezetet (JRE) Build rendszerek
Apache Ant
I Plug-in-ek letöltésével és telepítésével bővíthető
Apache Maven
I Moduláris szerkezetű Repository
Management
Nexus
Sajátos build rendszerrel rendelkezik, viszont támogatja az
Ant, Maven és Gradle alapú fordítást is.
13/42
NetBeans platform környezetek
1
Története Jakab Hunor
Bevezetõ
I Sun Microsystems tulajdona 1999-től, nyílt forráskódú Fejlesztői környezetek
2000 óta. Build rendszerek
I 2010-től az Oracle tulajdona Apache Ant
Apache Maven
I Eredetileg Romanik Stanek Charles Uiversity diák Repository
fejlesztette egy projekt keretén belül Management
Nexus
I Teljes egészében java-ban íródott, a JavaBeans koncepció
köré épül
Főbb funkcionalitások:
I Ant-alapú projekt rendszer
I Maven támogatás
I Verziókövetés (CVS, Subversion, Mercurial Clearcase).
I Java SE (JavaFX), Java ME, web, EJB mobil
alkalmazások fejlesztése
I Szabadon bővíthető, platform független
I Java, Php, C/C++, HTML5 támogatás
14/42
Code::Blocks környezetek
1
Története Jakab Hunor
Bevezetõ
I Ingyenes, nyílt forráskódú c/c++ ide, c++ es wxWidgets Fejlesztői környezetek
segítségével íródott Build rendszerek
Apache Ant
I Fejlesztői csapat: The Code::Blocks team
Apache Maven
I 2008-ba jelent meg az első stabil kiadása Repository
Management
I Számos c++ compilert támogat. Nexus
Főbb tulajdonságai:
I Jól megtervezett kód szerkesztő
I Vizuális debugger
I wxSmith Gui designer
I Saját build rendszer és projekt állományok
I Makefile projekteket is képes kezelni
15/42
Egyéb fejlesztői környezetek környezetek
1
I IntelliJ IDEA Jakab Hunor
I QTCreator Bevezetõ
Fejlesztői környezetek
I CodeLite Build rendszerek
I Dev-C++ Apache Ant
Apache Maven
I KDevelop Repository
Management
I MonoDevelop
Nexus
I Rational Software Architect
I Xcode (Apple)
I Anjuta
I etc.
I webstorm
I android studio
I aptana studio (Ruby on rails)
16/42
Build automatizáló eszközök környezetek
1
Build automation tool Jakab Hunor
Bevezetõ
A „fordítási”, „futáskész állapotba helyezés”-i folyamatok
Build rendszerek
automatizálását szolgálja Apache Ant
Apache Maven
Egy build rendszer által ellátott leggyakoribb feladatok: Repository
Management
I Erőforrások feldolgozása
Nexus
I Fordítás
I Csomagolás
I Tesztelés (teszt esetek végrehajtása, statisztikák
készítése)
I Telepítés ( deployment )
Néhány klasszikus példa

Make, AutoTools (GNU build system), Ant, Maven
17/42
Build automatizáló eszközök környezetek
1
Make alapú eszközök Jakab Hunor
Bevezetõ
I make, build,mk, nmake Microsoftstb. Build rendszerek
I Platform függőség ( platform specifikus utasítások Apache Ant
használata ) Apache Maven
Repository
I Hatalmas méretű, nehezen karban tartható állományok, Management
nagyobb projektek esetében Nexus
I Léteznek különböző build script generáló eszközök pl:

automake, cmake, premake stb.
Make alapú build eszközök listája
Apache Ant és Maven

I A hordozhatóság és átláthatóság jegyében születtek
I Open source eszközök ( főleg de nem csak java
alkalmazások fejlesztésére )
18/42
Apache Ant(Another neat tool) környezetek
Tulajdonságok:
1
Jakab Hunor
I Java-ban implementált build automation tool (hasonlít a
Bevezetõ
make-hez)
Build rendszerek
I Platform független
Apache Ant
I Open Source (Apache Software License) Apache Maven
I James Duncan Davidson fejlesztette ki: patform Repository

Management
függetlenné akarta tenni a build folyamatot a make-kel Nexus
ellentétben
Összehasonlítás: állomány törlése

Make:
I linux alatt rm -rf classes/
I Windows alatt rmdir /S /Q classes
Ant:
I delete dir="classes"
Konfiguráció:
I Xml alapú leíró állomány build.xml
19/42
Három koncepció köré épül:

1
Jakab Hunor
I target ( cél ) Bevezetõ
I task (feladat) Build rendszerek
Apache Ant
I extension point (kiterjesztési pont)
Apache Maven
Repository
Feladat ( task ) Management
Nexus
Egy végrehajtási egység, vamilyen elemi feladatot hajt végre pl
( fordítás, teszt futtatás stb. ). A teljes rendelkezésre álló task
listát megnézhetjük itt: Lista

Pl1:
<javac srcdir="${src}" destdir="${build}" classpath="xyz.jar"
debug="on" source="1.4" />
Pl2:
<echo>This is a longer message </echo>

20/42

1
Jakab Hunor
Apache Ant
Apache Maven
Repository
Target (cél) Management
Nexus
A feladatokat célokba csoportosíthatjuk, melyeket ant
segítségével futtathatunk. A különböző célokat külön is lehet
futtatni, vagy egymástól függővé tenni.

Pl:
<target name="compile">
<mkdir dir="build/classes"/>
<javac srcdir="src" destdir="build/classes"/>
</target>

21/42

1
Jakab Hunor
Apache Ant
Apache Maven
Repository
Kiterjesztési Pont Management
Nexus
Hasonló egy cél-hoz, egy fázist képvisel a build folyamatból.
Nem tartalmaz feladatleírást, csupán célok csoportosítását
szolgálja

Pl:
<extension-point name="ready-to-compile"
depends="create-directory-layout"/>
<target name="generate-sources"
extensionOf="ready-to-compile"> ... </target>

22/42
Példa:
1
Jakab Hunor
<project name="HelloWorld" basedir="." default="main"> Bevezetõ
Build rendszerek
<property name="src.dir" value="src"/>
Apache Ant
<property name="build.dir" value="build"/>
Apache Maven
<property name="classes.dir" value="${build.dir}/classes"/>
Repository
<property name="jar.dir" value="${build.dir}/jar"/> Management
<property name="main-class" value="oata.HelloWorld"/>
Nexus
<target name="clean">
<delete dir="${build.dir}"/>
</target>
<target name="compile">
<mkdir dir="${classes.dir}"/>
<javac srcdir="${src.dir}" destdir="${classes.dir}"/>
</target>
<target name="main" depends="clean,run"/>
</project>

23/42
Apache Maven környezetek
1
Maven koncepció Jakab Hunor
Bevezetõ
I Elsősorban Java alkalmazások fejlesztésénél használt Build rendszerek
„projekt menedzsment eszköz”, de számos más nyelvet is Apache Ant
támogat különböző plugin-eken keresztül: C#,Ruby Apache Maven
,Scala, C++ stb Repository
Management
I A Project Object Model koncepciója köré épül Nexus
I XML alapú konfigurációs állományok segítségével írja le a

projektet és ennek tulajdonságait: POM.xml
A "convention over configuration " elvét követi:

I pl. Ruby on Rails, EJB3,
Maven esetében a projektek szerkezete, fordítása,

csomagolása, terjesztése mind alapértelmezetten elfogadott
konvenciókon alapszik.
24/42
1
Project Object Model Jakab Hunor
Bevezetõ
Egy szoftver project körülírása, egyértelmű azonosítókkal való Build rendszerek
ellátása. (kik a fejlesztői, milyen függőségei vannak, milyen Apache Ant
licensz alapján használható stb.). Apache Maven
A projekt tulajdonságainak leírását is magába foglalja. Repository
Management
Nexus
Ez a definíció a következő funkcionalitásokat teszi lehetővé:
I Dependency management
I Távoli szoftware komponens gyűjtemények használata
I Általánosan újrahasznosítható fordítási munkamenet
I Hordozhatóság, integrálhatóság ( pl. Eclipse, NetBeans,
IntelliJ projektek egységesítése)
I Szoftver komponensek egyszerű keresése, szűrése
25/42
Az Ant-hez hasonló funkcionalitásokat valósít meg viszont

1
Jakab Hunor
sokkal több mint egy build automatizáló eszköz. Teljesen más
Bevezetõ
elveket követ mint az ANT:
Build rendszerek
I Életciklus (fázisok) és plug-inek ( célok és feladatok Apache Ant
helyett ) Apache Maven
Repository
I Előre meghatározott projekt szerkezetek ( konvenció Management
alapján) Nexus
I Életciklus és plug-in parancsok a build folyamat különböző

lépéseinek végrehajtására
I Függőségek automatikus kezelése egy központi
repository-n keresztül
26/42
Példa környezetek
Egy egyszerű projekt létrehozása:

1
Jakab Hunor
mvn archetype:generate
Bevezetõ
A fenti utasítás elemei: Build rendszerek
Apache Ant
I mvn: a maven parancs
Apache Maven
I archetype:generate: a maven cél (goal)
Repository
Management
I archetype: a maven plugin
Nexus
Archetype
Egy eredeti model vagy típus mely alapján hasonló
szoftveregységeket mintázhatunk. Egy úgynevezett prototípus

$ mvn archetype:generate -DgroupId=org.sonatype.mavenbook.simple \
-DartifactId=simple \
-Dpackage=org.sonatype.mavenbook
...
[INFO] [archetype:generate]
[INFO] artifact org.apache.maven.archetypes:maven-archetype-quickstart: \
checking for updates from central

27/42
Példa környezetek
Az eredmény: egy standard könyvtár struktúra:

1
Jakab Hunor
I A projekt alapkönyvtára (megegyezik az ArtifactId-val)
Bevezetõ
I pom.xml Build rendszerek
I src/main a projekt forráskódja és erőforrásai: Apache Ant
I src/main/java forráskódok Apache Maven
I src/main/resources erőforrások Repository

Management
I src/test a projekt teszt esetei Nexus
Fordítás, tesztelés, telepítés

mvn install

mvn install
[INFO] Scanning for projects...
[INFO]
----------------------------------------------------------------------
[INFO] Building simple
[INFO]task-segment: [install]
[INFO]
----------------------------------------------------------------------

28/42
Pluginok és célok környezetek
1
Plugin Jakab Hunor
Bevezetõ
Különböző célok kollekciója, ahol egy cél hasonlít egy ANT Build rendszerek
taszk-hoz. pl. jar, compile, surfire stb. Apache Ant
Apache Maven
Repository
Cél (goal) Management
Nexus
Egy specifikus feladat amelyet önállóan vagy más feladatokkal
együtt hajthatunk végre egy komplexebb build részeként.
A Maven funkcionalitásait pluginok és célok valósítják meg,

önmagában csak néhány alapvető feladat elvégzésére képes
pl:
I beállítani a classpath változót
I értelmezni a pom.xml-t
I letölteni különböző maven plugin-okat
29/42
Maven életciklus környezetek
Egy maven build életciklusa különböző fázisokból tevődik

1
Jakab Hunor
össze
Bevezetõ
Életciklus fázisok Build rendszerek
Apache Ant
Minden különböző típusú projekt esetében mást jelentenek. Apache Maven
Nincsenek szigorúan definiálva, alapértelmezett célok Repository

Management
sorozatát pl. package fázis web és egyszerű java alkalmazás Nexus
esetén.
I Az életciklus fázisaihoz különböző célokat köthetünk.

I Az életciklus fázisok rendelkeznek alapértelmezetten
hozzájuk rendelt célokkal (projekt típustól függően)
Tekintsük meg újra a következő utasítás eredményét:

mvn install

30/42
Maven alapértelmezett életciklus főbb fázisai környezetek
1
I validate - ellenőrzi a projekt helyességét és az összes Jakab Hunor
szükséges információ meglétét Bevezetõ
I compile - a forráskód fordítása Build rendszerek
Apache Ant
I test - a lefordított forráskód tesztelése egy megfelelő teszt Apache Maven
keretrendszer segítségével Repository
Management
I package - a fordított kód becsomagolása a projektnek Nexus
megfelelő formátumú hordozható állományba
I integration-test - a csomag feldolgozása és egy olyan
környezetbe való helyezése ahol integrációs tesztek
futtathatóak
I verify - a csomag érvényességének ellenőrzése
I install - a csomag lokális repositoryba való telepítése
I deploy - a csomag távoli tárhelyre történő másolása
megosztás vagy üzembehelyezés céljából
31/42
1
Jakab Hunor
Bevezetõ
Build rendszerek
Apache Ant
Apache Maven
Repository
Management
Nexus
Alapértelmezett életciklus fázisok és

hozzárendelések
I Dokumentálva ITT!
32/42
1
Jakab Hunor
Bevezetõ
Build rendszerek
Apache Ant
Apache Maven
Repository
Management
Nexus
33/42
Függőség management környezetek
Függőség kezelés a Maven egyik legjelentősebb előnye

1
Jakab Hunor
Kategóriák Bevezetõ
Build rendszerek
I Direkt függőségek Apache Ant
I Tranzitív függőségek "a függőségek függőségei" Apache Maven
Repository
Management
Nexus
Függőségek kezelésének menete:
I függőség kikeresése:

junit:junit:3.8.1 → maven <dependency>
repo:/junit/junit/3.8.1/junit- <groupId>junit</groupId>
3.8.1.jar <artifactId>junit</artifactId>
<version>3.8.1</version>
I a függőség .jar letöltése <scope>test</scope>
I A tranzitív függőségek </dependency>

kikeresése letöltése a
POM alapján
34/42
Maven függőségek környezetek
1
Felmerülő kérdések Jakab Hunor
Bevezetõ
I Honnan töltődnek le a függőségek ?
Build rendszerek
I Hol lesznek ezek lokálisan tárolva ? Apache Ant
I A fordítás melyik szakaszában lesznek igénybevéve és Apache Maven
hogyan? Repository
Management
Nexus
A központi gyűjtemény (central repository)

I repo.maven.apache.org vagy uk.maven.org
I keresés: http://search.maven.org
A lokális gyűjtemény (local repository)

I Windows: C:\Users\Documents and Settings
\USERNAME\.m2\repository
I Linux: /home/USERNAME/.m2/repository
35/42
Függőségek hatóköre környezetek
1
A lokális gyűjtemény (local repository) Jakab Hunor
Bevezetõ
Függőségeket általában csak a build egy adott fázisában van Build rendszerek
szükség Apache Ant
Apache Maven
Hatókörök jelentősége: Repository
Management
I test</scope> Nexus
I csak a test fázisban lesz a <dependency>

classpath-hoz hozzáadva <groupId>junit</groupId>
<artifactId>junit</artifactId>
I A scope lehet: <version>3.8.1</version>
I bármelyik maven <scope>test</scope>
életciklus fázis </dependency>

I provided EAR vagy WAR
esetén pl. servlet api jar
36/42
Maven függőségek környezetek
1
Jakab Hunor
Listing 1: pom.xml
Bevezetõ
<dependencies> Build rendszerek

<dependency> Apache Ant
<groupId>junit</groupId>
Apache Maven
<artifactId>junit</artifactId>
<version>3.8.1</version> Repository
Management
<scope>test</scope>
</dependency> Nexus
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
</dependency>
<dependency>
<groupId>velocity</groupId>
<artifactId>velocity</artifactId>
<version>1.5</version>
</dependency>
</dependencies>

37/42
Maven repository management környezetek
1
A gyűjtemény fogalma Jakab Hunor
Bevezetõ
A collection of binary software artifacts and metadata stored in Build rendszerek
a defined directory structure which is used by clients such as Apache Ant
Apache Ivy or Maven to retrieve binaries during a build Apache Maven
process. Repository
Management
Nexus
Tulajdonságok:
I Végleges(RELEASE) és ideiglenes(SNAPSHOT) állapotú
állományokat tárolhat (Artifact)
I struktúrált elrendezést biztosít amely alapján a kliensek
hatékonyan tudnak benne keresni
I az elsődleges "artifact" típus a jar
I Bármilyen más típust tárolhat (dokumentációt, forráskódot
tartalmazó archívumok, könyvtárak stb)
I Egy tárolási, elérési és menedzselési platformot kínál (
artifact + metadata)
38/42
Maven repository management környezetek
1
GAV koordináták Jakab Hunor
Bevezetõ
GAV) Group, ArtifactId, Version coordinate
Build rendszerek
Apache Ant
I groupId: logikai csoportokba szervezi a szoftver Apache Maven
komponenseket ( általában készítők hovatartozását Repository

Management
tükrözi ) pl: org.apache.maven Nexus
I artifactId: a szoftver komponens azonosítója, lehet ez

alkalmazás vagy library. A groupIdartifactId kombináció
egyedi kell legyen minden projekt esetében
I Version: Major, Minor, Point release verziószámok +
alfanumerikus jellemzők pl: 1.2.3BETA
39/42
Gyűjtemény típusok környezetek
1
A központi gyűjtemény (RELEASE) Jakab Hunor
Bevezetõ
egy szoftverkomponens specifikus verziószámmal ellátott stabil Build rendszerek
kiadása. Egy release artifact és a hozzá tartozó POM statikus Apache Ant
objektumok a repositoryban, soha nem változnak. Apache Maven
Repository
Management
A lokális gyűjtemény (SNAPSHOT) Nexus
egy szoftverkomponens fejlesztése során generált különböző

ideiglenes változatok. Verziószámmal és időbélyeggel is
rendelkeznek, a fejlesztési folyamat előrehaladtával
folytonosan változnak.
Egy stabil repository-ban található szoftver komponensek

valódiságát MD5 és SHA hash kódokkal és PGP aláírások
segítségével biztosítják.
40/42
Nexus repository manager környezetek
1
Előnyei Jakab Hunor
Bevezetõ
Lehetőséget ad saját repository létrehozására, külső Build rendszerek
reposiroty-k tükrözésére, cache-elésére, statisztikák Apache Ant
készítésére, projekt site-ok hosztolására stb. Jelentősen Apache Maven
felgyorsíthatja a build folyamatot Repository

Management
Nexus
BBTE Nexus belső repository managere:
I http://pdae.cs.ubbcluj.ro/nexus

<mirror>
<id>Nexus</id>
<mirrorOf>*</mirrorOf>
<url>http://pdae.cs.ubbcluj.ro/nexus/content/groups/public</url>
</mirror>
</mirrors>

41/42
DAO, Abstract DAO factory
Data Access Object környezetek
4
Szerepe Jakab Hunor
Elkülöníti az adatforráshoz való hozzáférést az alkalmazás

logikájától
Kapcsolódó fogalmak:
I Business object: adathozzáférést használó kódrészlet
“kliens”
I Data Source: az adathozzáférés alacsony szintű
implementációja pl: DriverManager
I Transfer object: Egy adat-egység átvitelére használt
model objektum (pl. Entity Bean)
3/9
4
Jakab Hunor
Problémák:
I Kliens direkt módon ismeri az implementáció részleteit
I Nincs egységesítve a különböző implementációkhoz való
hozzáférés
4/9
4
Jakab Hunor
I A példányosításhoz még mindig hivatkoznunk kell az

implementációt tartalmazó csomagra
5/9
4
Jakab Hunor
I Mi történik több különböző implementáció esetén

I A kliensnek ismernie kell azt amelyiket használni akarja
6/9
DAO factory környezetek
4
Jakab Hunor
I A különböző implementációk példányosítását

átruházhatjuk egy-egy sajátos Gyár(factory) osztályra
7/9
Abstract DAO factory környezetek
4
Jakab Hunor
I Az abstract factory elrejti a konkrét példányosítás

8/9
környezetek
Jakab Hunor
Lokalizáció és
nemzetköziesítés
ResourceBundle
Tervezői és fejlesztői környezetek Java erőforrások

betöltése
Erőforrások
Maven-ben
Szerializáció
Jakab Hunor Java Reflection API
1/37
Fogalmak környezetek
2
Nemzetköziesítés: Jakab Hunor
Az a folyamat melynek során egy alkalmazást felkészítünk Lokalizáció és

nemzetköziesítés
több különböző nyelv és adat-formátum támogatására! ResourceBundle
Java erőforrások
betöltése
Lokalizáció Erőforrások
Maven-ben
Az a folyamat melynek során egy nemzetköziesített Szerializáció
alkalmazást átalakítunk a forráskód módosítása nélkül, adott Java Reflection API
helyi sajátosságok támogatása érdekében.
Locale
java.util.Locale egy földrajzi, politikai vagy kulturális régiót
azonosít. Három információdarab azonosít egyértelműen egy
"locale"-t:
I nyelv
I ország
I változat (opcionális)
Pl: fr (Francia), de_CH (Svájci német), en_US_POSIX (Angol). 2/37
Fogalmak környezetek
2
Nemzetköziesítés: Jakab Hunor
Az a folyamat melynek során egy alkalmazást felkészítünk Lokalizáció és

nemzetköziesítés
több különböző nyelv és adat-formátum támogatására! ResourceBundle
Java erőforrások
betöltése
Lokalizáció Erőforrások
Maven-ben
Az a folyamat melynek során egy nemzetköziesített Szerializáció
alkalmazást átalakítunk a forráskód módosítása nélkül, adott Java Reflection API
helyi sajátosságok támogatása érdekében.
Locale
java.util.Locale egy földrajzi, politikai vagy kulturális régiót
azonosít. Három információdarab azonosít egyértelműen egy
"locale"-t:
I nyelv
I ország
I változat (opcionális)
Pl: fr (Francia), de_CH (Svájci német), en_US_POSIX (Angol). 2/37
Példák környezetek
Néhány példa "locale" függő információra:

2
Jakab Hunor
I üzenetek
Lokalizáció és
nemzetköziesítés
I UI címkék
ResourceBundle
I karakterkészletek Java erőforrások
betöltése
I karakterkódolás (legtöbb esetben utf-8 ázsiai nyelveknél Erőforrások
esetleg utf-16) Maven-ben
Szerializáció
I dátum és pénznem formátum
Java Reflection API
Motiváció
Kiemelt jelentösége van Web-alkalmazások esetében, a web
globális természetéből adódóan.
Példa
I Web: http://www.cs.ubbcluj.ro
I Standalone: http://www.libreoffice.org
3/37
Locale környezetek
I ISO Language Code: http://www.loc.gov/

2
Jakab Hunor
standards/iso639-2/php/code_list.php
Lokalizáció és
I ISO Country Code: nemzetköziesítés
https://www.iso.org/obp/ui/#search ResourceBundle
Java erőforrások
Locale l1 = new Locale("en","US"); betöltése
Locale l2 = new Locale("en","GB"); Erőforrások

Maven-ben
Szerializáció
Java Reflection API
/** Listing all the available locales on the System
*/
import java.util.*;
import java.text.*;
public class Available {
static public void main(String[] args) {
Locale list[] = DateFormat.getAvailableLocales();
for (int i = 0; i < list.length; i++) {
System.out.println(list[i].getLanguage() + " "
+list[i].getCountry());
}
}
}

4/37
Locale környezetek
2
Alapértelmezett érték megadása: Jakab Hunor
Lokalizáció és
a user.language és user.region rendszer tulajdonságok nemzetköziesítés
beállítása, vagy egy Locale osztály setDefault() metódusa ResourceBundle
Java erőforrások
betöltése
Erőforrások
Maven-ben
/** Setting the default locale */
import java.util.*; Szerializáció
public class DefaultLocale { Java Reflection API
static public void main(String[] args) {

Properties props = System.getProperties();
props.put("user.language", "ja");
props.put("user.region", "JP");
System.setProperties(props);
Locale aLocale = Locale.getDefault();
System.out.println(aLocale.toString());
aLocale = new Locale("fr", "FR");
Locale.setDefault(aLocale);
System.out.println(aLocale.toString());
}
}

5/37
Resource bundle környezetek
2
tárolás Jakab Hunor
Lokalizáció és
regionális adatok tárolása egy ResourceBundle nemzetköziesítés
(java.util.ResourceBundle)-ben történik. ResourceBundle
Java erőforrások
betöltése
I Kulcs-érték párokat tárol Erőforrások
Maven-ben
I Properties file properties resource bundle Szerializáció
I Class list resource bundle Java Reflection API
I Basename (közös része a különböző bundle neveknek)

kiegészítve a megfelelő Locale-el.
6/37
Resource bundle környezetek
2
Jakab Hunor
import java.util.*; Lokalizáció és

public class LocaleSample { nemzetköziesítés
public static void main(String[] args) { ResourceBundle
String language; Java erőforrások
String country; betöltése
if (args.length != 2) { Erőforrások
Maven-ben
language = new String("en");
country = new String("US"); Szerializáció
} else { Java Reflection API
language = new String(args[0]);

} else {
language = new String(args[0]);
country = new String(args[1]);
}
Locale currentLocale;
ResourceBundle messages;
currentLocale = new Locale(language, country);
messages = ResourceBundle.getBundle("MessagesBundle",currentLocale);
System.out.println(messages.getString("greetings"));
System.out.println(messages.getString("inquiry"));
System.out.println(messages.getString("farewell"));
}
}

7/37
Resource bundle propertiesbundle környezetek
2
Jakab Hunor
MessagesBundle.properties Lokalizáció és
greetings = Hello. nemzetköziesítés
farewell = Goodbye. ResourceBundle
inquiry = How are you?

Java erőforrások
betöltése
Erőforrások
MessagesBundle_de_DE.properties Maven-ben
greetings = Hallo. Szerializáció
farewell = Tschuss.
Java Reflection API
inquiry = Wie geht’s?

MessagesBundle_en_US.properties
greetings = Hello.
farewell = Goodbye.
inquiry = How are you?

MessagesBundle_fr_FR.properties
greetings = Bonjour.
farewell = Au revoir.
inquiry = Comment allez-vous?

8/37
Resource bundle listresourcebundle környezetek
2
Jakab Hunor
Listing 1: "MessageBundle_en_US.class" Lokalizáció és

nemzetköziesítés
import java.util.*; ResourceBundle
public class MessageBundle_en_US extends ListResourceBundle {
Java erőforrások
public Object[][] getContents() { betöltése
return contents; } Erőforrások
private Object[][] contents = { Maven-ben
{ "greetings", new String("Hello") }, Szerializáció

{ "farewell", new String("Goodbye") }, Java Reflection API
{ "inquiry", new String("How are you?") },
};}

Listing 2: "MessageBundle_fr_FR.class"
import java.util.*;
public class MessageBundle_fr_FR extends ListResourceBundle {
public Object[][] getContents() {
return contents; }
private Object[][] contents = {
{ "greetings", new String("Bonjour.") },
{ "farewell", new String("Au revoir.") },
{ "inquiry", new String("Comment allez-vous?") },
}; }

9/37
List vs. property resourcebundle környezetek
ListResourceBundle Pro
2
Jakab Hunor
I bármilyen lokalizálható objektumot tartalmazhat
Lokalizáció és
nemzetköziesítés
I gyorsabban betöltődik mivel előre fordítva van
ResourceBundle
I megírható úgy, hogy bárhonnan betöltsön erőforrásokat, Java erőforrások
betöltése
akár adatbázisokból is
Erőforrások
I bármilyen krakterkészletet használhatunk benne Maven-ben
Szerializáció
ListResourceBundle Contra Java Reflection API
I Meg kell írni a java forrást nehézkes nem-programozók
számára
Propertyresource Pro
I Könnyen szerkeszthető
I Könnyen lokalizálható
Propertyresource Contra
I Csak karakterláncokkal használható
I Korlátozott karakterkészlet
10/37
Erőforrások megtalálása környezetek
2
Keresés Jakab Hunor
I A futási környezet segítségével történik, a classpath-ban Lokalizáció és

nemzetköziesítés
levő összes .jar állomány megtekintésével. ResourceBundle
I location independent - mivel csak a helyes futási Java erőforrások

betöltése
környezetre van szüksége az erőforrások megtalálására. Erőforrások
Maven-ben
I A resource name alapján keres
Szerializáció
Java Reflection API
Abszolút és relatív erőforrás nevek.

I abszolút pl: /path/resource.xml
I relatív a metódus hívásának helyéhez viszonyítva pl:
path/resource.xml

package ro.ubbcluj.cs
class ResourceFinder {
public void findResources(){
InputStream stream1 =
getClass().getResourceAsStream("/path/resource.xml");
getClass().getResourceAsStream("path/resource.xml");
}

11/37
Erőforrások betöltése környezetek
2
Class vs. ClassLoader Jakab Hunor
Lokalizáció és
I Class.getResource() nemzetköziesítés
I ClassLoader.getResource() - nem alkalmaz ResourceBundle
Java erőforrások
abszolút/relatív átalakítást betöltése
Erőforrások
Maven-ben
Szerializáció
Java Reflection API

package ro.ubbcluj.cs
class ResourceFinder {
public void findResources(){
getClass().getResourceAsStream("/path/resource.xml");
getClass().getResourceAsStream("path/resource.xml");
getClass().getClassLoader().getResourceAsStream("path/resource.xml");
getClass().getClassLoader().getResourceAsStream("/path/resource.xml");
}

12/37
ResourceBundle vs. Properties környezetek
2
Használati esetek Jakab Hunor
Lokalizáció és
I ResourceBundle: i18, lehetővé teszi egy adott nemzetköziesítés
"locale"-hez tartozó objektumok konzisztens módon ResourceBundle
történő lekérdezését Java erőforrások

betöltése
I Properties - string-string megfeleltetésre van szükségünk Erőforrások
Maven-ben
loklizációtól függetlenül Szerializáció
Java Reflection API
Megjegyzések:
I A betöltendő erőforrások általában be vannak ágyazva
bizonyos .jar állományokba
I A szükséges .jar állományok bekerülnek a classpath-ba
I Itt keresés csak a class vagy classloader metódusain
keresztül lehetséges
13/37
Maven standard könyvtárstruktúra környezetek
2
src/main/java Application/Library sources Jakab Hunor
src/main/resources Application/Library resources Lokalizáció és

nemzetköziesítés
src/main/filters Resource filter files . . . ResourceBundle
src/main/config Configuration files Java erőforrások

betöltése
src/main/scripts Application/library scripts Erőforrások

Maven-ben
src/main/webapp Web application sources . . . Szerializáció
Java Reflection API

src/test/java Test sources
src/test/resources Test resources
src/test/filters Test resources filter files . . .
src/assembly Assembly descriptors
src/site Site
Erőforrások
Egyéb erőforrásokat tartalmazó könyvtárak hozzáadhatóak a
build-hez a maven resources plugin segítségével
14/37
Resource könyvtárak hozzáadása környezetek
2
Jakab Hunor
Listing 5: "project" Lokalizáció és

nemzetköziesítés
ResourceBundle
Project
Java erőforrások
|-- pom.xml betöltése
‘-- src
Erőforrások
‘-- my-resources

Maven-ben
Szerializáció
Listing 6: "pom.xml" Java Reflection API

<project>
...
<build>
...
<resources>
<resource>
<directory>src/my-resources</directory>
</resource>
</resources>
...
</build>
...
</project>

15/37
Szerializáció környezetek
2
I Standard eljárás az objektumok állapotának adatfolyamba Jakab Hunor
történő kiírására (elmentésére egy bájtszekvenciába), és Lokalizáció és

nemzetköziesítés
visszatöltésére
ResourceBundle
I Perzisztencia (archiválás későbbi felhasználásra), osztott Java erőforrások
OO rendszerek (távoli metódushívások) (marshalling – betöltése
Erőforrások
szerializáció, a codebase elmentésével) Maven-ben
I Lehetőségek: alapértelmezett protokoll, vagy annak Szerializáció
Java Reflection API

módosítása, saját protokoll
I ObjectInputStream, ObjectOutputStream
Kiírás

fos = new FileOutputStream(filename);
out = new ObjectOutputStream(fos);
out.writeObject(new MyObject());
//serialization out.close();

16/37
Szerializáció környezetek
2
I Standard eljárás az objektumok állapotának adatfolyamba Jakab Hunor
történő kiírására (elmentésére egy bájtszekvenciába), és Lokalizáció és

nemzetköziesítés
visszatöltésére
ResourceBundle
I Perzisztencia (archiválás későbbi felhasználásra), osztott Java erőforrások
OO rendszerek (távoli metódushívások) (marshalling – betöltése
Erőforrások
szerializáció, a codebase elmentésével) Maven-ben
I Lehetőségek: alapértelmezett protokoll, vagy annak Szerializáció
Java Reflection API

módosítása, saját protokoll
I ObjectInputStream, ObjectOutputStream
Beolvasás

fis = new FileInputStream(filename);
in = new ObjectInputStream(fis);
time = (MyObject)in.readObject();
//live object
//exact replica
in.close();

17/37
A Serializable interface környezetek
I Az objektumoknak implementálniuk kell a Serializable

2
Jakab Hunor
interface-t (vagy az alaposztálytól örökölniük az
Lokalizáció és
implementációt) nemzetköziesítés
I Az Object nem implementálja, tehát nem minden objektum ResourceBundle
szerializálható (de a legtöbb standard Java osztály – Java erőforrások

betöltése
alaposztályok, listák, GUI komponensek – igen) Erőforrások
I Nem szerializálható objektumok pl.: thread, socket, stream Maven-ben
Szerializáció
stb. (de attól, hogy egy osztály tartalmaz pl. egy thread
Java Reflection API
példányt, a többi része még lehet szerializálható →
transient típusmódosító alkalmazása)

import java.io.Serializable;
import java.util.Date;
import java.util.Calendar;
public class PersistentTime implements Serializable {
private Date time;
public PersistentTime() {
time = Calendar.getInstance().getTime();
}
public Date getTime(){
return time;
}}

18/37
Transient módosító környezetek
2
Azokat az adattagokat, amelyeket nem lehet szerializálni, vagy Jakab Hunor
nem szeretnénk, hogy részei legyenek az objektum Lokalizáció és

nemzetköziesítés
perzisztens állapotának (nem akarjuk elmenteni) transient ResourceBundle
–nek nyilvánítjuk Java erőforrások
betöltése
Erőforrások
Maven-ben
import java.io.Serializable; Szerializáció
public class PersistentAnimation Java Reflection API

implements Serializable, Runnable{
transient private Thread animator;
private int animationSpeed;
public PersistentAnimation(int animationSpeed) {
this.animationSpeed = animationSpeed;
animator = new Thread(this);
animator.start();
}
public void run(){
while(true) {
// do animation here}
}
}

19/37
A szerializációs protokoll testreszabása környezetek
2
Példa Jakab Hunor
Lokalizáció és
az animáció esetében, ha elmentünk, majd beolvasunk egy nemzetköziesítés
PersistentAnimation példányt, a konstruktor nem kerül ResourceBundle
meghívásra (nem történik példányosítás), az objektum nem fog Java erőforrások

betöltése
megfelelő módon viselkedni (a szál nem jön létre, nem Erőforrások
indíthatjuk el) Maven-ben
Ha külön metódusba tennénk a problémás részt, a Szerializáció
Java Reflection API

felhasználónak tudnia kellene erről a metódusról
Megoldás: a protokoll testreszabása:

private void writeObject(ObjectOutputStream out)
throws IOException;
private void readObject(ObjectInputStream in)
throws IOException, ClassNotFoundException;

Az újradefiniált metódusok első sorai:

out.defaultWriteObject();
in.defaultReadObject();

20/37
A szerializációs protokoll testreszabása környezetek
2
Jakab Hunor
import java.io.Serializable; Lokalizáció és

public class PersistentAnimation implements Serializable, Runnable{
nemzetköziesítés
transient private Thread animator; ResourceBundle
private int animationSpeed; Java erőforrások
public PersistentAnimation(int animationSpeed){ betöltése
this.animationSpeed = animationSpeed; Erőforrások

Maven-ben
startAnimation();
} Szerializáció
public void run(){ Java Reflection API
while(true){
// do animation here
}
}
private void writeObject(ObjectOutputStream out) throws IOException{
out.defaultWriteObject();
}
throws IOException, ClassNotFoundException {
in.defaultReadObject();
startAnimation();
}
private void startAnimation() {
animator = new Thread(this);
animator.start(); 21/37
Szerializáció letiltása környezetek
2
Jakab Hunor
Amennyiben nem szeretnénk, hogy az osztályunk példányai
szerializálhatóak legyenek (bár az alaposztály implementálja Lokalizáció és
nemzetköziesítés
az interfészt, és mi nem „unimplementálhatjuk”): ResourceBundle
Java erőforrások
betöltése
Erőforrások
Maven-ben
private void writeObject(ObjectOutputStream out)
Szerializáció
throws IOException {
Java Reflection API
throw new NotSerializableException("Not today!");
}
throws IOException {
throw new NotSerializableException("Not today!");
}

22/37
Version controll környezetek
2
InvalidClassException Jakab Hunor
Lokalizáció és
(mindenik szerializálható osztályhoz egy egyedi azonosító nemzetköziesítés
rendelődik hozzá, ha ez nem talál, kivételt kapunk) ResourceBundle
Java erőforrások
betöltése
Probléma Erőforrások
Maven-ben
Ha például csak egy adattagot adtunk hozzá → szeretnénk, Szerializáció
hogy ne keletkezzen kivétel, az illető adattag legyen Java Reflection API
inicializálva az alapértelmezett értékkel és történhessen meg a

betöltés
Megoldás:
I az azonosító a serialVersionUID mezőben van tárolva →
ennek értékét beállíthatjuk manuálisan (a JDK biztosít
nekünk ehhez egy serialver nevű eszközt, ami az
azonosítót automatikusan generálja, alapértelmezetten az
objektum hash kódja alapján)
I Kompatibilis változtatások: pl. attribútum/metódus
törlése/hozzáadása
I Inkompatibilis változtatások: pl. hierarchia 23/37
Object caching környezetek
2
Jakab Hunor
Az ObjectOutputStream alapértelmezetten fent tart egy a
beléje írt objektumra mutató referenciát → ha kiírjuk az Lokalizáció és
nemzetköziesítés
objektumot, majd megváltoztatjuk és újra kiírjuk, az új állapot ResourceBundle
nem lesz lementve Java erőforrások
betöltése
Erőforrások
Maven-ben
Szerializáció
Listing 8: "Példa"
Java Reflection API
ObjectOutputStream out = new ObjectOutputStream(...);
MyObject obj = new MyObject(); // must be Serializable
obj.setState(100);
out.writeObject(obj); // saves object with state = 100
obj.setState(200);
out.writeObject(obj); // does not save new object state

Megoldások:
I Mindig zárjuk a streamet írás után
I Használjuk az ObjectOutputStream.reset() metódust
(vigyázat: a metódus az összes tárolt referenciát
felszabadítja, törli a cache-t)
24/37
Java Reflection API
Bevezetés környezetek
2
Mire használják? Jakab Hunor
Lokalizáció és
Java virtuális gép alatt futó alkalmazások viselkedésének nemzetköziesítés
módosítására vagy vizsgálatára (futási időben) használatos. ResourceBundle
Java erőforrások
betöltése
Néhány alkalmazási terület: Erőforrások
Maven-ben
I Osztály böngészők és vizuális fejlesztői környezetek:
Szerializáció
helyes kód írásának elősegítése Java Reflection API
I Debuggolási és tesztelési eszközök : privát mezők
vizsgálata, code coverage javítása
Hátrányok:
I Performance overhead
I Biztonsági megszorítások
I Az absztrakció elrontása (hozzáférés védett
komponensekhez)
26/37
Osztályok környezetek
2
Objektumok Jakab Hunor
Lokalizáció és
Két féle objektumot különböztetünk meg: nemzetköziesítés
I primitív típusú: boolean, byte, short, int, long, char, float ResourceBundle
Java erőforrások
I referencia típusú: java.lang.Object -ből van származtatva betöltése
Erőforrások
A virtuális gép minden objektumhoz létrehoz egy Maven-ben
módosíthatatlan java.lang.Class példányt → a reflection API Szerializáció
belépési pontja!. Java Reflection API
Leggyakoribb műveletek:
I Class objektumok lekérdezése
I Osztály módosítók és típusok vizsgálata
I Osztály mezők felfedezése
27/37
java.lang.Class környezetek
2
osztály példányból Jakab Hunor
Lokalizáció és
Object.getClass() - csak referencia típusok esetében működik nemzetköziesítés
ResourceBundle
Java erőforrások
betöltése
Erőforrások
Listing 11: "pl." Maven-ben
Szerializáció
* Class c = "valami".getClass();
* Class c = System.console().getClass(); Java Reflection API

típusból
típusnév.class - ezt használjuk a primitív típusok esetében is
Listing 12: "pl."
boolean b;
Class c = boolean.class;
Class c = java.io.PrintStream.class;

28/37
java.lang.Class környezetek
2
Fully-qualified name-ből Jakab Hunor
Lokalizáció és
A Class osztály Class.forName() statikus metódusát nemzetköziesítés
használva. Nem alkalmazható primitív típusokra. ResourceBundle
Java erőforrások
betöltése
Erőforrások
Maven-ben
Listing 15: "pl." Szerializáció
Java Reflection API

Class c = Class.forName("csomagnev.Sajatosztaly");

Burkoló osztályok esetén

A burkoló osztály .TYPE mezőjét használva

Class c = Double.TYPE;
Class c = Integer.TYPE;

29/37
Osztályok szerkezetének feltárása környezetek
2
Feltárható elemek Jakab Hunor
I mezők Lokalizáció és
nemzetköziesítés
I metódusok ResourceBundle
Java erőforrások
I konstruktorok betöltése
Erőforrások
Maven-ben
Két féle metódus áll rendelkezésre ezek feltárására: Szerializáció
I Kereső metódusok Java Reflection API
I Felsoroló metódusok
Mezők feltárása java.lang.reflect.Field
getDeclaredField(String name) A paraméter által
meghatározott attribútum
getField(String name) A paraméter által meghatározott
publikus attribútum
getDeclaredFields() Minden attribútum (a nem publikusak is)
getFields() A publikus attribútumok (öröklöttek is)
visszafordítása
30/37
java.lang.reflect.Field példa környezetek
2
Mezők feltárása java.lang.reflect.Field Jakab Hunor
Lokalizáció és
getDeclaredField(String name) A paraméter által nemzetköziesítés
meghatározott attribútum ResourceBundle
Java erőforrások
getField(String name) A paraméter által meghatározott betöltése
publikus attribútum Erőforrások
Maven-ben
getDeclaredFields() Minden attribútum (a nem publikusak is) Szerializáció
getFields() A publikus attribútumok (öröklöttek is) Java Reflection API
visszafordítása

import java.lang.reflect.Field;
...
StringBuilder fields = new StringBuilder();
Field[] fieldContainer = persistentClass.getDeclaredFields();
for ( int i=0;i<fieldContainer.length; i++){
if ( i> 0) {
fields.append(",");
}
fields.append(fieldContainer[i].getName());
}; 31/37
2
nemzetköziesítés
Java erőforrások
Erőforrások
Maven-ben
Metódusok feltárása java.lang.reflect.Method

getMethods() Publikus metódusok ( öröklöttek is)
getMethod( String name, Class[ argumentTypes)] A
paraméterek által meghatározott metódus
getDeclaredMethods() Minden metódus
getDeclaredMethod( String name, ... ) A paraméter által
meghatározott metódus
32/37
java.lang.reflect.Method Példa környezetek
2
Jakab Hunor
private Class<T> persistentClass; Lokalizáció és

... nemzetköziesítés
\\\metodusok listazasa ResourceBundle
StringBuilder methods = new StringBuilder(); Java erőforrások

betöltése
Method[] methodContainer = persistentClass.getDeclaredMethods();
for ( int i=0;i<methodContainer.length; i++){ Erőforrások
Maven-ben
if ( i> 0) {
Szerializáció
methods.append(",");
Java Reflection API
}
methods.append(methodContainer[i].getName());
};
System.out.println(methods.toString());
\\\getter setter metodusok egy mezohoz:
Field field = persistentClass.getField("mezo");
PropertyDescriptor propertyDescriptor =
new PropertyDescriptor(field.getName(), persistentClass);
Method method = propertyDescriptor.getWriteMethod();

method.invoke(instance, value));

33/37
2
nemzetköziesítés
Java erőforrások
Erőforrások
Maven-ben
Konstruktorok feltárása java.lang.reflect.Constructor

getConstructors() Publikus konstruktorok ( öröklöttek is)
getConstructor( Class[ argumentTypes)] A paraméterek által
meghatározott publikus konstruktor
getDeclaredConstructors() Minden konstruktor
getDeclaredConstructor( Class[ argumentTypes )] A
paraméterek által meghatározott konstruktor
34/37
java.lang.reflect.Constructor Példa környezetek
2
Jakab Hunor
try{ Lokalizáció és
Constructor c = Date.class.getConstructor( new Class[] { String.class } );
nemzetköziesítés
Object o = c.newInstance( new Object[] {‘‘Jan 1,2015"}); ResourceBundle
Date d = ( Date )o; Java erőforrások

betöltése
System.out.println( d );
} Erőforrások

Maven-ben
Szerializáció
Java Reflection API

public class GenericJdbcDao<T>{
public GenericJdbcDao(Class<T> persistentClass){
T instance = persistentClass.newInstance();
}
...
MyClass p2 = new MyClass();
GenericDao<MyClass> dao = new GenericJdbcDao(MyClass);

35/37
ososztaly mezoinek lekerdese: Tervezői és fejlesztői
környezetek
Class.getSuperClass().getDeclaredFields
2
Jakab Hunor
Lokalizáció és
nemzetköziesítés
ResourceBundle
Java erőforrások
betöltése
Erőforrások
Maven-ben
Szerializáció
Java Reflection API
36/37
Ősosztály és mezőire való hivatkozás környezetek
2
I Class.getSuperClass() ősosztály lekérdezése Jakab Hunor
I Class.getSuperClass().getDeclaredFields ősosztály mezői Lokalizáció és

nemzetköziesítés
ResourceBundle
Java erőforrások
betöltése
Erőforrások
Maven-ben
Szerializáció
Java Reflection API
36/37
környezetek
Jakab Hunor
Annotációk
Perzisztencia
ORM
Tervezői és fejlesztői környezetek JPA
Jakab Hunor
1/36
Programszöveg elemeihez rendelhető környezetek
metainformációk Java nyelvben 3

Jakab Hunor
I Alapvető Java komment infrastruktúra Annotációk
Perzisztencia
public void mouseClicked(MouseEvent arg0) { ORM

// Calling method inherited from superclass JPA
super.mouseClicked(arg0);
}

I Blokk és egysoros kommentek ( magáról a kódról
szolgáltatnak információt, megkönnyítve a kód megértését
más programozók számára)
I TODO és FIXME kommentek IDE-ben
I Teendők megjelölése task management rendszerek részére
Listing 1: "Eclipse TODO comment"
//TODO implement this method more efficiently

2/36
Programszöveg elemeihez rendelhető környezetek
metainformációk Java nyelvben 3

Jakab Hunor
I Javadoc kommentek Annotációk
Perzisztencia
I Strukturált kommentek ( osztályokról, ezek metódusairól és
ORM
attribútumairól szolgáltatnak struktúrált információt )
JPA
I Jól meghatározott szintaxissal rendelkeznek
I Különböző módon feldolgozhatóak ( parserek )

/**
* A mock class that extends the
* javax.swing.Jframe class
* @author jakabh */
public class MockFrame extends JFrame { }

A hordozott információ csupán fordítási időben áll

rendelkezésünkre!!!
3/36
Java Annotációk - java.lang.annotation.* környezetek
3
Magyarázó jegyzet (Annotation) Jakab Hunor
Annotációk
A programszöveg elemeihez rendelhető metainformáció mely Perzisztencia
átvihető futási időbe. ORM
JPA
Tulajdonságok:
I Módosítószavak bővítése
I Nem befolyásolják direkt módon a program szemantikáját
I Csomagokhoz, típusokhoz, metódusokhoz,
attribútumokhoz, konstruktorokhoz, lokális változókhoz
rendelhetők
I Plusz információt hordoznak mely felhasználható a Java
fordító a JVM és más speciális eszközök által
I Konvenció alapján a magyarázó jegyzetek az egyéb
módosítószavak előtt szerepelnek
4/36
Hol találkoztunk annotációkkal az eddigiek környezetek
során ? 3
Jakab Hunor
I. gyakori példa: metódus túlterhelés @override

Annotációk
Perzisztencia
public class Example extends MouseAdapter {
ORM
@Override
JPA
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub
super.mouseClicked(e);
}}

II. gyakori példa: @deprecated

public void elavultmetodus(){
...
}

@Deprecated
public void <@\st{elavultmetodus}@>(){
...
}

5/36
Annotációk definíciója és használata környezetek
3
Bejelentés Jakab Hunor
Annotációk
Interfacekhez hasonlóan történik @-előtaggal @interface Perzisztencia
ORM
/** JPA
* Describes the Request-For-Enhancement(RFE)

* that led to the presence of the annotated
* API element. */
public @interface RequestForEnhancement {
int id();
String synopsis();
String engineer() default "[unassigned]";
String date(); default "[unimplemented]";
}

Részei
I megnevezés: RequestForEnhancement
I elemek pl. String synopsis
6/36
Annotációk definíciója és használata környezetek
Megszorítások:
3
Jakab Hunor
I nem lehet típusparaméterezni Annotációk
I az annotáció metódusainak nem lehetnek paraméterei Perzisztencia
nem dobhatnak kivételt ORM
JPA
I metódusok típusai: primitív, String, Class, enum, array
Példa használatra:

@RequestForEnhancement(
id = 2868724,
synopsis = "Enable time-travel",
engineer = "Mr. Peabody",
date = "4/1/3007"
)
public static void travelThroughTime() { ... }

7/36
Annotáció típusok környezetek
3
marker annotáció: Jakab Hunor
Annotációk
Elemek nélküli annotáció. Pl:
Perzisztencia
public @interface markerAnnotation {} ORM

JPA
Használatakor elhagyhatjuk az íves zárójeleket:

@markerAnnotation public class ExampleClass { }

Konvenció
Egyetlen elemmel rendelkező annotációk esetén az elem neve
value:

public @interface OneElementAnnotation {
String value(); }
@OneElementAnnotation("A random string")
public class ExampleClass { ... }

8/36
Beépített annotációk környezetek
Egyszerű annotációk: Meta annotációk 3

Jakab Hunor
I @Override I @Target
Annotációk
I @Deprecated I @Retention Perzisztencia
I @SupressWarnings I @Documented ORM
JPA
I @SafeVarargs I @Inherited
I @FunctionalInterface I @Repeatable
Meta annotációk
I Annotációkhoz rendelt metainformációt hordoznak.
I Megadhatjuk segítségükkel:
I egy annotáció céltípusát,
I az általa hordozott információ létezési idejét
I hogy bekerüljön-e a dokumentációba
I illetve öröklődést
9/36
Meta annotációk: Példa környezetek
Pl:
3
Jakab Hunor
import java.lang.annotation.Documented; Annotációk

import java.lang.annotation.ElementType; Perzisztencia
import java.lang.annotation.Inherited;
ORM
import java.lang.annotation.RetentionPolicy;
JPA
import java.lang.annotation.Target;
import java.lang.annotation.Retention;
@Target(ElementType.METHOD)
@Retention( RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnnotation {
String value() default " ";
}

10/36
@Target{ElementType} környezetek
3
Theorem Jakab Hunor
Szabályozza, hogy egy annotáció milyen típusú elemekre Annotációk
alkalmazható Perzisztencia
ORM
JPA
11/36
@Retention{RetentionPolicy} környezetek
3
Theorem Jakab Hunor
Szabályozza, hogy az annotáció által hordozott információ Annotációk
Perzisztencia
mikor és ki által legyen elérhető. Pl. futási időben reflection
ORM
API-n keresztül. JPA
12/36
Annotációk használata futási időben. Példa! környezetek
3
I Szeretnénk annotációk segítségével megjelölni egy Jakab Hunor
osztály bizonyos metódusait tesztlésre Annotációk
I Egy tesztelő rutin futási időben megkeresi a megjelölt Perzisztencia
metódusokat az annotációk és reflection API segítségével ORM
JPA
és végrehajtja a teszteket
I Szükségünk lesz:
I egy új @Test annotációra megfelelő tulajdonságokkal
I egy tesztelő rutinra: RunTests.main
I a tesztelendő metódusokat definiáló osztályra: FOO
A példa a hivatalos Java Annotations cikk alapján készült.
13/36
@Test környezetek
3
package idde.jakabh.Annotations; Jakab Hunor
Annotációk
import java.lang.annotation.*;
Perzisztencia
/**
ORM
* @author jakabh
*/ JPA
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Test {
}

@Test
Minden olyan metódust amelyet szeretnénk tesztelni
megjelölünk a @Test annotációval
14/36
A tesztelő osztály környezetek
3
import idde.jakabh.Annotations.Test; Jakab Hunor
import java.lang.reflect.*;
Annotációk
public class RunTests {
public static void main(String[] args) throws Exception { Perzisztencia
/** ORM
* Execute all the methods that are marked "@Test" JPA
* @see Test
*/
int passed = 0, failed = 0;
for (Method m : Class.forName(args[0]).getMethods()) {
if (m.isAnnotationPresent(Test.class)) {
try {
m.invoke(null);
passed++;
} catch (Throwable ex) {
System.out.printf("Test %s failed: ...
%s %n", m, ex.getCause());
failed++;
}
}
}
System.out.printf("Passed: %d, Failed %d%n", passed, failed);
}
}

15/36
A tesztelendő osztály környezetek
3
import idde.jakabh.Annotations.Test; Jakab Hunor
public class TestClass1 {

Annotációk
@Test
Perzisztencia
public static void m1() {
ORM
System.out.println("Testing method m1");
} JPA

}
@Test
throw new RuntimeException("Boom");
}
}
@Test
}
}

16/36
Perzisztencia: Java
Persistence API
Perzisztencia Java környezetben környezetek
3
Perzisztencia Jakab Hunor
I Olyan adatok jelenlétére utal, amelyek az őket létrehozó Annotációk
Perzisztencia
folyamat befejezte után is léteznek.
ORM
I Az angol "to persist" (továbbra is fennáll, létezik) JPA
kiefejezésből ered.
I Bármilyen típusú információ "perzisztens" tárolása
lehetséges a java programozási nyelv segítségével.
Példák perzisztencia megvalósítására:

I JDBC
I szerializáció Lásd az előző előadást
I file input output
I XML, XML adatbázisok
I stb.
Megjegyzés
A perzisztencia megvalósításának leggyakoribb módja a
relációs adatbázisok alkalmazása
18/36
JAXB környezetek
3
Java Architecture for XML Binding Jakab Hunor
Annotációk
I Marshalling - java objektum XML állományba történő Perzisztencia
átalakítása ORM
I Unmarshalling - XML állomány tartalmának java JPA
objektummá történő átalakítása.
19/36
OOP vs. RDB környezetek
3
Object relational impedance mismatch Jakab Hunor
Annotációk
Technikai nehézségek, melyek abban az esetben lépnek fel
Perzisztencia
amikor egy relációs adatbáziskezelő rendszert használunk egy
ORM
objektum-orientált programozási nyelvből. JPA
Forrásai:
I Kettős séma (dual-schema problem)
I Adatrejtés (encapsulation)
I Öröklődés (inheritance)
I Adattípusok (pl. referencia típusok, karakterláncok stb. )
I Tranzakciók (Unit of work, méretbeli különbségek)
I stb.
Megoldási lehetőségek
I Object relational mapping
I Object oriented database management systems
(OODBMS)
20/36
ORM környezetek
Motiváció ORM használatára:

3
Jakab Hunor
I Kiküszöböli az SQL ResultSet-ekben található adatok Annotációk
Java objektumokká történő kézi átalakítását. Jelentősen Perzisztencia
csökkenti a befektetett munka mennyiségét ORM
I A legtöbb ORM keretrendszer ingyenes és nyílt forráskódú JPA
I Adatbázis és adatbázis séma függetlenséget tesz lehetővé

I Segítségével elkerülhetjük az alacsonyszintű JDBC, SQL
kód írását
21/36
ORM architecture környezetek
3
Jakab Hunor
Annotációk
Perzisztencia
ORM
JPA
Figure: forrás: http://tutorialspoint.com
Három fázisú folyamatot definiál: Object data → Mapping →

Relational data
22/36
Java Persistence API (JPA) környezetek
3
Annotációk
Egy specifikáció amely egy standardot definiál adatok Perzisztencia
átvitelére, perzisztenciájára és menedzsmentjére java ORM
objektumok/osztályok és relációs adatbázisok között. JPA
Állapot
I Az EJB 3.0 specifikáció részeként jött létre, jelenlegi
verzió: JPA 2.1 (2013 április).
I Ezt tekintik a standard iparban használt ORM
megközelítésnek Java környezetben.
I Referencia implementáció: EclipseLink
23/36
Motiváció környezetek
3
Motiváció JPA használatára. Jakab Hunor
Annotációk
I Standardizált, az EJB3 valamint Java EE része
Perzisztencia
I Számos ingyenes, nyílt forráskódú implementációja van ORM
I Hordozhatóság JPA
I Objektum szintű lekérdezőnyelv JPQL( Java persistence

query language).
I Használható Java EE és SE-ben is.
JPA 2.1-et implementáló ingyenes ORM keretrendszerek:

I EclipseLink (Eclipse): Link
I Hibernate (RedHat): http://hibernate.org/
I Open JPA (Apache): https://openjpa.apache.org/
I TopLink (Oracle): Link
24/36
Architecture környezetek
3
Jakab Hunor
Annotációk
Perzisztencia
ORM
JPA
Figure: forrás: http://www.tutorialspoint.com
I EntityManagerFactory EntityManager példányokat hoz

létre
I Entitymanager A perzisztencia műveletek kezeléséért
felelős
25/36
3
Jakab Hunor
Annotációk
Perzisztencia
ORM
JPA
I Entity Az adatmodell
I EntityTransaction műveleteket ezen keresztül
végezhetünk
26/36
3
Jakab Hunor
Annotációk
Perzisztencia
ORM
JPA
I Persistence Statikus segédmetódusok

EntitymanagerFactory megszerzésére
I Query lekérdezéseknek megfelelő interface
27/36
Adatmodell környezetek
3
Entity osztályok Jakab Hunor
Annotációk
I Speciális annotációkkal ellátott POJO-k Perzisztencia
I Egy Entity osztály egy táblát reprezentál az adatbázisból ORM
JPA
I Egy példánya megfelel az adott tábla egy sorának!
I Sajátos életciklussal rendelkezik amelyet az
EntityManager befolyásol
További összetevők
I Persistence context (Entity manager határozza meg)
I Container managed
I Application managed
I Persistence unit ( különböző Entity-k összessége, a
persistence.xml-ben van definiálva)
28/36
@Entity, @Table környezetek
Egy entity osztálynak a következő tulajdonságokat kell

3
Jakab Hunor
teljesítenie:
Annotációk
Entity Class Perzisztencia
ORM
I Annotálva legyen: @Entity JPA
I Rendelkezzen egy publikus vagy protected

alapértelmezett konstruktorral (lehetnek ezen kívûl más
konstruktorai is)
I Nem lehet final
I Perzisztens mezőket private, protected vagy
package-private-nek kell deklarálnunk
I Rendlkezzen a megfelelő getter és setter metódusokkal
29/36
Entity osztályok környezetek
3
Példa Jakab Hunor
Annotációk
Perzisztencia
@Entity ORM
public class Party implements Serializable { JPA
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
private int id;
private String helyszin;
...
//bi-directional many-to-one association to Felhasznalok
@OneToMany(mappedBy="party")
private List<Felhasznalok> felhasznaloks;
public Party() { }
...
//getter and setter methods
}

I
30/36
JPA annotációk környezetek
3
javax.persistence.* Jakab Hunor
Annotációk
Perzisztencia
Legfontosabb elemei: ORM
I @Entity egy perzisztens osztály megjelölése JPA
I @Table a megfelelő adatbázis tábla kiválasztása

I @Column a megfeleltetett oszlop neve a táblából
I @Id a perzisztens objektum egyedi azonosítója
31/36
@Entity, @Table környezetek
3
Jakab Hunor
annotated class
Annotációk
@Entity
Perzisztencia
@Table( name = "EVENTS" )
public class Event { ORM
... JPA
}

Tulajdonságok:
I A @Table megadása nélkül az alapértelmezett táblanév
EVENT lenne ( convention over configuration ).
I
32/36
@Id környezetek
3
Jakab Hunor
annotated class
Annotációk
@Id
Perzisztencia
@GeneratedValue(generator="increment")
@GenericGenerator(name="increment", strategy = "increment") ORM
public Long getId() { JPA
return id;
}

hbm.xml

<id name="id" column="EVENT_ID">
<generator class="increment"/>
</id>

A @GeneratedValue es a @GenericGenerator határozzák
meg a kulcs generálási stratégiáját
33/36
@Column - egyszerû mezők mappelése környezetek
3
Jakab Hunor
annotated class
Annotációk
public String getTitle() {
Perzisztencia
return title;
} ORM
JPA
@Temporal(TemporalType.TIMESTAMP)
@Column(name = "EVENT_DATE")
public Date getDate() {
return date;
}

hbm.xml

<property name="date" type="timestamp" column="EVENT_DATE"/>
<property name="title"/>

A megfeleltetés megadása nem kötelező csupán akkor ha a
név egy fenntartott kulcsszó, vagy a property neve nem
egyezik meg az oszlop nevével
34/36
Entity állapotok környezetek
3
Jakab Hunor
Annotációk
Perzisztencia
ORM
JPA
Pl:

Car newcar = new Car();
try {
entityManager.getTransaction().begin();
entityManager.persist(newcar);
entityManager.getTransaction().commit();
} catch (Exception e) {
entityManager.getTransaction().rollback();
}

35/36
Java persistence API környezetek
4
JPA gyakorlatban Jakab Hunor
JPA
Legfőbb tulajdonságok:
I persistence.xml - persistence Unit
I EntityManager - persistence context
I transaction - atomi műveletek csoportosítása
A JPA 2.1 specifikáció alapján a persistence.xml

konfigurációs állomány a classpath-ban a
META-INF/persistence.xml elérési út alatt kell létezzen.
2/12
Persistence.xml környezetek
4
<?xml version="1.0" encoding="UTF-8"?> Jakab Hunor
<persistence version="2.0" xmlns="http://java.sun..."

JPA
xmlns:xsi="http://www.w3.org/2001/XMLSchema-..."
xsi:schemaLocation="http://java.sun.com/xml/ns/...">
<persistence-unit name="idde.eclipseLinkJpa">
<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
<class>idde.jakabh.eclipseLinkJpa.Car</class>
<class>idde.jakabh.eclipseLinkJpa.Drotkoszoru</class>
<class>idde.jakabh.eclipseLinkJpa.Party</class>
<class>idde.jakabh.eclipseLinkJpa.Vizsga</class>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://pdae.cs.ubbcluj.ro:3306/idde"/>
<property name="javax.persistence.jdbc.driver"
value="com.mysql.cj.jdbc.Driver"/>
<property name="javax.persistence.jdbc.user"
value="idde"/>
<property name="javax.persistence.jdbc.password"
value="idde"/>
</properties>
</persistence-unit>
</persistence>

3/12
javax.Persistence.EntityManagerFactory környezetek
4
EntityManagerFactory Jakab Hunor
JPA
Az EntityManagerFactory példányosítására és a példány
visszatérítésére egy segédosztályt hozunk létre az alábbiak
alapján:

public class JpaUtil {
private static EntityManagerFactory entityManagerFctory;
static {
try {
// Create from (persistence.xml)
entityManagerFctory =
Persistence.createEntityManagerFactory("idde.eclipseLinkJpa");
} catch (Throwable ex) {
// Log the exception.
}
}
public static EntityManagerFactory getEntityManagerFactory() {
return entityManagerFctory;
}

4/12
Különbségek EclipseLink és Hibernate környezetek
esetén 4
Jakab Hunor
JPA
PersistenceProvider a persistence.xml-ben
I EclipseLink:
org.eclipse.persistence.jpa.PersistenceProvider
I Hibernate: org.hibernate.ejb.HibernatePersistence
Elengedhetetlen beállítások:

value="jdbc:mysql://localhost:3306/idde"/>
<property name="javax.persistence.jdbc.user"
value="newidde"/>
<property name="javax.persistence.jdbc.password"
value="newidde"/>
value="com.mysql.jdbc.Driver"/>

Mindekét implementáció rendelkezik sajátos beállításokkal is!
5/12
Példák:
JPA példák elemi műveletekre környezetek
4
transaction, exceptions Jakab Hunor
JPA
I Új tranzakció elkezdése a Entitymanager segítségével
I Try-catch blokk, kivétel esetén rollback
I Session bezárása a finally ágban

Entitymanager em = JpaUtil.getEntityManagerFactory().createEntityManager();
EntityTransaction tx = em.getTransaction();
try {
tx = em.begin();
//muveletek
tx.commit();
} catch (Exception e) {
if (tx != null) {
tx.rollback();
}
} finally {
em.close(); //Attention!
}

7/12
Mentés: EntityManager.persist környezetek
4
Entity osztályok: Jakab Hunor
JPA
I Predator
I Prey

em.getTransaction().begin();
Predator farkas = new Predator();
farkas.setName("Farkas");
farkas.setPopulation(125);
farkas.setLivesInEurope(true);
Prey malac = new Prey();
malac.setName("malac");
malac.setPrey_average_weight(112.5);
em.persist(csirke);
em.persist(farkas);
em.getTransaction().commit();

Figyeljünk az entity példányok állapot változásaira: New →
Managed
8/12
További metódusok: környezetek
4
Entity manager fontos metódusai: Jakab Hunor
JPA
I void remove(java.lang.Object entity) törli a
paraméterként megadott bejegyzést
I <T> T find(java.lang.Class<T> entityClass,
java.lang.Object primaryKey) visszatéríti a
bejegyzést elsődleges kulcs alapján

em.getTransaction().begin();
Prey thePray = em.find(Prey.class,prayName);
if ( thePray != null ){
em.remove(thePray);
}
em.getTransaction().commit();

9/12
Tetszőleges lekérdezések: környezetek
4
SELECT Jakab Hunor
JPA
JPQL:
I SELECT p FROM Person as p
I SELECT p.firstName FROM Person as p where
p.lastName = “karcsi”
Az EntityManager.createQuery metódussal hozható létre

List<Prey> prayanimals = em.createQuery("select p from Prey p").getResultList
for ( Prey pr : prayanimals){
System.out.println(pr.getName());
}

10/12
Kapcsolatok: környezetek
4
One-to-One Jakab Hunor
JPA
Inner Join
I @OneToOne(optional=false)
I @JoinColumn(name = "PREY_ID")
Outer Join Az EntityManager.createQuery metódussal
hozható létre

List<Prey> prayanimals =
em.createQuery("select p from Prey p").getResultList();
for ( Prey pr : prayanimals){
System.out.println(pr.getName());
}

11/12
környezetek
Jakab Hunor
Tervezői és fejlesztői környezetek
Jakab Hunor
1/52
Tartalom: környezetek
Modularitás, moduláris fejlesztés Java platformon

5
Jakab Hunor
I Alapfogalmak:
I Modularitás fontossága
I SOA( Service oriented architecture)
I OSGI bevezetés
I OSGI bundle életciklus
I Szolgáltatások
2/52
Dinamikus moduláris fejlesztés, OSGI környezetek
5
Jakab Hunor
Meghatározás
OSGI (Open Services
Gateway Initiative)-
dinamikus, moduláris
rendszer a Java számára
I OSGI alliance ( 1999-ben alapította az Ericsson, IBM,

Oracle és a Sun )által specifikált java alpú keretrendszer
I egy Java Runtime környezet fölött fut
I komponens-szolgáltatás modellt definiál
I több különbözõ implementációja létezik:
Knopflerfish (Makewave) , Equinox (Eclipse),
Felix (Apache)
I Legfrissebb verzió: OSGI Release 6 ( 2014 júniusában)
3/52
OSGI specifikáció! környezetek
A specifikáció a következõ tulajdonságokkal rendelkezõ

5
Jakab Hunor
fejlesztési modell részleteit írja le:
I alkalmazások több különbözõ újrahasznosítható
komponensbõl tevõdnek össze
I a komponensek elrejtik egymás elõl a saját
implementációjukat (szolgáltatásokon keresztül történõ
kommunikáció)
I a szolgáltatások komponensek között explicit megosztott
objektumokat jelentenek
I csökkentett komplexitás a fejlesztési folyamat bármely
fázisában (kódolás, tesztelés, bug keresés, build ,
újrahasznosítás)
Megjegyzés
Működőképességét és létjogosultságát bizonyítja széleskörû
elterjedtsége és olyan népszerû alkalmazások esetében
történõ használata mint amilyen az Eclipse, Spring,
IBMWebsphere , Oracle/BEA Weblogic, Jonas, JBoss
4/52
OSGI rétegelt architektúrája környezetek
5
Jakab Hunor
Meghatározás
Bundle(Batyu): programozó által elkészített OSGI komponens
5/52
5
Jakab Hunor
Meghatározás
Services(Szolgáltatás réteg): dinamikusan összeköti a
batyukat
5/52
5
Jakab Hunor
Meghatározás
LifeCycle(Életciklus): Az API amelyen keresztül batyukat
tudunk telepíteni, elindítani, megállítani, frissíteni
5/52
5
Jakab Hunor
Meghatározás
Modules : Ez a réteg határozza meg azt, hogy egy batyu
hogyan tud kódot importálni vagy exportálni
5/52
5
Jakab Hunor
Meghatározás
Security(Biztonsági réteg): Biztonsági feladatokat lát el, a java
2 security architecture kiterjesztése
5/52
5
Jakab Hunor
Meghatározás
Execution Environment (végrehajtási környezet):
Meghatározza, hogy milyen metódusok és osztályok állnak
rendelkezésre egy konkrét platformon belül.
5/52
Rétegelt architektúra környezetek
5
Jakab Hunor
A rétegek közötti interakció a következőképpen ábrázolható
6/52
OSGI Container környezetek
5
Tartalmaz egy OSGI implementációt pl (Felix, equinox) és

különbözõ eszközöket pl.( konzol, ssh kliens, deploy
mechanizmus stb.)
Apache Karaf
(pehelysúlyú/lightweight)
Glassfish application server

(nehézsúlyú/heavyweight)
7/52
Elõnyök környezetek
Fejlesztõi szemszögbõl a keretrendszer a következõ elõnyöket

5
Jakab Hunor
biztosítja:
I dinamikusan lehet telepíteni, törölni, indítani, leaállítani
különbözõ modulokat, anélkül, hogy a konténert le kellene
állítani
I az alkalmazásban egy modulnak egyszerre több verziója
is futhat
I kiváló infrastruktúrát kínál a szolgÁltatás-orientált
alkalmazások létrehozására.
Example (1)
Pl: Home Server ( háztartási elektronikai eszközök
menedzselése )
8/52
Elõnyök környezetek
5
Example (2) Jakab Hunor
Összetett web applikáció fejlesztése:

I Az alkalmazást több modulra szeretnénk feloasztani :
ViewLayer, Service Layer, DAO Layer, Data Access Layer
stb.
I OSGI konténer alkalmazásával könnyen és hatékonyan
tudjuk menedzselni az egyes modulokat.
I Egy lassú DAO layert frissíthetünk egy gyorsabb változatra
anélkül, hogy az alkalmazást leállítanánk.
9/52
OSGI batyu (Bundle) környezetek
5
Jakab Hunor
Batyu (Programegység): a modularitás alapegysége OSGI
frameworkon belül.
I Csomagolási formátum (JAR) és végrehajtási egység

sajátös ötvözése ( JAR + sajátos meta információk )
I Konkrétan definiálja más moduloktól és szolgáltatásoktól
való függõségeit
I JAR: java osztályok, java osztályokból elért statikus
erõforrások, natív kóddarabok
I Manifest.MF leíró állomány (JAR-on belül) +
batyu-specifikus meta-információk
10/52
OSGI batyu: szimbolikus név és verziózás környezetek
Minden batyu rendelkezik:

5
Jakab Hunor
I egy szimbólikus névvel: Bundle-SymbolicName
I egy verziószámmal: Bundle-Version
Ezek az információk a (MANIFEST.MF)-ben vannak

meghatározva. Egyértelmûen azonosítanak egy batyu-t az
OSGI konténeren belül

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Popup Plug-in
Bundle-SymbolicName: com.example.myosgi;
Bundle-Version: 1.0.0
Bundle-Activator: com.example.myosgi.Activator
Require-Bundle: org.eclipse.ui,
org.eclipse.core.runtime
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6

11/52
OSGI batyu: szimbolikus név és verziózás környezetek
Minden batyu rendelkezik:

5
Jakab Hunor
I egy szimbólikus névvel: Bundle-SymbolicName
I egy verziószámmal: Bundle-Version

Bundle-Name: Popup Plug-in
Bundle-SymbolicName: com.example.myosgi;
Bundle-Version: 1.0.0
Bundle-Activator: com.example.myosgi.Activator
Require-Bundle: org.eclipse.ui,
org.eclipse.core.runtime

11/52
OSGI MANIFEST azonosítók: környezetek
5
Jakab Hunor
12/52
OSGI MANIFEST: További tulajdonságok környezetek
5
Jakab Hunor
I Bundle-Name: "Human Readable" batyu név

I Bundle-Description: a batyu funkcionalitásainak
szövegszerû leírása
I Bundle-Activator: a batyu aktivátor osztálya (
metódusok: késõbb )
I Export-Package: a batyuban található csomagok közül
melyek legyenek elérhetõek mások által
I Import-Package: milyen java csomagokra van szükség a
batyu függõségeinek kielégítéséhez
13/52
OSGI batyu: életciklus környezetek
5
Jakab Hunor
A batyuk életciklusát normális esetben a Modules réteg

menedzseli. Viszont az OSGI rendelkezéünkre bocsát egy
API-t lifecycle réteg amelyen keresztül futási idõben
módosíthatjuk egy batyu állapotát:
I Installed
I Resolved
I Uninstalled
I Starting
I Active
I Stopping
14/52
OSGI batyu: állapotok környezetek
5
Jakab Hunor
I Installed: a batyut sikeresen telepítette az OSGi

keretrendszer
I Resolved: a batyu export-import függõségei
kielégíthetõnek minõsültek
I Uninstalled: a batyut eltávolították a keretrendszerbõl,
többé nem használható
I Starting: a batyut elindították, de a start() metódusa még
nem tért vissza
I Active: a start() metódus visszatért, a batyu fut a
keretrendszerben
I Stopping: meghívódott a batyu stop() metódusa, de még
nem tért vissza
15/52
OSGI batyu környezetek
5
Jakab Hunor
I A batyu életciklusai eseményeket generálnak

I Eseményekre feliratkozhatnak más batyuk és figyelhetik
ezekt
I A batyuhoz jogok köthetõk
I A batyu szolgáltatásokat regisztrálhat (gazdagabb
kommunikációs mód az egyszerû metódushívásoknál )
16/52
BundleActivator interface környezetek
5
Jakab Hunor
Egy batyu rendelkezhet egy Aktivátor osztállyal (amely

implementlja a BundleActivator interface-t) . Manifest.MF:
Bundle-Activator

import org.osgi.framework.BundleActivator;
import org.osgi.framework.BundleContext;
public class Activator implements BundleActivator {
public void start(BundleContext context) throws Exception {
System.out.println("Hello World!!");
}
public void stop(BundleContext context) throws Exception {
System.out.println("Goodbye World!!");
}}

17/52
BundleContext objektum környezetek
5
Jakab Hunor
Egy proxy a batyu és az OSGi keretrendszer között.
A batyu indításakor a keretrendszer létrehoz egy

BundleContext objektumot és ezt átadja a batyunak.
Mûveletek:
I új batyuk telepítése
I telepített batyuk lekérése a keretrendszertõl
I tároló hely lekérése
I regisztrált batyuk service objektumainak lekérése
I service regisztrálása a keretrendszerben
I feliratkozás a keretrendszer által létrehozott eseményekre
18/52
export-import mechanizmus környezetek
5
Jakab Hunor
Lehetõséget ad a batyuban levõ csomagok kiajánlására és a

függõségek kielégítéséhez szükséges külsõ csomagok
importálására. Védelmi funkciót tölt be ( csak az exportált
csomagok és osztályok érhetõek el más batyuk által )
MANIFEST.MF
Export-Package: com.myosgiapp.mypackage;version="1.0.0"
Improt-Package: com.myosgiapp.mypackage;version="
[1.0.0,2.0.0)"

Intervallumok megadásával korlátozhatjuk, hogy milyen

verziószámú batyukat tartson megfelelõnek a rendszer
19/52
szolgáltatások környezetek
5
A keretrendszerben található batyuk (programegységek)

közötti kommunikáció alapegységei
I A batyuk létrehozhatnak objektumokat és regisztrálhatják

ezeket a szolgáltatás katalógusban
I Más batyuk listázhatják a szolgáltatás katalógusban
található szolgáltatásokat és használhatják ezeket.
I A regisztrált objektum egy szolgáltatás interface-t kell
implementáljon
I Az interface lényege, hogy a neki megfelelõ szolgáltatás
objektumokat bármikor ki lehet cserélni
Konvenció szerint a szolgáltatás interfaceket mindíg külön

batyukban adjuk meg és telepítjük! A szolgláltatás interface
batyu kötelezõen kell exportálja az interface-t tartalmazó
csomagot!!
20/52
OSGI szolgáltatás példa: környezetek
5
Jakab Hunor

public interface ServiceInterface {
public String message();
public void setMessage( String message);
}

public class ServiceObject implements ServiceInterface {
public String message() {
//code
}
public void setMessage(String message) {
//code
}
}

21/52
OSGI szolgáltatások környezetek
5
Jakab Hunor
Egy batyu regisztrálhat, igénybe vehet szolgáltatásokat,

listázhatja ezeket és várhat bizonyos szolgáltatások
megjelenésére vagy eltünésére
I több különbözõ batyu regisztrálhatja ugyanazt a

szolgáltatást
I több batyu használhatja egyszerre ugyanazt a
szolgáltatást
22/52
szolgáltatások regisztrálása környezetek
5
Jakab Hunor
A BundleContext objektumon keresztül történik

void start ( BundleContext bc ) {
//code
serviceObject = new ServiceObject();
serviceDictionary = (Dictionary) new Hashtable();
myServiceRegistration = bc. registerService(
ServiceInterface.class.getName(), (Object)serviceObject
, serviceDictionary );
//code
}
void stop ( BundleContext bc ) {
myServiceRegistration.unregister();
}

23/52
szolgáltatások lekérdezése környezetek
5
Jakab Hunor
A BundleContext objektumon keresztül történik

void queryAndUseService( BundleContext bc ){
ServiceReference sr = bc.getServiceReference(
ServiceInterface.class.getName() );
ServiceInterface serviceObject = (ServiceInterface)bc.
getService( sr );
String s = so.message();
}

Két lépésbõl áll:
I szolgáltatás referencia lekérdezése getServiceReference
I szolgáltatás objektum lekérdezése a referencia
segítségével getService
24/52
szolgáltatás követõ (Service Tracker) környezetek
5
Jakab Hunor
A keretrendszerben a szolgáltatások állandóan jönnek,

mennek. ! Hibalehetõségek amennyiben egy szolgáltatás nem
elérhetõ és mégis használni szeretnénk! Megoldás:
ServiceTracker használata az org.osgi.util.tracker csomagból
Lépések:
I ServiceTrackerCustomizer interface-t implementáló
osztály létrehozása a megfelelõ metódusok felülírásával:
I addingService
I modifiedService
I removedService
25/52
5
Jakab Hunor

public class MyServiceTrackerCustomizer implements
ServiceTrackerCustomizer {
private final BundleContext context;
public Object addingService(ServiceReference reference) {
return service;
}
public void modifiedService(ServiceReference reference,
Object service) {
// TODO Auto-generated method stub }
public void removedService(ServiceReference reference,
Object service) {
context.ungetService(reference);}

26/52
5
Jakab Hunor
A keretrendszerben a szolgáltatások állandóan jönnek,

mennek. ! Hibalehetõségek amennyiben egy szolgáltatás nem
elérhetõ és mégis használni szeretnénk! Megoldás:
ServiceTracker használata az org.osgi.util.tracker csomagból
Lépések:
I ServiceTracker létrehozása (a ServiceTrackerCustomizer
segítségével ) az Activator osztályban és menyitása!

MyQuoteServiceTrackerCustomizer customer = new
MyQuoteServiceTrackerCustomizer(
context);
serviceTracker = new ServiceTracker(context, IQuoteService.
class
.getName(), customer);
serviceTracker.open();

27/52
fejlesztés az OSGI keretrendszerben környezetek
5
Jakab Hunor
Lépések
I felépítjük a programegységeket (batyukat ) az OSGI API
segítségével
I összerakosgatjuk/elhelyezzük ezeket egy OSGI
konténerben
Szükséges eszközök:
I egy OSGI implementáció (equinox, felix stb. )
I fejlesztõi környezet
I build rendszer (Maven v. Eclipse PDE )
I külsõ OSGI konténer ( Apache Karaf )
28/52
5
Jakab Hunor
Példaprogramok
I https://pdae.cs.ubbcluj.ro/git/jakabh/IDDEE XAMPLES
I IDDE/OSGI
I karaf osgi container
I Maven bundle plugin vagy Gradle osgi plugin
I build rendszer (Maven v. Gradle )
29/52
Modularitás, moduláris fejlesztés, OSGI

6
Jakab Hunor
I Gyakorlati megfontolások
I Fejlesztés Eclipse-ben
I Maven támogatás
I OPS4J
I Deklaratív szolgáltatások
I OBR, remote deployment
30/52
6
Jakab Hunor
Lépések
I felépítjük a programegységeket (batyukat ) az OSGI API
segítségével
I összerakosgatjuk/elhelyezzük ezeket egy OSGI
konténerben
I egy OSGI implementáció (equinox, felix stb. )
I fejlesztõi környezet
I build rendszer (Maven v. Eclipse PDE )
I OSGI container ( Apache Karaf )
31/52
Dinamikus moduláris fejlesztés, OSGI környezetek
6
Jakab Hunor
Környezet
OSGI moduláris
alkalmazások
futtatásához a
következőkre van
szükségünk:
I OSGI container
I elkészített batyuk
I kiegészítő batyuk
I dinamikus telepítés
32/52
OSGI runtime környezetek
6
Futási környezet Jakab Hunor
Az OSGI konténerbe telepített batyuk által közzétett

szolgáltatások, csomagok, és alap funkcionalitások
összessége.
A fejlesztés főbb lépései:

I Az OSGI service platform egy megfelelő
implementációjának letöltése
I Batyuk létrehozása különböző projekt formátumok
segítségével:
I Eclipse - plugin project (PDE plugin)
I Maven - karaf-bundle-archetype
I Netbeans -
I Maven pux plugin - multimodule osgi projekt beépített
runtime és bundle managementtel
I Batyuk összerakása és menedzsmentje OSGI console
vagy web management interface
33/52
fejlesztés az OSGI keretrendszerben: környezetek
Eclipse 6
Jakab Hunor
Run configuration
OSGI framework, szükséges batyuk:
I org.eclipsel.osgi
I org.eclipse.equinox.console
I org.apache.felix.gogo.command
I org.apache.felix.gogo.runtime
I org.apache.felix.gogo.shell
Equinox és Felix keveredés ?? ( Az eclipse JUNO verzióban

levõ equinox verzió már a felix gogo console-jára épít, ezért
van szükség a felix batyukra
Szükséges az eclipse plugin development environment ( PDE )

telepítése.
34/52
Fejlesztés különálló containerrel környezetek
6
Apache Karaf Jakab Hunor
I Lightweight OSGI container

https://karaf.apache.org/index/community/download/karaf-
2.3.4-release.html
I Autodeploy feature KARAF_HOME/deploy
Telepítés eclipse plug-in projekt esetén:

I Batyu exportálása: deployable plug-ins and fragments
I A létrejött .jar file telepítése az autodeploy könyvtárba
35/52
karaf bundle környezetek
6
archetype Jakab Hunor
Létrehozhatunk OSGI batyuk készítésére tervezett projektet a

karaf-bundle-archetype-ból.

<dependency>
<groupId>org.apache.karaf.archetypes</groupId>
<artifactId>karaf-bundle-archetype</artifactId>
</dependency>

MANIFEST.MF
A létrejött projekt esetében a MANIFEST.MF tartalmát a
maven-bundle-plugin beállításai eredményezik
36/52
maven-bundle-plugin környezetek
6
<plugin> Jakab Hunor
<groupid>org.apache.felix</groupid>
<artifactid>maven-bundle-plugin</artifactid>
<version>${maven-bundle-plugin.version}</version>
<extensions>true</extensions>
<configuration>
<instructions>
<bundle-symbolicname>${project.artifactid}</bundle-symbolicname>
<bundle-version>${project.version}</bundle-version>
<bundle-activator>idde.karafproba.activator</bundle-activator>
<export-package>
idde.karafproba*;version=${project.version}
</export-package>
<import-package>
*
</import-package>
</instructions>
</configuration>
</plugin>>>

37/52
OSGI megjegyzések környezetek
6
Jakab Hunor
Telepítés
Maven bundle projekt: target/ *.jar állomány automatikus
telepítése a Karaf deploy könyvtárába: antrun plugin:

<artifactId>maven-antrun-plugin</artifactId>
<version>1.4</version>
<executions> <execution>
<phase>package</phase>
<configuration> <tasks>
<copy todir="${karaf-dir}">
<fileset dir="${basedir}/target"
includes="*.jar" /> </copy>
</tasks> </configuration>
<goals> <goal>run</goal> </goals>
</execution> </executions>

38/52
OSGI megjegyzések környezetek
6
Jakab Hunor
Maven properties
A karaf deploy könyvtárra a következõképpen hivatkoztunk:
${karaf-dir}
Maven property definíciók:
"pom.xml"
<properties>
<maven-bundle-plugin.version>2.3.7</maven-bundle-plugin.version>
<osgi.version>4.3.1</osgi.version>
< karaf-dir >c:\Users\jakabh\SRC\Karaf\deploy< /karaf-dir>
</properties>

39/52
OSGI deklaratív szolgáltatások környezetek
6
DS Jakab Hunor
I Lehetővé teszi szolgáltatások közzétételét és használatát

XML állományokban megadott metaadatok segítségével
I Segítségével elkerülhetjük az alcsonyszintű OSGI
szolgáltatás API használatát (lásd az előző előadást)
DS használatának főbb feltételei:

I Egy OSGI service component jelenléte
I A MANIFEST.MF bejegyzés jelenléte
I Az deklaratív szolgáltatásokat implementáló megfelelő
OSGI bundle jelenléte a runtime-ban ( implementáció
függő )
40/52
DS példa környezetek
6
Szolgáltatás Jakab Hunor
A szolgáltatást definiáló interface és az őt implementáló osztály

elkészítése

package dsservice;
public interface ServiceInterface {
public void servicemethod();

}
...
package dsservice;
public class ServiceImplementation implements ServiceInterface {
@Override
public void servicemethod() {
System.out.println("This is a service method");
}
}

41/52
6
Szolgáltatás leíró Jakab Hunor
A component definition elkészítése.
Listing 1: "service.xml"
<?xml version="1.0" encoding="UTF-8"?>

<scr:component xmlns:scr="http://www.osgi.org/xmlns/scr/v1.1.0" name="DSservi
<implementation class="dsservice.ServiceImplementation"/>
<service>
<provide interface="dsservice.ServiceInterface"/>
</service>
</scr:component>

Elhelyezés
Konvenció szerint a szolgáltatásokat definiáló .xml
állományokat az OSGI-INF könyvtárba helyezzük.
42/52
6
MANIFEST.MF Jakab Hunor
Ahhoz, hogy a batyu betöltésekor a szolgáltatás létrejöjjön, be

kell jegyeznünk a szolgáltatás leíróját a MANIFEST.MF-ben.

Bundle-Name: DSservice
Bundle-SymbolicName: DSservice
Bundle-Version: 1.0.0.qualifier
Bundle-Activator: dsservice.Activator
Import-Package: org.osgi.framework;version="1.3.0"
Require-Bundle: org.eclipse.equinox.util;bundle-version="1.0.500",
org.eclipse.equinox.ds;bundle-version="1.4.101",
org.eclipse.osgi.services;bundle-version="3.3.100"
Service-Component: OSG-INF/service.xml

maven bundle
Maven projektek esetén ezt az maven-scr(service component
runtime) plugin segítségével valósíthatjuk meg. 43/52
Bemutató témák környezetek
Bemutató témák az utolsó előadásra:

6
Jakab Hunor
I Spring framework, IOC, OSGI
I Continuous integration
I RMI és EE technológiák OSGI-ban
I Alkalmazásszerverek és Java EE
I Multi-tenancy
44/52
8
I Eclipse RCP ( Rich Client Platform) bevezetés Jakab Hunor
I eclipse alkalmazások szerkezete

I Workbench konfiguráció
I nézetek, szerkesztők és perspektívák
I testreszabott műveletek és parancsok definiálása
2/37
Miért alkalmas "Rich client" alkalmazások környezetek
fejlesztésére az eclipse ? 8
Jakab Hunor
I Megbízható komponens-model ( plug-in architektúra)

I Középszintű szolgáltatások és infrastruktúra
I Natív felhasználói élmény ( host operációs rendszer közeli
funkcionalitások)
I Hordozhatóság
I Intelligens telepítési és frissítési mechanizmus
I A fejlesztői eszközök támogatottsága
I Az eclipse ökoszisztéma ( komponens library-k)
3/37
Néhány példa RCP használatára környezetek
8
I IBM lotus project Jakab Hunor
I Nasa maestro project

I IBM notes 8,9
I Novell/NetIQ designer
I Apache Directory studio
I Mindstorms EV3 control center for LeJOS (Lego Java
Operating System)
I stb.
4/37
Kiterjesztési pontok környezetek
8
Jakab Hunor
Equinox extension registry

Equinox kiterjeszti az OSGI komponens modelljét egy
extension registry -vel. Minden plug-in megadhat kiterjesztési
pontokat melyeken keresztül funkcionalitásait lehet bővíteni
vagy konfigurálni.
Pl. Az UI plug-in actionSets kiterjesztési pontja :

org.eclipse.ui.actionSets.
5/37
8
Jakab Hunor
actionSets
" Plug-ins can contribute actionSets extensions that define
actions with an ID, a label, an icon , and a class that
implements the interface IActionDelegate. The UI will present
that label and icon to the user, and when the user clicks on the
item, the UI will instantiate the given action class and call its
run() method.
Pl. Az UI plug-in actionSets kiterjesztési pontja :

org.eclipse.ui.actionSets.
5/37
8
Jakab Hunor
plugin.xml
A különböző kiterjesztési pontokat a plugin.xml állományban
adjuk meg
"org.eclipsercp.hyperbola/plugin.xml"
<extension point="org.eclipse.ui.actionSets">
<actionSet id="org.eclipsercp.hyperbola.debugActionSet">
<action
id="org.eclipsercp.hyperbola.debug"
class="org.eclipsercp.hyperbola.DebugAction"
icon="icons/debug.gif"
label="Debug Chats"/>
</actionSet>
</extension>

6/37
8
"org.eclipsercp.hyperbola/plugin.xml"
Jakab Hunor
<extension point="org.eclipse.ui.actionSets">
<actionSet id="org.eclipsercp.hyperbola.debugActionSet">
<action
id="org.eclipsercp.hyperbola.debug"
class="org.eclipsercp.hyperbola.DebugAction"
icon="icons/debug.gif"
label="Debug Chats"/>
</actionSet>
</extension>

"org.eclipse.ui/plugin.xml"
<extension-point id="actionSets" name="Action Sets"

Lépések:
a UI közzéteszi a "Debug Chats" címkét egy menüben vagy
toolbarban, a debug.gif ikonnal együtt. Ha a user rákattint a
DebugAction osztály példányosítódik és meghívódik a run()
metódusa.
7/37
Kiterjesztési pontok tulajdonságai környezetek
8
Jakab Hunor
Tulajdonság
Az előző példában az UI plugin lehetővé teszi a
menürendszere bővítését más plug-ineken keresztül.
I A UI nem tud előre a különböző plug-inok

hozzájárulásairól
I Nincs szükség speciális kód futtatására a bővítés
elvégzéséhez
I Kiterjesztések és kiterjesztési pontok használata
Eclipse-en belül ( view, menü item, help dokumentumok
bekötése stb)
I Deklaratív mechanizmus ( a plug-in bekötése nem vonja
maga után a "kód" azonnali betöltését )
I "Lazy" tulajdonság
8/37
Eclipse RCP alkalmazások környezetek
8
Jakab Hunor
Megjegyzés
Eclipse platform újrahasznosítása önálló alkalmazások
készítésére azon technológiák felhasználásával melyekkel már
az Eclipse IDE esetében is találkoztunk
Főbb összetevői
I org.eclipse.core.runtime, org.eclipse.ui pluginok
I Fő program: IApplication interfacet implementáló osztály
I Perspektíva : az alkalmazás elrendezését definiálja ( egy
kiterjesztési ponton keresztül kell megadni )
I Workbench Advisor: láthatatlan komponens amely a
különböző kontrollok megjelenését illetve viselkedését
szabá lyozza ( menü, eszköztár, perspektíva stb. )
9/37
RCP alkalmazások felépítése környezetek
8
Jakab Hunor
10/37
RCP alkalmazások felépítése környezetek
8
Jakab Hunor
"plugin.xml"
<plugin>
<extension
id="application"
point="org.eclipse.core.runtime.applications">
<application>
<run
class="hiperbola2.Application">
</run>
</application>
</extension>
...

11/37
RCP alkalmazások életciklusa környezetek
8
Jakab Hunor
1. Az eclipse runtime megkeresi a belépési pontot:

org.eclipse.core.runtime.application kiterjesztési pont
2. Az illető osztály hozza létre az SWT Display-t és a
Workbench-et:

Display display = PlatformUI.createDisplay();
PlatformUI.createAndRunWorkbench(display, new
ApplicationWorkbenchAdvisor());

3. A Workbench az eclipse alkalmazás felhasználói felülete.
4. A WorkbenchAdvisor által van konfigurálva
12/37
RCP Workbench környezetek
8
Jakab Hunor
Workbench
Ahogy JFace struktúrálja az SWT elemeit, hasonlóan a
Workbench struktúrát és irányítást kölcsönöz a JFace-nek. A
felhasználó mindebből nézetek(view) és szerkesztők(editor)
különböző elrendezéseit látja.
Tuajdonságai:
1. UI építő elemeit taratalmazza/teszi elérhetővé.
2. Lehetővé teszi a felhasználói felület hozzájárulás alapú
bővítését
3. Skálázhatóság, teljesítmény és komplexitás
4. Egy sajátos UI paradigmát határoz meg: ablakok
(windows), perspektívák (perspectives), nézetek és
műveletek (actions)
5. Több mint 50 kiterjesztési pontból és 350 API osztályból áll
13/37
RCP Workbench Advisor; advisor = környezetek
"tanácsadó" 8
Jakab Hunor
Megjegyzés
Az alkalmazás indulásakor egyike a fő lépéseknek a
workbench létrehozása a workbenchAdvisor segítségével:
PlatformUI.createAndRunWorkbench(Display,
workbenchAdvisor) amely az alkalmazás ablakainak
létrehozását, konfigurációját és megnyitását szolgálja.
A Workbench nem tudja, hogy hogyan kellene kinézzen illetve

viselkedjen az alkalmazás. Ezeket az információkat a
Workbench advisor-ok segítségével szerzi be.
Pl.
egy ablak megnyitásakor a Workbench lekérdezi egy
advisor-tól, hogy az illető ablak tartalmazzon-e menüt vagy
sem: workbenchWindowAdvisor.preWindowOpen()
14/37
RCP Workbench Advisor környezetek
8
Jakab Hunor
Típusok
Három fő advisor típust különböztetünk meg egy RCP
alkalmazáson belül, azon workbench jellemzőknek
megfelelően amelyeket tanácsokkal látnak el RCP - structure
I WorkbenchAdvisor: Alkalmazás-szintű "tanácsot" ad,

résztvesz a workbench indításában illetve leállításában.
I WorkbenchWindowAdvisor: Ablak-szintű "tanácsot" ad,
résztvesz a menü, a státus sor, a toolbar
megjelenítésében, eltűntetésében, valamint az ablakban
található control-ok konfigurálásában.
I ActionBarAdvisor: Ablak-szintű "tanácsot" ad,
közreműködik a különböző, menüben és toolbar-ban és
status-sorban megjelenő műveletek definiálásában.
15/37
8
Jakab Hunor
Megjegyzés
Minden advisor rendelkezik egy konfigurálóval: configurer
amely hozzáférést biztosít a Workbench, WorkbenchWindow,
menü, toolbar vagy status line-hoz.
I IWorkbenchConfigurer:
I IWorkbenchWindowConfigurer:
I IActionBarConfigurer:
16/37
8
Jakab Hunor
Megjegyzés
Minden advisor rendelkezik egy konfigurálóval: configurer
amely hozzáférést biztosít a Workbench, WorkbenchWindow,
menü, toolbar vagy status line-hoz.
I IWorkbenchConfigurer:
I IWorkbenchWindowConfigurer:
I IActionBarConfigurer:
16/37
WorkbenchWindow configurer környezetek
8
Jakab Hunor
Megjegyzés
IWorkbenchConfigurer

public class ApplicationWorkbenchWindowAdvisor extends
WorkbenchWindowAdvisor {
...
public void preWindowOpen() {
IWorkbenchWindowConfigurer configurer =
getWindowConfigurer();
configurer.setInitialSize(new Point(400, 300));
configurer.setShowCoolBar(false);
configurer.setShowStatusLine(false);
configurer.setTitle("Hello RCP"); }

17/37
ActionBar configurer környezetek
8
Jakab Hunor
Megjegyzés
IActionBarConfigurer

public ApplicationActionBarAdvisor(IActionBarConfigurer
configurer) {
super(configurer);
}

18/37
A Workbench életciklusa környezetek
8
Jakab Hunor
Megjegyzés
PlatformUI.createAndRunWorkbench()
I Exception handler incializálása

I A fő ablak megnyitása és az alapértelmezett controll-ok
létrehozása ( toolbar, status line, perspective switcher,
perspective )
I Egy vagy több ablak megnyitása és a legutóbbi session
alatt mentett beállításoknak megfelelő inicializálása.
I Az SWT "event loop" indítása
I Amennyiben meghívódik az IWorkbenchWindow.close()
menti az ablak állapotát, majd bezárja azt
19/37
A Workbench advisor API környezetek
8
Jakab Hunor
Megjegyzés
Az API metódusai a következő három kategóriába tartoznak:
I Életciklus: lehetővé teszik az advisor számára, hogy

résztvegyen az alkalmazás indításában és leállításában
I Kivételkezelés és várakozás: lehetővé teszi az advisor
számára, hogy részt vegyen kivételkezelésben és az
alkalmazás várakoztatásában
I Konfiguráció: a globális alkalmazás beállításokhoz
használt alapértelmezett értékek meghatározását teszi
lehetővé
20/37
Perspektívák környezetek
8
Jakab Hunor
Megjegyzés
A perspektíva rendszerezi és csoportosítja azon UI elemeket
amelyek egy specifikus munkamenethez vagy feladathoz
tartoznak. Pl. Eclipse Java, Java EE, Debug, PDE
perspektívák. Egy ablakhoz lehet több különböző perspektíva
hozzárendelve amely lehetővé teszi a taszkok közötti egyszerű
váltást ablakváltás nélkül.
Perspektívák hozzáadásának lépései

I Új perspektíva kiterjesztési pont definíciója
I Egy perspektíva osztály definiálása ( implementája az
IPerspectiveFactory interface-t )
I A perspektíva bekötése
I Ikon hozzárendelése ( amennyiben a perspektíva váltás
elérhető kell legyen )
21/37
Perspektívák: elrendezés kialakítása az környezetek
IPageLayout interface-en keresztül 8

Jakab Hunor
Az interface metódusait két kategóriába sorolhatjuk :

I View placement: nézetek elrendezését szolgáló
metódusok pl: metódusok melyekkel nézeteket lehet
egymásra helyezni
I Perspective configuration: A perspektívához tartozó más
elemek konfigurálását szolgáló metódusok, pl: mely
varázslók, vagy műveletek (action set) láthatóak amikor az
illető perspektíva aktív.
22/37
PerspectiveBar láthatóvá tétele környezetek
8
Jakab Hunor
Megjegyzés
Perspektíva váltást a perspektíva toolbaron keresztül tudjuk
előidézni, ennek láthatóságát explicite meg kell adnunk a
WorkbenchAdvisor ban az IWorkbenchWindowConfigurer
preWindowOpen() metóusában:

public void preWindowOpen() {
IWorkbenchWindowConfigurer configurer = getWindowConfigurer()
;
configurer.setInitialSize(new Point(600, 500));
configurer.setShowCoolBar(true);
configurer.setShowMenuBar(true);
configurer.setShowStatusLine(true);
configurer.setShowPerspectiveBar(true);
...
}

23/37
IPageLayoutInterface környezetek
8
Jakab Hunor
Pl: console view hozzáadása a Debug perspektívához:

org.eclipsercp.hyperbola/PerspectiveDebug
public class PerspectiveDebug implements IPerspectiveFactory
{
public void createInitialLayout(IPageLayout layout) {
layout.addStandaloneView(ContactsView.ID, false,
IPageLayout.LEFT, 0.33f, layout.getEditorArea());
layout.addView(IConsoleConstants.ID_CONSOLE_VIEW,
IPageLayout.BOTTOM, 0.70f, layout.getEditorArea());
}
}

24/37
Nézetek és szerkesztők környezetek
8
Jakab Hunor
Megjegyzés
Az alkalmazás tartalmát nézetek és szerkesztők teszik közzé.
A felhasználó ezeken keresztül lép interakcióba az
alkalmazással.
Editors vs Views:
I Általában egy view-nek csak egy példánya létezik egy
workbench oldalon belül, míg ugyanazon típusú editor
több példánya is jelen lehet
I Editorok csupán az oldal egy bizonyos részén jelenhetnek
meg, view megjelenhet bárhol és mozgatható fastview
I Minden view rendelkezik egy lokális toolbar-al, az editorok
a globális toolbarhoz járulnak hozzá
I Editorok lehetnek dirty állapotban
I View tartalma magától mentődik, míg az editor-é csak
explicit utasítás hatására
25/37
Nézetek ( views ) környezetek
8
Jakab Hunor
Megjegyzés
Nézetek létrehozása két lépésből áll:
I A view osztály létrehozása ViewPart -osztály
leszármazottja
I org.eclipse.ui.views kiterjesztési pontban egy új view
deklaratív bejelentése

public class ViewPart1 extends ViewPart {
public ViewPart1() {
}
@Override
public void createPartControl(Composite parent) {
//a nezet tartalmanak felepitese }
@Override
public void setFocus() {
}}

26/37
Nézetek hozzáadása egy perspektívához környezetek
8
Jakab Hunor
Kiterjesztési pontokon keresztül:

I org.eclipse.ui.perspectiveExtensions kiterjesztési pont
I új view hozzáadása ( Id, relative, ratio, visible )
Kódból az IPageLayout interface metódusain keresztül:
pl.

layout.addview("ID",IPageLayout.TOP,0.5f,IPageLayout.
ID_EDITOR_AREA);
}

27/37
Műveletek definiálása (Command) környezetek
8
Jakab Hunor
Megjegyzés
Egy komponens(művelet) deklaratív leírása, független az
implementáció részleteitől. A command frameworkon keresztül
tudunk műveleteket hozzárendelni a UI elemeihez.
Kiterjesztési pontok használatával történik
Egy command definiálása és használata érdekében három

kiterjesztést kell definiálnunk:
28/37
Command handler környezetek
8
Jakab Hunor
Megjegyzés
Az org.eclipse.ui.handler kiterjesztési pont teremt kapcsolatot
egy "command" és egy "handler" osztály között, amely
végrehajtódik a parancs hívásakor
Tulajdonságok:
I A Handler osztálynak implementálnia kell az IHandler
interface-t.
I Az execute metódus hívódik meg a parancs
végrehajtásakor
I Az isEnabled metódus visszatérítési értéke határozza
meg a parancs elérhetőségét a UI-ról
I A leggyakrabban használt programelemeket a HandlerUtil
osztály segítségével érhetjük el.
29/37
Command handler környezetek
8
Jakab Hunor
pl. exit command
public class ExitCommand implements IHandler {

@Override
public Object execute(ExecutionEvent event) throws ExecutionException {
HandlerUtil.getActiveWorkbenchWindow(event).close();
return null;
}
public boolean isEnabled() {
return true; }
public boolean isHandled() {
return true;
}
...
}

30/37
Command hozzáadása a UI-hez környezetek
8
Jakab Hunor
Megjegyzés
Az org.eclipse.ui.menu kiterjesztési ponton keresztül történik
egy új menuContribution megadásával. A menuContribution
locationURI attribútuma határozza meg, hogy hol jelenjen meg
az illető parancs a felületen
31/37
Szerkesztők (editors) környezetek
8
Jakab Hunor
Megjegyzés
Minden editor a workbench ugyanazon részén jelenik meg.
Elhelyezésüket nem tudjuk befolyásolni
Szerkesztő létrehozásának lépései:

I Az editor area láthatóvá tétele a perspektíván belül
I Egy EditorInput osztály létrehozása
I Egy új kiterjesztés definiálása a org.eclipse.ui.editors
kiterjesztési pontban
I Az editor osztályának létrehozása IEditorPart
32/37
Az editor area láthatóvá tétele a környezetek
perspektíván belül 8
Jakab Hunor

public class Perspective implements IPerspectiveFactory {

layout.setEditorAreaVisible(true);
layout.setFixed(true);
}

33/37
Egy EditorInput osztály létrehozása környezetek
8
Jakab Hunor

public class MyPersonEditorInput implements IEditorInput {
private final int id;
public MyPersonEditorInput(int id) {
this.id = id; }
public int getId() {
return id; }
@Override public boolean exists() {}
@Override public ImageDescriptor getImageDescriptor()
{ }
@Override public String getName() {}
@Override public IPersistableElement getPersistable()
{ }
......
}

34/37
Az editor osztály létrehozása környezetek
8
Jakab Hunor

public class PersonEditor extends EditorPart {
public static final String ID = "MyEditorID"
public PersonEditor() {
}
@Override
public void createPartControl(Composite parent) {
}
...
}

Megjegyzés
Az editorhoz tartozó ID-t érdemes statikus adattagként
elmenteni: public static final String ID = "MyEditorID"
35/37
Editor megjelenítése "Command" környezetek
segítségével 8
Jakab Hunor
Megjegyzés
Létrehozunk egy parancsot és a hozzá tartozó handler
osztályt. A handler osztály execute metódusában egy
IWorkbenchPage objektumon keresztül nyitjuk meg a
szerkesztőt az openEditor metódus segítségével:

public class CallEditor extends AbstractHandler {
public Object execute(ExecutionEvent event) throws
ExecutionException {
IWorkbenchWindow window = HandlerUtil.
getActiveWorkbenchWindow(event);
IWorkbenchPage page = window.getActivePage();
MyPersonEditorInput input = new ..
try {
page.openEditor(input, MyPersonEditor.ID);
} catch (PartInitException e) {
throw new RuntimeException(e);
}
...

36/37
Dependency injection in Java
With Guice
Jakab Hunor
Lecturer @ Babes-Bolyai University, Faculty of Mathematics and Computer Science
IOC and DI
Inversion of Control: basic techniques
Template method
Factory pa ern
Service locator pa ern
Strategy pa ern
Dependency injection
Dependency injection: - the ability to inject external

dependencies into software components
Types of DI
The dependency injection pa ern separates behaviour
from dependency resolution.
How can we set dependencies into an object?

Constructor Injection
Method Injection
Field Injection
There are optional, on-demand, static and automatic

injection types as well
Types of DI
Constructor injection
public class RealBillingService implements BillingService {
private final CreditCardProcessor processorProvider;
private final TransactionLog transactionLogProvider;
@Inject
public RealBillingService(CreditCardProcessor processorProvider,
TransactionLog transactionLogProvider) {
this.processorProvider = processorProvider;
this.transactionLogProvider = transactionLogProvider;
}
Best for unit testing, notice the @Inject annotation

Method injetion
public class PayPalCreditCardProcessor implements CreditCardProcessor {
private static final String DEFAULT_API_KEY = "development-use-only";
private String apiKey = DEFAULT_API_KEY;
@Inject
public void setApiKey(@Named("PayPal API key") String apiKey) {
this.apiKey = apiKey;
}
Notice the @Inject annotation. the @Named annotation

makes choosing between multiple bindings possible
Field injection
public class DatabaseTransactionLogProvider implements Provider<TransactionLog> {
@Inject Connection connection;
public TransactionLog get() {

return new DatabaseTransactionLog(connection);
}
}
Most obvious type of injection. Not as easy to test as

with constructor injection
Service locator pa ern with Guice
Use sparingly, only when other types of injection are
not suitable.
Injector injector = Guice.createInjector(...);
MyObject o = injector.getInstance(MyObject.class);
Injector can be injected as a dependency, if desired type

is known only at runtime ex. web-request with custom
country related injector
Google guice
Guice vs Spring: dedicated DI vs. software stack
Main comoponents:
Injector
Module
Binder
Identification:
compile 'com.google.inject:guice:3.0'
Guice configuration
Configurations are placed inside so-called modules.
Each module serves a different purpose
```java public class ServiceModule extends AbstractModule {

@Override
protected void configure() {
bind(IPersonDAO.class)
.annotatedWith(Names.named("ormpersondao"))
.to(PersonDAO.class);
bind(IPersonDAO.class)
.annotatedWith(Names.named("jdbcpersondao"))
.to(PersonDAOJdbc.class);
bind(IOrganizationDAO.class).to(OrganizationDAO.class);
}
}
We can have arbitrary number of separate modules.
Guice configuration
The injector is configured by passing the desired
module upon creation
singletonInjector = Guice.createInjector(new ServiceModule());
Guice persistence
Guice has an extension for accomplishing persistence
according to JPA 2.1 standard
Steps
Persistence unit creation upon configurint the injector
Persistence service, that needs to be started
singletonInjector = Guice.createInjector(new ServiceModule(), new JpaPersistModule("MyP
singletonInjector.getInstance(PersistService.class).start();
DI in webapps
Servlet-based web applications require a different
container creation mechanism
Servlets are created and destroyed by the container

Each servlet has one instance
Each request spawns a new thread with the Servlet's service method
Questions:
When do we create the injector ?
How can we get servlet contexts injected elsewhere ?
Servlet lifecycle reminder
Using Guice in servlets
Guice has a special extension guice-servlet that
provides the mechanism to solve the above problems
The GAV coordinates of the dependency:

groupId: com.google.inject.extensions
artifactId: guice-servlet
version: 4.1.0
Using Guice in servlets
Guice-servlet enables injector creation, servlet
declaration and context injection
Most important components:

com.google.inject.servlet.ServletModule
com.google.inject.servlet.GuiceServletContextListener
com.google.inject.servlet.GuiceFilter
ServletModule
Sets up the request and session scopes, and provides a
place to configure your filters and servlets from.
Pl:
public class MyServletModule extends ServletModule {
@Override
protected void configureServlets() {
serve("/hello").with(HelloAppEngine.class);
filter("/*").through(MyFilter.class);
}
}
ServletContextListener
Injector should be created before any H p calls are
received.
public class MyGuiceServletConfig extends GuiceServletContextListener {
@Override
protected Injector getInjector() {
Injector myinjector = Guice.createInjector(new MyServletModule(),
new ServiceModule(),
new JpaPersistModule("MyPersistenceUnit"));
myinjector.getInstance(PersistService.class).start();
return myinjector;
}
}
GuiceFilter
All requests need to go through GuiceFilter in order
to properly set up request and session scopes
web.xml
<filter>
<filter-name>guiceFilter</filter-name>
<filter-class>com.google.inject.servlet.GuiceFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>guiceFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<listener>
<listener-class>guice.MyGuiceServletConfig</listener-class>
</listener>
Guice in App Engine
Requires the use of Guice v > 2.0 and the servlet
extension
Steps to perform:
Create web.xml, register Guice filter, reroute requests
Create a ServletModule
Create a class to extend GuiceServletContextListener
Register it in web.xml as a listener
Write code for Injector creation
Important considerations
Every servlet (or filter) is required to be a @Singleton
or you must bind it using
bind(..).in(Singleton.class)
According to the servlet specification only one instance can exist

When using Jersey, the Jersey implementation takes care of the
singleton binding
REST API
Can be created using pure servlets or a dedicated
library like Apache Jersey
Example code :
API with pure servlets
API with Apache Jersey
Cloud applications
GCP and App Engine basics
Jakab Hunor
Lecturer @ Babes-Bolyai University, Faculty of Mathematics and Computer Science
Cloud computing trends
Shared pools of configurable system resources and high
level services.
Timeline:
2006 - Amazon Elastic Compute Cloud
2008 - Google App Egine
2009 - Heroku
2010 - Microsoft Azure
NIST classifies them according to their service model

as: IaaS, Paas, SaaS
Cloud computing service models
Google Cloud Platform
Based on physical devices and virtual resources located
in data centers around the world
computers
hard disk drives
virtual machines
These resources are accessed through GCP services. Applications are a
mix of available GCP services
GCP - resource regions and zones
GCP - resource regions and zones
Geographical distribution is well thought out
Some of the main benefits:

Resources can be located near where they are needed (low latency)
Services can live in multiple zones ( fault tolerance )
Data redundancy can be achieved for catastrophic scenarios
GCP regions and zones
GCP projects
Any Cloud Platform resources that you allocate and
use must belong to a project. A project is the
organizing entity for what you're building.
Main properties of cloud platform projects:

Project name
Project ID (auto or self provided) unique across the whole GCP
Project number
Check project properties in the GCP web console!
Interacting with GCP services and
resources
Remember: Applications are a mix of available GCP
services that use certain resources
Three main ways of interaction:

Google Cloud Platform Console
Command line tool from Cloud SDK called gcloud
Different APIs (client libraries)
application development
resource management
Cloud Platform services
Four main categories can be distinguished:
Computing and hosting

Storage
Networking
Big Data
Computing and hosting services
Possibility to work with managed application platform,
leverage container technologies , or build your own
cloud-based infrastructure.
Other considerations
Pricing
Google adopts the pay as you go pricing model. Costs
are calculated based on resource type and usage
amount.
Main features:
No upfront costs
Pay-as-you-go
No termination fees
Free services with limited quotas
Google App Engine
Google App Engine is Cloud Platform's platform as a
service (PaaS)
Properties:
Fully managed (hosting, scaling, monitoring, infrastructure)
Supports many different languages:
standard environment: java7, java8, Python, PhP, Go
flexible environment: Python 3.4, Go, Node.js, Ruby
Free apps have to be deployed to the standard environment
Google Container Engine
Create and manage clusters of containerized
applications.
Kubernetes automation engine for containers

Docker base container format for Compute Engine instances
Possibility to create a services abstraction layer
A hybrid of PaaS and IaaS
Google Compute Engine
Cloud platforms IaaS, provides a robust computing
infrastructure, but you must choose and configure the
platform components that you want to use
Create virtual machines

Choose machine type, geographical location
Choose operating system, development stack, language framework
Autoscaling and external connecitons towards VMs
Storage and other services
Honorable mentions from the Google Cloud Platform
Big Query (data analysis service)
Cloud Dataflow ( batch and streaming data processing )
Cloud Pub/Sub ( asynchronous messaging service)
Cloud SQL ( Mysql and PostgreSQL databases)
Cloud Storage ( large-capacity data storage)
App Engine overview
App Engine offers a choice between two environments
for Java applications: flexible environment and
standard environment
Standard environment with Java 8

Runs web apps in Java 8 JVM (openJDK)
Jetty 9 as servlet container
Supports servlet specs 2.5 and 3.1
Can use any google cloud-based API
App Engine overview
App Engine application is made up of one or more
services, which can be configured to use different
runtimes and to operate with different performance
se ings
Microservice architecture
A deployed service behaves like a microservice
An application is a set of microservices
App Engine overview
Application
App Engine services
Microservices allow a large application to be
decomposed into independent constituent parts, with
each part having its own realm of responsibility
Properties:
full isolation of code
independent deployment cycles
autoscaling, loadbalanding
Multiple versions can be deployed at the same time
Code in one service can't directly call code in another
Service stack
App Engine applications
App Engine services consist of source code and
configuration files.
Service properties:
Has a unique name
Can have multiple versions ( determined by its source )
Can run on one or multiple instances at the same time
Communication between services
Services are logically separated components of the
application, each running in a secure sandbox
environment
Consequences:
Each service is reachable through HTTP requests
Services within the same app share certain resources:
Memcache
Datastore
Task Queues
Custom APIs and endpoints can be easily defined using Cloud
endpoints
App Engine instance handling
Instances are the computing units that App Engine
uses to automatically scale your application
Instance properties:
provide resources for the application
language runtime
App Engine APIs
Application code and memory
has its own security layer
Autoscaling se ings determine the number of instances for a service
Anathomy of an App Engine
Application
<application root>/
WAR Directory WAR Directory
META-INF/ <service1>/ <service2>/
WEB-INF/ WEB-INF/
appengine-application.xml appengine-web.xml appengine-web.xml

application. xml web. xml web. xml
Careful of the differences between Java7 and Java8 environments

Configuration details
The main configuration file for a service is
appengine-web.xml located in the WEB-INF folder
from the .war file
appengine-web.xml properties:
xml file with a root element <appengine-web-app>
Can be different when using cloud-sdk and appengine-java-sdk
tooling
Information within is used when deploying the app to the cloud
All configuration options can be found here
Google Cloud SQL
A fully-managed database service for relational
databases on Google Cloud Platform (MySQL and
PostgreSQL).
MySQL
Support mysql 5.6 or 5.7
Instances created and managed in the GCP console
Data replication between multiple zones
Regional locations
Cloud SQL
Requires google specific mysql driver and auto loading
se ing in appengine-web.xml
Driver coordinates:
<groupId>com.google.cloud.sql</groupId>
<artifactId>mysql-socket-factory-connector-j-6</artifactId>
Appengine-web.xml:
<use-google-connector-j>true</use-google-connector-j>
Cloud SQL sample
persistence.xml
Driver class and database url need to be specified
correctly:
value="jdbc:google:mysql://idde-191204:europe-west3:idde/idde"/>
value="com.mysql.jdbc.GoogleDriver"/>
idde-191204:europe-west3:idde is the cloud sql instance name and

should be changed accordingly!
Tooling
Google cloud SDK
Maven and Gradle plugins

Tervezői És Fejlesztői Környezetek (Maven, Ant, Gradle, GCP, OSGI, RCP)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tervezői És Fejlesztői Környezetek (Maven, Ant, Gradle, GCP, OSGI, RCP)

Uploaded by

Copyright:

Available Formats

Tervezői és fejlesztői

Tervezői és fejlesztői környezetek Apache Maven

A tantárgy során érintett főbb témák:

csoportja, melyekkel a szoftverfejlesztés során a felhasznált Build rendszerek

programozási nyelven vagy nyelveken létrehozott Apache Ant

forráskódokat futáskész állapotba lehet hozni és azokat Apache Maven

I Emacs, Lisp env, Smalltalk

A Microsoft által fejlesztett IDE Főbb jellemzői:

I .Net framework, Ms Silverlight, Ms Windows, Windows CE Repository

I Kiterjeszthető fejlesztői platform és keretrendszer Build rendszerek

fejlesztése Apache Ant

Több mint 100 open source projekt az alábbi kategóriákból:

Legfrissebb verziója: 4.7 Oxygen

forrásfájlokra Build rendszerek

I Kódkiegészítés, lehetőségek felajánlása Apache Ant

I Beépített és saját kódsablonok Apache Maven

I Erős refactoring támogatás (osztály, metódus Nexus

környezetet (JRE) Build rendszerek

2000 óta. Build rendszerek

I 2010-től az Oracle tulajdona Apache Ant

segítségével íródott Build rendszerek

I Dev-C++ Apache Ant

Néhány klasszikus példa

használata ) Apache Maven

nagyobb projektek esetében Nexus

I Léteznek különböző build script generáló eszközök pl:

Apache Ant és Maven

I James Duncan Davidson fejlesztette ki: patform Repository

Összehasonlítás: állomány törlése

Három koncepció köré épül:

Három koncepció köré épül:

Három koncepció köré épül:

<project name="HelloWorld" basedir="." default="main"> Bevezetõ

<target name="main" depends="clean,run"/>

I XML alapú konfigurációs állományok segítségével írja le a

A "convention over configuration " elvét követi:

Maven esetében a projektek szerkezete, fordítása,

Az Ant-hez hasonló funkcionalitásokat valósít meg viszont

helyett ) Apache Maven

I Életciklus és plug-in parancsok a build folyamat különböző

Egy egyszerű projekt létrehozása:

A fenti utasítás elemei: Build rendszerek

Az eredmény: egy standard könyvtár struktúra:

I src/main a projekt forráskódja és erőforrásai: Apache Ant

I src/main/java forráskódok Apache Maven

I src/main/resources erőforrások Repository

Fordítás, tesztelés, telepítés

A Maven funkcionalitásait pluginok és célok valósítják meg,

Egy maven build életciklusa különböző fázisokból tevődik

Életciklus fázisok Build rendszerek

Minden különböző típusú projekt esetében mást jelentenek. Apache Maven

Nincsenek szigorúan definiálva, alapértelmezett célok Repository

I Az életciklus fázisaihoz különböző célokat köthetünk.

szükséges információ meglétét Bevezetõ

I compile - a forráskód fordítása Build rendszerek

Alapértelmezett életciklus fázisok és

Függőség kezelés a Maven egyik legjelentősebb előnye

I Tranzitív függőségek "a függőségek függőségei" Apache Maven

I A fordítás melyik szakaszában lesznek igénybevéve és Apache Maven

A központi gyűjtemény (central repository)

A lokális gyűjtemény (local repository)

I csak a test fázisban lesz a <dependency>

<dependencies> Build rendszerek

Listing 1: "MessageBundle_en_US.class" Lokalizáció és