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

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

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渠道逻辑
    }
}

  <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>

Interface

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

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

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!