À l'aide de la Vélocité des Outils avec le Printemps 3.0.3

Quand je l'ai mise à jour de la fève:

<bean id="viewResolver" class="org.springframework.web.servlet.view.velocity.VelocityViewResolver">
  <property name="cache" value="true"/>
  <property name="prefix" value=""/>
  <property name="suffix" value=".vm"/>
  <property name="toolboxConfigLocation" value="tools.xml" />
</bean>

Avec l'tools.xml chemin d'accès pour la Vitesse d'Outils, j'obtiens:

Caused by: 
java.lang.ClassNotFoundException: org.apache.velocity.tools.view.ToolboxManager

J'ai essayé de brancher les outils de la version 2 et 1,4, n'ont ni cette structure de paquet. Ai-je raté quelque chose d'évident? Quelle est la version de la Vitesse d'Outils est le Printemps/l'appui de la composante de Vitesse?

InformationsquelleAutor David Parks | 2010-11-02

5

Le printemps est très désuet Vitesse de support par défaut. J'étends VelocityView classe à partir du Printemps et de remplacer createVelocityContext méthode où j'ai initialiser les Outils de moi-même. Ici à quoi ça ressemble à la fin.
- Oh fabuleux, que pourrais-je demander de plus, merci pour la référence et de clarifier tout pour moi!
InformationsquelleAutor serg

J'ai utilisé un peu plus simple de chemin. Je ne peux pas forcer la Vitesse des Outils de travail en raison du manque de documentation de la configuration et des exemples. Je viens d'obtenir le velocity-generic-tools-2.0.jar et faire un peu de changement dans mon avis de résolution:

<bean id="velocityViewResolver" 
    class="org.springframework.web.servlet.view.velocity.VelocityViewResolver">
    <property name="order" value="1"/>
    <property name="prefix" value="/WEB-INF/vm/"/>
    <property name="suffix" value=".vm"/>

    <property name="exposeSpringMacroHelpers" value="true"/>
    <property name="contentType" value="text/html;charset=UTF-8"/>
    <property name="attributesMap">
        <map>
            <!--Velocity Escape Tool-->
            <entry key="esc"><bean class="org.apache.velocity.tools.generic.EscapeTool"/></entry>
        </map>
    </property>        
</bean>

Puis, à la vitesse de modèle, vous pouvez l'utiliser comme d'habitude $esc.html($htmlCodeVar). Cette solution est très simple, sans des tonnes de configs et prioritaire de printemps classes.

InformationsquelleAutor sphinks

Avec 3.0.5 j'ai utilisé une catégorie similaire à ce que serg posté, avec la seule modification étant d'utiliser la mise à jour des classes qui en ressort ne pas utiliser la queue à travers VelocityToolboxView -> ServletToolboxManager (utilisé dans le createVelocityContext nous avons remplacé) Qui est la classe qui est obsolète, j'ai donc modifié le initVelocityToolContext en serg réponse à:

private ToolContext getToolContext() throws IllegalStateException, IOException {
  if (toolContext == null) {
    XmlFactoryConfiguration factoryConfiguration = new XmlFactoryConfiguration("Default Tools");
    factoryConfiguration.read(getServletContext().getResourceAsStream(getToolboxConfigLocation()));
    ToolboxFactory factory = factoryConfiguration.createFactory();
    factory.configure(factoryConfiguration);
    toolContext = new ToolContext();
    for (String scope : Scope.values()) {
      toolContext.addToolbox(factory.createToolbox(scope));
    }
  }
  return toolContext;
}

J'ai aussi dû changer la ligne qui a créé le VelocityContext pour appeler cette méthode, évidemment.

Mon haricot ressemble maintenant à:

<bean id="viewResolver" class="org.springframework.web.servlet.view.velocity.VelocityLayoutViewResolver"
      p:cache="false"
      p:prefix=""
      p:suffix=".vm"
      p:layoutUrl="templates/main.vm"
      p:toolboxConfigLocation="/WEB-INF/velocity/velocity-toolbox.xml"
      p:viewClass="path.to.overriden.class.VelocityToolsLayoutView"
/>

InformationsquelleAutor Scott

Inspiré par les réponses de Scott et serg, voici une autre façon de faire qui ne nécessite pas de XML: http://squirrel.pl/blog/2012/07/13/spring-velocity-tools-no-xml/

public class MyVelocityToolboxView extends VelocityView {
    @Override
    protected Context createVelocityContext(Map<String, Object> model,
            HttpServletRequest request, HttpServletResponse response) {
        ViewToolContext context = new ViewToolContext(getVelocityEngine(),
                request, response, getServletContext());

        ToolboxFactory factory = new ToolboxFactory();
        factory.configure(ConfigurationUtils.getVelocityView());

        for (String scope : Scope.values()) {
            context.addToolbox(factory.createToolbox(scope));
        }

        if (model != null) {
            for (Map.Entry<String, Object> entry : (Set<Map.Entry<String, Object>>) model
                    .entrySet()) {
                context.put(entry.getKey(), entry.getValue());
            }
        }
        return context;
    }
}

InformationsquelleAutor Konrad Garus

Inspiré par toutes les réponses ci-dessus, c'est ma mise en œuvre de VelocityLayoutView pour le printemps et la vélocité des outils 2.0, ajouté quelques améliorations!

public class VelocityToolsView extends VelocityLayoutView {

    private static final String TOOL_MANAGER_KEY = ViewToolManager.class.getName();

    @Override
    protected Context createVelocityContext(
            Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) {
        ServletContext application = getServletContext();

        //use a shared instance of ViewToolManager
        ViewToolManager toolManager = (ViewToolManager)application.getAttribute(TOOL_MANAGER_KEY);
        if(toolManager == null) {
            toolManager = createToolManager(getVelocityEngine(), getToolboxConfigLocation(), application);
            application.setAttribute(TOOL_MANAGER_KEY, toolManager);
        }

        ViewToolContext toolContext = toolManager.createContext(request, response);
        if(model != null) { toolContext.putAll(model); }

        return toolContext;
    }

    private ViewToolManager createToolManager(VelocityEngine velocity, String toolFile, ServletContext application) {
        ViewToolManager toolManager = new ViewToolManager(application, false, false);
        toolManager.setVelocityEngine(velocity);

        //generic & view tools config
        FactoryConfiguration config = ConfigurationUtils.getVelocityView();
        //user defined tools config
        if(toolFile != null) {
            FactoryConfiguration userConfig = ConfigurationUtils.load(application.getRealPath(toolFile));
            config.addConfiguration(userConfig);
        }
        toolManager.configure(config);

        return toolManager;
    }
}

InformationsquelleAutor tsl0922

0

J'ai trouvé que cette variation sur @serg la technique a fonctionné pour moi.

InformationsquelleAutor spume

Vous devez vous connecter pour publier un commentaire.