Spring Recipes, 2nd Edition pdf

Injecting Spring Beans into Domain Objects .... Consuming Message-Oriented Services Using BlazeDS and Spring .... Exporting a Service Using Spring Dynamic Modules .... About the Authors

Gary Mak, Josh Long, and Daniel Rubio

Covers

Spring Framework 3

Learn to use the full power of Spring 3 through coding recipes!

SECOND EDITION

Spring

Recipes

A Problem-Solution Approach

electronic or mechanical, including photocopying, recording, or by any information storage or retrieval system, without the prior written permission of the copyright owner and the publisher

ISBN-13 (pbk): 978-1-4302-2499-0

ISBN-13 (electronic): 978-1-4302-2500-3

Printed and bound in the United States of America 9 8 7 6 5 4 3 2 1

Trademarked names, logos, and images may appear in this book Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only

in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark

The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject

to proprietary rights

President and Publisher: Paul Manning

Lead Editor: Tom Welsh

Technical Reviewer: Manuel Jordan, Mario Gray and Greg Turnquist

Editorial Board: Clay Andres, Steve Anglin, Mark Beckner, Ewan Buckingham, Gary Cornell,

Jonathan Gennick, Jonathan Hassell, Michelle Lowman, Matthew Moodie, Duncan Parkes, Jeffrey Pepper, Frank Pohlmann, Douglas Pundick, Ben Renow-Clarke, Dominic Shakeshaft, Matt Wade, Tom Welsh

Coordinating Editor: Laurin Becker

Copy Editor: Mary Ann Fugate, Heather Lang

Production Support: Patrick Cunningham

Indexer: BIM Indexing & Proofreading Services

Artist: April Milne

Cover Designer: Anna Ishchenko

Distributed to the book trade worldwide by Springer Science+Business Media, LLC.,

233 Spring Street, 6th Floor, New York, NY 10013 Phone 1-800-SPRINGER, fax (201) 348-4505,

e-mail orders-ny@springer-sbm.com, or visit www.springeronline.com

For information on translations, please e-mail rights@apress.com, or visit www.apress.com

Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use eBook versions and licenses are also available for most titles For more information, reference our Special Bulk Sales–eBook Licensing web page at www.apress.com/info/bulksales

The information in this book is distributed on an “as is” basis, without warranty Although every

precaution has been taken in the preparation of this work, neither the author(s) nor Apress shall have any liability to any person or entity with respect to any loss or damage caused or alleged to be caused directly or indirectly by the information contained in this work

The source code for this book is available to readers at www.apress.com You will need to answer

questions pertaining to this book in order to successfully download the code

To my family –Daniel Rubio

Contents at a Glance

About the Author xxxvii

About the Technical Reviewers xxxviii

Acknowledgments xxxix

Introduction xli ■ Chapter 1: Introduction to Spring 1

■ Chapter 2: Advanced Spring IoC Container 61

■ Chapter 3: Spring AOP and AspectJ Support 117

■ Chapter 4: Scripting in Spring 159

■ Chapter 5: Spring Security 171

■ Chapter 6: Integrating Spring with Other Web Frameworks 219

■ Chapter 7: Spring Web Flow 249

■ Chapter 8: Spring @MVC 297

■ Chapter 9: Spring REST 371

■ Chapter 10: Spring and Flex 405

■ Chapter 11: Grails 459

■ Chapter 12: Spring Roo 501

■ Chapter 13: Spring Testing 525

■ Chapter 14: Spring Portlet MVC Framework 569

■ Chapter 15: Data Access 597

■ Chapter 16: Transaction Management in Spring 663

■ Chapter 17: EJB, Spring Remoting, and Web Services 707

■ Chapter 18: Spring in the Enterprise 765

■ Chapter 19: Messaging 803

■ Chapter 20: Spring Integration 829

■ Chapter 21: Spring Batch 875

■ Chapter 22: Spring on the Grid 909

