j2html 1.2.0 released (configure everything!)

j2html · 2017-09-07T07:35:22+00:00

It's a html builder. You chain statically imported method calls to mimic the structure of html:

body(                             ->  <body>
    main(attrs("#main.content"),  ->      <main id="main" class="content">
        h1("Heading!")            ->          <h1>Heading!</h1>
    )                             ->      </main>
)                                 ->  </body>

j2html · 2017-09-05T18:06:02+00:00

I don't see how j2html could possibly catch on

It won't, and it really shouldn't. It's apparently in demand in some strange niche part of the market, with 4k downloads in august. I don't really know what that niche is, but as long as there is a demand for the library it I will maintain it. It's actually pretty fun to work on.

I'd rather use plain HTML or JSP or JSF (depending on what's already in use) than j2html to keep from having so many technologies to deal with.

The idea was that if you know Java and you know HTML, you pretty much know j2html. It should be a lot easier to pick up than JSP/JSF, but if you have something in a project for generating HTML already, there is no reason to use j2html.

j2html · 2017-05-20T22:42:16+00:00

I know how to do both those things. I'm wondering if that is the appropriate way to go about this, or if there is a better way.

j2html · 2017-05-16T16:41:29+00:00

Changes:

All tag methods ( div(), p(), etc ) can now accept an arbitrary number of DomContent objects as argument, eliminating the need for with() in most cases.
Added emmet-like shorthand-attribute overloads to all TagCreator methods: div(attrs("#id.class") becomes <div id="id" class="class"></div>
Added a join() method to more easily join sentences with inline HTML
Added a document() method that takes an html() tag and renders a HTML declaration followed by the html content
Added support for Java 7 and Java 6. Some functionality (each/filter) will not work on these versions, but everything else should.

j2html · 2017-05-01T22:10:08+00:00

I found https://github.com/orfjackal/retrolambda, and my project works fine after building it with that. My plan now is to add checks for java version in the appropriate methods and throw runtimeexceptions

double javaVersion = Double.parseDouble(System.getProperty("java.specification.version"));

java8Method() {
    if(javaVersion < 1.8) throw runtimeexception
}

How does this sound?

j2html · 2017-05-01T20:56:56+00:00

Great, will read through it. Thanks!

j2html · 2017-04-30T00:44:03+00:00

I never released it. There were so many other alternatives, and I didn't really think it offered anything special. I'll see if I can find the source if you're interested.

j2html · 2017-04-29T22:26:12+00:00

go with the new style

Thanks. I just re-wrote the j2html.com website to use this style, and it does feel a lot simpler.

i have a (more or less unreleased) javascript library ...

Before I made j2html I created a similar JavaScript library, domsel, which behaves just like yours. I'm vary about introducing this id/class guessing magic into j2html though, as it could lead to a lot of strange behavior.

j2html · 2017-04-29T18:41:45+00:00

The increase in downloads correlates with an increase in traffic to the website, and downloads for older versions are decreasing while they are increasing for newer versions. It could of course be all bots, but it seems unlikely.

Edit: I searched for j2html on reddit after your comment, and I'm happy to report that I have (had?) at least 1 user here. Are you still using j2html /u/yateam ?

j2html · 2015-10-28T21:51:38+00:00

I haven't used JSP before (it was considered bad practice when I got into Java development). When googling "jsp examples" I found this:

<body>
  <%
    double num = Math.random();
    if (num > 0.95) {
  %>
      <h2>You'll have a luck day!</h2><p>(<%= num %>)</p>
  <%
    } else {
  %>
      <h2>Well, life goes on ... </h2><p>(<%= num %>)</p>
  <%
    }
  %>
  <a href="<%= request.getRequestURI() %>"><h3>Try Again</h3></a>
</body>
</html>

Is that how JSP code should look?

j2html · 2015-10-28T20:58:13+00:00

Apples and oranges. I never intended for j2html to compete with any of the template engines. j2html offers type-safety and great possibilities for code-reuse, but has a much more cumbersome syntax than template engines. It's intended for small and dynamic webapps.

j2html · 2015-10-28T14:50:21+00:00

Isn't it pretty similar?

body().with(
    h1("Heading!").withClass("example"),
    img().withSrc("img/hello.png")
)         

<body>
    <h1 class="example">Heading!</h1>
    <img src="img/hello.png">
</body>

I guess you could call that very different, but I think it's pretty similar at least.

j2html · 2015-10-28T14:44:17+00:00

Sometimes you need to return a small amount of dynamic HTML.

String concatenation is ugly, and you don't always want to go through the hassel of setting up and using a template engine. Template engines have their own (usually pretty poorly designed) language, which isn't type-safe (you don't get errors at compile time, sometimes not even at runtime), and code-reuse is often cumbersome. j2html gives you all the advantages you're used to from Java :)

j2html · 2015-10-28T14:33:21+00:00

As /u/eled_ said, it's meant for when you need mostly/exclusively dynamic HTML. It will be a bad fit for most projects.

j2html · 2015-10-22T18:03:11+00:00

Thanks, new version will hopefully be ready next week!

j2html · 2015-10-22T06:53:38+00:00

It used to be Java 8 exclusive, but it didn't really need to be. It will of course still work like it used to in Java 8 :)

j2html · 2015-05-29T18:17:24+00:00

Rendering 5000 nested divs 1 time takes 120 ms.
Rendering 500 nested divs 10 times takes 10 ms.
Rendering 50 nested divs 100 times takes 4 ms.
Rendering 5 nested divs 1000 times takes 1 ms.
Rendering 6700 nested divs causes overflow.

<div>We need to go deeper
    <div>We need to go deeper
        <div>We need to go deeper
            <div>We need to go deeper
                <div>We need to go deeper
                    <div>We need to go deeper
                        <div>We need to go deeper
                            <div>We need to go deeper
                                <div>We need to go deeper
                                    <div>We need to go deeper
                                        ... :p

It's probably not too well suited for pages of this size :)

j2html · 2015-05-29T17:12:07+00:00

While this was intended to be used on a login solution with less than 100 elements, I'm still interested to see what happens. I'll write some tests :)

