Object-Oriented Analysis and Design Using UML JAVA ARCHITECT.pdf · juego de abstracciones clave...

Copyright © 2013, Oracle. All rights reserved.

Oracle University | Contact Us: +52 1 55 8525 3225

Object-Oriented Analysis and Design Using UML

Duration: 5 Days

What you will learn

El curso Análisis y Diseño Orientados a Objetos mediante UML (Unified Modeling Language) proporciona formación y

experiencia práctica, centrándose en el uso eficaz de las tecnologías orientadas a objetos y un uso juicioso del

modelado de software en su aplicación al proceso de desarrollo de software. Este curso con instructor utiliza clases

teóricas, discusiones en grupo y actividades guiadas para presentar una guía básica de análisis y diseño orientados a

objetos (OOAD) práctica y completa que abarca desde la recopilación de requisitos hasta el diseño del sistema. El

curso proporciona un acercamiento pragmático al desarrollo de software orientado a objetos (OO) siguiendo patrones,

principios y tecnologías OO demostrados y aplicables a los lenguajes OO, como el lenguaje de programación Java

(TM).

Los alumnos disfrutarán de las ventajas de utilizar el lenguaje de modelado gráfico con amplia implantación, el lenguaje

unificado de modelado (UML) versión 2.2, que les permitirá comunicar conceptos y decisiones, entender el problema y

la solución propuesta, así como gestionar la complejidad de los artefactos describiendo el problema y la solución

propuesta. El curso está estructurado de tal manera que se sigue una forma genérica del proceso de desarrollo de

software que se centra en los aspectos de análisis y diseño aplicables a un proyecto de software OO. Este proceso

genérico se puede adaptar fácilmente a los procesos concretos, que se tratarán posteriormente en el curso. El curso

también permite comprender los patrones y marcos que pueden permitir la creación de componentes de software más

flexibles y reutilizables.

Alumnos para los que se ha diseñado el curso:

Arquitectos de sistemas, ingenieros de software, analistas de sistemas y diseñadores responsables de la concepción y

creación de aplicaciones de software orientadas a objetos.

Los arquitectos responsables de la concepción y creación de aplicaciones de software orientado a objetos también se

pueden beneficiar de este curso.

Learn To:

Utilizar tecnologías orientadas a objetos

Utilizar el lenguaje unificado de modelado 2.2

Realizar análisis y diseño orientados a objetos

Seguir un proceso de desarrollo de software utilizando un proyecto de software OO

Related Training

Required Prerequisites

Comprender los aspectos básicos del proceso de desarrollo de sistemas

Comprender los conceptos y la metodología orientados a objetos

Demostrar un conocimiento general sobre programación, preferiblemente utilizando el lenguaje de programación Java

http://education.oracle.com/pls/web_prod-plq-dad/db_pages.getpage?page_id=3


Course Objectives

Analizar los requisitos del sistema para determinar los casos de uso y el modelo de dominio del dominio del problema

(modelo de requisitos)

Crear una arquitectura de sistema (modelo de arquitectura) que soporte los requisitos no funcionales (NFR) y las

restricciones de desarrollo

Crear un diseño de sistema (modelo de solución) que soporte los requisitos funcionales (FR)

Describir el proceso de desarrollo de software orientado a objetos, incluidas las metodologías y flujos de trabajo

orientados a objetos

Recopilar los requisitos del sistema a través de entrevistas con los participantes

Course Topics

Examen de Terminología y Conceptos Orientados a Objetos

Describir los conceptos orientados a objetos (OO) importantes

Describir la terminología OO fundamental

Introducción al Modelado y al Proceso de Desarrollo de Software

Describir el proceso de desarrollo de software orientado a objetos (OOSD)

Describir la forma en que el modelado soporta el proceso OOSD

Describir las ventajas del modelado de software

Explicar la finalidad, actividades y artefactos de los siguientes flujos de trabajo OOSD (disciplinas): recopilación de requi

Creación de Diagramas de Casos de Uso

Justificar la necesidad de utilizar un diagrama de casos de uso

Identificar y describir los elementos esenciales de un diagrama de casos de uso UML

Desarrollar un diagrama de casos de uso para un sistema de software basado en los objetivos del propietario del negoci

Desarrollar elaborados diagramas de casos de uso basados en los objetivos de todos los participantes

Reconocer y documentar las dependencias de casos de uso utilizando la notación UML para ampliaciones, inclusiones y

Describir la forma de gestionar la complejidad de los diagramas de casos de uso mediante la creación de vistas UML em

Creación de Escenarios y Formularios de Casos de Uso

Identificar y documentar escenarios para un caso de uso

Crear un formulario de caso de uso que describa el resumen de los escenarios en los flujos principal y alternativo

Describir la forma de hacer referencia a casos de uso incluidos y ampliables

Identificar y documentar requisitos no funcionales (NFR), reglas de negocio, riesgos y prioridades para un caso de uso

Identificar la finalidad de un documento de especificaciones complementarias

Creación de Diagramas de Actividades

Identificar los elementos esenciales de un diagrama de actividades

Modelar un flujo de casos de uso de eventos utilizando un diagrama de actividades

Determinación de las Abstracciones Clave Identificar un

juego de abstracciones clave candidatas Identificar las

abstracciones clave mediante el análisis CRC


Construcción del Modelo de Dominio del Problema

Identificar los elementos esenciales de un diagrama de clases UML

Construir un modelo de dominio utilizando un diagrama de clases

Identificar los elementos esenciales de un diagrama de objetos UML

Validar el modelo de dominio con uno o varios diagramas de objetos

Transición del Análisis al Diseño mediante Diagramas de Interacción

Explicar el propósito y los elementos del modelo de diseño

Identificar los elementos esenciales de un diagrama de comunicación UML

Crear una vista de diagrama de comunicación del modelo de diseño

Identificar los elementos esenciales de un diagrama de secuencias UML

Crear una vista de diagrama de secuencias del modelo de diseño

Modelado del Estado del Objeto con Diagramas de Máquina de Estados

