Getting Started with IBM WebSphere sMash

Description

Use IBM WebSphere sMash to Rapidly Deliver Scalable, Flexible Web 2.0 Applications

With the radically new IBM WebSphere sMash and the Project Zero platform, it's far easier to develop, assemble, and run applications and mashups that align tightly with SOA enterprise infrastructures. Getting Started with IBM WebSphere sMash covers all aspects of architecting, designing, and developing solutions with these breakthrough technologies.

Authored by three IBM leading sMash experts, this practical tutorial shows how to create state-of-the-art web applications far more rapidly than you ever could with traditional Java or .NET enterprise platforms.

As you walk through sample projects based on real-life scenarios, you'll master both basic and advanced sMash features, ranging from request handling to event processing, database access to security. You'll also learn agile best practices for consistently writing better web applications, delivering them sooner, and getting more value from them.

Coverage includes

* Installing and configuring IBM WebSphere sMash, and choosing your development environment

* Creating handlers to efficiently service all types of requests

* Understanding sMash's convention over configuration approach, and knowing when to override convention

* Rendering responses that include visual content, data, and other resources

* Connecting with databases via Project Zero's powerful data access API

* Using sMash's security model to protect inbound and outbound connections

* Building more flexible applications with sMash's sophisticated event processing

* Extending sMash development to non-programmers with Assemble Flow

* Programming client-side code with the Dojo Toolkit

* Taking advantage of sMash's PHP support

CONTENTS:

Introduction 1

Situational Applications 1

Rapid Application Development 1

IBM WebSphere sMash Development Process 2

Available IBM WebSphere sMash Offerings 2

What Is Covered in This Book? 3

Chapter 1 Installing the IBM WebSphere sMash CLI 5

First Things First: Java Development Environment 5

Installing the Command-Line Interface 6

Activating HTTP(S) Proxy Support 8

Test Your IBM WebSphere sMash Installation 9

Getting Started with the Command-Line Interface (CLI) 11

Conclusion 13

Chapter 2 Choose Your Development Environment 15

Introduction 15

AppBuilder 15

   Getting Started 16

   Sample Applications 16

   Creating a New Application 18

   Editing Applications 18

Eclipse 21

   Sample Applications 21

   Creating a New Project 23

   Command-Line Interface Environment 27

   Sample Applications 28

   Creating a New Application 29

   Deploying Your Application 30

Conclusion 30

Chapter 3 Your First Handler and Beyond 33

Introduction 33

Application Directory Layout 33

   Source Directories 34

   Supporting Directories and Files 35

REST 36

REST with the Zero Resource Model (ZRM) 38

   Declaring a Dependency 41

   Virtual Directories 43

Synchronizing a ZRM Model 43

Event Handling in Groovy 44

Running the Application 44

Explicit Event Handling 46

Event Handling in PHP 49

Event Handling in Java 52

Creating a Client 52

   Groovy Templates 52

   PHP 56

   Dojo 59

Conclusion 61

Chapter 4 Configuration Files Explained 63

Application Configuration 63

   Global Context and zero.config 63

   Custom Configuration Data 64

   Variable Substitution 65

   Include Files 66

   Handler Configuration 66

Dependency Management with Ivy 69

   Ivy Modules 69

   Ivy Files 69

   Resolution and Resolvers 71

Environment Configuration 74

   Useful Information About Your Application 74

   Runtime Configuration 75

   Response Configuration 75

Command-Line Interface (CLI) Config 77

   App Builder Configuration 77

   Eclipse Configuration 77

   JVM Configuration 78

   Overriding Configuration Parameters 79

   Reverse Proxy Server Configuration 80

Conclusion 80

Chapter 5 Global Context 81

Zones 81

   Non-Persistent Zones 81

   Persistent Zones 84

Accessing the Global Context 85

   Java APIs 86

   Groovy APIs 100

   PHP APIs 108

Conclusion 120

Chapter 6 Response Rendering 121

Every Conversation Requires a Response 121

   Serving Static Files 122

Internationalizing Static Files 122

   Serving Dynamic Content 124

PHP Rendering 124

Groovy Rendering 125

Serving Default Files 126

Directory Browsing 127

Custom Rendering States 128

Using Views for Rendering 128

Managing Errors 135

Data Rendering 138

JSON Data Rendering 138

XML Rendering 141

Conclusion 142

Chapter 7 REST Programming 143

What Is REST? 143

Response Codes 145

Request Accept Headers 147

Response Headers 148

REST Handling Within WebSphere sMash 149

Creating a Groovy Resource Handler 150

