<!-- create the task definition -->
<taskdef name="runBean" classpathref="testpath"
      classname="jbetancourt.ant.task.spring.SpringContextTask"/>

<target name="simpleAppContextUseWithDefaults">
   <runBean beanLocations="applicationContext.xml"></runBean>
</target>         

   <target name="publish">
      <spring 
         beanLocations="applicationContext.xml"
         beanName="siteGenerator"   
         methodName="generateSite"
         host="${host.site.url}" 
         port="${site.port}">
         Made a few tweaks.  Removed some sentence fragments.   
      </spring>                    
   </target> 

  call="generateSite("${host.site.url}","${site.port}")" 
Or better:
  <methodCall><![CDATA[    generateSite("${host.site.url}","${site.port}")   ]]></methodCall> 

   <target name="publish">
      <spring beanLocations="applicationContext.xml" beanName="siteGenerator">
         <methodCall>  generateSite("${host.site.url}","${site.port}")  </methodCall>
         Made a few tweaks.  Removed some sentence fragments.   
      </spring>                    
   </target> 

<spring id="metrics" beanLocations="metricsContext.xml" beanName="main"
     exampleAttribute="a value"  and so forth . . ./>

   <target name="ComputeMetrics">
      <spring refid="metrics" call="computeNCSS"/>
      <spring refid="metrics" call="computeCCM"/>
      <spring refid="metrics" call="findBugs"/>
   </target>

   <target name="genDocs">
      <!- here are calls to other types of docs '/>
      <!- now call the metric docs '/>
      <spring refid="metrics" call="createDocs"/>
   </target> 

<target name="ComputeMetrics">
   <spring beanLocations="metricsContext.xml" beanName="computeNCSS"/>
   <spring beanLocations="metricsContext.xml" beanName="computeCCM"/>
   <spring beanLocations="metricsContext.xml" beanName="findBugs"/>
</target> 