■ Chapter 23: jBPM and Spring 935

■ Chapter 24: OSGi and Spring 959

Index 985

Contents

About the Authors xxxvii

About the Technical Reviewers xxxviii

Acknowledgments xxxix

Introduction xli ■ Chapter 1: Introduction to Spring 1

1-1 Instantiating the Spring IoC Container 1

Problem 1

Solution 1

How It Works 3

1-2 Configuring Beans in the Spring IoC Container 4

Problem 4

Solution 4

How It Works 5

1-3 Creating Beans by Invoking a Constructor 14

Problem 14

Solution 15

How It Works 15

1-4 Resolving Constructor Ambiguity 18

Problem 18

Solution 18

How It Works 18

1-5 Specifying Bean References 21

Problem 21

Solution 21

How It Works 21

1-6 Specifying the Data Type for Collection Elements 25

Problem 25

Solution 25

How It Works 25

1-7 Creating Beans Using Spring’s FactoryBean 28

Problem 28

Solution 28

How It Works 28

1-8 Defining Collections Using Factory Beans and the Utility Schema 30

Problem 30

Solution 30

How It Works 30

1-9 Checking Properties with Dependency Checking 32

Problem 32

Solution 32

How It Works 33

1-10 Checking Properties with the @Required Annotation 35

Problem 35

Solution 35

How It Works 35

1-11 Auto-Wiring Beans with XML Configuration 38

Problem 38

Solution 38

How It Works 39

1-12 Auto-Wiring Beans with @Autowired and @Resource 42

Problem 42

Solution 42

How It Works 43

1-13 Inheriting Bean Configuration 49

Problem 49

Solution 49

How It Works 50

1-14 Scanning Components from the Classpath 53

Problem 53

Solution 53

How It Works 53

Summary 58

■ Chapter 2: Advanced Spring IoC Container 61

2-1 Creating Beans by Invoking a Static Factory Method 61

Problem 61

Solution 61

How It Works 61

2-2 Creating Beans by Invoking an Instance Factory Method 62

Problem 62

Solution 63

How It Works 63

2-3 Declaring Beans from Static Fields 64

Problem 64

Solution 64

How It Works 64

2-4 Declaring Beans from Object Properties 66

Problem 66

Solution 66

How It Works 66

2-5 Using the Spring Expression Language 68

Problem 68

Solution 68

How It Works 68

2-6 Setting Bean Scopes 74

Problem 74

Solution 74

How It Works 74

2-7 Customizing Bean Initialization and Destruction 77

Problem 77

Solution 77

How It Works 77

2-8 Reducing XML Configuration with Java Config 82

Problem 82

Solution 82

How It Works 82

2-9 Making Beans Aware of the Container 86

Problem 86

Solution 86

How It Works 87

2-10 Loading External Resources 88

Problem 88

Solution 88

How It Works 89

2-11 Creating Bean Post Processors 91

Problem 91

Solution 91

How It Works 92

2-12 Externalizing Bean Configurations 95

Problem 95

Solution 95

How It Works 95

2-13 Resolving Text Messages 96

Problem 96

Solution 97

How It Works 97

2-14 Communicating with Application Events 99

Problem 99

Solution 99

How It Works 99

2-15 Registering Property Editors in Spring 102

Problem 102

Solution 102

How It Works 102

2-16 Creating Custom Property Editors 105

Problem 105

Solution 105

How It Works 105

2-17 Concurrency with TaskExecutors 107

Problem 107

Solution 107

How It Works 107

Summary 116

■ Chapter 3: Spring AOP and AspectJ Support 117

3-1 Enabling AspectJ Annotation Support in Spring 117

Problem 117

Solution 118

How It Works 118

3-2 Declaring Aspects with AspectJ Annotations 120

Problem 120

Solution 120

How It Works 121

3-3 Accessing the Join Point Information 126

Problem 126

