Wicket 1.5.2 で、CSS Javascript の Reference 出力をコントロールする

FilteringHeaderResponse.java

import org.apache.wicket.markup.html.IHeaderResponse;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.apache.wicket.request.resource.ResourceReference;
import org.apache.wicket.resource.filtering.HeaderResponseContainerFilteringHeaderResponse;
import org.apache.wicket.util.string.Strings;

/**
 * FilteringHeaderResponse
 */
public class FilteringHeaderResponse extends HeaderResponseContainerFilteringHeaderResponse {
    /**
     * Construct.
     *
     * @param response         the wrapped IHeaderResponse
     * @param headerFilterName the name that the filter for things that should appear in the head (default Wicket
     *                         location) uses
     * @param filters          the filters to use to bucket things. There will be a bucket created for each
     *                         filter, by name. There should typically be at least one filter with the same name
     */
    public FilteringHeaderResponse(IHeaderResponse response, String headerFilterName, IHeaderResponseFilter[] filters) {
        super(response, headerFilterName, filters);
    }

    /**
     * renderJavaScriptReferenceIntoFooter
     *
     * @param reference
     */
    public void renderJavaScriptReferenceIntoFooter(ResourceReference reference) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderJavaScriptReference(reference);
            }
        }, "footerBucket");
        super.renderJavaScriptReference(reference);
    }

    /**
     * renderJavaScriptReferenceIntoFooter
     *
     * @param reference
     * @param id
     */
    public void renderJavaScriptReferenceIntoFooter(ResourceReference reference, String id) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderJavaScriptReference(reference, id);
            }
        }, "footerBucket");
    }

    /**
     * renderJavaScriptReferenceIntoFooter
     *
     * @param reference
     * @param pageParameters
     * @param id
     */
    public void renderJavaScriptReferenceIntoFooter(ResourceReference reference, PageParameters pageParameters, String id) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderJavaScriptReference(reference, pageParameters, id);
            }
        }, "footerBucket");
    }

    /**
     * renderJavaScriptReferenceIntoFooter
     *
     * @param url
     */
    public void renderJavaScriptReferenceIntoFooter(String url) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderJavaScriptReference(url);
            }
        }, "footerBucket");
    }

    /**
     * renderJavaScriptReferenceIntoFooter
     *
     * @param url
     * @param id
     */
    public void renderJavaScriptReferenceIntoFooter(String url, String id) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderJavaScriptReference(url, id);
            }
        }, "footerBucket");
    }

    /**
     * renderJavaScriptIntoFooter
     *
     * @param javascript
     * @param id
     */
    public void renderJavaScriptIntoFooter(CharSequence javascript, String id) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderJavaScript(javascript, id);
            }
        }, "footerBucket");
    }

    /**
     * renderCSSReferenceIntoFooter
     *
     * @param reference
     */
    public void renderCSSReferenceIntoFooter(ResourceReference reference) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderCSSReference(reference);
            }
        }, "footerBucket");
    }

    /**
     * renderCSSReferenceIntoFooter
     *
     * @param url
     */
    public void renderCSSReferenceIntoFooter(String url) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderCSSReference(url);
            }
        }, "footerBucket");
    }

    public void renderCSSReferenceIntoFooter(ResourceReference reference, String media) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderCSSReference(reference, media);
            }
        }, "footerBucket");
    }

    public void renderCSSReferenceIntoFooter(ResourceReference reference, PageParameters pageParameters, String media) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderCSSReference(reference, pageParameters, media);
            }
        }, "footerBucket");
    }

    /**
     * renderCSSReferenceIntoFooter
     *
     * @param url
     * @param media
     */
    public void renderCSSReferenceIntoFooter(String url, String media) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderCSSReference(url, media);
            }
        }, "footerBucket");
    }

    /**
     * renderOnDomReadyJavaScriptIntoFooter
     *
     * @param javascript
     */
    public void renderOnDomReadyJavaScriptIntoFooter(String javascript) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderOnDomReadyJavaScript(javascript);
            }
        }, "footerBucket");
    }

    /**
     * renderOnLoadJavaScriptIntoFooter
     *
     * @param javascript
     */
    public void renderOnLoadJavaScriptIntoFooter(String javascript) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderOnLoadJavaScript(javascript);
            }
        }, "footerBucket");
    }

    /**
     * renderOnEventJavaScriptIntoFooter
     *
     * @param target
     * @param event
     * @param javascript
     */
    public void renderOnEventJavaScriptIntoFooter(String target, String event, String javascript) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderOnEventJavaScript(target, event, javascript);
            }
        }, "footerBucket");
    }
    /**
     * renderJavaScriptReference
     * @param url
     * @param defer
     * @param async
     */
    public void renderJavaScriptReference(String url, boolean defer, boolean async) {
        this.renderJavaScriptReference(url, null, defer, async);
    }

    /**
     * renderJavaScriptReference
     * @param url
     * @param id
     * @param defer
     * @param async
     */
    public void renderJavaScriptReference(String url, String id, boolean defer, boolean async) {
        runWithFilter(new Runnable() {
            public void run() {
                String javascriptUrl = getJavaScriptUrl(url, id , defer, null, async);
                getRealResponse().renderString(javascriptUrl);
            }
        }, "footerBucket");
    }

    /**
     * renderJavaScriptReferenceIntoFooter
     * @param url
     * @param defer
     * @param async
     */
    public void renderJavaScriptReferenceIntoFooter(String url, boolean defer, boolean async) {
        this.renderJavaScriptReferenceIntoFooter(url, null, defer, async);
    }

    /**
     * renderJavaScriptReferenceIntoFooter
     * @param url
     * @param id
     * @param defer
     * @param async
     */
    public void renderJavaScriptReferenceIntoFooter(String url, String id, boolean defer, boolean async) {
        runWithFilter(new Runnable() {
            public void run() {
                String javascriptUrl = getJavaScriptUrl(url, id , defer, null, async);
                getRealResponse().renderString(javascriptUrl);
            }
        }, "footerBucket");
    }

    /**
     * renderStringIntoFooter
     * @param charSequence
     */
    public void renderStringIntoFooter(CharSequence charSequence) {
        runWithFilter(new Runnable() {
            public void run() {
                getRealResponse().renderString(charSequence);
            }
        }, "footerBucket");
    }

    /**
     * getJavaScriptUrl
     * @see https://github.com/apache/wicket/blob/master/wicket-core/src/main/java/org/apache/wicket/core/util/string/JavaScriptUtils.java
     * @param url
     * @param id
     * @param defer
     * @param charset
     * @param async
     * @return
     */
    public String getJavaScriptUrl(final CharSequence url,
                                          final String id, boolean defer, String charset, boolean async) {
        StringBuilder sb = new StringBuilder();
        sb.append("<script type=\"text/javascript\" ");
        if (id != null)
        {
            sb.append("id=\"" + Strings.escapeMarkup(id) + "\" ");
        }
        if (defer)
        {
            sb.append("defer=\"defer\" ");
        }
        if (async)
        {
            sb.append("async=\"async\" ");
        }
        if (charset != null)
        {
            sb.append("charset=\"" + Strings.escapeMarkup(charset) + "\" ");
        }
        sb.append("src=\"");
        sb.append(url);
        sb.append("\"></script>");
        sb.append("\n");
        return sb.toString();
    }
}