Modelar el estado del objeto

Describir los elementos esenciales de un diagrama de máquina de estados UML

Aplicación de Patrones de Diseño al Modelo de Diseño

Definir los elementos esenciales de un patrón de software

Describir el patrón compuesto

Describir el patrón de estrategia

Describir el patrón observador

Describir el patrón de fábrica abstracto

Introducción a los Diagramas y Conceptos Arquitectónicos

Distinguir entre arquitectura y diseño

Describir niveles, capas y cualidades sistémicas

Describir el flujo de trabajo de arquitectura

Describir los diagramas de las vistas de arquitectura clave

Seleccionar el tipo de arquitectura

Crear los artefactos del flujo de trabajo de arquitectura

Introducción a los Niveles Arquitectónicos

Describir los conceptos de los niveles de cliente y de presentación

Describir los conceptos del nivel empresarial

Describir los conceptos de los niveles de recursos e integración

Describir los conceptos del modelo de solución

Acotación del Modelo de Diseño de Clases

Acotar los atributos del modelo de dominio

Acotar las relaciones del modelo de dominio

Acotar los métodos del modelo de dominio

Acotar los constructores del modelo de dominio

Anotar el comportamiento del método

Crear componentes con interfaces

Visión General Sobre los Procesos de Desarrollo de Software

Explicar las prácticas recomendadas de las metodologías OOSD

Describir las funciones de varias metodologías comunes

Elegir la metodología que mejor se adapte al proyecto

Desarrollar un plan de iteración


Visión General de los Marcos

Definir un marco

Describir las ventajas y desventajas del uso de marcos

Identificar varios marcos comunes

Comprender el concepto de creación de sus propios marcos de dominio de negocio

Revisión del Curso

Revisar las funciones clave de la orientación a objetos

Revisar los principales diagramas UML

Revisar los flujos de trabajo de análisis de requisitos (análisis) y diseño

Copyright © 2013, Oracle. All rights reserved. Page 1

Oracle University | Contact Us: 001-855-844-3881

Java EE 7: Front-end Web Application Development

Duration: 5 Days

What you will learn

This Java EE 7: Front-end Web Application Development training helps you explore building and deploying enterprise

applications that comply with the Java Platform, Enterprise Edition 7 Web Profile. Expert Oracle University instructors

will help you explore annotations, Session Enterprise JavaBeans (EJB-Lite), Java Persistence API (JPA), servlets,

JavaServer Pages(JSPs), Contexts and Dependency Injection (CDI), JAX-RS RESTful web services, the Java API for

WebSocket and the Java API for JSON processing.

Learn To:

Develop web-based interfaces for both desktop and mobile devices.

Assemble an application.

Build Java applications.

Deploy an application into an application server (Java EE platform runtime environment).

Benefits to You

By taking this course, you'll gain hands-on experience building Java EE web applications. You will get the chance to

create web-based user interfaces using HTML5 and JavaScript along with JSPs and servlets. Web-based user

interfaces will use AJAX to communicate with RESTful web services you create; data will persist using JPA and

optimistic locking.

Participate in Hands-On Labs

By learning through hands-on exercises via structured labs, you'll get a chance to explore EJB-Lite session bean

components, which can be used with container-managed transactions. You'll perform lab exercises using the NetBeans

IDE and WebLogic Server.

J2EE Developer

Java Developers

Java EE Developers

Web Administrator

Related Training


Able to author HTML, CSS, and JavaScript enabled web pages

Basic understanding of database concepts and SQL syntax



Experience with Java SE, or Java Programmer Certification

Understand object-oriented principles

Java SE 8 Programming

Suggested Prerequisites

Experience with an Integrated Development Environment

JavaScript and HTML5: Develop Web Applications

Course Objectives

Create and use Java annotations

Select the correct Java EE Profile for a given application

Develop and run an EJB technology application

Create Java EE technology applications with the Java EE 7 Platform

Identify the services provided by an Application Server

Package, deploy and debug enterprise applications

Create web-based user interfaces using Servlet, JSP, JAX-RS, and JavaScript technologies

Access relational databases using the Java Persistence API

Create scalable, transacted business logic with EJB-Lite

Develop basic Java Persistence API entity classes to enable database access

Develop a web-based user interface using Servlets, JSPs, and JAX-RS

Design applications to use dependency injection

Use IDEs and Application Servers for Java EE development

Course Topics

Java Platform, Enterprise Edition

The Java EE Platform

The needs of enterprise application developers

Java EE specifications

A comparison of services and libraries

The Java EE Web Profile

Java EE application tiers and layers


Enterprise Development Tools and Applications

The purpose of an application server

Starting and stopping WebLogic Server

Properties of Java EE components

The development process of a Java EE application

Configuring and packaging Java EE applications

JavaBeans, Annotations, and Logging

Java SE features used in Java EE applications

Creating POJO JavaBeans components

Using Logging

Using Common Java Annotations

Develop custom annotations

The role of annotations in Java EE applications

Java EE Web Architecture

The HTTP request-response model

Differences between Java Servlets, JSP, and JSF components

Application layering and the MVC pattern

Avoiding thread safety issues in web components

Use the Expression Language

Developing Servlets

The Servlet API

Request and response APIs

Set response headers

Two approaches to creating a response body

Uploading files using a servlet

Forwarding control and passing data

Using the session management API

Developing with JavaServer Pages

The role of JSP as a presentation mechanism

Authoring JSP view pages

Processing data from servlets in a JSP page

Using tag libraries

JAX-RS Web Services The need

for web services Designing a

RESTful web service

Create methods that follow the prescribed rules of HTTP method behavior

Create JAX-RS resource and application classes

Consume query and other parameter types

Produce and consume complex data in the form of XML

HTTP status codes

Java RESTful Clients

Pre-JAX-RS 2 Clients: HttpUrlConnection and the Jersey Client API

The JAX-RS 2 Client API

HTML5 Applications with JavaScript and AJAX