Solution 127

How It Works 127

3-4 Specifying Aspect Precedence 128

Problem 128

Solution 128

How It Works 128

3-5 Reusing Pointcut Definitions 130

Problem 130

Solution 130

How It Works 130

3-6 Writing AspectJ Pointcut Expressions 132

Problem 132

Solution 132

How It Works 133

3-7 Introducing Behaviors to Your Beans 138

Problem 138

Solution 138

How It Works 138

3-8 Introducing States to Your Beans 141

Problem 141

Solution 141

How It Works 141

3-9 Declaring Aspects with XML-Based Configurations 143

Problem 143

Solution 143

How It Works 143

3-10 Load-Time Weaving AspectJ Aspects in Spring 146

Problem 146

Solution 146

How It Works 147

3-11 Configuring AspectJ Aspects in Spring 152

Problem 152

Solution 152

How It Works 153

3-12 Injecting Spring Beans into Domain Objects 154

Problem 154

Solution 154

How It Works 154

Summary 158

■ Chapter 4: Scripting in Spring 159

19-1 Implementing Beans with Scripting Languages 159

Problem 159

Solution 159

How It Works 160

19-2 Injecting Spring Beans into Scripts 164

Problem 164

Solution 164

How It Works 164

19-3 Refreshing Beans from Scripts 167

Problem 167

Solution 167

How It Works 168

19-4 Defining Script Sources Inline 168

Problem 168

Solution 168

How It Works 169

Summary 170

■ Chapter 5: Spring Security 171

5-1 Securing URL Access 172

Problem 172

Solution 172

How It Works 173

5-2 Logging In to Web Applications 183

Problem 183

Solution 183

How It Works 183

5-3 Authenticating Users 187

Problem 187

Solution 188

How It Works 188

5-4 Making Access Control Decisions 199

Problem 199

Solution 200

How It Works 200

5-5 Securing Method Invocations 203

Problem 203

Solution 203

How It Works 203

5-6 Handling Security in Views 206

Problem 206

Solution 206

How It Works 206

5-7 Handling Domain Object Security 208

Problem 208

Solution 208

How It Works 209

Summary 218

■ Chapter 6: Integrating Spring with Other Web Frameworks 219

6-1 Accessing Spring in Generic Web Applications 220

Problem 220

Solution 220

How It Works 220

6-2 Using Spring in Your Servlets and Filters 224

Problem 224

Solution 225

How It Works 225

6-3 Integrating Spring with Struts 1.x 230

Problem 230

Solution 230

How It Works 231

6-4 Integrating Spring with JSF 237

Problem 237

Solution 237

How It Works 238

6-5 Integrating Spring with DWR 244

Problem 244

Solution 244

How It Works 244

Summary 248

■ Chapter 7: Spring Web Flow 249

7-1 Managing a Simple UI Flow with Spring Web Flow 249

Problem 249

Solution 249

How It Works 250

7-2 Modeling Web Flows with Different State Types 258

Problem 258

Solution 259

How It Works 259

7-3 Securing Web Flows 272

Problem 272

Solution 273

How It Works 273

7-4 Persisting Objects in Web Flows 275

Problem 275

Solution 275

How It Works 275

7-5 Integrating Spring Web Flow with JSF 283

Problem 283

Solution 283

How It Works 283

7-6 Using RichFaces with Spring Web Flow 291

Problem 291

Solution 291

Approach 291

Summary 295

■ Chapter 8: Spring @MVC 297

8-1 Developing a Simple Web Application with Spring MVC 297

Problem 297

Solution 297

How It Works 299

8-2 Mapping requests with @RequestMapping 310

Problem 310

Solution 311

How It Works 311

8-3 Intercepting Requests with Handler Interceptors 314

Problem 314

Solution 315

How It Works 315

8-4 Resolving User Locales 318

Problem 318

Solution 319

How It Works 319

