book

Spring Enterprise Recipes: A Problem-Solution Approach

Name: Spring Enterprise Recipes: A Problem-Solution Approach
ISBN: 9781430224976

by Gary Mak, Josh Long

November 2009

Intermediate to advanced

492 pages

12h 45m

English

Apress

Read now

Unlock full access

Copyright
About the Authors
About the Technical Reviewer
Acknowledgments
Introduction
Who This Book Is ForHow This Book Is StructuredConventionsPrerequisitesDownloading the CodeContacting the Authors
1. Introduction to Spring
1.1. Instantiating the Spring IoC Container1.1.1. Problem1.1.2. Solution1.1.3. How It Works1.1.3.1. Instantiating an Application Context1.1.3.2. Getting Beans from the IoC Container1.2. Configuring Beans in the Spring IoC Container1.2.1. Problem1.2.2. Solution1.2.3. How It Works1.2.3.1. Creating the Bean Class1.2.3.2. Creating the Bean Configuration File1.2.3.3. Declaring Beans in the Bean Configuration File1.2.3.4. Defining Bean Properties by Shortcut1.2.3.5. Configuring Collections for Your Beans1.2.3.6. Lists, Arrays, and Sets1.2.3.7. Maps and Properties1.3. Auto-Wiring Beans with XML Configuration1.3.1. Problem1.3.2. Solution1.3.3. How It Works1.3.3.1. Auto-Wiring by Type1.3.3.2. Auto-Wiring by Name1.3.3.3. Auto-Wiring by Constructor1.3.3.4. Auto-Wiring by Auto-Detection1.3.3.5. Auto-Wiring and Dependency Checking1.4. Auto-Wiring Beans with @Autowired and @Resource1.4.1. Problem1.4.2. Solution1.4.3. How It Works1.4.3.1. Auto-Wiring a Single Bean of Compatible Type1.4.3.2. Auto-Wiring All Beans of Compatible Type1.4.3.3. Auto-Wiring by Type with Qualifiers1.4.3.4. Auto-Wiring by Name1.5. Scanning Components from the Classpath1.5.1. Problem1.5.2. Solution1.5.3. How It Works1.5.3.1. Scanning Components Automatically1.5.3.2. Filtering Components to Scan1.5.3.3. Naming Detected Components1.6. Setting Bean Scopes1.6.1. Problem1.6.2. Solution1.6.3. How It Works1.7. Customizing Bean Initialization and Destruction1.7.1. Problem1.7.2. Solution1.7.3. How It Works1.7.3.1. Implementing the InitializingBean and DisposableBean Interfaces1.7.3.2. Setting the init-method and destroy-method Attributes1.7.3.3. Annotating the @PostConstruct and @PreDestroy Annotations1.8. Resolving Text Messages1.8.1. Problem1.8.2. Solution1.8.3. How It Works1.9. Loading External Resources1.9.1. Problem1.9.2. Solution1.9.3. How It Works1.9.3.1. Resource Prefixes1.9.3.2. Injecting Resources1.10. Enabling AspectJ Annotation Support in Spring1.10.1. Problem1.10.2. Solution1.10.3. How It Works1.11. Declaring Aspects with AspectJ Annotations1.11.1. Problem1.11.2. Solution1.11.3. How It Works1.11.3.1. Before Advices1.11.3.2. After Advices1.11.3.3. After Returning Advices1.11.3.4. After Throwing Advices1.11.3.5. Around Advices1.12. Reusing Pointcut Definitions1.12.1. Problem1.12.2. Solution1.12.3. How It Works1.13. Writing AspectJ Pointcut Expressions1.13.1. Problem1.13.2. Solution1.13.3. How It Works1.13.3.1. Method Signature Patterns1.13.3.2. Type Signature Patterns1.13.3.3. Bean Name Patterns1.13.3.4. Combining Pointcut Expressions1.13.3.5. Declaring Pointcut Parameters1.14. Introducing Behaviors to Your Beans1.14.1. Problem1.14.2. Solution1.14.3. How It Works1.15. Introducing States to Your Beans1.15.1. Problem1.15.2. Solution1.15.3. How It Works1.16. Summary
2. What's New in Spring 3.0?
2.0. Upgrades to the SpringSource Portfolio2.1. Getting Started with the Latest and Greatest Spring Framework2.1.1. Problem2.1.2. Solution2.1.3. How It Works2.2. Using Java 5 Syntax in Spring2.2.1. Problem2.2.2. Solution2.2.3. How It Works2.2.3.1. BeanFactory and FactoryBean2.2.3.2. ApplicationContext Events2.3. Achieving Concurrency with TaskExecutors2.3.1. Problem2.3.2. Solution2.3.3. How It Works2.3.3.1. Java SE2.3.3.2. Java EE2.3.3.3. Spring's Solution2.4. Using the Spring Expression Language2.4.1. Problem2.4.2. Solution2.4.3. How It Works2.4.3.1. Features of the Language Syntax2.4.3.2. Uses of the Language in Your Configurations2.4.3.3. Using the Spring Expression Language Parser2.5. My Code Doesn't Compile!2.5.1. Problem2.5.2. Solution2.5.3. How It Works2.6. Reducing XML Configuration with Java Config2.6.1. Problem2.6.2. Solution2.6.3. How It Works2.7. Summary
3. Data Access
3.0. Problems with Direct JDBC3.0.1. Setting Up the Application Database3.0.2. Understanding the Data Access Object Design Pattern3.0.3. Implementing the DAO with JDBC3.0.4. Configuring a Data Source in Spring3.0.5. Running the DAO3.1. Using a JDBC Template to Update a Database3.1.1. Problem3.1.2. Solution3.1.3. How It Works3.1.3.1. Updating a Database with a Statement Creator3.1.3.2. Updating a Database with a Statement Setter3.1.3.3. Updating a Database with a SQL Statement and Parameter Values3.1.3.4. Batch Updating a Database3.2. Using a JDBC Template to Query a Database3.2.1. Problem3.2.2. Solution3.2.3. How It Works3.2.3.1. Extracting Data with a Row Callback Handler3.2.3.2. Extracting Data with a Row Mapper3.2.3.3. Querying for Multiple Rows3.2.3.4. Querying for a Single Value3.3. Simplifying JDBC Template Creation3.3.1. Problem3.3.2. Solution3.3.3. How It Works3.3.3.1. Injecting a JDBC Template3.3.3.2. Extending the JdbcDaoSupport Class3.4. Using the Simple JDBC Template with Java 1.53.4.1. Problem3.4.2. Solution3.4.3. How It Works3.4.3.1. Using a Simple JDBC Template to Update a Database3.4.3.2. Using a Simple JDBC Template to Query a Database3.5. Using Named Parameters in a JDBC Template3.5.1. Problem3.5.2. Solution3.5.3. How It Works3.6. Handling Exceptions in the Spring JDBC Framework3.6.1. Problem3.6.2. Solution3.6.3. How It Works3.6.3.1. Understanding Exception Handling in the Spring JDBC Framework3.6.3.2. Customizing Data Access Exception Handling3.7. Problems with Using ORM Frameworks Directly3.7.1. Persisting Objects Using the Hibernate API with Hibernate XML Mappings3.7.2. Persisting Objects Using the Hibernate API with JPA Annotations3.7.3. Persisting Objects Using JPA with Hibernate as the Engine3.8. Configuring ORM Resource Factories in Spring3.8.1. Problem3.8.2. Solution3.8.3. How It Works3.8.3.1. Configuring a Hibernate Session Factory in Spring3.8.3.2. Configuring a JPA Entity Manager Factory in Spring3.9. Persisting Objects with Spring's ORM Templates3.9.1. Problem3.9.2. Solution3.9.3. How It Works3.9.3.1. Using a Hibernate Template and a JPA Template3.9.3.2. Extending the Hibernate and JPA DAO Support Classes3.10. Persisting Objects with Hibernate's Contextual Sessions3.10.1. Problem3.10.2. Solution3.10.3. How It Works3.11. Persisting Objects with JPA's Context Injection3.11.1. Problem3.11.2. Solution3.11.3. How It Works3.12. Summary
4. Transaction Management in Spring
4.1.4.1.1.4.1.1.1. Programmatic and Declarative Transaction Management4.2. Problems with Transaction Management4.2.1. Managing Transactions with JDBC Commit and Rollback4.3. Choosing a Transaction Manager Implementation4.3.1. Problem4.3.2. Solution4.3.3. How It Works4.4. Managing Transactions Programmatically with the Transaction Manager API4.4.1. Problem4.4.2. Solution4.4.3. How It Works4.5. Managing Transactions Programmatically with a Transaction Template4.5.1. Problem4.5.2. Solution4.5.3. How It Works4.6. Managing Transactions Declaratively with Transaction Advices4.6.1. Problem4.6.2. Solution4.6.3. How It Works4.7. Managing Transactions Declaratively with the @Transactional Annotation4.7.1. Problem4.7.2. Solution4.7.3. How It Works4.8. Setting the Propagation Transaction Attribute4.8.1. Problem4.8.2. Solution4.8.3. How It Works4.8.4. The REQUIRED Propagation Behavior4.8.5. The REQUIRES_NEW Propagation Behavior4.8.6. Setting the Propagation Attribute in Transaction Advices, Proxies, and APIs4.9. Setting the Isolation Transaction Attribute4.9.1. Problem4.9.2. Solution4.9.3. How It Works4.9.4. The READ_UNCOMMITTED and READ_COMMITTED Isolation Levels4.9.5. The REPEATABLE_READ Isolation Level4.9.6. The SERIALIZABLE Isolation Level4.9.7. Setting the Isolation Level Attribute in Transaction Advices, Proxies, and APIs4.10. Setting the Rollback Transaction Attribute4.10.1. Problem4.10.2. Solution4.10.3. How It Works4.11. Setting the Timeout and Read-Only Transaction Attributes4.11.1. Problem4.11.2. Solution4.11.3. How It Works4.12. Managing Transactions with Load-Time Weaving4.12.1. Problem4.12.2. Solution4.12.3. How It Works4.13. Summary
5. EJB, Spring Remoting, and Web Services
5.1. Exposing and Invoking Services Through RMI5.1.1. Problem5.1.2. Solution5.1.3. How It Works5.1.3.1. Exposing an RMI Service5.1.3.2. Invoking an RMI Service5.2. Creating EJB 2.x Components with Spring5.2.1. Problem5.2.2. Solution5.2.3. How It Works5.2.3.1. Creating EJB 2.x Components Without Spring's Support5.2.3.2. Creating EJB 2.x Components with Spring's Support5.3. Accessing EJB 2.x Components in Spring5.3.1. Problem5.3.2. Solution5.3.3. How It Works5.3.3.1. Accessing EJB 2.x Components5.4. Creating EJB 3.0 Components in Spring5.4.1. Problem5.4.2. Solution5.4.3. How It Works5.5. Accessing EJB 3.0 Components in Spring5.5.1. Problem5.5.2. Solution5.5.3. How It Works5.5.3.1. Accessing EJB 3.0 Components with Spring's Support5.6. Exposing and Invoking Services Through HTTP5.6.1. Problem5.6.2. Solution5.6.3. How It Works5.6.3.1. Exposing a Hessian Service5.6.3.2. Invoking a Hessian Service5.6.3.3. Exposing a Burlap Service5.6.3.4. Invoking a Burlap Service5.6.3.5. Exposing an HTTP Invoker Service5.6.3.6. Invoking an HTTP Invoker Service5.7. Choosing a Web Service Development Approach5.7.1. Problem5.7.2. Solution5.7.3. How It Works5.7.3.1. Contract-Last Web Services5.7.3.2. Contract-First Web Services5.7.3.3. Comparison5.8. Exposing and Invoking Web Services Using XFire5.8.1. Problem5.8.2. Solution5.8.3. How It Works5.8.3.1. Exposing a Web Service Using XFire5.8.3.2. Inspecting the Generated WSDL File5.8.3.3. Invoking a Web Service Using XFire5.8.3.4. Exposing an Annotation-Based Web Service Using XFire5.9. Defining the Contract of Web Services5.9.1. Problem5.9.2. Solution5.9.3. How It Works5.9.3.1. Creating Sample XML Messages5.9.3.2. Generating an XSD File from Sample XML Messages5.9.3.3. Optimizing the Generated XSD File5.9.3.4. Previewing the Generated WSDL File5.10. Implementing Web Services Using Spring-WS5.10.1. Problem5.10.2. Solution5.10.3. How It Works5.10.3.1. Setting Up a Spring-WS Application5.10.3.2. Mapping Web Service Requests to Endpoints5.10.3.3. Creating Service Endpoints5.10.3.4. Publishing the WSDL File5.11. Invoking Web Services Using Spring-WS5.11.1. Problem5.11.2. Solution5.11.3. How It Works5.12. Developing Web Services with XML Marshalling5.12.1. Problem5.12.2. Solution5.12.3. How It Works5.12.3.1. Creating Service Endpoints with XML Marshalling5.12.3.2. Invoking Web Services with XML Marshalling5.13. Creating Service Endpoints with Annotations5.13.1. Problem5.13.2. Solution5.13.3. How It Works5.14. Summary

