@Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable { ReplaceOverride ro = (ReplaceOverride) getBeanDefinition().getMethodOverrides().getOverride(method); Assert.state(ro != null, "ReplaceOverride not found"); // TODO could cache if a singleton for minor performance optimization MethodReplacer mr = this.owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class); return mr.reimplement(obj, method, args); } }
/** * Parse replaced-method sub-elements of the given bean element. */ public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) { NodeList nl = beanEle.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) { Element replacedMethodEle = (Element) node; String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE); String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE); ReplaceOverride replaceOverride = new ReplaceOverride(name, callback); // Look for arg-type match elements. List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT); for (Element argTypeEle : argTypeEles) { String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE); match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle)); if (StringUtils.hasText(match)) { replaceOverride.addTypeIdentifier(match); } } replaceOverride.setSource(extractSource(replacedMethodEle)); overrides.addOverride(replaceOverride); } } }
@Override public boolean matches(Method method) { if (!method.getName().equals(getMethodName())) { return false; } if (!isOverloaded()) { // Not overloaded: don't worry about arg type matching... return true; } // If we get here, we need to insist on precise argument matching... if (this.typeIdentifiers.size() != method.getParameterCount()) { return false; } Class<?>[] parameterTypes = method.getParameterTypes(); for (int i = 0; i < this.typeIdentifiers.size(); i++) { String identifier = this.typeIdentifiers.get(i); if (!parameterTypes[i].getName().contains(identifier)) { return false; } } return true; }
/** * Generates methods overrides (lookup or replace). */ private void generateMethodOverride(final MethodOverride override, final ElementBuilder builder) { if (override instanceof LookupOverride) { LookupOverride lookupOverride = (LookupOverride) override; builder.addChild(LOOKUP_METHOD_ELEMENT); String methodName = lookupOverride.getMethodName(); builder.addAttribute(NAME_ATTRIBUTE, methodName); String targetBeanName = lookupOverride.getBeanName(); builder.addAttribute(BEAN_REF_ATTRIBUTE, targetBeanName); builder.up(); } else if (override instanceof ReplaceOverride) { ReplaceOverride replaceOverride = (ReplaceOverride) override; builder.addChild(REPLACED_METHOD_ELEMENT); String methodName = replaceOverride.getMethodName(); String beanName = replaceOverride.getMethodReplacerBeanName(); builder.addAttribute(NAME_ATTRIBUTE, methodName); builder.addAttribute(REPLACER_ATTRIBUTE, beanName); builder.up(); } }
/** * Parse replaced-method sub-elements of the given bean element. */ public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) { NodeList nl = beanEle.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) { Element replacedMethodEle = (Element) node; String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE); String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE); ReplaceOverride replaceOverride = new ReplaceOverride(name, callback); // Look for arg-type match elements. List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT); for (Element argTypeEle : argTypeEles) { String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE); match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle)); if (StringUtils.hasText(match)) { replaceOverride.addTypeIdentifier(match); } } replaceOverride.setSource(extractSource(replacedMethodEle)); overrides.addOverride(replaceOverride); } } }
@Override public String toString() { return "Replace override for method '" + getMethodName() + "'"; }
private void setBaseProperties(AbstractBeanDefinition definition) { definition.setAbstract(true); definition.setAttribute("foo", "bar"); definition.setAutowireCandidate(false); definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE); // definition.getConstructorArgumentValues().addGenericArgumentValue("foo"); definition.setDependencyCheck(AbstractBeanDefinition.DEPENDENCY_CHECK_OBJECTS); definition.setDependsOn(new String[] { "foo", "bar" }); definition.setDestroyMethodName("destroy"); definition.setEnforceDestroyMethod(false); definition.setEnforceInitMethod(true); definition.setFactoryBeanName("factoryBean"); definition.setFactoryMethodName("factoryMethod"); definition.setInitMethodName("init"); definition.setLazyInit(true); definition.getMethodOverrides().addOverride(new LookupOverride("foo", "bar")); definition.getMethodOverrides().addOverride(new ReplaceOverride("foo", "bar")); definition.getPropertyValues().add("foo", "bar"); definition.setResourceDescription("desc"); definition.setRole(BeanDefinition.ROLE_APPLICATION); definition.setScope(BeanDefinition.SCOPE_PROTOTYPE); definition.setSource("foo"); }
/** * Generates methods overrides (lookup or replace). */ private void generateMethodOverride(final MethodOverride override, final ElementBuilder builder) { if (override instanceof LookupOverride) { LookupOverride lookupOverride = (LookupOverride) override; builder.addChild(LOOKUP_METHOD_ELEMENT); String methodName = lookupOverride.getMethodName(); builder.addAttribute(NAME_ATTRIBUTE, methodName); String targetBeanName = lookupOverride.getBeanName(); builder.addAttribute(BEAN_REF_ATTRIBUTE, targetBeanName); builder.up(); } else if (override instanceof ReplaceOverride) { ReplaceOverride replaceOverride = (ReplaceOverride) override; builder.addChild(REPLACED_METHOD_ELEMENT); String methodName = replaceOverride.getMethodName(); String beanName = replaceOverride.getMethodReplacerBeanName(); builder.addAttribute(NAME_ATTRIBUTE, methodName); builder.addAttribute(REPLACER_ATTRIBUTE, beanName); builder.up(); } }
/** * Parse replaced-method sub-elements of the given bean element. */ protected void parseReplacedMethodSubElements(Element beanEle, String beanName, MethodOverrides overrides) throws BeanDefinitionStoreException { NodeList nl = beanEle.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element && REPLACED_METHOD_ELEMENT.equals(node.getNodeName())) { Element replacedMethodEle = (Element) node; String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE); String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE); ReplaceOverride replaceOverride = new ReplaceOverride(name, callback); // Look for arg-type match elements. List argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT); for (Iterator it = argTypeEles.iterator(); it.hasNext();) { Element argTypeEle = (Element) it.next(); replaceOverride.addTypeIdentifier(argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE)); } overrides.addOverride(replaceOverride); } } }
@Override public String toString() { return "Replace override for method '" + getMethodName() + "'"; }
private void addMethodOverrides(final AbstractBeanDefinition beanDefinition, final Class<?> clazz) { final MethodOverrides methodOverrides = beanDefinition.getMethodOverrides(); for (final Method method : clazz.getMethods()) { if (Modifier.isAbstract(method.getModifiers()) && methodOverrides.getOverride(method) == null) { LOGGER.info("Add override for {}.", method); methodOverrides.addOverride(new ReplaceOverride(method.getName(), UNSUPPORTED_METHOD_REPLACER_NAME)); } } }
/** * Parse replaced-method sub-elements of the given bean element. */ public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) { NodeList nl = beanEle.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) { Element replacedMethodEle = (Element) node; String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE); String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE); ReplaceOverride replaceOverride = new ReplaceOverride(name, callback); // Look for arg-type match elements. List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT); for (Element argTypeEle : argTypeEles) { String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE); match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle)); if (StringUtils.hasText(match)) { replaceOverride.addTypeIdentifier(match); } } replaceOverride.setSource(extractSource(replacedMethodEle)); overrides.addOverride(replaceOverride); } } }
@Override public boolean matches(Method method) { if (!method.getName().equals(getMethodName())) { return false; } if (!isOverloaded()) { // Not overloaded: don't worry about arg type matching... return true; } // If we get here, we need to insist on precise argument matching... if (this.typeIdentifiers.size() != method.getParameterCount()) { return false; } Class<?>[] parameterTypes = method.getParameterTypes(); for (int i = 0; i < this.typeIdentifiers.size(); i++) { String identifier = this.typeIdentifiers.get(i); if (!parameterTypes[i].getName().contains(identifier)) { return false; } } return true; }
@Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable { ReplaceOverride ro = (ReplaceOverride) getBeanDefinition().getMethodOverrides().getOverride(method); Assert.state(ro != null, "ReplaceOverride not found"); // TODO could cache if a singleton for minor performance optimization MethodReplacer mr = this.owner.getBean(ro.getMethodReplacerBeanName(), MethodReplacer.class); return mr.reimplement(obj, method, args); } }
@Override public String toString() { return "Replace override for method '" + getMethodName() + "; will call bean '" + this.methodReplacerBeanName + "'"; }
/** * Parse replaced-method sub-elements of the given bean element. */ public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) { NodeList nl = beanEle.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) { Element replacedMethodEle = (Element) node; String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE); String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE); ReplaceOverride replaceOverride = new ReplaceOverride(name, callback); // Look for arg-type match elements. List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT); for (Element argTypeEle : argTypeEles) { replaceOverride.addTypeIdentifier(argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE)); } replaceOverride.setSource(extractSource(replacedMethodEle)); overrides.addOverride(replaceOverride); } } }
@Override public boolean matches(Method method) { // TODO could cache result for efficiency if (!method.getName().equals(getMethodName())) { // It can't match. return false; } if (!isOverloaded()) { // No overloaded: don't worry about arg type matching. return true; } // If we get to here, we need to insist on precise argument matching. if (this.typeIdentifiers.size() != method.getParameterTypes().length) { return false; } for (int i = 0; i < this.typeIdentifiers.size(); i++) { String identifier = this.typeIdentifiers.get(i); if (!method.getParameterTypes()[i].getName().contains(identifier)) { // This parameter cannot match. return false; } } return true; }
public Object intercept(Object obj, Method method, Object[] args, MethodProxy mp) throws Throwable { ReplaceOverride ro = (ReplaceOverride) beanDefinition.getMethodOverrides().getOverride(method); // TODO could cache if a singleton for minor performance optimization MethodReplacer mr = (MethodReplacer) owner.getBean(ro.getMethodReplacerBeanName()); return mr.reimplement(obj, method, args); } }
public String toString() { return "Replace override for method '" + getMethodName() + "; will call bean '" + this.methodReplacerBeanName + "'"; }
/** * Parse replaced-method sub-elements of the given bean element. * * @param beanEle a {@link org.w3c.dom.Element} object. * @param overrides a {@link org.springframework.beans.factory.support.MethodOverrides} object. */ public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) { NodeList nl = beanEle.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) { Element replacedMethodEle = (Element) node; String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE); String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE); ReplaceOverride replaceOverride = new ReplaceOverride(name, callback); // Look for arg-type match elements. List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT); for (Element argTypeEle : argTypeEles) { replaceOverride.addTypeIdentifier(argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE)); } replaceOverride.setSource(extractSource(replacedMethodEle)); overrides.addOverride(replaceOverride); } } }