Spring Recipes (eBook)

A Problem-Solution Approach

Gary Mak (Autor)

eBook Download: PDF

2008 | 1st ed.
XXIV, 700 Seiten
Apress (Verlag)
978-1-4302-0623-1 (ISBN)

Infos

Spring Framework 2 Recipes by Gary Mak is the newest, latest Spring book from Apress and its Spring from the Source series. This book lets readers get down and dirty with Spring code for immediate copy/paste into the reader's specific application development project.

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 more than 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. 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 including Spring, Hibernate, JPA, JSF, Portlet, AJAX, and OSGi. He has been using the Spring Framework in his projects 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.

---

Spring addresses most aspects of Java/Java EE application development and offers simple solutions to them. By using Spring, you will be lead to use industry best practices to design and implement your applications. The releases of Spring 2.x added many improvements and new features to the 1.x versions. Spring Recipes: A Problem–Solution Approach focuses on Spring 2.5 features for building enterprise Java applications.Spring Recipes covers Spring 2.5 from basic to advanced, including Spring IoC container, Spring AOP and AspectJ, Spring data access support, Spring transaction management, Spring Web and Portlet MVC, Spring testing support, Spring support for remoting, EJB, JMS, JMX, E–mail, scheduling, and scripting languages. This book also introduces several common Spring Portfolio projects that will bring significant value to your application development, including Spring Security, Spring Web Flow, and Spring Web Services.The topics in this book are introduced by complete and real–world code examples that you can follow step by step. Instead of abstract descriptions on complex concepts, you will find live examples in this book. When you start a new project, you can consider copying the code and configuration files from this book, and then modifying them for your needs. This can save you a great deal of work over creating a project from scratch.

Inhalt

