Java实现简易ORM框架案例

本文目录导读：

1. 框架核心代码
2. 配置文件和测试代码
3. 框架扩展（可选功能）

我来为您实现一个简易的Java ORM框架,包含核心功能和完整示例。

框架核心代码

1 自定义注解

// Table.java
package com.example.orm.annotation;
import java.lang.annotation.*;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Table {
    String name() default "";
}

// Column.java
package com.example.orm.annotation;
import java.lang.annotation.*;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Column {
    String name() default "";
    boolean isPrimaryKey() default false;
    boolean isAutoIncrement() default false;
}

// Ignore.java
package com.example.orm.annotation;
import java.lang.annotation.*;
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Ignore {
}

2 实体映射工具类

// EntityMapper.java
package com.example.orm.util;
import com.example.orm.annotation.Column;
import com.example.orm.annotation.Table;
import com.example.orm.exception.ORMException;
import java.lang.reflect.Field;
import java.util.*;
public class EntityMapper {
    // 缓存实体映射信息
    private static final Map<Class<?>, EntityInfo> ENTITY_INFO_CACHE = new HashMap<>();
    public static class EntityInfo {
        public Class<?> entityClass;
        public String tableName;
        public Map<String, Field> columnFields = new HashMap<>();
        public Map<String, String> fieldToColumn = new HashMap<>();
        public String primaryKey;
        public Field primaryKeyField;
        public boolean autoIncrement;
    }
    public static EntityInfo getEntityInfo(Class<?> entityClass) {
        return ENTITY_INFO_CACHE.computeIfAbsent(entityClass, EntityMapper::parseEntity);
    }
    private static EntityInfo parseEntity(Class<?> entityClass) {
        EntityInfo info = new EntityInfo();
        info.entityClass = entityClass;
        // 解析表名
        Table table = entityClass.getAnnotation(Table.class);
        if (table == null) {
            throw new ORMException("实体类 " + entityClass.getName() + " 缺少 @Table 注解");
        }
        info.tableName = table.name().isEmpty() ? 
                        camelToUnderscore(entityClass.getSimpleName()) : table.name();
        // 解析字段
        Field[] fields = entityClass.getDeclaredFields();
        for (Field field : fields) {
            // 跳过被@Ignore注解标记的字段
            if (field.isAnnotationPresent(Ignore.class)) {
                continue;
            }
            field.setAccessible(true);
            // 获取列注解
            Column column = field.getAnnotation(Column.class);
            String columnName;
            if (column != null) {
                columnName = column.name().isEmpty() ? 
                           camelToUnderscore(field.getName()) : column.name();
                if (column.isPrimaryKey()) {
                    info.primaryKey = columnName;
                    info.primaryKeyField = field;
                    info.autoIncrement = column.isAutoIncrement();
                }
            } else {
                columnName = camelToUnderscore(field.getName());
            }
            info.columnFields.put(columnName, field);
            info.fieldToColumn.put(field.getName(), columnName);
        }
        if (info.primaryKey == null) {
            throw new ORMException("实体类 " + entityClass.getName() + " 缺少主键字段");
        }
        return info;
    }
    // 驼峰转下划线
    public static String camelToUnderscore(String str) {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < str.length(); i++) {
            char c = str.charAt(i);
            if (Character.isUpperCase(c)) {
                if (i > 0) {
                    result.append('_');
                }
                result.append(Character.toLowerCase(c));
            } else {
                result.append(c);
            }
        }
        return result.toString();
    }
}

3 SQL生成器