HTML DOM manipulation with JavaScript


RESTful clients with JavaScript (AJAX)

Limitations of JavaScript clients

The Same-Origin policy and CORS

WebSocket and the Java API for JSO Processing

Web Service Limitations

WebSocket Explained

Creating WebSockets with Java

Client-side WebSokect with JavaScript

Client-side WebSocket with Java

Consuming JSON with Java

Producing JSON with Java

Implementing a Security Policy

Container-managed security User

roles and responsibilities Create a

role-based security policy The

security API

POJO and EJB-Lite Component Models

The role of EJB components in Java EE applications

The benefits of EJB components

Operational characteristics of stateless and stateful session beans

Creating session beans

Creating session bean clients

The Java Persistence API

The role of the Java Persistence API in Java EE applications

Basics of Object-relational mapping

The elements and environment of an entity component

The life cycle and operational characteristics of entity components

Implementing a transaction policy

Transaction semantics

Programmatic vs. declarative transaction scoping Using

JTA to scope transactions programmatically Implementing

a container-managed transaction policy Optimistic locking

with the versioning of entity components Pessimistic

locking using EntityManager APIs

The effect of exceptions on transaction state

Related Courses

Java EE 6: Develop Web Services with JAX-WS & JAX-RS


Oracle University | Contact Us: 800-260-690


Duration: 5 Days

What you will learn

This Java EE 6 programming course covers the design and creation of SOAP and RESTful web services and clients.

You'll use the NetBeans Integrated Development Environment (IDE) to develop JAX-WS and JAX-RS web services and

deploy those services to Oracle WebLogic Server 12c. The majority of topics covered are portable across all application

servers which support the Java EE 6 web service standards.

Learn To:

Create XML documents and XML schemas while using XML Namespaces.

Produce and consume JSON and XML using JAXB.

Understand WSDL files and the role they play in SOAP based web services and select either a top-down (WSDL first) or

bottom-up (code first) approach to the development of SOAP web services.

Make calls to and implement web services based on SOAP standards using JAX-WS (Metro Stack).

Implement REST practices in the creation of web services with the JAX-RS specification (Jersey Stack).

Secure web services using Java EE Security standards, WS-Security extensions, and OAuth 1.0a.

Benefits to You

Java EE 6 technology facilitates cross-platform application development through the use of platform neutral network

communication, supports HTML5 AJAX enabled applications and mobile clients by creating RESTful web services which

use the JSON data-interchange format. Enrolling in this course will help you stay current on the latest Java EE 6 web

service APIs.

Audience

J2EE Developer

Java Developers

Java EE Developers

Related Training


Java SE7 Fundamentals



Java Design Patterns

Java SE 7: Develop Rich Client Applications



Oracle Certified Associate, Java SE 7 Programmer

Oracle Certified Professional, Java SE 7 Programmer

Tutorials available on the Oracle Learning Library

Course Objectives

Apply the JAX-RS API in the creation of RESTful Web Services

Secure Web Services using WS-Security, Jersey, and OAuth

Handle errors and exceptions in Web Services and clients

Create XML documents using namespace declarations and XML schema

Produce and consume XML and JSON content using JAXB

Create RESTful Web Service clients using the Jersey Client API

Understand the role of Web Services

Apply the JAX-WS API in the creation of SOAP Web Services and clients

Course Topics

An Introduction to Web Services

Explaining the need for web services

Defining web services

Explaining the characteristics of a web service

Explaining the use of both XML and JSON in web services

Identifying the two major approaches to developing web services

Explaining the advantages of developing web services within a Java EE container

XML

Describing the Benefits of XML

Creating an XML Declaration

Assembling the Components of an XML Document

Declaring and Apply XML Namespaces

Validating XML Documents using XML Schemas

Creating XML Schemas

JAXB

Listing the Different Java XML APIs

Explaining the Benefits of JAXB

Unmarshalling XML Data with JAXB

Marshalling XML Data with JAXB

Compiling XML Schema to Java

Generating XML Schema from Java Classes


Applying JAXB Binding Annotations

Creating External Binding Configuration Files

SOAP Web Services

SOAP message structure

Using WSDL files to define web services

WS-I Basic Profile and WS-Policy

Creating JAX-WS Clients

Using tools to generate JAX-WS client artifacts

Calling SOAP web services using JAX-WS in a Java SE environment

Calling SOAP web services using JAX-WS in a Java EE environment

Using JAXB Binding customization with a SOAP web service

Creating a JAX-WS Dispatch client

Creating a client that consumes a WS-Policy enhanced services (WS-MakeConnection)

RESTful Web Services

Describing the RESTful architecture and how it can be applied to web services

Designing a RESTful web service and identify resources

Navigating a RESTful web service using hypermedia

Selecting the correct HTTP method to use when duplicate requests must be avoided

Identifying Web Service result status by HTTP response code

Version RESTful web services

Creating RESTful Clients in Java

Using Java SE APIs to make HTTP requests

Using the Jersey Client APIs to make HTTP requests

Processing XML and JSON in a RESTful web service client

Bottom-Up JAX-WS Web Services

Describing the benefits of Code First Design

Creating JAX-WS POJO Endpoints

Creating JAX-WS EJB Endpoints

Top-Down JAX-WS Web Services

Describing the benefits of WSDL First Design

Generating Service Endpoint Interfaces (SEIs) from WSDLs

Implementing Service Endpoint Interfaces

Customizing SEI Generation

JAX-RS RESTful Web Services

Download, Install, and Configure Jersey

Creating Application Subclasses

Creating Resource Classes

Creating Resource Methods, Sub-Resource Methods, and Sub-Resource Locator Methods

Producing and Consume XML and JSON content with JAX-RS

Web Service Error Handling

Describing how SOAP web services convey errors

Describing how REST web services convey errors

Returning SOAP faults

Returning HTTP error status codes


Mapping thrown Exceptions to HTTP status codes

Handling errors with SOAP clients

Handling errors with Jersey clients

Security Concepts

