为可测试性进行重构
学习 TDD 如何自然地带来更好的代码设计，以及如何借助对测试的信心安全地进行重构。
为可测试性进行重构 是 CoddyKit 上的免费 Testing Mastery: JUnit, Mockito & Integration Tests 课时。 这是第 3 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Testing Mastery: JUnit, Mockito & Integration Tests 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Testing Mastery: JUnit, Mockito & Integration Tests 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
Refactoring in TDD: An Intro
In Test-Driven Development (TDD), the "Refactor" step is crucial. After writing a failing test (Red) and making it pass (Green), we enter the Refactor phase.
Refactoring means improving the internal structure of code without changing its external behavior. It's about making your code cleaner, more readable, and easier to maintain.
The Safety Net of Tests
Why is refactoring safe in TDD? Because you have a comprehensive suite of passing tests!
- Confidence: Your tests act as a safety net, ensuring that any structural changes you make don't introduce new bugs.
- Feedback: If a test fails after refactoring, you immediately know you've broken something, allowing you to revert or fix it.
This confidence allows developers to continuously improve code quality.
What is Testable Code?
Refactoring naturally leads to more testable code. But what makes code testable?
- Small & Focused: Units of code (methods, classes) do one thing well.
- Loose Coupling: Components have minimal dependencies on each other.
- Clear Responsibilities: Each class or method has a single, well-defined purpose.
These principles make it easier to isolate and test individual parts.
Code Smell: Hidden Dependencies
Consider a class that processes data and also logs messages directly to the console. This introduces a "hidden dependency" on System.out, making it harder to test the processing logic in isolation.
We want to test if processData works, not if System.out.println works!
Example: Poorly Testable Code
Here's a simple ReportGenerator. Notice how it directly uses System.out.println. This makes it hard to test the report generation logic without seeing console output.
public class ReportGenerator {
public String generateReport(String data) {
// Simulate some complex processing
String processedData = "Processed: " + data.toUpperCase();
System.out.println("Log: Report generated for " + data);
return processedData;
}
public static void main(String[] args) {
ReportGenerator generator = new ReportGenerator();
System.out.println(generator.generateReport("sales"));
}
}Refactoring: Extract Interface
To improve testability, we can introduce an interface for our logging mechanism. This decouples the ReportGenerator from a specific logging implementation.
An interface defines a contract: what methods a class must implement.
public interface Logger {
void log(String message);
}
public class ConsoleLogger implements Logger {
@Override
public void log(String message) {
System.out.println("Console: " + message);
}
}Refactoring: Dependency Injection
Now, we can inject the Logger dependency into the ReportGenerator's constructor. This is called Dependency Injection.
The ReportGenerator no longer creates its logger; it receives it. This makes it much easier to provide a "mock" logger during testing.
public interface Logger {
void log(String message);
}
public class ConsoleLogger implements Logger {
@Override
public void log(String message) {
System.out.println("Console: " + message);
}
}
public class ReportGenerator {
private final Logger logger;
public ReportGenerator(Logger logger) {
this.logger = logger;
}
public String generateReport(String data) {
String processedData = "Processed: " + data.toUpperCase();
logger.log("Report generated for " + data);
return processedData;
}
public static void main(String[] args) {
Logger consoleLogger = new ConsoleLogger();
ReportGenerator generator = new ReportGenerator(consoleLogger);
System.out.println(generator.generateReport("sales"));
}
}The Testability Advantage
With dependency injection, testing becomes much simpler:
- You can pass a real
ConsoleLoggerfor production. - For unit tests, you can pass a test double (like a mock) that records calls without actual console output. This allows you to verify that
logger.log()was called as expected, without interfering with test output.
This makes your ReportGenerator's logic truly isolated and testable.
Continuous Improvement
Refactoring isn't a one-time event; it's a continuous habit within the TDD cycle. After every passing test, take a moment to look for ways to improve the code.
- The Boy Scout Rule: Always leave the campsite cleaner than you found it. Apply this to code: always leave the module cleaner than when you started working on it.
This leads to a codebase that naturally evolves towards better design and higher quality.
Refactoring Benefits Check
Consider the benefits of refactoring for testability.
Recap: Refactoring for TDD
In this lesson, we explored the crucial "Refactor" step in TDD. We learned that refactoring, backed by passing tests, allows us to safely improve code design without altering behavior.
- We saw how refactoring leads to more testable code by promoting loose coupling and dependency injection.
- This enables easier isolation of units for testing and simpler use of test doubles.
- Refactoring is a continuous process that improves code quality and maintainability over time.
Keep refactoring to build robust and clean software!
常见问题解答
「为可测试性进行重构」课时是免费的吗？
是的 — 「为可测试性进行重构」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Testing Mastery: JUnit, Mockito & Integration Tests 课程的其余内容，请升级到 CoddyKit PRO。 Testing Mastery: JUnit, Mockito & Integration Tests 课程共包含 4 节课。
「为可测试性进行重构」这节课中我会学到什么？
学习 TDD 如何自然地带来更好的代码设计，以及如何借助对测试的信心安全地进行重构。 你通过在浏览器中直接运行的动手代码来练习 Testing Mastery: JUnit, Mockito & Integration Tests，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 Testing Mastery: JUnit, Mockito & Integration Tests 需要有经验吗？
无需任何先前经验。CoddyKit 上的 Testing Mastery: JUnit, Mockito & Integration Tests 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 3 节课，共 4 节。
「为可测试性进行重构」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 Testing Mastery: JUnit, Mockito & Integration Tests 课中编写并运行代码吗？
能。每节 Testing Mastery: JUnit, Mockito & Integration Tests 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。