can I use uiview as viewcontroller?

I have a uiviewcontroller, it's view has 4 subviews, they don't need communication but need many user interaction and have many many content , but they need many network request to fetch data and refresh them. as the trandional mvc, viewcontroller fetch data and then refresh subviews. I think the viewcontroller is too heavy, can I take the 4 subviews as child viewcontroller, they request the data by themself. Is it a good practise or not ?

plan 1:tranditional MVC

#import "TTViewController.h"

@interface TTViewController ()

@property (nonatomic, strong) id modelA;
@property (nonatomic, strong) id modelB;
@property (nonatomic, strong) id modelC;
@property (nonatomic, strong) id modelD;

@property (nonatomic, strong) CustomView *aView;

@property (nonatomic, strong) CustomView *bView;
@property (nonatomic, strong) CustomView *cView;
@property (nonatomic, strong) CustomView *dView;



@end

@implementation TTViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    [self.view addSubview:self.aView];
    [self.view addSubview:self.bView];
    [self.view addSubview:self.cView];
    [self.view addSubview:self.dView];
    [self reqeustAData];
    [self requetBData];
    [self requestCData];
    [self reqeustDData];
}

- (void)reqeustAData {
    [self.aView  refresh:modelA];
}

- (void)requetBData {
    [self.bView  refresh:modelB];

}

- (void)requestCData {
    [self.cView  refresh:modelC];
}

- (void)reqeustDData {
    [self.dView  refresh:modelD];
}
    #pragma mark - delegate

- (void)delegateAuserAction {
    // handle user's touch when Aview's delegate tell vc
}

- (void)delegateBuserAction {
    // handle user's touch when Bview's delegate tell vc

}

- (void)delegateCuserAction {
    // handle user's touch when Cview's delegate tell vc

}

- (void)delegateDuserAction {
    // handle user's touch when Dview's delegate tell vc
}

@end

plan 2:Take subview as child viewcontroller

#import "TTViewController.h"
#import "CustomView.h"

@interface TTViewController ()

@property (nonatomic, strong) CustomView *aView;
@property (nonatomic, strong) CustomView *bView;
@property (nonatomic, strong) CustomView *cView;
@property (nonatomic, strong) CustomView *dView;

@end

@implementation TTViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self.view addSubview:self.aView];
    [self.view addSubview:self.bView];
    [self.view addSubview:self.cView];
    [self.view addSubview:self.dView];
    [self.aView reqeust];
    [self.bView reqeust];
    [self.cView reqeust];
    [self.dView reqeust];
}

@end


#import "CustomView.h"

@interface CustomView  ()
@property (nonatomic, strong) id model;

@end

@implementation CustomView


- (void)reqeust {
    [self refreshUI:model];
}

- (void)refreshUI:(id)model {
    
}

#pragma mark - handle user action
- (void)handleUserAction {
    // don't delegate to vc, handle it by self
}
@end

You can use container views instead of using multiple views in one view controller.
In this way you can separate your code based on your view controller or view.

you just need to drag number off controllers you want as a view in the storyboard.


Now in your main view controller add containers views in your view to add these controllers in the main view controller


Now in your main view controller create IBOutlets of these container views and in your viewDidLoad add these controllers as child view and set their constraints (you can do this using storyboard as well) 

Your Main view controller class will look like this.

class MainViewController: UIViewController {

    @IBOutlet weak var viewThree: UIView!
    @IBOutlet weak var viewTwo: UIView!
    @IBOutlet weak var viewOne: UIView!
    
    
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        print("Main view Controller Loaded")
        
        //add first view controller
        let controllerOne = storyboard!.instantiateViewController(withIdentifier: "OneViewController") as! OneViewController
        addChild(controllerOne)
        controllerOne.view.translatesAutoresizingMaskIntoConstraints = false
        self.viewOne.addSubview(controllerOne.view)
        
