Yesterday, a friend told me that he needed to simulate interviews and establish in-depth optimization. However, I remember that he only joined the job last month, so why did he start looking for a job again? After chatting with him for a while, I found out that he was fired and the code he wrote was like a piece of shit. Damn, it's a pity that I finally found a job.
In fact, the biggest difference between software engineers and coders is their habits when writing code. Coders like to write repeated code, while software engineers will use various techniques to eliminate repeated and redundant code.
Business students complained that business development has no technical content and does not use design patterns, Java advanced features, and OOP. They usually write code and pile on CRUD, making personal growth impossible.
Actually, I think that’s not the case. Design patterns and OOP are the experiences accumulated by predecessors in large-scale projects. These methodologies are used to improve the maintainability of large-scale projects. The reason why advanced features such as reflection, annotations, and generics are widely used in frameworks is that frameworks often need to use the same set of algorithms to deal with different data structures, and these features can help reduce duplication of code and improve project maintainability.
In my opinion, maintainability is an important indicator of the maturity of large projects, and a very important way to improve maintainability is to reduce code duplication. So why do you say this?
If the code is repeated in multiple places to achieve the exact same function, it is easy to modify one place and forget to modify the other, resulting in bugs
There are some The codes are not completely duplicated, but are very similar. It is easy to make mistakes (copy and paste) when modifying these similar codes, making the original differences the same.
Today, I will start with the three most common requirements in business code and talk about how to use some advanced features, design patterns, and some tools in Java to eliminate duplicate code. Both elegant and high-end. Through today's study, I also hope to change your view that business code has no technical content.
1. Use the factory pattern template method pattern to eliminate if...else and duplicate codes
Suppose you want to develop a shopping cart order function , different treatments are performed for different users:
Ordinary users need to charge shipping fees, which are 10% of the product price, and there is no product discount;
VIP users also need to charge a courier fee of 10% of the product price, but when purchasing two or more of the same product, the third item will start to enjoy a certain discount;
#Internal users can enjoy free shipping, no products Discount.
Our goal is to implement three types of shopping cart business logic and convert the input parameter Map object (Key is the product ID, Value is the product quantity) into the output shopping cart type Cart.
First implement the shopping cart processing logic for ordinary users:
//购物车
@Data
public class Cart {
//商品清单
private List<Item> items = new ArrayList<>();
//总优惠
private BigDecimal totalDiscount;
//商品总价
private BigDecimal totalItemPrice;
//总运费
private BigDecimal totalDeliveryPrice;
//应付总价
private BigDecimal payPrice;
}
//购物车中的商品
@Data
public class Item {
//商品ID
private long id;
//商品数量
private int quantity;
//商品单价
private BigDecimal price;
//商品优惠
private BigDecimal couponPrice;
//商品运费
private BigDecimal deliveryPrice;
}
//普通用户购物车处理
public class NormalUserCart {
public Cart process(long userId, Map<Long, Integer> items) {
Cart cart = new Cart();
//把Map的购物车转换为Item列表
List<Item> itemList = new ArrayList<>();
items.entrySet().stream().forEach(entry -> {
Item item = new Item();
item.setId(entry.getKey());
item.setPrice(Db.getItemPrice(entry.getKey()));
item.setQuantity(entry.getValue());
itemList.add(item);
});
cart.setItems(itemList);
//处理运费和商品优惠
itemList.stream().forEach(item -> {
//运费为商品总价的10%
item.setDeliveryPrice(item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity())).multiply(new BigDecimal("0.1")));
//无优惠
item.setCouponPrice(BigDecimal.ZERO);
});
//计算商品总价
cart.setTotalItemPrice(cart.getItems().stream().map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()))).reduce(BigDecimal.ZERO, BigDecimal::add));
//计算运费总价
cart.setTotalDeliveryPrice(cart.getItems().stream().map(Item::getDeliveryPrice).reduce(BigDecimal.ZERO, BigDecimal::add));
//计算总优惠
cart.setTotalDiscount(cart.getItems().stream().map(Item::getCouponPrice).reduce(BigDecimal.ZERO, BigDecimal::add));
//应付总价=商品总价+运费总价-总优惠
cart.setPayPrice(cart.getTotalItemPrice().add(cart.getTotalDeliveryPrice()).subtract(cart.getTotalDiscount()));
return cart;
}
}
Copy after login
Then implement the shopping cart logic for VIP users. The difference from the shopping cart logic of ordinary users is that VIP users can enjoy discounts for buying more of the same product. Therefore, this part of the code only requires additional processing of the multi-buy discount part:
Finally, there is free shipping and no discount for internal users. It is also just a logical difference in processing product discounts and shipping costs:
public class InternalUserCart {
public Cart process(long userId, Map<Long, Integer> items) {
...
itemList.stream().forEach(item -> {
//免运费
item.setDeliveryPrice(BigDecimal.ZERO);
//无优惠
item.setCouponPrice(BigDecimal.ZERO);
});
...
return cart;
}
}
Copy after login
Comparing the amount of code, we can find that 70% of the codes in the three shopping carts are repeated. The reason is simple. Although different types of users calculate shipping costs and discounts in different ways, the logic of initializing the entire shopping cart, counting the total price, total shipping costs, total discounts and payment prices is the same.
As we mentioned at the beginning, code duplication itself is not terrible, what is terrible is missing or making mistakes. For example, a classmate who wrote a VIP user shopping cart discovered that there was a bug in the calculation of the total price of the product. Instead of adding the prices of all Items together, the price*quantity of all Items should be added together.
At this time, he may only modify the code of the VIP user's shopping cart, while ignoring the same bugs in the repeated logic implementation of ordinary users and internal users' shopping carts.
After we have three shopping carts, we need to use different shopping carts according to different user types. As shown in the following code, three ifs are used to realize that different types of users call the process methods of different shopping carts:
@GetMapping("wrong")
public Cart wrong(@RequestParam("userId") int userId) {
//根据用户ID获得用户类型
String userCategory = Db.getUserCategory(userId);
//普通用户处理逻辑
if (userCategory.equals("Normal")) {
NormalUserCart normalUserCart = new NormalUserCart();
return normalUserCart.process(userId, items);
}
//VIP用户处理逻辑
if (userCategory.equals("Vip")) {
VipUserCart vipUserCart = new VipUserCart();
return vipUserCart.process(userId, items);
}
//内部用户处理逻辑
if (userCategory.equals("Internal")) {
InternalUserCart internalUserCart = new InternalUserCart();
return internalUserCart.process(userId, items);
}
return null;
}
Copy after login
The marketing methods of e-commerce are diverse, and there will inevitably be more user types in the future, and more are needed. shopping cart. Can we just keep adding more shopping cart classes, write repetitive shopping cart logic, and write more if logic over and over again?
Of course not, the same code should only appear in one place!
If we memorize the definitions of abstract classes and abstract methods, we may think about whether we can define repeated logic in abstract classes. The three shopping carts only need to implement different logic. Woolen cloth?
In fact, this pattern is the template method pattern. We implemented the shopping cart processing process template in the parent class, and then left blank the areas that required special processing, that is, leaving abstract method definitions, and let the subclass implement the logic. Since the logic of the parent class is incomplete and cannot work alone, it needs to be defined as an abstract class.
ComplicatedOrderDTO orderDTO = new ComplicatedOrderDTO();
ComplicatedOrderDO orderDO = new ComplicatedOrderDO();
BeanUtils.copyProperties(orderDTO, orderDO, "id");
return orderDO;
Copy after login
总结
第一种代码重复是，有多个并行的类实现相似的代码逻辑。我们可以考虑提取相同逻辑在父类中实现，差异逻辑通过抽象方法留给子类实现。使用类似的模板方法把相同的流程和逻辑固定成模板，保留差异的同时尽可能避免代码重复。同时，可以使用 Spring 的 IoC 特性注入相应的子类，来避免实例化子类时的大量 if…else 代码。
The above is the detailed content of The code was terrible and I was fired!. For more information, please follow other related articles on the PHP Chinese website!
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
![[Web front-end] Node.js quick start](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
