Miscellaneous: MVC/MVP/MVVM (Part 1)

Miscellaneous: MVC/MVP/MVVM (Part 1)

Preface

This article is written to answer a friend's question about the MVC/MVP/MVVM architecture. It aims to introduce the design ideas of the three architectures of MVC/MVP/MVVM under iOS as well as their respective advantages and disadvantages.

MVC

  • MVC related concepts

MVC first existed in desktop programs. M refers to business data, V refers to user interface, and C is the controller. In specific business scenarios, C is the connection between M and V, responsible for obtaining input business data, and then outputting the processed data to the interface for corresponding display. In addition, when the data is updated, C also needs to submit the corresponding update to the interface for display in a timely manner. In the above process, because M and V are completely isolated, when switching business scenarios, usually only the corresponding C needs to be replaced, and the existing M and V can be reused to quickly build a new business scenario. MVC has greatly improved development efficiency due to its reusability, and has now been widely used in various terminal development.

Now that we have gone through the concepts, let's take a look at how MVC/MVP/MVVM behaves in specific business scenarios.

  • MVC's Disappearing C Layer

I believe that many of you have created the page (business scenario) in the figure above or similar pages. The specific implementation methods of each programmer may be different. Here are some of the programmers' writing methods that I have seen:

  1.  //UserVC 
  2.  
  3.  - (void)viewDidLoad { 
  4.  
  5.  [super viewDidLoad]; 
  6.  
  7.   
  8.  
  9.     [[UserApi new] fetchUserInfoWithUserId:132 completionHandler:^(NSError *error, id result) { 
  10.  
  11.  if (error) { 
  12.  
  13.  [self showToastWithText:@ "Failed to obtain user information~" ]; 
  14.  
  15.  } else { 
  16.  
  17.   
  18.  
  19.             self.userIconIV.image = ... 
  20.  
  21.             self.userSummaryLabel.text = ... 
  22.  
  23.  ... 
  24.  
  25.  } 
  26.  
  27.  }]; 
  28.  
  29.   
  30.  
  31.     [[userApi new] fetchUserBlogsWithUserId:132 completionHandler:^(NSError *error, id result) { 
  32.  
  33.  if (error) { 
  34.  
  35.             [self showErrorInView:self.tableView info:...]; 
  36.  
  37.  } else { 
  38.  
  39.   
  40.  
  41.             [self.blogs addObjectsFromArray:result]; 
  42.  
  43.             [self.tableView reloadData]; 
  44.  
  45.  } 
  46.  
  47.  }]; 
  48.  
  49.  } 
  50.  
  51.  //...slightly 
  52.  
  53.  - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { 
  54.  
  55.     BlogCell *cell = [tableView dequeueReusableCellWithIdentifier:@ "BlogCell" ]; 
  56.  
  57.     cell.blog = self.blogs[indexPath.row]; 
  58.  
  59.  return cell; 
  60.  
  61.  } 
  62.  
  63.   
  64.  
  65.  - (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath { 
  66.  
  67.     [self.navigationController pushViewController:[BlogDetailViewController instanceWithBlog:self.blogs[indexPath.row]] animated:YES]; 
  68.  
  69.  } 
  70.  
  71.  //...slightly 
  72.  
  73.  
  74.  //BlogCell 
  75.  
  76.  - (void)setBlog:(Blog)blog { 
  77.  
  78.  _blog = blog; 
  79.  
  80.   
  81.  
  82.     self.authorLabel.text = blog.blogAuthor; 
  83.  
  84.     self.likeLebel.text = [NSString stringWithFormat:@ "Like %ld" , blog.blogLikeCount]; 
  85.  
  86.  ... 
  87.  
  88.  }

The programmer quickly finished writing the code, pressed Command+R, and ran it. There was no problem, so he went to do other things with satisfaction. Later one day, the product required that this business be modified. When the user viewed other people's information, the page in the above picture was displayed. When viewing their own information, there was an additional draft box display, like this:

So Xiaobai changed the code to this:

  1.  //UserVC 
  2.  
  3.  - (void)viewDidLoad { 
  4.  
  5.  [super viewDidLoad]; 
  6.  
  7.   
  8.  
  9.     if (self.userId != LoginUserId) { 
  10.  
  11.         self.switchButton.hidden = self.draftTableView.hidden = YES; 
  12.  
  13.         self.blogTableView.frame = ... 
  14.  
  15.  } 
  16.  
  17.   
  18.  
  19.     [[UserApi new] fetchUserI... slightly 
  20.  
  21.     [[UserApi new] fetchUserBlogsWithUserId:132 completionHandler:^(NSError *error, id result) { 
  22.  
  23.  //if Error...omitted 
  24.  
  25.         [self.blogs addObjectsFromArray:result]; 
  26.  
  27.         [self.blogTableView reloadData]; 
  28.  
  29.   
  30.  
  31.  }]; 
  32.  
  33.   
  34.  
  35.     [[userApi new] fetchUserDraftsWithUserId:132 completionHandler:^(NSError *error, id result) { 
  36.  
  37.  //if Error...omitted 
  38.  
  39.         [self.drafts addObjectsFromArray:result]; 
  40.  
  41.         [self.draftTableView reloadData]; 
  42.  
  43.  }]; 
  44.  
  45.  } 
  46.  
  47.   
  48.  
  49.  - (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger) section { 
  50.  
  51.  return tableView == self.blogTableView ? self.blogs. count : self.drafts. count ; 
  52.  
  53.  } 
  54.  
  55.   
  56.  
  57.  //...slightly 
  58.  
  59.  - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { 
  60.  
  61.   
  62.  
  63.     if (tableView == self.blogTableView) { 
  64.  
  65.         BlogCell *cell = [tableView dequeueReusableCellWithIdentifier:@ "BlogCell" ]; 
  66.  
  67.         cell.blog = self.blogs[indexPath.row]; 
  68.  
  69.  return cell; 
  70.  
  71.  } else { 
  72.  
  73.         DraftCell *cell = [tableView dequeueReusableCellWithIdentifier:@ "DraftCell" ]; 
  74.  
  75.         cell.draft = self.drafts[indexPath.row]; 
  76.  
  77.  return cell; 
  78.  
  79.  } 
  80.  
  81.  } 
  82.  
  83.   
  84.  
  85.  - (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath { 
  86.  
  87.     if (tableView == self.blogTableView) ... 
  88.  
  89.  } 
  90.  
  91.  //...slightly 
  92.  
  93.  
  94.  //DraftCell 
  95.  
  96.  - (void)setDraft:(draft)draft { 
  97.  
  98.  _draft = draft; 
  99.  
  100.  self.draftEditDate = ... 
  101.  
  102.  } 
  103.  
  104.   
  105.  
  106.  //BlogCell 
  107.  
  108.  - (void)setBlog:(Blog)blog { 
  109.  
  110.  ...same as above 
  111.  
  112.  }

Later, the product developer thought it would be nice to have a recycle bin for users to view their own pages, so the programmer added a piece of code logic, and then...

As requirements change, UserVC becomes more and more bloated, more and more difficult to maintain, and has poor scalability and testability. Programmers also find that there seems to be some problems with the code, but where exactly is the problem? Isn't this MVC?

We use a diagram to represent the above process:

From this picture, we can see that the user information page, as a business scene Scene, needs to display multiple data M (Blog/Draft/UserInfo), so there are multiple Views (blogTableView/draftTableView/image...), but there is no connection layer C between each MV. The logic that should have been distributed to each C layer is all packaged and thrown into the Scene for processing, that is, MCV becomes MM...-Scene-...VV, and the C layer disappears inexplicably.

In addition, the two cells of V are directly coupled to M (blog/draft), which means that the inputs of the two Vs are tied to the corresponding M, and reuse is out of the question.

***, the test for this business scenario is extremely troublesome, because the business initialization and destruction are bound to the life cycle of VC, and the corresponding logic is also related to the click event of View. The test can only be done by Command+R, click click click...

  • Correct MVC usage posture

Maybe the class name of UIViewController confuses newcomers, making them think that VC must be the C layer in MVC, or maybe Views like Button and Label are too simple and do not need a C layer to cooperate with them. In short, I have seen too many such "MVC" in the projects I have worked on. So, what is the correct way to use MVC?

Still taking the above business scenario as an example, the correct MVC should look like this:

As a business scenario, UserVC needs to display three types of data, corresponding to which there are three MVCs. These three MVCs are responsible for data acquisition, data processing and data display of their respective modules. What UserVC needs to do is to configure these three MVCs and notify their respective C layers to acquire data at the right time. After each C layer gets the data, it will process it accordingly and render it to its own View after processing. UserVC*** will lay out the rendered Views. The specific code is as follows:

  1.  @interface BlogTableViewHelper : NSObject 
  2.  
  3.   
  4.  
  5.  + (instancetype)helperWithTableView:(UITableView *)tableView userId:(NSUInteger)userId; 
  6.  
  7.   
  8.  
  9.  - (void)fetchDataWithCompletionHandler:(NetworkTaskCompletionHander)completionHander; 
  10.  
  11.  - (void)setVCGenerator:(ViewControllerGenerator)VCGenerator; 
  12.  
  13.   
  14.  
  15.  @ end   
  16.  
  17.  
  18.  @interface BlogTableViewHelper() 
  19.  
  20.   
  21.  
  22.  @property (weak, nonatomic) UITableView *tableView; 
  23.  
  24.  @property (copy, nonatomic) ViewControllerGenerator VCGenerator; 
  25.  
  26.   
  27.  
  28.  @property (assign, nonatomic) NSUInteger userId; 
  29.  
  30.  @property (strong, nonatomic) NSMutableArray *blogs; 
  31.  
  32.  @property (strong, nonatomic) UserAPIManager *apiManager; 
  33.  
  34.   
  35.  
  36.  @ end   
  37.  
  38.  #define BlogCellReuseIdentifier @ "BlogCell"   
  39.  
  40.  @implementation BlogTableViewHelper 
  41.  
  42.   
  43.  
  44.  + (instancetype)helperWithTableView:(UITableView *)tableView userId:(NSUInteger)userId { 
  45.  
  46.  return [[BlogTableViewHelper alloc] initWithTableView:tableView userId:userId]; 
  47.  
  48.  } 
  49.  
  50.   
  51.  
  52.  - (instancetype)initWithTableView:(UITableView *)tableView userId:(NSUInteger)userId { 
  53.  
  54.     if (self = [super init]) { 
  55.  
  56.   
  57.  
  58.  self.userId = userId; 
  59.  
  60.         tableView.delegate = self; 
  61.  
  62.         tableView.dataSource = self; 
  63.  
  64.         self.apiManager = [UserAPIManager new]; 
  65.  
  66.         self.tableView = tableView; 
  67.  
  68.   
  69.  
  70.         __weak typeof(self) weakSelf = self; 
  71.  
  72.         [tableView registerClass:[BlogCell class] forCellReuseIdentifier:BlogCellReuseIdentifier]; 
  73.  
  74.  tableView.header = [MJRefreshAnimationHeader headerWithRefreshingBlock:^{//Pull down to refresh 
  75.  
  76.                [weakSelf.apiManage refreshUserBlogsWithUserId:userId completionHandler:^(NSError *error, id result) { 
  77.  
  78.  //...omitted 
  79.  
  80.  }]; 
  81.  
  82.  }]; 
  83.  
  84.  tableView.footer = [MJRefreshAnimationFooter headerWithRefreshingBlock:^{//Pull up to load 
  85.  
  86.                 [weakSelf.apiManage loadMoreUserBlogsWithUserId:userId completionHandler:^(NSError *error, id result) { 
  87.  
  88.  //...omitted 
  89.  
  90.  }]; 
  91.  
  92.  }]; 
  93.  
  94.  } 
  95.  
  96.  return self; 
  97.  
  98.  } 
  99.  
  100.   
  101.  
  102.  #pragma mark - UITableViewDataSource && Delegate 
  103.  
  104.  //...slightly 
  105.  
  106.  - (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger) section { 
  107.  
  108.  return self.blogs.count ;​ 
  109.  
  110.  } 
  111.  
  112.   
  113.  
  114.  - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath { 
  115.  
  116.   
  117.  
  118.     BlogCell *cell = [tableView dequeueReusableCellWithIdentifier:BlogCellReuseIdentifier]; 
  119.  
  120.     BlogCellHelper *cellHelper = self.blogs[indexPath.row]; 
  121.  
  122.     if (!cell.didLikeHandler) { 
  123.  
  124.         __weak typeof(cell) weakCell = cell; 
  125.  
  126.         [cell setDidLikeHandler:^{ 
  127.  
  128.             cellHelper.likeCount += 1; 
  129.  
  130.             weakCell.likeCountText = cellHelper.likeCountText; 
  131.  
  132.  }]; 
  133.  
  134.  } 
  135.  
  136.     cell.authorText = cellHelper.authorText; 
  137.  
  138.  //...various settings 
  139.  
  140.  return cell; 
  141.  
  142.  } 
  143.  
  144.   
  145.  
  146.  - (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath { 
  147.  
  148.     [self.navigationController pushViewController:self.VCGenerator(self.blogs[indexPath.row]) animated:YES]; 
  149.  
  150.  } 
  151.  
  152.   
  153.  
  154.  #pragma mark - Utils 
  155.  
  156.   
  157.  
  158.  - (void)fetchDataWithCompletionHandler:(NetworkTaskCompletionHander)completionHander { 
  159.  
  160.   
  161.  
  162.     [[UserAPIManager new] refreshUserBlogsWithUserId:self.userId completionHandler:^(NSError *error, id result) { 
  163.  
  164.  if (error) { 
  165.  
  166.             [self showErrorInView:self.tableView info:error.domain]; 
  167.  
  168.  } else { 
  169.  
  170.   
  171.  
  172.  for (Blog *blog in result) { 
  173.  
  174.                 [self.blogs addObject:[BlogCellHelper helperWithBlog:blog]]; 
  175.  
  176.  } 
  177.  
  178.             [self.tableView reloadData]; 
  179.  
  180.  } 
  181.  
  182.       completionHandler ? completionHandler(error, result) : nil; 
  183.  
  184.  }]; 
  185.  
  186.  } 
  187.  
  188.  //...slightly 
  189.  
  190.  @ end   
  191.  
  192.  
  193.  @implementation BlogCell 
  194.  
  195.  //...slightly 
  196.  
  197.  - (void)onClickLikeButton:(UIButton *)sender { 
  198.  
  199.     [[UserAPIManager new] likeBlogWithBlogId:self.blogId userId:self.userId completionHandler:^(NSError *error, id result) { 
  200.  
  201.  if (error) { 
  202.  
  203.  //do error 
  204.  
  205.  } else { 
  206.  
  207.  //do success 
  208.  
  209.             self.didLikeHandler ? self.didLikeHandler() : nil; 
  210.  
  211.  } 
  212.  
  213.  }]; 
  214.  
  215.  } 
  216.  
  217.  @ end   
  218.  
  219.  
  220.  @implementation BlogCellHelper 
  221.  
  222.   
  223.  
  224.  - (NSString *)likeCountText { 
  225.  
  226.  return [NSString stringWithFormat:@ "Like %ld" , self.blog.likeCount]; 
  227.  
  228.  } 
  229.  
  230.  //...slightly 
  231.  
  232.  - (NSString *)authorText { 
  233.  
  234.  return [NSString stringWithFormat:@ "Author name: %@" , self.blog.authorName]; 
  235.  
  236.  } 
  237.  
  238.  @ end  

The Blog module consists of BlogTableViewHelper (C), BlogTableView (V), and Blogs (C). There is something special here. Blogs does not contain M, but CellHelper, the C layer of Cell. This is because the MVC of Blog is actually composed of multiple smaller MVCs. There is nothing much to say about M and V. Let's mainly talk about what TableVIewHelper, which is C, does.

In actual development, the View of each module may be newly created and laid out in the Storyboard corresponding to the Scene. In this case, each module does not need to create its own View (such as BlogTableViewHelper here), and the Scene can be passed to the C layer for management. Of course, if you use pure code, the View needs to be created by the corresponding module itself (such as UserInfoViewController below). This depends on your own wishes and is harmless.

BlogTableViewHelper provides external interfaces for obtaining data and necessary construction methods, and performs corresponding initialization based on its own situation.

When the fetchData interface is called externally, Helper will start the data acquisition logic. Because some page displays (such as HUD) may be involved before and after data acquisition, and the specific display is directly related to the Scene (some Scenes display HUD, some may display another style or not display at all), so this part will be handled by the Scene itself in the form of CompletionHandler.

Inside Helper, if data acquisition fails, the corresponding error page will be displayed. If data acquisition succeeds, a smaller MVC part will be created and notified to display data (that is, to notify CellHelper to drive Cell). In addition, the pull-up refresh and pull-down load logic of TableView also belongs to the Blog module, so it is also handled in Helper.

In the page jump logic, the page to jump to is directly configured by the Scene through VCGeneratorBlock, so it is also decoupled (you can also pass data to the Scene layer through methods such as didSelectRowHandler, and let the Scene do the jump, which is the same).

***, V(Cell) now only exposes the Set method for external settings, so it is isolated from M(Blog), and there is no problem with reuse.

This series of processes are self-managed. In the future, if the Blog module will be displayed in another SceneX, SceneX only needs to create a new BlogTableViewHelper and then call helper.fetchData.

The logic of DraftTableViewHelper and BlogTableViewHelper is similar, so I won’t post them here. I will simply post the logic of the UserInfo module:

  1.  @implementation UserInfoViewController 
  2.  
  3.   
  4.  
  5.  + (instancetype)instanceUserId:(NSUInteger)userId { 
  6.  
  7.  return [[UserInfoViewController alloc] initWithUserId:userId]; 
  8.  
  9.  } 
  10.  
  11.   
  12.  
  13.  - (instancetype)initWithUserId:(NSUInteger)userId { 
  14.  
  15.  // ...omitted 
  16.  
  17.  [self addUI]; 
  18.  
  19.  // ...omitted 
  20.  
  21.  } 
  22.  
  23.   
  24.  
  25.  #pragma mark - Action   
  26.  
  27.   
  28.  
  29.  - (void)onClickIconButton:(UIButton *)sender { 
  30.  
  31.     [self.navigationController pushViewController:self.VCGenerator(self. user ) animated:YES]; 
  32.  
  33.  } 
  34.  
  35.   
  36.  
  37.  #pragma mark - Utils 
  38.  
  39.   
  40.  
  41.  - (void)addUI { 
  42.  
  43.   
  44.  
  45.  // Various UI initialization various layouts 
  46.  
  47.     self.userIconIV = [[UIImageView alloc] initWithFrame:CGRectZero]; 
  48.  
  49.     self.friendCountLabel = ... 
  50.  
  51.  ... 
  52.  
  53.  } 
  54.  
  55.   
  56.  
  57.  - (void)fetchData { 
  58.  
  59.   
  60.  
  61.     [[UserAPIManager new] fetchUserInfoWithUserId:self.userId completionHandler:^(NSError *error, id result) { 
  62.  
  63.  if (error) { 
  64.  
  65.             [self showErrorInView:self. view info:error.domain]; 
  66.  
  67.  } else { 
  68.  
  69.   
  70.  
  71.             self.user = [ User objectWithKeyValues:result]; 
  72.  
  73.  self.userIconIV.image = [UIImage imageWithURL:[NSURL URLWithString:self. user .url]]; //Data formatting 
  74.  
  75.  self.friendCountLabel.text = [NSString stringWithFormat:@ "Like %ld" , self. user .friendCount]; //Data formatting 
  76.  
  77.  ... 
  78.  
  79.  } 
  80.  
  81.  }]; 
  82.  
  83.  } 
  84.  
  85.   
  86.  
  87.  @ end  

UserInfoViewController has more addUI subcontrol layout methods than the two TableViewHelpers, but the rest of the logic is similar. It is also a self-managed MVC and can be used in any Scene after only initialization.

Now that the three self-management modules have been built, UserVC only needs to assemble them according to its own situation, just like building blocks.

As a business scene, Scene (UserVC) does very simple things. It configures (configuration), lays out (addUI) the three modules according to its own situation, and then notifies each module to start (fetchData). Because the display and interaction of each module are self-managed, Scene only needs to be responsible for the parts that are strongly related to its own business. In addition, we create a UserVC subclass SelfVC for self-access, which does similar things.

That’s about it for MVC. Compared with the wrong MVC method above, let’s see what problems are solved:

1. Code reuse: The V (cell/userInfoView) of the three small modules only exposes the Set method to the outside, and is isolated from M and even C, so there is no problem with reuse. The MVC of the three large modules can also be used to quickly build similar business scenarios (the reuse of large modules is worse than that of small modules, which I will explain below).

2. Code bloat: Because most of the logic and layout of the Scene have been transferred to the corresponding MVC, we only assembled MVC to build two different business scenes. Each business scene can display the corresponding data normally and has corresponding logical interactions. To complete these things, it only takes about 100 lines of code with spaces (of course, I ignored the layout code of the Scene here).

3. Easy to expand: Whether the product wants to add a recycling bin or a defense tower in the future, all I need to do is create a corresponding MVC module and add it to the corresponding Scene.

4. Maintainability: The responsibilities of each module are separated. If there is an error, it can be fixed there without affecting other modules. In addition, the code of each module is not much. Even if the code writer leaves one day, the person who takes over can quickly locate the error module according to the error prompt.

5. Testability: Unfortunately, the initialization of the business is still bound to the life cycle of the Scene, and some logic still needs to be triggered by UI click events. We can still only press Command+R, click click...

  • Disadvantages of MVC

As you can see, even the standard MVC architecture is not perfect, and there are still some problems that are difficult to solve. So what are the shortcomings of MVC? The summary is as follows:

1. Excessive emphasis on isolation: In fact, the MV(x) series all have this shortcoming. In order to achieve complete isolation of the V layer, V only exposes Set methods to the outside world. Generally, there is no problem, but when there are many properties that need to be set, it is still very tiring to write a large number of repeated Set methods.

2. Strong coupling between business logic and business display: As you can see, some business logic (page jump/like/share...) is directly scattered in the V layer, which means that when we test these logics, we must first generate the corresponding V before we can test. Obviously, this is unreasonable. Because the business logic ultimately changes the data M, our focus should be on M, not the V that displays M.

<<:  Get in the right posture and see the practical ideas of Google's god-level deep learning framework TensorFlow

>>:  Custom View-Imitate the reward button of the Hupu live broadcast game interface

Recommend

It’s cold, do you feel the static electricity?

In our daily life, you must have felt static elec...

Justill Poster Color Lab Bootcamp 2.0

Justill Poster Color Lab Training Camp 2.0 Resour...

Coral fleece and milk fleece, I finally know how to choose!

(Pictures from the Internet) In fact, it is not j...

1000 top landing pages, 5 conversion rate optimization tips

Conversion is the key factor in paid promotion . ...

Based on these six criteria, they invested in Zhubajie, which is valued at 10 billion yuan.

Why is "white-collar women aged 18-35" ...

How to monetize short videos in the medical and health field?

In the past few months, we have participated in t...

Analysis of the regularity of Douyin's popular cases: "Your Little Sweetie" is now worth 500,000

There are many cases of people becoming famous ov...

Want to upgrade to iPhone 7? It’s not too late to check these minor issues before buying

With the global release of iPhone 7 and iPhone 7 ...

Can Huawei HMS replace Google's GMS? Check out the test by foreign media

introduction [[319525]] Google's GMS? Check o...

Winning in design, high-end and classy or low-key and luxurious with connotation – iteration vs. planning

[[141348]] Mobile game design concepts typically ...

No matter how much you calculate, don’t miss this trillion-dollar opportunity!

Mixed Knowledge Specially designed to cure confus...

From 0 to 1, make a 100-like Xiaohongshu note!

How to continue to gain traffic for Xiaohongshu N...

Is it more energy-efficient to use the dehumidification mode of the air conditioner? How should I choose from so many modes? Read this article today to find out!

gossip Some people say that the air conditioner c...

Wrong posture will ruin your cervical spine! Huaxi doctors: 3 tips to stay away from cervical spondylosis! Save your "stiff neck"

Now the adults are at work and the kids are doing...

Xue Xun: The Strategic Pivot for Great Brands

Xue Xun's "Strategic Pivot for Great Bra...