Explaining Authentication, Authorization, and Confidentiality

Applying Basic Java EE Security by using deployment descriptors (web.xml)

Creating users and groups and map them to application roles

Detailing possible web service attack vectors

WS-Security

Describing the purpose of WS-Policy, WS-SecurityPolicy, WS-Security

Configuring WebLogic Server for WS-Security

Applying WS-Policy to WebLogic JAX-WS Web Services

Signing and Encrypt SOAP Messages using WS-Security

Web Service Security with Jersey

Applying JSR-250 Security Annotations such as @RolesAllowed

Enabling an assortment of filters including the RolesAllowedResourceFilterFactory

Obtaining a SecurityContext and perform programmatic security

Authenticating using the Jersey Client API

OAuth 1.1a with Jersey

Describing the purpose of OAuth

Describing the request lifecycle when using OAuth

Creating OAuth enabled services using Jersey

Creating OAuth enabled clients using Jersey

mailto:@RolesAllowed



Java EE 6: Develop Database Applications with JPA

Duration: 4 Days

What you will learn

This Java EE 6: Develop Database Applications with JPA NEW training explores using the Java Persistence API within

the context of a web-based Java Enterprise Edition application, as well as within a stand-alone Java Standard Edition

application. This includes using Java Persistence API with the Enterprise JavaBeans technology.

Learn To:

Update multiple database tables based on relationships.

Perform CRUD operations with JPA in Java SE and EE environments.

Perform data validation using Bean Validation.

Optimize JPA for performance.

Apply transactions and locking.

Map relational database tables to Java using ORM techniques and JPA.

Understand key concepts found in the Java Persistence API.

Create robust entity models.

Create static and dynamic queries using Java Persistence API Query Language.

Create type-safe queries with the Java Persistence API Criteria API.

Benefits to You

Learn how to accelerate the development of applications that use relational databases by mapping tables and table

relationships to Java objects using Java Persistence API. You will also see how JPA solves issues with traditional

relational database applications, including SQL injection.

JPA Enhancements

JPA has been enhanced and simplified in Java EE 6. The Java Persistence API (JPA) version 2.0 specification

facilitates more effective and reliable (that is, more strongly typed) methodology for building object-centric criteria-based

dynamic database queries.

JPA was introduced in Java EE 5, and provides a POJO-based persistence model for Java EE and Java SE

applications.

Relational Data Mapping

Persistence is the technique through which object models broker the access and manipulation of information from a

relational database. JPA handles the details of how relational data is mapped to Java objects, and it standardizes

Object/Relational mapping.



Audience

Database Designers

J2EE Developer

Java Developer

Java EE Developer

Related Training


Experience with Java EE 6 platform recommended

Experience with Java programming

Experience with Relational Databases recommended


Developing Applications with Java EE 6 on WebLogic Server 12c


Experience building and deploying EE applications

Experience with NetBeans recommended

Oracle WebLogic Server 12c Basic Administration Tasks OBEs

Course Objectives

Map relational database tables to Java using ORM techniques and JPA

Perform CRUD operations with JPA in Java SE and EE environments

Update multiple database tables based on relationships

Perform data validation using Bean Validation

Apply transactions and locking

Optimize JPA for performance

Course Topics

Course Introduction

Describing the target audience for this course

Explaining the course itinerary

Describing the format that the class will use

Introducing the course environment

Describing the need for Object-Relational Mapping


Introduction to Java Persistence API

Describing the Java Persistence API

Creating entity classes

Using persistent field and properties

Using a generated primary key (table, sequence and identity)

Obtaining an Entity Manager

Creating a Persistence Unit

Using an entity manager to create, find, update, and delete entities

Creating typed queries in JPA

Working with JPA in a Java Enterprise Environment

Evaluating the role of the container with JPA

Accessing JPA entities from a servlet

Evaluating the application of JSF as a user interface framework

Accessing JPA entities from Enterprise JavaBeans

Determining the impact of using stateless, stateful, and singleton session beans on entities

Configuring a persistence context in an EE context

Introduction to the Auction Application Case Sudy

Describing the auction application

Defining the domain objects of the auction application

Describing the implementation model for the auction system

Modeling Relational Databases with JPA Entities

Examining relationships in the data and object models

Using relationship properties to define associations

Implementing one-to-one unidirectional and bidirectional associations

Implementing many-to-one/one-to-many bidirectional associations

Implmenting many-to-many unidirectional and bidirectional associations

Using OrderBy and OrderColumn annotations to define sort order

Applying the OrphanRemoval annotation to prevent orphaned entities

Working with the Entity Manager

Describing the relationship between an entity and an entity manager, and between a persistence context and a persisten

Differentiating between transaction-scoped and extended entity managers

Describing the entity life cycle

Using entity manager operations to perform CRUD operations: persist, find, merge, remove

Examining the role of the entity manager with detached entities

Defining and use cascading operations

Persisting Enums and Collections

Persisting entities that contain enums

Persisting entities that contain collections

Persisting entities that contain Maps

Creating Queries with the Java Persistence Query Language (JPQL)

Describing the Java Persistence Query Language (JPQL)

Contrasting JPQL with native queries

Using conditionals to filter results

Refining queries to return only needed data

Performing joins between entities

Creating dynamic queries with parameters


Using named queries

Performing bulk updates and deletes

Using the Critieria API

Contrasting the Critiera API with JPQL

Using the Critieria API structure and core interfaces

Creating SELECT, FROM, and WHERE clauses

Creating paths and expressions

Using ORDER BY, GROUP BY, and HAVING clauses

Using the canonical metamodel

Implementing Bean Validation with JPA

Describing the JPA lifecycle phases where validation takes place

Creating an entity listener class

Utilizing validation groups

Using built-in validation constraint annotations provided by Bean Validation

Creating a custom Bean Validation constraint

Applying Locking and Transactions

Describing transaction semantics

Comparing programmatic and declarative transaction scoping

Using JTA to scope transactions programmatically

Implementing a container-managed transaction policy

