优化重复冗余代码的8种方式

客官°小女子只卖身不卖艺 2024-02-18 10:42 84阅读 0赞

文章目录

  • 前言
  • 1、抽取公用方法
  • 2、抽工具类
  • 3、反射
  • 4、泛型
  • 5、继承与多态
  • 6、使用设计模式
  • 7、自定义注解(或者说AOP面向切面)
  • 8、函数式接口和Lambda表达式

前言

日常开发中，我们经常会遇到一些重复代码。大家都知道重复代码不好，它主要有这些缺点：可维护性差、可读性差、增加错误风险等等。这里给大家讲讲优化重复代码的几种方式。

1、抽取公用方法

抽取公用方法，是最常用的代码去重方法~

比如这个例子，分别遍历names列表，然后各自转化为大写和小写打印出来：

  1. public class TianLuoExample {
  4.     public static void main(String[] args) {
  6.         List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "TianLuo");
  8.         System.out.println("Uppercase Names:");
  9.         for (String name : names) {
  11.             String uppercaseName = name.toUpperCase();
  12.             System.out.println(uppercaseName);
  13.         }
  15.         System.out.println("Lowercase Names:");
  16.         for (String name : names) {
  18.             String lowercaseName = name.toLowerCase();
  19.             System.out.println(lowercaseName);
  20.         }
  21.     }
  22. }

显然，都是遍历names过程，代码是重复的，只不过转化大小写不一样。我们可以抽个公用方法processNames，优化成这样：

  1. public class TianLuoExample {
  4.     public static void processNames(List<String> names, Function<String, String> nameProcessor, String processType) {
  6.         System.out.println(processType + " Names:");
  7.         for (String name : names) {
  9.             String processedName = nameProcessor.apply(name);
  10.             System.out.println(processedName);
  11.         }
  12.     }
  14.     public static void main(String[] args) {
  16.         List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "TianLuo");
  18.         processNames(names, String::toUpperCase, "Uppercase");
  19.         processNames(names, String::toLowerCase, "Lowercase");
  20.     }
  21. }

2、抽工具类

我们优化重复代码，抽一个公用方法后，如果发现这个方法有更多共性，就可以把公用方法升级为一个工具类。比如这样的业务场景：我们注册的时候，修改邮箱，重置密码等，都需要校验邮箱。

实现注册功能时，用户会填邮箱，需要验证邮箱格式。

  1. public class RegisterServiceImpl implements RegisterService{
  3.     private static final String EMAIL_REGEX =
  4.         "^[A-Za-z0-9+_.-]+@(.+)$";
  6.     public boolean registerUser(UserInfoReq userInfo) {
  8.         String email = userInfo.getEmail();
  9.         Pattern pattern = Pattern.compile(EMAIL_REGEX);
  10.         Matcher emailMatcher = pattern.matcher(email);
  11.         if (!emailMatcher.matches()) {
  13.             System.out.println("Invalid email address.");
  14.             return false;
  15.         }
  17.         // 进行其他用户注册逻辑，比如保存用户信息到数据库等
  18.         // 返回注册结果
  19.         return true;
  20.     }
  21. }

在密码重置流程中，通常会向用户提供一个链接或验证码，并且需要发送到用户的电子邮件地址。在这种情况下，也需要验证邮箱格式合法性：

  1. public class PasswordServiceImpl implements PasswordService{
  4.     private static final String EMAIL_REGEX =
  5.         "^[A-Za-z0-9+_.-]+@(.+)$";
  7.     public void resetPassword(PasswordInfo passwordInfo) {
  9.         Pattern pattern = Pattern.compile(EMAIL_REGEX);
  10.         Matcher emailMatcher = pattern.matcher(passwordInfo.getEmail());
  11.         if (!emailMatcher.matches()) {
  13.             System.out.println("Invalid email address.");
  14.             return false;
  15.         }
  16.         //发送通知修改密码
  17.         sendReSetPasswordNotify();
  18.     }
  19. }

我们可以抽取个校验邮箱的方法出来，又因为校验邮箱的功能在不同的类中，因此，我们可以抽个校验邮箱的工具类：

  1. public class EmailValidatorUtil {
  3.     private static final String EMAIL_REGEX =
  4.         "^[A-Za-z0-9+_.-]+@(.+)$";
  6.     private static final Pattern pattern = Pattern.compile(EMAIL_REGEX);
  8.     public static boolean isValid(String email) {
  10.         Matcher matcher = pattern.matcher(email);
  11.         return matcher.matches();
  12.     }
  13. }
  15. //注册的代码可以简化为这样啦
  16. public class RegisterServiceImpl implements RegisterService{
  19.     public boolean registerUser(UserInfoReq userInfo) {
  21.         if (!EmailValidatorUtil.isValid(userInfo.getEmail())) {
  23.             System.out.println("Invalid email address.");
  24.             return false;
  25.         }
  27.         // 进行其他用户注册逻辑，比如保存用户信息到数据库等
  28.         // 返回注册结果
  29.         return true;
  30.     }
  31. }

