Java^TM 2 Bible , Enterprise Edition

by Justin Couch; Daniel H. Steinberg

• ISBN13: 9780764508820
• ISBN10: 0764508822
• Format: Paperback
• Copyright: 2002-01-01
• Publisher: Wiley

Summary

Sun Microsystems2 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.

Author Biography

<b>Justin Couch</b> spends most of his time in Australia but travels extensively in the United States and England as a trainer and consultant. He is the author of Java 2 Bible (Hungry Minds) and Java 2 Networking (McGraw-Hill). <p> gt;Daniel H. Steinberg</b> is from Oberlin, Ohio where he is a Mathematics Professor at Oberlin College. He is coauthor of Java 2 Bible and editor of IBM's developerWorks JavaZone.

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 application	6	(3)
The building blocks of an enterprise application	9	(2)
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(), forward(), and include()	54	(6)
Using filters with servlets	55	(2)
Passing control between servlets using forward()	57	(2)
Including content from one resource in another	59	(1)
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 Searches	123	(122)
Interacting with Relational Databases	125	(24)
What is a Relational Database?	126	(4)
How data is structured in a relational database	126	(2)
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 of JDBC	150	(1)
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 a query	166	(6)
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 database?	200	(2)
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 service	242	(2)
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 installation	323	(1)
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 documents	385	(2)
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 generates	390	(3)
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 server	399	(1)
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 directories on one machine	407	(2)
Running an http class server	409	(1)
Running the application from two different machines	409	(2)
Using Non-Remote Objects	411	(5)
Sending a Person object instead of a string	411	(3)
Object serialization	414	(1)
Performance problems	415	(1)
Activating Services	416	(4)
Changing the implementation of the Remote interface	417	(1)
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 interfaces	433	(2)
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 application	500	(2)
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 techniques	544	(1)
Providing system-agnostic configuration properties	545	(1)
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 Application	586	(1)
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 application	603	(4)
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 substracting services	631	(1)
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 (SOAP)	669	(4)
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 HelloService	691	(3)
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 messages	729	(9)
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 your application	805	(1)
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 J2EE	823	(7)
Summary	830	(1)
Appendix A: Installing the J2EE Reference Implementation	831	(46)
Appendix B: J2EE API Version Requirements	877	(4)
Appendix C: J2EE Vendors and Systems	881	(8)
Glossary	889	(6)
Index	895