Developing Applications with Java EE 6 on WebLogic Server 12c




    5 Day(s) Course


    Official Courseware


    Certified Trainer


    Exam Voucher


    1:1 Training Available on Demand


    Customize Your Batch

    Course Information

    The Developing Applications with Java EE 6 on WebLogic Server 12c training imparts the knowledge base to successfully build and deploy enterprise applications. This course will expose participants to applications that hold relevance with the Java Platform, and Enterprise Edition 6 Web Profile.

    Completion of this training course will enable candidates in:

    • Creating mobile web applications.
    • Creating JSF facelet pages.
    • Developing web profile applications.
    • Assembling a web application and deploy it into an application server (Java EE platform runtime environment).
    • Using CDI.
    • Updating a database with JPA.
    • Performing bean validation.

    Course Benefits:

    Attaining certification of this course helps you gain experience using the following technologies:

    • Annotations
    • Servlets
    • Session Enterprise JavaBeans (EJBs)
    • The Java Persistence API (JPA)
    • JavaServer Pages (JSPs)
    • JavaServer Faces (JSF)
    • Contexts and Dependency Injection (CDI) and
    • Bean Validation


    1. Java Platform, Enterprise Edition

    • Describing the purpose of the Java EE Platform
    • Describing the needs of enterprise applications
    • List the various Java EE specifications
    • Compare services and libraries
    • Describing the Java EE Web Profile
    • Describing the EE application tiers and layers

    2. Enterprise Development Tools and Application Servers

    • Describing the purpose of an application server
    • Identifying the potential selection criteria used when choosing an application server
    • Installing the Oracle WebLogic Server 12c Zip Distribution
    • Describing the properties of Java EE components
    • Describing the process of developing a Java EE application
    • Describing how to configure and package Java EE applications
    • List EE supporting features provided by integrated development environments (IDEs)

    3. JavaBeans, Annotations, and Logging

    • Describing the Java SE features that are used extensively in enterprise applications
    • Creating POJO JavaBeans components
    • Log application activity and errors
    • Write to server logs
    • Describing common Java SE annotations and features
    • Developing Java annotations
    • Describing the role of annotations in Java EE

    4. Web Component Model

    • Describing the HTTP request-response model
    • Defining the difference between Java Servlets, JSP, and JSF components
    • Implementing application layering and the MVC Pattern
    • Avoid thread safety issues in web components
    • Using the Expression Language

    5. Developing with JavaServer Faces Technology

    • Evaluating the role of JavaServer Faces (JSF) technology as a presentation mechanism
    • Describing the flow of the JSF lifecycle
    • Describing the use of JSF tag libraries
    • Process form submissions and use JSF managed beans
    • Using a component to iterate over values in a collection
    • Using the appropriate annotation to control the scope of a bean instance

    6. Using AJAX and Composite Components with JSF

    • Defining Asynchronous JavaScript and XML (AJAX)
    • Describing how JSF Components can be enhanced with AJAX
    • Using the tag
    • Describing how AJAX request integrates with the JSF lifecycle
    • Defining a composite component
    • Creating a JSF composite component

    7. Apache Trinidad JSF Component Library and Mobile Development

    • Creating JavaServer Faces (JSF) pages that use Apache Trinidad components
    • Creating a JSF-based mobile application
    • Dynamically apply Cascading Style Sheets (CSS) with Trinidad Skinning
    • Using the HTML5 video tag

    8. Dependency Injection with CDI

    • Creating managed bean compatible classes
    • Injecting managed beans
    • Qualify the bean being requested at an injection point
    • Using CDI alternatives

    9. Using JSF and Bean Validation

    • Defining the approach JSF uses to convert and validate input data
    • Using built-in validation constraints provided with JSF
    • Using built-in validation constraint annotations provided by Bean Validation
    • Creating a custom Bean Validation constraint

    10. Developing Servlets

    • Describing the servlet API
    • Using the request and response APIs
    • Setting response headers
    • Creating text and binary response bodies
    • Processing file uploads using servlets
    • Forward to JSPs using Request Dispatcher
    • Using the session management API

    11. Developing with JavaServer Pages Technology

    • Evaluating the role of JSP technology as a presentation mechanism
    • Author JSP pages
    • Processing data received from servlets in a JSP page
    • Describing the use of tag libraries

    12. EJB Component Model

    • Describing the role of EJB components in a Java EE application
    • Describing the benefits of EJB components
    • Describing the operational characteristics of a stateless, stateful, and singleton session beans
    • Creating session beans
    • Creating session bean clients

    13. The Java Persistence API

    • Describing the role of the Java Persistence API (JPA) in a Java EE application
    • Explaining the basics of object-relational mapping
    • Describing the elements and environment of an entity component

    14. Implementing a Transaction Policy

    • Describing transaction semantics
    • Compare programmatic and declarative transaction scoping
    • Using 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
    • Describing the effect of exceptions on transaction state

    15. Web Service and Integration Technology Survey

    • Describing the purpose of integration technologies
    • Defining the integration layer in a multilayered application architecture
    • List various Java EE integration technologies
    • Describing the benefit of Web Services over other integration technologies

    16. Implementing a Security Policy

    • Leveraging container-managed security
    • Defining user roles and responsibilities
    • Creating a role-based security policy
    • Using Declarative Security
    • Configure authentication in the web tier


    • Java Developers




    • Knowledge working on HTML and CSS
    • Understanding with relational database theory and the basics of structured query language (SQL)
    • Familiarity with the use of an IDE
    • Experience with the Java programming language
    • Java SE 7 Programming Training

    Suggested Prerequisites:

    • Java SE 7: Develop Rich Client Applications


    Name Code Fee



    What Our Trainees Say

    Mercury Solutions Ltd. is rated 4.6 stars by based on 18 reviews.