Anda di halaman 1dari 24

Diplomado Certificacin

Duracin: 250 horas.


Horario: Sabatino de 8:00 a 15:00 horas.
Incluye:
1. Curso presencial de 250 horas.
2.- Material oficial de Oracle University (e-kits) de los siguientes cursos:
- Java SE 8 Fundamentals
- Java SE 8 Programming
- JavaScript and HTML5: Develop Web Applications
- Web Component Development with Serviets & JSPs, Java EE6
- Java EE 7: Back-End Server Application Development
- Java EE 7: Front-End Web Application Development
- Developing Applications with Java EE 6 on WebLogic Server 12c
3.- Material oficial de EC-Council del siguiente curso:
- EC-Council Certified Secure Programmer (JAVA)
4.- 1 voucher de certificacin a elegir con 6 meses de vigencia.
Requisitos:
Es Indispensable traer lap-top con las siguientes caractersticas:
1. Procesador: Intel(R) Core(TM) i5 i7 Quad Core a 2.0 GHz o un procesador equivalente
en Intel o AMD de cuatro ncleos.
2. Tipo de Sistema Operativo Windows 7 u 8 a 64 Bits.
3. Mnimo de memoria RAM: 12 GB.
4. Mnimo de espacio en Disco 150 GB disponibles.

Java SE 8 Fundamentals
What Is a Java Program?
Introduction to Computer Programs
Key Features of the Java Language
The Java Technology and Development Environment
Running/testing a Java program
Creating a Java Main Class
Java Classes
The main Method
Data In the Cart
Introducing variables
Working with Strings
Working with numbers
Manipulating numeric data
Managing Multiple Items
Working with Conditions
Working with a List of Items
Processing a list of items
Describing Objects and Classes
Working with objects and classes
Defining fields and methods
Declaring, Instantiating, and Initializing Objects
Working with Object References
Doing more with Arrays
Introducing the NetBeans IDE
Introducing the Soccer League Use Case
Manipulating and Formatting the Data in Your Program
Using the String Class Using
the Java API Docs Using the
StringBuilder Class
More about primitive data types
The remaining numeric operators
Promoting and casting variables

Creating and Using Methods


Using methods
Method arguments and return values
Static methods and variables
How Arguments are Passed to a Method
Overloading a method
Using Encapsulation
Access Control
Encapsulation
Overloading constructors
More on Conditionals
Relational and conditional operators
More ways to use if/else constructs
Using Switch Statements
Using the NetBeans Debugger
More on Arrays and Loops
Working with Dates
Parsing the args Array
Two-dimensional Arrays
Alternate Looping Constructs
Nesting Loops
The ArrayList class
Using Inheritance
Overview of inheritance
Working with subclasses and superclasses
Overriding methods in the superclass
Introducing polymorphism
Creating and extending abstract classes
Using Interfaces
Polymorphism in the JDK foundation classes
Using Interfaces
Using the List Interface
Introducing Lambda expressions

Handling Exceptions
Handling Exceptions: An overview
Propagation of exceptions
Catching and throwing exceptions
Handling multiple exceptions and errors

Java SE 8 Programming
Java Platform Overview
Defining how the Java language achieves platform independence
Differentiating between the Java ME, Java SE, and Java EE Platforms
Evaluating Java libraries, middle-ware, and database options
Defining how the Java language continues to evolve
Java Syntax and Class Review
Creating simple Java classes
Creating primitive variables
Using operators
Creating and manipulate strings
Using if-else and switch statements
Iterating with loops: while,do-while,for,enhanced for
Creating arrays
Using Java fields, constructors, and methods
Encapsulation and Subclassing
Using encapsulation in Java class design
Modeling business problems using Java classes
Making classes immutable
Creating and use Java subclasses
Overloading methods
Overriding Methods, Polymorphism, and Static Classes
Using access levels: private, protected, default, and public.
Overriding methods
Using virtual method invocation
Using varargs to specify variable arguments
Using the instanceof operator to compare object types
Using upward and downward casts
Modeling business problems by using the static keyword
Implementing the singleton design pattern

Abstract and Nested Classes


