Apr 30, 2008

Pro PHP XML and Web Services


How This Book Is Structured

For you to get the most out of XML and Web services in PHP, this book is really grouped into three sections. The first section contains terminology and technical information about XML. This includes the concepts and structure of an XML document, validation, and other XML technologies commonly used. The chapters covering this information are based on various specifications. These specifications often use cryptic language and are difficult to understand, so I distill the information in clear terms.

The next group of chapters covers how to parse and manipulate XML documents using some of the extensions in PHP. I explain each extension and its API in detail with real-world examples to help reenforce the concepts covered. I also compare and contrast the extensions, providing you with some insight about where a particular extension excels and how it may not be the correct one to use in a particular situation.

The last group of chapters covers Web services. Although only a single native Web service extension exists in PHP (SOAP), I will provide in-depth coverage of additional technologies using
the extensions from earlier chapters. In addition, I will cover how to integrate with the Yahoo, Google, Amazon, and eBay Web services. Specifically, the chapters break down as follows:

Chapter 1, “Introduction to XML and Web Services”: This chapter provides some background information about XML and Web services. In addition, the chapter defines what these terms mean, explains the history of how they came about, and shows some examples of how XML is used in the real world.

Chapter 2, “XML Structure”: The XML 1.0 specification defines what XML is and the structure of documents but uses language that is not always so straightforward. This chapter explains the structure of an XML document in simple terms and provides some lucid examples. In addition, this chapter introduces some terminology used throughout the book.

Chapter 3, “Validation”: This chapter explains the use of validation in XML using Document Type Definitions (DTDs), XML Schemas, and RELAX NG.

Chapter 4, “XPath, XPointer, XInclude, and the Future”: The focus of this chapter is explaining how to write XPath expressions to query an XML document. You can use XPath with a few of the PHP extensions, and XPath serves as the foundation for XSLT in Chapter 10. The chapter also explains both XPointer and XInclude, which allow for more advanced XML processing.

Chapter 5, “PHP and XML”: This chapter introduces the new XML support in PHP 5.
It explains much of the functionality shared by the XML-based extensions, such as parser options, error handling, PHP streams, and document encoding.

Chapter 6,“Document Object Model (DOM)”: This chapter provides an in-depth look at using the DOM extension and shows how it is used to manipulate an XML document.

Chapter 7, “SimpleXML”: The SimpleXML extension provides a simple interface for working with XML documents. This chapter explains how to use the extension to access virtually any type of XML document, including more complex ones that use namespaces.

Chapter 8, “Simple API for XML (SAX)”: This chapter explains how to work with the xml extension and covers issues you may encounter when migrating an application that uses this extension from PHP 4 to PHP 5.

Chapter 9, “XMLReader”: The XMLReader extension is a lightweight parser and an alternative to the xml extension covered in Chapter 8. This chapter explains and demonstrates how to process an XML document using this extension.

Chapter 10, “Extensible Stylesheet Language Transformation (XSLT)”: You can transform XML documents using XSLT. This chapter begins by explaining the XSLT specification in easy-to-understand terms. Then, this chapter shows how to use the XSL extension in PHP to perform transformations.

Chapter 11, “Effective and Efficient Processing”: With a number of different extensions that can be used to work with XML in PHP, it is often difficult to decide which one to use. This chapter explains the differences between the extensions and continues with tips and tricks that can be used to optimally work with XML in PHP.

Chapter 12, “XML Security”: Data integrity and data security are topics that every developer must be concerned with when writing applications. In this chapter, you will learn how to work with digital signatures and encryption as they pertain to XML.

Chapter 13, “PEAR and XML”: The PHP Extension and Application Repository (PEAR) is a collection of software that can be used when writing an application. This chapter introduces PEAR and explores some of the XML packages it provides.

Chapter 14, “Content Syndication: RSS and Atom”: Content syndication has become popular with the explosion of weblogs (blogs). This chapter examines the three formats that are used to syndicate data and shows how to create and consume syndicated feeds using the PHP extensions.

Chapter 15, “Web Distributed Data Exchange (WDDX)”: This chapter explains what WDDX is and how you can use the wddx extension to exchange data between systems.

Chapter 16, “XML-RPC”: This chapter examines the structure and exchange of XML-RPC documents. You will then learn about the xmlrpc extension and how you can use it to communicate with remote systems.

Chapter 17, “Representational State Transfer (REST)”: Representational State Transfer (REST) is a simple method to create and consume Web services. I demonstrate how to create and consume REST-based services. In particular, you will see how to consume some real services from both Yahoo and Amazon.

Chapter 18, “SOAP”: SOAP allows for the creation of complex Web services. The specifications involved are also quite complex. In this chapter, I show examples of both the Web Services Description Language (WSDL) specification and the SOAP specification. Using this knowledge, you will see how to use the SOAP extension in PHP using realworld examples from eBay and Google.

Chapter 19,“Universal Description,Discovery, and Integration (UDDI)”: UDDI is a technology meant to make working with Web services easier. This chapter shows how you can use PHP to access and maintain records in a UDDI registry.

Chapter 20, “PEAR and Web Services”: Chapter 13 introduces PEAR and its XML packages;this chapter introduces you to some packages that you can use to create and consume a variety of Web services.

Chapter 21, “Other XML Technologies and Extensions”: There are too many XML-based technologies to cover in a single book. In this chapter, I will introduce you to the XMLWriter and SDO XML Data Access Service extensions as well as show how to work with Ajax and Wireless Application Protocol (WAP) using PHP.


DOWNLOAD THIS BOOK

Apr 29, 2008

Ebooks Beginning Ajax With PHP Tutorial


Title : Beginning Ajax With PHP Tutorial
Filetype : PDF
Pages : 235
From Apress
Release : 2007


Detail This Books "Beginning Ajax With PHP Tutorial"