8-5 Externalizing Locale-Sensitive Text Messages 321

Problem 321

Solution 321

How It Works 321

8-6 Resolving Views by Names 322

Problem 322

Solution 322

How It Works 323

8-7 Views and Content Negotiation 325

Problem 325

Solution 326

How It Works 326

8-8 Mapping Exceptions to Views 329

Problem 329

Solution 329

How It Works 329

8-9 Assigning values in a Controller with @Value 331

Problem 331

Solution 331

How It Works 331

8-10 Handling Forms with Controllers 333

Problem 333

Solution 333

How It Works 333

8-11 Handling Multipage Forms with Wizard Form Controllers 348

Problem 348

Solution 348

How It Works 349

8-12 Bean validation with Annotations (JSR-303) 359

Problem 359

Solution 359

How It Works 359

8-13 Creating Excel and PDF Views 362

Problem 362

Solution 362

How It Works 362

Summary 369

■ Chapter 9: Spring REST 371

9-1 Publishing a REST Service with Spring 371

Problem 371

Solution 371

How It Works 372

9-2 Accessing a REST Service with Spring 376

Problem 376

Solution 376

How It Works 377

9-3 Publishing RSS and Atom feeds 381

Problem 381

Solution 381

How It Works 382

9-4 Publishing JSON with REST services 391

Problem 391

Solution 391

How It Works 392

9-5 Accessing REST Services with Elaborate XML Responses 394

Problem 394

Solution 394

How It Works 394

Summary 404

■ Chapter 10: Spring and Flex 405

10-1 Getting started with Flex 406

Problem 406

Solution 407

How It Works 407

10-2 Leaving the Sandbox 412

Problem 412

Solution 412

How It Works 413

10-3 Adding the Spring BlazeDS support to an application 424

Problem 424

Solution 424

How It Works 425

10-4 Exposing Services Through BlazeDS / Spring 430

Problem 430

Solution 430

How It Works 430

10-5 Working With Server-Side Objects 437

Problem 437

Solution 437

How It Works 437

10-6 Consuming Message-Oriented Services Using BlazeDS and Spring 440

Problem 440

Solution 441

How It Works 441

10-7 Bringing Dependency Injection to your ActionScript Client 452

Problem 452

Solution 453

How It Works 453

Summary 457

■ Chapter 11: Grails 459

11-1 Getting and Installing Grails 459

Problem 459

Solution 459

How It Works 460

11-2 Creating a Grails Application 460

Problem 460

Solution 461

How It Works 461

11-3 Grails Plug-Ins 466

Problem 466

Solution 466

How It Works 467

11-4 Developing, Producing, and Testing in Grails Environments 468 Problem 468 Solution 468 How It Works 468 11-5 Creating an Application’s Domain Classes 470 Problem 470 Solution 471 How It Works 471 11-6 Generating CRUD Controllers and Views for an Application’s Domain Classes 473 Problem 473 Solution 473 How It Works 473 11-7 Internationalization (I18n) Message Properties 477 Problem 477 Solution 477 How it works 477 11-8 Changing Permanent Storage Systems 480 Problem 480 Solution 480 How It Works 480 11-9 Logging 483 Problem 483 Solution 483 How It Works 483 11-10 Running Unit and Integration Tests 486 Problem 486 Solution 486 How It Works 487

11-11 Using Custom Layouts and Templates 492 Problem 492 Solution 492 How It Works 492 11-12 Using GORM Queries 495 Problem 495 Solution 495 How It Works 495 11-13 Creating Custom Tags 497 Problem 497 Solution 497 How It Works 497 Summary 499

■ Chapter 12: Spring Roo 501

12-1 Setting Up the Spring Roo Development Environment 503 Problem 503 Solution 503 How It Works 503 12-2 Creating Your First Spring Roo Project 506 Problem 506 Solution 506 How It Works 506 12-3 Importing an Existing Project into SpringSource Tool Suite 512 Problem 512 Solution 512 How It Works 512 12-4 Building A Better Application, Quicker 514 Problem 514 Solution 515 How It Works 515

