《Better Java》项目教程：现代Java开发的最佳实践指南

原创 于 2025-04-09 09:45:12 发布 · 429 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

《Better Java》项目教程：现代Java开发的最佳实践指南

【免费下载链接】better-java Resources for writing modern Java 【免费下载链接】better-java 项目地址: https://gitcode.com/gh_mirrors/be/better-java

引言：为什么需要"更好的Java"？

Java作为一门已有20多年历史的编程语言，在企业级开发中占据着重要地位。然而，许多开发者对Java的印象仍然停留在冗长、繁琐的传统企业级开发模式上。随着Java 8及后续版本的发布，现代Java开发已经发生了革命性的变化。

《Better Java》项目正是为了帮助开发者摆脱传统Java开发的束缚，拥抱现代Java编程的最佳实践而诞生的。本文将深入解析这个项目，带你领略现代Java开发的魅力。

项目概览

《Better Java》是一个开源指南项目，旨在收集和整理现代Java开发中的最佳实践、工具和库。项目采用Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License许可证，允许非商业用途的分享和修改。

核心目标

  • 🎯 提供现代Java开发的实用指南
  • 🔧 推荐优秀的第三方库和工具
  • 📚 分享编码风格和最佳实践
  • 🚀 帮助开发者提高开发效率

现代Java编程风格

1. 简洁的数据结构设计

传统JavaBean模式过于冗长：

// 传统方式 - 需要16行代码
public class DataHolder {
    private String data;
    
    public DataHolder() {}
    
    public void setData(String data) {
        this.data = data;
    }
    
    public String getData() {
        return this.data;
    }
}

现代简洁方式：

// 现代方式 - 只需5行代码
public class DataHolder {
    public final String data;
    
    public DataHolder(String data) {
        this.data = data;
    }
}

2. 构建器模式（Builder Pattern）

对于复杂对象的构建，推荐使用构建器模式：

public class UserProfile {
    public final String username;
    public final String email;
    public final int age;
    public final List<String> roles;
    
    private UserProfile(Builder builder) {
        this.username = builder.username;
        this.email = builder.email;
        this.age = builder.age;
        this.roles = Collections.unmodifiableList(builder.roles);
    }
    
    public static class Builder {
        private String username;
        private String email;
        private int age;
        private List<String> roles = new ArrayList<>();
        
        public Builder username(String username) {
            this.username = username;
            return this;
        }
        
        public Builder email(String email) {
            this.email = email;
            return this;
        }
        
        public Builder age(int age) {
            this.age = age;
            return this;
        }
        
        public Builder addRole(String role) {
            this.roles.add(role);
            return this;
        }
        
        public UserProfile build() {
            return new UserProfile(this);
        }
    }
}

// 使用方式
UserProfile user = new UserProfile.Builder()
    .username("john_doe")
    .email("john@example.com")
    .age(30)
    .addRole("admin")
    .addRole("user")
    .build();

3. 不可变性设计

现代Java开发强调不可变性（Immutability），这能带来更好的线程安全和代码可读性：

public final class ImmutableConfig {
    private final String host;
    private final int port;
    private final Map<String, String> settings;
    
    public ImmutableConfig(String host, int port, Map<String, String> settings) {
        this.host = host;
        this.port = port;
        // 防御性拷贝，确保外部修改不会影响内部状态
        this.settings = Collections.unmodifiableMap(new HashMap<>(settings));
    }
    
    // 只有getter方法，没有setter
    public String getHost() { return host; }
    public int getPort() { return port; }
    public Map<String, String> getSettings() { return settings; }
}

依赖管理最佳实践

Maven依赖收敛

在大型项目中，依赖冲突是常见问题。Maven依赖收敛插件可以帮助解决这个问题：

<build>
    <plugins>
        <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-enforcer-plugin</artifactId>
            <version>3.0.0-M3</version>
            <executions>
                <execution>
                    <id>enforce</id>
                    <configuration>
                        <rules>
                            <dependencyConvergence/>
                        </rules>
                    </configuration>
                    <goals>
                        <goal>enforce</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

依赖管理策略

mermaid

现代Java库推荐

必备工具库对比表

库名称主要功能适用场景替代方案
Guava集合操作、缓存、函数式编程通用工具库Apache Commons
GsonJSON序列化/反序列化REST API开发Jackson
Lombok减少样板代码所有Java项目手动编写
JUnit 5单元测试测试驱动开发TestNG
AssertJ流畅断言测试断言Hamcrest

Guava使用示例

import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;

public class GuavaExamples {
    
    // 不可变集合
    public static final ImmutableList<String> COLORS = ImmutableList.of(
        "red", "green", "blue", "yellow"
    );
    
