Sample code that briefly introduces the open and closed principles of Java design patterns

This article mainly introduces the open and closed principle of Java design pattern. The editor thinks it is quite good. Now I will share it with you and give you a reference. Let’s follow the editor and take a look.

Written in front

Recently, I took over a new business, and the architecture of the system can Remarkable. But some places are intimidating, and some codes are bloated and difficult to maintain, which makes people unworthy. Therefore, based on the open and closed principle of Java, part of the code was refactored and optimized.

Let’s first look at the old code of the previous system

ShareChannelManager.java

public ResultDO<String> shareChannel(int shareCode) {

  if(ShareCodeUtil.share2A(shareCode)) {
     // TODO, 分享到A渠道的业务逻辑代码
  }

  if(ShareCodeUtil.share2B(shareCode)) {
     // TODO, 分享到B渠道的业务逻辑代码
  }

  ...渠道n...
}

The shareChannel method carries the main link logic of the sharing channel. The code shared to various channels is written in the method of a class, which is very bloated and difficult to maintain. Every time you add a sharing channel, you have to modify this heavyweight method. If your hands are slightly shaking and you make a mistake, it will affect sharing on other channels. At the same time, it also violates the open and closed principle of Java.

Introducing the open and closed principle of Java

The open and closed principle of Java gives people a contradictory feeling at first glance. Why is it closed when it is open? Don't take it at face value. Think from two dimensions, **open** & ***closed**. The open principle of Java means that the designed architecture has good scalability; while the closed principle means that the main link of the system's architecture cannot be significantly changed with business iterations. Even if it happens frequently, it can only mean that there is a problem with the system's architecture. Every system must go through a process from 0 to 1. As the business develops, the system may also remain unchanged. How to make the system's architecture

forward-looking and scalable are technical points that we must think about in daily development. In short, Java's open and closed principle has two characteristics.

1. - Open for extension

2. - Closed for changes

Based on the above-mentioned design principles, how to optimize the above-mentioned issues

The idea is to combine multiple sharing channels into chain calls. Abstract sharing actions and distribute them to various channels for implementation.

Define sharing channel chain

public class ShareChannelChain {  
  private final Logger LOG = LoggerFactory.getLogger(this.getClass());

  /**
   * 分享渠道链
   */
  private List<ShareChannel> shareChannels;
  public ResultDO<String> share(int shareCode) {
    for (ShareChannel s : shareChannels) {
      ResultDO<String> r = s.share(shareCode);
         }
  }

Define sharing channel parent class

public interface ShareChannel {
  public ResultDO<String> share(int shareCod);
}

A channel sharing

public class AChannel implements ShareChannel {

  @Override
  public ResultDO<String> share(int shareCode) {
       // TODO 分享A渠道逻辑
    }
}

B Channel Sharing

public class BChannel implements ShareChannel {

  @Override
  public ResultDO<String> share(int shareCode) {
       // TODO 分享B渠道逻辑
    }
}

Assemble AChannel and BChannel into a call chain ShareChannelChain.

  <bean id="AChannel" class="com.test.AChannel">
  </bean>
  <bean id="BChannel" class="com.test.BChannel">
  </bean>
  <bean id="shareChannelChain" class="com.test.ShareChannelChain">
    <property name="shareChannels">
      <list>
        <ref local="AChannel"/>
        <ref local="BChannel"/>
      </list>
    </property>
  </bean>

Channel Sharing Main

Interface

ShareChannelManager.java

public ResultDO<String> shareChannel(int shareCode) {
    ShareChannelChain.share(shareCode);
}

Finally, let’s review and see what the architecture brings after optimization Benefits

Assuming there is a new channel to share business needs, CChannel, think about the points we want to change. This time there is no need to change the ShareChannelManager core class logic. You only need to expand a CChannel, implement the share method of the ShareChannel interface, and then configure it in xml. The risk of this kind of change can be controlled and does not affect the core class logic.

The above is the detailed content of Sample code that briefly introduces the open and closed principles of Java design patterns. For more information, please follow other related articles on the PHP Chinese website!