Download This Books

Apr 27, 2008

Ebooks PHP 5 Advanced Download


PHP 5 Advanced with Visual Quickpro Guide
Peachpit Press
Release 2007
Filetype : PDF
Pages : 569
Total Chapter : 14
Size : 8,687 KB

Detail this books "tutorial PHP 5 Advanced"

Apr 24, 2008

PHP Tuturial In Action: Objects, Design, Agility


This book’s purpose involves a kind of bigamy. It introduces state-of-the art objectoriented design principles, patterns, and techniques. Then it weds these to two different partners. The first partner is PHP, the programming language. The second partner is the PHP programmer’s everyday work.

More specifically, this book is about handling and implementing these principles, patterns, and techniques in PHP with its specific syntax and characteristics. It is also about how to apply them to the specific and common challenges of web programming.

Who should read this book?
This book is for programmers who develop applications in PHP and want to learn modern object-oriented practices, principles, and techniques, and how to apply them to the everyday challenges of web programming.
It is not a beginner’s book in PHP; it presupposes a minimum of familiarity with PHP—or experience in other programming languages—and with the basic ideas and challenges of web programming.

How this book is organized
The book is divided into four parts. Parts 1 and 2 introduce the principles, patterns, and techniques mentioned initially and demonstrate how they can be implemented in PHP. Part 1 introduces and develops the subjects of object-oriented programming and design. Part 2 deals with unit testing and refactoring.

Parts 3 and 4 apply the material from the first two parts to the everyday challenges of web programming. Part 3 is about the web interface, while part 4 deals with databases and data storage.

Part 1: Basic tools and concepts
Part 1 moves gradually, chapter by chapter, from the nuts and bolts of object-oriented programming in PHP to the more conceptual subject of object-oriented application design.
Chapter 1 introduces and discusses the pros and cons of PHP and agile practices.
Chapter 2 and chapter 3 deal with the mechanics and syntax of object-oriented programming in PHP. Although objects and classes are ultimately inseparable subjects,
chapter 2 focuses mostly on object features and chapter 3 on class features.
Chapter 4 discusses why objects and classes are a good idea, how they relate to the real world, and how we can tell the difference between good and bad object-oriented designs.
Chapter 5 is about the basic class relationships—inheritance, association, and composition— and the role of interfaces in program design.
Chapter 6 is where we start to go into object-oriented design in earnest. It deals with object-oriented principles that serve as general guidelines for design.
Chapter 7 introduces the subject of design patterns—recurrent solutions to common design problems—and describes some of the most common ones.
Chapter 8 shows how design principles and patterns work in the context of an extended example: date and time handling.

Read more and Download

Writing Secure Code (Ms Press)


Organization of This Books (Writing Secure Code):

The book is divided into five parts. Chapter 1, The Need for Secure Systems and Chapter 2, Designing Secure Systems make up.

Part I, Contemporary Security, and outline the reasons why systems should be secured from attack and the guidelines and analysis techniques for designing such systems.

The meat of the book is in Parts II and III. Part II, Secure Coding Techniques, encompassing Chapters 3 through 8, outlines critical coding techniques that apply to almost any application.

Part III, Network-Based Application Considerations, includes four chapters (Chapters 9 through 12) that focus on networked applications, including Web-based applications.

Part IV, Special Topics, includes three chapters (Chapters 13 through 15) that cover less-often-discussed subjects, including security in .NET applications, testing, and secure software installation.
Chapter 16 includes general guidelines that dont fit in any single chapter.

Part V, Appendixes, includes four appendixes covering sundry other matters, including dangerous APIs and the lame excuses we ve heard for not considering security!
Michael wrote Chapters 1, 2, 4,8, and 12,14. David wrote Chapters 3, 9, 11, and 15. Both authors crafted Chapters 10 and 16.

As a final note, unlike the authors of a good many other security books, we wont just tell you how insecure applications are and moan about people not wanting to build secure systems. This book is utterly pragmatic and, again, relentlessly practical. It explains how systems can be attacked, mistakes that are often made, and, most important, how to build secure systems.

Download This Books

Apr 23, 2008

PHP in Action Tutorial Download

PHP in Action Objects, Design, Agility
PHP tutorial Ebooks-Content :
Part 1 Tools and concepts 1
1 PHP and modern software development 3
2 Objects in PHP 18
3 Using PHP classes effectively 40
4 Understanding objects and classes 65
5 Understanding class relationships 87
6 Object-oriented principles 102
7 Design patterns 123
8 Design how-to: date and time handling 152

Part 2 Testing and refactoring 187
9 Test-driven development 189
10 Advanced testing techniques 210
11 Refactoring web applications 232
12 Taking control with web tests 269

Part 3 Building the web interface 293
13 Using templates to manage web presentation 295
14 Constructing complex web pages 325
15 User interaction 338
16 Controllers 356
17 Input validation 377
18 Form handling 413
19 Database connection, abstraction, and configuration 432

Part 4 Databases and infrastructure 449
20 Objects and SQL 451
21 Data class design 470

Download this books

Apr 22, 2008

Java EE and .Net Interoperability: Integration Strategies, Patterns, and Best Practices


Structure of the Book:


This book covers two main constituents of any Java EE.NET integration. The first one pertains to the integration type such as synchronous or asynchronous, outlining how individual Java and .NET components can integrate using their diverse technology set. The second constituent relates to the quality of service requirements, such as security, reliability, and scalability, essential to meet a Service Level Agreement (SLA) across the heterogeneous enterprise environment. If you take a closer look at the book structure, you'll notice that the book represents a catalog of integration strategies that adheres to the following format:
  • Strategy Name The strategy has a unique name that reflects its objective.
  • Problem space Each strategy aims to address a specific Java EE.NET interoperability problem. Asynchronous reliable integration is an example of such a problem.
  • Solution This part of the strategy details a strategy design and outlines technology choices.
  • Benefits and Limitations Any interoperability strategy has its pros and cons that are highlighted here. For example, ease of maintenance or scalability are common benefits of some of the strategies.
  • Related Patterns Industry patterns such as Core J2EE Patterns are used throughout this book to bring those that are familiar to you into the scope of Java EE.NET integration. Are there similar resources in the .NET space?
  • Example Throughout the book, use cases from the WS-I Supply Chain Management Application (SCMA) are utilized to demonstrate how to implement a strategy. Most of the strategies have two sets of samples corresponding to the Java.NET and .NETJava communication.
