Geek asks and answers

Design Template for Generating HTML Tags

For a small system that can receive a string and output HTML code, which design template is suitable?

This is a small example:

public String makeStrong(String in) {

    return "<strong>" + in + "</strong>";
}

Of course, it needs to simulate a hierarchical structure so that it can comply with <ul>, and <ol>their children. I think of Decorator , but Composite Pattern is also good. What should I consider?

+3
source share
3 answers

Consider a builder template for creating valid HTML snippets. I wrote something similar to HTML validation for use in Swing app components, for example. tooltips. Here's a rough skeleton of something to rely on:

public final class HtmlBuilder()
{
  private final StringBuilder sb = new StringBuilder();
  private final Deque tagStack = new ArrayDeque();  

  public HtmlBuilder()
  {
    startTag("html");
  }

  // Consider using an enum of valid tags and extending to support attributes
  public HtmlBuilder startTag( String tag )
  {
    // TODO preconditions
    tagStack.push( tag );
    sb.append('<').append(tag).append('>');
    return this;
  }

  public HtmlBuilder endTag( String tag )
  {
    // TODO preconditions,
    // e.g. check "!tagStack.isEmpty() && tagStack.peek().equals( tag )
    tagStack.pop();
    sb.append('<').append('/').append(tag).append('>');
    return this;
  }

  public HtmlBuilder append( String text )
  {
    // TODO Preconditions, check for/escape special characters etc
    sb.append( text );
    return this;
  }

  @Override
  public String toString()
  {
    endTag("html")
    return sb.toString();
  }
}

:

String html = new HtmlBuilder()
    .startTag( "strong" ).append( "text" ).endTag( "strong" )
    .toString();

, , . "tr", "". , - .

+2

Builder API. :

import static a.b.c.HTML.*;

    String html = p(
                ol(
                    li(),
                    li(
                        _("Hello, "),
                        strong(_("World")),
                        _("!")
                    ),
                    li()
                )
            ).toString();


public class HTML {

    protected final String tag;
    private final HTML[] items;

    public HTML(String tag, final HTML... items) {
        this.tag = tag;
        this.items = items;
    }

    public static HTML _(String text) {
        return new HTML(text) {

            @Override
            public String toString() {
                return tag;
            }

            @Override
            protected void buildString(StringBuilder sb) {
                sb.append(tag);
            }
       };
    }

    public static HTML li(final HTML... items) {
        return new HTML("li", items);
    }

    public static HTML ol(final HTML... items) {
        return new HTML("ol", items);
    }

    public static HTML p(final HTML... items) {
        return new HTML("p", items);
    }

    public static HTML strong(final HTML... items) {
        return new HTML("strong", items);
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        buildString(sb);
        return sb.toString();
    }

    protected void buildString(StringBuilder sb) {
        sb.append('<').append(tag);
        if (items.length == 0) {
            sb.append(" />"); 
        } else {
            sb.append('>');
            for (HTML item : items) {
                item.buildString(sb);
            }
            sb.append("</").append(tag).append('>');
        }

    }
}
+2

A minimalistic approach would be: using an interface AutoCloseable:

Program prints <body><strong> some text </strong><ol><li>a</li><li>b</li><li>c</li></ol></body>
online demo

public class Main {

    public static void main(String args[]) {
        Page page = new Page();
        writeBody(page);
        page.show();

    }

    static void writeBody(Page page) {
        try (BodyTag bodyTag = new BodyTag(page)) {
            writeText(page);
            writeList(page);
        }
    }

    static void writeText(Page page) {
        try (StrongTag strongTag = new StrongTag(page)) {
            strongTag.append(" some text ");
        }
    }

    static void writeList(Page page) {
        try (ListTag list = new ListTag(page)) {
            // A twisted way to write a, b and c as elements
            for (char c=97; c<100; ++c) {
                appendElem(page, String.valueOf(c));
            }
        }
    }

    static void appendElem(Page page, String elem) {
        try (ListElem li = new ListElem(page)) {
            li.append(elem);
        }        
    }
}

class Page {

    StringBuilder content = new StringBuilder();

    void append(String text) {
        content.append(text);
    }

    void show() {
        System.out.println(content);
    }
}

abstract class Tag implements AutoCloseable {

    String name;
    Page content;

    Tag(Page parent, String tagName) {
        name = tagName;
        content = parent;
        content.append("<");
        content.append(name);
        content.append(">");        
    }

    public void append(String text) {
        content.append(text);
    }

    @Override
    final public void close() {
        content.append("</");
        content.append(name);
        content.append(">");
    }
}

final class StrongTag extends Tag {

    public StrongTag(Page parent) {
        super(parent, "strong");
    }
}

final class BodyTag extends Tag {

    public BodyTag(Page parent) {
        super(parent, "body");
    }
}

final class ListTag extends Tag {

    public ListTag(Page parent) {
        super(parent, "ol");
    }
}

final class ListElem extends Tag {

    public ListElem(Page parent) {
        super(parent, "li");
    }
}

Definitely not an idiot proof, but for simple purposes this may be a good start.

+2
source

More articles:


All Articles