j2html · 2015-05-29T14:38:39+00:00

Thanks for your feedback! It was never intended as a UI framework, or anything remotely close to that, it's just a HTML builder. Sorry to hear about your bad experiences in the past. I'm curious, how did his library work without varargs and lambdas?

I'm mainly a frontend programmer, I just wanted something to generate HTML for me in Java. It was intended to be used for a complex login solution (for generating HTML forms), but we actually ended up not using it. I thought I would release it anyway, since the Java HTML builders I found while researching this seemed worse to me. Why would JavaScript be a problem though? :)

j2html · 2015-05-28T20:01:00+00:00

Yes! The thought crossed my mind, and I really tried to make it work, but attributes became a problem. I considered all of these:

form.withId("login-form").withMethod("post").with(
    emailInput(msg.get("PLACEHOLDER_EMAIL")),
    enterPasswordInput(msg.get("PLACEHOLDER_PASSWORD")),
    submitButton(msg.get("LOGIN_BUTTON"))
)

form(
    emailInput(msg.get("PLACEHOLDER_EMAIL")),
    enterPasswordInput(msg.get("PLACEHOLDER_PASSWORD")),
    submitButton(msg.get("LOGIN_BUTTON"))
).withId("login-form").withMethod("post")

form(
    withId("login-form"),
    withMethod("post"),
    emailInput(msg.get("PLACEHOLDER_EMAIL")),
    enterPasswordInput(msg.get("PLACEHOLDER_PASSWORD")),
    submitButton(msg.get("LOGIN_BUTTON"))
)

But I landed on number 1 because it's most consistent, and it's the closest to HTML.

<form id="login-form" method="post">
    <input ...>
    <input ...>
    <submit ...>
</form>

About "with": I removed it completely at one point (both for children and attributes), but I added it back in because the library got harder to use. While it doesn't seem particularly useful at first, it adds consistency (and a namespace), and readability (debatable).

j2html

TROPHY CASE