Parameterisierter Validator Tag#

SomeValidator.java

import javax.el.ValueExpression;
import javax.faces.application.FacesMessage;
import javax.faces.component.StateHolder;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.Validator;
import javax.faces.validator.ValidatorException;

public class SomeValidator implements Validator, Stateholder {
  private ValueExpression type;
  private boolean transientValue;
  
  public ValueExpression getType() {
    return type;
  }
  public void setType(ValueExpression type) {
    this.type = type;
  }
  
  @Override
  public Object saveState(FacesContext context) {
    Object values[] = new Object[1];
    values[0] = type;
    return values;
  }
  @Override
  public void restoreState(FacesContext context, Object state) {
    Object[] values = (Object[])state;
    type = (ValueExpression)values[0];
  }
  @Override
  public boolean isTransient() {
    return transientValue;
  }
  @Override
  public void setTransient(boolean transientValue) {
    this.transientValue = transientValue;
  }
  
  @Override
  public void validate(FacesContext context, UIComponent component, Object value) throws ValidatorException {
      ...
  }
}

SomeValidatorHandler.java

public class SomeValidatorHandler extends ValidateHandler {
  private TagAttribute type;

  public SomeValidatorHandler(ValidatorConfig config) {
    super(config);
    type = getRequiredAttribute("type");
  }

  @Override
  protected Validator createValidator(FaceletContext context) {
    SomeValidator validator = (SomeValidator)context.getFacesContext().getApplication().createValidator(
        "intersult.some");
    if (type != null)
      validator.setType(type.getValueExpression(context, QueryType.class));
    return validator;
  }

  @Override
  protected MetaRuleset createMetaRuleset(Class type) {
    return super.createMetaRuleset(type).ignoreAll();
  }
}

faces-config.xml

  <validator>
  	<validator-id>intersult.some</validator-id>
  	<validator-class>com.intersult.SomeValidator</validator-class>
  </validator>

intersult.taglib.xml

	<tag>
		<tag-name>SomeValidator</tag-name>
		<validator>
			<validator-id>intersult.some</validator-id>
			<handler-class>com.intersult.SomeValidatorHandler</handler-class>
		</validator>
	</tag>

intersult.tld

	<tag>
		<name>SomeValidator</name>
		<tag-class/>
		<body-content>empty</body-content>
		<attribute>
			<name>type</name>
		</attribute>
	</tag>

ViewHandler#

package com.intersult.jsf;

import java.io.IOException;

import javax.faces.FacesException;
import javax.faces.application.ViewHandler;
import javax.faces.component.UIComponent;
import javax.faces.component.UIViewRoot;
import javax.faces.context.FacesContext;
import javax.faces.context.ResponseWriter;

import com.sun.facelets.FaceletViewHandler;
import com.sun.facelets.tag.jsf.ComponentSupport;

public class PartialViewHandler extends FaceletViewHandler {
  public PartialViewHandler(ViewHandler parent) {
    super(parent);
  }

  @Override
  public void renderView(FacesContext context, UIViewRoot viewToRender) throws IOException, FacesException {
    String region = context.getExternalContext().getRequestParameterMap().get("region");
    if (region == null) {
      super.renderView(context, viewToRender);
    } else {
      renderRegion(context, viewToRender, region);
    }
  }

  private void renderRegion(FacesContext context, UIViewRoot viewToRender, String region) {
    try {
      this.buildView(context, viewToRender);
      UIComponent component = viewToRender.findComponent(region);
      ResponseWriter writer = super.createResponseWriter(context);
      FacesContext.getCurrentInstance().setResponseWriter(writer);
      ComponentSupport.encodeRecursive(context, component);
      writer.close();
      FacesContext.getCurrentInstance().responseComplete();
    } catch (IOException exception) {
      throw new RuntimeException(exception);
    }
  }

  @Override
  public void writeState(FacesContext context) throws IOException {
    String region = context.getExternalContext().getRequestParameterMap().get("region");
    if (region == null)
      super.writeState(context);
  }
}

Einfache Komponente#

public class OutputStream extends UIComponentBase {
  private String url;

  @Override
  public String getFamily() {
    return "javax.faces.Output";
  }

  public String getUrl() {
    ValueExpression expression = getValueExpression("url");
    if (expression != null)
      return (String)expression.getValue(getFacesContext().getELContext());
    return url;
  }
  public void setUrl(String url) {
    this.url = url;
  }
}

Renderer:

public class OutputStreamRenderer extends Renderer {
  @Override
  public void encodeEnd(FacesContext context, UIComponent component) throws IOException {
    OutputStream outputStream = (OutputStream)component;
    ResponseWriter writer = context.getResponseWriter();
    URL url = new URL(outputStream.getUrl());
    InputStream inputStream = null;
    try {
      inputStream = url.openStream();
      IOUtils.copy(inputStream, writer);
    } finally {
      if (inputStream != null)
        inputStream.close();
    }
  }
}

faces-config.xml:

  <component>
  	<component-type>intersult.OutputStream</component-type>
  	<component-class>com.intersult.OutputStream</component-class>
  </component>

  <render-kit>
  	<render-kit-id>HTML_BASIC</render-kit-id>
  	<renderer>
  		<component-family>javax.faces.Output</component-family>
  		<renderer-type>intersult.OutputStream</renderer-type>
  		<renderer-class>com.intersult.OutputStreamRenderer</renderer-class>
  	</renderer>
  </render-kit>

intersult.taglib.xml:

	<tag>
		<tag-name>outputStream</tag-name>
		<component>
			<component-type>intersult.OutputStream</component-type>
			<renderer-type>intersult.OutputStream</renderer-type>
		</component>
	</tag>