Designing general-purpose base classes by using abstract classes
Constructing abstract Java classes and subclasses
Applying final keyword in Java
Distinguish between top-level and nested classes
Interfaces and Lambda Expressions
Defining a Java interface
Choosing between interface inheritance and class inheritance
Extending an interface
Defaulting methods
Anonymous inner classes
Defining a Lambda Expression
Collections and Generics
Creating a custom generic class
Using the type inference diamond to create an object
Creating a collection by using generics
Implementing an ArrayList
Implementing a TreeSet
Implementing a HashMap
Implementing a Deque
Ordering collections
Collections Streams, and Filters
Describing the Builder pattern
Iterating through a collection using lambda syntax
Describing the Stream interface
Filtering a collection using lambda expressions
Calling an existing method using a method reference
Chaining multiple methods together
Defining pipelines in terms of lambdas and collections
Lambda Built-in Functional Interfaces
Listing the built-in interfaces included in java.util.function
Core interfaces - Predicate, Consumer, Function, Supplier
Using primitive versions of base interfaces
Using binary versions of base interfaces
Lambda Operations
Extracting data from an object using map
Describing the types of stream operations
Describing the Optional class
Describing lazy processing
Sorting a stream

Saving results to a collection using the collect method


Grouping and partition data using the Collectors class
Exceptions and Assertions
Defining the purpose of Java exceptions
Using the try and throw statements
Using the catch, multi-catch, and finally clauses
Autoclose resources with a try-with-resources statement
Recognizing common exception classes and categories
Creating custom exceptions
Testing invariants by using assertions
Java Date/Time API
Creating and manage date-based events Creating
and manage time-based events Combining date
and time into a single object Working with dates
and times across time zones Managing changes
resulting from daylight savings
Defining and create timestamps, periods and durations
Applying formatting to local and zoned dates and times
I/O Fundamentals
Describing the basics of input and output in Java
Read and write data from the console
Using streams to read and write files
Writing and read objects using serialization
File I/O (NIO.2)
Using the Path interface to operate on file and directory paths
Using the Files class to check, delete, copy, or move a file or directory
Using Stream API with NIO2
Concurrency
Describing operating system task scheduling
Creating worker threads using Runnable and Callable
Using an ExecutorService to concurrently execute tasks
Identifying potential threading problems
Using synchronized and concurrent atomic to manage atomicity
Using monitor locks to control the order of thread execution
Using the java.util.concurrent collections

The Fork-Join Framework


Parallelism
The need for Fork-Join
Work stealing
RecursiveTask
RecursiveTask
Parallel Streams
Reviewing the key characteristics of streams
Describing how to make a stream pipeline execute in parallel
List the key assumptions needed to use a parallel pipeline
Defining reduction
Describing why reduction requires an associative function
Calculating a value using reduce
Describing the process for decomposing and then merging work
Listing the key performance considerations for parallel streams
Database Applications with JDBC
Defining the layout of the JDBC API
Connecting to a database by using a JDBC driver
Submitting queries and get results from the database
Specifying JDBC driver information externally
Performing CRUD operations using the JDBC API
Localization
Describing the advantages of localizing an application
Defining what a locale represents
Read and set the locale by using the Locale object
Building a resource bundle for each locale
Calling a resource bundle from an application
Changing the locale for a resource bundle

JavaScript and HTML5: Develop Web Applicartions


Introduction
Knowing the objectives of the course
Setting up the Environment
Web Application Essentials
Creating HTML5 Applications in NetBeans
Running HTML pages and analizing them by using the browser's development tools
Separating CSS and JavaScript content from HTML pages
Running HTML5 Applications in NetBeans
Practice: Creating HTML5 Web Applications with NetBeans 8
Practice: Separating JavaScript and CSS Resources
JavaScript Fundamentals
Writing JavaScript code to declare variables, objects, functions and arrays
Writing JavaScript Arrays to store data
Defining JavaScript Objects as a key-value store
Accessing the properties of an object
Practice: Writing JavaScript code to pass tests in Jasmine
Combining HTML5 and JavaScript in Web Applications
Creating HTML5 Documents
Creating HTML5 Forms to request information and process it
Validating HTML5 form input
Writing JavaScript functions for HTML5 events
Manipulating HTML5 elements through DOM
Practice: Writing JavaScript code to modify document elements
The JavaScript API
Validating user input with JavaScript
and Regular Expressions Handling
multiple values with JavaScript
Collections Manipulating Dates with
the JavaScript Date API
Practice: Creating a meal-divider application
Practice: Calculating the total based on the age
Web Application Data
Converting Objects to JSON Strings
Parsing JSON Strings into JavaScript Objects
Storing Objects by using the JSON API, Cookies, and Local Storage
Practice: Saving user input using JSON and Local Storage
Practice: Restoring saved data when page loads