<methodCall>  <![CDATA[    notifyDeveloper(names(${dev}) ]]>       </methodCall> 

/*
* SpringContextTask.java
* Created on Jan 9, 2005
* Creator: Josef Betancourt
* Project: SpringContextTask
* -----------------------------------------------------------------------------
* 
* Copyright 2005 by Josef Betancourt
* 
* 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 jbetancourt.ant.task.spring;

import java.util.Enumeration;
import java.util.Properties;

import jbetancourt.ant.task.AbstractContextTask;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.PropertyOverrideConfigurer;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

/**
* 
* Ant task extension that invokes a POJO within a Spring Application
* Context, a "springdef".
* 
* Tested with Ant 1.6.2, JDK 1.4.2, Spring 1.1.4, and OGNL 2.6.7.
* 
* This task is added to Ant with a taskdef or one of the new Ant 1.6+
* approaches. 
* 
*
* 
*  Example taskdef:  
*  <taskdef name="springTask" 
*     classname="jbetancourt.SpringContextTask" 
*     classpathref="taskdefclasspath">
*  
*  It is then used simply by accepting the defaults as:
*      <target name="test1">
*      <springTask beanLocations="applicationContext.xml">
*      </springTask></target>        
*   
*  A more complex use is:
*     <target name="publishBean">
*           <springTask 
*                      beanLocations="applicationContext.xml"
*                beanName="siteGenerator" 

*                      host="${host.site.url}" 
*                      port="${site.port}" 
*                      methodName="generateSite">
*                            In-line site post change text
*                </springTask>                    
*       </target>
* 
*  
* Use of methodCall element with CDATA expression.
* 
*   <target name="test8">
*      <springTask beanLocations="applicationContext.xml" 
*                 beanName="antBean1">            
*           <methodCall><![CDATA[execute("Goodbye")]]>
*                 </methodCall>            
*       </springTask>                
*   </target>                  
* 
* 
*
* 
* 
* @author JBETANCOURT
* @since Jan 9, 2005  
*  
*/
public class SpringContextTask extends AbstractContextTask {

    /** runtime Spring context that that will be set or created */
    private ApplicationContext applicationContext;

    /**
     * 
     * Get the container managed bean.
     * 
     * @param beanName
     * @return the pojo, singleton or non-singleton.
     */
    public Object getBeanFromContainer(String beanName) throws BuildException {
        try {
            if(applicationContext == null){
                applicationContext = new FileSystemXmlApplicationContext(
                    getBeanLocations().list());
            }

            return applicationContext.getBean(getBeanName());
            
        } catch (BeansException e) {
            throw new BuildException("Failure: could not get bean '" + 
                    getBeanName() + "' from context",e);
        }        
    }
    
    /**
     * Invoke target bean setters with Ant specified dynamic properties.
     * 
     */
    public void insertManagedBeanProperties(){
        // How to programmatically post process a Spring bean?
        // See Spring Forum thread for source of this approach.
        // http://forum.springframework.org/viewtopic.php?p=11833#11833
        PropertyOverrideConfigurer poc = new PropertyOverrideConfigurer();
        
        // The keys must be of form 'beanName.key'. 
        // Create a new Properties with this format.
        Properties props = addKeyPrefix(getDynamicProperties(), getBeanName());        

        poc.setProperties(props);

        ((ConfigurableApplicationContext)applicationContext).
            addBeanFactoryPostProcessor(poc); 
        ((ConfigurableApplicationContext)applicationContext).refresh();        
    }
    
    /**
     * For each key in props, convert to 'beanname.key' format.
     * 
     * @return with keys modified
     * @throws BuildException
     */
    private Properties addKeyPrefix(Properties initProps, 
            String prefix) throws BuildException {
        
        // TODO:  This seems like a wrong approach here.  
        // Can the passed in props be manipulated instead?

        
        Properties props = new Properties();
        
        for (Enumeration en = initProps.propertyNames(); 
                  en.hasMoreElements();) {
            String key = (String) en.nextElement();
            
            // Let Ant resolve any property replacements.
            String resolvedText = getProject().replaceProperties(initProps.getProperty(key));
            props.put(prefix + "." + key, resolvedText);
        }
        
        return props;
    }

    /**
     * Get the Spring context that was created or set.
     * @return could be null
     */
    public ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 
     * 
     * @param applicationContext non-null
     *            The applicationContext to set.
     */
    public void setApplicationContext(ApplicationContext applicationContext) {
        log("setting applicationContext: " + applicationContext,
                Project.MSG_DEBUG);
        this.applicationContext = applicationContext;
    }

    /* (non-Javadoc)
     * @see jbetancourt.ant.task.ExternalContainer#createContainer()
     */
    public void createContainer() throws BuildException {
        try {
            if(applicationContext == null){
                applicationContext = new FileSystemXmlApplicationContext(
                    getBeanLocations().list());
            }
            
        } catch (BeansException e) {
            throw new BuildException("Failure: could not create Spring container.",e);
        }        
    }
} 

   public void test2(){ 
      executeTarget("test2"); 
  }       
  public void test3(){
      expectBuildException("test3", "beanLocation or class must be specified");
  }     

   <target name="test3">  <!-- No context path or class specified; should fail -->
     <springTask methodName="length"/></target> 

   <bean id="antBean1" class="jbetancourt.TestBean1"/>     
   <bean id="beanWithProps" class="jbetancourt.TestBean1"/>
   <bean id="main" class="org.springframework.beans.factory.
     config.MethodInvokingFactoryBean">
      <property name="targetObject"><ref local="antBean"/></property>
      <property name="targetMethod"><value>execute<
        /value></property>
   </bean>  

  <target name="test18">
      <springTask beanLocations="etc/contexts/applicationContext.xml" 
        beanName="postBugReport" methodName="doService"></springTask> 
    </target>         
Bean定义如下：
    <bean id="securityInterceptor" class="jbetancourt.SecurityInterceptor">        
    </bean>
    
    <bean id="postBugReport" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="target"><ref local="antBean"/></property>
        <property name="proxyInterfaces">
            <list>
                <value>jbetancourt.ISecurity</value>
            </list>
        </property>
        <property name="interceptorNames">
            <list>
                <value>securityInterceptor</value>
            </list>

        </property>        
    </bean>