    // 缓存示例
    private static final LoadingCache<String, String> cache = CacheBuilder.newBuilder()
        .maximumSize(1000)
        .expireAfterWrite(10, TimeUnit.MINUTES)
        .build(new CacheLoader<String, String>() {
            @Override
            public String load(String key) throws Exception {
                return expensiveOperation(key);
            }
        });
    
    public static String getCachedValue(String key) {
        return cache.getUnchecked(key);
    }
    
    private static String expensiveOperation(String key) {
        // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return key.toUpperCase();
    }
}

Java 8+ 新特性实践

Stream API 深度应用

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class StreamExamples {
    
    public static void advancedStreamOperations() {
        List<Employee> employees = getEmployees();
        
        // 复杂数据转换
        Map<Department, List<String>> deptEmails = employees.stream()
            .filter(emp -> emp.getSalary() > 50000)
            .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.mapping(Employee::getEmail, Collectors.toList())
            ));
        
        // 并行流处理
        double averageSalary = employees.parallelStream()
            .filter(emp -> emp.getExperience() > 5)
            .mapToDouble(Employee::getSalary)
            .average()
            .orElse(0.0);
        
        // 自定义收集器
        Map<Boolean, List<Employee>> partitioned = employees.stream()
            .collect(Collectors.partitioningBy(emp -> emp.getAge() > 30));
    }
    
    static class Employee {
        private String name;
        private String email;
        private Department department;
        private double salary;
        private int experience;
        private int age;
        
        // getters and setters
    }
    
    enum Department {
        ENGINEERING, MARKETING, SALES, HR
    }
}

Optional的正确使用

import java.util.Optional;

public class OptionalBestPractices {
    
    public static void processUserData(Optional<User> userOptional) {
        // 错误用法 - 直接使用isPresent()和get()
        if (userOptional.isPresent()) {
            User user = userOptional.get();
            // 处理用户
        }
        
        // 正确用法 - 使用函数式方法
        userOptional.ifPresent(user -> {
            // 处理用户
            processUser(user);
        });
        
        // 链式操作
        String email = userOptional
            .map(User::getProfile)
            .map(Profile::getContactInfo)
            .map(ContactInfo::getEmail)
            .orElse("default@example.com");
        
        // 异常处理
        User user = userOptional.orElseThrow(() -> 
            new IllegalArgumentException("用户不存在"));
    }
    
    static class User {
        private Profile profile;
        // getters and setters
    }
    
    static class Profile {
        private ContactInfo contactInfo;
        // getters and setters
    }
    
    static class ContactInfo {
        private String email;
        // getters and setters
    }
}

测试驱动开发实践

现代测试策略

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.*;

public class ModernTestingExamples {
    
    @Mock
    private UserRepository userRepository;
    
    private UserService userService;
    
    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        userService = new UserService(userRepository);
    }
    
    @Nested
    @DisplayName("用户服务测试")
    class UserServiceTests {
        
        @Test
        @DisplayName("应该成功创建用户")
        void shouldCreateUserSuccessfully() {
            // 准备测试数据
            User user = new User("test@example.com", "password");
            when(userRepository.save(any(User.class))).thenReturn(user);
            
            // 执行测试
            User result = userService.createUser("test@example.com", "password");
            
            // 验证结果
            assertThat(result).isNotNull();
            assertThat(result.getEmail()).isEqualTo("test@example.com");
            verify(userRepository).save(any(User.class));
        }
        
        @ParameterizedTest
        @ValueSource(strings = {"invalid", "short", "no@domain"})
        @DisplayName("应该拒绝无效邮箱格式")
        void shouldRejectInvalidEmails(String invalidEmail) {
            assertThatThrownBy(() -> 
                userService.createUser(invalidEmail, "password"))
                .isInstanceOf(IllegalArgumentException.class)
                .hasMessageContaining("无效的邮箱格式");
        }
    }
    
    static class UserService {
        private final UserRepository userRepository;
        
        public UserService(UserRepository userRepository) {
            this.userRepository = userRepository;
        }
        
        public User createUser(String email, String password) {
            if (!isValidEmail(email)) {
                throw new IllegalArgumentException("无效的邮箱格式");
            }
            User user = new User(email, password);
            return userRepository.save(user);
        }
        
        private boolean isValidEmail(String email) {
            return email != null && email.contains("@");
        }
    }
    
    interface UserRepository {
        User save(User user);
    }
    
    static class User {
        private final String email;
        private final String password;
        
        public User(String email, String password) {
            this.email = email;
            this.password = password;
        }
        
        public String getEmail() { return email; }
        public String getPassword() { return password; }
    }
}

部署和运维最佳实践

持续集成流水线设计