Hello.html

<html>
<wicket:head>
<head>
    <title>Wicket Hello World</title>
</head>
</wicket:head>
<body>
<h1>
    <span wicket:id="message">message will be replace later</span>
</h1>
<p>Javascript</p>
<wicket:container wicket:id="footerBucket"/>
</body>
</html>

Hello.java

import org.apache.wicket.Component;
import org.apache.wicket.behavior.Behavior;
import org.apache.wicket.markup.html.IHeaderResponse;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.request.mapper.parameter.PageParameters;
import org.apache.wicket.resource.filtering.HeaderResponseFilteredResponseContainer;

public class Hello extends WebPage {

    private static final long serialVersionUID = 1L;

    public Hello(final PageParameters parameters) {
        super(parameters);
    }

    @Override
    public void renderHead(IHeaderResponse response) {
        FilteringHeaderResponse filteringResponse = (FilteringHeaderResponse) response;
        filteringResponse.renderString("<script type=\"text/javascript\"><!-- document.write(\"Hello\"); // --></script>");
        filteringResponse.renderString("<link type=\"image/x-icon\" rel=\"shortcut icon\" href=\"resources/favicon.ico\" />");
        filteringResponse.renderCSSReference("https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css");
        filteringResponse.renderJavaScriptReference("https://code.jquery.com/jquery-1.12.4.min.js");
        filteringResponse.renderJavaScriptReference("https://code.jquery.com/jquery-1.12.4.min.js", true, false);
        filteringResponse.renderJavaScriptReferenceIntoFooter("https://code.jquery.com/jquery-2.2.4.min.js", true, true);
        super.renderHead(response);
    }