Style Applications using CSS3 and JavaScript


Applying CSS styles to HTML documents
Using CSS3 features to add dynamic styles
to elements with events Using Media
Queries and media data to adapt to different
screens Using JavaScript to add and
remove styles from elements
Practice: Writing CSS rules to style elements in the document
Advanced JavaScript
Defining Functions
Creating Closures and explaining Variable Scope
Writing JavaScript functions as modules
Creating Prototypes
Creating Drag-and-Drop interactions with JavaScript
Creating JavaScript Timers and Delays to
create animations in HTML Using the HTML5
Canvas Object to draw in pages
Practices: Creating a Canvas, intervals, Drag and Drop, and implementing Mouse Gestures
AJAX and WebSocket
Using AJAX with JavaScript to request data from an Application Server
Using AJAX to consume RESTful Web Services
Using AJAX calls to create
"Server Push" interactions
Identifying alternatives to
AJAX used in legacy code
Understanding AJAX Security
Using WebSocket to create Real-time Client/Server interactions
Identifying the required Back-End technologies for REST and WebSocket with Java EE7
Practices: Creating a Single-Page Application using RESTand a Tic-Tac-Toe Game Client with
WebSocket
Developing Applications with jQuery
Adding jQuery and jQuery UI libraries to your projects
Using Selectors and DOM manipulators to handle documents
Handling Events with jQuery
Animating elements and Applying effects in the document
Handling AJAX server responses

Java EE 6: Develop Web Components with Servlets & JSPs


Introducing the Course
Reviewing the Java SE and Java EE Curriculum
Getting Acquainted with Other Students
Reviewing Course Objectives
Discussing 5 Day Course Schedule
Describing the Format that the Class will Use
Introducing Web Application Technologies
Describing the Java EE 6 Web Profile
Web Application Essentials Describing
Java Servlet Technology Describing
JavaServer Pages Technology
Understanting the Model-View-Controller (MVC) Architecture
Explaining Java EE Containers and Java Application Servers
Describing the Web Application Development Process
Identifying the Essential Structure of a WAR File
Developing a Servlet
Describing the HTTP Headers and Their Function
Explaining the Request and Response Processes
Understanding the Life Cycle of a Servlet
Listing Injection and Lifecycle Method Annotations
Understanding the Threading Model of a Servlet
Developing a Servlet to Respond to Requests from the Client Browser
Handling Form Requests in Servlets
Using HTML Forms To Collect Data From Users and Send it To a Servlet
Understanding How Form Data Is Sent in an HTTP Request
Developing a Servlet that Retrieves Form Parameters
Understanding and Using HttpSession Objects
Using Cookies for Session Management
Using URL Rewriting for Session Management

Configuring Your Web Application


Describing the Purpose of Deployment Descriptors
Creating Servlet Mappings to Allow Invocation of a Servlet
Creating and Access Context and Init Parameters
Using the @WebServlet and @WebInitParam Annotations
Using the ServletContextListener Interface
Describing the Different Scopes in a Web Application
Handling Errors Using a Deployment Descriptor
Implementing an MVC Design
Implementing the Controller Design Element Using a Servlet
Implementing the Model Design Element Using a POJO
Implementing the View Design Element Using a JSP and Expression Language (EL)
Connecting the model, View, and Controller Elements to Implement a Working MVC
Solution
Injecting a Service in a Controller
Developing Components with JavaServer Pages Technology
Describing JSP Page Technology
Writing JSP Code Using Scripting Elements
Writing JSP Code Using the Page Directive
Writing JSP Code Using Standard Tags
Writing JSP code using Expression Language
Configuring the JSP Page Environment in the web.xml File
Writing an Error Page by Using JSP
Developing JSP Pages by Using Custom Tags
Designing JSP Pages with Custom Tag Libraries
Using a Custom Tag Library in JSP Pages
Describing JSTL Tags
Using Filters in Web Applications
Describing the Web Container Request Cycle
Describing the Filter API
Developing a Filter Class
Configuring a Filter in the web.xml File