// SQLBuilder.java
package com.example.orm.util;
import com.example.orm.exception.ORMException;
import java.lang.reflect.Field;
import java.util.*;
import java.util.stream.Collectors;
public class SQLBuilder {
    // 生成插入SQL
    public static String buildInsertSQL(Object entity) {
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entity.getClass());
        List<String> columns = new ArrayList<>();
        List<String> values = new ArrayList<>();
        for (Map.Entry<String, Field> entry : info.columnFields.entrySet()) {
            String columnName = entry.getKey();
            Field field = entry.getValue();
            // 如果是自动递增主键且值为null或0，跳过
            if (columnName.equals(info.primaryKey) && info.autoIncrement) {
                try {
                    Object value = field.get(entity);
                    if (value == null || (value instanceof Number && ((Number) value).longValue() == 0)) {
                        continue;
                    }
                } catch (IllegalAccessException e) {
                    throw new ORMException("字段访问失败", e);
                }
            }
            columns.add(columnName);
            values.add("?");
        }
        return String.format("INSERT INTO %s (%s) VALUES (%s)", 
               info.tableName, 
               String.join(", ", columns), 
               String.join(", ", values));
    }
    // 生成更新SQL
    public static String buildUpdateSQL(Object entity) {
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entity.getClass());
        List<String> setClauses = new ArrayList<>();
        for (Map.Entry<String, Field> entry : info.columnFields.entrySet()) {
            String columnName = entry.getKey();
            Field field = entry.getValue();
            if (columnName.equals(info.primaryKey)) {
                continue;
            }
            setClauses.add(columnName + " = ?");
        }
        return String.format("UPDATE %s SET %s WHERE %s = ?", 
               info.tableName,
               String.join(", ", setClauses),
               info.primaryKey);
    }
    // 生成删除SQL
    public static String buildDeleteSQL(Class<?> entityClass, Object primaryKey) {
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entityClass);
        return String.format("DELETE FROM %s WHERE %s = ?", 
               info.tableName, info.primaryKey);
    }
    // 生成查询SQL（根据主键）
    public static String buildSelectByIdSQL(Class<?> entityClass) {
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entityClass);
        return String.format("SELECT * FROM %s WHERE %s = ?", 
               info.tableName, info.primaryKey);
    }
    // 生成查询所有SQL
    public static String buildSelectAllSQL(Class<?> entityClass) {
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entityClass);
        return String.format("SELECT * FROM %s", info.tableName);
    }
    // 生成条件查询SQL
    public static String buildSelectByConditionSQL(Class<?> entityClass, 
                                                   Map<String, Object> conditions) {
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entityClass);
        if (conditions.isEmpty()) {
            return buildSelectAllSQL(entityClass);
        }
        String whereClause = conditions.keySet().stream()
               .map(field -> {
                   String column = info.fieldToColumn.getOrDefault(field, field);
                   return column + " = ?";
               })
               .collect(Collectors.joining(" AND "));
        return String.format("SELECT * FROM %s WHERE %s", 
               info.tableName, whereClause);
    }
}

4 JDBC工具类