12-5 Removing Spring Roo from Your Project 521 Problem 521 Solution 522 How It Works 522 Summary 523

■ Chapter 13: Spring Testing 525

13-1 Creating Tests with JUnit and TestNG 526 Problem 526 Solution 526 How It Works 526 13-2 Creating Unit Tests and Integration Tests 532 Problem 532 Solution 532 How It Works 533 13-3 Unit Testing Spring MVC Controllers 542 Problem 542 Solution 542 How It Works 542 13-4 Managing Application Contexts in Integration Tests 544 Problem 544 Solution 544 How It Works 545 13-5 Injecting Test Fixtures into Integration Tests 551 Problem 551 Solution 551 How It Works 551 13-6 Managing Transactions in Integration Tests 555 Problem 555 Solution 555 How It Works 556

13-7 Accessing a Database in Integration Tests 561 Problem 561 Solution 561 How It Works 562 13-8 Using Spring’s Common Testing Annotations 565 Problem 565 Solution 565 How It Works 566 Summary 568

■ Chapter 14: Spring Portlet MVC Framework 569

14-1 Developing a Simple Portlet with Spring Portlet MVC 569 Problem 569 Solution 569 How It Works 571 14-2 Mapping Portlet Requests to Handlers 579 Problem 579 Solution 579 How It Works 579 14-3 Handling Portlet Forms with Simple Form Controllers 587 Problem 587 Solution 587 How It Works 587 Summary 595

■ Chapter 15: Data Access 597

Problems with Direct JDBC 598 Setting Up the Application Database 598 Understanding the Data Access Object Design Pattern 600 Implementing the DAO with JDBC 600 Configuring a Data Source in Spring 602

How It Works 604 Running the DAO 605 Taking It A Step Further 606 15-1 Using a JDBC Template to Update a Database 606 Problem 606 Solution 607 How It Works 607 15-2 Using a JDBC Template to Query a Database 612 Problem 612 Solution 612 How It Works 612 15-3 Simplifying JDBC Template Creation 617 Problem 617 Solution 617 How It Works 618 15-4 Using the Simple JDBC Template with Java 1.5 620 Problem 620 Solution 620 How It Works 620 15-5 Using Named Parameters in a JDBC Template 624 Problem 624 Solution 624 How It Works 624 15-6 Handling Exceptions in the Spring JDBC Framework 626 Problem 626 Solution 626 How It Works 627 15-7 Problems with Using ORM Frameworks Directly 632 Problem 632 Solution 632 How It Works 632

Persisting Objects Using the Hibernate API with Hibernate XML Mappings 634 Persisting Objects Using the Hibernate API with JPA Annotations 637 Persisting Objects Using JPA with Hibernate as the Engine 639 15-8 Configuring ORM Resource Factories in Spring 643 Problem 643 Solution 643 How It Works 643 15-9 Persisting Objects with Spring’s ORM Templates 649 Problem 649 Solution 650 How It Works 650 15-10 Persisting Objects with Hibernate’s Contextual Sessions 656 Problem 656 Solution 656 How It Works 656 15-11 Persisting Objects with JPA’s Context Injection 659 Problem 659 Solution 659 How It Works 660 Summary 662

■ Chapter 16: Transaction Management in Spring 663

16-1 Problems with Transaction Management 664 16-2 Choosing a Transaction Manager Implementation 671 Problem 671 Solution 671 How It Works 672 16-3 Managing Transactions Programmatically with the Transaction Manager API 673 Problem 673 Solution 673 How It Works 673

