title: Advice on Factory Method
body: <p>Using php 5.2, I'm trying to use a factory to return a service to the controller.  My request uri would be of the format www.mydomain.com/service/method/param1/param2/etc.  My controller would then call a service factory using the token sent in the uri.  From what I've seen, there are two main routes I could go with my factory.</p>
  
  <p>Single method:</p>
  
  <pre><code>class ServiceFactory { 
      public static function getInstance($token) { 
          switch($token) { 
              case 'location':
                  return new StaticPageTemplateService('location');
                  break;
              case 'product':
                  return new DynamicPageTemplateService('product');
                  break;
              case 'user'
                  return new UserService();
                  break;
              default:
                  return new StaticPageTemplateService($token);
           }
      }
  }
  </code></pre>
  
  <p>or multiple methods:</p>
  
  <pre><code>class ServiceFactory { 
      public static function getLocationService() { 
          return new StaticPageTemplateService('location');
      }
      public static function getProductService() { 
          return new DynamicPageTemplateService('product');
      }
      public static function getUserService() { 
          return new UserService();
      }
      public static function getDefaultService($token) { 
          return new StaticPageTemplateService($token);
      }
  }
  </code></pre>
  
  <p>So, given this, I will have a handful of generic services in which I will pass that token (for example, StaticPageTemplateService and DynamicPageTemplateService) that will probably implement another factory method just like this to grab templates, domain objects, etc.  And some that will be specific services (for example, UserService) which will be 1:1 to that token and not reused.  So, this seems to be an ok approach (please give suggestions if it is not) for a small amount of services.  But what about when, over time and my site grows, I end up with 100s of possibilities.  This no longer seems like a good approach.  Am I just way off to begin with or is there another design pattern that would be a better fit?  Thanks.</p>
  
  <p>UPDATE: @JSprang - the token is actually sent in the uri like mydomain.com/location would want a service specific to loction and mydomain.com/news would want a service specific to news.  Now, for a lot of these, the service will be generic.  For instance, a lot of pages will call a StaticTemplatePageService in which the token is passed in to the service.  That service in turn will grab the "location" template or "links" template and just spit it back out.  Some will need DynamicTemplatePageService in which the token gets passed in, like "news" and that service will grab a NewsDomainObject, determine how to present it and spit that back out.  Others, like "user" will be specific to a UserService in which it will have methods like Login, Logout, etc.  So basically, the token will be used to determine which service is needed AND if it is generic service, that token will be passed to that service.  Maybe token isn't the correct terminology but I hope you get the purpose. </p>
  
  <p>I wanted to use the factory so I can easily swap out which Service I need in case my needs change.  I just worry that after the site grows larger (both pages and functionality) that the factory will become rather bloated.  But I'm starting to feel like I just can't get away from storing the mappings in an array (like Stephen's solution).  That just doesn't feel OOP to me and I was hoping to find something more elegant.</p>