3、反射

我们日常开发中，经常需要进行PO、DTO和VO的转化。所以大家经常看到类似的代码：

  1. //DTO 转VO
  2.     public UserInfoVO convert(UserInfoDTO userInfoDTO) {
  4.         UserInfoVO userInfoVO = new UserInfoVO();
  5.         userInfoVO.setUserName(userInfoDTO.getUserName());
  6.         userInfoVO.setAge(userInfoDTO.getAge());
  7.         return userInfoVO;
  8.     }
  9.       //PO 转DTO
  10.     public UserInfoDTO convert(UserInfoPO userInfoPO) {
  12.         UserInfoDTO userInfoDTO = new UserInfoDTO();
  13.         userInfoDTO.setUserName(userInfoPO.getUserName());
  14.         userInfoDTO.setAge(userInfoPO.getAge());
  15.         return userInfoDTO;
  16.     }

我们可以使用BeanUtils.copyProperties() 去除重复代码，BeanUtils.copyProperties()底层就是使用了反射：

  1. public UserInfoVO convert(UserInfoDTO userInfoDTO) {
  3.         UserInfoVO userInfoVO = new UserInfoVO();
  4.         BeanUtils.copyProperties(userInfoDTO, userInfoVO);
  5.         return userInfoVO;
  6.     }
  8.     public UserInfoDTO convert(UserInfoPO userInfoPO) {
  10.         UserInfoDTO userInfoDTO = new UserInfoDTO();
  11.         BeanUtils.copyProperties(userInfoPO,userInfoDTO);
  12.         return userInfoDTO;
  13.     }

4、泛型

泛型是如何去除重复代码的呢？给大家看个例子，我有个转账明细和转账余额对比的业务需求，有两个类似这样的方法：

  1. private void getAndUpdateBalanceResultMap(String key, Map<String, List<TransferBalanceDTO>> compareResultListMap,
  2. List<TransferBalanceDTO> balanceDTOs) {
  4.     List<TransferBalanceDTO> tempList = compareResultListMap.getOrDefault(key, new ArrayList<>());
  5.     tempList.addAll(balanceDTOs);
  6.     compareResultListMap.put(key, tempList);
  7. }
  9. private void getAndUpdateDetailResultMap(String key, Map<String, List<TransferDetailDTO>> compareResultListMap,
  10.                                           List<TransferDetailDTO> detailDTOS) {
  12.     List<TransferDetailDTO> tempList = compareResultListMap.getOrDefault(key, new ArrayList<>());
  13.     tempList.addAll(detailDTOS);
  14.     compareResultListMap.put(key, tempList);
  15. }

这两块代码,流程功能看着很像,但是就是不能直接合并抽取一个公用方法,因为类型不一致。单纯类型不一样的话,我们可以结合泛型处理,因为泛型的本质就是参数化类型.优化为这样:

  1. private <T> void getAndUpdateResultMap(String key, Map<String, List<T>> compareResultListMap, List<T> accountingDTOS) {
  3. List<T> tempList = compareResultListMap.getOrDefault(key, new ArrayList<>());
  4. tempList.addAll(accountingDTOS);
  5. compareResultListMap.put(key, tempList);
  6. }

5、继承与多态

假设你正在开发一个电子商务平台，需要处理不同类型的订单，例如普通订单和折扣订单。每种订单都有一些共同的属性（如订单号、购买商品列表）和方法（如计算总价、生成订单报告），但折扣订单还有特定的属性和方法。

在没有使用继承和多态的话,会写出类似这样的代码:

  1. //普通订单
  2. public class Order {
  4.     private String orderNumber;
  5.     private List<Product> products;
  7.     public Order(String orderNumber, List<Product> products) {
  9.         this.orderNumber = orderNumber;
  10.         this.products = products;
  11.     }
  13.     public double calculateTotalPrice() {
  15.         double total = 0;
  16.         for (Product product : products) {
  18.             total += product.getPrice();
  19.         }
  20.         return total;
  21.     }
  23.       public String generateOrderReport() {
  25.         return "Order Report for " + orderNumber + ": Total Price = $" + calculateTotalPrice();
  26.     }
  27. }
  29. //折扣订单
  30. public class DiscountOrder {
  32.     private String orderNumber;
  33.     private List<Product> products;
  34.     private double discountPercentage;
  36.     public DiscountOrder(String orderNumber, List<Product> products, double discountPercentage) {
  38.         this.orderNumber = orderNumber;
  39.         this.products = products;
  40.         this.discountPercentage = discountPercentage;
  41.     }
  43.     public double calculateTotalPrice() {
  45.         double total = 0;
  46.         for (Product product : products) {
  48.             total += product.getPrice();
  49.         }
  50.         return total - (total * discountPercentage / 100);
  51.     }
  52.       public String generateOrderReport() {
  54.         return "Order Report for " + orderNumber + ": Total Price = $" + calculateTotalPrice();
  55.     }
  56. }

