深入探索Java EE 7开发

5星 · 超过95%的资源需积分: 9 61 浏览量更新于2024-07-23 收藏 15.81MB PDF 举报

"Beginning Java EE 7.pdf 是一本详细介绍Java EE 7开发规范的书籍，适合初学者。书中涵盖了一系列关键章节，包括Java EE 7概述、上下文和依赖注入、bean验证、Java持久化API、对象关系映射、管理持久化对象、企业Java Beans、回调、定时服务和授权、事务处理、JavaServer Faces、处理和导航、XML及JSON处理、消息传递、SOAP Web服务以及RESTful Web服务。此外，还提供了设置开发环境的附录内容，便于读者实践学习。" Java EE 7是企业级应用开发的重要框架，这本书旨在引导读者掌握其核心概念和技术。以下是对书中的关键章节的详细说明： 1. **Java EE 7概述**：本章介绍了Java EE 7平台的基本概念，包括它为开发人员提供的主要功能，如Web服务、数据库集成、分布式计算等，以及相比之前的版本有哪些改进和新特性。 2. **上下文和依赖注入(CDI)**：CDI是Java EE 7中用于管理对象生命周期和依赖关系的组件。这里将阐述如何通过注解来声明和注入依赖，以及如何定义和使用自定义事件和上下文。 3. **Bean验证**：本章讨论了Bean Validation 1.1，它是Java EE 7中用于验证对象属性的标准。读者将学习如何定义和实现验证约束，以及在实际应用中如何进行数据验证。 4. **Java Persistence API (JPA)**：JPA允许开发者以声明式的方式处理对象-关系映射(ORM)。这章会介绍实体管理、查询语言(JPQL)和 Criteria API，以及如何配置数据源和事务策略。 5. **对象关系映射(O/R Mapping)**：这部分深入探讨了如何将Java对象与数据库表关联，包括实体类的创建、关系映射、懒加载和级联操作。 6. **管理持久化对象**：此章节关注于如何在Java EE 7环境中保存、更新和删除持久化对象，以及如何处理并发和数据一致性问题。 7. **企业Java Beans(EJB)**：EJB是Java EE的核心组件，用于构建可扩展、可靠的业务逻辑。本章将涵盖无状态和有状态bean，以及会话bean和消息驱动bean的使用。 8. **回调、定时服务和授权**：这部分内容涉及到EJB的生命周期回调方法、定时任务的设定以及安全性，包括角色和权限的管理。 9. **事务处理**：讲解Java EE 7中的事务管理，包括自动事务传播、声明式事务和编程式事务控制。 10. **JavaServer Faces(JSF)**：JSF是用于构建用户界面的MVC框架。本章会介绍组件库、导航结构、数据绑定和事件处理。 11. **处理和导航**：这部分涉及JSF的请求处理和页面导航，如何根据用户行为控制应用程序流程。 12. **XML和JSON处理**：XML用于数据交换，而JSON更适合轻量级交互。本章将讲解如何在Java EE 7中解析和生成XML和JSON文档。 13. **消息传递**：介绍了Java Message Service (JMS)，用于异步通信和解耦应用组件。 14. **SOAP Web服务**：讲解如何在Java EE 7中创建、消费和测试基于SOAP协议的Web服务。 15. **RESTful Web服务**：REST是一种简化Web服务设计的方法，本章将指导读者使用Java API for RESTful Web Services (JAX-RS)创建REST服务。 16. **附录A：设置开发环境**：提供了详细的步骤，帮助读者配置Java EE 7开发环境，包括服务器和IDE的安装与配置。这本书为读者提供了一个全面的Java EE 7学习路径，从基础到高级，覆盖了开发企业级应用所需的关键技术。无论你是刚接触Java EE的新手，还是希望深入理解这一平台的开发者，都将从中受益匪浅。

CHAPTER 1 ■ JAVA EE 7 AT A GLANCE

In the early days of Java, if you were doing any kind of web or enterprise development, you were living in a

proprietary world by creating your own frameworks or locking yourself to a proprietary commercial framework. Then

came the days of open source frameworks, which are not always based on open standards. You can use open source

and be locked to a single implementation, or use open source that implements standards and be portable. Java EE

provides open standards that are implemented by several commercial (WebLogic, Websphere, MQSeries, etc.) or

open source (GlassFish, JBoss, Hibernate, Open JPA, Jersey, etc.) frameworks for handling transactions, security,

stateful components, object persistence, and so on. Today, more than ever in the history of Java EE, your application

can be deployed to any compliant application server with very few changes.

JCP

The JCP is an open organization, created in 1998 by Sun Microsystems, that is involved in the definition of future

versions and features of the Java platform. When the need for standardizing an existing component or API is