mermaid

容器化部署配置

# Dockerfile 示例
FROM openjdk:17-jdk-slim

# 设置工作目录
WORKDIR /app

# 复制构建好的JAR文件
COPY target/my-application.jar app.jar

# 设置JVM参数
ENV JAVA_OPTS="-Xms512m -Xmx1024m -XX:+UseG1GC"

# 暴露端口
EXPOSE 8080

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8080/actuator/health || exit 1

# 启动命令
ENTRYPOINT ["sh", "-c", "java $JAVA_OPTS -jar app.jar"]

性能优化技巧

内存管理最佳实践

import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;

public class MemoryManagement {
    
    // 使用弱引用避免内存泄漏
    private static final WeakHashMap<Object, String> CACHE = new WeakHashMap<>();
    
    // 线程安全的缓存实现
    private static final ConcurrentHashMap<String, ExpensiveObject> 
        THREAD_SAFE_CACHE = new ConcurrentHashMap<>();
    
    public static void manageMemory() {
        // 对象池模式
        ObjectPool<DatabaseConnection> connectionPool = new ObjectPool<>(
            10, // 最大连接数
            DatabaseConnection::new,
            conn -> conn.isValid() // 验证函数
        );
        
        try (DatabaseConnection conn = connectionPool.borrowObject()) {
            // 使用数据库连接
            conn.executeQuery("SELECT * FROM users");
        } catch (Exception e) {
            // 处理异常
        }
    }
    
    static class DatabaseConnection implements AutoCloseable {
        private boolean valid = true;
        
        public void executeQuery(String sql) {
            // 执行查询
        }
        
        public boolean isValid() {
            return valid;
        }
        
        @Override
        public void close() {
            // 清理资源
            valid = false;
        }
    }
    
    static class ObjectPool<T extends AutoCloseable> {
        private final int maxSize;
        private final List<T> pool;
        private final Supplier<T> creator;
        private final Predicate<T> validator;
        
        public ObjectPool(int maxSize, Supplier<T> creator, Predicate<T> validator) {
            this.maxSize = maxSize;
            this.creator = creator;
            this.validator = validator;
            this.pool = new ArrayList<>();
        }
        
        public T borrowObject() {
            synchronized (pool) {
                // 尝试从池中获取有效对象
                for (T obj : pool) {
                    if (validator.test(obj)) {
                        pool.remove(obj);
                        return obj;
                    }
                }
                
                // 创建新对象
                if (pool.size() < maxSize) {
                    T newObj = creator.get();
                    pool.add(newObj);
                    return newObj;
                }
                
                throw new IllegalStateException("对象池已满");
            }
        }
        
        public void returnObject(T obj) {
            synchronized (pool) {
                if (validator.test(obj)) {
                    pool.add(obj);
                } else {
                    try {
                        obj.close();
                    } catch (Exception e) {
                        // 记录日志
                    }
                }
            }
        }
    }
}

安全编程实践

常见安全漏洞防护

import java.security.SecureRandom;
import java.util.Base64;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;

public class SecurityBestPractices {
    
    // 密码哈希处理
    public static String hashPassword(String password, byte[] salt) {
        try {
            PBEKeySpec spec = new PBEKeySpec(
                password.toCharArray(), 
                salt, 
                10000,  // 迭代次数
                256     // 密钥长度
            );
            SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
            byte[] hash = skf.generateSecret(spec).getEncoded();
            return Base64.getEncoder().encodeToString(hash);
        } catch (Exception e) {
            throw new RuntimeException("密码哈希失败", e);
        }
    }
    
    // 安全的随机数生成
    public static byte[] generateSalt() {
        SecureRandom random = new SecureRandom();
        byte[] salt = new byte[16];
        random.nextBytes(salt);
        return salt;
    }
    
    // SQL注入防护
    public static void safeDatabaseOperation(Connection conn, String username) {
        String sql = "SELECT * FROM users WHERE username = ?";
        try (PreparedStatement stmt = conn.prepareStatement(sql)) {
            stmt.setString(1, username); // 参数化查询
            ResultSet rs = stmt.executeQuery();
            // 处理结果
        } catch (SQLException e) {
            // 处理异常
        }
    }
    
    // XSS防护
    public static String sanitizeHtml(String input) {
        return input.replaceAll("<", "&lt;")
                   .replaceAll(">", "&gt;")
                   .replaceAll("\"", "&quot;")
                   .replaceAll("'", "&#x27;")
                   .replaceAll("/", "&#x2F;");
    }
}

【免费下载链接】better-java Resources for writing modern Java 【免费下载链接】better-java 项目地址: https://gitcode.com/gh_mirrors/be/better-java

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值