View Javadoc

    1   package org.apache.turbine.annotation;
    2
    3
    4   /*
    5    * Licensed to the Apache Software Foundation (ASF) under one
    6    * or more contributor license agreements.  See the NOTICE file
    7    * distributed with this work for additional information
    8    * regarding copyright ownership.  The ASF licenses this file
    9    * to you under the Apache License, Version 2.0 (the
    10   * "License"); you may not use this file except in compliance
    11   * with the License.  You may obtain a copy of the License at
    12   *
    13   *   http://www.apache.org/licenses/LICENSE-2.0
    14   *
    15   * Unless required by applicable law or agreed to in writing,
    16   * software distributed under the License is distributed on an
    17   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    18   * KIND, either express or implied.  See the License for the
    19   * specific language governing permissions and limitations
    20   * under the License.
    21   */
    22
    23
    24  import java.lang.reflect.Field;
    25
    26  import org.apache.commons.configuration.Configuration;
    27  import org.apache.commons.lang.StringUtils;
    28  import org.apache.commons.logging.Log;
    29  import org.apache.commons.logging.LogFactory;
    30  import org.apache.turbine.Turbine;
    31  import org.apache.turbine.modules.Loader;
    32  import org.apache.turbine.services.ServiceManager;
    33  import org.apache.turbine.services.TurbineServices;
    34  import org.apache.turbine.services.assemblerbroker.TurbineAssemblerBroker;
    35  import org.apache.turbine.util.TurbineException;
    36
    37  /**
    38   * AnnotationProcessor contains static helper methods that handle the
    39   * Turbine annotations for objects
    40   *
    41   * @author <a href="mailto:tv@apache.org">Thomas Vandahl</a>
    42   * @version $Id: TurbineAssemblerBrokerService.java 1521103 2013-09-09 13:38:07Z tv $
    43   */
    44  public class AnnotationProcessor
    45  {
    46      /** Logging */
    47      private static Log log
    48              = LogFactory.getLog(AnnotationProcessor.class);
    49
    50      /**
    51       * Search for annotated fields of the object and provide them with the
    52       * appropriate TurbineService
    53       *
    54       * @param object the object
    55       * @throws TurbineException if the service could not be injected
    56       */
    57      public static void process(Object object) throws TurbineException
    58      {
    59          ServiceManager manager = TurbineServices.getInstance();
    60          Class<?> clazz = object.getClass();
    61
    62          while (clazz != null)
    63          {
    64              Field[] fields = clazz.getDeclaredFields();
    65
    66              for (Field field : fields)
    67              {
    68                  if (field.isAnnotationPresent(TurbineService.class))
    69                  {
    70                      TurbineService sa = field.getAnnotation(TurbineService.class);
    71                      String serviceName = null;
    72                      // Check for annotation value
    73                      if (StringUtils.isNotEmpty(sa.value()))
    74                      {
    75                          serviceName = sa.value();
    76                      }
    77                      // Check for fields SERVICE_NAME and ROLE
    78                      else
    79                      {
    80                          Field[] typeFields = field.getType().getFields();
    81                          for (Field f : typeFields)
    82                          {
    83                              if (TurbineService.SERVICE_NAME.equals(f.getName()))
    84                              {
    85                                  try
    86                                  {
    87                                      serviceName = (String)f.get(null);
    88                                  }
    89                                  catch (Exception e)
    90                                  {
    91                                      continue;
    92                                  }
    93                                  break;
    94                              }
    95                              else if (TurbineService.ROLE.equals(f.getName()))
    96                              {
    97                                  try
    98                                  {
    99                                      serviceName = (String)f.get(null);
    100                                 }
    101                                 catch (Exception e)
    102                                 {
    103                                     continue;
    104                                 }
    105                                 break;
    106                             }
    107                         }
    108                     }
    109
    110                     if (StringUtils.isEmpty(serviceName))
    111                     {
    112                         // Try interface class name
    113                         serviceName = field.getType().getName();
    114                     }
    115
    116                     if (log.isDebugEnabled())
    117                     {
    118                         log.debug("Looking up service for injection: " + serviceName + " for object " + object);
    119                     }
    120
    121                     Object service = manager.getService(serviceName); // throws Exception on unknown service
    122                     field.setAccessible(true);
    123
    124                     try
    125                     {
    126                         if (log.isDebugEnabled())
    127                         {
    128                             log.debug("Injection of " + serviceName + " into object " + object);
    129                         }
    130
    131                         field.set(object, service);
    132                     }
    133                     catch (IllegalArgumentException e)
    134                     {
    135                         throw new TurbineException("Could not inject service "
    136                                 + serviceName + " into object " + object, e);
    137                     }
    138                     catch (IllegalAccessException e)
    139                     {
    140                         throw new TurbineException("Could not inject service "
    141                                 + serviceName + " into object " + object, e);
    142                     }
    143                 }
    144                 else if (field.isAnnotationPresent(TurbineConfiguration.class))
    145                 {
    146                     TurbineConfiguration ca = field.getAnnotation(TurbineConfiguration.class);
    147                     Configuration conf = null;
    148
    149                     // Check for annotation value
    150                     if (StringUtils.isNotEmpty(ca.value()))
    151                     {
    152                         conf = Turbine.getConfiguration().subset(ca.value());
    153                     }
    154                     else
    155                     {
    156                         conf = Turbine.getConfiguration();
    157                     }
    158
    159                     field.setAccessible(true);
    160
    161                     try
    162                     {
    163                         if (log.isDebugEnabled())
    164                         {
    165                             log.debug("Injection of " + conf + " into object " + object);
    166                         }
    167
    168                         field.set(object, conf);
    169                     }
    170                     catch (IllegalArgumentException e)
    171                     {
    172                         throw new TurbineException("Could not inject configuration "
    173                                 + conf + " into object " + object, e);
    174                     }
    175                     catch (IllegalAccessException e)
    176                     {
    177                         throw new TurbineException("Could not inject configuration "
    178                                 + conf + " into object " + object, e);
    179                     }
    180                 }
    181                 else if (field.isAnnotationPresent(TurbineLoader.class))
    182                 {
    183                     TurbineLoader la = field.getAnnotation(TurbineLoader.class);
    184                     Loader<?> loader = TurbineAssemblerBroker.getLoader(la.value());
    185                     field.setAccessible(true);
    186
    187                     try
    188                     {
    189                         if (log.isDebugEnabled())
    190                         {
    191                             log.debug("Injection of " + loader + " into object " + object);
    192                         }
    193
    194                         field.set(object, loader);
    195                     }
    196                     catch (IllegalArgumentException e)
    197                     {
    198                         throw new TurbineException("Could not inject loader "
    199                                 + loader + " into object " + object, e);
    200                     }
    201                     catch (IllegalAccessException e)
    202                     {
    203                         throw new TurbineException("Could not inject loader "
    204                                 + loader + " into object " + object, e);
    205                     }
    206                 }
    207             }
    208
    209             clazz = clazz.getSuperclass();
    210         }
    211     }
    212 }