www.it-ebooks.info For your convenience Apress has placed some of the front matter material after the index. Please use the Bookmarks and Contents at a Glance links to access them. www.it-ebooks.info Contents at a Glance Foreword ��������������������������������������������������������������������������������������������������������������������������xxv About the Author ������������������������������������������������������������������������������������������������������������xxvii About the Technical Reviewer �����������������������������������������������������������������������������������������xxix Acknowledgments �����������������������������������������������������������������������������������������������������������xxxi Introduction �������������������������������������������������������������������������������������������������������������������xxxiii ■ Chapter 1: Java EE 7 at a Glance ���������������������������������������������������������������������������������������1 ■ Chapter 2: Context and Dependency Injection �����������������������������������������������������������������23 ■ Chapter 3: Bean Validation ����������������������������������������������������������������������������������������������67 ■ Chapter 4: Java Persistence API �����������������������������������������������������������������������������������103 ■ Chapter 5: Object-Relational Mapping���������������������������������������������������������������������������125 ■ Chapter 6: Managing Persistent Objects �����������������������������������������������������������������������177 ■ Chapter 7: Enterprise JavaBeans ����������������������������������������������������������������������������������227 ■ Chapter 8: Callbacks, Timer Service, and Authorization �����������������������������������������������263 ■ Chapter 9: Transactions �������������������������������������������������������������������������������������������������289 ■ Chapter 10: JavaServer Faces ���������������������������������������������������������������������������������������305 ■ Chapter 11: Processing and Navigation ������������������������������������������������������������������������349 ■ Chapter 12: XML and JSon Processing ��������������������������������������������������������������������������387 v www.it-ebooks.info ■ Contents at a GlanCe ■ Chapter 13: Messaging ��������������������������������������������������������������������������������������������������417 ■ Chapter 14: SOAP Web Services ������������������������������������������������������������������������������������455 ■ Chapter 15: RESTful Web Services ��������������������������������������������������������������������������������495 ■ Appendix A: Setting Up the Development Environment �������������������������������������������������539 Index ���������������������������������������������������������������������������������������������������������������������������������561 vi www.it-ebooks.info Introduction In today’s business world, applications need to access data, apply business logic, add presentation layers, be mobile, use geolocalization, and communicate with external systems and online services. That’s what companies are trying to achieve while minimizing costs, using standard and robust technologies that can handle heavy loads. If that’s your case, you have the right book in your hands. Java Enterprise Edition appeared at the end of the 1990s and brought to the Java language a robust software platform for enterprise development. Challenged at each new version, badly understood or misused, overengineered, and competing with open source frameworks, J2EE was seen as a heavyweight technology. Java EE benefited from these criticisms to improve and today focuses on simplicity. If you are part of the group of people who still think that “EJBs are bad, EJBs are evil,” read this book, and you’ll change your mind. EJBs (Enterprise Java Beans) are great, as is the entire Java EE 7 technology stack. If, on the contrary, you are a Java EE adopter, you will see in this book how the platform has found equilibrium through its ease of development and easy component model. If you are a beginner in Java EE, this is also the right book: it covers the most important specifications in a very understandable manner and is illustrated with a lot of code and diagrams to make it easier to follow. Open standards are collectively one of the main strengths of Java EE. More than ever, an application written with JPA, CDI, Bean Validation, EJBs, JSF, JMS, SOAP web services, or RESTful web services is portable across application servers. Open source is another of Java EE’s strengths. As you’ll see in this book, most of the Java EE 7 Reference Implementations use open source licensing (GlassFish, EclipseLink, Weld, Hibernate Validator, Mojarra, OpenMQ, Metro, and Jersey). This book explores the innovations of this new version, and examines the various specifications and how to assemble them to develop applications. Java EE 7 consists of nearly 30 specifications and is an important milestone for the enterprise layer (CDI 1.1, Bean Validation 1.1, EJB 3.2, JPA 2.1), for the web tier (Servlet 3.1, JSF 2.2, Expression Language 3.0), and for interoperability (JAX-WS 2.3 and JAX-RS 2.0). This book covers a broad part of the Java EE 7 specifications and uses the JDK 1.7 and some well-known design patterns, as well as the GlassFish application server, the Derby database, JUnit, and Maven. It is illustrated abundantly with UML diagrams, Java code, and screenshots. How the Book Is Structured This book concentrates on the most important Java EE 7 specifications and highlights the new features of this release. The structure of the book follows the architectural layering of an application. xxxiii www.it-ebooks.info ■ IntroduCtIon Chapter 1 briefly presents Java EE 7 essentials and Appendix A highlights the tools used throughout the book and how to install them (JDK, Maven, JUnit, Derby, and GlassFish). In the first chapters, I explain the common concerns discussed throughout the book. Chapter 2 describes Context and Dependency Injection 1.1 and Chapter 3 looks at Bean Validation 1.1. Chapters 4 through 6 describe the persistent tier and focus on JPA 2.1. After a general overview with some hands-on examples in Chapter 4, Chapter 5 dives into object-relational mapping (mapping attributes, relationships, and inheritance), while Chapter 6 shows you how to manage and query entities, their life cycle, callback methods, and listeners. To develop a transaction business logic layer with Java EE 7, you can naturally use EJBs. Chapters 7 through 9 describe this process. After an overview of the specification and its history, Chapter 7 concentrates on session beans and their programming model. Chapter 8 focuses on the life cycle of EJBs, the timer service, and how to handle authorization. Chapter 9 explains transactions and how JTA 1.2 brings transactions to EJBs as well as CDI Beans. In Chapters 10 and 11 you will learn how to develop a presentation layer with JSF 2.2. After an overview of the specification, Chapter 10 focuses on how to build a web page with JSF and Facelets components. Chapter 11 shows you how to interact with an EJB back end with CDI backing beans and navigate through pages. Finally, the last chapters present different ways to interoperate with other systems. Chapter 12 explains how to process XML (using JAXB and JAXP) and JSON (JSON-P 1.0). Chapter 13 shows you how to exchange asynchronous messages with the new JMS 2.0 and Message-Driven Beans. Chapter 14 focuses on SOAP web services, while Chapter 15 covers RESTful web services with the new JAX-RS 2.0. Downloading and Running the Code The examples used in this book are designed to be compiled with the JDK 1.7, to be built with Maven 3, to be deployed on GlassFish v4 application server, and to store data in a Derby database. Appendix A shows you how to install all these software packages, and each chapter explains how to build, deploy, run, and test components depending on the technology used. The code has been tested on the Mac OS X platform (but should also work on Windows or Linux). The source code of the examples in the book is available from the Source Code page of the Apress web site at www.apress.com. You can also download the code straight from the public GitHub at https://github.com/agoncal/agoncal-book-javaee7. Contacting the Author If you have any questions about the content of this book, the code, or any other topic, please contact the author at [email protected]. You can also visit his web site at www.antoniogoncalves.org and follow him on Twitter at @agoncal. xxxiv www.it-ebooks.info Chapter 1 Java EE 7 at a Glance Enterprises today live in a globally competitive world. They need applications to fulfill their business needs, which are getting more and more complex. In this age of globalization, companies are distributed over continents, they do business 24/7 over the Internet and across different countries, have several datacenters, and internationalized systems which have to deal with different currencies and time zones—all that while reducing their costs, lowering the response times of their services, storing business data on reliable and safe storage, and offering several mobile and web interfaces to their customers, employees, and suppliers. Most companies have to combine these complex challenges with their existing enterprise information systems (EIS) at the same time developing business-to-business applications to communicate with partners or business-to-customer systems using mobile and geolocalized applications. It is also not rare for a company to have to coordinate in-house data stored in different locations, processed by multiple programming languages, and routed through different protocols. And, of course, it has to do this without losing money, which means preventing system crashes and being highly available, scalable, and secure. Enterprise applications have to face change and complexity, and be robust. That’s precisely why Java Enterprise Edition (Java EE) was created. The first version of Java EE (originally known as J2EE) focused on the concerns that companies were facing back in 1999: distributed components. Since then, software applications have had to adapt to new technical solutions like SOAP or RESTful web services. The Java EE platform has evolved to respond to these technical needs by providing various ways of working through standard specifications. Throughout the years, Java EE has changed and became richer, simpler, easier to use, more portable, and more integrated. In this chapter, I’ll give you an overview of Java EE. After an introduction to its internal architecture, components, and services, I’ll cover what’s new in Java EE 7. Understanding Java EE When you want to handle collections of objects, you don’t start by developing your own hashtable; you use the collection API (application programming interface). Similarly, if you need a simple Web application or a transactional, secure, interoperable, and distributed application, you don’t want to develop all the low-level APIs: you use the Enterprise Edition of Java. Just as Java Standard Edition (Java SE) provides an API to handle collections, Java EE provides a standard way to handle transactions with Java Transaction API (JTA), messaging with Java Message Service (JMS), or persistence with Java Persistence API (JPA). Java EE is a set of specifications intended for enterprise applications. It can be seen as an extension of Java SE to facilitate the development of distributed, robust, powerful, and highly available applications. Java EE 7 is an important milestone. Not only does it follow in the footsteps of Java EE 6 by focusing on an easier development model, but it also adds new specifications, as well as adding new functionalities to existing ones. Moreover, Context and Dependency Injection (CDI) is becoming the integration point between all these new specifications. The release of Java EE 7 coincides closely with the 13th anniversary of the enterprise platform. It combines the advantages of the Java language with experience gained over the last 13 years. Java EE profits from the dynamism of open source communities as well as the rigor of the JCP (Java Community Process) standardization process. Today Java EE is a well-documented platform with experienced developers, a large community, and many 1 www.it-ebooks.info Chapter 1 ■ Java ee 7 at a GlanCe deployed applications running on companies’ servers. Java EE is a suite of APIs that can be used to build standard component-based multitier applications. These components are deployed in different containers offering a series of services. Architecture Java EE is a set of specifications implemented by different containers. Containers are Java EE runtime environments that provide certain services to the components they host such as life-cycle management, dependency injection, concurrency, and so on. These components use well-defined contracts to communicate with the Java EE infrastructure and with the other components. They need to be packaged in a standard way (following a defined directory structure that can be compressed into archive files) before being deployed. Java EE is a superset of the Java SE platform, which means Java SE APIs can be used by any Java EE components. Figure 1-1 shows the logical relationships between containers. The arrows represent the protocols used by one container to access another. For example, the web container hosts servlets, which can access EJBs through RMI-IIOP. Figure 1-1. Standard Java EE containers 2 www.it-ebooks.info Chapter 1 ■ Java ee 7 at a GlanCe Components The Java EE runtime environment defines four types of components that an implementation must support: • Applets are GUI (graphic user interface) applications that are executed in a web browser. They use the rich Swing API to provide powerful user interfaces. • Applications are programs that are executed on a client. They are typically GUIs or batch- processing programs that have access to all the facilities of the Java EE middle tier. • Web applications (made of servlets, servlet filters, web event listeners, JSP and JSF pages) are executed in a web container and respond to HTTP requests from web clients. Servlets also support SOAP and RESTful web service endpoints. Web applications can also contain EJBs Lite (more on that in Chapter 7). • Enterprise applications (made of Enterprise Java Beans, Java Message Service, Java Transaction API, asynchronous calls, timer service, RMI/IIOP) are executed in an EJB container. EJBs are container-managed components for processing transactional business logic. They can be accessed locally and remotely through RMI (or HTTP for SOAP and RESTful web services). Containers The Java EE infrastructure is partitioned into logical domains called containers (see Figure 1-1). Each container has a specific role, supports a set of APIs, and offers services to components (security, database access, transaction handling, naming directory, resource injection). Containers hide technical complexity and enhance portability. Depending on the kind of application you want to build, you will have to understand the capabilities and constraints of each container in order to use one or more. For example, if you need to develop a web application, you will develop a JSF tier with an EJB Lite tier and deploy them into a web container. But if you want a web application to invoke a business tier remotely and use messaging and asynchronous calls, you will need both the web and EJB containers. Java EE has four different containers: • Applet containers are provided by most web browsers to execute applet components. When you develop applets, you can concentrate on the visual aspect of the application while the container gives you a secure environment. The applet container uses a sandbox security model where code executed in the “sandbox” is not allowed to “play outside the sandbox.” This means that the container prevents any code downloaded to your local computer from accessing local system resources, such as processes or files. • The application client container (ACC) includes a set of Java classes, libraries, and other files required to bring injection, security management, and naming service to Java SE applications (swing, batch processing, or just a class with a main() method). The ACC communicates with the EJB container using RMI-IIOP and the web container with HTTP (e.g., for web services). • The web container provides the underlying services for managing and executing web components (servlets, EJBs Lite, JSPs, filters, listeners, JSF pages, and web services). It is responsible for instantiating, initializing, and invoking servlets and supporting the HTTP and HTTPS protocols. It is the container used to feed web pages to client browsers. • The EJB container is responsible for managing the execution of the enterprise beans (session beans and message-driven beans) containing the business logic tier of your Java EE application. It creates new instances of EJBs, manages their life cycle, and provides services such as transaction, security, concurrency, distribution, naming service, or the possibility to be invoked asynchronously. 3 www.it-ebooks.info Chapter 1 ■ Java ee 7 at a GlanCe Services Containers provide underlying services to their deployed components. As a developer, containers allow you to concentrate on implementing business logic rather than solving technical problems faced in enterprise applications. Figure 1-2 shows you the services provided by each container. For example, web and EJB containers provide connectors to access EIS, but not the applet container or the ACCs. Java EE offers the following services: • Java Transaction API: This service offers a transaction demarcation API used by the container and the application. It also provides an interface between the transaction manager and a resource manager at the Service Provider Interface (SPI) level. • Java Persistence API: Standard API for object-relational mapping (ORM). With its Java Persistence Query Language (JPQL), you can query objects stored in the underlying database. • Validation: Bean Validation provides class and method level constraint declaration and validation facilities. • Java Message Service: This allows components to communicate asynchronously through messages. It supports reliable point-to-point (P2P) messaging as well as the publish-subscribe (pub-sub) model. • Java Naming and Directory Interface: This API, included in Java SE, is used to access naming and directory systems. Your application uses it to associate (bind) names to objects and then to find these objects (lookup) in a directory. You can look up data sources, JMS factories, EJBs, and other resources. Omnipresent in your code until J2EE 1.4, JNDI is used in a more transparent way through injection. • JavaMail: Many applications require the ability to send e-mails, which can be implemented through use of the JavaMail API. • JavaBeans Activation Framework: The JAF API, included in Java SE, provides a framework for handling data in different MIME types. It is used by JavaMail. • XML processing: Most Java EE components can be deployed with optional XML deployment descriptors, and applications often have to manipulate XML documents. The Java API for XML Processing (JAXP) provides support for parsing documents with SAX and DOM APIs, as well as for XSLT. The Streaming API for XML (StAX) provides a pull-parsing API for XML. • JSON processing: New in Java EE 7 the Java API for JSON Processing (JSON-P) allows applications to parse, generate, transform, and query JSON. • Java EE Connector Architecture: Connectors allow you to access EIS from a Java EE component. These could be databases, mainframes, or enterprise resource planning (ERP) programs. • Security services: Java Authentication and Authorization Service (JAAS) enables services to authenticate and enforce access controls upon users. The Java Authorization Service Provider Contract for Containers (JACC) defines a contract between a Java EE application server and an authorization service provider, allowing custom authorization service providers to be plugged into any Java EE product. Java Authentication Service Provider Interface for Containers (JASPIC) defines a standard interface by which authentication modules may be integrated with containers so that these modules may establish the authentication identities used by containers. • Web services: Java EE provides support for SOAP and RESTful web services. The Java API for XML Web Services (JAX-WS), replacing the Java API for XML-based RPC (JAX-RPC), provides support for web services using the SOAP/HTTP protocol. The Java API for RESTful Web Services (JAX-RS) provides support for web services using the REST style. 4 www.it-ebooks.info