Supporting optimistic locking with the versioning of entity components

Supporting pessimistic locking by using EntityManager APIs

Describing the effect of exceptions on transaction state

Advanced Modeling: Entity Inheritance Relationships

Evaluating object-relational mapping strategies for entity inheritance

Applying single-table-per-class, joined-subclass, and table-per-class inheritance mapping strategies

Using embeddable classes

Overriding mappings with the @AttributeOverride and @AssociationOverride annotations

Specifying composite primary keys

Optimizing JPA Performance

Using lazy fetching to prevent the loading of entities that are not being used

Using pagination to control the amount data that is needed at any one time

Modifying queries to prevent the N + 1 problem

Creating read-only queries

Describing performance issues associated with IDENTITY ID generation

Creating and using stored procedures with JPA and EclipseLink

Using cache optimizations with JPA and EclipseLink

mailto:@AssociationOverride



Java EE 7: Front-end Web Application Development

Duration: 5 Days

What you will learn

This Java EE 7: Front-end Web Application Development training helps you explore building and deploying enterprise

applications that comply with the Java Platform, Enterprise Edition 7 Web Profile. Expert Oracle University instructors

will help you explore annotations, Session Enterprise JavaBeans (EJB-Lite), Java Persistence API (JPA), servlets,

JavaServer Pages(JSPs), Contexts and Dependency Injection (CDI), JAX-RS RESTful web services, the Java API for

WebSocket and the Java API for JSON processing.

Learn To:

Develop web-based interfaces for both desktop and mobile devices.

Assemble an application.

Build Java applications.

Deploy an application into an application server (Java EE platform runtime environment).

Benefits to You

By taking this course, you'll gain hands-on experience building Java EE web applications. You will get the chance to

create web-based user interfaces using HTML5 and JavaScript along with JSPs and servlets. Web-based user

interfaces will use AJAX to communicate with RESTful web services you create; data will persist using JPA and

optimistic locking.

Participate in Hands-On Labs

By learning through hands-on exercises via structured labs, you'll get a chance to explore EJB-Lite session bean

components, which can be used with container-managed transactions. You'll perform lab exercises using the NetBeans

IDE and WebLogic Server.

J2EE Developer

Java Developers

Java EE Developers

Web Administrator

Related Training


Able to author HTML, CSS, and JavaScript enabled web pages

Basic understanding of database concepts and SQL syntax



Experience with Java SE, or Java Programmer Certification

Understand object-oriented principles



Experience with an Integrated Development Environment

JavaScript and HTML5: Develop Web Applications

Course Objectives

Create and use Java annotations

Select the correct Java EE Profile for a given application

Develop and run an EJB technology application

Create Java EE technology applications with the Java EE 7 Platform

Identify the services provided by an Application Server

Package, deploy and debug enterprise applications

Create web-based user interfaces using Servlet, JSP, JAX-RS, and JavaScript technologies

Access relational databases using the Java Persistence API

Create scalable, transacted business logic with EJB-Lite

Develop basic Java Persistence API entity classes to enable database access

Develop a web-based user interface using Servlets, JSPs, and JAX-RS

Design applications to use dependency injection

Use IDEs and Application Servers for Java EE development

Course Topics

Java Platform, Enterprise Edition

The Java EE Platform

The needs of enterprise application developers

Java EE specifications

A comparison of services and libraries

The Java EE Web Profile

Java EE application tiers and layers


Enterprise Development Tools and Applications

The purpose of an application server

Starting and stopping WebLogic Server

Properties of Java EE components

The development process of a Java EE application

Configuring and packaging Java EE applications

JavaBeans, Annotations, and Logging

Java SE features used in Java EE applications

Creating POJO JavaBeans components

Using Logging

Using Common Java Annotations

Develop custom annotations

The role of annotations in Java EE applications

Java EE Web Architecture

The HTTP request-response model

Differences between Java Servlets, JSP, and JSF components

Application layering and the MVC pattern

Avoiding thread safety issues in web components

Use the Expression Language

Developing Servlets

The Servlet API

Request and response APIs

Set response headers

Two approaches to creating a response body

Uploading files using a servlet

Forwarding control and passing data

Using the session management API

Developing with JavaServer Pages

The role of JSP as a presentation mechanism

Authoring JSP view pages

Processing data from servlets in a JSP page

Using tag libraries

JAX-RS Web Services The need

for web services Designing a

RESTful web service

Create methods that follow the prescribed rules of HTTP method behavior

Create JAX-RS resource and application classes

Consume query and other parameter types

Produce and consume complex data in the form of XML

HTTP status codes

Java RESTful Clients

Pre-JAX-RS 2 Clients: HttpUrlConnection and the Jersey Client API

The JAX-RS 2 Client API

HTML5 Applications with JavaScript and AJAX

HTML DOM manipulation with JavaScript


RESTful clients with JavaScript (AJAX)

Limitations of JavaScript clients

The Same-Origin policy and CORS

WebSocket and the Java API for JSO Processing

Web Service Limitations

WebSocket Explained

Creating WebSockets with Java

Client-side WebSokect with JavaScript

Client-side WebSocket with Java

Consuming JSON with Java

Producing JSON with Java

Implementing a Security Policy

Container-managed security User

roles and responsibilities Create a

role-based security policy The

security API

POJO and EJB-Lite Component Models

The role of EJB components in Java EE applications

The benefits of EJB components

Operational characteristics of stateless and stateful session beans

Creating session beans

Creating session bean clients

The Java Persistence API

The role of the Java Persistence API in Java EE applications

Basics of Object-relational mapping

The elements and environment of an entity component

The life cycle and operational characteristics of entity components

Implementing a transaction policy

Transaction semantics

Programmatic vs. declarative transaction scoping Using

JTA to scope transactions programmatically Implementing

a container-managed transaction policy Optimistic locking

with the versioning of entity components Pessimistic

locking using EntityManager APIs

The effect of exceptions on transaction state

Related Courses





Duration: 4 Days

What you will learn