显然,看到在Order和DiscountOrder类中，generateOrderReport()方法的代码是完全相同的。calculateTotalPrice()则是有一点点区别，但也大相径庭。

我们可以使用继承和多态去除重复代码,让DiscountOrder去继承Order,代码如下:

  1. public class Order {
  3.     private String orderNumber;
  4.     private List<Product> products;
  6.     public Order(String orderNumber, List<Product> products) {
  8.         this.orderNumber = orderNumber;
  9.         this.products = products;
  10.     }
  12.     public double calculateTotalPrice() {
  14.         double total = 0;
  15.         for (Product product : products) {
  17.             total += product.getPrice();
  18.         }
  19.         return total;
  20.     }
  22.     public String generateOrderReport() {
  24.         return "Order Report for " + orderNumber + ": Total Price = $" + calculateTotalPrice();
  25.     }
  26. }
  28. public class DiscountOrder extends Order {
  30.     private double discountPercentage;
  32.     public DiscountOrder(String orderNumber, List<Product> products, double discountPercentage) {
  34.         super(orderNumber, products);
  35.         this.discountPercentage = discountPercentage;
  36.     }
  38.     @Override
  39.     public double calculateTotalPrice() {
  41.         double total = super.calculateTotalPrice();
  42.         return total - (total * discountPercentage / 100);
  43.     }
  44. }

6、使用设计模式

很多设计模式可以减少重复代码、提高代码的可读性、可扩展性.比如:

  • 工厂模式: 通过工厂模式，你可以将对象的创建和使用分开，从而减少重复的创建代码。
  • 策略模式: 策略模式定义了一族算法，将它们封装成独立的类，并使它们可以互相替换。通过使用策略模式，你可以减少在代码中重复使用相同的逻辑。
  • 模板方法模式:模板方法模式定义了一个算法的骨架，将一些步骤延迟到子类中实现。这有助于避免在不同类中重复编写相似的代码。

举个例子,模板方法是如何去除重复代码的吧,业务场景:

假设你正在开发一个咖啡和茶的制作流程，制作过程中的热水和添加物质的步骤是相同的，但是具体的饮品制作步骤是不同的。

如果没有使用模板方法模式，实现是这样的:

  1. public class Coffee {
  3.     public void prepareCoffee() {
  5.         boilWater();
  6.         brewCoffeeGrinds();
  7.         pourInCup();
  8.         addCondiments();
  9.     }
  11.     private void boilWater() {
  13.         System.out.println("Boiling water");
  14.     }
  16.     private void brewCoffeeGrinds() {
  18.         System.out.println("Brewing coffee grinds");
  19.     }
  21.     private void pourInCup() {
  23.         System.out.println("Pouring into cup");
  24.     }
  26.     private void addCondiments() {
  28.         System.out.println("Adding sugar and milk");
  29.     }
  30. }
  32. public class Tea {
  34.     public void prepareTea() {
  36.         boilWater();
  37.         steepTeaBag();
  38.         pourInCup();
  39.         addLemon();
  40.     }
  42.     private void boilWater() {
  44.         System.out.println("Boiling water");
  45.     }
  47.     private void steepTeaBag() {
  49.         System.out.println("Steeping the tea bag");
  50.     }
  52.     private void pourInCup() {
  54.         System.out.println("Pouring into cup");
  55.     }
  57.     private void addLemon() {
  59.         System.out.println("Adding lemon");
  60.     }
  61. }

这个代码例子,我们可以发现,烧水和倒入杯子的步骤代码,在Coffee和Tea类中是重复的。

使用模板方法模式，代码可以优化成这样:

  1. abstract class Beverage {
  3.     public final void prepareBeverage() {
  5.         boilWater();
  6.         brew();
  7.         pourInCup();
  8.         addCondiments();
  9.     }
  11.     private void boilWater() {
  13.         System.out.println("Boiling water");
  14.     }
  16.     abstract void brew();
  18.     private void pourInCup() {
  20.         System.out.println("Pouring into cup");
  21.     }
  23.     abstract void addCondiments();
  24. }
  26. class Coffee extends Beverage {
  28.     @Override
  29.     void brew() {
  31.         System.out.println("Brewing coffee grinds");
  32.     }
  34.     @Override
  35.     void addCondiments() {
  37.         System.out.println("Adding sugar and milk");
  38.     }
  39. }
  41. class Tea extends Beverage {
  43.     @Override
  44.     void brew() {
  46.         System.out.println("Steeping the tea bag");
  47.     }
  49.     @Override
  50.     void addCondiments() {
  52.         System.out.println("Adding lemon");
  53.     }
  54. }