16-4 Managing Transactions Programmatically with a Transaction Template 675 Problem 675 Solution 675 How It Works 676 16-5 Managing Transactions Declaratively with Transaction Advices 678 Problem 678 Solution 679 How It Works 679 16-6 Managing Transactions Declaratively with the @Transactional Annotation 681 Problem 681 Solution 681 How It Works 682 16-7 Setting the Propagation Transaction Attribute 683 Problem 683 Solution 683 How It Works 684 16-8 Setting the Isolation Transaction Attribute 689 Problem 689 Solution 689 How It Works 690 16-9 Setting the Rollback Transaction Attribute 698 Problem 698 Solution 698 How It Works 699 16-10 Setting the Timeout and Read-Only Transaction Attributes 700 Problem 700 Solution 700 How It Works 700

16-11 Managing Transactions with Load-Time Weaving 701 Problem 701 Solution 702 How It Works 702 Summary 705

■ Chapter 17: EJB, Spring Remoting, and Web Services 707

17-1 Exposing and Invoking Services Through RMI 707 Problem 707 Solution 707 How It Works 708 17-2 Creating EJB 2.x Components with Spring 711 Problem 711 Solution 712 How It Works 712 17-3 Accessing Legacy EJB 2.x Components in Spring 718 Problem 718 Solution 719 How It Works 719 17-4 Creating EJB 3.0 Components in Spring 723 Problem 723 Solution 723 How It Works 723 17-5 Accessing EJB 3.0 Components in Spring 725 Problem 725 Solution 725 How It Works 725 17-6 Exposing and Invoking Services Through HTTP 727 Problem 727 Solution 727 How It Works 727

17-7 Choosing a SOAP Web Service Development Approach 731 Problem 731 Solution 731 How It Works 731 17-8 Exposing and Invoking a Contract-Last SOAP Web Services Using JAX-WS 733 Problem 733 Solution 733 How It Works 733 17-9 Defining the Contract of a Web Service 740 Problem 740 Solution 740 How It Works 741 17-10 Implementing Web Services Using Spring-WS 745 Problem 745 Solution 745 How It Works 746 17-11 Invoking Web Services Using Spring-WS 751 Problem 751 Solution 751 How It Works 751 17-12 Developing Web Services with XML Marshalling 755 Problem 755 Solution 755 How It Works 756 17-13 Creating Service Endpoints with Annotations 761 Problem 761 Solution 761 How It Works 761 Summary 763

■ Chapter 18: Spring in the Enterprise 765

18-1 Exporting Spring Beans as JMX MBeans 765 Problem 765 Solution 766 How It Works 766 18-2 Publishing and Listening to JMX Notifications 778 Problem 778 Solution 778 How It Works 778 18-3 Accessing Remote JMX MBeans in Spring 780 Problem 780 Solution 780 How It Works 780 18-4 Sending E-mail with Spring’s E-mail Support 783 Problem 783 Solution 784 How It Works 784 18-5 Scheduling with Spring’s Quartz Support 792 Problem 792 Solution 792 How It Works 792 18-6 Scheduling With Spring 3.0’s Scheduling Namespace 797 Problem 797 Solution 797 How It Works 797 Summary 801

■ Chapter 19: Messaging 803

19-1 Sending and Receiving JMS Messages with Spring 804 Problem 804 Solution 804 How It Works 805 19-2 Converting JMS Messages 816 Problem 816 Solution 817 Approach 817 19-3 Managing JMS Transactions 819 Problem 819 Approach 819 Solution 819 19-4 Creating Message-Driven POJOs in Spring 821 Problem 821 Solution 821 How It Works 821 19-5 Making the Connection 827 Problem 827 Solution 827 How It Works 828 Summary 828

■ Chapter 20: Spring Integration 829

20-1 Integrating One System with Another Using EAI 830 Problem 830 Solution 830 How It Works 831