This Java Patterns course reviews common and emerging patterns specific to Java SDK and EE development. You'll

learn the depth and evolution of pattern-based techniques in Java, with particular emphasis on Java EE 6 conventions.

Learn To:

Dinstinguish between Java EE 5 and Java EE 6 pattern-based features.

Implement relevant patterns in each tier of the Java EE environment.

Re-factor code to improve inter-tier communications.

Relate pattern-based development to an implementation architecture.

Apply object-oriented pronciples and design guidelines.

Implement well-known patterns to Java-specific code problems.

Lab Exercises

The lab exercises show you how to identify, apply and re-factor selected patterns into code, using a NetBeans or Eclipse

IDE and the GlassFish Application Server v3. You'll also learn a subset of UML notation to expedite communicating

through design instead of code.


In design patterns, the responsibility of each component is identified by role. The conventions of design pattern

documentation make it easier for development teams to communicate their programming intentions and provide a

reference point for the entire Java development community.

Java-Based Frameworks

The Java language and popular Java-based frameworks incorporate more proven development practices into their

programming interfaces with each major release. These practices, referred to as design patterns, document well-known

names, code implementation and re-factoring techniques, and the risks and trade-offs associated with using them.

Audience

Application Developers

Architect

J2EE Developer

Java Developer

Java EE Developer



Related Training


Experience with Java SE and Java EE development

Java Programming Language, Java SE 6

Developing Applications for the Java EE 6 Platform

Course Objectives

Identify key design principles of object-oriented development

Apply Java-specific implementation techniques to well-known patterns

Use patterns to complete a Java application design

Use patterns to complete a web-tier application design

Use patterns to complete a business-tier application design

Use patterns to improve communication between Java EE tiers

Identify and refactor anti-patterns in working code

Using part of a sample architecture scheme, select design patterns for implementing the scheme

Course Topics

Reviewing Object-Oriented Principles in Java

Describe how OO concepts apply to Java

Describe how OO principles apply to Java

List the goals of an OO language

Interpret Unified Modeling Language (UML) notation and create UML diagrams

Identify selected design patterns

Reviewing Gang of Four Patterns

List key behavioral, creational and structural patterns

Apply the Facade pattern

Apply the Strategy pattern

Apply the Observer pattern

Apply the Composite pattern

Review the Model-View-Controller (MVC) patterns

Implementing Patterns in Java

Use implementation patterns designed for Java

List forces affecting class, state, and behavioral patterns

Describe how patterns, idioms and refactoring differ from each other


Exploring Changes in Java EE Technology

Describe the design goals of the Java EE model

Describe improvements in the Java EE 6 model

Implementing Integration Patterns

Describe design patterns for the integration tier

Review Java EE integration changes that apply design patterns

Identify use cases for applying integration tier patterns

Implementing Patterns in Business Components

Describe the role of an enterprise bean

Describe design patterns for the business tier

Implementing Infrastructural Patterns in Java EE

Describe the role of infrastructural Java EE patterns

Describe the Service Starter pattern

Describe the Singleton pattern

Describe the Bean Locator pattern

Describe the Resource Binder pattern

Implementing More Infrastructure Patterns

Describe how Java EE interceptors work

Describe the Dependency Injection Extender pattern

Describe the Payload Extractor pattern

Describe the Context Holder pattern

Describe the Thread Tracker pattern

Exploring Anti-Patterns

Describe the Law of Leaky Abstractions

Define AntiPatterns

Describe Integration Tier AntiPatterns

Describe Business Tier AntiPatterns

Describe Presentation Tier AntiPatterns

Selecting Patterns for Architecture

Define the roles of architect, designer, and developer

Describe the relationship between design patterns and architecture

List guidelines for applying patterns to an architectural solution



Java Performance Tuning and Optimization

Duration: 3 Days

What you will learn

This Java Performance Tuning and Optimization training will teach you about performance tuning methodologies,

performance tuning theories and practical tips to solve difficult performance problems for Java applications. Expert

Oracle University instructors will help you expand your skills during a series of labs derived from real world performance

tuning issues.

Learn To:

Set up a performance tuning environment.

Tune the performance of a Java application at the language level.

Monitor Java applications.

Apply rigor to the task of performance tuning.

Use various tools and mechanisms for monitoring, profiling and tuning Java applications.

Apply best practices for performance testing.

Tune garbage collection in a Java application.

Benefits to You

By enrolling in this course, you'll also learn to develop applications using the Java programming language. Develop the

skills to implement interfaces and handle Java programming exceptions, while using object-oriented programming

techniques.

Audience

Architect

Java Developers

Java EE Developers

Support Engineer

Technical Consultant

Related Training


Develop applications by using the Java programming language

Implement interfaces and handle Java programming exceptions

Use object-oriented programming techniques




Administer basic Windows, Linux or Solaris systems

Course Objectives

Apply basic performance tuning principles to a Java application

Monitor performance on Solaris, Linux and Windows at the OS/JVM/Application level

Profile the performance of a Java Application

Describe various garbage collection schemes

Course Topics

Introduction to Java Performance Tuning

Course Introduction

Course Agenda

JVM and Peformance Overview

JVM Overview

Performance Principles

Common Performance Problems

Performance Methodology

Development and Performance

Monitoring Operating System Performance

Monitor CPU Usage

Monitor Network I/O

Monitor Disk I/O

Monitor Virtual Memory Usage

Monitor and Identify Lock Contention

Monitoring the JVM

HotSpot Generational Garbage Collector

Monitor the Garbage Collector with Command Line Tools

Monitor the Garbage Collector with VisualVM

Monitor the JIT Compiler

Throughput and Responsiveness

Performance Profiling

NetBeans Profiler, Oracle Solaris Studio, and jmap/jhat

Profile CPU Usage

Profile JVM Heap

Find Memory Leaks

Identify Lock Contention Heap

Profiling Anti-patters Method

Profiling Anti-patterns

Garbage Collection Schemes


Garbage Collection

Generational Garbage Collection

GC Performance Metrics

