.Net Profesyonelleri için Java EE

Kurs Dili: Türkçe/İngilizce

Süre: 10 gün

Bu kurs, Java EE geliştirme platformunu kullanarak güvenilir, ölçeklenebilir ve güvenli uygulamalar geliştirmek isteyen deneyimli .Net profesyonelleri için gereken temel becerileri kazandırmaya çalışan hızlandırılmış bir eğitim programı sunmaktadır. Kurs, Java platformu ve anahtar Java API'leri (EJB, Servlet ve JSP'ler, JNDI, Spring, Hibernate, vd.) konusunda uygulamalı bir içerik sağlamakta ve bu teknolojilerin güvenli, verimli ve yönetilebilir web uygulamaları geliştirmek üzere nasıl değerlendirileceğini katılımcılarına aktarmaktadır. Yaklaşık olarak %50 laboratuvar ve %50 teknik/teorik derslerden oluşan bu kurs, dikkatle seçilmiş birçok laboratuvar egzersizi ve uygulama içermektedir. Sistematik bir biçimde birbirine eklenerek işlenen bloklar şeklinde hazırlanan kursta laboratuvar çalışmaları, ileri düzeyde çok-katmanlı uygulamaların geliştirme ve uyarlama süreçlerini başlangıç fazından sonuna kadar incelemektedir. Konu ve uygulamaların anlaşılmış olduğundan emin olmak üzere katılımcılar her laboratuvar seansının sonunda bir dizi sorudan oluşan testlere tabi tutulmaktadır. Uygulamalı bir ortamda çalışmak suretiyle katılımcılar, kurs kapsamında öğrenilen kavramları ve edinilen becerileri kullanarak çok-katmanlı, web-tabanlı e-ticaret uygulamaları tasarlamakta ve geliştirmektedir. Kurs süresince eğitmenimiz kritik Java EE mimarisi ile önemli tasarım hususları konusunda katılımcıları bilgilendirmekte, pratikte uygulanan yöntem ve tekniklerle birlikte kaçınılması gereken temel hataları da katılımcılarla paylaşmaktadır. Katılımcıların deneyimli .Net yazılım geliştiriciler olduğu varsayımıyla kursun ilk günü Java dili ve platformuna giriş ile başlamaktadır. Kurs daha sonra Java EE platformu ve Java Enterprise sürümünün temel mimarisi ile devam etmektedir. Bunu takiben katılımcılar farklı teknolojiler üzerinde eğitilmektedir:

• İyi bir tasarım ve mimariye sahip, ölçeklenebilir Web uygulamaları inşa etme,
• Dağıtık nesnelerden oluşan ölçeklenebilir kümeler inşa etmek üzere EJB çerçevesinin kullanılması,
• O/R uygulaması ile veritabanı erişimi için Java Persistent API'lerin kullanılması,
• JAX-WS kullanımı.

• Etkileşimli Web uygulamaları geliştirmek üzere Java ile Ajax'a giriş
• Spring'e giriş (özellikle Spring'in güçlü Web uygulama desteği)

Kimler katılabilir? Bu kurs, ileri J2EE kavramlarını öğrenmek ve gerekli becerileri hızlı bir şekilde edinmek isteyen yazılım geliştiriciler için tasarlanmış, orta-ileri düzeyde bir Java eğitim kursudur. İdeal olarak katılımcıların Java uygulama geliştirme ve 2-3 katmanlı dağıtık uygulamalar konusunda en az 1 yıl deneyime sahip ve istemci-sunucu mimarisine aşikar olmaları beklenmektedir. Veritabanı API'leri kurs kapsamında işlenecek olmakla birlikte veritabanı uygulamaları geliştirme konusunda deneyim, kurstan daha fazla verim alınması bakımından yararlı olacaktır.

Kurs İçeriği

Session 1: Getting started with Java

Lesson: The Java Platform

