Python for Java Developers: Building Real Applications - III
· 7 min read
Based on our progression and your background as a Java developer, here's what would be most valuable for Chapater 3:
📊 Chapater 3: Production-Ready Python - Building Real Applications
Why This Should Be Next:
- Practical Application: You now know Python syntax and functional programming
- Career Relevance: These are skills you'll use daily in production
- Java Context: You'll appreciate Python's approach to problems you've solved in Java
🎯 Proposed Chapter Outline for Part 3:
1. Web Development: FastAPI vs Spring Boot
# Compare building REST APIs
# Java: @RestController, @GetMapping, Spring Data JPA
# Python: FastAPI with Pydantic, SQLAlchemy
from fastapi import FastAPI, HTTPException, Depends
from sqlalchemy.orm import Session
from pydantic import BaseModel
from typing import List
app = FastAPI()
class UserCreate(BaseModel): # Like DTO
name: str
email: str
age: int
@app.get("/users/{user_id}") # Like @GetMapping
async def get_user(user_id: int, db: Session = Depends(get_db)):
# Auto OpenAPI docs, validation, async support
pass
2. Database & ORM: SQLAlchemy vs Hibernate
# Compare ORM patterns
# Java: EntityManager, JPA annotations, Hibernate
# Python: SQLAlchemy declarative, Alembic migrations
from sqlalchemy import Column, Integer, String, create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
Base = declarative_base()
class User(Base): # Like @Entity
__tablename__ = 'users' # Like @Table
id = Column(Integer, primary_key=True) # Like @Id
name = Column(String(50), nullable=False)
email = Column(String(100), unique=True)
# Relationships, eager loading, lazy loading comparison
3. Dependency Injection & IoC Containers
# Compare dependency management
# Java: @Autowired, @Component, ApplicationContext
# Python: FastAPI Depends, dependency-injector
from dependency_injector import containers, providers
from fastapi import Depends
class ServiceContainer(containers.DeclarativeContainer):
# Like @Configuration in Spring
user_repository = providers.Singleton(UserRepository)
user_service = providers.Factory(UserService, user_repository)
@app.get("/users")
def get_users(service: UserService = Depends(ServiceContainer.user_service)):
# Like @Autowired
return service.get_all()
4. Testing in Production: Beyond Unit Tests
# Compare testing strategies
# Java: JUnit, Mockito, SpringBootTest, TestContainers
# Python: pytest fixtures, factory_boy, testcontainers
import pytest
from testcontainers.postgres import PostgresContainer
@pytest.fixture(scope="session")
def postgres_container():
# Like TestContainers in Java
with PostgresContainer("postgres:15") as postgres:
yield postgres
@pytest.mark.integration
async def test_database_integration(postgres_container):
# Integration tests with real database
pass
5. Concurrency & Parallelism
# Compare concurrency models
# Java: Thread, ExecutorService, CompletableFuture
# Python: asyncio, threading, multiprocessing, concurrent.futures
import asyncio
import concurrent.futures
from typing import List
# CPU-bound tasks (like Java ForkJoinPool)
def cpu_intensive(x: int) -> int:
return x * x
with concurrent.futures.ProcessPoolExecutor() as executor:
results = list(executor.map(cpu_intensive, range(10)))
# I/O-bound tasks (like Java virtual threads)
async def fetch_multiple(urls: List[str]) -> List[str]:
tasks = [fetch_url(url) for url in urls]
return await asyncio.gather(*tasks)
6. Data Processing: Pandas vs Java Streams/DataFrame APIs
# Compare data manipulation
# Java: Stream API, Spark DataFrame, Joinery
# Python: Pandas, Polars, DuckDB
import pandas as pd
import polars as pl
# Pandas (like Spark DataFrame but in-memory)
df = pd.read_csv("data.csv")
result = (df[df['age'] >= 18]
.groupby('department')
.agg({'salary': 'mean', 'count': 'size'})
.reset_index())
# Polars (faster, Rust-based, like modern DataFrame API)
df_pl = pl.read_csv("data.csv")
result_pl = (df_pl.filter(pl.col("age") >= 18)
.groupby("department")
.agg([
pl.col("salary").mean().alias("avg_salary"),
pl.count().alias("employee_count")
]))
7. Build & Dependency Management
# Compare build tools and dependency management
# Java: Maven pom.xml, Gradle build.gradle
# Python: pyproject.toml, requirements.txt, Poetry, pipenv
# pyproject.toml (like pom.xml)
"""
[tool.poetry]
name = "my-project"
version = "1.0.0"
[tool.poetry.dependencies]
python = "^3.8"
fastapi = "^0.100.0"
sqlalchemy = "^2.0.0"
[tool.poetry.group.dev.dependencies]
pytest = "^7.0.0"
mypy = "^1.0.0"
[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"
"""
8. Monitoring & Observability
# Compare monitoring approaches
# Java: Micrometer, Spring Boot Actuator, Prometheus
# Python: Prometheus client, OpenTelemetry, structlog
from prometheus_client import Counter, Histogram, generate_latest
import structlog
# Metrics (like Micrometer)
REQUEST_COUNT = Counter('http_requests_total', 'Total HTTP requests')
REQUEST_DURATION = Histogram('http_request_duration_seconds', 'HTTP request duration')
# Structured logging (like SLF4J with JSON layout)
logger = structlog.get_logger()
logger.info("user_login", user_id=123, ip="192.168.1.1")
9. Configuration Management
# Compare configuration approaches
# Java: Spring @Value, application.properties, Config Server
# Python: pydantic-settings, python-decouple, dynaconf
from pydantic_settings import BaseSettings
from functools import lru_cache
class Settings(BaseSettings): # Like @ConfigurationProperties
database_url: str
api_key: str
debug: bool = False
class Config:
env_file = ".env" # Like application.properties
@lru_cache
def get_settings():
return Settings()
10. Deployment & Containerization
# Compare deployment strategies
# Java: JAR files, Docker, Kubernetes manifests
# Python: Docker multi-stage builds, Poetry install, gunicorn
# Dockerfile comparison
"""
# Java Dockerfile
FROM openjdk:17-jdk-slim
COPY target/myapp.jar /app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]
# Python Dockerfile
FROM python:3.11-slim as builder
COPY pyproject.toml poetry.lock ./
RUN pip install poetry && poetry install --no-root
FROM python:3.11-slim
COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
"""
🎯 Real-World Complete Example: Building a Microservice
Let's build a complete user service from scratch, comparing Java and Python approaches:
# Complete FastAPI microservice with all best practices
# Java equivalent would be Spring Boot + Spring Data + Lombok
from fastapi import FastAPI, Depends, HTTPException, status
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, Session
from pydantic import BaseModel, EmailStr, validator
from typing import List, Optional
import redis
from prometheus_client import Counter, generate_latest
import structlog
import uvicorn
from contextlib import asynccontextmanager
# ========== MODELS ==========
Base = declarative_base()
class UserModel(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True)
email = Column(String, unique=True, index=True)
name = Column(String)
age = Column(Integer)
# ========== SCHEMAS ==========
class UserCreate(BaseModel):
email: EmailStr
name: str
age: int
@validator('age')
def validate_age(cls, v):
if v < 0 or v > 150:
raise ValueError('Age must be between 0 and 150')
return v
class UserResponse(BaseModel):
id: int
email: str
name: str
age: int
class Config:
from_attributes = True # For SQLAlchemy model conversion
# ========== SERVICES ==========
class UserService:
def __init__(self, db: Session, cache):
self.db = db
self.cache = cache
def create_user(self, user_data: UserCreate) -> UserModel:
# Check cache first
cache_key = f"user:email:{user_data.email}"
if self.cache.exists(cache_key):
raise HTTPException(status_code=400, detail="User already exists")
# Create in database
db_user = UserModel(**user_data.dict())
self.db.add(db_user)
self.db.commit()
self.db.refresh(db_user)
# Update cache
self.cache.set(cache_key, "exists", ex=3600)
return db_user
def get_users(self, skip: int = 0, limit: int = 100) -> List[UserModel]:
return self.db.query(UserModel).offset(skip).limit(limit).all()
# ========== DEPENDENCIES ==========
def get_db():
db = SessionLocal()
try:
yield db
finally:
db.close()
def get_cache():
return redis.Redis(host='localhost', port=6379, db=0)
def get_user_service(
db: Session = Depends(get_db),
cache = Depends(get_cache)
) -> UserService:
return UserService(db, cache)
# ========== METRICS ==========
USER_CREATE_COUNT = Counter('user_create_total', 'Total user creations')
# ========== LIFECYCLE ==========
@asynccontextmanager
async def lifespan(app: FastAPI):
# Startup
logger.info("Starting application")
engine = create_engine("sqlite:///./test.db")
Base.metadata.create_all(bind=engine)
yield
# Shutdown
logger.info("Shutting down")
# ========== APP ==========
app = FastAPI(lifespan=lifespan)
logger = structlog.get_logger()
# Database setup
engine = create_engine("sqlite:///./test.db")
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
# ========== ENDPOINTS ==========
@app.post("/users", response_model=UserResponse, status_code=status.HTTP_201_CREATED)
def create_user(
user: UserCreate,
service: UserService = Depends(get_user_service)
):
USER_CREATE_COUNT.inc()
logger.info("Creating user", email=user.email)
try:
db_user = service.create_user(user)
return db_user
except Exception as e:
logger.error("Failed to create user", error=str(e))
raise HTTPException(status_code=500, detail=str(e))
@app.get("/users", response_model=List[UserResponse])
def read_users(
skip: int = 0,
limit: int = 100,
service: UserService = Depends(get_user_service)
):
users = service.get_users(skip=skip, limit=limit)
return users
@app.get("/metrics")
def metrics():
return generate_latest()
# ========== MAIN ==========
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000)
📚 What Makes This Chapter Critical for You:
As a Java Developer, You'll Appreciate:
- Pattern Recognition: Seeing familiar patterns (DI, ORM, REST) implemented differently
- Productivity Comparison: How much faster you can build things in Python
- Trade-off Understanding: Where Python shines vs where Java is better
- Career Expansion: Adding Python to your toolkit for full-stack/data/ML roles
Key Comparisons to Highlight:
- Spring Boot Actuator vs FastAPI auto-docs + Prometheus
- JPA/Hibernate vs SQLAlchemy
- Maven/Gradle vs Poetry/pip
- JUnit/Mockito vs pytest/unittest.mock
- Lombok vs Python dataclasses
🎯 Learning Outcomes from Part 3:
After this chapter, you'll be able to:
- Build production-ready Python microservices from scratch
- Make informed decisions about when to use Python vs Java
- Understand the Python ecosystem equivalents of Java tools
- Write enterprise-grade Python with proper testing, monitoring, and deployment
- Transition Java projects to Python where appropriate
🚀 Suggested Practical Exercise:
Convert a Spring Boot microservice to FastAPI:
- Take a simple Java service (e.g., user management with JPA)
- Rewrite it in Python using the patterns from this chapter
- Compare:
- Lines of code
- Development time
- Performance characteristics
- Memory usage
- Developer experience