The strategy catalog comprises the core of this book and can be used as a reference manual on Java EE.NET interoperability. Before delving into the strategy discussion, it is helpful to review the fundamentals of the Java EE and .NET platforms. The emphasis in reviewing these platforms will focus on their interoperability characteristics. Both platforms expose APIs to develop component-based, loosely coupled integration points. The platform overview is followed by Part II, "Synchronous Integration Solutions," which discusses common business scenarios and reasons for synchronous integration. The de facto technology to integrate disparate applications is based on Web services. Chapter 4, "Web Services for Synchronous Integration," demonstrates how a .NET application can discover and access a Web service implemented in Java and vice versa. The synchronous integration discussion continues with the .NET Remoting technology that remains an alternative to Web services and is adopted by open source and various commercial solutions. The .NET Remoting is shipped as part of the Microsoft Indigo Services. Chapter 6, "Resource Tier Synchronous Integration," details database and legacy integration. It demonstrates a simple strategy to build a Data Access Layer to connect to heterogeneous RDMSs, such as MySql and SQL Server. All in all, synchronous integration strategies are useful if you have two systems with tight coupling or strong dependencies. The industry, however, is heavily leaning toward asynchronous application integration.

Asynchronous integrations between Java EE and .NET systems are easier to maintain, less brittle, and tend to be more scalable. Therefore, the majority of the strategies in this book fall under Part III, "Asynchronous Integration Solutions." The first two strategies, Automatic Callback and Response Polling, are based on Web services technologies. They fundamentally differ from the approach taken in the previous section. The main goal of these strategies is to factor out remote calls from the rest of the request processing. The response can be sent via the callback or polling technique. Chapter 9, "Messaging," unveils five distinct strategies that help to automate and streamline the Java EE and .NET system integration around MOM, SMTP, and Enterprise Service Bus technologies. Reliable message delivery is the key differentiator of these strategies. Similar to the previous section, Chapter 10, "Resource Tier Asynchronous Integration," shows how to asynchronously communicate with back-end resources.

Part IV of the book addresses "Quality of Services" for interoperability. It incorporates several chapters that discuss how to implement a secure, reliable, interoperable Java EE.NET environment. This section encompasses distributed transactions and management of a heterogeneous environment, but most importantly it provides best practices on the enterprise architecture that mitigates security, manageability, availability, and reliability risks. The table here outlines strategies listed in this catalog.

Aside from the integration and systemic quality strategies, this book discusses how to deploy a .NET application under a Java EE application server and how to manually port a .NET application to Java. These strategies are included in Chapter 16, "Migrating .NET Applications to Java." Each chapter of this book intends to give the reader an overview of the technologies and concepts used by individual strategies. Messaging, resource pooling, threading, and asynchronous programming models differ under the Java EE and .NET platforms. Understanding these programming models under each platform enables the reader to effectively apply strategy within a specific domain.

Download This Books

THE Java™ EE 5 Tutorial


About This Tutorial:

THE Java™ EE 5 Tutorial is a guide to developing enterprise applications for the Java Platform, Enterprise Edition 5 (Java EE 5). Here we cover all the things you need to know to make the best use of this tutorial.

Who Should Use This Tutorial:

This tutorial is intended for programmers who are interested in developing and deploying Java EE 5 applications on the Sun Java System Application Server Platform Edition 9.

How to Read This Tutorial

The Java EE 5 platform is quite large, and this tutorial reflects this. However, you don’t have to digest everything in it at once. The tutorial has been divided into parts to help you navigate the content more easily.
This tutorial opens with an introductory chapter, which you should read before proceeding to any specific technology area. Chapter 1 covers the Java EE 5 platform architecture and APIs along with the Sun Java System Application Server Platform Edition 9.
When you have digested the basics, you can delve into one or more of the five main technology areas listed next. Because there are dependencies between some of the chapters, Figure 1 contains a roadmap for navigating through the tutorial.

The web-tier technology chapters cover the components used in developing the presentation layer of a Java EE 5 or stand-alone web application:
• Java Servlet • JavaServer Pages (JSP) • JavaServer Pages Standard Tag Library (JSTL) • JavaServer Faces • Web application internationalization and localization

The web services technology chapters cover the APIs used in developing

standard web services:
• The Java API for XML-based Web Services (JAX-WS) • The Java API for XML Binding (JAXB) • The Streaming API for XML (StAX) • The SOAP with Attachments API for Java (SAAJ) • The Java API for XML Registries (JAXR)

The Enterprise JavaBeans (EJB) technology chapters cover the components

used in developing the business logic of a Java EE 5 application:
• Session beans
• Message-driven beans

The Persistence technology chapters cover the Java Persistence API, which

is used for accessing databases from Java EE applications:
• Introduction to the Java Persistence API
• Persistence in the Web Tier
• Persistence in the EJB Tier
• The Java Persistence Query Language

The platform services chapters cover the system services used by all the

Java EE 5 component technologies:
• Transactions
• Resource connections
• Security
• Java Message Service
• The Connector architecture

After you have become familiar with some of the technology areas, you are
ready to tackle the case studies, which tie together several of the technologies discussed in the tutorial. The Coffee Break Application (Chapter 37) describes an application that uses the web application and web services APIs. The Duke’s Bank Application (Chapter 38) describes an application that employs web application technologies, enterprise beans, and the Java Persistence API.

