Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.
AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by Oracle
Exam Format
Registration
Validity
Skills this practice test covers
- Write JPQL queries and manage entities through the Entity Manager.
- Choose container-managed or bean-managed transactions for session EJBs.
- Consume JMS messages with message-driven beans inside transactions.
- Marshal Java objects to XML with JAXB for a JAX-WS service.
- Follow a request through the JSF life cycle to a CDI bean.
- Run background tasks with managed executors and batch jobs with JSR 352.
Explore related topics
1z0-900 exam content
14 domains · 78 topics · 192 of 359 questions sorted by domain
Understand Java EE Architecture11 questions
This domain sets out the platform: Java EE 7 standards, containers, APIs and services, and the tier where each component belongs. Candidates also package and deploy an application and explain how annotations, injection and JNDI tie beans together.
Skills tested
- Match each Java EE 7 API to the container and tier where it runs.
- Package and deploy a Java EE application.
- Compare the life cycles and scopes of EJBs and CDI beans.
- Explain how annotations, injection and JNDI connect bean components.
Manage Persistence using JPA Entities and Bean Validation
This domain covers persistence with the Java Persistence API (JPA). Candidates map entities and their relationships, use the Entity Manager for operations, transactions and locking, handle conversions, validation and key generation, and write JPQL queries.
Skills tested
- Map entities and their relationships with object-relational mapping annotations.
- Use the Entity Manager for database operations, transactions and locking.
- Validate entity data with Bean Validation constraints.
- Generate keys and convert field values in entities.
- Write and run JPQL statements.
Implement Business Logic by Using EJBs18 questions
Business logic lives in session EJBs. Candidates write synchronous and asynchronous business methods, handle container callbacks and interceptors, choose between container-managed and bean-managed transactions, and create EJB timers.
Skills tested
- Create session beans with synchronous and asynchronous methods.
- Use life cycle callbacks and interceptors on an EJB.
- Choose between container-managed (CMT) and bean-managed (BMT) transactions.
- Schedule work with EJB timers.
Questions by topic
- EJB Lifecycle and Passivation3
- EJB Timer Service2
- EJB Concurrency Management2
- Choosing the Right EJB Type1
- EJB Transaction Attributes4
- Singleton EJB in a Cluster3
- Asynchronous EJB Methods2
- Dependency Injection in EJBs1
Use Java Message Service API13 questions
This domain covers messaging with the Java Message Service (JMS). Candidates describe its messaging models, write producers and consumers for Java SE and Java EE, including message-driven beans, and use transactions with the JMS API.
Skills tested
- Compare point-to-point queues with publish/subscribe topics.
- Send and receive messages from Java SE and Java EE code.
- Consume messages with a message-driven bean.
- Group message sends and receives in a transaction.
Questions by topic
- Durable Subscriptions3
- JMS and JTA Transactions2
- JMS Messaging Models2
- Message-Driven Beans (MDB)2
- Message Selectors2
- JMS 2.0 Simplified API2
Implement SOAP Services by Using JAX-WS and JAXB APIs15 questions
This domain builds SOAP web services. Candidates create services and clients with JAX-WS, and define Java-to-XML Schema mappings so that JAXB can marshal and unmarshal objects.
Skills tested
- Create a SOAP web service and its client with JAX-WS.
- Map Java classes to XML Schema with JAXB annotations.
- Marshal Java objects to XML and unmarshal them back.
Questions by topic
- JAXB Custom Data Binding3
- WSDL Fault Handling3
- JAXB Unmarshalling Behavior2
- JAX-WS Handlers4
- JAXB Annotations for Collections2
- Web Services Security (WS-Security)1
Create Java Web Applications using Servlets15 questions
Servlets handle HTTP requests in the web container. Candidates map servlets to URLs, use HTTP methods, headers, parameters and cookies, and manage the servlet life cycle with callbacks and web filters.
Skills tested
- Map a servlet to URLs and handle each HTTP method.
- Read headers and parameters, and set cookies.
- Use life cycle callbacks and WebFilters around servlets.
Questions by topic
- Servlet Logging3
- Servlet Filter Lifecycle2
- Asynchronous Servlets and Non-blocking I/O3
- Servlet Session Management2
- Asynchronous Servlet Processing2
- Servlet Listeners2
- Servlet vs JSP Comparison1
Create Java Web Applications using JSPs10 questions
This domain covers JavaServer Pages (JSP). Candidates describe the JSP life cycle and syntax, use tag libraries and Expression Language (EL), and handle errors with servlets and JSPs.
Skills tested
- Describe how a JSP is translated, compiled and run.
- Use tag libraries and EL in JSP pages.
- Send errors to an error page from a servlet or a JSP.
Questions by topic
- JSTL Conditional Logic3
- Servlet vs JSP Comparison1
- JSP Include Mechanisms3
- JSP Error Handling2
- Expression Language (EL)1
Implement REST Services using JAX-RS API18 questions
This domain builds REST services with JAX-RS. Candidates apply REST conventions for resources and HTTP methods, then create services and clients with the JAX-RS API.
Skills tested
- Design resources and URIs that follow REST conventions.
- Create a JAX-RS resource with path and HTTP method annotations.
- Call a REST service with the JAX-RS client API.
Questions by topic
- JAX-RS Response Handling3
- JAX-RS Client Filters2
- Content Negotiation Annotations3
- JAX-RS Resource Annotation2
- JAX-RS StreamingOutput3
- Exception Mapping2
- Programmatic Security in JAX-RS2
- CDI Scopes1
Create Java Applications using WebSockets13 questions
WebSockets keep one connection open for messages in both directions. Candidates explain the communication style and life cycle, write server and client endpoints with the JSR 356 API and JavaScript, and encode and decode messages.
Skills tested
- Explain the WebSocket life cycle from open to close.
- Write server and client endpoints with JSR 356 annotations.
- Connect a JavaScript client to a WebSocket endpoint.
- Encode and decode WebSocket messages.
Questions by topic
- Streaming WebSocket Messages3
- Managing WebSocket Sessions2
- WebSocket Encoders and Decoders4
- Programmatic Endpoint Creation2
- Session Management2
Develop Web Applications using JSFs23 questions
This domain builds page-based web interfaces with JavaServer Faces (JSF). Candidates describe the JSF architecture, life cycle and navigation, use JSF tag libraries, localize messages, and use EL to work with CDI beans.
Skills tested
- Describe each phase of the JSF request life cycle.
- Build pages with JSF tag libraries.
- Localize text and show messages to users.
- Bind page components to CDI beans with EL.
Questions by topic
- Passing Parameters in JSF3
- JSF Localization2
- JSF Lifecycle Phases2
- JSF Lifecycle and Validation5
- Custom JSF Validators2
- JSF Message Handling2
- JSF Navigation2
- JSF Converters2
- JSF Ajax2
- Expression Language (EL)1
Secure Java EE 7 Applications12 questions
This domain covers declarative and programmatic security. Candidates configure authentication with application roles, security constraints and login modules, and describe the security standards for web services.
Skills tested
- Protect resources with security constraints and application roles.
- Check a caller's role in code with programmatic security.
- Configure authentication with login modules.
- Describe the security standards for web services.
Questions by topic
- Programmatic Security in JAX-RS1
- Declarative Security with web.xml3
- Declarative Security Annotations3
- Transport Layer Security2
- Programmatic Security2
- Web Services Security (WS-Security)1
Use CDI Beans17 questions
Contexts and Dependency Injection (CDI) creates beans and injects them where they are needed. Candidates create qualifiers, producers, disposers, interceptors, events and stereotypes.
Skills tested
- Choose between beans of one type with qualifiers.
- Create objects with producers and clean them up with disposers.
- Add logging or auditing code with interceptors.
- Fire and observe CDI events.
Questions by topic
- CDI Scopes1
- CDI Producers and Qualifiers2
- CDI Interceptors3
- CDI Events and Polymorphism3
- CDI Qualifiers2
- CDI Producers and Disposers3
- CDI Events3
Use Concurrency API in Java EE 7 Applications15 questions
Java EE components are not meant to create their own threads. This domain covers the Java Concurrency Utilities, whose managed executors run tasks with the container's context.
Skills tested
- Submit tasks to a managed executor service.
- Schedule repeated tasks with a managed scheduled executor.
- Explain how context, such as security, passes to managed tasks.
Questions by topic
- Handling Future Results3
- ManagedThreadFactory3
- Context Propagation in ManagedExecutorService5
- ManagedScheduledExecutorService2
- ManagedTaskListener2
Use Batch API in Java EE 7 Applications12 questions
The last domain covers batch jobs. Candidates describe jobs written as JSL XML documents and run through the JSR 352 API, with chunk steps that read, process and write items.
Skills tested
- Describe a batch job and its steps in a JSL XML document.
- Explain chunk processing with an item reader, processor and writer.
- Start, stop and restart jobs through the JSR 352 API.
Questions by topic
- Resolving Memory Issues in Chunk Processing3
- Sharing Data Between Batch Steps2
- Job Execution and Restart3
- Batch Listeners2
- Job Repository2
Requirements
- No formal prerequisites: passing this exam alone earns the certification.
- Recommended: an earlier Java SE certification, for example through Java SE 8 Programmer I and Java SE 8 Programmer II.
- Recommended: hands-on Java EE 7 programming and up-to-date training.
About the 1z0-900 exam
1z0-900 is Oracle's professional exam for developers who build and deploy enterprise applications on Java Platform, Enterprise Edition 7 (Java EE 7). It reaches across the whole platform, from JPA persistence and EJBs to JMS, SOAP and REST services, servlets, JSPs, JSF, WebSockets, security, CDI and the concurrency and batch APIs. Oracle recommends hands-on programming experience and an earlier Java SE certification. A pass earns Oracle Certified Professional, Java EE 7 Application Developer.
The PlanetCert practice test covers all fourteen domains and gives the most questions to JPA persistence and JSF. Explanations matter most where two APIs look alike, such as a CDI scope and an EJB type, or a JAX-RS resource and a servlet mapping. Study Mode suits the EJB and JMS domains, where transaction attributes and rollback rules need a careful read. Brainy AI Assistant can trace the JSF life cycle phase by phase, or explain why a message-driven bean has no client view.
How to earn the certification
- Earns
- Oracle Certified Professional, Java EE 7 Application DeveloperProfessional
The certification does not expire.
- Before
- 1z0-808 Java SE 8 Programmer I
The first Java SE 8 step. It earns the associate-level Java SE 8 Programmer certification.
- 1z0-808 Java SE 8 Programmer I
How to prepare for 1z0-900
- 1
Set up a Java EE 7 server
Install an application server that supports Java EE 7. Deploy a small application with one servlet, one EJB and one entity, and build each later domain on top of it.
- 2
Type out the Java EE 7 Tutorial examples
Oracle's Java EE 7 Tutorial has a chapter for most domains. Type out and run its examples instead of only reading them, starting with JPA and EJBs.
- 3
Roll back a JMS send
Write a session bean that sends a JMS message inside a container-managed transaction. Roll the transaction back and check that the message is never delivered.
- 4
Log every JSF phase
Add a phase listener to a JSF page and log each phase. Then submit invalid input and see which phases the request skips.
- 5
Finish with domain drills and a timed run
Take the 1z0-900 practice test one domain at a time in Study Mode, then a full run in Timed Mode. Ask Brainy AI Assistant to explain any missed question on CDI scopes or JPA locking.
Start a timed 1z0-900run
Oracle lists its Enterprise Java Developer learning path as optional preparation for this exam.
Who 1z0-900 is for
- Back-end Java developers who write business logic, persistence and services for Java EE 7 servers.
- Front-end Java developers who build web interfaces with JSF, JSPs and servlets.
- Architects and software engineers who design applications on the Java EE platform.
Typical job titles: Java EE developer · Java back-end developer · Software engineer · Enterprise application architect · Full-stack Java developer
1z0-900 glossary
18 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- Bean Validation
- The API that checks field values against constraints written as annotations, such as @NotNull or @Size.
- CDI beans
- Java objects managed by Contexts and Dependency Injection, which creates them, injects them and ends them with their scope.
- Enterprise JavaBeans
- Server-side Java components that hold business logic and get transactions, security and pooling from the EJB container.
- Entity Manager
- The JPA interface that saves, finds, updates and removes entities and tracks them in a persistence context.
- Expression Language (EL)
- A short syntax that JSP and JSF pages use to read and set values held in Java beans.
- JAX-RS
- The Java API for building REST services and clients with annotations such as @Path and @GET.
- JAX-WS
- The Java API for building SOAP web services and the clients that call them.
- JAXB
- The Java Architecture for XML Binding, which converts Java objects to XML and back, called marshalling and unmarshalling.
- JNDI
- The Java Naming and Directory Interface, which lets components look up resources such as data sources and EJBs by name.
- JPQL
- The Java Persistence Query Language, which queries entities and their fields instead of database tables and columns.
- JSL XML
- Job Specification Language files that define a batch job's steps, flow and settings in XML.
- JSR 356
- The Java API for WebSocket, used to write server and client endpoints that exchange messages over one open connection.
- Managed Executors
- Container-provided thread pools that run tasks in the background and keep the application's context, such as security.
- Message-Driven beans
- EJBs that the container calls each time a message arrives on a JMS queue or topic.
- Object-Relational Mappings (ORM)
- Rules that link Java entity classes and their relationships to database tables, columns and keys.
- Qualifiers
- CDI annotations that tell the container which of several beans of the same type to inject.
- Stereotypes
- CDI annotations that bundle other annotations, such as a scope and interceptor bindings, under one name.
- WebFilters
- Servlet filters that inspect or change requests and responses before or after a servlet runs.