Garbage Collection Algorithms

Types of Garbage Collectors

JVM Ergonomics

Garbage Collection Tuning

Tune the Garbage Collection

Select the Garbage Collector

Interpret GC Output

Language Level Concerns and Garbage Collection

The best practices for Object Allocation

Invoking the Garbage Collector

Reference Types in Java

The use of Finalizers

Performance Tuning at the Language Level

String-efficient Java Applications

Collection Classes

Using Threads

Using I/O Efficiently



Architect Enterprise Applications with Java EE

Duration: 5 Days

What you will learn

This Architect Enterprise Applications with Java EE training teaches you how to develop robust architectures for

enterprise Java applications. Learn how to use Java Platform, Enterprise Edition (Java EE) technology.

Learn How To:

Define the Enterprise Architect’s roles, responsibilities and deliverables.

Identify non-functional requirements (NFRs) and describe common problems and solutions.

Translate business requirements into an architecture.

Weigh choices in architecting the client, web, business, integration and data tiers.

Apply various evaluation criteria to choosing architectural elements and patterns, tools, servers and frameworks.

Benefits to You

By enrolling in this course, you'll understand how Enterprise Java applications developed using the architecture as a

guideline can accommodate rapid change and growth. Expert Oracle University instructors will help you explore the

technical context of the Java EE and relevant technologies.

Strategies to Create Application Blueprints

You'll also learn the strategies needed to create application blueprints that work well when implementing Java EE

technologies. These strategies include effective decision-making through the use of non-functional qualities (such as

scalability and flexibility), Java EE technology blueprints and design patterns.

Audience

Architect

Developer

J2EE Developer

Java EE Developers

Related Training


Describe distributed computing and communication concepts

Describe, in outline form, all Java EE technologies, including Enterprise JavaBeans, servlets, JavaServer Pages, and

JavaServer Faces



Perform analysis and design of object-oriented software systems

Use a notation, such as the UML, for modeling object-oriented systems

Object-Oriented Analysis and Design Using UML



Java EE 6: Develop Business Components with JMS & EJBs

Java EE 6: Develop Web Components with Servlets & JSPs

Course Objectives

Make good use of Java EE component technologies to solve typical problems in system architecture

Derive software systems using techniques outlined in the Java EE Blueprint and solutions defined in the Java EE

Patterns

Address quality-of-service requirements in a cost-effective manner using engineering trade-off techniques

Describe the role of the architect and the products an architect delivers

List and describe typical problems associated with large-scale enterprise systems

Course Topics

Introducing Enterprise Architecture

What is Enterprise Architecture?

An Architect’s Roles and Responsibilities

Introducing Fundamental Architectural Concepts

Distinguish between architecture and design

Architectural Patterns

Architectural Deliverable Artifacts

What is an Enterprise Architecture Framework

4 + 1 View Model

Architectural Modeling Using UML

Architecture Workflow

What is an Enterprise Architecture Framework

Developing a Security Architecture

Analyzing the Impact of Security in Distributed Computing

Examining Security in the Java EE Technology

Understanding Web Services Security

Understanding Non-Functional Requirements


Examining Non-Functional Requirements (NFRs)

Common Practices for Improving Qualities

Prioritizing Quality-of-Service (QoS) Requirements

Inspecting QoS Requirements for Trade-offs

Defining Common Problems and Solutions: Risk Factors and System Flexibility

Identifying Risk Factors

Designing a Flexible Object Model

Defining Common Problems and Solutions: Network, Transaction and Capacity Planning

Describing Network Communication Guidelines

Justifying the Use of Transactions

Planning System Capacity

Java EE 7 Overview

Describe the new features in Java EE 7

Describe the impact of Java EE 7 features on J2EE, Java EE 5 and 6 architectures

Developing an Architecture for the Client Tier

Client Tier Development Roles

Information Architecture Client Concerns

Selecting User Interface Devices and Technologies

Discovering Reusability in the Client Tier

Deployment Strategies for the User Interface

Security Concerns in the Client Tier

Testing

Developing an Architecture for the Web Tier

Responsibilities of the Web Tier

Seperation of Concerns

Comparing Web Tier Frameworks

Providing Security in the Web Tier

Scaling the Web Tier

Developing an Architecture for the Business Tier

Business Tier Technologies

Architecting the Domain Model

Development Best Practices

Developing an Architecture for the Integration and Resource Tiers

Examining Enterprise Information System Integration

Reviewing Java Integration Technologies

Applying Integration Patterns

Examining Service-Oriented Architecture (SOA)

Evaluating the Software Architecture

Evaluating Software Architectures

Evaluating Java EE Technologies

Creating System Prototypes

Selecting Servers and Frameworks


Desarrollo de Aplicaciones Empresariales con Spring Framework Core 4

I. Generales

El temario comprende las siguientes tecnologías. 1. Introducción a Spring Framework 2. Spring Core 3. Spring AOP 4. Spring JDBC - Transaction 5. Spring ORM – Hibernate 4 6. Fundamentos Spring MVC y Spring Security 7. Fundamentos Spring REST

II. Temario Introducción a Spring Framework 4 i. ¿Qué es Spring Framework?

a. POJOs b. JavaBeans c. Spring Beans

ii. Motivación de Spring Framework iii. Arquitectura y Módulos principales iv. Proyectos Spring.io v. Programación orientada a interfaces vi. Instalación ambiente de desarrollo vii. Práctica 1. Definición y uso de Interfaces

Spring Core i. Conceptos

a. Inversión de Control b. Inyección de Dependencias c. Inversión de Dependencias

ii. Contenedor de IoC a. BeanFactory b. ApplicationContext c. Tipos de configuración de Beans

iii. Configuración de Beans con XML a. Definición de Beans b. Inyección de Dependencias

iv. Práctica 2. Inyección de Dependencias Bean Factory v. Práctica 3. Inyección de Dependencias Application Context vi. Bean Scopes

a. Práctica 4. Bean Scopes vii. Ciclo de vida de Beans