Finally, the appendix contains auxiliary information helpful to the Java EE 5
application developer:
• Java encoding schemes (Appendix A)

Download The Java EE 5 Tutorial


Rapid J2EE Development: An Adaptive Foundation for Enterprise Applications


How This Book Is Organized:
The contents of this book are broken up into four logical parts:

Part I: Adaptive Processes
  • Chapter 1: A J2EE Tutorial Adaptive Foundation. This chapter introduces the concepts behind the creation of an adaptive foundation for rapid development.
  • Chapter 2: Rapid Application Development. Techniques commonly associated with the rapid development of software, including rapid development languages, approaches to prototyping, and timeboxed development methods, are described in this chapter.
  • Chapter 3: Embracing Adaptive Methods. Chapter 3 explores the importance of lightweight development methodologies that incorporate an iterative approach to building software.
Part II: Agile Architectures
  • Chapter 4: Designing for Rapidity. This chapter looks at how the choices we make at design time have implications for the project's timeframe.
  • Chapter 5: Modeling Software. The topic of this chapter is the use of models for building software architectures, and it examines how UML diagrams enable the communication, validation, and exploration of system designs.
  • Chapter 6: Code Generation. We discuss the merits of passive and active code generation. The use of XDoclet for generating boilerplate code artifacts for Enterprise JavaBeans is illustrated by example, along with the use of Apache's Velocity template engine.
  • Chapter 7: Rapidity and the Database. The repetitive nature of data access code makes it a prime candidate for code generation. This chapter looks at the time savings to be had from the use of the code generation tool Middlegen, as well as at how object-relational mapping products can ease the process of mixing object-oriented technology with that of relational database technology.
  • Chapter 8: Model-Driven Architecture. This chapter brings together models with code generation techniques to explore the MDA paradigm. The use of the open source MDA tool AndroMDA is covered by example.

Part III: Rapid Languages

  • Chapter 9: Scripting. This chapter looks at the benefits of scripting languages and introduces the Java-compatible scripting language Jython.
  • Chapter 10: Working to Rule. This chapter examines the benefits of using rule engines to maintain business logic. The open source, expert system shell Jess is introduced as an example of a rule-based language.
  • Chapter 11: Aspect-Oriented Programming. AOP provides new language constructs for modularizing crosscutting concerns. The result is a powerful mechanism for applying changes dynamically to an application. This chapter introduces the AOP language AspectJ and the AOP framework AspectWerkz.

Part IV: Dynamic Environments

  • Chapter 12: Optimal Builds. Chapter 12 addresses the importance of having a highly efficient and optimized build process in place for conducting rapid development.
  • Chapter 13: The Integrated Development Environment. We examine the need to invest in sophisticated and integrated development tools. The open source developer's workbench Eclipse is introduced as an example of a suitable J2EE development environment.
  • Chapter 14: Test-Driven Development. The practice of test-driven development is key to defining an approach that is resilient to changing requirements and designs. This chapter looks at the importance of constructing an automated unit test suite and covers the JUnit framework for writing unit tests as well as the use of mock objects in testing.
  • Chapter 15: Efficient Quality Assurance. The final chapter looks at using automated testing tools for undertaking functional and performance testing. The open source tools HttpUnit and Apache JMeter are covered by example.

Download This Books

Apr 21, 2008

The Java 2 Platform, Enterprise Edition (J2EE)

Overview of the Book and Technology:

The Java 2 Platform, Enterprise Edition (J2EE) defines the standard for developing n-tier enterprise applications using Java. J2EE simplifies enterprise applications by basing them on standardized modular components and providing for those components a complete set of services that handle the complexities automatically.

N-tier applications are difficult to build. Usually building such an application
requires people with a variety of skills and an understanding of both modern and legacy code and data. Enterprise applications typically use heterogeneous approaches to systems development and require the integration of tools from a variety of vendors and the merging of disparate application models and standards.



This book covers the various components of J2EE that are used to build enterprise
n-tier applications, including the following:
  • JavaServer Pages (JSP)
  • Enterprise JavaBeans (EJB)
  • Java Messaging Service (JMS)
  • Java Naming and Directory Interface (JNDI)
  • Java Authentication and Authorization Service (JAAS)
  • Java Connector Architecture (JCA)
  • And more . . .

The author team recommends that the chapters in this book be read in order, as each chapter builds upon previous chapters. If reading the chapters in order is not viable, reading a particular section in a single sitting may be a better choice.

Contents :
Part I: Introduction
Chapter 1: Understanding Java and the J2EE Platform
Chapter 2: Reviewing XML Fundamentals
Chapter 3: Introducing Application Servers
Chapter 4: Understanding Remote Method Invocation

Part II: The Presentation Tier
Chapter 5: Studying Servlet Programming
Chapter 6: Going Over JSP Basics
Chapter 7: Using JSP Tag Extensions

Part III: The Enterprise Information System Tier
Chapter 8: Working with JavaMail
Chapter 9: Understanding the Java Messaging Service
Chapter 10: Introducing Java Transactions
Chapter 11: Examining JNDI and Directory Services
Chapter 12: Understanding Java Authentication and Authorization Services
Chapter 13: Exploring Java Cryptography Extensions

Part IV: The Service Tier
Chapter 14: Understanding EJB Architecture and Design
Chapter 15: Explaining Session Beans and Business Logic .
Chapter 16: Working with Entity Beans
Chapter 17: Using Message-Driven Beans

Part V: The Data Tier
Chapter 18: Reviewing Java Database Connectivity
Chapter 19: Understanding the J2EE Connector Architecture

Part VI: Web Services
Chapter 20: Introducing Web Services
Chapter 21: Digging Deeper into SOAP, WSDL, and UDDI
Chapter 22: Understanding J2EE Web Services