20-2 Integrating Two Systems Using JMS 833 Problem 833 Solution 833 How it Works 833 20-3 Interrogating Spring Integration Messages for Context Information 837 Problem 837 Solution 837 How it Works 838 20-4 Integrating Two Systems Using a File System 840 Problem 840 Solution 840 How It Works 841 20-5 Transforming a Message from One Type to Another 843 Problem 843 Solution 843 How It Works 843 20-6 Error Handling Using Spring Integration 846 Problem 846 Solution 847 How It Works 847 20-7 Forking Integration Control: Splitters and Aggregators 849 Problem 849 Solution 849 How it Works 850 20-8 Conditional Routing with Routers 853 Problem 853 Solution 853 How It Works 853

20-9 Adapting External Systems to the Bus 854 Problem 854 Solution 854 How It Works 855 20-10 Staging Events Using Spring Batch 865 Problem 865 Solution 865 How It Works 865 20-11 Using Gateways 866 Problem 866 Solution 866 How It Works 867 Summary 873

■ Chapter 21: Spring Batch 875

Runtime Metadata Model 876 21-1 Setting Up Spring Batch’s Infrastructure 877 Problem 877 Solution 877 How It Works 878 21-2 Reading and Writing (but No Arithmetic) 880 Problem 880 Solution 880 How It Works 880 21-3 Writing a Custom ItemWriter and ItemReader 885 Problem 885 Solution 885 How It Works 885

21-4 Processing Input Before Writing 888 Problem 888 Solution 888 How It Works 888 21-5 Better Living through Transactions 891 Problem 891 Solution 891 How It Works 891 21-6 Retrying 893 Problem 893 Solution 893 How It Works 893 21-7 Controlling Step Execution 896 Problem 896 Solution 896 How It Works 897 21-8 Launching a Job 900 Problem 900 Solution 901 How It Works 901 21-9 Parameterizing a Job 905 Problem 905 Solution 905 How It Works 905 Summary 907

■ Chapter 22: Spring on the Grid 909

22-1 Clustering Object State Using Terracotta 911 Problem 911 Solution 911 How It Works 911

22-2 Farming Out Execution to a Grid 921 Problem 921 Solution 921 Approach 921 22-3 Load Balancing a Method 923 Problem 923 Solution 923 Approach 923 22-4 Parallelizing Processing 927 Problem 927 Solution 927 Approach 927 22-5 Deploying on GridGain 929 Problem 929 Solution 929 How It Works 929 Summary 934

■ Chapter 23: jBPM and Spring 935

Software Processes 936 23-1 Understanding Workflow Models 939 Problem 939 Solution 939 How It Works 939 23-2 Installing jBPM 941 Problem 941 Solution 941 How It Works 941

23-3 Integrating jBPM 4 with Spring 944 Problem 944 Solution 944 How It Works 944 23-4 Building a Service with Spring 950 Problem 950 Solution 950 How It Works 950 23-5 Building a Business Process 953 Problem 953 Solution 954 How It Works 954 Summary 956

■ Chapter 24: OSGi and Spring 959

24-1 Getting Started with OSGi 960 Problem 960 Solution 960 How It Works 960 24-2 Getting Started Using Spring Dynamic Modules 967 Problem 967 Solution 967 How It Works 967 24-3 Exporting a Service Using Spring Dynamic Modules 971 Problem 971 Solution 971 How It Works 971 24-4 Finding a Specific Service in the OSGi Registry 975 Problem 975 Solution 975 How It Works 975

24-5 Publishing a Service Under Multiple Interfaces 977 Problem 977 Solution 977 How It Works 978 24-6 Customizing Spring Dynamic Modules 979 Problem 979 Solution 979 How It Works 979 24-7 Using SpringSource dm Server 981 Problem 981 Solution 981 How It Works 981 24-8 SpringSource’s Tooling 982 Problem 982 Solution 982 How it Works 983 Summary 983

Index 985

About the Authors

■ Gary Mak, founder and chief consultant of Meta-Archit Software Technology Limited, has been a technical architect and application developer on the enterprise Java platform for over seven years He is the author of the Apress books

