I've read that, incorporating many words(spatial locality) per cache blocks leads to lower miss rate. Is it the case always? One possibility of such approach is to make a single cache block of size equal to the size of the cache, but that would be meaningless as far as benefits of memory hierarchy are concerned. Isn't it so?
If you use larger blocks in the cache, it will mean having less blocks available (given fixed cache size). If the blocks are too large, part of them isn't used; if they are too small, there is much traffic loading them.
More than very general statements like the above, it is almost impossible to say anything unless considering some specific memory access traces. Real workloads access memory in definite patterns that moreover change in time. Look up the working set model.
Spatial (and temporal) locality are both heuristics. Many (in fact, most) algorithms run on data structures in some sequential manner, which many times means that the memory used is consecutive.
However, there are examples where spatial locality may actually be very bad. Perhaps the most common example is scanning a 2-dimensional array: consider an $n\times n$ array, then in the memory, it is represented as an $n^2$ length array, where the entry $i,j$ is in cell $i+n*j$.
If you scan the array row by row, then spatial locality is excellent, your cache will always prepare the next row. However, if you scan by column, then not only will you always get a miss, but using spatial locality, you will actually retrieve the same rows over and over.
If you increase the size of the data imported into the cache, it obliterates an equal amount of data that is previously a part of the cache- your cache, at the end of the day, can accommodate only a given number of bytes. Considering the column based access of matrix elements example discussed previously by Shaull, if I make the size of data equal to number of columns that reduces the chance of a miss. However if the number of columns are so big that it can't fit in the cache you still have a miss despite increasing the cache-block size. So in a nutshell, not always but does the job most of the times as there are only a few applications with irregular data patterns and only data-intensive applications can fill up the cache so fastly that it needs to invalidate it's contents entirely for fetching new data. Hope that helps.