1. The blood and tears history of traditional verbal conviction
A certain Internet financial platform caused 9,800 wrong transactions in the early morning due to an abnormal empty pointer at the expense calculation level.
The problem with the DEBUG log display appears in the following code segment:
// Error example
BigDecimal amount = ().getBalance().add(new BigDecimal("100"));If a null value appears in the intermediate link of this type of chain call, it will definitely lead to NPE.
Initial developers usually write multi-layer nested judgments:
if(user != null){
Wallet wallet = ();
if(wallet != null){
BigDecimal balance = ();
if(balance != null){
// Actual business logic
}
}
}This writing method is neither elegant nor affects the readability of the code.
So, how should we optimize?
Friends who are preparing for the interview recently can check out this treasure website: Inside: Interview Eight-Legend Essays, Interview Real Questions, and Work Recommendations。
2. The judgment revolution of the Java 8+ era
After Java 8, an Optional class was added, which is used to specifically judge empty spaces.
Can help you write more elegant code.
1. Optional Golden Three-Standard Axe
// Reconstructed chain call
BigDecimal result = (user)
.map(User::getWallet)
.map(Wallet::getBalance)
.map(balance -> (new BigDecimal("100")))
.orElse();Advanced Usage: Conditional Filtering
(user)
.filter(u -> () > 3)
.ifPresent(u -> sendCoupon(u)); // VIP user sends coupons2. Optional throws business exception
BigDecimal balance = (user)
.map(User::getWallet)
.map(Wallet::getBalance)
.orElseThrow(() -> new BusinessException("User wallet data exception"));3. Encapsulate general tool classes
public class NullSafe {
// Securely obtain object properties
public static <T, R> R get(T target, Function<T, R> mapper, R defaultValue) {
return target != null ? (target) : defaultValue;
}
// Chain safe operation
public static <T> T execute(T root, Consumer<T> consumer) {
if (root != null) {
(root);
}
return root;
}
}
// Use example
(user, u -> {
().charge(new BigDecimal("50"));
("User {}recharged", ());
});3. The modern framework of the judgment silver bullet
4. Spring practical skills
Spring comes with some useful tool classes, such as CollectionUtils, StringUtils, etc., which can be used to judge empty spaces very effectively.
The specific code is as follows:
// Collection of empty-determining tools
List<Order> orders = getPendingOrders();
if ((orders)) {
return ("No pending order");
}
// String check
String input = ("token");
if ((input)) {
validateToken(input);
}5. Lombok is escorting
In our daily development, our entity objects generally use the annotations in the Lombok framework to implement the getter/setter method.
In fact, this framework also provides annotations such as @NonNull for null.
for example:
@Getter
@Setter
public class User {
@NonNull // Generate null check code during compilation
private String name;
private Wallet wallet;
}
// Automatically determine empty when using the construct
User user = new User(@NonNull "Zhang San", wallet);IV. Engineering-level solutions
6. Empty object mode
public interface Notification {
void send(String message);
}
// Real implementation
public class EmailNotification implements Notification {
@Override
public void send(String message) {
// Send email logic
}
}
// Empty object implementation
public class NullNotification implements Notification {
@Override
public void send(String message) {
// Default processing
}
}
// Use example
Notification notifier = getNotifier();
("System Reminder"); // No need to be judged7. Optional enhancement of Guava
In fact, the Guava toolkit provides us with Optional enhanced functions.
for example:
import ;
// Create an Optional with default values
Optional<User> userOpt = (user).or(defaultUser);
// Chain operation with Function
Optional<BigDecimal> amount = (u -> ())
.transform(w -> ());The Optional class in the Guava toolkit has been encapsulated and we can use it directly.
5. Advanced defensive programming
8. Assert assertion interception
In fact, some Assert assert classes have done the work of null judgments, and if the parameters are null, an exception will be thrown.
This way we can call this assertion class directly.
For example, the requireNonNull method in the ValidateUtils class below has been nulled, so if the requireNonNull method is called elsewhere, if it is null, an exception will be thrown directly.
In the business code, we can just call requireNonNull directly without writing additional empty judgment logic.
For example:
public class ValidateUtils {
public static <T> T requireNonNull(T obj, String message) {
if (obj == null) {
throw new ServiceException(message);
}
return obj;
}
}
//User posture
User currentUser = (
(userId),
"User does not exist -ID:" + userId
);9. Global AOP Intercept
In some special business scenarios, we can implement the judgment of entities or fields through custom annotations + global AOP interceptors.
For example:
@Aspect
@Component
public class NullCheckAspect {
@Around("@annotation()")
public Object checkNull(ProceedingJoinPoint joinPoint) throws Throwable {
Object[] args = ();
for (Object arg : args) {
if (arg == null) {
throw new IllegalArgumentException("Argument cannot be empty");
}
}
return ();
}
}
// Use of annotations
public void updateUser(@NullCheck User user) {
// Method implementation
}6. Comparative analysis of practical scenarios
Scene 1: Deep-level object value
// Old code (4-layer nested judgment)
if (order != null) {
User user = ();
if (user != null) {
Address address = ();
if (address != null) {
String city = ();
// Use city
}
}
}
// After reconstruction (smooth chain)
String city = (order)
.map(Order::getUser)
.map(User::getAddress)
.map(Address::getCity)
.orElse("Unknown City");Scenario 2: Batch data processing
List<User> users = ();
// Traditional writing method (explicit iterative judgment)
List<String> names = new ArrayList<>();
for (User user : users) {
if (user != null && () != null) {
(());
}
}
// Stream optimized version
List<String> nameList = ()
.filter(Objects::nonNull)
.map(User::getName)
.filter(Objects::nonNull)
.collect(());7. The art of balancing performance and safety
All the solutions described above can be used, but in addition to the readability of the code, we also need to consider performance factors.
The following lists the above comparisons between CPU consumption, memory usage and code readability:
| plan | CPU consumption | Memory usage | Code readability | Applicable scenarios |
|---|---|---|---|---|
| Multi-layer if nesting | Low | Low | ★☆☆☆☆ | Simple hierarchical call |
| Java Optional | middle | middle | ★★★★☆ | Medium complexity business flow |
| Empty object pattern | high | high | ★★★★★ | Basic services for high-frequency calls |
| AOP Global Intercept | middle | Low | ★★★☆☆ | Non-null verification of interface parameters |
Golden Rules
- Web layer entry mandatory parameter verification
- Service layer uses Optional chain processing
- The core domain model adopts the empty object pattern
8. Expanding technology
In addition to the conventional empty judgment introduced above, we will introduce two extended technologies to you below.
Kotlin's empty security design
Although Java developers cannot use it directly, they can draw on their design philosophy:
val city = order?.user?.address?.city ?: "default"
JDK 14 new features preview
//Try the pattern matching syntax
if (user instanceof User u && () != null) {
(().toUpperCase());
}In short, elegance and emptyness are not only the beauty of code, but also the bottom line of production safety.
This article shares 10 solutions for empty codes, hoping to help you write both elegant and robust Java code.
Finally, I would like to say (please pay attention, don't mess with me for free)
If this article is helpful or inspiring to you, please help me follow my official account of the same name: Su San Talks about Technology. Your support is my greatest motivation for persisting in writing.
Please ask for three consecutive one click: like, forward, and watch.
Follow the official account: [Su San Talks about Technology], reply in the official account: When you enter a large factory, you can get the 100,000-word interview book I have compiled for free. Many friends have obtained offers from many large factories through this book.