Akademi Isparta


Introducing the Java and Oracle Platforms
Identifying the key elements of the Java environment
The benefits of using Java
The Java SE Java Development Kit
Using Java with Oracle JDeveloper (
Defining Object Oriented Principles
Defining objects and understand how they are used
Defining classes and understand how they are used
Defining the O-O principles of Abstraction, Inheritance, Encapsulation, Aggregation, and Polymorphism
Introducing the course application class model
Basic Java Syntax and Coding Conventions
Introducing basic source and byte file structure
Describing the basic language syntax
Java file structure (package, import, class)
Defining Classes
Specifying Methods (entry method main)
Placing comments in Java code
Establishing Naming Conventions
Declaring variables
Exploring Primitive Data Types and Operators
Primitive data types
What are variables?
Declaring and initializing variables
What are literals?
What are operators?
Controlling Program Flow
Using Flow Control in Java
Decisions: if, switch, conditional operator
Repetition: while, do-while, for
The break statement
Building Java Applications Using Oracle JDeveloper (
Exploring the JDeveloper Environment
Creating applications
Specifying Project Properties
Examining the Directory structure
New Code Editor Features
Using the Help System
Using the JDeveloper Debugger
Creating Classes and Objects
Using Java classes
Defining instance variables and instance methods
Creating objects using new and the default Constructor
Declaring Instance Variables
Calling instance methods
Applying Encapsulation in Java
What are Class Variables?
What are Class Methods?
Class Loading, Object Life Cycle, and Inner Classes
Method Overloading
The 'this' keyword
What are constructors?
Defining Inner and Anonymous Classes
The finalize method
Using Strings, String Buffer, Wrapper, and Text-Formatting Classes
The Java String class
String conversion and comparison
Overview of wrapper classes
Conversions to and from primitive types using wrapper classes
Formatting classes
About streams
Sets of I/O Classes
Reusing Code
Specifying Inheritance in Java
The super reference
Over-riding super class methods
Browsing super class references with Oracle JDeveloper (
Acme Video and Polymorphism
Limiting methods and classes with final
What are Java Beans?
Steps to build and use a Java Bean in JDeveloper
Using Arrays and Collections
What is an Array?
Multidimensional arrays
Using Vectors
Collections framework components
Using Integrators
Structuring code using Abstract Classes and Interface
Defining Abstract classes
Defining Abstract methods
Creating Interfaces
The Sortable Interface
Throwing and Catching Exceptions
How does Java handle exceptions?
Catching and handling exceptions
Ensuring code is executed using a finally block
Creating exceptions
Accessing the Database with JDBC
Connecting to a database with Java
What is JDBC?
Registering the Driver
Getting a database connection
Creating a Statement
Executing a SQL statement
The Prepared Statement object
Pooling connections
User Interface Design: Planning a Form Layout
Running Java UI Applications
Swing features
Planning the UI layout
Swing Containers
Using Frames or Dialogs
Adding Components with Oracle JDeveloper (
Adding User Interface Components and Event Handling
Swing Components
Swing Components in JDeveloper
Adding a component to a form
The Java Event model
Adding event handlers using Oracle JDeveloper
Model View Controller Principles using a List Component
Deploying Applications using Java Web Start
What is Java Web Start?
Deploying Applications with JDeveloper
Creating the Deployment Profile file
Making an executable .JAR file
Creating and deploying the archive file
Using JDeveloper to deploy an application to Java Web Start

OracleAS 10g: Oracle ADF for Java Developers

Oracle ADF Introduction and JDeveloper
ADF architecture and its MVC relationship
ADF Business Components: characteristics
ADF Faces: characteristics
ADF data binding
Defining the Application Pageflow
The role of JSF and ADF Faces
Creating JSF Pages
Adding JSF navigation cases to the diagram
Including notes and attachments to the diagram
Using ADF Faces Components
UI components
Page structure
Rich Internet components
UIResources file
Exploring ADF Business Components
Using Database connections
Creating applications, projects and applications
Entity Objects
View Objects
Application Modules
The ADF BC Browser (tester)
Debugging business components using the tester
Customize EO for Security
Developing Entity Objects
Creating the data model using entity objects
Defining attribute default values
Refining the associations between entities
Incorporating Validation in the data model
Using custom properties
Creating a Container to hold the data model (application module)
Determining EO to table relationships – best practices
Presenting and Packaging the Data Model with View Objects
Declaratively creating view objects
Creating view objects using SQL statements
Customizing Attribute Definitions
Linking view objects
Creating and passing parameter values
Managing Applications with Application Modules
Components of an application module
Nesting application modules
Creating and exposing custom methods
Modeling relationship types
Renaming views and associations
Expose Business Components as data controls
Building efficient AMs and view objects – best practices
Binding UI Components to Data Sources
Adding lookup view objects to the application module
Utilizing ADF databinding
Binding data using ADF
Binding Editor
Creating custom data controls
Developing a Simple Page with ADF Faces
Creating the Page Outline
Adding UI Components to the Page
Creating the Edit and View Buttons
Adding Command Buttons to the Page
Running and Testing the Page
Creating a Master-Detail Page
Creating the Data View
Developing the Basic UI
Adding the Master component as a Form
Adding the Notes Panel
Adding the Detail component as a Table
Linking the Page to the Application
Implementing Transactional Capabilities
Custom method to the application module
Set a date when the user is assigned
Create the Data View components
Develop the Create Page
Develop the Confirmation Page
Develop the Done Page
Pass values in a two page create transaction
Add a create button to Search page
Passing Values within a Page
Defining the search method view object
Creating a search form to enter the search criteria
Using the page definition to bind LOV values
Set LOV values to be dynamic or static
Creating a table to display the returned records
Creating Application Events in JSF
JSF Lifecycle events
Creating event listeners
Validating JSF components
Converting data
Action Listeners
Deploying ADF Applications
Deployment options for an ADF application
Deploy an ADF application
Export methods from view objects and application modules
Deploy an application module to Oracle Application Server 10g
Using Web Services with ADF Applications
Service Oriented Architecture
Web services
Calling a web service from an ADF application
Exposing an application module as a web service

OracleAS 10g: Build J2EE Applications

Course Objectives
Review of J2EE Architecture
Set Up the Server Environment
Set Up the Development Environment
Designing J2EE Applications
Using a Model View Controller (MVC) Design Approach
Implementing a Session Facade Pattern
Describing EJB Types and EJB 3.0 Annotations
Explaining the Role of JMX, JCA, and JAAS
Configuring Data Sources
Choosing a JDBC Driver
Creating a Connection Pool
Creating a Managed Data Source
Testing the Managed Data Source in Application Server Control
Creating EJB Entities
Creating EJB 3.0 Entities
Selecting a Primary Key Field
Performing O-R Mapping with Annotations
Mapping Relationships Between Entities
Creating Stateless and Stateful Session Beans
What is a Session Bean?
Creating Stateless and Stateful Session Beans using Annotations
Understanding Passivation and Activation of Stateful Session Beans
Using Interceptor Methods and Classes
Accessing Resources with JNDI and Dependency Injection
Describing the Java Naming and Directory Interface
Locating Resources and EJBs using JNDI and Dependency Injection
Working with JNDI Enhancements in OC4J
Manipulating and Querying with the Entity Manager API
What is Entity Manager?
Looking Up an Entity Manager Reference Using JNDI
Using the Entity Manager API to Manage Entities
Executing Dynamic Queries Using the Query API
Writing Simple EJB QL Queries
Writing EJB Query Language Statements
Writing Unconditional EJB QL Statements
Writing Conditional EJB QL Statements
Writing EJB QL Queries That Traverse Entity Relationships
Writing EJB QL in Named Query Annotations
Using the Query API to Execute Dynamic EJB QL Statements
Communicating with Message-Driven Beans
Features of a Messaging System
Java Message System (JMS) Architecture
Configuring a JMS Service
Creating a Message-Driven Bean
Creating a JMS/MDB Client
Managing Transactions with Session and Message-Driven Beans
Choosing the Appropriate Type of Transaction Management
Setting the Transaction Attribute for Container-Managed Transactions
Creating Transaction Demarcations
Configuring the OC4J Transaction Manager
Scheduling Tasks and Jobs for J2EE Applications
Why EJB Timers?
Developing EJB Timers
Comparing the EJB-Specification Timer-Service and the OC4J EJB Timer-Service
Overview of the Oracle Application Server Job Scheduler
Securing J2EE Applications with JAAS
Overview of J2EE Security Architecture
Java Authentication and Authorization Service
Configuring Web-tier Application Security
Configuring EJB Application Security
Deploying J2EE Applications
Planning Deployment
Packaging Business-Tier Components
JSR-88 Deployment Plans
Creating and Managing Deployment Plans

OracleAS 10g: Build Web Services

Introduction to Web Services
Course Objectives
What Is a Web Service?
Identifying Web Service Standards
J2EE Web Service APIs
Oracle Application Server 10g: Web Services Architecture
Exploring Web Service Technologies
Communication with SOAP
Defining a Web Services Description Language (WSDL) document
Alternate strategies to invoke Web services
RPC-Style and Document-Style Web Services
UDDI Registry
Developing Web Services
Web Service Development Approach
Developing a Web Service by Using the Bottom-Up Approach
Invoking the Web Service with a Java Client Application
Developing a Web Service by Using the Top-Down Approach
Troubleshooting a Web Service
Developing a Web Service by Using the JSR-181 Annotations
Web Service Metadata for Java Platform (JSR-181)
Developing a Web Service by Using JSR-181 Annotations
Exposing EJB 3.0 as a Web Service
Developing Database Web Services
Database Call-In and Call-Out
Publishing SQL Query as a Web Service
Publishing a PL/SQL Package as a Web Service
Securing a Web Service with WS-Security
Web Service Security Approaches
What Is WS-Security?
Configuring WS-Security for a Web Service
Configuring WS-Security for a Web service Client
Managing Web Service Quality of Service
What Is WS-Reliability?
Web Service Quality of Service (QoS)
WS-Reliability Messaging Model
Configuring WS-Reliability for a Web Service
Auditing and Logging Web Service SOAP Content
What Is Auditing?
Configuring the Server for Auditing
What Is Logging?
Configuring Logging for a Web Service
Advance Web Service Features
Testing for WS-Interoperability
Developing a Web Service with MIME Attachments
Assembling a REST Web Service
Incorporating a Web Service Invocation Framework (WSIF) based client to dynamically invoke a Web service.