在这个例子中，我们创建了一个抽象类Beverage，其中定义了制作饮品的模板方法 prepareBeverage()。这个方法包含了烧水、倒入杯子等共同的步骤，而将制作过程中的特定步骤 brew() 和addCondiments()延迟到子类中实现。这样，我们避免了在每个具体的饮品类中重复编写相同的烧水和倒入杯子的代码，提高了代码的可维护性和重用性。

7、自定义注解(或者说AOP面向切面)

使用 AOP框架可以在不同地方插入通用的逻辑，从而减少代码重复。

业务场景：

假设你正在开发一个Web应用程序，需要对不同的Controller方法进行权限检查。每个Controller方法都需要进行类似的权限验证，但是重复的代码会导致代码的冗余和维护困难。

  1. public class MyController {
  3.     public void viewData() {
  5.         if (!User.hasPermission("read")) {
  7.             throw new SecurityException("Insufficient permission to access this resource.");
  8.         }
  9.         // Method implementation
  10.     }
  12.     public void modifyData() {
  14.         if (!User.hasPermission("write")) {
  16.             throw new SecurityException("Insufficient permission to access this resource.");
  17.         }
  18.         // Method implementation
  19.     }
  20. }

你可以看到在每个需要权限校验的方法中都需要重复编写相同的权限校验逻辑,即出现了重复代码.我们使用自定义注解的方式能够将权限校验逻辑集中管理，通过切面来处理,消除重复代码.如下:

  1. @Aspect
  2. @Component
  3. public class PermissionAspect {
  6.     @Before("@annotation(requiresPermission)")
  7.     public void checkPermission(RequiresPermission requiresPermission) {
  9.         String permission = requiresPermission.value();
  11.         if (!User.hasPermission(permission)) {
  13.             throw new SecurityException("Insufficient permission to access this resource.");
  14.         }
  15.     }
  16. }
  18. public class MyController {
  20.     @RequiresPermission("read")
  21.     public void viewData() {
  23.         // Method implementation
  24.     }
  26.     @RequiresPermission("write")
  27.     public void modifyData() {
  29.         // Method implementation
  30.     }
  31. }

就这样，不管多少个Controller方法需要进行权限检查，你只需在方法上添加相应的注解即可。权限检查的逻辑在切面中集中管理，避免了在每个Controller方法中重复编写相同的权限验证代码。这大大提高了代码的可读性、可维护性，并避免了代码冗余。

8、函数式接口和Lambda表达式

业务场景:

假设你正在开发一个应用程序，需要根据不同的条件来过滤一组数据。每次过滤的逻辑都可能会有些微的不同，但基本的流程是相似的。

没有使用函数式接口和Lambda表达式的情况：

  1. public class DataFilter {
  3.     public List<Integer> filterPositiveNumbers(List<Integer> numbers) {
  5.         List<Integer> result = new ArrayList<>();
  6.         for (Integer number : numbers) {
  8.             if (number > 0) {
  10.                 result.add(number);
  11.             }
  12.         }
  13.         return result;
  14.     }
  16.     public List<Integer> filterEvenNumbers(List<Integer> numbers) {
  18.         List<Integer> result = new ArrayList<>();
  19.         for (Integer number : numbers) {
  21.             if (number % 2 == 0) {
  23.                 result.add(number);
  24.             }
  25.         }
  26.         return result;
  27.     }
  28. }

在这个例子中，我们有两个不同的方法来过滤一组数据，但是基本的循环和条件判断逻辑是重复的,我们可以使用使用函数式接口和Lambda表达式,去除重复代码,如下:

  1. public class DataFilter {
  3.     public List<Integer> filterNumbers(List<Integer> numbers, Predicate<Integer> predicate) {
  5.         List<Integer> result = new ArrayList<>();
  6.         for (Integer number : numbers) {
  8.             if (predicate.test(number)) {
  10.                 result.add(number);
  11.             }
  12.         }
  13.         return result;
  14.     }
  15. }

我们将过滤的核心逻辑抽象出来。该方法接受一个 Predicate函数式接口作为参数，以便根据不同的条件来过滤数据。然后，我们可以使用Lambda表达式来传递具体的条件,这样最终也达到去除重复代码的效果啦.

发表评论

表情：
评论列表 （有 0 条评论，84人围观）

还没有评论，来说两句吧...

相关阅读

    相关 优化重复冗余代码的8种方式！

    前言 日常开发中，我们经常会遇到一些重复冗余的代码。大家都知道重复代码不好，它主要有这些缺点：可维护性差、可读性差、增加错误风险等等。最近呢，我优化了一些系统中的重复代码

    墨蓝墨蓝/ 0 赞/ 159 阅读