© 2026 Machinery For Change LLC
This software is made available for use, modification, and redistribution, under the terms of the Lesser GNU Public License, v.2.1 (LGPL) or the Eclipse Public License, v.1.0 (EPL), at your option. You should have received copies of both licenses with this distribution. You may also opt to license this software under a more recent version of LGPL than v.2.1.
You'll find this version on the Maven Central repository — com.mchange:c3p0:0.13.0
For support of asynchrony via Java 21 "loom" virtual threads, use instead — com.mchange:c3p0-loom:0.13.0
To its author's profound shame, c3p0, along with its supporting libraries, was used for about a decade as a "deserialization gadget". If an attacker is able to replace and maliciously recraft a javax.naming.Reference or Java-serialized object that an application will decode, c3p0's libraries could be misused to expand that access into execution of arbitrary malicious code.
c3p0-0.12.0, along with its dependency mchange-commons-java-0.4.0, includes mitigations that lock down the functionality misused as gadget chains.
Although it remains possible to resurrect and make use of the dangerous functionality, it requires new, affirmative configuration, and very few contemporary applications should do so.
Most installations will not, but if you experience breaking changes in c3p0-0.12.0, you may need to customize security configuration for your deployment. Please see Configuring Security below for information on how, and for more background on the security issues.
c3p0-0.13.0, with mchange-commons-java-0.5.0, eliminates all use of Java serialization in resolving References, definitively ending any possibility of misuse of c3p0-related JNDI utilities to construct deserialization gadgets.
Many thanks to David Pollak of Spice Labs for a very detailed report about this issue.
See also Warning: c3p0 trusts its CLASSPATH and configuration.
c3p0 was designed to be butt-simple to use.
Just bring Maven dependency com.mchange:c3p0:0.13.0 into your application's effective CLASSPATH (which should bring along its one transitive dependency, mchange-commons-java). Then make a DataSource like this:
[Optional] If you want to turn on PreparedStatement pooling, you must also set maxStatements and/or maxStatementsPerConnection (both default to 0):
Do whatever you want with your DataSource, which will be backed by a Connection pool set up with default parameters. You can bind the DataSource to a JNDI name service, or use it directly, as you prefer.
When you are done, you can clean up the DataSource you've created like this:
That's it! The rest is detail.
c3p0 is an easy-to-use library for making traditional JDBC drivers "enterprise-ready" by augmenting them with functionality defined by the jdbc3 spec and the optional extensions to jdbc2. c3p0 now also fully supports the jdbc4.
In particular, c3p0 provides several useful services:
The library tries hard to get the details right:
c3p0 hopes to provide DataSource implementations more than suitable for use by high-volume "J2EE enterprise applications". Please provide feedback, bug-fixes, etc!
c3p0-0.13.0 requires a level 1.7.x or above Java Runtime Environment.
There is no installation beyond accessing managed Maven dependency com.mchange:c3p0:0.13.0.
If you wish to make use of Java 21 ("loom") virtual threading, use com.mchange:c3p0-loom:0.13.0 instead.
If you want to install c3p0 by hand, just place the files c3p0-0.13.0.jar and mchange-commons-java-0.5.0.jar somewhere in your CLASSPATH (or any other place where your application's classloader will find it). For Java 21 "loom" support, also include the jar c3p0-loom-0.13.0.jar.
If you’d like, I can:
Here’s a solid, plausible story about Kodak Preps 10, framed as a turning point for a mid-sized printing company.
Title: The 2 AM Shift
Logline: When a high-stakes booklet job threatens to derail a family-run print shop’s biggest client, a veteran prepress operator must convince his old-school boss that Kodak Preps 10 isn’t just software—it’s survival.
Story:
For 22 years, Marco had laid out flats by hand. His fingers knew the weight of a ruby lith mask, the hiss of the light table, the slide of a X-Acto blade. But when the shop upgraded to digital, he adapted—grudgingly. He learned Preps 5, then 6, but after that, he just made do.
Then came the Hartwell job. 224 pages. 20,000 copies. Four different paper stocks, three signature sizes, and a fold-out map that had to align perfectly across two spreads. Delivery date: Friday at 7 AM.
It was Tuesday night.
Marco’s usual version of Preps (version 8, hacked and patched to death) crashed six times before midnight. Each time, he lost the step-and-repeat for the map section. The sheet was 40 inches, but the press’s gripper margin was tight—2 millimeters of error, and the folder would rip the map to shreds.
By 1:30 AM, he was staring at an error message: “Insufficient memory for flat construction.”
He called his boss, Lou. “It’s the software. Preps 8 can’t handle this many floating impositions. We need Preps 10.”
Lou snorted through the phone. “Ten? We don’t even have a license. And you want me to call IT at 2 AM?”
“I want you to let me download the trial.”
Silence. Then: “One hour. If you can’t get a proof by 3, we hand-collate.”
Marco downloaded Kodak Preps 10 at 1:47 AM. The interface was different—cleaner, more aggressive with the GPU rendering. But the muscle memory was there. He imported the PDFs, set the sheet size, and this time, instead of manual page assignment, he used the Smart Marks feature. Preps 10 auto-detected the fold-out map’s bleed and spine position, then suggested a double-gate fold imposition that Marco had only ever done by hand.
He clicked Apply.
The software recalculated the entire 224-page run in 11 seconds. It flagged two pages where the map’s registration was off by 0.3mm—something Preps 8 would have missed until press check. Marco nudged the marks, re-ran the collision check, and got a green light.
At 2:33 AM, he hit Generate Imposition Proof. Preps 10 rendered a full-color, scale-accurate PDF in 90 seconds. He sent it to the Epson 9900.
By 2:48 AM, he was holding a perfect imposition proof. The map aligned. The gripper margins were safe. The fold marks matched the binder’s specs.
He called Lou. “We’re good.”
Lou showed up at 4 AM with coffee and a credit card. They bought the full license for Preps 10 before the press even started rolling.
The Hartwell job finished at 6:52 AM—eight minutes early. The client never knew there was a crisis. But Marco did. And when the next rush job came in, he didn’t reach for the old version.
He opened Preps 10, took a sip of cold coffee, and smiled.
Why this story works for Kodak Preps 10:
Kodak Preps 10 is not a revolutionary overhaul; it is an evolution that corrects the pain points of the last decade. It eliminates the spinning beach ball of death, handles modern PDF transparency without a fight, and finally bridges the gap between offset traditionalists and digital disruptors.
If your prepress department is currently swearing at version 8 or 9, or if you are still using the "Step and Repeat" function in Adobe Acrobat, you are burning money. Kodak Preps 10
Download the 30-day trial of Preps 10 from the Kodak Partner Portal. Throw your most problematic 100-page booklet at it. Time the export. You will likely order the license before lunch.
Kodak Preps 10: Because good imposition is invisible, but bad imposition is unforgivable.
Sure! Since Kodak Preps 10 is a specialized tool for print professionals, a "review" usually looks at how it handles the nitty-gritty of imposition —the art of arranging pages on a press sheet.
Here is a breakdown of what makes version 10 stand out, written from the perspective of a daily user. The Bottom Line Kodak Preps 10
remains the "gold standard" for professional print imposition. It isn't a flashy update, but it doubles down on automation integration Kodak Prinergy Workflow
. If you are still manually dragging and dropping pages, this version is designed to get you out of the software and back to the press faster. Key Features & Strengths Smart Automation (AutoGang): The standout feature in version 10 is the improved
. It intelligently decides how to fit different PDF pages onto a sheet to minimize paper waste. For shops running high-volume "gang runs" (multiple customers on one sheet), this is a massive time-saver. JDF Integration: It plays very nicely with JDF (Job Definition Format)
data. You can pull in job requirements from your MIS (Management Information System), and Preps will automatically suggest the best press-run layouts based on that data. The "Search & Find" Layouts: Layouts Search tool
has been refined. Instead of digging through hundreds of old templates, you can filter by page count, binding style, or sheet size to find exactly what you need in seconds. Complex Binding Support:
Whether it’s perfect bound, saddle-stitched, or complex "shingling and bottling" for thick booklets, Preps 10 handles the math so you don't have to. The "Not-So-Great" Parts Learning Curve:
If you’re new to print, the interface can feel a bit "old school" and intimidating. It’s built for power, not necessarily for a modern "app" feel.
It’s a premium tool. Smaller shops might find the licensing cost high unless they are heavily utilizing the automation features. Who is it for? Commercial Printers: Who need to move hundreds of jobs a day with zero errors. Packaging Pros: Who deal with complex step-and-repeat patterns. Prinergy Users:
If you already use Kodak Prinergy, staying on the latest version of Preps is almost a no-brainer for the integrated hot folder automation
4.5/5 stars for high-volume shops; 3/5 for small, simple print jobs. specific feature in Preps 10, or are you trying to decide if it's worth the from an older version?
Kodak Preps 10 is the latest significant evolution of the printing industry’s leading imposition software, designed to streamline the transition from digital design to physical press runs. As a cornerstone of the Kodak Prinergy Workflow, Preps 10 introduces critical updates for modern operating systems and enhanced automation to reduce manual intervention and production costs. What is Kodak Preps 10?
At its core, Preps 10 is a prepress tool used to create precise layouts for bound-work impositions, ganged flat work, and step-and-repeat jobs. It allows printers to:
Maximize Press Sheet Usage: Minimize paper waste through intelligent signature plans.
Support Hybrid Printing: Create layouts for both conventional offset and digital label jobs within the same interface.
Automate Complex Tasks: Use JDF (Job Definition Format) functionality to trigger specific tasks automatically based on job data. Key Features & New Enhancements
Preps 10 focuses on modernizing the user experience and increasing technical compatibility. Description Modern OS Support Fully qualified for Windows 11 and macOS 13 Ventura. Apple Silicon Native
Offers compatibility with M1 and M2 chips, ensuring high performance on newer Mac hardware. Software-Based Licensing
Moves away from hardware dongles to a more flexible software-based or floating license system. SmartMark Improvements
Greater efficiency and accuracy in SmartMark placement, including better logic for Page and Page Bleed Mark anchors. 64-bit Migration
The Preps Migration Utility is now 64-bit native, simplifying the move from legacy versions. Workflow Integration and Automation
Preps 10 is most powerful when integrated into a larger ecosystem like Kodak Prinergy 10.0. KODAK Preps Imposition Software Release Notes If you’d like, I can:
Kodak Preps 10 is an industry-leading imposition software designed to
streamline the creation of press-run layouts for bound-work, ganged flat work, and step-and-repeat projects
. It serves as a critical bridge in the prepress process, allowing users to impose PDF input files for sheetfed or web press runs and send them to various output devices like CTP (computer-to-plate) systems or digital printers. Core Capabilities Flexible Layout Creation
: Supports a wide range of job types, including bound work (books, magazines), ganged flat work (leaflets, cards), and step-and-repeat layouts for packaging and label printers. Smart Automation : Features like
intelligently determine the best page placement to minimize waste, while JDF (Job Definition Format) automation enables seamless communication with other prepress systems. Workflow Integration : Preps 10 is deeply integrated with the Kodak Prinergy Workflow
but also functions as a standalone solution or within third-party systems like Agfa ApogeeX or Global Graphics Harlequin. Dynamic Customization SmartMarks
: Users can create custom marks (crop marks, text marks) that automatically anchor to specific page elements or job properties. Custom Fold Patterns
: Advanced users can define and save specific grid impositions as custom fold patterns for repeated use. Key Features for Efficiency Step-and-Repeat Tools
: Quickly fills printable areas with copies of a page or placeholder, featuring "hot corners" for easy drag-and-drop artwork assignment. Advanced Finish Controls : Includes automated calculations for shingling and bottling to compensate for paper thickness in bound work. Unified Licensing
: Starting from version 7, Preps simplified its structure to a single license type that includes all previously "Pro-only" features, such as unlimited sheet sizes and JDF binding data output. Resource Management : A robust database for stock and media
allows users to store specifications like sheet dimensions, weight, and grain direction for fast recall. Legacy Support & Compatibility File Migration
: Preps 10 can open jobs and templates from previous versions; however, legacy files (e.g., from Preps 6) are converted to the version 10 format once saved. Multi-Format Output : Supports generating PDF, JDF, PS, and PPF
files to meet the requirements of different downstream devices and cutting systems. step-by-step guide for a specific task like booklet imposition? Features - Preps 10 - Workflow Documentation - Kodak
Kodak Preps 10 is an advanced imposition software designed to automate and streamline the creation of error-free press runs for the printing industry. It focuses on reducing turnaround times and minimizing material waste through flexible layout tools and seamless workflow integration. Core Capabilities & Features
Flexible Layout Creation: Supports a variety of complex imposition styles, including come-and-go layouts (producing two complete books from a single sheet) and cut-and-stack press runs.
Ganging and Step-and-Repeat: Users can manually create ganged layouts for independent positioning or use step-and-repeat tools to quickly fill an area with repeated pages or sections.
SmartMarks Technology: Automates the placement of marks and color bars based on job rules, ensuring consistent output across different media and devices.
Template Management: Features a Template Editing mode for modifying existing layouts and supports migrating templates from previous versions of the software. Operational Workflow Creating a cut-and-stack press run - Preps 10
Kodak Preps 10 is a professional imposition software used in the commercial printing industry to create press run layouts for various job types, including books, folders, and ganged sheets. It is designed to automate the process of arranging digital pages on a press sheet to optimize paper usage and ensure correct folding and binding. Key Features of Kodak Preps 10
Product section properties - Preps 10 - Workflow Documentation
The Modern Standard for Automated Imposition
Executive Summary
Kodak Preps 10 represents a significant evolution in imposition workflow software. As the industry standard for over two decades, the Preps platform has long been the backbone of prepress departments worldwide. Version 10 introduces a modernized architecture designed to meet the demands of modern digital and offset environments. By combining a reimagined user interface with enhanced automation capabilities and a new architecture based on the Kodak Unified Workflow Platform, Preps 10 reduces manual intervention, minimizes error rates, and accelerates job turnaround times. This paper outlines the key features, architectural changes, and operational benefits of upgrading to or implementing Kodak Preps 10.
Preps 10 does not reinvent the wheel; it sharpens the spokes. The headline feature is the enhanced Smart Mark and Smart Grid logic. Older versions required users to manually adjust marks (color bars, fold marks, registration targets) when sheet sizes changed. Preps 10 introduces dynamic anchoring.
Now, when a printer switches from a 40-inch sheet to a 29-inch sheet, the marks intelligently reposition themselves based on relative sheet geometry rather than fixed XY coordinates. This reduces manual rework by an estimated 30-40% for shops running varied job sizes. Here’s a solid, plausible story about Kodak Preps
The most significant change in Kodak Preps 10 is under the hood. Previous versions relied on legacy codebases that struggled to integrate seamlessly with modern automation APIs. Preps 10 is built on the Kodak Unified Workflow Platform.
Kodak Preps 10 is not merely an incremental update; it is a modernization of the industry's most trusted imposition tool. By shedding legacy code in favor of a unified, 64-bit architecture and introducing the Evaluator for rule-based automation, Kodak has positioned Preps 10 as the solution for the modern era of automated, data-driven print production.
For print service providers looking to reduce touch times, eliminate manual errors, and integrate their prepress floor with their wider MIS ecosystem, Kodak Preps 10 provides the necessary infrastructure to remain competitive.
Disclaimer: This white paper is for informational purposes. Features and specifications are subject to change based on software updates provided by Kodak.
Kodak Preps 10: Maximizing Efficiency in Prepress Imposition
Kodak has released Preps 10, a major update to its industry-leading imposition software designed to streamline the production of press run layouts for bound-work, ganged flat work, and step-and-repeat jobs. This version brings enhanced compatibility, native performance improvements, and deeper integration with the Kodak Prinergy Workflow. What’s New in Kodak Preps 10?
The update focuses on modernizing the user experience and technical foundation:
Native Silicon Support: Preps 10 now features native compatibility with Apple M1 and M2 chips, ensuring faster performance for macOS users.
64-Bit Migration Utility: The Preps Migration Utility is now 64-bit native, simplifying the transition of legacy configurations to the latest version.
Enhanced OS Support: Full support for macOS 13 Ventura and qualified use on Windows 10 and 11.
Smart Mark Improvements: Building on the logic introduced in version 9.5, Preps 10 addresses historical issues with Page and Page Bleed Mark Anchors for more reliable placement. Core Capabilities for Modern Printers
Preps 10 continues to offer a robust toolset that was previously reserved for "Pro" license holders, making advanced features more accessible:
Workflow Automation: Supports JDF input, AutoGang for semi-automation, and JDF Auto Signature Matching (ASM).
Advanced Layouts: Includes mixed binding styles, web growth compensation, and automated calculations for shingling and bottling.
Integrated or Standalone: Whether used as part of the Kodak Prinergy Workflow 10.x or as a standalone prepress tool, it remains highly flexible. Preparing for the Upgrade
If you are upgrading from an older version, keep these key points in mind: Installation - Preps 11 - Workflow Documentation
Kodak Preps 10 represents the latest evolution in professional imposition software, designed to streamline the complex process of arranging book pages or flat-work items on press sheets. As a core component of modern print production, version 10 focuses on deeper automation, enhanced security, and seamless integration with broader print workflows like Kodak PRINERGY. Key Features and Capabilities
Preps 10 serves as an interactive workspace for creating press run layouts for bound-work impositions, ganged flat-work, and step-and-repeat projects. Notable features include:
Flexible Layout Creation: Users can impose PDF input files for sheetfed or web press layouts, as well as packaging labels and flexible bags.
Smart Marks: The software utilizes Smart Marks to automatically place collation marks and page bleed indicators based on job-specific rules.
Production Automation: Integration with Kodak’s PRINERGY Workflow allows for higher-level automation, reducing manual touchpoints and potential errors.
Task-Based Views: A refined interface allows users to tab between dynamically updated views for pages, press runs, or product assemblies. System Requirements and Compatibility
For peak performance, Preps 10 is optimized for modern hardware and operating systems: Requirements - Preps 10 - Workflow Documentation - Kodak
To generate an interesting report in Kodak Preps 10, let's create a hypothetical scenario where we analyze the usage and efficiency of a print shop's workflow. We will create a report that could potentially highlight areas of improvement, efficiency, and profitability.
These utilities are no longer supported. Please use Connection.unwrap(...) to access Oracle-specific APIs.
The Oracle thin JDBC driver provides a non-standard API for creating temporary BLOBs and CLOBs that
requires users to call methods on the raw, Oracle-specific Connection implementation. Advanced users
might use the raw connection operations described above to access this
functionality, but a convenience class is available in a separate jar file (c3p0-oracle-thin-extras-0.13.0.jar)
for easier access to this functionality. Please see the
API docs for com.mchange.v2.c3p0.dbms.OracleUtils
for details.
As of c3p0 0.10.0, c3p0's config property connectionTesterClassName defaults to null. When this property is null, c3p0 just uses the Java 6+ Connection.isValid(int timeout) method to test Connections.
But c3p0 is an old library, first published uner Java 1.3. Back in the day, we didn't have no stinking standard Connection.isValid(int timeout) method, and had to roll our own Connection tests. This Appendix documents that old but still supported style of Connection test management. To make this section relevant again, just 1) set connectionTesterClassName to its old default of com.mchange.v2.c3p0.DefaultConnectionTester; 2) set connectionTesterClassName to the name of a custom ConnectionTester implementation with a public no-arg constructor; 3) set a non-null preferredTestQuery; or 4) set a non-null automaticTestTable. If any connectionTesterClassName is explicitly set, the provided ConnectionTester implementation will be used. If preferredTestQuery or automaticTestTable are set, but no connectionTesterClassName is provided, an instance of com.mchange.v2.c3p0.DefaultConnectionTester will be used to perform Connection tests.
If any of these conditions apply, the following section documents how Connection testing with a ConnectionTester works in c3p0.
c3p0 can be configured to test the Connections that it pools in a variety of ways, to minimize the likelihood that your application will see broken or "stale" Connections. Pooled Connections can go bad for a variety of reasons -- some JDBC drivers intentionally "time-out" long-lasting database Connections; back-end databases or networks sometimes go down "stranding" pooled Connections; and Connections can simply become corrupted over time and use due to resource leaks, driver bugs, or other causes.
c3p0 provides users a great deal of flexibility in testing Connections, via the following configuration parameters:
idleConnectionTestPeriod, testConnectionOnCheckout, and testConnectionOnCheckin control when Connections will be tested. automaticTestTable, connectionTesterClassName, and preferredTestQuery control how they will be tested.
When configuring Connection testing, first try to minimize the cost of each test. If you are using a JDBC driver that you are certain supports the new(ish) jdbc4 API — and if you are using c3p0-0.9.5 or higher! — let your driver handle this for you. jdbc4 Connections include a method called isValid() that should be implemented as a fast, reliable Connection test. By default, c3p0 will use that method if it is present.
However, if your driver does not support this new-ish API, c3p0's default behavior is to test Connections by calling the getTables() method on a Connection's associated DatabaseMetaData object. This has the advantage of being very robust and working with any database, regardless of the database schema. However, a call to DatabaseMetaData.getTables() is often much slower than a simple database query, and using this test may significantly impair your pool's performance.
The simplest way to speed up Connection testing under a JDBC 3 driver (or a pre-0.9.5 version of c3p0) is to define a test query with the preferredTestQuery parameter. Be careful, however. Setting preferredTestQuery will lead to errors as Connection tests fail if the query target table does not exist in your database prior to initialization of your DataSource. Depending on your database and JDBC driver, a table-independent query like SELECT 1 may (or may not) be sufficient to verify the Connection. If a table-independent query is not sufficient, instead of preferredTestQuery, you can set the parameter automaticTestTable. Using the name you provide, c3p0 will create an empty table, and make a simple query against it to test the database.
The most reliable time to test Connections is on check-out. But this is also the most costly choice from a client-performance perspective. Most applications should work quite reliably using a combination of idleConnectionTestPeriod and testConnectionOnCheckin. Both the idle test and the check-in test are performed asynchronously, which can lead to better performance, both perceived and actual.
For some applications, high performance is more important than the risk of an occasional database exception. In its default configuration, c3p0 does no Connection testing at all. Setting a fairly long idleConnectionTestPeriod, and not testing on checkout and check-in at all is an excellent, high-performance approach.
It is possible to customize how c3p0's DefaultConnectionTester tests when no preferredTestQuery or automaticTestTable are available. Please see Configuring DefaultConnectionTester.isValidTimeout and Configuring DefaultConnectionTester.QuerylessTestRunner.
Advanced users may define any kind of Connection testing they wish, by implementing a ConnectionTester and supplying the fully qualified name of the class as connectionTesterClassName. If you'd like your custom ConnectionTesters to honor and support the preferredTestQuery and automaticTestTable parameters, implement UnifiedConnectionTester, most conveniently by extending AbstractConnectionTester. See the api docs for more information.
If you know you want to use the jdbc4 Connection.isValid() method, but you want to set a timeout, consider writing a trivial extension of IsValidConnectionTester.
See? These really are trivial to write.
If you don't know what to do, try this:
If you know your driver supports the JDBC 4 Connection.isValid(...) method and you are using c3p0-0.9.5 or above, don't set a preferredTestQuery. If your driver does not support this method (or if you are not sure), try SELECT 1 for your preferredTestQuery, if you are running MySQL or Postgres. For other databases, look for suggestions here. Leave automatedTestTable undefined.
Begin by setting testConnectionOnCheckout to true and get your application to run correctly and stably. If you are happy with your application's performance, you can stop here! This is the simplest, most reliable form of Connection-testing, but it does have a client-visible performance cost.
If you'd like to improve performance by eliminating Connection testing from clients' code path:
Set testConnectionOnCheckout to false
Set testConnectionOnCheckin to true
Set idleConnectionTestPeriod to 30, fire up you application and observe. This is a pretty robust setting, all Connections will tested on check-in and every 30 seconds thereafter while in the pool. Your application should experience broken or stale Connections only very rarely, and the pool should recover from a database shutdown and restart quickly. But there is some overhead associated with all that Connection testing.
If database restarts will be rare so quick recovery is not an issue, consider reducing the frequency of tests by idleConnectionTestPeriod to, say, 300, and see whether clients are troubled by stale or broken Connections. If not, stick with 300, or try an even bigger number. Consider setting testConnectionOnCheckin back to false to avoid unnecessary tests on checkin. Alternatively, if your application does encounter bad Connections, consider reducing idleConnectionTestPeriod and set testConnectionOnCheckin back to true. There are no correct or incorrect values for these parameters: you are trading off overhead for reliability in deciding how frequently to test. The exact numbers are not so critical. It's usually easy to find configurations that perform well. It's rarely worth spending time in pursuit of "optimal" values here.
So, when should you stick with simple and reliable (Step 2 above), and when is it worth going for better performance (Step 3)? In general, it depends on how much work clients typically do with Connections once they check them out. If clients usually make complex queries and/or perform multiple operations, adding the extra cost of one fast test per checkout will not much affect performance. But if your application typically checks out a Connection and performs one simple query with it, throwing in an additional test can really slow things down.
That's nice in theory, but often people don't really have a good sense of how much work clients perform on average. The best thing to do is usually to try Step 3, see if it helps (however you measure performance), see if it hurts (is your application troubled by broken Connections? does it recover from database restarts well enough?), and then decide. You can always go back to simple, slow, and robust. Just set testConnectionOnCheckout to true, testConnectionOnCheckin to false, and set idleConnectionTestPeriod to 0.
But do, always, be sure that your tests themselves are performant, either because your JDBC driver supports Connection.isValid(...) or because you have set an efficient preferredTestQuery !!!