Know - how aus der Praxis - Schulungskatalog - aformatik
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
Know – how
aus der Praxis
Schulungskatalog
aformatik
Training & Consulting GmbH & Co. KG
Tilsiter Straße 6
71065 Sindelfingen
Tel: 0 70 31 / 23 80 7 - 0
E-Mail: seminare@aformatik.de
Januar 2021 Internet: www.aformatik.deaformatik
aformatik Kurzportrait
Die aformatik ist ein unabhängiges Software-Beratungshaus mit Kompetenz in der objektorientierten
Anwendungsentwicklung im Java/Java EE-Umfeld. Das Dienstleistungsportfolio umfasst Schulungen,
Technologieberatung, Coaching (Know-how-Transfer) und Anwendungsentwicklung. aformatik ist IBM
Business Partner und ist Partner der IBM Global Training Provider.
Von der Idee, über die Realisierung, bis hin zur Wartung – wir unterstützen unsere Kunden über die gesamte
Laufzeit des Software life cycles.
Technologien
• Java: ME, SE, Enterprise Edition
• Servlets, JSP, EJB, Design Patterns, CDI, JSF, JPA.
AWT, Swing, Spring, XML, HTML, HTML 5, JSF, Facelets, Ajax, Tiles.
• WebServices (SOAP und REST-basiert).
• Tomcat, JBoss, Apache Geronimo, IBM WebSphere Application Server,
IBM WebSphere Portal.
• Java auf System z
• Frameworks: Swing, Struts, Hibernate.
• Datenbanken: DB2, Oracle, Derby, MySQL, Microsoft SQL Server, Cloudscape.
• Betriebssysteme: Linux, Unix, Windows, System z, MacOS
• Entwicklungsumgebungen: Eclipse, IBM Rational Application Developer,
Rational Developer for System z und andere.
• Versionsmanagement: Subversion, CVS
• Testen: JUnit, Robot Framework
• Standards und Methoden: OSGI, Maven, Python, Hudson
Das aformatik Team:
Wir setzen auf Qualität, Geschwindigkeit und Flexibilität. Unsere Mitarbeiter sind exzellent
ausgebildete Persönlichkeiten, die unsere Kunden, ob bei den Schulungen oder in den Software-
Projekten, voranbringen. Der Blick bleibt dabei immer auf der Machbarkeit und dem Budget – aber
auch über den Tellerrand hinaus, um Ihnen die bestmögliche Lösung zu bieten.
Unsere Trainer und Consultants sind:
• Erfahrene Dipl.-Informatiker Uni/FH/BA
• Praxiserfahren mit einer Vielzahl von Projekten
• Zertifizierte Dozenten mit Erfahrung in Praxis und Didaktik
• Teamfähig und flexibel Qualitätsbewusst und Zeit-und Kostenorientiert
Seite 2aformatik
Dienstleistungen
• Machbarkeitsanalysen, Konzeption und Erstellung von Prototypen (Proof-of-concept)
• Architekturberatung für objektorientierte Software Systeme
• Analyse und Design fachlicher Abläufe
• Objektorientierte Modellierung (UML)
• Analyse, Design und Anwendungsentwicklung mit Java und JAVA EE Technologie
• E-Business-, Internet- bzw. Intranet-Architekturen in der verteilten Client/Server-Welt
• Anbindung an Host-/ Legacy-Systeme und Systemintegration.
• Standard- und kundenindividuelle Schulungen in Themen der objektorientierten Softwareentwicklung
und Datenbanken
• Schulungsbegleitendes Coaching
• Qualitätssicherung
• Profiling und Performance Tuning
• Projektorganisation und – Leitung, technische Projektleitung
• Betrieb und Wartung von Softwaresystemen
• Installation und Konfiguration von IBM Softwareprodukten
Zertifizierungen der Mitarbeiter:
Certified Project Management Associate IPMA Level D®
ITIL Foundation
Sun Certified Web Component Developer for the Java2 Enterprise Edition 1.5
Sun Certified Business Component Developer for the Java EE 5 Platform
Sun Certified Programmer for the Java2 Platform Standard Edition 5.0
Sun Certified Java Programmer or Oracle Certified Professional, Java SE 6 or 7 Programmer
OMG Certified UML Professional
Data - DB2-Data Management
IBM Certified Database Associate -- DB2 9 Fundamentals
IBM Certified Database Administrator - DB2 9 DBA for z/OS
IBM Certified Database Administrator -- DB2 9 DBA for Linux UNIX and Windows
IBM Certified Application Developer - DB2 9
IBM Certified Solution Developer - DB2 9.5 SQL Procedure Developer
IBM Certified Application Developer - DB2 9.7 for Linux, Unix and Windows
IBM Certified Database Administrator - DB2 10 for z/OS
IBM Certified Database Associate - DB2 10.1 Fundamentals
IBM Certified Database Administrator - DB2 10.1 for Linux UNIX and Windows
IBM Certified Application Developer - DB2 11 for z/OS
IBM Certified Database Administrator - DB2 11 DBA for z/OS
WebSphere - Foundation and Tools
IBM Certified Advanced Application Developer - Rational Application Developer v7
IBM Certified Associate Developer - Rational Application Developer V8
IBM Certified System Administrator - WebSphere Application Server Network Deployment V6.0
IBM Certified Advanced System Administrator - WebSphere Application Server Network Deployment V6.1
IBM Certified System Administrator - WebSphere Application Server Network Deployment V6.1
IBM Certified System Administrator - WebSphere Application Server Network Deployment V7.0
IBM Certified System Administrator - WebSphere Application Server Network Deployment V8.0
zSeries Technical IBM System z System Programmer
PAI Certification – Developer for PAI J2EE Release 5.0, DIR and SEC Platform Release 4.0
Seite 3aformatik
Um unseren Kunden den Ein- oder Umstieg auf die neueste Java-Technologie zu erleichtern, haben wir,
ausgehend von unserer langjährigen Erfahrung auf diesem Gebiet, eine ganze Palette von
maßgeschneiderten Seminaren und Workshops erarbeitet.
Unabhängig, ob Ein- oder Umsteiger - wir haben immer das passende Seminar.
Unsere zertifizierten Dozenten sind nicht nur pädagogisch erfahren, sondern Ihre Kompetenz wird ständig in
Praxisprojekten erweitern. Praxisrelevante Tipps und Tricks kommen nicht zu kurz.
Seminar- und Workshopübersicht
aformatik Kurzportrait ......................................................................................................................................2
Seminar- und Workshopübersicht ..................................................................................................................4
aformatik Schulungs-Curriculum im Überblick .............................................................................................6
............................................................................................................................................................................6
1. Spezial-Seminare ...................................................................................................................................7
Kurs Nr. S100: Git Grundlagen ................................................................................................................ 7
Kurs Nr. S101: Apache Service Mix ........................................................................................................ 8
Kurs Nr. S102: Einführung in Continuous Delivery ................................................................................. 9
Kurs Nr. S103: Entwicklung von Backend-Microservices (Rest-Webservices) mit Springboot ............ 10
Kurs Nr. S104: Auf Springboot basierte Backend(Rest-Webservice)-Entwicklung ............................... 11
2. Theorie Basiswissen ...........................................................................................................................12
Kurs Nr. 100: Objektorientierte Analyse und Design mit der Unified Modeling Language (UML)......... 12
3. Java Standard Edition .........................................................................................................................13
3.1. Java Grundlagen ..................................................................................................................................13
Kurs Nr. 200: Java für Entscheider ........................................................................................................ 13
Kurs Nr. 201: Vorbereitung - Java Programmierung Teil 1 ................................................................... 15
Kurs Nr. 202: Einstieg - Java Programmierung Teil 2 ........................................................................... 16
Kurs Nr. 203: Aufbau – Java Programmierung Teil 3............................................................................ 17
Kurs Nr. 250: Objektorientierte Programmierung mit Java – Intensivkurs ............................................ 18
3.2. Java Expertenwissen ..........................................................................................................................19
Kurs Nr. 300: Professionelles Java ....................................................................................................... 19
Kurs Nr. 301: GUIs mit Swing ................................................................................................................ 20
Kurs Nr. 350: Android Grundlagen für Java Entwickler ......................................................................... 21
4. Java Enterprise Edition .......................................................................................................................22
Kurs Nr. 400: Java EE 5 - Web Applikationen ....................................................................................... 22
Kurs Nr. 451: Java EE – JPA und Enterprise JavaBeans ..................................................................... 24
5. Weiterführende Schulungen ...............................................................................................................25
Kurs Nr. 500: Struts basierte Software-Entwicklung ............................................................................. 25
Kurs Nr. 501: Design Patterns in Java .................................................................................................. 26
Kurs Nr. 503: Einführung in das Persistenz-Framework Hibernate ...................................................... 27
Kurs-Nr. 511: JavaServer Faces V2.0/2.2 ............................................................................................. 28
Kurs Nr. 520: Einführung in Spring ........................................................................................................ 29
Kurs Nr. 521: Einführung in Spring und JPA ......................................................................................... 30
Kurs Nr. 800: Mainframe Grundlagen für Java-Entwickler .................................................................... 31
Kurs Nr. 810: IBM Data Studio Einführung für DB2 z/OS Entwickler .................................................... 32
Kurs Nr. 820: Java on z/OS (Workshop) ............................................................................................... 33
Preise und die aktuellen Schulungstermine unter: www.aformatik.de
Seite 4aformatik
Bewertung der Seminare durch unsere Kunden
Da uns ihr Feedback sehr wichtig ist, führen wir nach jedem Seminar eine anonymisierte Umfrage bei den
Teilnehmer durch. Wir nehmen Ihre Anregungen und Kritik sehr ernst. Das ist ein Garant für die
durchgehend hohe Qualität unserer Seminare.
Das sagen unsere Teilnehmer, wenn wir Sie danach fragen, was Ihnen gefallen hat (Zitate):
Umfassendes Es wurde auf alle
Wissen des Trainers Angenehme Fragen eingegangen Know-how und
Atmosphäre Flexibilität des
Dozenten
Sehr professionell, mit hohem Engagierte
Bezug zur Praxis Praxisbezug. Weiter so! Trainer
Großer Anteil an
praktischen Übungen
Durchgehendes
Übungsbeispiel Optimale
Betreuung
Danke für das tolle Seminar. Ich
werde Sie gerne weiterempfehlen.
Referenzen
Unter anderen vertrauen folgende Firmen auf die Qualität unserer Schulungen und überlassen uns
regelmäßig Ihre Mitarbeiter zur Weiterbildung:
• Allianz • R + V Allgemeine Versicherung AG
• AMB Generali • Robert Bosch GmbH
• Daimler AG • SDK Süddeutsche Versicherung
• Deutsche Bundesbank • Siemens
• Deutscher Sparkassenverlag • Stuttgarter Versicherung
• Die Schweizer Post • T-Systems
• EADS • UBS
• Gothaer Systems • VR Kreditwerk
• IBM Deutschland GmbH • Württembergische & Wüstenrot
• Kassenzahnärztliche Vereinigung • ZIVIT Zentrum für Informationsverarbeitung
Seite 5aformatik Schulungs-Curriculum im Überblick
Theorie Basiswissen Java Grundlagen Java Expertenwissen Java Enterprise
Kurs 100: Objektorientierte Analyse Kurs 201: Vorbereitung Kurs 400: Java EE-Web Kurs 800: Mainframe Grundlagen für
Kurs 300: Professionelles Java
und Design mit der Unified Modeling Java-Programmierung Teil I Applikationen (mit Eclipse/RAD und Java Entwickler
5 Tage
Language (UML) 3 Tage 2 Tage Web Tools) 5 Tage 3 Tage
Kurs 202: Einstieg Kurs 450:
Kurs 200: Java für Entscheider Kurs 301: GUIs mit Swing
Java-Programmierung Teil II J2EE - Enterprise JavaBeans
1Tag 5 Tage
3 Tage 5 Tage
Kurs 203: Aufbau Kurs 350: Java-Entwicklung mit Kurs 451: Java EE 5 - JPA und
Java-Programmierung Teil III Android Enterprise JavaBeans
Weiterführende Themen: 5 Tage 3 Tage 5 Tage
Kurs 500: Struts Einstieg mit Kenntnisse in der
basierte Software-Entwicklung Java Standard Edition Java Enterprise Edition
Objektorientierung
3 Tage
Kurs 250: Intensivkurs
Kurs 501: Design Patterns in Java Objektorientierte Programmierung
und J2EE mit Java 5 Tage
2 Tage
Kurs 503: Einführung in das
Persistenz-Framework Hibernate
2 Tage
Kurs 510: JavaServer Faces
3 Tage
Kurs 520: Einführung in Spring
2 Tage
Kurs 521: Einführung in Spring und
JPA
4 Tage1. Spezial-Seminare
Seminar
Kurs Nr. S100: Git Grundlagen
Git ist ein freies Versionskontrollsystem zur Verwaltung von Softwareprojekten und hat sich als quasi-
Standard etabliert. Die hohe Flexibilität des Werkzeugs geht auch mit einer gewissen Komplexität
einher. Das Seminar vermittelt ausführlich die theoretischen Grundlagen des Systems, spannt dabei
stets den Bogen zu Beispielen aus der Praxis und gibt Orientierung mit Hilfe von Best Practices für
den Projektalltag.
Das Git Grundlagen-Seminar kann mit einem Workshop gekoppelt werden, dessen Themen ganz auf
Ihre Bedürfnisse zugeschnitten sind (z.B. Migration von Subversion nach Git, ausgehend von Ihrem
konkreten Setup).
Kursziele
• Grundsätzliches Verständnis der Umgebung Git und Vertiefung der Kenntnisse und
Zusammenhänge
• Kursziele werden im Vorfeld in Absprache mit den Teilnehmern definiert
Workshop-Inhalte:
• Die Philosophie hinter Git
• Aufbau und Terminologie
• Datenmodell
• Branches und Tags
• Working Tree und Staging Area
• Remote Repositories
• Git Kommandos
o Commiterstellung
o Integration: Merge und Rebase
o Synchronisation: Arbeiten mit Remote Repositories
Weitere Themen können auf Ihre konkreten Bedürfnisse zugeschnitten werden, z.B.
• Migration von Subversion nach Git
• Branchingmodelle und Workflows mit Git
Zielgruppe
Dieser Kurs richtet sich an Softwareentwickler, die Git als Versionsverwaltung nutzen wollen und
damit sowohl an Neueinsteiger als auch Umsteiger von anderen Systemen wie z.B. Subversion. Auch
Anwender, die Git bereits verwenden, sich bisher jedoch noch nicht mit den Modellen dahinter befasst
haben, werden von dem Seminar profitieren.
Voraussetzungen:
• Erfahrung in der Softwareentwicklung
• Grundkenntnisse zur Kommandozeile sind vorteilhaft
Werkzeug und Unterlagen
Der Kurs konzentriert sich auf das Git-Basissystem und die Bedienung über die Kommandozeile. Alle
Unterlagen und Übungen sind in deutsch.
Dauer:
1 Tagaformatik
Seminar
Kurs Nr. S101: Apache Service Mix
Der Workshop vermittelt einen Überblick über den Apache Service Mix und siner Hauptmodule.
Einführung in die Management Features und Nutzungsmöglichkeiten ohne Programmierung, Self-
Service Features oder Security Features, Möglichkeiten der Protokollierung, Monitoring und
Fehlerhandling im Betrieb. Beispielhafte Durchführung von Datentransfers.
Kursziele
• Die genauen Seminarinhalte und Ziele werden in einem Vorgespräch festgelegt
Workshop-Inhalte:
• Architektur, Bestandteile und typische Einsatzbereiche
• Installation, Verzeichnisstruktur, Start/Stop, Wer macht was: Java, Karaf
• ActiveMQ, Camel, Einfache Prozessüberwachung
• Detaillierte Server-Überwachung mit JMX
• Service Mix-Anwendungen: Installation, Konfiguration, Protokollierung
• Vertiefung der Datentransfer-Komponenten
• REST: Übersicht und Best Practices
• Detaillierte Routen-Überwachung: Aufruf-Metriken, Fehler-Protokollierung
• Erkennen von betrieblichen Problemen (Durchsatz, Performance, Speicher)
• Zusammenfassung, Q&A
• Weitere Themen nach vorheriger Abstimmung möglich
Methode: Vortrag, Präsentation, Übungen, Diskussion, Praktische Übungen
Zielgruppe
Administratoren, Architekten, Entwickler
Voraussetzungen:
Dies ist kein Developer-Seminar, der Fokus liegt auf betrieblichen Aspekten
Werkzeug und Unterlagen
Linux-Betriebssystem mit aktueller Java-Version sowie Apache Service Mix > 6.x.
Dauer:
2 Tage, insgesamt 8 Unterrichtseinheiten mit jeweils 90 Minuten
Seite 8aformatik
Seminar
Kurs Nr. S102: Einführung in Continuous Delivery
Um (neue) Anforderungen an ein Produkt schnell umsetzen zu können, werden agile Praktiken
angewandt. Damit die daraus entstehende Software auch schnell den Weg in die Produktion findet,
wird Continuous Delivery benötigt.
Der Workshop beschreibt die Hintergründe und Grundlagen von Continuous Delivery. Zusammen mit
den Teilnehmern werden mögliche Umsetzungen für die eigene Praxis diskutiert.
Kursziele
• Verständnis von Continuous Delivery und den damit verbundenen Praktiken
• Erkennen des Einflusses von CD auf die betrieblichen Abläufe
• Einfluss von CD auf die Entwicklung der Software
• Notwendige Komponenten der Infrastruktur
Workshop-Inhalte:
• Continuous Delivery (CD) als Weiterentwicklung von Continuous Integration (CI)
• Schritte der CD Pipline
• Software-Tests als essentieller Bestandteil der Pipline
• Automatisierung der Konfiguration
• Automatisierung des Deployments
• formale Genehmigung des Deployments / Einhaltung von Prozessen
Zielgruppe
Dieser Workshop richtet sich an erfahrene Softwareentwickler, Architekten und Projektleiter.
Voraussetzungen:
• Grundlegende Kenntisse von Build-Prozessen
• Grundlagen zum Konfigurationsmanagement
• Grundlagen zum Thema Softwaretests
Werkzeug und Unterlagen
Alle Unterlagen und Übungen sind in deutsch.
Dauer:
1 Tag
Seite 9aformatik
Seminar
Kurs Nr. S103: Entwicklung von Backend-Microservices (Rest-Webservices)
mit Springboot
Workshop Basic Version
Dieser Workshop besteht zu 80% aus praktischem Lernen und Übungen.
Kursziele
• Entwickler können danach Backend/Webservices mit Springboot für einfache Themen
selbständig erarbeiten.
Workshop-Inhalte:
• Vorstellung von Rest/Json basierten Webservices
• Setup von Springboot Applikationen
• Annotation und Konfigurationen
• Validierung und Exception handling
• Tooling: API-Dokumentation, Test
• Implementierung von UnitTest
• Erste Installation in AWS
• Praktische Übungen
Zielgruppe
Dieser Kurs richtet sich an Softwareentwickler, Software-Designer
Voraussetzungen:
• Kenntnisse über Java und Eclipse
Werkzeug und Unterlagen
Alle Unterlagen und Übungen sind in Deutsch oder Englisch.
Eigene Laptops sind mitzubringen.
Dauer:
1 Tage (maximal 8 Teilnehmer
Seite 10aformatik
Seminar
Kurs Nr. S104: Auf Springboot basierte Backend(Rest-Webservice)-
Entwicklung
Workshop Advanced Version – Basic Version + Zusätzliche Agenda
Dieser Workshop besteht zu 80% aus praktischem Lernen und Übungen.
Kursziele
• Entwickler können danach Backend/Webservices aus Architekten-Sicht für komplizierte
Themen, wie Spring Security, oder NoSQL, selbstständig entwickeln.
Workshop-Inhalte:
• Basic Security
• OAuth basiertes Security
• Entwicklung von NoSQL(MongoDB) Applikationen
• Optimierung von RestAPI-Design: GraphQL
• Praktische Übungen
Zielgruppe
Dieser Kurs richtet sich an Softwareentwickler, Software-Architekten, Software-Designer, System-
Architekten.
Voraussetzungen:
• Kenntnisse über Java und Eclipse
Werkzeug und Unterlagen
Alle Unterlagen und Übungen sind in Deutsch oder Englisch.
Eigene Laptops sind mitzubringen.
Dauer:
2 Tage (maximal 8 Teilnehmer
Seite 11aformatik
2. Theorie Basiswissen
Seminar
Kurs Nr. 100: Objektorientierte Analyse und Design mit der Unified Modeling
Language (UML)
In diesem Kurs erlernen die Teilnehmer die Verwendung der Unified Modeling Language (UML) für die
Verwendung bei der Dokumentation der von Ihnen entwickelten Software. Es wird ein vollständiger
Überblick über die UML Version 1.5 gegeben. Zusätzlich zur Vermittlung der UML werden
grundlegende Konzepte der objektorientierten Softwareentwicklung und Softwaredokumentation
besprochen. Die Vermittlung der UML umfasst sowohl die Analyse als auch das Design
objektorientierter Software.
Die theoretisch vermittelten Inhalte werden in betreuten Übungen vertieft.
Kursziele
• Einblick in die Geschichte und Grundlagen der objektorientierten Softwareentwicklung.
• Verständnis für die Dokumentation von Software.
• Kennen lernen der objektorientierten Analyse und Design.
• Kennen lernen und Einsatz der verschieden UML Diagramme.
• Bewerten des Einsatzes von UML Diagrammen in Softwareprojekten.
Themen
• Einführung in die objektorientierte Begriffswelt und Softwareentwicklung.
• Dokumentation von Software
• Unified Modeling Language (UML)
o Strukturdiagramme
▪ Klassendiagramm (Class)
▪ Objektdiagramm (Object)
▪ Komponentendiagramm (Component)
▪ Einsatzdiagramm (Deployment)
o Verhaltensdiagramme
▪ Anwendungsfalldiagramm (Use-Case)
▪ Sequenzdiagramm (Sequence)
▪ Aktivitätsdiagramm (Activity)
▪ Kollaborationsdiagramm (Collaboration)
▪ Zustandsdiagramm (State)
• Verwaltung von UML Modellen
• Object Constraint Language
• Patterns und UML
• UML im Praxiseinsatz
• Model Driven Architecture
Zielgruppe
Dieser Kurs richtet sich an Softwareentwickler, die Anforderungen an die von Ihnen entwickelte
Software und die Konstruktion Ihrer Software mit der Unified Modeling Language (UML)
dokumentieren möchten.
Voraussetzungen
• Grundlegende Kenntnis der objektorientierten Softwareentwicklung.
• Erfahrung in der Softwareentwicklung.
Werkzeuge und Unterlagen
• In diesem Kurs wird kein Entwicklungswerkzeug (CASE-Tool) verwendet.
• Alle Unterlagen und Übungen sind in deutsch.
• Der Kurs wird in deutsch durchgeführt.
Kursdauer
3 Tage
Seite 12aformatik
3. Java Standard Edition
3.1. Java Grundlagen
Seminar
Kurs Nr. 200: Java für Entscheider
Die Überblicksveranstaltung zeigt Begrifflichkeiten und wichtige Technologien aus der seit Jahren in
der Industrie etablierten Plattform "Java". Ausgehend von strategischen Gesichtspunkten wie
Bedeutung und Verbreitung wird der Blick über das Client-seitige Java (Java SE) und die
wesentlichen Entwicklungswerkzeuge hinüber zum Server-seitigen Java (Java EE) gelenkt. Dort
stehen dann die Bedeutung von Java als Integrationsplattform und die verschiedenen Technologien
im Mittelpunkt. Abschliessend werden noch das Ausrollen von Java-Lösungen und das sehr
interessante Eclipse als Rich-Client besprochen, um dann den Bogen von der Softwareentwicklung
hin zum Betrieb zu schlagen.
Zielgruppe
Personen aus der IT oder IT-nahen Einsatzfeldern, die bislang wenig oder keinen Kontakt mit Java
hatten. Ein gewisses Grundverständnis von Softwareentwicklung und IT-Problematiken wie
Softwareverteilung und Betrieb wird vorausgesetzt.
Objektorientierte Softwareentwicklung
• Bedeutung der Objektorientierung (OO) für die Softwareentwicklung
• Einführung in OO
• Was kann OO leisten, was nicht?
• Vorgehen und Notationen für die OO-Entwicklung
Java
• Einordnung von Java
• Java als Programmiersprache
• Die Java-Plattformen Java ME, Java SE, Java EE
• Einsatzgebiete von Java
• Tools zur Java-Entwicklung (Eclipse, RAD etc.)
• Java Community Process (JCP) – Java als lebendige Sprache
• Java-Performance
Java EE
• Java EE-Philosophie
• Abgrenzung zu .NET
• Architekturen mit Java und Java EE
• Application-Server: Produkte, Aufbau, Deployment, Versionen
• Integrationstechnologien: JDBC, JMS, JCA, JavaMail
• Wichtige Java EE-Technologien
o Servlets und JavaServer Pages (JSP)
o JavaServer Faces (JSF)
o Enterprise JavaBeans (EJB)
o Java Persistence API (JPA)
o WebServices
• Tools zur Java EE-Entwicklung (Eclipse, IBM Rational Application Developer, etc.)
Technologien im Java EE-Umfeld
• Struts
• Spring
• Portale
• Business Process Management
Seite 13aformatik
Java auf Smartphones
▪ Java in der iWelt (iPhone, iOS)
▪ Android
Softwareverteilung
• Methoden der Softwareverteilung in Java
• Rich-Client vs. Web-Anwendung oder Portal
• Applets und WebStart
Eclipse - Ökosystem und RCP
• Bedeutung von Eclipse, Gedanke von RCP
Java im Betrieb
• Was zeichnet Java im Betrieb aus, Betrieb eines Application-Servers
Abschluss
Diskussion, z.B. über kundenspezifische Problemstellungen und deren Umsetzbarkeit in Java
Kursdauer
2 Tage
Seite 14aformatik
Seminar
Kurs Nr. 201: Vorbereitung - Java Programmierung Teil 1
Java hat sich in den letzten Jahren als eine der wichtigsten OO-Sprachen etabliert, insbesondere in
der Web-Programmierung. Dabei spielt neben der Sprache Java insbesondere die Java Plattform eine
Rolle, die den Entwickler auf den vielfältigsten Gebieten mit umfangreichen Klassenbibliotheken,
Frameworks und Architekturen unterstützt.
Unsere Reihe der drei Seminare „Java Programmierung“ geben eine fundierte Einführung in Java. Sie
ist gedacht für Programmierer ohne OO-Erfahrung.
Dieses erste Seminar der Reihe „Vorbereitung - Java Programmierung Teil 1 “ führt in Grundlegendes
der Sprache Java ein und schafft damit eine Basis für die weiteren Seminare dieser Reihe. Das
Seminar richtet sich insbesondere an COBOL- und RPG-Programmierer, die keine oder nur geringe
Kenntnisse in einer Sprache haben, die in ihrer Syntax mit Java vergleichbar ist, so wie C oder
Pascal.
Inhalt
• Die Entwicklung von Java-Programmen
• Grundlegende Elemente eines Java-Programms
• Variablen und symbolische Konstanten
• Die arithmetischen Operatoren
• Typangleichungen und Typkonvertierungen
• Die Vergleichsoperatoren und die logischen Operatoren
• Verzweigungen im Kontrollfluss
• Schleifen
• Arrays
• Routinen und Methoden
• Rekursion
Übungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf deutsch.
Werkzeuge
Als Entwicklungsumgebung wird Eclipse verwendet.
Seminarziel
Die Seminarteilnehmer sind nach dem Seminarbesuch in der Lage, an dem Seminar „Einstieg –Java
Programmierung Teil 2“ teilzunehmen.
Voraussetzung
Das Seminar richtet sich an Programmentwickler, die bislang noch keine oder nur geringe Kenntnisse
in einer Sprache haben, die in ihrer Syntax mit Java vergleichbar ist, so wie C oder Pascal.
Dauer
2 Tage.
Seite 15aformatik
Seminar
Kurs Nr. 202: Einstieg - Java Programmierung Teil 2
Java hat sich in den letzten Jahren als eine der wichtigsten OO-Sprachen etabliert, insbesondere in
der Web-Programmierung. Dabei spielt neben der Sprache Java insbesondere die Java Plattform eine
Rolle, die den Entwickler auf den vielfältigsten Gebieten mit umfangreichen Klassenbibliotheken,
Frameworks und Architekturen unterstützt.
Unsere Reihe der drei Seminare „Java Programmierung“ geben eine fundierte Einführung in Java. Sie
ist gedacht für Programmierer ohne OO-Erfahrung.
Dieses Seminar „Einstieg - Java Programmierung Teil 2“ führt in die grundlegenden OO-Konzepte von
Java ein.
Inhalt
• Die grundlegenden Sprachelemente von Java
• Klassen und Objekte
• Superklassen und Subklassen, Vererbung und Polymorphismus
• Übersetzungseinheiten und Pakete
• Paketierung und Auslieferung fertiger Programme (Deployment)
Das Seminar bietet stoffbegleitend eine Einführung in UML in einem Umfang, der dem Inhalt des
Seminars entspricht.
Übungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf deutsch.
Werkzeuge
Als Entwicklungsumgebung wird Eclipse verwendet.
Seminarziel
Die Seminarteilnehmer sind nach dem Seminarbesuch in der Lage, einfachste Java Anwendungen zu
entwickeln. Das Hauptziel des Seminars ist jedoch im Zusammenhang mit dem weiter führenden
Seminar „Java Programmierung Teil 3 – Aufbau“ zu sehen.
Voraussetzung
Das Seminar richtet sich an Programmentwickler ohne OO Kenntnisse. Erfahrungen in einer gängigen
Nicht-OO-Sprache wie C oder Pascal werden erwartet. Kenntnisse ausschließlich in COBOL oder
RPG reichen als Voraussetzung nicht aus.
Für COBOL- und RPG- Programmentwickler bieten wir als Vorbereitung das Seminar „Java
Programmierer Teil 1 - Vorbereitung“ an.
Dauer
3 Tage.
Seite 16aformatik
Seminar
Kurs Nr. 203: Aufbau – Java Programmierung Teil 3
Java hat sich in den letzten Jahren als eine der wichtigsten OO-Sprachen etabliert, insbesondere in
der Web-Programmierung. Dabei spielt neben der Sprache Java insbesondere die Java Plattform eine
Rolle, die den Entwickler auf den vielfältigsten Gebieten mit umfangreichen Klassenbibliotheken,
Frameworks und Architekturen unterstützt.
Unsere Reihe der drei Seminare „Java Programmierung“ geben eine fundierte Einführung in Java. Sie
ist gedacht für Programmierer ohne OO-Erfahrung.
Dieses Seminar „Aufbau - Java Programmierung Teil 3“ ist eine Fortsetzung des Seminars „Einstieg -
Java Programmierung Teil 2“ und führt in weitere Konzepte von Java und der Java Plattform ein.
Themen
• Zugriffsrechte
• Beziehungen zwischen Klassen
• Abstrakte Klassen und Interfaces
• Einige grundlegende Klassen der Java Plattform
• Arrays
• Collections
• Eingebettete Klassen
• Exceptions (Ausnahmebehandlung)
• Events
• JavaBeans
• Threads
• Eingabe und Ausgabe
• Datenbankzugriff mit JDBC
Übungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf deutsch.
Werkzeuge
Als Entwicklungsumgebung wird Eclipse verwendet.
Seminarziel
Die Seminarteilnehmer sind nach dem Besuch dieses Seminars in der Lage, Java Anwendungen
(Java Applications) zu entwickeln und damit verbundene Architekturen zu bewerten.
Voraussetzung
Das Seminar richtet sich an Programmentwickler mit OO und Java Kenntnisse, die dem Inhalt unseres
Seminars „Java Programmierung Teil 2 - Einstieg“ entsprechen.
Dauer
5 Tage
Seite 17aformatik
Seminar
Kurs Nr. 250: Objektorientierte Programmierung mit Java – Intensivkurs
Java hat sich in den letzten Jahren als eine der wichtigsten OO-Sprachen etabliert, insbesondere in
der Web-Programmierung. Dabei spielt neben der Sprache Java insbesondere die Java Plattform eine
Rolle, die den Entwickler auf den vielfältigsten Gebieten mit umfangreichen Klassenbibliotheken,
Frameworks und Architekturen unterstützt.
Unser Seminar „OOP mit Java“ ist als Intensiv-Seminar gedacht. Es richtet sich an
Programmentwickler, die schon gute Kenntnisse und Erfahrungen in einer anderen OO-Sprache
haben, also an sog. „OO-Umsteiger“.
Inhalt
• Die grundlegenden Sprachelemente von Java
• Klassen und Objekte
• Superklassen, Subklassen und Vererbung
• Abstrakte Klassen und Interfaces
• Innere Klassen (eingebettete Klassen)
• Pakete und Geltungsbereiche, Auslieferung von fertigen Programmen (Deployment)
• Grundlegende Klassen der Plattform
• Arrays und Collections
• Exceptions
• Events
• JavaBeans (die Komponentenarchitektur von Java)
• Eingabe und Ausgabe
• Threads (Multitasking mit Java)
• JDBC (Datenbankzugriff mit Java)
Übungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft.
Werkzeuge
Als Entwicklungsumgebung wird Eclipse verwendet.
Für JDBC wird DB2 UDB eingesetzt.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf Deutsch.
Seminarziel
Die Seminarteilnehmer sind nach dem Seminarbesuch in der Lage, Java Anwendungen zu entwickeln
und damit verbundene Architekturen zu bewerten.
Voraussetzung
Das Seminar richtet sich an Programmentwickler, die gute Kenntnisse und Erfahrungen in einer
anderen OO-Sprache haben.
Dauer
5 Tage.
Seite 18aformatik
3.2. Java Expertenwissen
Seminar
Kurs Nr. 300: Professionelles Java
Das Seminar „Professionelles Java“ ist sowohl Fortsetzung als auch Abrundung des Seminars „Java
Programmierung Teil 3 – Aufbau“ und bietet eine Fülle wichtiger Themen, die für den professionellen
Umgang mit Java unerlässlich sind: Voreinstellungen mit Properties und Preferences, Classloading und
Metainformationen, Internationalisierung, Dokumentieren mit JavaDoc und Testen von Java-
Programmen mit JDK 1.4-Sprachmitteln und JUnit, Logging, das Sandbox-Modell in Java, Serialisierung
und Client-/Server-Programmierung mit RMI, sowie die Softwareverteilung mit Applets oder Java
WebStart. Weitere zentrale Punkte des Seminars sind Betrachtungen zum OO-Design (Gegensatz
Vererbung-Delegation) und eine Einführung in Entwurfsmuster (Design-Patterns).
Themen
• Wichtige Themen aus der Java-Plattform:
▪ Preferences und Properties
▪ Classloading
▪ Meta-Informationen zur Laufzeit
▪ Internationalisierung
▪ Die Java Sandbox
▪ Garbage Collection und das Reference-API
▪ Regular Expressions
• Software-Verteilung und Verteilte Systeme
▪ Serialisierung
▪ RMI
▪ Applets und Java WebStart
• Software-Dokumentation, Test und Logging
▪ JavaDoc
▪ OO-Software testen
▪ Software-Test mit JUnit
▪ Java 1.4-Assertions
▪ Logging mit Java 1.4-Bordmitteln
• OO-Vertiefung
▪ OO-Design (Delegation und Vererbung, Risiken bei Vererbung)
▪ Entwurfsmuster
Übungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf deutsch.
Werkzeuge
Als Entwicklungsumgebung wird Eclipse verwendet.
Seminarziel
Die Seminarteilnehmer sind nach dem Besuch dieses Seminars in der Lage, UML zu lesen und
umzusetzen. Weiterhin haben die Teilnehmer Einblick in wichtige Themen der OO- und Java-
Programmierung erhalten (Logging, Softwareverteilung, Dokumentation, Testen, Design und Design-
Patterns) und können diese bewerten.
Voraussetzung
Das Seminar richtet sich an Programmentwickler mit OO und Java Kenntnisse, die dem Inhalt unserer
Seminare „Java Programmierung Teil 3 – Aufbau“ entsprechen.
Dauer
5 Tage
Seite 19aformatik
Seminar
Kurs Nr. 301: GUIs mit Swing
Das Seminar „GUIs mit Swing“ gibt eine ausfühliche Einführung in die Entwicklung von grafischen
Benutzerschnittstellen in Java.
Themen
• Features und Konzepte
• Container
• Layouting
• Events
• Daten und die Sicht auf die Daten
• Labels, Icons und Images
• Buttons
• Menus und Tool Bars
• Actions
• Die einfachen Text-Komponenten
• Bounded-Range Components
• Lists und List Models
• Combo Boxes und Combo Box Models
• Spinners
• Tables und Table Models
• Table Rows und Columns
• Table Rendering und Editing
• Trees
• Dialogs
• Formatted Text Fields
Übungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf deutsch.
Werkzeuge
Als Entwicklungsumgebung wird Eclipse verwendet.
Seminarziel
Die Seminarteilnehmer sind nach dem Besuch dieses Seminars in der Lage, Java Anwendungen
(Java Applications) mit grafischen Benutzerschnittstellen zu erstellen. Anhand von zahlreichen
anschaulichen Beispielen wird Swing in seinen verschiedenen Facetten vertieft.
Voraussetzung
Das Seminar richtet sich an Programmentwickler mit OO und Java Kenntnissen, die dem Inhalt
unseres Seminars „Aufbau - Java Programmierung Teil 3 “ oder unseres Seminars „OOP mit Java“
entsprechen.
Dauer
5 Tage
Seite 20aformatik
Seminar
Kurs Nr. 350: Android Grundlagen für Java Entwickler
Seit die Open Handset Alliance rund um Suchmaschinen- und Online-Werbungsgigant Google 2008
seine erstes in Deutschland erhältliches Smartphone mit dem Android OS vorstellte wächst die Zahl der
Geräte und Formfaktoren mit großer Geschwindigkeit. Die Anzahl an verfügbaren Anwendungen
("Apps") steigt stark an und auch in der Unternehmenspraxis, so sind sich Analysten einig, wird man
um Geräte und Anwendungen für das Android OS nicht herumkommen ("consumerized IT"). In dieser
3 Tage dauernden Schulung werden die Grundlagen der Entwicklung von Applikationen für Android
OS gelegt und darauf aufbauend eine praxisnahe Applikation mit Server-Anbindung an einen REST-
Service entwickelt.
Inhalt
• Hintergrundwissen über Android
• Android Tools
• Android Konzepte
• Implementierung einer REST-basierten Applikation
• Zugriff auf verschiedene Gerätefunktionen
Übungen
Die im Theorieteil vorgestellten Konzepte werden anhand eines praxisnahen Beispiels praktisch
umgesetzt.
Seminarunterlagen
Die Seminarunterlagen sind auf Deutsch.
Werkzeuge
Als Werkzeug kommt die Eclipse IDE mit dem Android SDK zum Einsatz.
Seminarziel
Die Teilnehmer verfügen über Grundlagenwissen über die Entwicklung für das Androide OS,
grundlegenden Konzepte und haben bereits eine praxisnahe erste App entwickelt.
Voraussetzung
Das Seminar richtet sich an Entwickler, die über grundlegende, praktische Kenntnisse der
Programmiersprache Java verfügen.
Dauer
3 Tage
Seite 21aformatik
4. Java Enterprise Edition
Seminar
Kurs Nr. 400: Java EE 5 - Web Applikationen
Java EE ist die Plattform für Enterprise Web-Anwendungen. Das Seminar bietet einen Überblick über
die momentane Welt der Web-Anwendungen mit Java auf Plattformen nach Wahl der Kursteilnehmer
(z.B. Eclipse, RAD v7, Tomcat, SUN Glassfish, IBM WebSphere) und vertieft diesen anhand eines
durchgängigen Übungsbeispiels. Die im Seminar gestreiften Themen werden durch einen Ausblick
auf das aktuelle Java EE-Oberflächen-Framework JSF (JavaServer Faces) abgerundet.
Bei Interesse kann noch ein optionaler Überblick über Struts 1.x angeboten werden.
Inhalt
• Überblick über Java EE und Application Server
• HTTP
• Servlets und ihre Rolle als managed Components
• Session-Tracking
• JSP, Architekturen mit Servlets und JSPs, Model-View-Controller (MVC)
• Die JSP-Expression-Language und der Umgang mit Beans
• Tag-Libraries, Custom-Tags, Simple Tags, Tag Files, Functions
• Packaging von Custom Tag Libraries
• Die JSP Standard Tag-Library (JSTL)
• Architekturen und Design von Web-Anwendungen
• Mehrsprachigkeit
• Browserbasierte Geschäftsprozesse
• Kommunikation mit Java EE Ressourcen (wie z.B. DataSources)
• Filter und Listener
• Einführung in JSF
• (Einführung in Struts)
• Deployment auf einen Application Server, z.B. Tomcat, Glassfish, WebSphere
Übungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft, wobei während des Seminars ein durchgängiges Beispiel erarbeitet wird.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf deutsch.
Werkzeuge
Laufzeitumgebung ist während des Entwickelns und Testens entweder der Tomcat Web-Application-
Server 6.0, SUN Glassfish 2 oder IBM WebSphere Application Server 6.1. Als Entwicklungsumgebung
wird Eclipse 3.3 mit dem Eclipse Web-Tools-Plugin oder der Rational Application Developer V7 (RAD
7) verwendet.
Seminarziel
Die Seminarteilnehmer sind nach dem Seminarbesuch in der Lage, Web-basierte Anwendungen mit
Eclipse zu entwickeln und damit verbundene Architekturen zu bewerten.
Voraussetzung
Das Seminar richtet sich an Entwickler, die schon erste Erfahrungen mit Java gesammelt haben.
Dauer
5 Tage.
Seite 22aformatik
Details zu den Übungen
Ziel der Übungen ist der sukzessive Aufbau einer Web-Applikation, an der nach und nach
verschiedene Techniken erprobt werden. Als Szenario dient das Modell einer Bibliotheksverwaltung,
in der Bücher gesucht und von verschiedenen Personen ausgeliehen werden können. Schritt für
Schritt wird so die Funktionalität der Applikation erweitert oder es werden technologische Alternativen
erkundet.
Folgende Inhalte sind unter anderem vorgesehen:
• Suche und Anzeige: Bücher können nach Stichwörtern oder Autoren gesucht und in einer
Detailansicht angezeigt werden.
• Warenkorb: die Buchsuche wird um eine Ausleihliste ergänzt.
• JSP: Die Auftragsbestätigung wird als JSP umgesetzt.
• Serverseitiges Model-View-Controller: die Detailseite als MVC mit JSP und Servlet.
• Custom Tags und JSTL: die Anwendung wird um höherwertige, eigene Tags ergänzt.
• Web-Architekturen: die Applikation wird in eine moderne, robuste Architektur redesigned.
• Internationalisierung: die Einstiegsseite wird mehrsprachig.
• Browserbasierte Geschäftsprozesse: die Applikation wird auf Schwachstellen untersucht und an
einigen Stellen exemplarisch umgebaut.
• Kommunikationen: es wird gezeigt, wie Servlets mit dem "hinteren" Teil der Java EE
(DataSources) kommunizieren.
• JSF: exemplarischer Aufbau der bisherigen Applikation mit JSF.
• optional: (Struts: expemplarischer Aufbau der Applikation mit Struts 1.x)
Seite 23aformatik
Seminar
Kurs Nr. 451: Java EE – JPA und Enterprise JavaBeans
Die Java Enterprise Edition (Java EE) ist die Plattform, auf der heute moderne verteilte und
skalierbare Systeme erstellt werden. Zentrale Bestandteile dieser Plattform bilden das neue,
einheitliche Persistenzframework Java Persistence API (JPA) und die Enterprise JavaBeans
Komponenten-Architektur (EJB).
Unser Seminar "Java EE - JPA und Enterprise JavaBeans" basiert auf Java EE 6, bzw. der EJB 3.1-
Spezifikation, und führt allgemein in die Konzepte für die Persistenzschicht und der Enterprise
JavaBeans ein. Anhand von verschiedenen Übungen wird der Seminarteilnehmer nach und nach mit
den Begriffen und Technologien dieser wichtigen, serverseitigen Architektur vertraut gemacht.
Inhalt
▪ Die Java EE-Plattform und der Application-Server
▪ JPA-Basisbegriffe: EntityManager, LifeCycle und Callbacks
▪ Mapping von Daten, Beziehungen und Vererbung
▪ Datenzugriff mit JPQL und nativem SQL
▪ JPA-Transaktionen
▪ Komponentenbegriff
▪ SessionBeans: Stateful, Stateless, Singletons
▪ Client-Zugriff: Remote, Local und NoInterface-View
▪ Dependency-Injection und JNDI
▪ Neue Variante der Dependency-Injection mit CDI
▪ Asynchrone Methoden
▪ WebService-Schnittstellen für EJBs
▪ EJBs als verteilte, transaktionale Komponenten, Zugriff auf Datenbanken über DataSources
▪ Einbettung von JPA
▪ Exception-Handling
▪ JMS und Message-Driven Beans
▪ Timer-Services und die Scheduler Syntax
▪ Interceptors
▪ Anbindung an Legacy-Systeme über JCA
▪ Security im EJB-Container
▪ Ausblick auf EJB 3.2
Übungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf deutsch.
Werkzeuge
Als Entwicklungsumgebung wird ein "Eclipse für Java EE Developer" inkl. JBoss-Tools verwendet. Als
Laufzeitumgebung dient während des Entwickelns und Testens JBoss 7 oder Wildfly 8.
Als Persistenzframework wird anfänglich Hibernate im Standalonebetrieb eingesetzt.
Seminarziel
Die Seminarteilnehmer sind nach Seminarbesuch in der Lage, einfache, auf JPA und Enterprise
JavaBeans basierende, Anwendungen zu entwickeln und damit verbundene Architekturen zu
bewerten.
Voraussetzung
Das Seminar richtet sich an Programmentwickler mit OO und Java Kenntnissen, die dem Inhalt
unseres Seminars "Aufbau - Java Programmierung Teil 3" oder unseres Seminars "OOP mit Java"
entsprechen. Der Besuch des komplementären Seminars "Java EE Web-Applikationen" ist hilfreich,
aber nicht vorausgesetzt.
Dauer
5 Tage.
Seite 24aformatik
5. Weiterführende Schulungen
Workshop
Kurs Nr. 500: Struts basierte Software-Entwicklung
Mit der JAVA EE und den heutigen Entwicklungswerkzeugen ist eine leistungsfähige Basis verfügbar,
um Enterprise Web-Anwendungen zu erstellen. Die Erfahrung mit dieser etablierten Technologie hat
gezeigt, dass für sich wiederholende Aufgaben immer wieder ähnlicher Code implementiert wurde.
Auch gestaltet sich die Anpassung einer Anwendung an sich ändernde Unternehmensprozesse mit
der bisherigen JAVA EE Technologie unter Umständen schwierig.
Diese Lücke möchte das OpenSource Framework Struts schließen und erfreut sich dabei einer immer
größer werdenden Fangemeinde, sowohl bei den JAVA EE Entwicklern, als auch bei den Tool-
Herstellern.
Inhalt des Workshops
• Das Struts Framework im Überblick
• MVC in Struts
• Die Struts JSP Custom Tag-Libs
• Web-Formulare
• Die Möglichkeiten der Eingabevalidierung von Struts Web-Formularen
• Fehlerbehandlung
• Internationalisierung
• Einbau von eigenen Struts Erweiterungen
• Die Jakarta Commons Bibliotheken in Struts
• GUI Templates mit Tiles
• Werkzeuge für die Struts Entwicklung (Eclipse, WSAD, OpenSource Produkte)
• Logging und Debugging in einer Struts-Anwendung
Voraussetzungen
• HTML Grundkenntnisse
• Java Kenntnisse
• JAVA EE Web Kenntnisse (Servlet und JSP)
• Von Vorteil: Kenntnisse im Umgang mit Eclipse oder dem Rational Application Developer
Übungen
Die einzelnen im Vortrag behandelten Themen werden an einem durchgängigen Beispiel praktisch
geübt. In den Übungen wird ein Währungsumrechner realisiert.
Dauer:
3 Tage
Seite 25aformatik
Workshop
Kurs Nr. 501: Design Patterns in Java
Design Patterns sind ein immer wichtiger werdender Bestandteil moderner Software, da durch sie zum
einen häufig auftretende Probleme in genau umrissenen Lösungen angegangen werden können, zum
anderen aber dienen Patterns heute auch als gemeinsames Vokabular für Software-Entwickler und –
Architekten. Design Patterns sind die grobkörnigen Bausteine, die heutige Softwarelösungen
zusammenhalten und den Blick vom Detail aufs Wesentliche lenken.
Dieser Workshop vermittelt Ihnen einen Überblick über wichtige Patterns, die Sie für die Entwicklung
zukunftsfähiger Java Programme benötigen.. Die vorgestellten Software-Patterns reichen von Code
Patterns, die Ihnen eine robuste Implementierung ermöglichen, bis hin zu Design Patterns für
Anwendungsarchitekturen. Alle wichtigen Grundlagen werden in vertiefenden Übungen angewendet.
Am Ende des Workshops können Sie Design Patterns anwenden, bewerten und erhalten somit ein
mächtiges Werkzeug, ihre Softwareentwicklung durch höhere Abstraktion noch flexibler, wartbarer
und somit zukunftsfähiger zu machen.
Themen
• Entstehung und Begriffe der Pattern Welt
• Design Patterns Grundlagen
• Patterns für die Objekterzeugung
• Struktur Patterns
• Verhaltens Patterns
• Patterns für Enterprise Anwendungen
• Patterns für die Persistenzschicht
• Patterns in der Anwendungslogik
• Patterns in der Präsentationsschicht
• Ausblick auf weiterführende Patterns
Zielgruppe
Erfahrene Java Entwickler, die Ihre Software nach aktuellen Prinzipien entwerfen und entwickeln
möchten.
Voraussetzungen
Dieser Workshop richtet sich an erfahrene Java Entwickler. Kenntnisse in der Entwicklung mit der
Java 2 Enterprise Edition sind von Vorteil. Erfahrungen in der Benutzung einer
Entwicklungsumgebung, vorrangig Eclipse oder WebSphere Studio, sind vorteilhaft.
Unterlagen und Werkzeuge
In diesem Kurs verwendete Unterlagen sind in deutsch. Für die Durchführung der Übungen wird
Eclipse oder wahlweise ein darauf aufbauendes
Werkzeug (IBM Rational Application Developer) in einer aktuellen Version verwendet.
Dauer
2 Tage
Seite 26aformatik
Kurs Nr. 503: Einführung in das Persistenz-Framework Hibernate
Hibernate ist ein mächtiges und performantes Framework zur Persistierung von puren Java-Objekten
auf relationale Datenbanken. Es beinhaltet verschiedene Möglichkeiten des Mappings (deklarativ
anhand von XML-Dateien, programmatisch und unterstützt auch den zukünftigen Persistenzstandard
EJB 3.0). Datenbank-Anfragen können ebenfalls auf verschiedene Weise umgesetzt werden.
Hibernate ist weit verbreitet und hat sich als „quasi Standard“ durchgesetzt. Als lebendiges Open-
Source Projekt bietet es eine guten Support durch die Gemeinschaft der Entwickler.
Unser Kurs Hibernate bietet einen grundlegenden Einstieg und liefert das Handwerkzeug für den
Einsatz im Projekt.
Inhalt
• Installation
• Konfiguration
o Properties
o XML
o Programmatisch
o JDBC / Datasource
• Einbettung in eine JAVA EE-Umgebung
• Mapping
o XML
o Programmatisch
o Assoziationen
• Anfragen
o Criteria
o Query By Example
o Hibernate Query Language
o Native SQL
Voraussetzungen
• Java Kenntnisse
• SQL Grundkenntnisse
• XML Grundkenntnisse
Übungen
Die einzelnen im Vortrag behandelten Themen werden an einem durchgängigen Beispiel praktisch
geübt.
Dauer
2 Tage
Seite 27aformatik
Seminar
Kurs-Nr. 511: JavaServer Faces V2.0/2.2
JavaServer Faces (JSF) ist ein komponentenbasiertes Framework für die Entwicklung von
Webanwendungen. Mit der Version 2 wurden neue Möglichkeiten und Verfahrensweisen hinzugefügt,
die eine bessere Integration in die Java EE-Welt ermöglichen und auch moderne AJAX-Features
unterstützen. Die Version 2.2 bietet weitere Verbesserungen und interessante neue Features.
Das Seminar gibt einen Überblick über die Funktionsweise von JSF 2 und stellt sukzessiv in einzelnen
Schritten die Aspekte vor, die notwendig sind, um mit JSF komplexe, Facelet-basierte
Webanwendungen schreiben zu können und bei Bedarf benutzerspezifische Komponenten (sog.
Composite Components) zu erstellen.
Es wird im Einzelnen darauf hingewiesen, wenn JSF 2.2-spezifische Features besprochen werden, so
dass dieser Kurs auch als Einführung in JSF 2.0 mit Ausblick auf JSF 2.2 genutzt werden kann.
Inhalt
• JavaServer Faces im Überblick
• Oberflächenkomponenten - die Grundlagen
• Arbeiten mit Managed-Beans und der Expression Language
• CDI
• Oberflächenkomponenten – Details
• Facelets und Templates
• Ressourcen und Contracts
• Parameterübergabe
• Durchführung von Konvertierungen und Validierungen
• Internationalisierung
• Der JSF-Lifecycle
• Fehlerbehandlung
• Custom Components (inkl. Composite Components)
• AJAX-Features
• JSF 2.2 Flows
• Security
Übungen
Die behandelten Themen werden durch zahlreiche praktische Übungen am Rechner vertieft.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf Deutsch.
Werkzeuge
Laufzeitumgebung ist während des Entwickelns und Testens ein gängiger Application-Server.
Angeboten werden u.a. JBoss/Wildfly oder IBM Websphere Application Server. Als
Entwicklungsumgebungen stehen Eclipse for Java EE Developers oder der IBM Rational Application
Developer (RAD) zur Verfügung.
Seminarziel
Die Seminarteilnehmer sind nach Seminarbesuch in der Lage, einfache, auf JPA und Enterprise
JavaBeans basierende, Anwendungen zu entwickeln und damit verbundene Architekturen zu
bewerten.
Voraussetzung
Das Seminar richtet sich an Entwickler, die schon Erfahrungen mit dem Erstellen von
Webanwendungen auf Java-Basis (Servlets, JSPs) gesammelt haben. JSF-Kenntnisse sind nicht
erforderlich.
Dauer
4 Tage.
Seite 28aformatik
Seminar
Kurs Nr. 520: Einführung in Spring
Das Open-Source-Framework Spring ist seit Jahren sowohl ein mächtiger und flexibler Ersatz für Java
2 Enterprise Edition (JAVA EE) Umgebungen als auch eine gute Ergänzung innerhalb von JAVA EE-
Architekturen. Viele unrunde oder wenig durchgängig konsistente Features der JAVA EE können durch
den Einsatz von Spring angenehm und einfach gestaltet werden. Die Modulatität von Spring ermöglicht
es dem Java-Entwickler, das Framework für viele unterschiedliche und auch kleine Einsatzgebiete zu
nutzen, ohne die Nachteile solcher allumfassenden Monolithen wie JAVA EE und deren Komplexität in
die Projekte hineinzutragen.
Das Seminar bietet einen ersten Überblick und Einstieg in das Core-Framework von Spring und
erkundet auch die Bereiche der Persistenzschicht mit JDBC und der Java Persistence API (JPA).
Inhalt
Einführung
▪ Eine erste Tour (Installation, Konfiguration, erster Einsatz, das Bean-Konzept)
▪ Core I (Dependency-Injection, Wiring)
▪ Core II (Bean-Erzeugung, Kontext-Objekte, Annotations, Umgang mit Ressourcen)
▪ Optional: Aspektorientierung (AOP) in Spring
▪ Spring-Unterstützung für JDBC
▪ Spring und JPA
▪ Transaktionsmanagement mit SpringÜbungen
Die im Theorieteil besprochenen Konzepte werden durch zahlreiche praktische Übungen am Rechner
vertieft.
Seminarunterlagen
Die kompletten Seminarunterlagen sind auf deutsch.
Werkzeuge
Als Entwicklungsumgebung wird wahlweise Eclipse mit Spring-Plugin oder die SpringSource Tool
Suite verwendet.
Seminarziel
Die Seminarteilnehmer sind nach Seminarbesuch in der Lage, einfache, auf Spring basierende,
Anwendungen zu entwickeln und damit verbundene Architekturen zu bewerten.
Voraussetzung
Das Seminar richtet sich an Entwickler mit guten Java Kenntnissen und Programmiererfahrung.
Vorzugsweise Kenntnisse aus unseren Seminaren "Java-Programmierung 1 – 3" und "Professionelles
Java", bzw. gleichwertige Kurse. Weiterhin sind JPA-Kenntnisse erforderlich.
Dauer
2 Tage.
Seite 29Sie können auch lesen