• Understand what Java is
• Understand the role of the JVM
• Understand the development steps
• Which Tools to use
• Understand how to setup your (development) environment

• Use the command line compiler to compile a Java class.
• Use the command line Java interpreter to run a Java application class.
• Correctly set up the CLASSPATH environment variable to allow the compiler and interpreter to run correctly.

• Write a class that does not explicitly extend another class.
• Define instance fields for a class.
• Implement a main method to create an instance of the defined class.

• Write a class with accessor methods to read and write private instance fields.
• Write a constructor to initialize an instance with data.
• Write a constructor that calls other constructors of the class to benefit from code reuse.
• Use the this keyword to distinguish local variables from instance fields.

• List the four arithmetic operators.
• List the three operators to increment and decrement numbers.
• List the six comparison operators.
• List the two logical operators.
• Name the return type of the comparison and logical operators.
• Use one of the increment operators to increment an integer.
• Write a for loop that can iterate a specified number of times.

• Create an instance of the String class.
• Test if two String objects are equal.
• Test if two String objects are the same object.
• Get the length of a String object.
• Parse a String object for its token components.
• Perform a case-insensitive equality test.
• Build up a String object using a StringBuffer object.
• Build up a String object using a StringBuilder object.
• Understand the difference between the StringBuffer and StringBuilder
• Convert between String and StringBuffer/StringBuilder.

• Convert String representations of primitive numbers into their corresponding wrapper.
• Convert String representations of primitive numbers into their primitive types.
• Appreciate auto unboxing a wrapper to its primitive type
• Use the Date class to get the current time and date.
• Use the Date class to determine if one Date is earlier or later than another.

• Declare an array reference.
• Allocate an array.
• Initialize the entries in an array.
• Appreciate the extended for-loop for iterating over an array

• Use the package keyword to define a class within a specific package.
• Explain the effects of the four levels of accessibility.
• Use the import keyword to declare references to classes in a specific package.
• Use the standard type naming conventions when creating packages, classes, and methods.
• Correctly execute a Java application class that is defined in a package.

• Initialize instance fields to default values.
• Distinguish between instance fields and method variables within a method.
• Initialize method variables prior to use.
• Explain the difference between the terms field and variable.
• List the default values for instance fields of type String, int, double, and boolean.
• Name the keyword used to create constants in Java.

• Create static fields in a class.
• Explain one use of static fields.
• Create static methods in a class.
• Explain one benefit of static fields.
• Understand the concept of a static import
• Appreciate enums
• Explain the syntax used to reference static fields and methods.

• Construct a class that extends another class.
• Correctly implement equals and toString.
• Write constructors that pass initialization data to the parent constructor as appropriate.
• Use instanceof to verify the class type of an object reference.
• Override subclass methods and use the super keyword to leverage behaviors in the parent.
• Safely cast references to a more refined type.

• Write a subclass with a method that overrides a method in the superclass.
• Group objects by their common supertype.
• Utilize polymorphism by correctly invoking subclass method implementations through superclass references.
• Safely cast a supertype reference to a valid subtype reference.
• Use the final keyword on methods and classes to prevent overriding through subclassing.

• Define supertype contracts using interfaces.
• Define supertype contracts using abstract classes.
• Implement concrete classes using interfaces.
• Implement concrete classes using abstract classes.
• Explain one advantage of interfaces over abstract classes.
• Explain one advantage of abstract classes over interfaces.

• Understand what generics are
• Understand how te create generic classes
• Understand how te create generic methods
• Understand generic wildcards
• Understand how to use generics

• Define a try/catch block that allows methods that throw exceptions to be called.
• Correctly implement try/catch blocks for methods which throw multiple exceptions.
• Name the exception supertype which is not checked for by the compiler.
• Correctly implement a method which throws exceptions.
• Correctly override a method which throws exceptions.

• Understand how How to throw exceptions.
• Define your own application exceptions.
• Introduce the assert keyword

