封装 Java 工具类

1. 使用静态工厂方法或静态方法封装实例

使用静态工厂方法或静态方法封装实例的好处：
 1.提高代码的复用性。通过将实例化逻辑封装在静态方法中，可以在多个地方重复使用同一个实例，从而提高代码的复用性。
 2.隐藏实例化细节。将实例化逻辑封装在静态方法中，可以隐藏实例化的具体实现细节，使得代码更加简洁易懂。
 3.增加代码的安全性和可维护性。通过将实例化逻辑封装在静态方法中，可以限制对实例化的访问和操作，从而增加代码的安全性和可维护性。

下面是一个使用静态工厂方法封装实例的示例：

public class MyClass {private static final int MAX_COUNT = 10;// 静态工厂方法，用于创建MyClass对象public static MyClass create(int count) {if (count > MAX_COUNT) {throw new IllegalArgumentException("Count must be less than or equal to " + MAX_COUNT);}return new MyClass(count);}// 构造函数，用于初始化实例状态private MyClass(int count) {// ...}// 其他公共方法...
}// 在其他类中调用MyClass的静态工厂方法创建实例MyClass myClass = MyClass.create(5);

2.将工具类中的方法进行分组

  将工具类中的方法进行分组，按照功能进行分类，并将它们封装到不同的类中实例可以提高代码的可读性和可维护性。

以下是一个示例：

  假设我们有一个工具类 Utils,其中包含一些常用的方法，例如字符串处理、日期时间处理、文件操作等。我们可以将这些方法按照功能进行分类，并将它们封装到不同的类中实例。

1. StringUtils:用于字符串操作，例如大小写转换、截取、替换等。

public class StringUtils {public static String toLowerCase(String str) {// ...}public static String trim(String str) {// ...}public static String replace(String str, String oldStr, String newStr) {// ...}
}

2. DateUtils:用于日期时间操作，例如获取当前时间、格式化日期时间等。

public class DateUtils {public static LocalDateTime now() {// ...}public static String format(LocalDateTime dateTime, String pattern) {// ...}
}

3. FileUtils:用于文件操作，例如创建文件、读取文件、写入文件等。

public class FileUtils {public static boolean createFile(String filePath) throws FileNotFoundException {// ...}public static void writeToFile(String filePath, String content) throws IOException {// ...}public static String readFromFile(String filePath) throws IOException {// ...}
}

  通过将这些方法封装到不同的类中实例，我们可以更方便地使用它们，并且可以更好地组织和管理代码。例如，在需要字符串操作的地方，可以直接调用 StringUtils 中的方法；在需要日期时间操作的地方，可以直接调用 DateUtils

3. 常用方法定义为静态方法或枚举

  将常用的方法定义为静态方法或者枚举实例可以提高代码的可读性和可维护性。