More Servlet Features


Using the Asynchronous Servlet Mechanism
Using JavaScript to Send an HTTP Request from a Client
Processing an HTTP Response Entirely in JavaScript
Combining These Techniques to Create the Effect of Server-push
Handling Multipart Form Data
Implementing Security
Describing a Common Failure Mode in Security
Requiring that a User Log in Before Accessing Specific Pages in Your Web Application
Describing the Java EE Security Model
Requiring SSL Encrypted Communication for Certain URLs or Servlets
Integrating Web Applications with Databases
Understanding the Nature of the Model as a Macro-pattern
Implementing Persistent Storage for Your Web Applications Using JDBC or Java
Persistence API

Java EE 7: Back-End Server Application Development


Java Platform, Enterprise Edition
The Java EE Platform
The needs of enterprise application developers
Java EE specifications
A comparison of services and libraries
Java EE application tiers and architecture
Enterprise Development Tools and Applications
The purpose of an application server
Properties of Java EE components
The development process of Java EE applications
Configuring and deploying Java EE applications
Java Beans, Annotations and Logging
Java SE features in Java EE applications
Creating POJO JavaBeans components
Using logging
Using common Java annotations
Developing custom annotations
The role of annotations in Java EE applications
XML Programming with JAXB
The benefits of XML
XML namespaces and schemas
Java XML APIs
The Java XML Binding API (JAXB)
Reading and writing XML documents with JAXB
xjc: the JAXB binding compiler
JAXB annotations
SOAP Web Services with JAX-WS
Overview of SOAP
Overview of WSDL files
Comparing WSDL-first and code-first design approaches
Writing a JAX-WS web service
Generating WSDL from a Java class
Creating JAX-WS web service clients
Java Naming and Directory (JNDI) Services
What is JNDI?
Naming service concepts
Directory service concepts
JNDI packages
Using JNDI to look up JDBC and EJB components in Java EE

The EJB Component Model


The role EJB components play in Java EE appplications
The role of the EJB container
EJB changes in Java EE 7
Local, distributed and no-client EJB client access views
EJB Session types
Stateless, Stateful and Singleton EJBs
Session bean packaging and deploying
Contexts and Dependency Injection
What is dependency injection?
Using Qualifiers
The beans.xml file and Alternatives
Using Producers and Disposers
Using Interceptors
Using Events and Stereotypes
Java Message Service
What is the Java Message Service?
Why do we need JMS?
JMS OverviewPoint-to-point messaging architecture
Publish/subscribe messaging architecture
Message producers and consumers
Queues and topics
Durable vs. non-durable subscriptions
Message-driven Beans
The life cycle of a message-driven bean
Creating a message-driven bean
Creating life cycle handlers for message-driven beans
Configuring a message-driven bean
Java EE Concurrency
Concurrency in Java EE
Asynchronous EJBs
Managed Executors
JDBC in Java EE Environments
Overview of the JDBC API
Using CDI to inject a JDBC resource in a Java EE component
The Data Access Object pattern
Transactions in Java EE Environments
What are transaction semantics?
Comparing programmatic and declarative transaction scoping
Using JTA to scope transactions programmatically
Implementing a container-managed transaction policy using declarations
Controlling container-managed transaction propagation

Java Persistence API


Object-relational mapping
Entities and the entity manager
Persistence contexts and persistence units
Create, read, update and delete operations with JPA
Create typed queries in JPA with JPQL
Bean Validation with JPA
What is Bean Validation?
JPA lifecycle phases where validation takes place
Using the built-in validation constraints
Creating a custom bean validation constraint
Programmatic validation by injecting a Validator
Using validation groups
Timer and Batch Services
What are timer services?
Programmatic and automatic timers
What is Batch processing?
Jobs, steps and chunks
Batch examples
Security
Authentication, authorization and confidentiality
Apply Java EE security using deployment descriptors
Creating users and groups and mapping them to roles
Defining possible web service attack vectors