Creating a PHP Resource Handler 152

Content Negotiation 154

Bonding Resources Together 157

Error Handling and Response Codes 159

Enabling SSL Communication Handlers 160

Testing and Documentation 162

Conclusion 170

Chapter 8 Database Access 171

Introduction 171

   Databases Supported in WebSphere sMash 172

Configuration Settings 172

   Apache Derby 173

   IBM DB2 175

   MySQL 175

   Oracle 176

   Microsoft SQL Server 177

Zero Resource Model 177

   Establishing a New ZRM Application 177

   Creating a Zero Resource Model 178

   Making ZRM Data Available as a Service 181

   Adding Data to a Zero Resource Model 182

   Loading Data Using a ZRM Test Page 183

   Iterative Zero Resource Model Design 184

Database Access with pureQuery 186

   Working with pureQuery 186

   Simple Query Methods 188

   Data Manipulation Statements 191

   Prepared Statements 192

   Externalizing SQL Statements 194

   Connection Pooling 194

   Data Access Using Java 195

   Data Access in PHP 195

   Standard JDBC Database Access 197

   Command-Line Database Management 205

Conclusion 206

Chapter 9 Security Model 207

SSL Configuration 209

   Enabling Security 213

   Application Secret Key 213

   Authentication Types 214

Login Form 217

Knowing Your Users 219

   Additional Files for Our Application 221

   Testing the Secure Application 223

Directory Server Configuration 224

Directory Server User Details 226

OpenID Configuration 228

   Securing Outbound Connections 230

Conclusion 233

Chapter 10 Event Processing 235

Timers 235

Application Initialization Using Timers 237

Kickers 239

Simple Kicker 240

File Kicker and Receiver 243

Events 245

Custom Events 247

Conclusion 249

Chapter 11 Framework Components 251

URIUtils 251

   Java APIs 251

   Groovy APIs 255

   PHP APIs 256

Validators 257

Active Content Filtering 259

Assemble Flow 263

Conclusion 267

Chapter 12 Client-Side Programming with the Dojo Toolkit 269

Enter the Dojo 270

Enabling Dojo in Your Application 271

AppBuilder Page Designer 277

Put a Dojo Face on ZRM and Application Data 279

   DBA--A Complete RIA Using WebSphere sMash and Dojo 282

Project Creation 283

Layout Mockup 284

Initial Page Loading 286

Application Initialization 288

Driver Details and Schema Loading 291

Table Selection and Running SQL 293

Final Product 294

   Creating Custom Dojo Builds for Performance 294

Using Non-Supplied Versions of Dojo 295

   Debugging and Best Practices in Dojo Development 296

Debugging and Logging with Firebug 297

Code Validation with JSLint 297

Data Validation with JSONLint 298

Dojo References 298

Conclusion 299

Chapter 13 PHP in WebSphere sMash 301

Why Develop in PHP Using sMash? 301

Adding PHP to Your Application 301

PHP Applications 302

Running PHP Applications in WebSphere sMash 303

PHP to Java Bridge 303

   Accessing Java Classes 304

   Access Static Java Class Members 304

   Example: Using Apache Commons Logging in PHP 305

PHP to Groovy Bridge 308

   PHP to Groovy Bridge Example 308

Extending PHP 311

   Logger Extension Sample 313

Data Conversion Between PHP and Java in Extensions 315

   PHP Arguments to Java Variables 315

   Java to PHP Variable Conversion 317

SuperGlobals 317

   $_SERVER 318

   $_GET and $_POST 318

   $HTTP_RAW_POST_DATA 319

   $_FILES 319

   $_COOKIE 320

   $_REQUEST 320

XML Processing Using PHP and WebSphere sMash 320

WebSphere sMash PHP Extensions 323

   WebSphere sMash Utilities 323

   URI Utilities 326

   Java Extensions 327

   Groovy Extensions 328

   Remote Connections 329

   JSON Utilities 330

   Active Content Filtering 331

   Cross-Site Request Forgery 331

   Login 332

   Database Access 332

   XML Utilities 346

Conclusion 346

Appendix A Get Started with Groovy 349

Default Imports 350

Dynamic Typing 350

GStrings and Heredocs 351

Embedded Quotes 352

Getters and Field Pointers 352

Parentheses and Method Pointers 353

Return Statements 354

Exception Handling 354

Safe Dereferencing 355

Operator Overloading 355

Boolean Evaluation 356

Closures 357

Lists 358

Maps 361

Ranges 362

Looping 363

Optional Parameters 365

Index 367