identified, the initiator (a.k.a. specification lead) creates a JSR and forms a group of experts. This group, made of

companies’ representatives, organizations, universities, or private individuals, is responsible for the development of

the JSR and has to deliver:

One or more specifications that explain the details and define the fundamentals of the JSR •

(Java Specification Request),

A • Reference Implementation (RI), which is an actual implementation of the specification,

• Compatibility Test Kit (a.k.a. Technology Compatibility Kit, or TCK), which is a set of tests every

implementation needs to pass before claiming to conform to the specification.

Once approved by the executive committee (EC), the specification is released to the community for

implementation.

Portable

From its creation, the aim of Java EE was to enable the development of an application and its deployment to

any application server without changing the code or the configuration files. This was never as easy as it seemed.

Specifications don’t cover all the details, and implementations end up providing nonportable solutions. That’s what

happened with JNDI names, for example. If you deployed an EJB to GlassFish, JBoss, or WebLogic, the JNDI name

was different because it wasn’t part of the specification, so you had to change your code depending on the application

server you used. That particular problem, for example, was fixed in Java EE by specifying a syntax for JNDI names.

Today, the platform has introduced more portable configuration properties than ever, thus increasing portability.

Despite having deprecated some APIs (pruning), Java EE applications keep their backward compatibility, letting you

migrate your application to newer versions of an application server without too many problems.

Programming Model

Most of the Java EE 7 specifications use the same programming model. It’s usually a POJO with some metadata

(annotations or XML) deployed into a container. Most of the time the POJO doesn’t even implement an interface

or extend a superclass. Thanks to the metadata, the container knows which services to apply to this deployed

component.

In Java EE 7, servlets, JSF backing beans, EJBs, entities, SOAP and REST web services are annotated classes with

optional XML deployment descriptors. Listing 1-3 shows a JSF backing bean that turns out to be a Java class with

a single CDI annotation.

www.it-ebooks.info

CHAPTER 1 ■ JAVA EE 7 AT A GLANCE

Listing 1-5. A RESTful Web Service

@Path("books")

public class BookResource {

@Inject

private EntityManager em;

@GET

@Produces({"application/xml", "application/json"})

public List<Book> getAllBooks() {

Query query = em.createNamedQuery("findAllBooks");

List<Book> books = query.getResultList();

return books;

}

Throughout the chapters of this book you will come across this kind of code where components only contain business

logic and where metadata are represented by annotations (or XML) to ensure that the container applies the right services.

Java Standard Edition 7

It’s important to stress that Java EE is a superset of Java SE. This means that all the features of the Java language are

available in Java EE as well as the APIs.

Java SE 7 was officially released on July 2011. It was developed under JSR 336 and brought many new features as

well as continuing the ease of development introduced by Java SE 5 (autoboxing, annotations, generics, enumeration,

etc.) and Java SE 6 (diagnosing, managing, and monitoring tools, JMX API, simplified execution of scripting languages

in the Java Virtual Machine). Java SE 7 aggregates the JSR 334 (better known under the name of Project Coin), JSR 292

(InvokeDynamic, or support of dynamic languages in the JVM), JSR 203 (the new API I / O, commonly called NIO.2)

and several updates of existing specifications (such as JDBC 4.1 (JSR 221). Even if this book does not explicitly cover

Java SE 7, some of these enhancements will be used throughout the book samples so I just want to give you a quick

overview of what the samples could look like.

String Case

Before Java SE 7 only numbers (byte, short, int, long, char) or enumerations could be used in switch cases. It is now

possible to use a switch on a Strcompare alphanumerical values. This avoids long lists of if/then/else and makes the

code more readable. Listing 1-6 shows you what you can now write in your applications.

Listing 1-6. A String Case

String action = "update";

switch (action) {

case "create":

create();

break;

case "read":

read();

break;

case "udpate":

udpate();

break;

www.it-ebooks.info

剩余596页未读，继续阅读

stayeveryoung

粉丝: 6
资源: 31

深入探索Java EE 7开发

Java.EE.7.pdf.zip

JavaEE开发的颠覆者完整版.pdf

Beginning JavaEE 7

for {set ii 1} {$ii<=25} {incr ii} { puts "The $ii th Time history analysis is Beginning..............." if {[file exists outputBWPZ[expr $ii]]==0} { file mkdir outputBWPZ[expr $ii];请帮我解释并优化这段代码

JavaEE详细参考文献

Can not find the tag library descriptor for "http://java.sun.com/jsp/jstl/core"

Parses text from the beginning of the given string to produce a date. The method may not use the entire text of the given string.

Java 获取Kafka的topic的offset

Write the while loop that reads each line from the console input stream and prints the line out to the file. Each line should be prepended with the count of the line number. in java

最新资源