    @Override
    public void onInitialize() {
        super.onInitialize();
        add(new Label("message", "Hello World, Wicket"));
        add(new HeaderResponseFilteredResponseContainer("footerBucket", "footerBucket"));
        add(new Behavior() {
            @Override
            public void renderHead(Component component, IHeaderResponse response) {
                FilteringHeaderResponse filteringResponse = (FilteringHeaderResponse) response;
                filteringResponse.renderStringIntoFooter("<link type=\"image/x-icon\" rel=\"shortcut icon\" href=\"resources/favicon.ico2\" />");
                super.renderHead(component, response);
            }
        });
    }
}

MyApplication.java

import org.apache.wicket.Page;
import org.apache.wicket.markup.html.IHeaderResponse;
import org.apache.wicket.markup.html.IHeaderResponseDecorator;
import org.apache.wicket.protocol.http.WebApplication;
import org.apache.wicket.resource.filtering.AbstractHeaderResponseFilter;
import org.apache.wicket.resource.filtering.HeaderResponseContainerFilteringHeaderResponse;

public class MyApplication extends WebApplication {

    @Override
    public Class<? extends Page> getHomePage() {
        return Hello.class; //return default page
    }

    @Override
    public void init() {

        setHeaderResponseDecorator(new IHeaderResponseDecorator() {
            HeaderResponseContainerFilteringHeaderResponse.IHeaderResponseFilter[] filters = {new AbstractHeaderResponseFilter("headerBucket") {
            }, new AbstractHeaderResponseFilter("footerBucket") {
            }};

            @Override
            public IHeaderResponse decorate(IHeaderResponse response) {
                return new FilteringHeaderResponse(response, "headerBucket", filters);
            }
        });
    }
}

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>wicket</groupId>
    <artifactId>example</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.wicket/wicket-core -->
        <dependency>
            <groupId>org.apache.wicket</groupId>
            <artifactId>wicket-core</artifactId>
            <version>1.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.jetty</groupId>
            <artifactId>jetty-maven-plugin</artifactId>
            <version>9.0.7.v20131107</version>
        </dependency>
    </dependencies>
    <build>
        <finalName>WicketExamples</finalName>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
            <resource>
                <filtering>false</filtering>
                <directory>src/main/java</directory>
                <includes>
                    <include>*</include>
                </includes>
                <excludes>
                    <exclude>**/*.java</exclude>
                </excludes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <inherited>true</inherited>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <debug>true</debug>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.0.7.v20131107</version>
                <configuration>
                    <!-- http://docs.codehaus.org/display/JETTY/Maven+Jetty+Plugin -->
                    <scanIntervalSeconds>2</scanIntervalSeconds>
                    <connectors>
                        <connector implementation="org.eclipse.jetty.server.nio.SelectChannelConnector">
                            <port>8080</port>
                            <maxIdleTime>60000</maxIdleTime>
                        </connector>
                    </connectors>
                    <webAppConfig>
                        <contextPath>/</contextPath>
                    </webAppConfig>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.8</version>
                <configuration>
                    <downloadSources>true</downloadSources>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>