Part VII: Patterns
Chapter 23: Reviewing Presentation-Tier Patterns
Chapter 24: Working with Service-Tier Patterns
Chapter 25: Using Data-Tier Patterns

Part VIII: Advanced Topics
Chapter 26: Exploring Frameworks and Application Architecture
Chapter 27: Using ANT to Build and Deploy Applications
Chapter 28: Creating High-Performance Java Applications
Appendix A: Airline Reservations Business Case
Appendix B: Magazine Publisher Business Case
Appendix C: Additional Reading and References

Download This Books and tutorials

The Java™ EE 5 Tutorial, Third Edition: For Sun Java System Application Server Platform Edition 9

This tutorial is a guide to developing enterprise applications for the Java Platform, Enterprise Edition 5 (Java EE 5). Here we cover all the things you need to know to make the best use of this tutorial.

Who Should Use This Tutorial :
This tutorial is intended for programmers who are interested in developing and deploying Java EE 5 applications on the Sun Java System Application Server Platform Edition 9.

How to Read This Tutorial
The Java EE 5 platform is quite large, and this tutorial reflects this. However, you don't have to digest everything in it at once. The tutorial has been divided into parts to help you navigate the content more easily.

This tutorial opens with an introductory chapter, which you should read before proceeding to any specific technology area. Chapter 1 covers the Java EE 5 platform architecture and APIs along with the Sun Java System Application Server Platform Edition 9.
When you have digested the basics, you can delve into one or more of the five main technology areas listed next. Because there are dependencies between some of the chapters, Figure 1 contains a roadmap for navigating through the tutorial.

The web-tier technology chapters cover the components used in developing the presentation layer of a Java EE 5 or stand-alone web application:
  • Java Servlet
  • JavaServer Pages (JSP)
  • JavaServer Pages Standard Tag Library (JSTL)
  • JavaServer Faces
  • Web application internationalization and localization
The web services technology chapters cover the APIs used in developing standard web services:
  • The Java API for XML-based Web Services (JAX-WS)
  • The Java API for XML Binding (JAXB)
  • The Streaming API for XML (StAX)
  • The SOAP with Attachments API for Java (SAAJ)
  • The Java API for XML Registries (JAXR)

The Enterprise JavaBeans (EJB) technology chapters cover the components used in developing the business logic of a Java EE 5 application:
  • Session beans
  • Message-driven beans

The Persistence technology chapters cover the Java Persistence API, which is used for accessing databases from Java EE applications:
  • Introduction to the Java Persistence API
  • Persistence in the Web Tier
  • Persistence in the EJB Tier
  • The Java Persistence Query Language

The platform services chapters cover the system services used by all the Java EE 5 component technologies:
  • Transactions
  • Resource connections
  • Security
  • Java Message Service
  • The Connector architecture

Download this tutorial

Essential XML Quick Reference A Programmer’s

Complete tittle this books is Essential XML Quick Reference A Programmer’s Reference to XML, XPath, XSLT, XML Schema, SOAP, and More.

This book and tutorial is for anyone working with today’s mainstream XML technologies. It was specifically designed to serve as a handy but thorough quick reference that answers the most common XML-related technical questions.
It goes beyond the traditional pocket reference design by providing complete coverage of each topic along with plenty of meaningful examples. Each chapter provides a brief introduction, which is followed by the detailed reference information. This approach assumes the reader has a basic understanding of the given topic.
The detailed outline (at the beginning), index (in the back), bleeding tabs (along the side), and the page headers/footers were designed to help readers quickly find answers to their questions.

Chapter Contents
1 XML 1.0 and Namespaces
2 Document Type Definitions
3 XPath 1.0
4 XPointer, XInclude, and XML Base
5 XSL Transformations 1.0
6 SAX 2.0
7 DOM Level 2
8 XML Schema Datatypes
9 XML Schema Structures
10 SOAP 1.1

Download This Books

Effective XML: 50 Specific Ways to Improve Your XML


Table of content "Effective XML: 50 Specific Ways to Improve Your XML"

Praise for Effective XML
Effective Software Development Series
Titles in the Series

Preface
Acknowledgments

Introduction
Element versus Tag
Attribute versus Attribute Value
Entity versus Entity Reference
Entity Reference versus Character Reference
Children versus Child Elements versus Content
Text versus Character Data versus Markup
Namespace versus Namespace Name versus Namespace URI
XML Document versus XML File
XML Application versus XML Software
Well-Formed versus Valid
DTD versus DOCTYPE
XML Declaration versus Processing Instruction
Character Set versus Character Encoding
URI versus URI Reference versus IRI
Schemas versus the W3C XML Schema Language

Part 1: Syntax
Item 1. Include an XML Declaration
The version Info
The encoding Declaration
The standalone Declaration

Item 2. Mark Up with ASCII if Possible
Item 3. Stay with XML 1.0
New Characters in XML Names
C0 Control Characters
C1 Control Characters
NEL Used as a Line Break
Unicode Normalization
Undeclaring Namespace Prefixes

Item 4. Use Standard Entity References
Item 5. Comment DTDs Liberally
The Header Comment
Declarations

Item 6. Name Elements with Camel Case
Item 7. Parameterize DTDs
Parameterizing Attributes
Parameterizing Namespaces
Full Parameterization
Conditional Sections

Item 8. Modularize DTDs
Item 9. Distinguish Text from Markup
Item 10. White Space Matters
The xml:space Attribute
Ignorable White Space
Tags and White Space
White Space in Attributes
Schemas


Part 2: Structure
Item 11. Make Structure Explicit through Markup
Tag Each Unit of Information
Avoid Implicit Structure
Where to Stop?