• Read/Write byte data into a buffer
• Read/Write character data to a buffer
• Read/Write objects to a buffer

• Create a file in the file system
• Create a directory in the file system
• List the contents of a directory
• Read and write text to a file

• Connect to a database using JDBC.
• Execute a statement against a database that returns a ResultSet.
• Extract multiple rows of data from a ResultSet, where each column value is represented as a String.

• Get a complete technical overview of the Java EE Platform
• Understand how each tier is addressed in Java EE
• Understand the architectural role of each of the technologies
• Understand the concept of the EAR and the deployment descriptors
• Understand the relationship between Java EE and Web Services
• Understand what Dependency Injection is
• List the supporting technologies (JMX, JACC, JTA, etc.)
• List the different versions of J2EE and Java EE and the related versions and APIs

• Position Java EE and Enterprise JavaBeans
• Explain the need for Enterprise JavaBeans
• Define purpose of Enterprise JavaBeans.
• Understand the key features of the EJB Specification.
• Explain how EJB and CORBA relate
• Explain how EJBs relate to "ordinary" JavaBeans.

• List the four client types
• List the primary components in an EJB server.
• List services the container may provide to the bean.
• List the four components the EJB developer is responsible for providing.
• Describe ways session, entities and message driven beans differ.
• Describe the relationship between Web Services and Enterprise Java Beans
• Describe the purpose of the EJB jar file.
• List the mandatory four objects per bean included in an EJB jar file.

• List the super classes for your home and remote interfaces.
• Understand the life-cycle of a session bean
• Add a session bean in WSAD
• Add a session bean in RAD
• Configure a session bean in RAD
• Describe the four methods provided to clients by the superclass to your home interface.
• Describe the five methods provided to clients by the superclass to your remote interface.
• Name the one exception that all methods in both interfaces must declare, and explain why.
• Explain why a bean does not implement these interfaces.

• Explain the differences between a system error and an application error.
• Explain which exceptions should be thrown to indicate system errors.
• Explain which exceptions should be thrown to indicate application errors.
• Describe how the container handles exceptions thrown by a bean.

• List the four methods in the SessionBean interface.
• List the sequence of six steps that are performed to create a session bean instance in the server.
• Describe the difference between a stateful and a stateless session bean.
• Explain how the bean provider specifies the state management type.
• Explain one advantage of stateful session beans.
• Explain one advantage of stateless session beans.
• Explain how to configure bean passivation

• Name the four significant values that make up the structural information for a bean.
• Show how to add environment information to the deployment descriptor.
• Add bean and resource factory references.
• Show how to provide assembly information, resolving references to external beans, web services and resource factories.
• List three values the deployer cannot change.
• Write a deployment descriptor for a session bean.
• Successfully deploy a session bean to a server.
• Control session bean lifetimes in WebSphere
• Manage bean caching strategies in WebSphere
• Define WebSphere's Activity sessions
• Control session bean lifetimes in WebSphere
• Manage bean caching strategies in WebSphere
• Define WebSphere's Activity sessions

• Write local interfaces for an enterprise bean.
• Name two advantages of local interface access.
• Name one disadvantage of local interface access.

• Understand the concept of Timer Services
• Introduce the API

• Show an example of how to implement a web service as a Stateless Session Bean
• Show how to write the web service endpoint
• Show how to write the Session Bean implementation for a web service endpoint
• Understand the restrictions placed upon the arguments and return types.
• Understand which clients can access your bean
• Understand the relationship between JSR109 and JSR153

• Define Object to Relational (O/R) Mapping (ORM)
• Define the Hibernate Architecture
• Illustrate the benefits of using Hibernate
• Understand the goals of Hibernate
• Understand key functionalities of Hibernate
• Define the different Hibernate types (Entities and values)
• Understand different Persistent representations (POJOs, Maps and XML)