Spring Recipes: A Problem-Solution Approach and Pro SpringSource dm Server

In his career, Gary has developed a number of Java-based software projects, most

of which are application frameworks, system infrastructures, and software tools

He enjoys designing and implementing the complex parts of software projects

Gary has a master’s degree in computer science and his research interests include object-oriented technology, aspect-oriented technology, design patterns, software reuse, and domain-driven development

Gary specializes in building enterprise applications on technologies such as Spring, Hibernate, JPA, JSF, Portlet, AJAX, and OSGi He has been using the Spring framework in his projects for five years, since Spring version 1.0 Gary has been an instructor of courses on enterprise Java, Spring, Hibernate, Web

Services, and agile development He has written a series of Spring and Hibernate tutorials as course

materials, parts of which are open to the public, and they’re gaining popularity in the Java community

In his spare time, he enjoys playing tennis and watching tennis competitions

■ Josh Long, Spring Developer Advocate for SpringSource, is an engineer (wearing

an architect's hat) with more than a decade of experience and a vocal contributor to the community He is a contributor and committer to open source projects, including the Spring Integration project He is a member of the JCP, as well as an editor for the popular technology portal InfoQ.com Josh is a frequent speaker at conferences, both nationally and internationally, on a number of topics ranging from business process management and web frameworks to enterprise application integration and architecture patterns His interests include scalability, BPM, grid processing, mobile computing, and so-called "smart" systems

In his function as the Spring Developer Advocate for SpringSource, he focuses on growing and enriching the community around the Spring platform

Josh lives in sunny southern California with his wife Richelle He maintains a blog at www.joshlong.com and can be reached via e-mail at josh@joshlong.com

■ Daniel Rubio is a consultant with over ten years of experience in enterprise and web technologies Throughout his career, he's relied on Java, Python, CORBA, and NET technologies to deliver cost effective solutions to the financial and manufacturing industries More recently, he has focused on convention-over-configuration web frameworks—Spring, Grails, Roo, and Django—

concentrating on their performance and scalability in enterprise settings

Additionally, he writes articles on emerging technologies for various content networks in this same space, which include Oracle Technology Network, DZone, and his own blog at www.WebForefront.com

About the Technical Reviewers

■ Manuel Jordan Elera is a freelance Java developer He has designed and developed personal systems for his customers using powerful frameworks based

in Java, such as Spring and Hibernate, among others Manuel is now an autodidact developer and enjoys learning new frameworks to get better results

on his projects

Manuel has a degree in systems engineering with public congratulations, and he is a professor at Universidad Católica de Santa María and Universidad Alas Peruanas in Perú In his little free time, he likes reading the bible and composing music with his guitar Manuel is a senior member in the Spring Community Forums known as dr_pompeii

You can contact him through his blog at http://manueljordan

wordpress.com/

■ Mario Gray is an engineer with more than a decade of experience in systems integration, systems administration, game programming, and highly available enterprise architectures He is ever vigilant for force-multiplying technologies to better enable businesses He has developed countless systems, including CRMs, message plants, and highly available web applications using leading open source, enterprise Java frameworks and tools Mario has a record of successfully leveraging open source frameworks to better serve businesses

He lives in the city of Chandler, Arizona with his wife Fumiko and his daughter Makani Enjoying outdoor recreational sports, exercise, and family activities are his main habits outside of his career He maintains a blog at www.sudoinit5.com and can be reached at mario@sudioinit5.com

■ Greg Turnquist is a test-bitten script junkie always seeking the right tool for the job He has been a professional software developer since 1997 and has worked on a diverse number of systems, including mission-critical, 24 × 7 × 365 systems In 2006, he created the Spring Python project, taking the concepts of Spring to the platform of Python In 2010 he joined the SpringSource team He is the author of Spring Python 1.1 and is a SpringOne speaker He graduated with a master's degree from Auburn University and lives in the United States with his family