Why do most systemd examples contain WantedBy=multi-user.target?
1.) multi-user.target is basically the closest equivalent of classic SysVinit runlevel 3 that systemd has. When a systemd system boots up, systemd is trying to make the system state match the state specified by default.target - which is usually an alias for either graphical.target or multi-user.target.
multi-user.target normally defines a system state where all network services are started up and the system will accept logins, but a local GUI is not started. This is the typical default system state for server systems, which might be rack-mounted headless systems in a remote server room.
graphical.target is another possible alias for default.target. Normally it's defined as a superset of the multi-user.target: it includes everything the multi-user.target does, plus the activation of a local GUI login. So kind of like runlevel 5 in classic SysVinit.
The line WantedBy=multi-user.target in a service is essentially the same as specifying "this service should start in runlevels 3, 4 and 5" in SysVinit systems: it tells systemd that this service should be started as part of normal system start-up, whether or not a local GUI is active.
However, WantedBy is separate from the enabled/disabled state: so in another sense, it's sort of a "preset": it determines under what conditions the automatic start may happen, but only when the service is enabled in the first place.
2.) if you omit the WantedBy=multi-user.target line and no other enabled service includes a Requires=your.service or Wants=your.service in its service definition, your service will not be started automatically.
systemd works on dependencies, and at boot time, if nothing Requires or Wants your service, it won't be started even if the service is enabled.
Sure, you could edit your default.target to add or delete Requires or Wants lines for any services you want started at boot time - but so that you can just drop a new service file into the system and have it work by default (which makes things very easy for software package managers), systemd has the WantedBy and RequiredBy keywords which can be used to insert Wants and Requires-type dependencies (respectively) from "the other end".
3.) You should omit the line if you don't want the service to be ever started automatically at boot time, or this service is a part of a chain of dependencies you've defined explicitly.
For example, you might be refactoring server application A and for some reason or another decide to split some optional functionality off it into a separate service B, to allow the user the choice of not installing it if it isn't needed. You could then make service B a separate service-B.rpm, and define B.service with WantedBy=A.service to make systemd start up service B automatically whenever service A is started - but only when service-B.rpm is actually installed.
Note that a Wants or WantedBy only says that the system should startup one service whenever another service or target is also started, but it specifies nothing at all about the startup/shutdown order. If you need service B to be already running when service A starts up, you'd need to add Before=A.service in the B.service file to explicitly specify the start-up order dependency.
4.) Anytime you do want the service to have the capability of being started automatically at boot time, and there are no other dependencies already defined.
If you remove WantedBy=multi-user.target, then systemctl enable your-example-here will (noisily) fail to do anything.
graphical.target
If you install pure systemd from the source, the "default target" that it boots to is graphical.target.
Starting graphical.target starts multi-user.target, plus whatever unit(s) are required to provide a graphical user interface. This extra complexity was arranged in an attempt to emulate legacy "runlevels".
You really should ignore / gloss over the "runlevel" emulation; it does not work correctly anyway. Sorry! I guess the reason for emphasizing "graphical" v.s. "multi-user" historically is that graphics software is 1) not as robust and mature as the rest of the system and 2) requires a lot of resources.
Typically only a few units are specific to graphical.target. There is a single service for the GUI itself like gdm.target. There are a few support services that are mostly used by the GUI here as well.
Edit: Googling suggests that if you don't have a GUI installed, but the "default target" has been left as graphical.target, then systemd might log a warning. "Cannot add dependency job for unit display-manager.service, ignoring: Unit display-manager.service failed to load: No such file or directory." We want to avoid littering our logs with unnecessary warnings. So if you did not install a GUI, it is good to use systemctl set-default multi-user. Although the install system for your OS might have taken care of this for you already. Other than that, I am strongly in favour of apathy in this matter :-).
sysinit.target
Some services and other types of units are "involved in early boot". They are defined to start Before=sysinit.target - either directly or indirectly. Most services are only started After=sysinit.target - this is automatically the case, unless the service sets DefaultDependencies=no.
multi-user.target
Most example services do not fall under either of the above categories, therefore we attach them to multi-user.target. This includes most network services (e.g. a web server), which are the archetypal system service.
dynamically activated services
Another possibility you might see, is a service unit that is not started automatically at boot. So it would not need WantedBy=multi-user.target. The service can instead be triggered or "activated" by something else.
One example of this is a dbus activated service. Dbus can be configured to start your service on-demand, when a dbus call is made to the service.
For network services, you can use socket-activated services. This might be easier to find details about, because all the configuration is in systemd units. For example sshd.socket or ssh.socket is typically available to activate [email protected] or [email protected]. Although, I think it is more common to start the sshd service at boot time.
As always, the above simplifies and omits details which did not seem to be required.