// JDBCUtil.java
package com.example.orm.util;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
public class JDBCUtil {
    private static String url;
    private static String username;
    private static String password;
    private static String driver;
    static {
        try {
            // 这里简化处理，实际应该从配置文件读取
            Properties props = new Properties();
            props.load(JDBCUtil.class.getResourceAsStream("/db.properties"));
            driver = props.getProperty("jdbc.driver");
            url = props.getProperty("jdbc.url");
            username = props.getProperty("jdbc.username");
            password = props.getProperty("jdbc.password");
            Class.forName(driver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }
    public static void close(AutoCloseable... resources) {
        for (AutoCloseable resource : resources) {
            if (resource != null) {
                try {
                    resource.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

5 简易ORM框架主类

// SimpleORM.java
package com.example.orm;
import com.example.orm.exception.ORMException;
import com.example.orm.util.EntityMapper;
import com.example.orm.util.JDBCUtil;
import com.example.orm.util.SQLBuilder;
import java.lang.reflect.Field;
import java.sql.*;
import java.util.*;
public class SimpleORM {
    private static final SimpleORM INSTANCE = new SimpleORM();
    private SimpleORM() {}
    public static SimpleORM getInstance() {
        return INSTANCE;
    }
    // ========== 基础CRUD操作 ==========
    // 插入
    public int insert(Object entity) {
        String sql = SQLBuilder.buildInsertSQL(entity);
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entity.getClass());
        List<Object> params = new ArrayList<>();
        for (Map.Entry<String, Field> entry : info.columnFields.entrySet()) {
            if (entry.getKey().equals(info.primaryKey) && info.autoIncrement) {
                continue;
            }
            try {
                params.add(entry.getValue().get(entity));
            } catch (IllegalAccessException e) {
                throw new ORMException("获取字段值失败", e);
            }
        }
        // 如果主键是自动生成，并且支持，则在插入后获取
        try (Connection conn = JDBCUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql, 
                    info.autoIncrement ? Statement.RETURN_GENERATED_KEYS : 
                                         Statement.NO_GENERATED_KEYS)) {
            for (int i = 0; i < params.size(); i++) {
                ps.setObject(i + 1, params.get(i));
            }
            int affectedRows = ps.executeUpdate();
            if (info.autoIncrement && affectedRows > 0) {
                try (ResultSet rs = ps.getGeneratedKeys()) {
                    if (rs.next()) {
                        info.primaryKeyField.set(entity, rs.getObject(1));
                    }
                }
            }
            return affectedRows;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // 更新
    public int update(Object entity) {
        String sql = SQLBuilder.buildUpdateSQL(entity);
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entity.getClass());
        List<Object> params = new ArrayList<>();
        for (Map.Entry<String, Field> entry : info.columnFields.entrySet()) {
            if (entry.getKey().equals(info.primaryKey)) {
                continue;
            }
            try {
                params.add(entry.getValue().get(entity));
            } catch (IllegalAccessException e) {
                throw new ORMException("获取字段值失败", e);
            }
        }
        // 添加主键值
        try {
            params.add(info.primaryKeyField.get(entity));
        } catch (IllegalAccessException e) {
            throw new ORMException("获取主键值失败", e);
        }
        try (Connection conn = JDBCUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            for (int i = 0; i < params.size(); i++) {
                ps.setObject(i + 1, params.get(i));
            }
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }
    // 删除
    public int delete(Class<?> entityClass, Object primaryKey) {
        String sql = SQLBuilder.buildDeleteSQL(entityClass, primaryKey);
        try (Connection conn = JDBCUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            ps.setObject(1, primaryKey);
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }
    // 根据主键查询
    public <T> T selectById(Class<T> entityClass, Object primaryKey) {
        String sql = SQLBuilder.buildSelectByIdSQL(entityClass);
        try (Connection conn = JDBCUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            ps.setObject(1, primaryKey);
            try (ResultSet rs = ps.executeQuery()) {
                if (rs.next()) {
                    return mapRowToEntity(entityClass, rs);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
    // 查询所有
    public <T> List<T> selectAll(Class<T> entityClass) {
        String sql = SQLBuilder.buildSelectAllSQL(entityClass);
        List<T> list = new ArrayList<>();
        try (Connection conn = JDBCUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql);
             ResultSet rs = ps.executeQuery()) {
            while (rs.next()) {
                list.add(mapRowToEntity(entityClass, rs));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }
    // 条件查询
    public <T> List<T> selectByCondition(Class<T> entityClass, 
                                         Map<String, Object> conditions) {
        String sql = SQLBuilder.buildSelectByConditionSQL(entityClass, conditions);
        List<T> list = new ArrayList<>();
        try (Connection conn = JDBCUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            int index = 1;
            for (Object value : conditions.values()) {
                ps.setObject(index++, value);
            }
            try (ResultSet rs = ps.executeQuery()) {
                while (rs.next()) {
                    list.add(mapRowToEntity(entityClass, rs));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }
    // 通用查询
    public <T> List<T> query(Class<T> entityClass, String sql, Object... params) {
        List<T> list = new ArrayList<>();
        try (Connection conn = JDBCUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            try (ResultSet rs = ps.executeQuery()) {
                while (rs.next()) {
                    list.add(mapRowToEntity(entityClass, rs));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }
    // 执行更新操作
    public int executeUpdate(String sql, Object... params) {
        try (Connection conn = JDBCUtil.getConnection();
             PreparedStatement ps = conn.prepareStatement(sql)) {
            if (params != null) {
                for (int i = 0; i < params.length; i++) {
                    ps.setObject(i + 1, params[i]);
                }
            }
            return ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }
    // 结果集映射到实体
    private <T> T mapRowToEntity(Class<T> entityClass, ResultSet rs) 
            throws Exception {
        EntityMapper.EntityInfo info = EntityMapper.getEntityInfo(entityClass);
        T entity = entityClass.getDeclaredConstructor().newInstance();
        for (Map.Entry<String, Field> entry : info.columnFields.entrySet()) {
            String columnName = entry.getKey();
            Field field = entry.getValue();
            Object value = rs.getObject(columnName);
            if (value != null) {
                // 类型转换
                value = convertValue(value, field.getType());
                field.set(entity, value);
            }
        }
        return entity;
    }
    // 值类型转换
    private Object convertValue(Object value, Class<?> targetType) {
        if (value == null) return null;
        if (targetType.isInstance(value)) {
            return value;
        }
        if (targetType == Integer.class && value instanceof Number) {
            return ((Number) value).intValue();
        }
        if (targetType == Long.class && value instanceof Number) {
            return ((Number) value).longValue();
        }
        if (targetType == Double.class && value instanceof Number) {
            return ((Number) value).doubleValue();
        }
        if (targetType == Boolean.class) {
            if (value instanceof Number) {
                return ((Number) value).intValue() != 0;
            }
            return Boolean.valueOf(value.toString());
        }
        if (targetType == String.class) {
            return value.toString();
        }
        if (targetType == Date.class) {
            if (value instanceof java.sql.Date) {
                return new Date(((java.sql.Date) value).getTime());
            }
            if (value instanceof java.sql.Timestamp) {
                return new Date(((java.sql.Timestamp) value).getTime());
            }
        }
        return value;
    }
    // 事务支持
    public <T> T executeInTransaction(TransactionCallback<T> callback) {
        try (Connection conn = JDBCUtil.getConnection()) {
            boolean originalAutoCommit = conn.getAutoCommit();
            conn.setAutoCommit(false);
            try {
                T result = callback.doInTransaction(conn);
                conn.commit();
                return result;
            } catch (Exception e) {
                conn.rollback();
                throw new ORMException("事务执行失败", e);
            } finally {
                conn.setAutoCommit(originalAutoCommit);
            }
        } catch (SQLException e) {
            throw new ORMException("获取连接失败", e);
        }
    }
    @FunctionalInterface
    public interface TransactionCallback<T> {
        T doInTransaction(Connection conn) throws Exception;
    }
}

6 自定义异常

// ORMException.java
package com.example.orm.exception;
public class ORMException extends RuntimeException {
    public ORMException(String message) {
        super(message);
    }
    public ORMException(String message, Throwable cause) {
        super(message, cause);
    }
}

配置文件和测试代码

1 数据库配置文件 db.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/orm_demo?useSSL=false&serverTimezone=Asia/Shanghai&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

2 实体类

// User.java
package com.example.entity;
import com.example.orm.annotation.Column;
import com.example.orm.annotation.Table;
import java.util.Date;
@Table(name = "t_user")
public class User {
    @Column(name = "id", isPrimaryKey = true, isAutoIncrement = true)
    private Long id;
    @Column(name = "username")
    private String username;
    @Column(name = "password")
    private String password;
    @Column(name = "email")
    private String email;
    @Column(name = "age")
    private Integer age;
    @Column(name = "create_time")
    private Date createTime;
    @Column(name = "update_time")
    private Date updateTime;
    // getter和setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public Integer getAge() { return age; }
    public void setAge(Integer age) { this.age = age; }
    public Date getCreateTime() { return createTime; }
    public void setCreateTime(Date createTime) { this.createTime = createTime; }
    public Date getUpdateTime() { return updateTime; }
    public void setUpdateTime(Date updateTime) { this.updateTime = updateTime; }
    @Override
    public String toString() {
        return String.format("User{id=%d, username='%s', email='%s', age=%d, createTime=%s}", 
               id, username, email, age, createTime);
    }
}

// Order.java
package com.example.entity;
import com.example.orm.annotation.Column;
import com.example.orm.annotation.Table;
import java.math.BigDecimal;
import java.util.Date;
@Table(name = "t_order")
public class Order {
    @Column(name = "id", isPrimaryKey = true, isAutoIncrement = true)
    private Long id;
    @Column(name = "order_no")
    private String orderNo;
    @Column(name = "user_id")
    private Long userId;
    @Column(name = "total_amount")
    private BigDecimal totalAmount;
    @Column(name = "status")
    private Integer status;
    @Column(name = "create_time")
    private Date createTime;
    // getter和setter方法
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getOrderNo() { return orderNo; }
    public void setOrderNo(String orderNo) { this.orderNo = orderNo; }
    public Long getUserId() { return userId; }
    public void setUserId(Long userId) { this.userId = userId; }
    public BigDecimal getTotalAmount() { return totalAmount; }
    public void setTotalAmount(BigDecimal totalAmount) { this.totalAmount = totalAmount; }
    public Integer getStatus() { return status; }
    public void setStatus(Integer status) { this.status = status; }
    public Date getCreateTime() { return createTime; }
    public void setCreateTime(Date createTime) { this.createTime = createTime; }
    @Override
    public String toString() {
        return String.format("Order{id=%d, orderNo='%s', userId=%d, amount=%s, status=%d}", 
               id, orderNo, userId, totalAmount, status);
    }
}

3 测试代码

// SimpleORMTest.java
package com.example.test;
import com.example.entity.Order;
import com.example.entity.User;
import com.example.orm.SimpleORM;
import com.example.orm.util.EntityMapper;
import java.math.BigDecimal;
import java.util.*;
public class SimpleORMTest {
    public static void main(String[] args) {
        SimpleORM orm = SimpleORM.getInstance();
        // 测试用户CRUD
        testUserCRUD(orm);
        System.out.println("==================");
        // 测试订单CRUD
        testOrderCRUD(orm);
        System.out.println("==================");
        // 测试事务
        testTransaction(orm);
    }
    // 测试用户CRUD
    private static void testUserCRUD(SimpleORM orm) {
        System.out.println("=== 测试用户CRUD ===");
        // 创建用户
        User user = new User();
        user.setUsername("张三");
        user.setPassword("123456");
        user.setEmail("zhangsan@example.com");
        user.setAge(25);
        user.setCreateTime(new Date());
        user.setUpdateTime(new Date());
        int result = orm.insert(user);
        System.out.println("插入结果: " + result + ", 生成ID: " + user.getId());
        // 查询单个
        User userFromDB = orm.selectById(User.class, user.getId());
        System.out.println("查询单个: " + userFromDB);
        // 更新用户
        userFromDB.setEmail("zhangsan_new@example.com");
        userFromDB.setAge(26);
        userFromDB.setUpdateTime(new Date());
        result = orm.update(userFromDB);
        System.out.println("更新结果: " + result);
        // 条件查询
        Map<String, Object> conditions = new HashMap<>();
        conditions.put("age", 26);
        conditions.put("username", "张三");
        List<User> userList = orm.selectByCondition(User.class, conditions);
        System.out.println("条件查询结果数量: " + userList.size());
        userList.forEach(System.out::println);
        // 查询所有
        List<User> allUsers = orm.selectAll(User.class);
        System.out.println("所有用户数量: " + allUsers.size());
        // 删除
        result = orm.delete(User.class, user.getId());
        System.out.println("删除结果: " + result);
    }
    // 测试订单CRUD
    private static void testOrderCRUD(SimpleORM orm) {
        System.out.println("=== 测试订单CRUD ===");
        // 创建订单
        Order order = new Order();
        order.setOrderNo("ORD" + System.currentTimeMillis());
        order.setUserId(1L);
        order.setTotalAmount(new BigDecimal("199.99"));
        order.setStatus(0); // 0:待支付, 1:已支付, 2:已发货
        order.setCreateTime(new Date());
        int result = orm.insert(order);
        System.out.println("插入结果: " + result + ", 生成ID: " + order.getId());
        // 查询订单
        Order orderFromDB = orm.selectById(Order.class, order.getId());
        System.out.println("查询订单: " + orderFromDB);
        // 更新订单
        orderFromDB.setStatus(1);
        result = orm.update(orderFromDB);
        System.out.println("更新结果: " + result);
        // 使用原生SQL查询
        List<Order> orders = orm.query(Order.class, 
                "SELECT * FROM t_order WHERE user_id = ?", 1L);
        System.out.println("原生SQL查询结果数量: " + orders.size());
        // 删除
        result = orm.delete(Order.class, order.getId());
        System.out.println("删除结果: " + result);
    }
    // 测试事务
    private static void testTransaction(SimpleORM orm) {
        System.out.println("=== 测试事务 ===");
        try {
            Boolean success = orm.executeInTransaction(conn -> {
                // 创建用户
                User user = new User();
                user.setUsername("事务用户");
                user.setPassword("123456");
                user.setEmail("tx@example.com");
                user.setAge(30);
                user.setCreateTime(new Date());
                user.setUpdateTime(new Date());
                // 手动插入
                insertUser(conn, user);
                // 创建订单
                Order order = new Order();
                order.setOrderNo("TX" + System.currentTimeMillis());
                order.setUserId(user.getId());
                order.setTotalAmount(new BigDecimal("88.88"));
                order.setStatus(0);
                order.setCreateTime(new Date());
                insertOrder(conn, order);
                System.out.println("事务中的用户ID: " + user.getId());
                System.out.println("事务中的订单ID: " + order.getId());
                return true;
            });
            System.out.println("事务执行结果: " + success);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static void insertUser(Connection conn, User user) throws SQLException {
        String sql = "INSERT INTO t_user (username, password, email, age, create_time, update_time) " +
                    "VALUES (?, ?, ?, ?, ?, ?)";
        try (PreparedStatement ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
            ps.setString(1, user.getUsername());
            ps.setString(2, user.getPassword());
            ps.setString(3, user.getEmail());
            ps.setInt(4, user.getAge());
            ps.setTimestamp(5, new java.sql.Timestamp(user.getCreateTime().getTime()));
            ps.setTimestamp(6, new java.sql.Timestamp(user.getUpdateTime().getTime()));
            ps.executeUpdate();
            try (ResultSet rs = ps.getGeneratedKeys()) {
                if (rs.next()) {
                    user.setId(rs.getLong(1));
                }
            }
        }
    }
    private static void insertOrder(Connection conn, Order order) throws SQLException {
        String sql = "INSERT INTO t_order (order_no, user_id, total_amount, status, create_time) " +
                    "VALUES (?, ?, ?, ?, ?)";
        try (PreparedStatement ps = conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
            ps.setString(1, order.getOrderNo());
            ps.setLong(2, order.getUserId());
            ps.setBigDecimal(3, order.getTotalAmount());
            ps.setInt(4, order.getStatus());
            ps.setTimestamp(5, new java.sql.Timestamp(order.getCreateTime().getTime()));
            ps.executeUpdate();
            try (ResultSet rs = ps.getGeneratedKeys()) {
                if (rs.next()) {
                    order.setId(rs.getLong(1));
                }
            }
        }
    }
}

4 数据库建表SQL

-- 创建数据库
CREATE DATABASE IF NOT EXISTS orm_demo DEFAULT CHARACTER SET utf8mb4;
USE orm_demo;
-- 用户表
CREATE TABLE IF NOT EXISTS t_user (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(50) NOT NULL COMMENT '用户名',
    password VARCHAR(100) NOT NULL COMMENT '密码',
    email VARCHAR(100) COMMENT '邮箱',
    age INT COMMENT '年龄',
    create_time DATETIME COMMENT '创建时间',
    update_time DATETIME COMMENT '更新时间'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-- 订单表
CREATE TABLE IF NOT EXISTS t_order (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    order_no VARCHAR(50) NOT NULL COMMENT '订单号',
    user_id BIGINT NOT NULL COMMENT '用户ID',
    total_amount DECIMAL(10,2) COMMENT '订单总金额',
    status INT DEFAULT 0 COMMENT '订单状态',
    create_time DATETIME COMMENT '创建时间'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

5 Maven依赖配置

<!-- pom.xml -->
<dependencies>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
    <!-- 日志框架（可选） -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.7.36</version>
    </dependency>
</dependencies>

框架扩展（可选功能）

1 序列化支持

// Serializer.java
package com.example.orm.util;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Serializer {
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static String serialize(Object value) {
        if (value == null) return "NULL";
        if (value instanceof Date) {
            return "'" + DATE_FORMAT.format((Date) value) + "'";
        }
        if (value instanceof Number || value instanceof Boolean) {
            return value.toString();
        }
        return "'" + value.toString().replace("'", "''") + "'";
    }
}

2 查询装饰器

// QueryBuilder.java
package com.example.orm.util;
public class QueryBuilder {
    private StringBuilder sql = new StringBuilder();
    private List<Object> params = new ArrayList<>();
    public static QueryBuilder select(String columns) {
        QueryBuilder qb = new QueryBuilder();
        qb.sql.append("SELECT ").append(columns);
        return qb;
    }
    public QueryBuilder from(String table) {
        sql.append(" FROM ").append(table);
        return this;
    }
    public QueryBuilder where(String condition, Object... args) {
        sql.append(" WHERE ").append(condition);
        params.addAll(Arrays.asList(args));
        return this;
    }
    public QueryBuilder orderBy(String column, boolean asc) {
        sql.append(" ORDER BY ").append(column);
        sql.append(asc ? " ASC" : " DESC");
        return this;
    }
    public QueryBuilder limit(int count) {
        sql.append(" LIMIT ").append(count);
        return this;
    }
    public String toSQL() {
        return sql.toString();
    }
    public Object[] getParams() {
        return params.toArray();
    }
}

这个简易ORM框架包含了：

1. 注解支持：使用自定义注解实现实体到数据库表的映射
2. CRUD操作：提供基础的增删改查操作
3. SQL生成：自动生成SQL语句
4. 事务支持：支持数据库事务
5. 类型转换：自动处理Java类型与数据库类型转换
6. 缓存机制：缓存实体映射信息提高性能

这个框架简单易懂，适合学习ORM原理，实际生产环境建议使用成熟的ORM框架如MyBatis、Hibernate等。