Java tutorial
/* * Copyright 2006 - 2007 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.springmodules.xt.model.introductor.bean; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; import org.aopalliance.intercept.MethodInvocation; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.springmodules.xt.model.introductor.AbstractIntroductorInterceptor; import org.springmodules.xt.model.introductor.support.IllegalReturnTypeException; /** * Spring AOP Introduction Interceptor for dynamically constructing JavaBeans style classes with additional setter and getter methods.<br> * * @author Sergio Bossa */ public class BeanIntroductorInterceptor extends AbstractIntroductorInterceptor { private static final Logger logger = Logger.getLogger(BeanIntroductorInterceptor.class); private Map<String, Object> fields = new ConcurrentHashMap(); /** * Constructor. * @param introducedInterfaces The interfaces to introduce. */ public BeanIntroductorInterceptor(Class[] introducedInterfaces) { super(introducedInterfaces); } public Object invoke(MethodInvocation methodInvocation) throws Throwable { Object result = null; Method invokedMethod = methodInvocation.getMethod(); if (this.shouldOverrideTarget(invokedMethod)) { result = this.executeOnProxy(methodInvocation, invokedMethod); } else if (this.shouldMapToTargetField(invokedMethod)) { result = this.executeOnTargetField(methodInvocation, invokedMethod); } else { Method targetMethod = this.getTargetMethod(methodInvocation); if (this.isIntroduced(invokedMethod) && targetMethod != null) { result = this.executeOnTargetMethod(methodInvocation, targetMethod); } else if (this.isIntroduced(invokedMethod)) { result = this.executeOnProxy(methodInvocation, invokedMethod); } else { result = methodInvocation.proceed(); } } return result; } protected Object executeOnTargetMethod(MethodInvocation methodInvocation, Method method) throws Exception { logger.debug("Executing on target; method: " + method.getName()); return method.invoke(methodInvocation.getThis(), methodInvocation.getArguments()); } protected Object executeOnTargetField(MethodInvocation methodInvocation, Method method) throws Exception { logger.debug("Mapping to target field; method: " + method.getName()); Object result = null; try { Object target = methodInvocation.getThis(); if (method.getName().startsWith("get")) { String fieldName = StringUtils.uncapitalize(method.getName().substring(3)); Field field = target.getClass().getDeclaredField(fieldName); field.setAccessible(true); result = field.get(target); } else if (method.getName().startsWith("is")) { String fieldName = StringUtils.uncapitalize(method.getName().substring(2)); Field field = target.getClass().getDeclaredField(fieldName); field.setAccessible(true); result = field.get(target); } else if (method.getName().startsWith("set")) { String fieldName = StringUtils.uncapitalize(method.getName().substring(3)); Field field = target.getClass().getDeclaredField(fieldName); field.setAccessible(true); if (methodInvocation.getArguments().length != 1) { throw new IllegalStateException( "The setter method " + method.getName() + " must have only one argument!"); } else { field.set(target, methodInvocation.getArguments()[0]); } } else { throw new UnsupportedOperationException( "The introduced interface must contain only setter and getter methods."); } } catch (Exception ex) { logger.warn("Something wrong happened calling: " + method.getName()); logger.warn("Exception message: " + ex.getMessage()); throw ex; } return result; } protected Object executeOnProxy(MethodInvocation methodInvocation, Method method) throws Exception { logger.debug("Introducing method: " + method.getName()); Object result = null; try { if (method.getName().startsWith("get")) { if (method.getReturnType().isPrimitive()) { throw new IllegalReturnTypeException( "Return types of your introduced interfaces cannot be primitives."); } result = this.fields.get(method.getName().substring(3)); } else if (method.getName().startsWith("is")) { if (method.getReturnType().isPrimitive()) { throw new IllegalReturnTypeException( "Return types of your introduced interfaces cannot be primitives."); } result = this.fields.get(method.getName().substring(2)); } else if (method.getName().startsWith("set")) { if (methodInvocation.getArguments().length != 1) { throw new IllegalStateException( "The setter method " + method.getName() + " must have only one argument!"); } else { String key = method.getName().substring(3); Object value = methodInvocation.getArguments()[0]; // ConcurrentHashMap doesn't support null values: so, if the value is not null, proceed with setting: if (value != null) { this.fields.put(key, value); } // Else, remove it (this equals setting it null): else { this.fields.remove(key); } } } else { throw new UnsupportedOperationException( "The introduced interface must contain only setter and getter methods."); } } catch (Exception ex) { logger.warn("Something wrong happened calling: " + method.getName()); logger.warn("Exception message: " + ex.getMessage()); throw ex; } return result; } }