  以下是一些常见的方法，以及它们应该如何被定义：

1. 字符串操作方法：例如 toLowerCase()、trim()、replace() 等。
   这些方法通常用于字符串处理，可以将它们定义为静态方法，以便在需要时可以直接调用。

public static String toLowerCase(String str) {return str.toLowerCase();
}public static String trim(String str) {return str.trim();
}public static String replace(String str, String oldStr, String newStr) {return str.replace(oldStr, newStr);
}

2. 日期时间操作方法：例如 now()、format() 等。
   这些方法通常用于日期时间处理，可以将它们定义为静态方法，以便在需要时可以直接调用。

public static LocalDateTime now() {return LocalDateTime.now();
}public static String format(LocalDateTime dateTime, String pattern) {return dateTime.format(DateTimeFormatter.ofPattern(pattern));
}

3. 文件操作方法：例如 createFile()、writeToFile()、readFromFile() 等。
   这些方法通常用于文件操作，可以将它们定义为静态方法或者使用枚举实例来封装。如果使用枚举实例，可以在枚举中定义常量，然后在调用方法时传入相应的常量值。

public enum FileAction {CREATE, WRITE, READ;public static FileAction createFile(String filePath) throws FileNotFoundException {// ...}public static void writeToFile(String filePath, String content) throws IOException {// ...}public static String readFromFile(String filePath) throws IOException {// ...}
}public class FileUtils {public static boolean createFile(String filePath) throws FileNotFoundException, IllegalArgumentException, FileAlreadyExistsException, SecurityException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, InstantiationException, ClassNotFoundException {FileAction action = FileAction.CREATE.equals(fileAction) ? FileAction.CREATE : FileAction.READ;switch (action) {case CREATE:// ...break;}}
}

4. 工厂 | 抽象工厂模式

  工厂方法模式和抽象工厂模式都是创建型设计模式，它们都可以用于将对象的创建过程从客户端代码中解耦出来。下面分别使用示例来说明这两种模式的使用。

1. 工厂模式

  工厂方法模式用于创建一系列相关或相互依赖的对象，它将对象的创建过程封装在一个工厂类中，客户端只需要调用工厂类即可获得相应的对象。

  例如，我们有一个工具类 Tool,其中包含了一些工具方法，比如计算两个数的和、计算两个数的积等。现在我们需要为每个工具方法都创建一个新的工具类实例，可以使用工厂方法模式来实现。

public interface Tool {int add(int a, int b);int subtract(int a, int b);int multiply(int a, int b);
}public class Calculator implements Tool {@Overridepublic int add(int a, int b) {return a + b;}@Overridepublic int subtract(int a, int b) {return a - b;}@Overridepublic int multiply(int a, int b) {return a * b;}
}public class CalculatorFactory {public static Tool createCalculator(String type) {if (type.equalsIgnoreCase("add")) {return new Calculator();} else if (type.equalsIgnoreCase("subtract")) {return new Calculator();} else if (type.equalsIgnoreCase("multiply")) {return new Calculator();} else {throw new IllegalArgumentException("Invalid operation type: " + type);}}
}// 在客户端代码中使用工厂方法创建工具类实例
Tool calculator = CalculatorFactory.createCalculator("add");
System.out.println("10 + 20 = " + calculator.add(10, 20)); // 输出30
System.out.println("50 - 30 = " + calculator.subtract(50, 30)); // 输出20
System.out.println("10 * 20 = " + calculator.multiply(10, 20)); // 输出200

2. 抽象工厂模式

  抽象工厂模式是一种创建型设计模式，它提供了一种统一的方式来创建一系列相关或依赖对象的实例，而不需要指定它们的具体类。

以下是一个简单的抽象工厂模式实例：

// 抽象产品接口
public interface Product {void use();
}// 具体产品A1实现
public class ConcreteProductA1 implements Product {@Overridepublic void use() {System.out.println("使用具体产品A1");}
}// 具体产品A2实现
public class ConcreteProductA2 implements Product {@Overridepublic void use() {System.out.println("使用具体产品A2");}
}// 具体产品B1实现
public class ConcreteProductB1 implements Product {@Overridepublic void use() {System.out.println("使用具体产品B1");}
}// 具体产品B2实现
public class ConcreteProductB2 implements Product {@Overridepublic void use() {System.out.println("使用具体产品B2");}
}// 具体工厂A实现
public class ConcreteFactoryA implements Factory {@Overridepublic Product createProductA() {return new ConcreteProductA1();}
}// 具体工厂B实现
public class ConcreteFactoryB implements Factory {@Overridepublic Product createProductB() {return new ConcreteProductB1();}
}

5. 访问数据库

  对于一些需要访问数据库的方法，可以使用 JDBC 驱动程序提供的 API 或者第三方的数据库访问库来进行操作。这样可以避免手写 SQL 语句，从而提高代码的可读性和可维护性。

5.1 JDBC API ：

使用 JDBC API 访问数据库有以下好处：

1. 灵活性高：JDBC API 是标准的方式，可以与各种不同类型的数据库进行交互，包括关系型数据库、非关系型数据库等。
2. 可控性强：通过 JDBC API 访问数据库，可以在应用程序和数据库之间实现完全的解耦，使得对数据库的操作更加可控。
3. 易于维护：使用 JDBC API 访问数据库，可以将数据访问逻辑从业务逻辑中分离出来，使得代码更加清晰易懂，便于维护。
4. 支持事务处理：JDBC API 支持事务处理，可以保证数据的一致性和可靠性。
5. 安全性高：JDBC API 可以提供多种安全机制，如加密、认证、授权等，可以保护数据的安全性。

以下是使用 JDBC 驱动程序提供的 API 进行数据库操作的示例代码：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;public class DBOperations {// JDBC 驱动名和数据库 URLprivate static final String DRIVER_NAME = "com.mysql.jdbc.Driver";private static final String DB_URL = "jdbc:mysql://localhost:3306/demo";public static void main(String[] args) throws SQLException, ClassNotFoundException {// 加载 JDBC 驱动程序Class.forName(DRIVER_NAME);// 建立数据库连接Connection conn = DriverManager.getConnection(DB_URL, "username", "password");// 创建 PreparedStatement 对象PreparedStatement pstmt = conn.prepareStatement("SELECT * FROM test WHERE id = ?");// 设置占位符参数值pstmt.setInt(1, 123);// 执行查询语句并获取结果集ResultSet rs = pstmt.executeQuery();while (rs.next()) {int id = rs.getInt("id");String name = rs.getString("name");int age = rs.getInt("age");System.out.println("ID: " + id + ", Name: " + name + ", Age: " + age);}// 关闭结果集、PreparedStatement 和数据库连接rs.close();pstmt.close();conn.close();}
}

  以上代码使用了 MySQL 数据库，需要在项目中添加 MySQL JDBC 驱动程序的依赖。如果使用其他数据库，需要替换 DRIVER_NAME、DB_URL 和相应的 JDBC 驱动程序。

5.2 第三方数据库

使用第三方的数据库访问库有以下好处：

1. 简化开发：第三方的数据库访问库通常提供了简单易用的 API,可以大大简化开发人员的工作量，提高开发效率。
2. 提高性能：第三方的数据库访问库通常会对底层数据库进行优化和封装，从而提高数据库的访问性能。
3. 支持更多的功能：第三方的数据库访问库通常会提供更多的功能和特性，如事务处理、缓存、连接池等，可以满足不同场景下的需求。
4. 更好的可维护性：使用第三方的数据库访问库可以减少对底层数据库的依赖，从而降低代码的复杂度和维护难度。
5. 更好的安全性：第三方的数据库访问库通常会提供多种安全机制，如加密、认证、授权等，可以保护数据的安全性。

以下是使用第三方的数据库访问库—— MyBatis 进行数据库操作的示例代码：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN""http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.dao.UserDao"><select id="getUserById" parameterType="int"resultType="com.example.entity.User">select * from user where id = #{id}</select></mapper>

  以上代码使用了 MyBatis 作为数据库访问库，需要在项目中添加相应的依赖。如果使用其他数据库或版本，需要替换 namespace 标签中的类名和相应的 Mapper XML 文件名。然后，可以在 Java 代码中通过 SqlSessionFactory 对象来获取 UserDao 接口的实例，并调用其中的方法来进行数据库操作。

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;@Component
public class DBOperations {@Autowiredprivate SqlSessionFactory sqlSessionFactory;public User getUserById(int id) throws SQLException {return sqlSessionFactory.getObject().openSession().getUserDao().getUserById(id);}
}

  以上代码中，SqlSessionFactory 是 MyBatis 的核心组件之一，用于创建 SqlSession 对象并管理其生命周期。在 Spring Boot 应用中，可以通过 @Autowired 注解将 SqlSessionFactory 对象自动注入到需要它的组件中。然后，可以通过 openSession() 方法来获取 SqlSession 对象，并调用其中的方法来进行数据库操作。

  如果喜欢的话，欢迎 🤞关注 👍点赞 💬评论 🤝收藏  🙌一起讨论你的评价就是我✍️创作的动力！					  💞💞💞