Title Page 2
Copyright Page 3
Contents at a Glance 4
Table of Contents 6
About the Author 13
About the Technical Reviewers 14
Acknowledgments 15
Introduction 16
Who This Book Is For 16
How This Book Is Structured 17
Conventions 19
Prerequisites 19
Downloading the Code 19
Contacting the Author 19
PART 1 Core 20
CHAPTER 1 Inversion of Control and Containers 21
1-1.Using a Container toManageYour Components 22
Problem 22
Solution 22
How It Works 22
Separating Interface from Implementation 22
Employing a Container 24
1-2.Using a Service Locator to Reduce Lookup Complexity 27
Problem 27
Solution 27
How It Works 27
1-3. Applying Inversion of Control and Dependency Injection 29
Problem 29
Solution 29
How It Works 29
1-4.Understanding Different Types of Dependency Injection 31
Problem 31
Solution 31
How It Works 31
Setter Injection (Type 2 IoC) 31
Constructor Injection (Type 3 IoC) 32
Interface Injection (Type 1 IoC) 33
1-5. Configuring a Container with a Configuration File 35
Problem 35
Solution 35
How It Works 35
1-6. Summary 38
CHAPTER 2 Introduction to Spring 39
2-1. Introducing the Spring Framework 39
Introducing Spring’s Modules 40
Introducing Spring’s Releases 41
Introducing Spring’s Projects 43
2-2. Installing the Spring Framework 44
Problem 44
Solution 44
How It Works 44
Installing JDK 44
Installing a Java IDE 44
Downloading and Installing Spring 44
Exploring Spring’s Installation Directory 45
2-3. Setting Up a Spring Project 46
Problem 46
Solution 46
How It Works 46
Setting Up the Classpath 46
Creating the Bean Configuration File 46
Using Beans from the Spring IoC Container 47
2-4. Installing Spring IDE 48
Problem 48
Solution 48
How It Works 48
2-5.Using Spring IDE’s Bean-Supporting Features 50
Problem 50
Solution 50
How It Works 50
Creating a Spring Project 50
Creating a Spring Bean Configuration File 50
Viewing Spring Beans in Spring Explorer 53
Viewing Spring Beans in Spring Beans Graph 54
Using Content Assist in Bean Configuration Files 55
Validating Bean Configuration Files 55
Searching Spring Beans 56
2-6. Summary 57
CHAPTER 3 Bean Configuration in Spring 58
3-1. Configuring Beans in the Spring IoC Container 58
Problem 58
Solution 58
How It Works 59
Creating the Bean Class 59
Creating the Bean Configuration File 60
Declaring Beans in the Bean Configuration File 60
Defining Bean Properties by Shortcut 62
3-2. Instantiating the Spring IoC Container 62
Problem 62
Solution 62
How It Works 63
Instantiating a Bean Factory 63
Instantiating an Application Context 64
Getting Beans from the IoC Container 64
3-3. Resolving Constructor Ambiguity 65
Problem 65
Solution 65
How It Works 65
3-4. Specifying Bean References 68
Problem 68
Solution 68
How It Works 68
Specifying Bean References for Setter Methods 69
Declaring Inner Beans 72
3-5. Checking Properties with Dependency Checking 72
Problem 72
Solution 72
How It Works 73
Checking Properties of the Simple Types 73
Checking Properties of the Object Types 74
Checking Properties of All Types 74
Dependency Checking and Constructor Injection 74
3-6. Checking Properties with the @Required Annotation 75
Problem 75
Solution 75
How It Works 75
3-7. Auto-Wiring Beans with XML Configuration 77
Problem 77
Solution 77
How It Works 78
Auto-Wiring by Type 78
Auto-Wiring by Name 79
Auto-Wiring by Constructor 80
Auto-Wiring by Auto-Detection 80
Auto-Wiring and Dependency Checking 81
3-8. Auto-Wiring Beans with @Autowired and @Resource 81
Problem 81
Solution 81
How It Works 82
Auto-Wiring a Single Bean of Compatible Type 82
Auto-Wiring All Beans of Compatible Type 84
Auto-Wiring by Type with Qualifiers 86
Auto-Wiring by Name 87
3-9. Inheriting Bean Configuration 88
Problem 88
Solution 88
How It Works 88
3-10.Defining Collections for Bean Properties 91
Problem 91
Solution 91
How It Works 92
Lists, Arrays, and Sets 92
Maps and Properties 95
Merging the Collection of the Parent Bean 97
3-11. Specifying the Data Type for Collection Elements 98
Problem 98
Solution 98
How It Works 99
3-12.Defining Collections Using Factory Beans and the Utility Schema 101
Problem 101
Solution 101
How It Works 101
Specifying the Concrete Class for Collections 101
Defining Stand-Alone Collections 102
3-13. Scanning Components from the Classpath 103
Problem 103
Solution 104
How It Works 104
Scanning Components Automatically 106
Filtering Components to Scan 108
Naming Detected Components 108
3-14. Summary 109
CHAPTER 4 Advanced Spring IoC Container 110
4-1. Creating Beans by Invoking a Constructor 110
Problem 110
Solution 110
How It Works 110
4-2. Creating Beans by Invoking a Static Factory Method 114
Problem 114
Solution 114
How It Works 114
4-3. Creating Beans by Invoking an Instance Factory Method 115
Problem 115
Solution 115
How It Works 115
4-4. Creating Beans Using Spring’s Factory Bean 117
Problem 117
Solution 117
How It Works 117
4-5.Declaring Beans from Static Fields 119
Problem 119
Solution 119
How It Works 119
4-6.Declaring Beans from Object Properties 121
Problem 121
Solution 121
How It Works 121
4-7. Setting Bean Scopes 123
Problem 123
Solution 123
How It Works 123
4-8. Customizing Bean Initialization and Destruction 125
Problem 125
Solution 126
How It Works 126
Implementing the InitializingBean and DisposableBean Interfaces 128
Annotating the @PostConstruct and @PreDestroy Annotations 129
4-9.Making Beans Aware of the Container 131
Problem 131
Solution 131
How It Works 132
4-10. Creating Bean Post Processors 132
Problem 132
Solution 132
How It Works 133
4-11. Externalizing Bean Configurations 137
Problem 137
Solution 137
How It Works 137
4-12. Resolving Text Messages 138
Problem 138
Solution 138
How It Works 138
4-13. Communicating with Application Events 140
Problem 140
Solution 141
How It Works 141
Defining Events 141
Publishing Events 142
Listening to Events 142
4-14. Registering Property Editors in Spring 143
Problem 143
Solution 143
How It Works 143
4-15. Creating Custom Property Editors 146
Problem 146
Solution 146
How It Works 146
4-16. Loading External Resources 148
Problem 148
Solution 148
How It Works 149
Resource Prefixes 150
Injecting Resources 150
4-17. Summary 151
CHAPTER 5 Dynamic Proxy and Classic Spring AOP 152
5-1. Problems with Non-Modularized Crosscutting Concerns 153
Tracing the Methods 154
Validating the Arguments 157
Identifying the Problems 159
5-2.Modularizing Crosscutting Concerns with Dynamic Proxy 161
Problem 161
Solution 161
How It Works 162
Creating the Logging Proxy 162
Creating the Validation Proxy 165
5-3.Modularizing Crosscutting Concerns with Classic Spring Advices 167
Problem 167
Solution 168
How It Works 168
Before Advices 169
After Returning Advices 172
After Throwing Advices 173
Around Advices 175
5-4.Matching Methods with Classic Spring Pointcuts 177
Problem 177
Solution 177
How It Works 177
Method Name Pointcuts 177
Regular Expression Pointcuts 179
AspectJ Expression Pointcuts 179
5-5. Creating Proxies for Your Beans Automatically 180
Problem 180
Solution 180
How It Works 180
5-6. Summary 182
CHAPTER 6 Spring 2.x AOP and AspectJ Support 183
6-1. Enabling AspectJ Annotation Support in Spring 184
Problem 184
Solution 184
How It Works 184
6-2.Declaring Aspects with AspectJ Annotations 186
Problem 186
Solution 186
How It Works 187
Before Advices 187
After Advices 188
After Returning Advices 189
After Throwing Advices 190
Around Advices 191
6-3. Accessing the Join Point Information 192
Problem 192
Solution 192
How It Works 193
6-4. Specifying Aspect Precedence 194
Problem 194
Solution 194
How It Works 194
6-5. Reusing Pointcut Definitions 196
Problem 196
Solution 196
How It Works 196
6-6.Writing AspectJ Pointcut Expressions 198
Problem 198
Solution 198
How It Works 198
Method Signature Patterns 198
Type Signature Patterns 200
Bean Name Patterns 201
Combining Pointcut Expressions 201
Declaring Pointcut Parameters 202
6-7. Introducing Behaviors to Your Beans 203
Problem 203
Solution 203
How It Works 203
6-8. Introducing States to Your Beans 206
Problem 206
Solution 206
How It Works 206
6-9.Declaring Aspects with XML-Based Configurations 208
Problem 208
Solution 208
How It Works 209
Declaring Aspects 209
Declaring Pointcuts 210
Declaring Advices 210
Declaring Introductions 211
6-10. Load-Time Weaving AspectJ Aspects in Spring 212
Problem 212
Solution 212
How It Works 212
Load-Time Weaving by the AspectJ Weaver 215
Load-Time Weaving by Spring 2.5 Load-Time Weaver 216
6-11. Configuring AspectJ Aspects in Spring 217
Problem 217
Solution 217
How It Works 217
6-12. Injecting Spring Beans into Domain Objects 218
Problem 218
Solution 218
How It Works 219
6-13. Summary 222
PART 2 Fundamentals 223
CHAPTER 7 Spring JDBC Support 224
7-1. Problems with Direct JDBC 224
Setting Up the Application Database 225
Understanding the Data Access Object Design Pattern 226
Implementing the DAO with JDBC 227
Configuring a Data Source in Spring 229
Running the DAO 231
7-2.Using a JDBC Template to Update a Database 231
Problem 231
Solution 232
How It Works 232
Updating a Database with a Statement Creator 232
Updating a Database with a Statement Setter 234
Updating a Database with a SQL Statement and Parameter Values 234
Batch Updating a Database 235
7-3.Using a JDBC Template to Query a Database 236
Problem 236
Solution 237
How It Works 237
Extracting Data with a Row Callback Handler 237
Extracting Data with a Row Mapper 238
Querying for Multiple Rows 239
Querying for a Single Value 241
7-4. Simplifying JDBC Template Creation 242
Problem 242
Solution 242
How It Works 243
Injecting a JDBC Template 243
Extending the JdbcDaoSupport Class 244
7-5.Using the Simple JDBC Template with Java 1.5 245
Problem 245
Solution 245
How It Works 245
Using a Simple JDBC Template to Update a Database 245
Using a Simple JDBC Template to Query a Database 246
7-6.Using Named Parameters in a JDBC Template 248
Problem 248
Solution 249
How It Works 249
7-7.Modeling JDBC Operations As Fine-Grained Objects 251
Problem 251
Solution 251
How It Works 251
Update Operation Objects 251
Query Operation Objects 253
Function Operation Objects 254
7-8.Handling Exceptions in the Spring JDBC Framework 255
Problem 255
Solution 255
How It Works 256
Understanding Exception Handling in the Spring JDBC Framework 256
Customizing Data Access Exception Handling 259
7-9. Summary 260
CHAPTER 8 Transaction Management in Spring 262
8-1. Problems with TransactionManagement 263
Managing Transactions with JDBC Commit and Rollback 267
8-2. Choosing a TransactionManager Implementation 268
Problem 268
Solution 269
How It Works 269
8-3.Managing Transactions Programmatically with the Transaction Manager API 270
Problem 270
Solution 270
How It Works 270
8-4.Managing Transactions Programmatically with a Transaction Template 272
Problem 272
Solution 272
How It Works 272
8-5.Managing Transactions Declaratively with Classic Spring AOP 275
Problem 275
Solution 275
How It Works 276
8-6.Managing Transactions Declaratively with Transaction Advices 278
Problem 278
Solution 278
How It Works 278
8-7.Managing Transactions Declaratively with the @Transactional Annotation 280
Problem 280
Solution 280
How It Works 280
8-8. Setting the Propagation Transaction Attribute 281
Problem 281
Solution 281
How It Works 282
The REQUIRED Propagation Behavior 283
The REQUIRES_NEWPropagation Behavior 285
Setting the Propagation Attribute in Transaction Advices, Proxies, and APIs 285
8-9. Setting the Isolation Transaction Attribute 286
Problem 286
Solution 286
How It Works 287
The READ_UNCOMMITTED and READ_COMMITTED Isolation Levels 289
The REPEATABLE_READ Isolation Level 291
The SERIALIZABLE Isolation Level 293
Setting the Isolation Level Attribute in Transaction Advices, Proxies, and APIs 293
8-10. Setting the Rollback Transaction Attribute 294
Problem 294
Solution 294
How It Works 294
8-11. Setting the Timeout and Read-Only Transaction Attributes 295
Problem 295
Solution 296
How It Works 296
8-12.Managing Transactions with Load-TimeWeaving 297
Problem 297
Solution 297
How It Works 297
8-13. Summary 300
CHAPTER 9 Spring ORM Support 302
9-1. Problems with Using ORM Frameworks Directly 303
Persisting Objects Using the Hibernate API with Hibernate XML Mappings 304
Persisting Objects Using the Hibernate API with JPA Annotations 308
Persisting Objects Using JPA with Hibernate As the Engine 310
9-2. Configuring ORM Resource Factories in Spring 314
Problem 314
Solution 314
How It Works 314
Configuring a Hibernate Session Factory in Spring 314
Configuring a JPA EntityManager Factory in Spring 318
9-3. Persisting Objects with Spring’s ORMTemplates 321
Problem 321
Solution 321
How It Works 321
Using a Hibernate Template and a JPA Template 321
Extending the Hibernate and JPA DAO Support Classes 325
9-4. Persisting Objects with Hibernate’s Contextual Sessions 327
Problem 327
Solution 327
How It Works 327
9-5. Persisting Objects with JPA’s Context Injection 330
Problem 330
Solution 331
How It Works 331
9-6. Summary 334
CHAPTER 10 Spring MVC Framework 335
10-1.Developing a Simple Web Application with Spring MVC 335
Problem 335
Solution 336
How It Works 337
Setting Up a Spring MVC Application 339
Creating the Configuration Files 340
Creating Spring MVC Controllers 341
Creating JSP Views 345
Deploying the Web Application 346
10-2.Mapping Requests to Handlers 347
Problem 347
Solution 347
How It Works 347
Mapping Requests by Bean Names 347
Mapping Requests by Controller Class Names 348
Mapping Requests with Custom Mapping Definitions 349
Mapping Requests by Multiple Strategies 349
10-3. Intercepting Requests with Handler Interceptors 350
Problem 350
Solution 350
How It Works 351
10-4. Resolving User Locales 353
Problem 353
Solution 353
How It Works 354
Resolving Locales by an HTTP Request Header 354
Resolving Locales by a Session Attribute 354
Resolving Locales by a Cookie 354
Changing a User’s Locale 355
10-5. Externalizing Locale-Sensitive Text Messages 356
Problem 356
Solution 356
How It Works 356
10-6. Resolving Views by Names 357
Problem 357
Solution 357
How It Works 358
Resolving Views Based on URLs 358
Resolving Views from an XML Configuration File 358
Resolving Views from a Resource Bundle 359
Resolving Views with Multiple Resolvers 360
The Redirect Prefix 360
10-7.Mapping Exceptions to Views 360
Problem 360
Solution 361
How It Works 361
10-8. Constructing ModelAndView Objects 362
Problem 362
Solution 362
How It Works 363
10-9. Creating a Controller with a Parameterized View 365
Problem 365
Solution 365
How It Works 365
10-10.Handling Forms with Form Controllers 367
Problem 367
Solution 367
How It Works 367
Creating a Form Controller 368
Applying the Post/Redirect/Get Design Pattern 372
Initializing the Command Object 373
Providing Form Reference Data 375
Binding Properties of Custom Types 377
Validating Form Data 378
10-11.Handling Multipage Forms with Wizard Form Controllers 380
Problem 380
Solution 380
How It Works 381
Creating Wizard Form Pages 382
Creating a Wizard Form Controller 385
Validating Wizard FormData 387
10-12.Grouping Multiple Actions into a Controller 389
Problem 389
Solution 389
How It Works 389
Creating a Multi-Action Controller 391
Mapping URLs to Handler Methods 393
10-13. Creating Excel and PDF Views 395
Problem 395
Solution 395
How It Works 395
Creating Excel Views 397
Creating PDF Views 398
10-14.Developing Controllers with Annotations 399
Problem 399
Solution 399
How It Works 400
Developing Single-Action and Multi-Action Controllers 401
Developing a Form Controller 403
Comparison with the Traditional Controller Approach 406
10-15. Summary 407
CHAPTER 11 Integrating Spring with Other Web Frameworks 408
11-1. Accessing Spring in Generic Web Applications 408
Problem 408
Solution 409
How It Works 409
11-2. Integrating Spring with Struts 1.x 413
Problem 413
Solution 413
How It Works 414
Loading Spring’s Application Context into a Struts Application 415
Accessing Spring’s Application Context in Struts Actions 416
Declaring Struts Actions in Spring’s Bean Configuration File 418
11-3. Integrating Spring with JSF 420
Problem 420
Solution 420
How It Works 420
Resolving Spring Beans in JSF 423
Declaring JSF Managed Beans in Spring’s Bean Configuration File 424
11-4. Integrating Spring with DWR 425
Problem 425
Solution 425
How It Works 425
Exposing Spring Beans for Remote Invocation 427
Configuring DWR in Spring’s Bean Configuration File 428
11-5. Summary 429
CHAPTER 12 Spring Testing Support 430
12-1. Creating Tests with JUnit and TestNG 431
Problem 431
Solution 431
How It Works 431
Testing with JUnit 3.8 432
Testing with JUnit 4 433
Testing with TestNG 434
12-2. Creating Unit Tests and Integration Tests 436
Problem 436
Solution 436
How It Works 437
Creating Unit Tests for Isolated Classes 437
Creating Unit Tests for Dependent Classes Using Stubs and Mock Objects 441
Creating Integration Tests 445
12-3.Unit Testing Spring MVC Controllers 446
Problem 446
Solution 446
How It Works 446
Unit Testing Classic Spring MVC Controllers 446
Unit Testing Annotation-Based Spring MVC Controllers 449
12-4.Managing Application Contexts in Integration Tests 451
Problem 451
Solution 451
How It Works 452
Accessing the Context with JUnit 3.8 Legacy Support 452
Accessing the Context with the TestContext Framework in JUnit 4.4 453
Accessing the Context with the TestContext Framework in JUnit 3.8 455
Accessing the Context with the TestContext Framework in TestNG 456
12-5. Injecting Test Fixtures into Integration Tests 457
Problem 457
Solution 458
How It Works 458
Injecting Test Fixtures with JUnit 3.8 Legacy Support 458
Injecting Test Fixtures with the TestContext Framework in JUnit 4.4 459
Injecting Test Fixtures with the TestContext Framework in JUnit 3.8 460
Injecting Test Fixtures with the TestContext Framework in TestNG 461
12-6.Managing Transactions in Integration Tests 462
Problem 462
Solution 462
How It Works 463
Managing Transactions with JUnit 3.8 Legacy Support 464
Managing Transactions with the TestContext Framework in JUnit 4.4 465
Managing Transactions with the TestContext Framework in JUnit 3.8 467
Managing Transactions with the TestContext Framework in TestNG 467
12-7. Accessing a Database in Integration Tests 468
Problem 468
Solution 468
How It Works 468
Accessing a Database with JUnit 3.8 Legacy Support 468
Accessing a Database with the TestContext Framework 469
12-8.Using Spring’s Common Testing Annotations 472
Problem 472
Solution 472
How It Works 473
Using Common Testing Annotations with JUnit 3.8 Legacy Support 473
Using Common Testing Annotations with the TestContext Framework 473
12-9. Summary 474
PART 3 Advanced 476
CHAPTER 13 Spring Security 477
13-1. Securing URL Access 477
Problem 477
Solution 478
How It Works 478
Setting Up a Spring MVC Application That Uses Spring Security 480
Creating the Configuration Files 480
Creating the Controllers and Page Views 482
Securing URL Access 486
13-2. Logging In to Web Applications 488
Problem 488
Solution 488
How It Works 488
HTTP Basic Authentication 489
Form-Based Login 489
The Logout Service 491
Anonymous Login 492
Remember-Me Support 492
13-3. Authenticating Users 492
Problem 492
Solution 492
How It Works 493
Authenticating Users with In-Memory Definitions 493
Authenticating Users Against a Database 494
Encrypting Passwords 496
Authenticating Users Against an LDAP Repository 497
Caching User Details 501
13-4.Making Access Control Decisions 502
Problem 502
Solution 503
How It Works 503
13-5. Securing Method Invocations 506
Problem 506
Solution 506
How It Works 506
Securing Methods by Embedding a Security Interceptor 506
Securing Methods with Pointcuts 507
Securing Methods with Annotations 508
13-6.Handling Security in Views 509
Problem 509
Solution 509
How It Works 509
Displaying Authentication Information 509
Rendering View Contents Conditionally 510
13-7.Handling Domain Object Security 511
Problem 511
Solution 511
How It Works 512
Setting Up an ACL Service 512
Maintaining ACLs for Domain Objects 515
Making Access Control Decisions Based on ACLs 517
Handling Domain Objects Returned from Methods 520
13-8. Summary 521
CHAPTER 14 Spring Portlet MVC Framework 523
14-1.Developing a Simple Portlet with Spring Portlet MVC 523
Problem 523
Solution 523
How It Works 525
Setting Up a Portlet Application 525
Creating the Configuration Files 526
Creating Portlet Controllers 528
Mapping Portlet Requests to Handlers 529
Resolving View Names into Views 529
Creating Portlet Views 530
Deploying the Portlet Application 530
14-2.Mapping Portlet Requests to Handlers 531
Problem 531
Solution 532
How It Works 532
Mapping Requests by the Portlet Mode 534
Mapping Requests by a Parameter 538
Mapping Requests by Both the Portlet Mode and Parameter 540
14-3.Handling Portlet Forms with Simple Form Controllers 541
Problem 541
Solution 541
How It Works 541
Creating Form Controllers 543
Validating Form Data 547
14-4.Developing Portlet Controllers with Annotations 549
Problem 549
Solution 549
How It Works 549
Developing Multi-Action Controllers 549
Developing Form Controllers 552
14-5. Summary 555
CHAPTER 15 Spring Web Flow 556
15-1.Managing a Simple UI Flow with Spring Web Flow 556
Problem 556
Solution 556
How It Works 557
Setting Up a Spring MVC Application That Uses Spring Web Flow 558
Creating the Configuration Files 559
Creating Web Flow Definitions 561
15-2.Modeling Web Flows with Different State Types 563
Problem 563
Solution 564
How It Works 564
Defining View States 567
Defining Action States 571
Defining Decision States 572
Defining End States 573
Defining Subflow States 575
15-3. Securing Web Flows 576
Problem 576
Solution 576
How It Works 577
15-4. Persisting Objects in Web Flows 579
Problem 579
Solution 579
How It Works 579
Configuring JPA in Spring’s Application Context 580
Setting Up JPA for Spring Web Flow 581
Using JPA in Web Flows 582
15-5. Integrating Spring Web Flow with JSF 585
Problem 585
Solution 586
How It Works 586
Rendering JSF Views for Spring Web Flow 586
Using the JSF Components of Spring Faces 589
15-6. Summary 591
CHAPTER 16 Spring Remoting and Web Services 593
16-1. Exposing and Invoking Services Through RMI 594
Problem 594
Solution 594
How It Works 595
Exposing an RMI Service 596
Invoking an RMI Service 597
16-2. Exposing and Invoking Services Through HTTP 598
Problem 598
Solution 598
How It Works 599
Exposing a Hessian Service 599
Invoking a Hessian Service 601
Exposing a Burlap Service 601
Invoking a Burlap Service 601
Exposing an HTTP Invoker Service 602
Invoking an HTTP Invoker Service 602
16-3. Choosing aWeb Service Development Approach 602
Problem 602
Solution 602
How It Works 603
Contract-LastWeb Services 603
Contract-FirstWeb Services 603
Comparison 604
16-4. Exposing and InvokingWeb Services Using XFire 605
Problem 605
Solution 605
How It Works 605
Exposing aWeb Service Using XFire 605
Inspecting the GeneratedWSDL File 607
Invoking aWeb Service Using XFire 609
Exposing an Annotation-BasedWeb Service Using XFire 610
16-5.Defining the Contract ofWeb Services 611
Problem 611
Solution 611
How It Works 611
Creating Sample XMLMessages 611
Generating an XSD File from Sample XMLMessages 612
Optimizing the Generated XSD File 614
Previewing the GeneratedWSDL File 614
16-6. ImplementingWeb Services Using Spring-WS 615
Problem 615
Solution 615
How It Works 616
Setting Up a Spring-WS Application 616
MappingWeb Service Requests to Endpoints 618
Creating Service Endpoints 618
Publishing theWSDL File 620
16-7. InvokingWeb Services Using Spring-WS 622
Problem 622
Solution 622
How It Works 622
16-8.DevelopingWeb Services with XMLMarshalling 625
Problem 625
Solution 625
How It Works 626
Creating Service Endpoints with XMLMarshalling 626
InvokingWeb Services with XMLMarshalling 629
16-9. Creating Service Endpoints with Annotations 631
Problem 631
Solution 631
How It Works 631
16-10. Summary 632
CHAPTER 17 Spring Support for EJB and JMS 634
17-1. Creating EJB 2.x Components with Spring 634
Problem 634
Solution 635
How It Works 635
Creating EJB 2.x Components with Spring’s Support 638
17-2. Accessing EJB 2.x Components in Spring 640
Problem 640
Solution 641
How It Works 641
Accessing EJB 2.x Components Without Spring’s Support 642
Accessing EJB 2.x Components with Spring’s Support 644
17-3. Accessing EJB 3.0 Components in Spring 646
Problem 646
Solution 646
How It Works 646
Accessing EJB 3.0 Components Without Spring’s Support 647
Accessing EJB 3.0 Components with Spring’s Support 647
17-4. Sending and Receiving JMSMessages with Spring 649
Problem 649
Solution 649
How It Works 650
Sending and ReceivingMessages with Spring’s JMS Template 655
Sending and ReceivingMessages to and from a Default Destination 658
Extending the JmsGatewaySupport Class 660
Converting JMSMessages 661
Managing JMS Transactions 663
17-5. CreatingMessage-Driven POJOs in Spring 664
Problem 664
Solution 665
How It Works 665
Listening for JMSMessages withMessage Listeners 665
Listening for JMSMessages with POJOs 667
Converting JMSMessages 668
Managing JMS Transactions 669
Using Spring’s JMS Schema 669
17-6. Summary 670
CHAPTER 18 Spring Support for JMX, E-mail, and Scheduling 672
18-1. Exporting Spring Beans As JMX MBeans 672
Problem 672
Solution 673
How It Works 673
Registering MBeansWithout Spring’s Support 675
Exporting Spring Beans As MBeans 678
Exposing MBeans for Remote Access 679
Assembling theManagement Interface of MBeans 680
Auto-Detecting MBeans by Annotations 682
18-2. Publishing and Listening to JMX Notifications 684
Problem 684
Solution 684
How It Works 684
Publishing JMX Notifications 684
Listening to JMX Notifications 685
18-3. Accessing Remote JMX MBeans in Spring 686
Problem 686
Solution 686
How It Works 686
Accessing Remote MBeans Through an MBean Server Connection 686
Accessing Remote MBeans Through an MBean Proxy 688
18-4. Sending E-mail with Spring’s E-mail Support 689
Problem 689
Solution 689
How It Works 689
Sending E-mail Using the JavaMail API 691
Sending E-mail with Spring’sMailSender 692
Defining an E-mail Template 694
Sending MIMEMessages 695
18-5. Scheduling with Spring’s JDK Timer Support 697
Problem 697
Solution 697
How It Works 698
Creating a Timer Task 698
Using JDK Timer Without Spring’s Support 698
Using JDK Timer with Spring’s Support 699
18-6. Scheduling with Spring’s Quartz Support 700
Problem 700
Solution 700
How It Works 700
Using Quartz Without Spring’s Support 700
Using Quartz with Spring’s Support 702
18-7. Summary 705
CHAPTER 19 Scripting in Spring 706
19-1. Implementing Beans with Scripting Languages 706
Problem 706
Solution 706
How It Works 707
Scripting Beans with JRuby 707
Scripting Beans with Groovy 709
Scripting Beans with BeanShell 710
19-2. Injecting Spring Beans into Scripts 711
Problem 711
Solution 711
How It Works 711
Injecting Spring Beans into JRuby 712
Injecting Spring Beans into Groovy 713
Injecting Spring Beans into BeanShell 713
19-3. Refreshing Beans from Scripts 714
Problem 714
Solution 714
How It Works 714
19-4.Defining Script Sources Inline 715
Problem 715
Solution 715
How It Works 715
19-5. Summary 716
Index 718

Produkt-Details

• Erscheint lt. Verlag: 29.8.2008
• Zusatzinfo: XXIV, 700 p.
• Verlagsort: Berkeley
• Sprache: englisch
• Themenwelt: Informatik ► Programmiersprachen / -werkzeuge ► Java
• Themenwelt: Mathematik / Informatik ► Informatik ► Software Entwicklung
• Themenwelt: Mathematik / Informatik ► Informatik ► Web / Internet
• Schlagworte: aspect-oriented programming (AOP) • Design • Development • Framework • Java • Java EE • language • Open Source • programming • Ruby On Rails • Testing • web applications • Web Services • XML
• ISBN-10: 1-4302-0623-3 / 1430206233
• ISBN-13: 978-1-4302-0623-1 / 9781430206231