本文目录导读：
我来为您实现一个简易的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框架包含了：
- 注解支持：使用自定义注解实现实体到数据库表的映射
- CRUD操作：提供基础的增删改查操作
- SQL生成：自动生成SQL语句
- 事务支持：支持数据库事务
- 类型转换：自动处理Java类型与数据库类型转换
- 缓存机制：缓存实体映射信息提高性能
这个框架简单易懂，适合学习ORM原理，实际生产环境建议使用成熟的ORM框架如MyBatis、Hibernate等。