Item 12. Store Metadata in Attributes
Item 13. Remember Mixed Content
Item 14. Allow All XML Syntax
Item 15. Build on Top of Structures, Not Syntax
Empty-Element Tags
CDATA Sections
Character and Entity References

Item 16. Prefer URLs to Unparsed Entities and Notations
Item 17. Use Processing Instructions for Process-Specific Content
Style Location
Overlapping Markup
Page Formatting
Out-of-Line Markup
Misuse of Processing Instructions

Item 18. Include All Information in the Instance Document
Item 19. Encode Binary Data Using Quoted Printable and/or Base64
Quoted Printable
Base64

Item 20. Use Namespaces for Modularity and Extensibility
Choosing a Namespace URI
Validation and Namespaces

Item 21. Rely on Namespace URIs, Not Prefixes
Item 22. Don't Use Namespace Prefixes in Element Content and Attribute Values
Item 23. Reuse XHTML for Generic Narrative Content
Item 24. Choose the Right Schema Language for the Job
The W3C XML Schema Language
Document Type Definitions
RELAX NG
Schematron
Java, C#, Python, and Perl
Layering Schemas

Item 25. Pretend There's No Such Thing as the PSVI
Item 26. Version Documents, Schemas, and Stylesheets
Item 27. Mark Up According to Meaning

Part 3: Semantics
Item 28. Use Only What You Need
Item 29. Always Use a Parser
Item 30. Layer Functionality
Item 31. Program to Standard APIs
SAX DOM JDOM

Item 32. Choose SAX for Computer Efficiency
Item 33. Choose DOM for Standards Support
Item 34. Read the Complete DTD
Item 35. Navigate with XPath
Item 36. Serialize XML with XML
Item 37. Validate Inside Your Program with Schemas
Xerces-J
DOM Level 3 Validation


Part 4: Implementation
Item 38. Write in Unicode
Choosing an Encoding
A char Is Not a Character
Normalization Forms
Sorting

Item 39. Parameterize XSLT Stylesheets
Item 40. Avoid Vendor Lock-In
Item 41. Hang On to Your Relational Database
Item 42. Document Namespaces with RDDL
Natures
Purposes

Item 43. Preprocess XSLT on the Server Side
Servlet-Based Solutions
Apache
IIS

Item 44. Serve XML+CSS to the Client
Item 45. Pick the Correct MIME Media Type
Item 46. Tidy Up Your HTML
MIME Type
HTML Tidy
Older Browsers

Item 47. Catalog Common Resources
Catalog Syntax
Using Catalog Files

Item 48. Verify Documents with XML Digital Signatures
Digital Signature Syntax
Digital Signature Tools

Item 49. Hide Confidential Data with XML Encryption
Encryption Syntax
Encryption Tools

Item 50. Compress if Space Is a Problem


Download Effective XML: 50 Specific Ways to Improve Your XML

Applied XML Programming for Microsoft .NET

What Is Applied XML Programming for Microsoft .NET About?

This book explores the array of XML tools provided by the .NET Framework. XML is everywhere in the .NET Framework, from remoting to Web services, and from data access to configuration. In the first part of this book, you'll find in-depth coverage of the key classes that implement XML in the .NET platform. Readers and writers, validation, and schemas are discussed with samples and reference information. Next the book moves on to XPath and XSL Transformations (XSLT) and the .NET version of the XML Document Object Model (XML DOM).

The final part of this book focuses on data access and interoperability and touches on SQL Server 2000 and its XML extensions and .NET Remoting and its cross-platform counterpart—XML Web services. You'll also find a couple of chapters about XML configuration files and XML data islands and browser/deployed managed controls.

Table of Contents This Ebooks and Tutorial:
Applied XML Programming for Microsoft .NET
Introduction

Part I - XML Core Classes in the .NET Framework
Chapter 1 - The .NET XML Parsing Model
Chapter 2 - XML Readers
Chapter 3 - XML Data Validation
Chapter 4 - XML Writers

Part II - XML Data Manipulation
Chapter 5 - The XML .NET Document Object Model
Chapter 6 - XML Query Language and Navigation
Chapter 7 - XML Data Transformation

Part III - XML and Data Access
Chapter 8 - XML and Databases
Chapter 9 - ADO.NET XML Data Serialization
Chapter 10 - Stateful Data Serialization

Part IV - Applications Interoperability
Chapter 11 - XML Serialization
Chapter 12 - The .NET Remoting System
Chapter 13 - XML Web Services
Chapter 14 - XML on the Client
Chapter 15 - .NET Framework Application Configuration

Download Applied XML Programming for Microsoft .NET
Filetype : chm
Page : (696 pages)
Pub Date : 2003

Apr 20, 2008

Excel 2003 – Tutorial I

Spreadsheet Basics Tutorials

Microsoft Excel is a spreadsheet program that you can use to organize, analyze and attractively present data such as a budget or sales report. Each Excel file is a workbook that can hold many worksheets. The worksheet is a grid of columns, designated by letters, and rows, designated by numbers. The letters and numbers of the columns and row called labels are displayed in gray buttons across the top and left side of the worksheet. The intersection of a column and a row is called a cell. Each cell on the spreadsheet has a cell address that is the column letter and the row number. Cells can contain text, numbers, or mathematical formulas.

Spreadsheet Basics
  • Screen Layout
  • Title bar
  • Menu bar
  • Standard Toolbar
  • Other Tools
  • Task Pane
  • Adding and Renaming Worksheets
Modifying Worksheets
  • Moving Through Cells
  • Adding Worksheets, Rows, Columns, and Cells
  • Resizing Rows and Columns
  • Selecting Cells
  • Moving and Copying Cells
  • Deleting Rows, Columns and Cells
  • Freeze Panes
Formatting Cells
  • Formatting Toolbar
  • Format Cells Dialog Box
  • Formatting Worksheet
  • Dates and Times
  • Format Painter
  • AutoFormat