a. Inicialización Lazy b. Práctica 5. Init – Destroy ciclo de vida c. Práctica 6. Definición lazy de Beans

viii. Definición de Beans heredada (Templates) a. Práctica 7. Definición de beans heredada

ix. Bean Post Processors a. Práctica 8. Bean post processors


x. Beans internos

a. Práctica 9. Beans Internos xi. Inyección de Colecciones y Arreglos

a. Práctica 10. Inyección de Colecciones y Arreglos. xii. Namespace p, c y util xiii. Autowiring

a. Práctica 11. Autowiring xiv. Práctica 12. Convertidor número a letra configuración XML xv. Configuración con @Anotaciones.

a. Namespace context b. @Required, @Autowired y @Qualifier

i. Práctica 13. @Required, @Autowired y @Qualifier c. Anotaciones JSR 250 @Resource, @PostConstruct y @PreDestroy

i. Práctica 14. @Resource, @PostConstruct y @PreDestroy d. Component scan e. Anotaciones estereotipo @Component, @Service, @Repository, @Controller

i. Práctica 15. @Component, @Service, @Repository, @Controller f. Anotaciones JSR 330 @Inject y @Named

i. Práctica 16. @Inject y @Named xvi. Configuración con Clases Java.

a. Anotaciones @Configuration, @Bean e @Import i. Práctica 17. @Configuration, @Bean e @Import

xvii. Práctica 18. Convertidor número a letra configuración @Anotaciones xviii. Resources

a. Conceptos b. Tipos de resource

i. Práctica 19. Tipos de resource xix. Spring Expression Language

a. Conceptos principales i. Práctica 20. API SpEL

b. Evaluación de expresiones i. Práctica 21. SpEL configuración XML ii. Práctica 22. SpEL configuración @Anotaciones

Spring AOP i. ¿Qué es AOP? ii. AOP vs POO iii. Spring AOP iv. Conceptos Básicos

a. Join point b. Advise c. Pointcut d. Aspect e. Proxy f. Target Object g. Introductions h. Weaving

v. Spring y Proxies vi. Spring AOP con XML

a. Dependencias b. Configuración

i. Aop config c. Deficinión de pointcut

i. Expresiones de Pointcut d. Tipos de Advice

i. Before advice ii. After advice iii. After returning advice iv. After throwing advice


v. Around advice

e. Práctica 23. Spring AOP usando configuración XMvii. Spring AOP con @Anotaciones a. Dependencias

i. @AspectJ b. Configuración

i. Aop aspectj-autoproxy c. Deficinión de pointcut

i. Expresiones de Pointcut d. Tipos de Advice

i. Before advice ii. After advice iii. After returning advice iv. After throwing advice

v. Around advice e. Práctica 24. Spring AOP usando configuración @Anotaciones f. Comparativa Spring AOP XML y AOP @Anotaciones g. Práctica 25. Spring AOP Adivinador

Spring JDBC - Transaction i. API JDBC

a. Implementación API JDBC ii. ¿Por qué usar Spring JDBC? iii. Filosofía de Acceso a Datos

a. Patrón de diseño DAO b. DataSource

iv. Manejo de excepciones v. Spring Jdbc Templates

a. JdbcTemplate b. NamedParameterJdbcTemplate

vi. Jdbc DAO Support vii. Uso JdbcTemplate

a. Execute b. Query c. QueryFor d. Update e. BatchUpdate

viii. Jdbc Callbacks a. RowMapper

ix. Configuración Base de datos H2 x. Configuración DataSource xi. Práctica 26. Spring DAO Jdbc Template CRUD xii. Spring y el manejo Transaccional

a. Configuración b. Transaction Manager c. Transacciones programáticas d. Transacciones declarativas e. Transacciones declarativas con @Anotaciones

xiii. Propagación de Transacciones xiv. Aislamiento de Transacciones xv. Práctica 27. Spring Transactions Jdbc Template Spring ORM – Hibernate 4 i. ¿Qué es ORM? ii. ¿Qué es Spring ORM? iii. Hibernate 4

a. Sesiones b. Transacciones c. Mapeo de Entidades con Anotaciones


iv. Integración Hibernate 4

a. Configuración DataSource b. Configuración Transaction Manager c. Session vs HibernateTemplate – Hibernate DAO Support d. Configuración Session Factory

v. Práctica 28. Spring DAO hibernate 4 CRUD

Fundamentos Spring MVC y Spring Security i. ¿Qué es Spring MVC?

a. Patrón MVC ii. Dispatcher Servlet

a. Ciclo de Vida Request Spring MVC iii. Configuración Spring MVC

a. WebApplicationContext b. ContextLoaderListener c. Namespace mvc

iv. Controllers y Views a. @Controller b. @Mapping Request c. URI Template Pattern

i. @PathVariable ii. @RequestParam

d. Internal Resource View Resolver e. Vistas JSP y JSTL

v. Sirviendo contenido estático vi. Formularios y redirección

a. Tags spring b. Model Interface c. @ModelAttribute d. Forward y SendRedirect (Servlet API)

vii. Validaciones viii. Práctica 29. Implementación aplicación CRUD ix. Spring Security Introducción x. ¿Qué es Spring Security? xi. Módulos Spring Security xii. Configuración Spring Security xiii. Implementando Seguridad en Spring MVC xiv. Práctica 30. Formulario Login básico Fundamentos Spring REST i. ¿Qué es REST? ii. Principios de REST iii. HTTP REST code statsus iv. Headers v. Produces y Consumes vi. @ResponseBody y @RequestBody vii. Servicios RESTful con Spring

a. Configuración Dependencias b. Implementación REST

i. GET ii. POST iii. PUT iv. DELETE

viii. Práctica 31. Implementación Servicios RES

Object-Oriented Analysis and Design Using UML JAVA ARCHITECT.pdf · juego de abstracciones clave...

Documents

Transcript of Object-Oriented Analysis and Design Using UML JAVA ARCHITECT.pdf · juego de abstracciones clave...