Java 2 Enterprise Edition Bible

Java 2 Enterprise Edition Bible

  • ただいまウェブストアではご注文を受け付けておりません。 ⇒古書を探す
  • 製本 Paperback:紙装版/ペーパーバック版/ページ数 936 p.
  • 言語 ENG,ENG
  • 商品コード 9780764508820
  • DDC分類 005

Full Description


Sun Microsystems' Java 2 Platform, Enterprise Edition (J2EE) defines the standard for developing multitier enterprise applications - and the "Java 2 Enterprise Edition Bible" defines the standard for comprehensive coverage of this exciting development tool! This book covers all the primary technologies of J2EE, including: Enterprise JavaBeans, Java Server Pages, servlets, the Java Naming and Directory Interface (JNDI), the Java Transaction API (JTA), CORBA, and the JDBC data access API. It also explains how XML works with Java. Developers can rely on this book to provide detail on developing and deploying a complete, stable, secure, fast Java platform to the enterprise level.

Table of Contents

Preface                                            vii
Acknowledgments xi
Part I: Getting Started 1 (34)
Defining the Enterprise 3 (20)
Introducing Enterprise Applications 3 (8)
Not just a pretty Web site 4 (2)
The architecture of an enterprise 6 (3)
application
The building blocks of an enterprise 9 (2)
application
Introducing J2EE 11 (8)
A brief history of Enterprise Java 12 (1)
Navigating J2EE 13 (4)
Not just for the enterprise application 17 (1)
Deciding which parts to use 17 (2)
Getting Started 19 (3)
Downloading and installing J2EE 19 (1)
Deciding on a Project 20 (2)
Summary 22 (1)
Introducing Enterprise Applications 23 (12)
Business-to-Consumer Applications 24 (4)
Example 1: E-commerce Web site 24 (2)
Example 2: Aircraft reservation system 26 (2)
Business-to-Business Applications 28 (3)
Example 1: Inventory system 28 (2)
Example 2: Electronic payments 30 (1)
Back-End Applications 31 (2)
Example 1: Telco applications 31 (1)
Example 2: Monthly electronic newsletter 32 (1)
Summary 33 (2)
Part II: Delivering Content 35 (88)
Creating Dynamic Content with Servlets 37 (26)
What is a Servlet? 37 (2)
Creating a Basic Http Servlet 39 (8)
Using a servlet to create a static page 39 (2)
Tidying up---where to put your servlets 41 (2)
Adding dynamic elements 43 (4)
Introducing the Servlet APIs 47 (5)
The Servlet Family 47 (2)
The Servlet Request Family 49 (2)
The Servlet Response family 51 (1)
Saving and Sharing Information 52 (2)
Session tracking 52 (1)
Using the Servlet Context 53 (1)
Adding Functionality with Filter(), 54 (6)
forward(), and include()
Using filters with servlets 55 (2)
Passing control between servlets using 57 (2)
forward()
Including content from one resource in 59 (1)
another
Summary 60 (3)
Using Java Server Pages 63 (28)
Creating a Basic JSP Page 64 (5)
Creating, saving, and accessing a page 64 (1)
The JSP life cycle 65 (2)
Adding dynamic elements to the JSP 67 (2)
Putting the ``J'' in JSP 69 (7)
Embedding Java code in a JSP page 70 (2)
Using JSP directives 72 (2)
Transferring control with actions 74 (1)
Accessing implicit Java objects 75 (1)
Adding JavaBeans 76 (6)
Bean property conventions 77 (2)
JSP bean tags 79 (3)
Using Custom Tags 82 (6)
A class that returns the current time 82 (1)
The tag library descriptor 83 (1)
A JSP page that uses a custom tag 84 (1)
Putting one tag inside another 85 (1)
Attributes in custom tags 86 (2)
Bringing JSPs and Servlets Together 88 (1)
Summary 88 (3)
Sending and Receiving Mail With JavaMail 91 (32)
What is E-mail? 91 (8)
A day in the life of an e-mail 92 (2)
The format of a mail message 94 (3)
Types of servers 97 (2)
Introducing JavaMail 99 (2)
The JavaMail package 100(1)
JavaMail requirements 100(1)
Downloading JavaMail 100(1)
JavaMail terminology 101(1)
Sending an E-mail 101(10)
Setting up e-mail 102(2)
Constructing a message 104(2)
Sending a message 106(1)
Sending to newsgroups 106(1)
Messages with attachments 107(4)
Receiving an E-mail 111(5)
Preparing to receive mail 112(1)
Managing incoming mail 113(3)
Building E-mail Filters 116(5)
Constructing a Search 116(3)
Managing messages 119(2)
Summary 121(2)
Part III: Finding Things with Databases and 123(122)
Searches
Interacting with Relational Databases 125(24)
What is a Relational Database? 126(4)
How data is structured in a relational 126(2)
database
Agreeing on a language to communicate 128(1)
Finding a database to use 129(1)
Defining Information in an RDBMS 130(9)
An introduction to SQL 130(1)
Designing a new database 131(1)
Using data types to represent data 132(2)
Managing tables 134(3)
Improving performance of a database 137(2)
Managing Data 139(3)
Creating a new entry 140(1)
Updating an existing entry 141(1)
Deleating entries 142(1)
Searching for Information 142(5)
Creating simple searches 143(2)
Facilitating complex interactions 145(2)
Summary 147(2)
Using JDBC to Interact with SQL Databases 149(46)
Java Abstractions of a Database 149(3)
A bit of history about the introduction 150(1)
of JDBC
Hiding the implementation 150(2)
Getting Started 152(5)
Finding the JDBC classes 153(1)
Introducing JDBC drivers 154(2)
Finding drivers for your database 156(1)
Connecting to a Database 157(8)
Representing a single database Connection 157(2)
Connecting using the core classes 159(3)
Connecting using the enterprise classes 162(3)
Database Data Structures 165(15)
Mapping SQL types to Java types 165(1)
Representing the returned information of 166(6)
a query
Taking the results home with you 172(4)
Managing custom datatypes 176(4)
Interacting with the Database 180(8)
Representing an SQL Statement within Java 180(4)
Querying the Database for information 184(2)
Making updates to the database 186(2)
Using Enterprise Features 188(6)
Batching a collection of actions together 188(3)
Pooling statements for faster access 191(1)
Managing transactions 191(3)
Summary 194(1)
Working with Directory Services and LDAP 195(28)
Introducing Directory Services 195(4)
What is a directory service? 196(2)
When should I use a Directory Service? 198(1)
Introducing LDAP 199(5)
A brief history of LDAP 199(1)
How is data structured in an LDAP 200(2)
database?
Standard languages 202(1)
Software using LDAP 203(1)
Defining Information in an LDAP Database 204(9)
Designing a new database 204(5)
An Introduction to standard LDAP 209(4)
Interacting with the Database 213(2)
Connecting to the database 213(1)
Searching an LDAP database 213(2)
Modifying values in an LDAP database 215(1)
Building Custom Data Structures 215(6)
Data hierarchies 215(2)
Replication 217(1)
Schemas 218(3)
Summary 221(2)
Accessing Directory Services with JNDI 223(22)
Java Abstraction of Directory Services 223(3)
A brief history of JNDI 224(1)
Hiding the implementation 224(1)
Packages and classes 225(1)
Connecting to a Service 226(10)
What is in a connection? 226(3)
Connecting to naming services 229(3)
Connecting to directory services 232(4)
Interacting with Databases 236(8)
Generalized searching 236(4)
Modifying existing data 240(2)
Changing the structure of the directory 242(2)
service
Summary 244(1)
Part IV: Communicating Between Systems With XML 245(150)
Building an XML Foundation 247(24)
What is XML? 247(6)
Creating XML 248(2)
Displaying XML 250(1)
Two views of the same document 251(2)
XML for Documents and Presentation 253(4)
A resume in Word 253(2)
A resume in HTML 255(1)
A resume in XML 256(1)
XML for Configuration 257(2)
XML for Storing and Sharing Data 259(5)
Serializing using Object Output Stream 260(1)
Saving state using XML 261(3)
XML Syntax 264(5)
Elements 264(2)
Namespaces 266(1)
Attributes 267(2)
Summary 269(2)
Describing Documents with DTDs and Schemas 271(22)
Producing Valid XML Documents 272(4)
Reading a DTD 273(1)
Connecting the document and the DTD 274(2)
Writing Document Type Definitions (DTDs) 276(5)
Declaring elements 276(3)
Declaring entities 279(1)
Declaring attributes 280(1)
Validating XML 281(2)
Describing Documents with XML Schemas 283(8)
The shell of a schema 284(1)
Elements and Attributes 285(1)
Simple types 286(2)
Complex types 288(3)
Summary 291(2)
Parsing Documents with JAXP 293(28)
Introducting JAXP 293(9)
The JAX Pack 294(1)
Installing JAXP and the Examples 294(1)
Testing the installation 295(2)
The Play's the thing 297(1)
Checking for well-formed documents 298(2)
Validating 300(2)
Reaching for SAX 302(6)
Using SAX callbacks 303(2)
Events handled by DefaultHandler 305(3)
Using the DOM 308(12)
Creating a document 308(2)
Navigating a document 310(5)
Creating XML 315(5)
Summary 320(1)
Interacting with XML Using JDOM 321(22)
Using JDOM 322(6)
Why, why, why 322(1)
Installing JDOM and testing the 323(1)
installation
Revisiting the DOM examples 323(5)
The JDOM APIs 328(12)
Creating a document 329(4)
Working with the document 333(4)
Outputting the document 337(3)
Summary 340(3)
Transforming and Binding Your XML Documents 343(52)
Presenting XML 343(16)
Using cascading style sheets 344(4)
Presenting a document with XSLT 348(11)
Transforming XML 359(8)
A second DTD for Shakespeare's plays 360(1)
Translating with a style sheet 361(6)
Binding with JAXB 367(18)
Installing and running JAXB 367(2)
Introducing the user-stories example 369(2)
Refining the binding schema 371(4)
The file User Story.java 375(10)
Using the JAXB Bindings 385(8)
Unmarshalling: Java objects from XML 385(2)
documents
Adding to the content tree 387(1)
Validating your objects 388(1)
Marshalling: Java objects to XML documents 389(1)
Extending the classes the schema compiler 390(3)
generates
Summary 393(2)
Part V: Abstracting the System 395(264)
Exploring the RMI Mechanism 397(24)
The Components of a Basic RMI Application 397(7)
The Remote interface 398(1)
Implementing the Remote interface on the 399(1)
server
Starting up the service 400(1)
Turning to the client 401(1)
Compiling the code 402(1)
Running the RMI application 403(1)
Running a Distributed Version 404(7)
Splitting the files into two directories 404(1)
Creating and calling a security policy 405(2)
Setting the codebase 407(1)
Running the application from two 407(2)
directories on one machine
Running an http class server 409(1)
Running the application from two 409(2)
different machines
Using Non-Remote Objects 411(5)
Sending a Person object instead of a 411(3)
string
Object serialization 414(1)
Performance problems 415(1)
Activating Services 416(4)
Changing the implementation of the Remote 417(1)
interface
Modifying the setup class 418(1)
Running the example 419(1)
Summary 420(1)
Introducing Enterprise JavaBeans 421(64)
Introducing a New Level of Abstraction 422(4)
Who am I? 422(2)
Finding a development environment 424(2)
Exploring the Components of an EJB Service 426(9)
Terminology of the EJB application 426(2)
Types of beans 428(3)
A sample application 431(2)
An introduction to the EJB classes and 433(2)
interfaces
Using Enterprise Beans on the Server Side 435(38)
Session beans 435(12)
Entity beans 447(18)
Home interfaces and kicking off 465(3)
Deploying beans to an EJB server 468(5)
Using Enterprise Beans on the Client Side 473(11)
Looking up and using beans 473(2)
Beans in the wild 475(9)
Summary 484(1)
Using Advanced EJB Techniques 485(66)
Extending Enterprise Beans 485(14)
Local beans for better Performance 486(5)
Method-data granularity 491(4)
Inter-bean communication 495(1)
Combining beans in transactions 496(3)
Using Message-Driven Beans 499(6)
The role of message-driven beans in an 500(2)
application
Coding a message-driven bean 502(3)
Understanding Container-Managed Persistence 505(27)
Introducing CMP entity concepts 505(2)
Writing a CMP entity bean 507(11)
Container-managed relationships 518(8)
EBJ QL 526(6)
Managing Bean-Security Issues 532(11)
Identifying the user 532(4)
Profiling the user for access capabilities 536(7)
Dealing with Bean-Configuration Issues 543(3)
Summary of existing configuration 544(1)
techniques
Providing system-agnostic configuration 545(1)
properties
Who is Looking After the Code? 546(4)
EJB development roles 547(1)
Non-development roles 548(2)
Summary 550(1)
Introducing CORBA 551(38)
The Need for CORBA 551(1)
What is CORBA? 552(1)
The Object Management Architecture 553(23)
Object services 553(1)
Common facilities 553(1)
Domain interfaces 554(1)
Application interfaces 554(1)
Object Request Broker 554(21)
The idltojava compiler 575(1)
Example: Calculating Simple Interest 576(11)
Step 1: Writing the IDL interface 576(1)
Step 2: Compiling the IDL file 577(1)
Step 3: Coding the InterestServer 578(5)
Step 4: Coding the Client 583(3)
Step 5: Compiling and Running the 586(1)
Application
CORBA Services 587(1)
Differences Between CORBA and RMI 588(1)
Summary 588(1)
CORBA Applications in the Enterprise 589(28)
Build the CORBA Object 590(1)
Develop the CORBA Server 591(12)
Develop the CORBA Client 603(13)
Accessing the CORBA Objects from a client 603(4)
application
Compiling and running the application 607(2)
Accessing the CORBA object from servlets 609(5)
Compiling and running the servlet 614(2)
Summary 616(1)
Why Dream of Jini? 617(42)
A Quick Look at Jini 617(2)
Why do we need Jini? 618(1)
Jini resources 619(1)
Introducing Our Example 619(2)
The Calculator interface 620(1)
The Adder and Subtractor classes 620(1)
The Client 621(1)
Getting Jini Up and Running 621(8)
Installing Jini 622(1)
The GUI tool 623(6)
A Simple Proxy Jini Calculator Service 629(13)
The Calculator interface 630(1)
The proxies for the adding and 631(1)
substracting services
Create the services 632(2)
The Jini Calculator client 634(3)
Compile the application 637(1)
Run the distributed application 638(4)
Use Attributes in the Jini Calculator 642(6)
Set a service's attributes 642(2)
Create filters on the client side 644(2)
Use ServiceItemFilter objects 646(2)
Run the example 648(1)
Cache the Services 648(6)
A simple LookupCache example 649(2)
Use a ServiceDiscoveryListener 651(3)
Use RMI Stubs as Thin Proxies 654(3)
The RMI version of the proxy 655(1)
The RMIAddingService 655(2)
Summary 657(2)
Part VI: Building Big Systems 659(172)
Implementing Web Services 661(40)
A Hello World Service 662(7)
Setting up Axis 662(1)
A Hello World Web service client 663(1)
A local greeting service 664(2)
Behind the scenes with tcpmon 666(3)
Understanding Simple Object Access Protocol 669(4)
(SOAP)
The structure of a SOAP message 669(3)
SOAP and HTTP 672(1)
Deploying Web Services 673(4)
Setting up for the example 673(1)
Using deployment descriptors 674(1)
Running your deployed service 675(2)
Finding Web Services with UDDI 677(4)
UDDI resources 677(2)
Exploring Web services using UDDI 679(2)
Creating and Working with WSDL files 681(10)
Generating a WSDL files from HelloService 681(2)
Generating the client from the WSDL 683(6)
Using WSDL files to create a service 689(2)
Sending a Java Object to your Web Service 691(8)
The classes for the JavaBean version of 691(3)
HelloService
Deploying and running the application 694(2)
Sending a JavaBean 696(3)
Summary 699(2)
JMS 701(46)
Messages in the Middle 701(1)
Life before JMS 702(1)
MOM Meets JMS 702(1)
JMS for application independence 702(1)
Pure JMS providers 703(1)
Types of Messaging Systems 703(1)
Point-to-point 703(1)
Publish/subscribe 703(1)
JMS Overview 704(6)
Messaging terminology 704(1)
Interface overview 705(4)
Operational overview 709(1)
JMS System Setup 710(1)
Administered Objects 710(2)
Sending and Receiving Messages 712(10)
Point-to-point---sending messages 712(2)
Point-to-point---receiving messages 714(1)
Publish/subscribe---sending messages 715(2)
Publish/subscribe---receiving messages 717(1)
MessageListeners 718(1)
Connections and Sessions 719(3)
Messages in Detail 722(5)
Message header 722(2)
Message Properties 724(1)
Message body 724(3)
Application Development with JMS 727(2)
Connections and Sessions 727(1)
Resource management 727(1)
Persistence and durable subscriptions 728(1)
JMS and threads 728(1)
JMS transactions 728(1)
Putting it All Together---an Example 729(14)
Simple sending and receiving of text 729(9)
messages
Add properties 738(2)
Add message selection 740(3)
JMS and J2EE 743(3)
Connect to corporate and legacy systems 743(1)
Message-driven beans 743(2)
Distributed applications 745(1)
Summary 746(1)
Managing Transactions with JTA/JTS 747(52)
What Are Transactions? 748(11)
Transaction requirements 748(1)
Transaction-processing terms 749(2)
Transaction-processing components 751(3)
Distributed transactions 754(1)
Two-phase commit 755(1)
Transaction-processing standards 755(4)
Java Transaction Service 759(1)
Java Transaction API 760(5)
JTA interfaces and classes 761(1)
The UserTransaction interface 762(1)
The Status interface 763(1)
The Synchronization interface 764(1)
How Do I Use JTA/JTS? 765(13)
Container-Managed transactions 765(3)
When things go awry 768(1)
Reinitialize session beans 769(4)
Bean-managed transactions 773(3)
Transaction timeout 776(1)
Transaction isolation 777(1)
ACME Widgets Inc.---A Shopping-Cart Demo 778(20)
Create the database and tables 779(1)
The Order session bean 780(4)
The Inventory session bean 784(5)
The Catalog session bean 789(3)
The shopping-cart client application 792(2)
Packaging and deploying 794(2)
Setting up the data source 796(1)
Running the Shopping Cart demo 797(1)
Summary 798(1)
System Architecture Issues 799(18)
Designing Real-World Systems 799(5)
Understanding the Customer 800(2)
Being nice to the neighbors 802(2)
Dividing up the Workload 804(5)
Assigning work to the various tiers of 805(1)
your application
When one is not enough 806(3)
Choosing a Design 809(3)
Large-Scale technology options 809(3)
Design Options 812(1)
Implementing Security 812(3)
Securing the connections 813(1)
Securing the data 813(1)
Securing the system 814(1)
Securing the users 814(1)
Summary 815(2)
J2EE Design Patterns 817(14)
Design-Pattern Basics 817(5)
What is a Design pattern? 817(2)
Design patterns in the core Java libraries 819(3)
Introducing Enterprise Design Patterns 822(8)
The role of enterprise design patterns 823(1)
Standard enterprise design patterns for 823(7)
J2EE
Summary 830(1)
Appendix A: Installing the J2EE Reference 831(46)
Implementation
Appendix B: J2EE API Version Requirements 877(4)
Appendix C: J2EE Vendors and Systems 881(8)
Glossary 889(6)
Index 895