Diplomado Certificación

Transcription

1 Diplomado Certificación Duración: 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-kit s) 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) voucher de certificación a elegir con 6 meses de vigencia. Requisitos: Es Indispensable traer lap-top con las siguientes características: 1. Procesador: Intel(R) Core(TM) i5 ó i7 Quad Core a 2.0 GHz o un procesador equivalente en Intel o AMD de cuatro núcleos. 2. Tipo de Sistema Operativo Windows 7 u 8 a 64 Bits. 3. Mínimo de memoria RAM: 12 GB. 4. Mínimo de espacio en Disco 150 GB disponibles.

2 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

3 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

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

5 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

6 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

7 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

8 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

9

10 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

11 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

12 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

13 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 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

14 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

15 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

16 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

17 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

18 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

19 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

20 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

21 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

22 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

23 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

24 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