• Understand the nuts and bolts of Hibernate
• Understand how to map a class to the database
• Understand the configurations involved and their relationships
• List different ways of configuring Hibernate
• Understand the overall syntax of the Hibernate Configuration file
• Understand the overall syntax of a mapping file
• Introduce the org.hibernate.SessionFactory
• Introduce the org.hibernate.Session
• Understand one way of obtain a session using Hibernate contextual sessions
• Supply a basic example of using Hibernate

• Configure persistent classes
• Configure persistent state of a class
• Understand the requirements for a persistent entity class
• Understand object identity in Hibernate
• Understand how to correctly implement equals and hashCode in Hibernate
• Discuss object identity and a caveat in hashCode and equals implementations
• Discuss different ways of generating unique numbers for keys
• Understand how to influence mapping to columns
• Understand how to map properties of a class to multiple tables

• Understand how to map composition using Hibernate's components
• Understand how to use components as composite identifiers
• Understand the different collection types supported
• List different element types: simple types, composite types and entities
• Understand programming restrictions when using collections
• Understand how to map java.util.Set and java.util.List
• Understand how to position elements explicitly in the List
• Understand how to map java.util.SortedSet
• Understand how to correctly use a Comparator
• Understand how to map a java.util.Map
• Understand how to map the key of the map
• Understand Hibernate's bags
• Introduce Dynamic components

• List the different types of associations
• Understand the difference between uni and bidirectional associations
• Understand how to map unidirectional one to one, many to one and one to many associations
• Understand how and when to use join tables
• Understand how to map many-to-many associations
• Understand how to configure bidirectional associations
• Understand how to cascade over associations

• Discuss the three Inheritance ORM strategies
• Discuss the Single Table Inheritance Pattern (i.e. table per class hierarchy)
• Discuss the Class Table Inheritance Pattern (i.e. table per subclass)
• Discuss the Concrete Table Inheritance Pattern (i.e. table per concrete class)
• Discuss Hibernate's implicit polymorphism strategy
• Understand how to configure these mappings
• Understand the concept of a discriminator

• Understand the concept of dynamic web applications
• List the Web technologies in Java EE 5
• Understand for each their purpose and architectural position
• Get an overview of the deployable unit of a web application
• Explain the principles of Servlet and JSP
• Introduce JSF

• Introduce the Model 2 Architecture (MVC for the web)
• Understand the architectural relation between Servlets and JSP
• Understand the responsibilities and typical implementation technology of each element in Model 2
• Understand how to write a Servlet to process a form
• Understand how to configure a Servlet in de web.xml deployment descriptor
• Understand the basic Servlet API
• Understand how to write a JSP
• Understand the different techniques available in JSP
• Introduce attributes, their scope and their role in the Model 2 architecture
• Introduce the use and syntax of Unified Expression Language
• Introduce JSP standard actions
• Introduce JSTL
• Mention and discuss language based scripting

• Understand what JAX-WS is
• Understand the JAX-WS Architecture in detail
• Understand the JAX-WS 2.1 Specification
• Understand the role of WSDL
• Discuss bottom-up versus top-down service realization
• Overview of the WSDL and Java Mapping and vice versa
• Introduce the two APIs (client/service side)

• Introduce Ajax and its principles
• Understand the technologies involved
• Understand the architecture of Ajax
• Make a first Ajax enabled web page
• Introduce the W3C XMLHttpRequest (XHR)
• Understand the XHR API and lifecycle
• Discuss security restrictions on Ajax

• Use XML requests and response
• Introduce W3C DOM
• Understand the DOM Levels and browser support
• Use DOM to create and parse XML documents
• Understand and address browser differences in using DOM
• Understand how to use Web Services and REST in conjunction with Ajax
• Introduce JSON
• Ajaj: Receive and use JSON

• Ajax Toolkits (Dojo)
• Direct Web Remoting (DWR)
• Understand the DWR architecture
• Understand the workings of DWR
• Configure a Web Application and DWR
• Understand how to use DWR
• Use Java objects as argument and return types
• Advanced DWR configuration