Formulas and Functions
  • Formulas
  • Linking Worksheets
  • Relative, Absolute, and Mixed
  • Referencing
  • Basic Functions
  • AutoSum
Sorting and Filling
  • Basic Sorts
  • Complex Sorts
  • Auto-fill

Comparing Workbooks
  • Compare Side by Side

Page Properties and Printing
  • Page Breaks
  • Page Setup
  • Margins
  • Header/Footer
  • Sheet
  • Print Preview
  • Print
Read more and download

Microsoft Excel Tutorial



Introduction to Excel
Excel allows you to create spreadsheets that can perform automatic calculations. Each Excel file is a workbook that can hold many worksheets. The worksheet is a grid of columns (letters) and rows (numbers).

Adding Worksheets, Rows, and Columns
Worksheets - Add a worksheet to a workbook by selecting Insert|Worksheet from the menu bar. To rename the worksheet tab, right-click on the tab with the mouse and select Rename from the shortcut menu. Type the new name and press the ENTER key. Row - To add a row to a worksheet, select Insert|Rows from the menu bar, or highlight the row by clicking on the row label, right-click with the mouse, and choose Insert.
Column - Add a column by selecting Insert|Columns from the menu bar, or highlight the column by click on the column label, right-click with the mouse, and choose Insert.

Resizing Rows and Columns

There are two ways to resize rows and columns.
To resize a row individually drag the line below the label of the row you would like to resize. You can resize a column in a similar manner by dragging the line to the right of the label corresponding to the column you want to resize.

Read More and Download

JSP Tutorial



This is a tutorial to help a developer understand what is meant by JavaServer Pages (JSP). The reader will learn the main concepts, setup the JSP environment on their computer and write a few JSP programs.

JavaServer Pages (JSP) is a technology based on the Java language and enables the development of dynamic web sites. JSP was developed by Sun Microsystems to allow server side development. JSP files are HTML files with special Tags containing Java source code that provide the dynamic content. The following shows the Typical Web server, different clients connecting via the Internet to a Web server. In this example, the Web server is running on Unix and is the very popular Apache Web server.

First static web pages were displayed. Typically these were people’s first experience with making web pages so consisted of My Home Page sites and company marketing information. Afterwards Perl and C were languages used on the web server to provide dynamic content. Soon most languages including Visualbasic, Delphi, C++ and Java could be used to write applications that provided dynamic content using data from text files or database requests. These were known as CGI server side applications. ASP was developed by Microsoft to allow HTML developers to easily provide dynamic content supported as standard by Microsoft’s free Web Server, Internet Information Server (IIS). JSP is the equivalent from Sun Microsystems, a comparison of ASP and JSP will be presented in the following section.

Why use JSP?
JSP is easy to learn and allows developers to quickly produce web sites and applications in an open and standard way. JSP is based on Java, an object- oriented language. JSP offers a robust platform for web development.

Main reasons to use JSP:

1. Multi platform
2. Component reuse by using Javabeans and EJB.
3. Advantages of Java.
You can take one JSP file and move it to another platform, web server or JSP Servlet engine.

Download

JavaServer Pages (JSP) Tutorials


This is a tutorial to help a developer understand what is meant by JavaServer Pages (JSP). The reader will learn the main concepts, setup the JSP environment on their computer and write a few JSP programs.

JavaServer Pages (JSP) is a technology based on the Java language and enables the development of dynamic web sites. JSP was developed by Sun Microsystems to allow server side development. JSP files are HTML files with special Tags containing Java source code that provide the dynamic content. The following shows the Typical Web server, different clients connecting via the Internet to a Web server. In this example, the Web server is running on Unix and is the very popular Apache Web server.

First static web pages were displayed. Typically these were people’s first experience with making web pages so consisted of My Home Page sites and company marketing information. Afterwards Perl and C were languages used on the web server to provide dynamic content. Soon most languages including Visualbasic, Delphi, C++ and Java could be used to write applications that provided dynamic content using data from text files or database requests. These were known as CGI server side applications. ASP was developed by Microsoft to allow HTML developers to easily provide dynamic content supported as standard by Microsoft’s free Web Server, Internet Information Server (IIS). JSP is the equivalent from Sun Microsystems, a comparison of ASP and JSP will be presented in the following section.

Why use JSP?
JSP is easy to learn and allows developers to quickly produce web sites and applications in an open and standard way. JSP is based on Java, an object- oriented language. JSP offers a robust platform for web development.
Main reasons to use JSP:
1. Multi platform
2. Component reuse by using Javabeans and EJB.
3. Advantages of Java.
You can take one JSP file and move it to another platform, web server or JSP Servlet engine

Download


Java Programming for Wireless devices using Java 2 Platform Micro Edition (J2ME)


What is a J2ME Configuration?

A configuration defines the minimum Java™ technology that can be expected to be available on implementing devices Broad range of devices Similar requirements for memory size and processing capabilities Configurations are specified via the Java Community Process Implementations are tested via a compatibility test kit (TCK)

J2ME Configurations
J2ME Connected, Limited Device Configuration (CLDC) Specifies Java environment for mobile phone, pager, and PDA class devices CLDC devices are usually wireless J2ME Connected Device Configuration (CDC) Specifies Java environment for digital television settop boxes, high end wireless devices, and automotive telematics systems. CDC devices may be wired (DTV cable, etc.)

What Is a J2ME Profile?
Java™ technology which supplements a Configuration to provide capabilities for a specific vertical market or device type Defined through Java Community Process initiative Subject to compatibility tests

J2ME Profiles
  • Mobile Information Device Profile (MIDP)
  • Profile for wireless devices implementing CLDC
  • J2ME Foundation Profile
  • Profile for non-GUI networked devices implementing
  • CDC
  • J2ME Personal Basis, Personal, RMI Profiles
  • Basic graphics, next generation PersonalJava environment, and RMI support for CDC &
  • Foundation Profile based devices