6. Spring in the Enterprise
6.1. Exporting Spring Beans as JMX MBeans6.1.1. Problem6.1.2. Solution6.1.3. How It Works6.1.3.1. Registering MBeans Without Spring's Support6.1.3.2. Exporting Spring Beans as MBeans6.1.3.3. Exposing MBeans for Remote Access6.1.3.4. Assembling the Management Interface of MBeans6.1.3.5. Auto-Detecting MBeans by Annotations6.2. Publishing and Listening to JMX Notifications6.2.1. Problem6.2.2. Solution6.2.3. How It Works6.2.3.1. Publishing JMX Notifications6.2.3.2. Listening to JMX Notifications6.3. Accessing Remote JMX MBeans in Spring6.3.1. Problem6.3.2. Solution6.3.3. How It Works6.3.3.1. Accessing Remote MBeans Through an MBean Server Connection6.3.3.2. Accessing Remote MBeans Through an MBean Proxy6.4. Sending E-mail with Spring's E-mail Support6.4.1. Problem6.4.2. Solution6.4.3. How It Works6.4.3.1. Sending E-mail Using the JavaMail API6.4.3.2. Sending E-mail with Spring's MailSender6.4.3.3. Defining an E-mail Template6.4.3.4. Sending MIME Messages6.5. Scheduling with Spring's JDK Timer Support6.5.1. Problem6.5.2. Solution6.5.3. How It Works6.5.3.1. Creating a Timer Task6.5.3.2. Using JDK Timer Without Spring's Support6.5.3.3. Using JDK Timer with Spring's Support6.6. Scheduling with Spring's Quartz Support6.6.1. Problem6.6.2. Solution6.6.3. How It Works6.6.3.1. Using Quartz Without Spring's Support6.6.3.2. Using Quartz with Spring's Support6.7. Summary
7. Messaging
7.1. Sending and Receiving JMS Messages with Spring7.1.1. Problem7.1.2. Solution7.1.3. How It Works7.1.3.1. Sending and Receiving Messages Without Spring's Support7.1.3.2. Sending and Receiving Messages with Spring's JMS Template7.1.3.3. Sending and Receiving Messages to and from a Default Destination7.1.3.4. Extending the JmsGatewaySupport Class7.2. Converting JMS Messages7.2.1. Problem7.2.2. Solution7.2.3. Approach7.3. Managing JMS Transactions7.3.1. Problem7.3.2. Approach7.3.3. Solution7.4. Creating Message-Driven POJOs in Spring7.4.1. Problem7.4.2. Solution7.4.3. How It Works7.4.3.1. Listening for JMS Messages with Message Listeners7.4.3.2. Listening for JMS Messages with POJOs7.4.3.3. Converting JMS Messages7.4.3.4. Managing JMS Transactions7.4.3.5. Using Spring's JMS Schema7.5. Summary
8. Spring Integration
8.1. Getting Started with Spring Integration8.1.1. Problem8.1.2. Solution8.1.3. How It Works8.2. Integrating One System with Another Using EAI8.2.1. Problem8.2.2. Solution8.2.3. How It Works8.2.3.1. Picking an Integration Style8.2.3.2. Building on an ESB Solution8.3. Integrating Two Systems Using JMS8.3.1. Problem8.3.2. Solution8.3.3. How it Works8.3.3.1. Building an MDP Using Spring Integration8.4. Interrogate Spring Integration Messages for Context Information8.4.1. Problem8.4.2. Solution8.4.3. How it Works8.4.3.1. Using MessageHeaders for Fun and Profit8.5. Integrating Two Systems Using a File System8.5.1. Problem8.5.2. Solution8.5.3. How It Works8.5.3.1. Concerns in Dealing with a File System8.6. Transforming a Message from One Type to Another8.6.1. Problem8.6.2. Solution8.6.3. How it Works8.6.3.1. Modifying a Message's Payload8.6.3.2. Modifying a Message's Headers8.7. Error Handling Using Spring Integration8.7.1. Problem8.7.2. Solution8.7.3. How It Works8.7.3.1. Routing to Custom Handlers Based on the Type of Exception8.7.3.2. Building a Solution with Multiple Error channels8.8. Forking Integration Control: Splitters and Aggregators8.8.1. Problem8.8.2. Solution8.8.3. How it Works8.8.3.1. Splitter8.8.3.2. Aggregators8.9. Conditional Routing with Routers8.9.1. Problem8.9.2. Solution8.9.3. How It Works8.10. Adapting External Systems to the Bus8.10.1. Problem8.10.2. Solution8.10.3. How It Works8.10.3.1. An Inbound Twitter Adapter8.10.3.2. Twitter Messages8.10.3.3. A Simple MessageSource8.10.3.4. An Outbound Twitter Example8.11. Staging Events Using Spring Batch8.11.1. Problem8.11.2. Solution8.11.3. How It Works8.12. Gateways8.12.1. Problem8.12.2. Solution8.12.3. How It Works8.12.3.1. SimpleMessagingGateway8.12.3.2. Breaking the Interface Dependency8.13. Summary
9. Spring Batch
9.1.9.1.1.9.1.1.1. Runtime Meta Model9.2. Getting Started with the Spring Batch Distribution9.2.1. Problem9.2.2. Solution9.2.3. How It Works9.3. Setting Up Spring Batch's Infrastructure9.3.1. Problem9.3.2. Solution9.3.3. How It Works9.4. Running Jobs9.4.1. Problem9.4.2. Solution9.4.3. How It Works9.4.3.1. Launching From a Web Application9.4.3.2. Running from the Command Line9.5. Reading and Writing (but No Arithmetic)9.5.1. Problem9.5.2. Solution9.5.3. How It Works9.5.3.1. The Job Configuration9.5.3.2. Input9.5.3.3. Output9.6. Writing a Custom ItemWriter and ItemReader9.6.1. Problem9.6.2. Solution9.6.3. How It Works9.6.3.1. Writing a Custom ItemReader9.6.3.2. Writing a Custom ItemWriter9.7. Processing Input Before Writing9.7.1. Problem9.7.2. Solution9.7.3. How It Works9.7.3.1. Chaining Processors Together9.8. Better Living through Transactions9.8.1. Problem9.8.2. Solution9.8.3. How It Works9.8.3.1. Transactions9.8.3.2. Rollbacks9.9. Retry9.9.1. Problem9.9.2. Solution9.9.3. How It Works9.9.3.1. Configuring a Step9.9.3.2. Retry Template9.9.3.3. AOP-based Retries9.10. Controlling Step Execution9.10.1. Problem9.10.2. Solution9.10.3. How It Works9.10.3.1. Sequential Steps9.10.3.2. Concurrency9.10.3.3. Conditional Steps with Statuses9.10.3.4. Conditional Steps with Decisions9.11. Parameterizing a Job9.11.1. Problem9.11.2. Solution9.11.3. How It Works9.11.3.1. Launching a Job with Parameters9.11.3.2. Accessing JobParameters9.12. Summary
10. Distributed Spring
10.1. Cluster Object State Using Terracotta10.1.1. Problem10.1.2. Solution10.1.3. How It Works10.1.3.1. Deploying a Simple Example with Terracotta10.1.3.2. Terracotta Architecture and Deployment10.1.3.3. How to Build a Terracotta XML Configuration File10.2. Using Spring to Simplify Terracotta Configuration10.2.1. Problem10.2.2. Solution10.2.3. Approach10.3. You Want to Farm Out Execution to a Grid10.3.1. Problem10.3.2. Solution10.3.3. Approach10.3.3.1. Deployment10.4. Load Balancing a Method10.4.1. Problem10.4.2. Solution10.4.3. Approach10.5. Parallelizing Processing10.5.1. Problem10.5.2. Solution10.5.3. Approach10.6. On GridGain Deployment10.6.1. Problem10.6.2. Solution10.6.3. Approach10.6.3.1. Creating a Grid Node10.6.3.2. Provisioning a Grid Node10.6.3.3. Getting Access To The Spring Container From a Task10.6.3.4. Node-Specific GridGain Configuration10.7. Summary
11. jBPM and Spring
11.0. Software Processes11.1. Understanding Workflow Models11.1.1. Problem11.1.2. Solution11.1.3. Approach11.2. Installing jBPM11.2.1. Problem11.2.2. Approach11.2.3. Solution11.3. Integrating jBPM 4 with Spring11.3.1. Problem11.3.2. Solution11.3.3. Approach11.3.3.1. The Application Context11.4. Building a Service With Spring11.4.1. Problem11.4.2. Solution11.4.3. Approach11.5. Building a Business Process11.5.1. Problem11.5.2. Solution11.5.3. Approach11.6. Summary
12. OSGi and Spring
12.1. Getting Started With OSGi12.1.1. Problem12.1.2. Solution12.1.3. Approach12.1.3.1. Osgi and "JavaBeans™"12.1.3.2. The "Service"12.1.3.3. Installing Equinox12.1.3.4. Using the Service in a Client Bundle12.2. How do I get Started Using Spring Dynamic Modules?12.2.1. Problem12.2.2. Solution12.2.3. Approach12.3. How do I Export a Service Using Spring Dynamic Modules?12.3.1. Problem12.3.2. Solution12.3.3. Approach12.3.3.1. Interfacing With the OSGi Runtime12.4. Finding a Specific Service in the OSGi Registry12.4.1. Problem12.4.2. Solution12.4.3. Approach12.4.3.1. Ranking12.4.3.2. Service Attributes12.4.3.3. Cardinality12.5. Publishing a Service Under Multiple Interfaces12.5.1. Problem12.5.2. Solution12.5.3. Approach12.6. Customizing Spring Dynamic Modules12.6.1. Problem12.6.2. Solution12.6.3. Approach12.6.3.1. You Want Spring To Process OSGi Annotations on Beans12.6.3.2. Change the Default HTTP Server that Spring Uses When Deploying a .WAR12.7. Using SpringSource dm Server12.7.1. Problem12.7.2. Solution12.7.3. Approach12.8. SpringSource's Tooling12.8.1. Problem12.8.2. Solution12.8.3. Approach12.9. Summary

Content preview from Spring Enterprise Recipes: A Problem-Solution Approach

Chapter 10. Distributed Spring

In this chapter, you will learn the principles behind various distributed computing concepts, and how to use Spring in conjunction with some very powerful, open-source–ish third-party products to build solutions leveraging those concepts. Grid computing is a very important concept in today's world, for many reasons. It solves many problems, some more ephemeral than others:

Scalability: Distribution provides a mechanism by which to expand capability to scale an application to meet demand. This is simple, on the face of it: the more computers responding to the same request means more people can make requests. This is the quintessential reason behind clustering, and behind load balancing.
Redundancy: Computers fail. It's ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781430224976Purchase book

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Spring Enterprise Recipes: A Problem-Solution Approach

by Gary Mak, Josh Long

Chapter 10. Distributed Spring

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.