JAVA EE 7: FRONT-END WEB APPLICATION DEVELOPMENT


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 GlassFish 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 Architecure
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

Developing Applications with Java EE 6 on WebLogic


Server 12c
Java Platform, Enterprise Edition
Describe the purpose of the Java EE Platform
Describe the needs of enterprise applications
List the various Java EE specifications
Compare services and libraries
Describe the Java EE Web Profile
Describe the EE application tiers and layers
Enterprise Development Tools and Application Servers
Describe the purpose of an application server
Identify the potential selection criteria used when choosing an application server
Install the Oracle WebLogic Server 12c Zip Distribution
Describe the properties of Java EE components
Describe the process of developing a Java EE application
Describe how to configure and package Java EE applications
List EE supporting features provided by integrated development environments (IDEs)
JavaBeans, Annotations, and Logging
Describe the Java SE features that are used extensively in enterprise applications
Create POJO JavaBeans components
Log application activity and errors
Write to server logs
Describe common Java SE annotations and features
Develop Java annotations
Describe the role of annotations in Java EE
Web Component Model
Describe the HTTP request-response model
Define the difference between Java Servlets, JSP, and JSF components
Implement application layering and the MVC Pattern
Avoid thread safety issues in web components
Use the Expression Language

Developing with JavaServer Faces Technology


Evaluate the role of JavaServer Faces (JSF) technology as a presentation mechanism
Describe the flow of the JSF life cycle
Author JSF pages using Facelets
Process form submissions and use JSF managed beans
Describe the use of JSF tag libraries
Use the appropriate annotation to control the scope of a bean instance
Use a component to iterate over values in a collection
Using AJAX and Composite Components with JSF
Define Asynchronous JavaScript and XML (AJAX)
Describe how JSF Components can be enhanced with AJAX
Use the tag
Describe how AJAX request integrates with the JSF life cycle
Define a composite component
Create a JSF composite component
Apache Trinidad JSF Component Library and Mobile Development
Create JavaServer Faces (JSF) pages that use Apache Trinidad components
Create a JSF-based mobile application
Dynamically apply Cascading Style Sheets (CSS) with Trinidad Skinning
Use the HTML5 video tag
Dependency Injection With CDI
Create managed bean compatible classes
Inject managed beans
Qualify the bean being requested at an injection point
Use CDI alternatives
Using JSF and Bean Validation
Define the approach JSF uses to convert and validate input data
Use built-in validation constraints provided with JSF
Use built-in validation constraint annotations provided by Bean Validation
Create a custom Bean Validation constraint

Developing Servlets
Describe the servlet API
Use the request and response APIs
Set response headers
Create text and binary response bodies
Process file uploads using servlets
Forward to JSPs using RequestDispatcher
Use the session management API
Developing with JavaServer Pages Technology
Evaluate the role of JSP technology as a presentation mechanism
Author JSP pages
Process data received from servlets in a JSP page
Describe the use of tag libraries
EJB Component Model
Describe the role of EJB components in a Java EE application
Describe the benefits of EJB components
Describe the operational characteristics of a stateless, stateful, and singleton session
beans
Create session beans
Create session bean clients
The Java Persistence API
Describe the role of the Java Persistence API (JPA) in a Java EE application
Explain the basics of object-relational mapping
Describe the elements and environment of an entity component
Describe the life cycle and operational characteristics of entity components
Implementing a Transaction Policy
Describe transaction semantics
Compare programmatic and declarative transaction scoping
Use JTA to scope transactions programmatically
Implement a container-managed transaction policy
Support optimistic locking with the versioning of entity components
Support pessimistic locking using EntityManager APIs
Describe the effect of exceptions on transaction state

Web Service and Integration Technology Survey


Describe the purpose of integration technologies
Define the integration layer in a multilayered application architecture
List various Java EE integration technologies
Describe the benefit of Web Services over other integration technologies
Implementing a Security Policy
Leverage container-managed security
Define user roles and responsibilities
Create a role-based security policy
Using Declarative Security
Configure authentication in the web tier