Flask vs Old Tools: What Changed for Java Developers

Java to Python · Web Frameworks

Flask vs Old Tools: What Changed for Java Developers

SECTION 01The old workflow — JSP + Servlets + XML

If you started Java web development before Spring Boot, you remember the pain: XML config, WAR files, containers like Tomcat and JBoss, and reams of boilerplate before you could serve a page.

• XML-heavy config: web.xml, spring-beans.xml, struts-config.xml — none of it was type-safe.
• Slow startup: deploy cycle = restart the container, wait 30s.
• Fragmented stack: different libraries for routing, templating, DB, JSON.
• Heavy ceremony: 50+ lines of Java for a "Hello World" endpoint.
• JSP for templates: mixing Java code inside HTML — poor separation.

SECTION 02What Flask changed

Flask is a "microframework" — it gives you just routing, templating and request handling, and lets you add everything else via extensions. For Java devs, the shift is dramatic:

// Old Java — Servlet + JSP + web.xml
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse res)
            throws ServletException, IOException {
        req.setAttribute("name", req.getParameter("name"));
        RequestDispatcher view = req.getRequestDispatcher("/hello.jsp");
        view.forward(req, res);
    }
}

// web.xml
/*
<servlet>
  <servlet-name>hello</servlet-name>
  <servlet-class>com.example.HelloServlet</servlet-class>
</servlet>
<servlet-mapping>
  <servlet-name>hello</servlet-name>
  <url-pattern>/hello</url-pattern>
</servlet-mapping>
*/

// hello.jsp
/*
<h1>Hello, ${name}!</h1>
*/

# Flask — the whole app in one file
from flask import Flask, request, render_template_string

app = Flask(__name__)

TEMPLATE = """
<h1>Hello, {{ name }}!</h1>
"""

@app.route("/hello")
def hello():
    name = request.args.get("name", "world")
    return render_template_string(TEMPLATE, name=name)

if __name__ == "__main__":
    app.run(debug=True)

SECTION 03Java → Flask concept map

If you're a Java developer, most of your mental models transfer directly. Here's the translation table:

SECTION 04Common mistakes Java devs make

• Over-engineering with classes: Python rewards simple functions — don't recreate Java service layers.
• Ignoring virtualenv: always isolate dependencies — never install globally.
• Bringing DI frameworks: Flask doesn't need Spring-style DI; imports are enough.
• Writing getters/setters for everything: Python prefers simple public attributes and @property where needed.
• Not using type hints: Python 3.10+ has excellent typing — use it like you used Java types.
• Pretending it's not production-grade: Flask + Gunicorn + nginx is used by companies serving billions of requests.

SECTION 05Flask → FastAPI: the next step

If you're building APIs (not full HTML pages), FastAPI is often a better next step than Flask — it's like Java's Spring Boot in spirit but much simpler:

• Type hints everywhere — validation built-in (like Spring's @Valid, but automatic).
• Async by default — great for I/O-heavy services.
• Auto-generated OpenAPI docs — free documentation.
• Pydantic models — like Java records, but with runtime validation.
• Same ideas as Spring Boot — DI via function parameters, request-scoped dependencies.

SECTION 06Interview Q&A — Flask for Java devs

SECTION 07Test yourself — Flask for Java devs quiz

SECTION 08Frequently asked questions

SECTION 09Related reads