        NSLayoutConstraint.activate([
            controllerOne.view.leadingAnchor.constraint(equalTo: self.viewOne.leadingAnchor, constant: 0),
            controllerOne.view.trailingAnchor.constraint(equalTo: self.viewOne.trailingAnchor, constant: 0),
            controllerOne.view.topAnchor.constraint(equalTo: self.viewOne.topAnchor, constant: 0),
            controllerOne.view.bottomAnchor.constraint(equalTo: self.viewOne.bottomAnchor, constant: 0)
        ])
        controllerOne.didMove(toParent: self)
        
        
        // add second view controller
        let controllerTwo = storyboard!.instantiateViewController(withIdentifier: "TwoViewController") as! TwoViewController
        addChild(controllerTwo)
        controllerTwo.view.translatesAutoresizingMaskIntoConstraints = false
        self.viewTwo.addSubview(controllerTwo.view)
        
        NSLayoutConstraint.activate([
            controllerTwo.view.leadingAnchor.constraint(equalTo: self.viewTwo.leadingAnchor, constant: 0),
            controllerTwo.view.trailingAnchor.constraint(equalTo: self.viewTwo.trailingAnchor, constant: 0),
            controllerTwo.view.topAnchor.constraint(equalTo: self.viewTwo.topAnchor, constant: 0),
            controllerTwo.view.bottomAnchor.constraint(equalTo: self.viewTwo.bottomAnchor, constant: 0)
        ])
        controllerTwo.didMove(toParent: self)
        
        
        // add Third view controller
        let controllerThree = storyboard!.instantiateViewController(withIdentifier: "ThreeViewController") as! ThreeViewController
        addChild(controllerThree)
        controllerThree.view.translatesAutoresizingMaskIntoConstraints = false
        self.viewThree.addSubview(controllerThree.view)
        
        NSLayoutConstraint.activate([
            controllerThree.view.leadingAnchor.constraint(equalTo: self.viewThree.leadingAnchor, constant: 0),
            controllerThree.view.trailingAnchor.constraint(equalTo: self.viewThree.trailingAnchor, constant: 0),
            controllerThree.view.topAnchor.constraint(equalTo: self.viewThree.topAnchor, constant: 0),
            controllerThree.view.bottomAnchor.constraint(equalTo: self.viewThree.bottomAnchor, constant: 0)
        ])
        controllerThree.didMove(toParent: self)
        
    }
}

In the console you can see First MainViewController Loaded and then the others

And you are good to go.

Object / class "naming" can be taken too literally. Don't confuse yourself with UIViewController being the only class that can "control views."

As a very simple example - well, it seems simple to me - let's look at a commonly used view: a UITextField ...

Suppose in my view controller code I add a UITextField as a subview. After that point, maybe in response to a "Submit" button tap, I may:

• get the text of that text field
• do something with the resulting string

But... what does my controller do when the user is editing the field? Do I have code in my controller that says:

• user tapped "A" on the keyboard
• figure out where the insertion point is
• insert "A" into that string
• redraw the text field

No - all of that code is self-contained inside the UITextField view class itself.

So, in your case, you could think in terms of:

• the view controller manages the size/positions of the 4 subviews
• the view controller perhaps sets some initial properties of those 4 subviews
• perhaps at some point the view controller asks each subview for an update of what it has been doing -- or maybe it never needs to.

It is perfectly acceptable for each subview to have its own internal code to handle "doing its own thing."

The trap that people run into - and the reason MVC is stressed - is when they write code in a subview (which is a subview of a subview of a subview...) that relies on a distinct coupling with one or more of its parent views.

TL;DR - if a view has code to manage (control) its subviews, that doesn't mean it has to be a UIViewController class, nor does it mean it violates the MVC pattern.

Edit - in response to comment...

A little searching, and we can find hundreds of articles / discussions about MVC and views vs controllers - far too much to go into here.

But, a quick example...

Suppose I have a view that looks like this:

Each time a color quadrant is tapped, it increases the "number of taps" for that quadrant.

Should I put all of the tap handling and value tracking into my UIViewController holding this view? Or, can I put that inside the UIView itself?

Personally, I would put it inside the view.

Now, suppose I then want to save the values to persistent storage (data file, database, remote db, etc)?

In that case, it would make much more sense to have the view (via protocol/delegate or closure) inform the controller of the changes. The controller would then handle updating the model / storing the data.

It could be argued that I've violated MVC ...

Of course, suppose I have 8 of these views? Would it make more sense to build a big, heavy controller with all of the tap and value tracking logic, and the view itself only, ummm, does nothing?

I'd suggest searching the web for uiviewcontroller vs uiview mvc -- and spend a few days reading all of the different opinions.