Getting Started with IBM Websphere Smash

by Lynn, Ron; Bishop, Karl; King, Brett

• ISBN13: 9780137019700
• ISBN10: 013701970X
• Edition: 1st
• Format: Hardcover
• Copyright: 2010-09-20
• Publisher: IBM Press

Summary

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, itrs"s far easier to develop, assemble, and run applications and mashups that align tightly with SOA enterprise infrastructures.Getting Started with IBM WebSphere sMashcovers 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, yours"ll master both basic and advanced sMash features, ranging from request handling to event processing, database access to security. Yours"ll also learn agile best practices for consistently writing better web applications, delivering them sooner, and getting more value from them. Coverage includes bull; Installing and configuring IBM WebSphere sMash, and choosing your development environment bull; Creating handlers to efficiently service all types of requests bull; Understanding sMashrs"s "convention over configuration" approach, and knowing when to override convention bull; Rendering responses that include visual content, data, and other resources bull; Connecting with databases via Project Zerors"s powerful data access API bull; Using sMashrs"s security model to protect inbound and outbound connections bull; Building more flexible applications with sMashrs"s sophisticated event processing bull; Extending sMash development to non-programmers with Assemble Flow bull; Programming client-side code with the Dojo Toolkit bull; Taking advantage of sMashrs"s PHP support

Author Biography

Ron Lynn is a Senior Software Engineer on the IBM Web Enablement and support team. He is currently working on internal projects utilizing WebSphere sMash. Ron joined IBM June 1995, as an indentured graduate student and has yet to return to academia. As an IBM neophyte, he spent his time working on a now-defunct project called Knowledge Utility (KnU). KnU allowed for exploration of many technologies and theories, from a then little-known language named Java to knowledge representation to what we now call portals and portlets. This led him to develop portlets for IBM Business Partners and proselytizing portals to the world. After landing on the Web enablement and support development team, Ron formalized his expertise into building portal applications in support of IBM’s biggest customer, IBM. The team’s fast pace and everchanging project line-up is a fertile environment for forging applications out of the latest IBM products and technologies, which led him to work with Web 2.0 technology and WebSphere sMash.

 

Ron’s primary passion for his job is the multiplicity of skills it draws upon from the mathematical, theoretical, scientifical, and engineerical to the personal, magical, and artistical. The constant variety and juggling keeps him forever learning and wondering what will smite him next--though there are dark times when he muses if he’d have the same passion for his work were he a juggler in the circus.

 

Ron calls a small farm in the San Joaquin Valley of central California home, where he lives with his fabulous wife, darling children, a great dog, and several cats of undetermined disposition. When he’s not bent over his computers, he spends his time as a father, husband, knitter, dressmaker, tailor, welder, carpenter, painter, plumber, gardener, pool boy, fine furniture builder, farmer, mechanic, writer, mad scientist, and water gun target. He loves to see the angelic delight on little faces as the latest in rocket launchers, onagers, or robots work wonderfully or fail fabulously. He doesn’t even mind the eventual chastisement when his lovely wife discovers the mess that the dog must have made. (Sorry Madison--someone had to take the fall.)

 

Karl Bishop is a Senior Software Engineer with IBM. He works for the Web enablement and support group within the IBM Software Services for WebSphere for IBM. As the name implies, his group develops and supports many internal IBM applications. His technical focus of late has been in Web 2.0 technologies in general, and the Dojo Toolkit in particular. Karl has worked for IBM for close to 12 years. Before that, he spent another dozen years honing his geek credentials at another computer company in California. Karl currently works out of his house, hidden away in the Sandhills near Pinehurst, North Carolina--no, he doesn’t play golf--but professes to be an original “Florida Cracker” by heart and birth.

 

When he’s not pounding away at the keyboard, Karl enjoys being the cool dad and husband. Karl likes to play with his son, Matt, building Lego’s and other contraptions. With his daughter, Aubri, he plays games, critiques her artwork, and generally goofs off. Other family enjoyments include biking, swimming, gardening, and playing disc golf. Karl also enjoys brewing when time permits and quaffing craft beers just about anytime. When work gets to be too much, the Bishop family frequently heads up toward the Appalachian mountains or the beach. Come on kids, we’re off to Boone-Tweetsie Railroad and the Mellow Mushroom are calling.

 

Brett King is a Senior Software Engineer with IBM, working on the WebSphere Commerce product. He is currently working on social networking enhancements to the product using WebSphere sMash. Prior to WebSphere Commerce, Brett was a developer on WebSphere sMash. Brett has been a software developer at IBM for almost 20 years, working in such varied areas as networking software, pervasive computing, and grid computing. He has been fortunate to work with advanced technologies throughout his career, including WebSphere sMash. He has particular interests in finding ways for developers to be more productive, whether through better tools or better software engineering processes, such as agile development.

 

Brett grew up in rural Pennsylvania but he has lived in the Research Triangle area of North Carolina since graduating from Lehigh University. In his free time, Brett has a wonderful wife, two kids, and a multitude of hobbies to keep him busy. He especially enjoys reliving his childhood through his own kids. Always eager to tap into his creative side, Brett enjoys playing role-playing games, constructing miniature terrain sets, and modding his muscle car. Brett also enjoys travel, with favorite destinations being places with historical significance, the homes of remote family members, and anywhere the Pittsburgh Steelers are playing.

 

Table of 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