Download

MIDlet development with J2ME and MIDP


Why J2ME?
Nokia, the dominant player in the mobile phone market, has estimated that in 2002 it will sell over 50 million J2ME-enabled mobile phones. With lofty numbers announced by other mobile phone manufacturers as well, there is a flood of interest in software development revolving around J2ME (Java 2 Micro Edition). J2ME is a slimmed-down version of Java targeted at devices that have limited memory, display, and processing power.

This tutorial provides a step-by-step introduction to downloading, installing, and
configuring your computer to begin development of applications for this runtime environment. There will be a specific focus on application development for mobile devices using an application programming interface (API) known as the Mobile Information Device Profile (MIDP). Applications written for this API are affectionately referred to as MIDlets.

Download MIDlet development with J2ME and MIDP

Apr 19, 2008

XML programming in Java technology, Part 2

In an earlier tutorial ("XML programming in Java technology, Part 1"), I showed you the basics of XML parsing in the Java language. I covered the major APIs (DOM, SAX, and JDOM), and went through a number of examples that demonstrated the basic tasks common to most XML applications. This tutorial will look at more difficult things that weren't covered before, such as:
• Getting and setting parser features
• Working with namespaces
• Validating XML documents

As in the introductory tutorial, the APIs I'll cover are:
• The Document Object Model (DOM), Levels 1, 2, and 3
• The Simple API for XML (SAX), Version 2.0
• JDOM, a simple Java API created by Jason Hunter and Brett McLaughlin
• The Java API for XML Processing (JAXP)

I'll also cover several approaches to validation, including W3C XML Schema, RELAX
NG, and Schematron.

About the examples
Most of the examples here will work with the Shakespearean sonnet that appeared in the last tutorial. The structure of this sonnet is:









[14 elements]




In the various sample programs, some versions of this document will have namespaces, and some will use DTDs, W3C XML Schemas, or other schema languages for validation. For the complete examples, see the following files:
• sonnet.xml
• sonnet.dtd (download to view in a text editor)
sonnetNamespaces.xml
sonnet.xsd
sonnetSchema.xml
sonnet.rng
sonnetRules.xsl
sonnetSchematron.xml
As an alternative, download x-java2_code_files.zip to view these files in a text editor.

Download this tutorial

XML programming in Java technology, Part 1

About this tutorial

Over the last few years, XML has become a universal data format. In this updated tutorial, I'll show you the most common programming interfaces for working with XML documents in the Java language. The most common XML processing task is parsing an XML document. Parsing involves reading an XML document to determine its structure and contents. One of the pleasures of XML programming is the availability of open-source, no-cost XML parsers that read XML documents for you. This tutorial focuses on creating parser objects, asking those parsers to process XML files, and handling the results. As you might expect, you can do these common tasks in several different ways; I'll examine the standards involved as well as when you should use one approach or another.

Programming interfaces
A number of programming interfaces have been created to simplify writing Java programs that process XML. These interfaces have been defined by companies, by standards bodies, and by user groups to meet the needs of XML programmers. In this tutorial, I'll cover the following interfaces:
• The Document Object Model (DOM), Level 2
• The Simple API for XML (SAX), Version 2.0
• JDOM, a simple Java API created by Jason Hunter and Brett McLaughlin
• The Java API for XML Processing (JAXP)

The first three of these four interfaces (DOM, SAX, and JDOM) define how the
contents of an XML document are accessed and represented. JAXP contains classes for creating parser objects. To create DOM or SAX parsers, you'll use JAXP. When you use JDOM, the JDOM library uses JAXP under the covers to create a parser. To sum it all up:
• You use DOM, SAX, or JDOM to work with the contents of an XML document.
• If you use DOM or SAX, you use JAXP to create a parser.
• If you use JDOM, the JDOM library creates a parser for you.

I'll explore the design goals, strengths, and weaknesses of each of these APIs, along
with a bit of their histories and the standards bodies that created them.

Download this tutorial

XQuery Java API (tutorial)

This API provides the methods for compiling and executing XQuery/XPath scripts from Java and exploiting the results. This is very similar to using the SQL language through a Java interface like JDBC.
Using XQuest's implementation of XQuery provides a high-level query language and extended processing capabilities. It is therefore advisable to implement the largest possible part of an application with XQuery, and use Java only for retrieving final results. This is especially true when connecting to a remote server, because such an approach will likely minimize the network traffic.
The API is actually used in the GUI and Command-line Interface applications provided with XQuest, as well as in the "Server Pages" extension, which embeds the XQuery engine in a Servlet.

The API allows:
• Creation and setup of a compilation and execution environment (which implements both the static context and dynamic context defined in the XQuery Specifications). These environments are basically provided by an interface named XQueryConnection Creation of Expressions from a XQueryConnection (interfaces XQueryExpression and XQueryPreparedExpression ). Such expressions are similar to Statements found in database connectivity interfaces like JDBC. Expressions receive a Query (i.e. a XQuery script) which is compiled and then executed once or several times.

An Expression is itself a context which inherits the environment provided by the connection, and can then be set up individually before execution. In particular, it is possible to bind global variables of the XQuery expressions to initial values.

• Exploitation of results of Expression evaluations.

The result sets are iterators, since the XQuery/XPath2 language can generally return se- quences of Items. Items are either atomic values (such as numbers or strings), or Nodes, which describe the structure of XML documents and data. The properties and relationships of Nodes are de- scribed in a section of the XQuery/XPath2/XSLT2 specifications which is called the Data Model. A section of the present document is dedicated to the Data Model interfaces, which handle Nodes.

For calling Java methods from within XQuery expressions, see the Java Binding section of the XQuery Extensions documentation.
For dealing specifically with XML databases (XML Libraries), see the XML Library API


Download