核心技術靠化緣是要不來的——自己動手寫ORM框架

老錢發表於2018-04-28

ORM框架

開源市場上的Java的ORM框架一個都不好用，所以花了幾天時間自己擼了一個 OrmKids，歡迎大家下載學習。遇到問題請關注公眾號進群大家一起討論。

OrmKids

支援分庫分表的MySQL單表ORM框架，暫用於學習，後續會在生產環境進行檢驗

功能特性

程式碼簡潔，沒有任何依賴項，除了使用時需要用到MySQL driver
易於使用，無須複雜的配置
提供自動建立表功能
支援分庫又分表，可以只分庫，也可以只分表
支援groupby/having
支援原生SQL
支援事件回撥，可用於服務跟蹤除錯和動態sql改寫

不支援多表關聯

多表比較複雜，實現成本高，學習成本也高，容易出錯
常用的多表的操作一般都可以使用多條單表操作組合實現
在分庫分表的場合，很少使用多表操作
不使用外來鍵，專注於sql邏輯

db.withinTx

對於複雜的多表查詢和批量資料處理，可以使用該方法。使用者可以獲得原生的jdbc連結，通過編寫jdbc程式碼來實現。

Q

使用者可以使用Q物件構建複雜的SQL查詢

其它資料庫支援

暫時沒有

實體介面

/**
 * 所有的實體類必須實現該介面
 */
public interface IEntity {

	/**
	 * 表名
	 * @return
	 */
	String table();

	/**
	 * 分表必須覆蓋此方法
	 * @return
	 */
	default String suffix() {
		return null;
	}

	default String tableWithSuffix() {
		return tableWith(suffix());
	}

	default String tableWith(String suffix) {
		return Utils.tableWithSuffix(table(), suffix);
	}
	
	/**
	 * 定義表的物理結構屬性如engine=innodb，用於動態建立表
	 * @return
	 */
	TableOptions options();

	/**
	 * 定義表的主鍵和索引資訊，用於動態建立表
	 * @return
	 */
	TableIndices indices();

}
複製程式碼

單表單主鍵

@Table
public class User implements IEntity {

	@Column(name = "id", type = "int", autoincrement = true, nullable = false)
	private Integer id;
	@Column(name = "name", type = "varchar(255)", nullable = false)
	private String name;
	@Column(name = "nick", type = "varchar(255)", nullable = false)
	private String nick;
	@Column(name = "passwd", type = "varchar(255)")
	private String passwd;
	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
	private Date createdAt;

	public User() {
	}

	public User(String name, String nick, String passwd) {
		this.name = name;
		this.nick = nick;
		this.passwd = passwd;
	}

	public Integer getId() {
		return id;
	}

	public String getName() {
		return name;
	}

	public String getNick() {
		return nick;
	}

	public String getPasswd() {
		return passwd;
	}

	public Date getCreatedAt() {
		return createdAt;
	}

	@Override
	public TableOptions options() {
		return new TableOptions().option("engine", "innodb");
	}

	@Override
	public TableIndices indices() {
		return new TableIndices().primary("id").unique("name");
	}

	@Override
	public String table() {
		return "user";
	}

}

複製程式碼

單表複合主鍵

@Table
public class Member implements IEntity {

	@Column(name = "user_id", type = "int", nullable = false)
	private Integer userId;
	@Column(name = "group_id", type = "int", nullable = false)
	private Integer groupId;
	@Column(name = "title", type = "varchar(255)")
	private String title;
	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
	private Date createdAt;

	public Member() {
	}

	public Member(Integer userId, Integer groupId, String title, Date createdAt) {
		this.userId = userId;
		this.groupId = groupId;
		this.title = title;
		this.createdAt = createdAt;
	}

	public Integer getUserId() {
		return userId;
	}

	public Integer getGroupId() {
		return groupId;
	}

	public String getTitle() {
		return title;
	}

	public Date getCreatedAt() {
		return createdAt;
	}

	@Override
	public TableOptions options() {
		return new TableOptions().option("engine", "innodb");
	}

	@Override
	public TableIndices indices() {
		return new TableIndices().primary("user_id", "group_id");
	}

	@Override
	public String table() {
		return "member";
	}

}
複製程式碼

分庫介面

public interface IGridable<T extends IEntity> {

	/**
	 * 根據實體物件選擇分庫索引
	 */
	int select(int dbs, T t);

	/**
	 * 根據特定引數選擇分庫索引
	 */
	int select(int dbs, Object... params);

}
複製程式碼

分庫分表

@Table
public class BookShelf implements IEntity {

	public final static int PARTITIONS = 4;

	@Column(name = "user_id", type = "varchar(255)", nullable = false)
	private String userId;
	@Column(name = "book_id", type = "varchar(255)", nullable = false)
	private String bookId;
	@Column(name = "comment", type = "varchar(255)")
	private String comment;
	@Column(name = "created_at", type = "datetime", nullable = false, defaultValue = "now()")
	private Date createdAt;

	public BookShelf() {
	}

	public BookShelf(String userId, String bookId, String comment, Date createdAt) {
		this.userId = userId;
		this.bookId = bookId;
		this.comment = comment;
		this.createdAt = createdAt;
	}

	public String getUserId() {
		return userId;
	}

	public String getBookId() {
		return bookId;
	}

	public void setComment(String comment) {
		this.comment = comment;
	}

	public String getComment() {
		return comment;
	}

	public Date getCreatedAt() {
		return createdAt;
	}

	@Override
	public String table() {
		return "book_shelf";
	}

	@Override
	public TableOptions options() {
		return new TableOptions().option("engine", "innodb");
	}

	@Override
	public TableIndices indices() {
		return new TableIndices().primary("user_id", "book_id");
	}

	/* 
	 * 分表策略
	 */
	@Override
	public String suffix() {
		var crc32 = new CRC32();
		crc32.update(userId.getBytes(Utils.UTF8));
		return String.valueOf(Math.abs(crc32.getValue()) % PARTITIONS);
	}

	/**
	 * 分庫策略
	 */
	public static class GridStrategy<D extends DB> implements IGridable<BookShelf> {

		@Override
		public int select(int dbs, BookShelf t) {
			return Math.abs(t.getUserId().hashCode()) % dbs;
		}

		@Override
		public int select(int dbs, Object... params) {
			String userId = (String) params[0];
			return Math.abs(userId.hashCode()) % dbs;
		}

	}

}
複製程式碼

定義單個資料庫

public class DemoDB extends DB {

	private DataSource ds;

	public DemoDB(String name, String uri) {
		this(name, new HashMap<>(), uri);
	}

	public DemoDB(String name, Map<Class<? extends IEntity>, Meta> metas, String uri) {
		super(name, metas);
		var ds = new MysqlConnectionPoolDataSource(); // 連線池
		ds.setUrl(uri);
		this.ds = ds;
	}

	@Override
	protected Connection conn() {  // 獲取連結
		try {
			return ds.getConnection();
		} catch (SQLException e) {
			throw new KidsException(e);
		}
	}

}
複製程式碼

定義網格資料庫——分庫

public class GridDemoDB extends GridDB<DemoDB> {

	/**
	 * 傳進來多個DB物件
	 */
	public GridDemoDB(DemoDB[] dbs) {
		super(dbs);
		this.registerGridables();
	}

	/* 
	 * 註冊實體類的分庫策略
	 */
	@Override
	public void registerGridables() {
		this.gridWith(BookShelf.class, new BookShelf.GridStrategy<DemoDB>());
	}

}

複製程式碼

單表單主鍵增刪改查

public class DemoSimplePk {

	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";

	public static void main(String[] args) {
		var db = new DemoDB("demo", URI);
		try {
			db.create(User.class); // 建立表
			var user = new User("test1", "nick1", "passwd1");
			db.insert(user); // 插入
			System.out.println(user.getId());
			user = db.get(User.class, user.getId());  // 主鍵查詢
			System.out.printf("%s %s %s %s %s\n", user.getId(), user.getName(), user.getNick(), user.getPasswd(),
					user.getCreatedAt());
			user = new User("test2", "nick2", "passwd2");
			db.insert(user); // 再插入
			var count = db.count(User.class); // 查詢總行數
			System.out.println(count);
			var users = db.find(User.class);  // 列出所有行
			System.out.println(users.size());
			for (var u : users) {
				System.out.printf("%s %s %s %s %s\n", u.getId(), u.getName(), u.getNick(), u.getPasswd(),
						u.getCreatedAt());
			}
			users = db.find(User.class, Q.eq_("nick"), "nick2"); // 條件查詢
			System.out.println(users.size());
			var setters = new HashMap<String, Object>();
			setters.put("passwd", "whatever");
			db.update(User.class, setters, 2); // 修改
			users = db.find(User.class); // 再列出所有行
			System.out.println(users.size());
			for (var u : users) {
				System.out.printf("%s %s %s %s %s\n", u.getId(), u.getName(), u.getNick(), u.getPasswd(),
						u.getCreatedAt());
			}
			db.delete(User.class, 1); // 刪除
			db.delete(User.class, 2); // 再刪除
			count = db.count(User.class); // 統計所有行
			System.out.println(count);
		} finally {
			db.drop(User.class); // 刪除表
		}
	}

}
複製程式碼

單表複合主鍵增刪改查

public class DemoCompoundPk {
	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";

	public static void main(String[] args) {
		var db = new DemoDB("demo", URI);
		try {
			db.create(Member.class);  // 建表
			var member = new Member(1, 2, "boss", null);
			db.insert(member); // 插入
			member = db.get(Member.class, 1, 2); // 主鍵查詢
			System.out.println(member.getTitle());
			member = new Member(2, 2, "manager", new Date());
			db.insert(member); // 再插入
			var count = db.count(Member.class);  // 獲取總行數 
			System.out.println(count);
			var members = db.find(Member.class); // 獲取全部行
			for (var m : members) {
				System.out.printf("%d %d %s %s\n", m.getUserId(), m.getGroupId(), m.getTitle(), m.getCreatedAt());
			}
			member = new Member(2, 3, "manager", new Date());
			db.insert(member); // 再插入
			members = db.find(Member.class, Q.eq_("group_id"), 2);  // 條件查詢
			for (var m : members) {
				System.out.printf("%d %d %s %s\n", m.getUserId(), m.getGroupId(), m.getTitle(), m.getCreatedAt());
			}
			var setters = new HashMap<String, Object>();
			setters.put("title", "employee");
			db.update(Member.class, setters, 2, 3); // 修改
			member = db.get(Member.class, 2, 3); // 主鍵查詢
			System.out.println(member.getTitle());
			db.delete(Member.class, 1, 2); // 刪除
			db.delete(Member.class, 2, 2); // 刪除
			db.delete(Member.class, 2, 3); // 刪除
			count = db.count(Member.class); // 再獲取總行數
			System.out.println(count);
		} finally {
			db.drop(Member.class); // 刪表
		}
	}

}
複製程式碼

複雜查詢

public class DemoComplexQuery {
	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";

	public static void main(String[] args) {
		var db = new DemoDB("demo", URI);
		try {
			db.create(Exam.class); // 建表
			var random = new Random();
			for (var i = 0; i < 100; i++) {
				var userId = Math.abs(random.nextLong());
				var exam = new Exam(userId, random.nextInt(100), random.nextInt(100), random.nextInt(100),
						random.nextInt(100), random.nextInt(100), random.nextInt(100));
				db.insert(exam); // 插入
			}
			System.out.println(db.count(Exam.class)); // 查詢總行數
			// math >= 50
			var exams = db.find(Exam.class, Q.ge_("math"), 50); // 條件查詢
			System.out.println(exams.size());
			var count = db.count(Exam.class, Q.ge_("math"), 50); // 條件總行數
			System.out.println(count);
			// math > 50 & english >= 50
			exams = db.find(Exam.class, Q.and(Q.gt_("math"), Q.ge_("english")), 50, 50); // 條件查詢
			System.out.println(exams.size());
			count = db.count(Exam.class, Q.and(Q.gt_("math"), Q.ge_("english")), 50, 50); // 條件總行數
			System.out.println(count);
			// math > 50 || english >= 50
			exams = db.find(Exam.class, Q.or(Q.gt_("math"), Q.ge_("english")), 50, 50); // 條件查詢
			System.out.println(exams.size());
			count = db.count(Exam.class, Q.or(Q.gt_("math"), Q.ge_("english")), 50, 50); // 條件總行數
			System.out.println(count);
			// math > 50 && (english >= 50 || chinese > 60)
			exams = db.find(Exam.class, Q.and(Q.gt_("math"), Q.or(Q.ge_("english"), Q.gt_("chinese"))), 50, 50, 60); // 條件查詢
			System.out.println(exams.size());
			count = db.count(Exam.class, Q.and(Q.gt_("math"), Q.or(Q.ge_("english"), Q.gt_("chinese"))), 50, 50, 60); // 條件總行數
			System.out.println(count);
			// math > 50 || physics between 60 and 80 || chemistry < 60
			exams = db.find(Exam.class, Q.or(Q.gt_("math"), Q.between_("physics"), Q.lt_("chemistry")), 50, 60, 80, 60); // 條件查詢
			System.out.println(exams.size());
			count = db.count(Exam.class, Q.or(Q.gt_("math"), Q.between_("physics"), Q.lt_("chemistry")), 50, 60, 80,
					60); // 條件總行數
			System.out.println(count);
			// group by math / 10
			var q = Q.select().field("(math div 10) * 10 as mathx", "count(1)").table("exam").groupBy("mathx")
					.having(Q.gt_("count(1)")).orderBy("count(1)", "desc"); // 複雜sql構造
			var rank = new LinkedHashMap<Integer, Integer>();
			db.any(Exam.class, q, stmt -> { // 原生sql查詢
				stmt.setInt(1, 0);
				ResultSet rs = stmt.executeQuery();
				while (rs.next()) {
					rank.put(rs.getInt(1), rs.getInt(2));
				}
				return rs;
			});
			rank.forEach((mathx, c) -> {
				System.out.printf("[%d-%d) = %d\n", mathx, mathx + 10, c);
			});
		} finally {
			db.drop(Exam.class);
		}
	}

}
複製程式碼

分表

public class DemoPartitioning {
	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";

	public static void main(String[] args) {
		var db = new DemoDB("demo", URI);
		try {
			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
				db.create(BookShelf.class, String.valueOf(i)); // 建立所有分表
			}
			var bss = new ArrayList<BookShelf>();
			for (int i = 0; i < 100; i++) {
				var bs = new BookShelf("user" + i, "book" + i, "comment" + i, new Date());
				bss.add(bs);
				db.insert(bs); // 插入，自動插入相應分表
			}
			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
				System.out.printf("partition %d count %d\n", i, db.count(BookShelf.class, String.valueOf(i)));
			}
			Random random = new Random();
			for (var bs : bss) {
				bs.setComment("comment_update_" + random.nextInt(100));
				db.update(bs); // 更新，自動更新相應分表資料
			}
			bss = new ArrayList<BookShelf>();
			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
				bss.addAll(db.find(BookShelf.class, String.valueOf(i))); // 指定分表列出所有行
			}
			for (var bs : bss) {
				System.out.println(bs.getComment());
			}
			for (var bs : bss) {
				db.delete(bs); // 挨個刪除，自動刪除相應分表資料
			}
		} finally {
			for (int i = 0; i < BookShelf.PARTITIONS; i++) {
				db.drop(BookShelf.class, String.valueOf(i)); // 刪除所有分表
			}
		}
	}

}
複製程式碼

分庫

public class DemoSharding {

	private static DemoDB[] dbs = new DemoDB[3];
	static {
		Map<Class<? extends IEntity>, Meta> metas = new HashMap<>();
		dbs[0] = new DemoDB("demo-0", metas,
				"jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
		dbs[1] = new DemoDB("demo-1", metas,
				"jdbc:mysql://localhost:3307/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
		dbs[2] = new DemoDB("demo-2", metas,
				"jdbc:mysql://localhost:3308/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8");
	}

	public static void main(String[] args) {
		var grid = new GridDemoDB(dbs); // 構造Grid例項
		try {
			for (int k = 0; k < BookShelf.PARTITIONS; k++) {
				grid.create(BookShelf.class, String.valueOf(k)); // 建立所有分庫中的分表
			}
			var bss = new ArrayList<BookShelf>();
			for (int i = 0; i < 100; i++) {
				var bs = new BookShelf("user" + i, "book" + i, "comment" + i, new Date());
				bss.add(bs);
				grid.insert(bs); // 插入，自動分發到相應的分庫中的分表
			}
			for (int k = 0; k < grid.size(); k++) {
				for (int i = 0; i < BookShelf.PARTITIONS; i++) {
					System.out.printf("db %d partition %d count %d\n", k, i,
							grid.count(BookShelf.class, k, String.valueOf(i))); // 依次查詢出所有分庫的分表的行數
				}
			}
			Random random = new Random();
			for (var bs : bss) {
				bs.setComment("comment_update_" + random.nextInt(100));
				grid.update(bs); // 更新，自動分發到相應的分庫中的分表
			}
			for (var bs : bss) {
				bs = grid.get(BookShelf.class, bs.getUserId(), bs.getBookId()); // 主鍵查詢，自動分發到相應的分庫中的分表
				System.out.println(bs.getComment());
			}
			for (var bs : bss) {
				grid.delete(bs); // 刪除，自動分發到相應的分庫中的分表
			}
			for (int k = 0; k < grid.size(); k++) {
				for (int i = 0; i < BookShelf.PARTITIONS; i++) {
					System.out.printf("db %d partition %d count %d\n", k, i,
							grid.count(BookShelf.class, k, String.valueOf(i))); // 依次查詢出所有分庫的分表的行數
				}
			}
		} finally {
			for (int k = 0; k < BookShelf.PARTITIONS; k++) {
				grid.drop(BookShelf.class, String.valueOf(k)); // 刪除所有分庫中的分表
			}
		}
	}

}
複製程式碼

事件上下文物件

public class Context {

	private DB db; // 資料庫例項
	private Connection conn;  // 當前的連結
	private Class<? extends IEntity> clazz; // 當前的實體類
	private Q q; // 查詢sql
	private Object[] values; // 查詢的繫結引數
	private boolean before; // before or after
	private Exception error; // 異常
	private long duration; // 耗時microsecond

}
複製程式碼

事件回撥

public class DemoEvent {

	private final static String URI = "jdbc:mysql://localhost:3306/mydrc?user=mydrc&password=mydrc&useUnicode=true&characterEncoding=UTF8";

	public static void main(String[] args) {
		var db = new DemoDB("demo", URI);
		db.on(ctx -> { // 全域性事件回撥
			System.out.printf("db=%s sql=%s cost=%dus\n", ctx.db().name(), ctx.q().sql(), ctx.duration());
			return true; // 返回false會導致事件鏈終止，後續的ORM操作也不會執行
		});
		try {
			db.create(User.class);
			db.scope(ctx -> { // 範圍回撥，execute方法內部的所有ORM操作都會回撥
				System.out.printf("db=%s sql=%s cost=%dus\n", ctx.db().name(), ctx.q().sql(), ctx.duration());
				return true;
			}).execute(() -> {
				db.count(User.class);
				db.find(User.class);
			});
		} finally {
			db.drop(User.class); // 刪除表
		}
	}

}
複製程式碼

自己手寫一個SpringMVC框架(簡化)
2021-09-09
SpringMVC框架
推動邊緣計算的七項核心技術
2019-01-23
自己動手寫一個持久層框架
2020-11-10
框架
自己動手寫Android資料庫框架
2021-09-09
Android資料庫框架
手寫自己的MyBatis框架-SqlSession
2020-12-14
MyBatis框架SQLSession
手寫開源ORM框架介紹
2020-12-17
ORM框架
7天用Go動手寫/從零實現ORM框架GeeORM
2020-10-16
GoORM框架
手寫 Hibernate ORM 框架 00-hibernate 簡介
2024-07-30
ORM框架
自己動手寫Promise
2018-08-24
Promise
技術總監到底要不要寫程式碼？
2019-06-04
手寫 Hibernate ORM 框架 05-基本效果測試
2024-07-31
ORM框架
模仿vue自己動手寫響應式框架(三) - dom解析
2020-07-19
Vue框架
自己動手寫Impala UDF
2018-05-09
手寫 Hibernate ORM 框架 01-註解常量定義
2024-07-30
ORM框架
邊緣資料中心需求和核心技術分析
2022-04-14
模仿vue自己動手寫響應式框架(二) - Vue物件建立
2020-07-16
Vue框架物件
開始編寫自己的技術部落格...
2018-05-07
30個類手寫Spring核心原理之自定義ORM（上）（6）
2021-12-16
SpringORM
手擼ORM淺談ORM框架之Add篇
2020-10-21
ORM框架
手擼ORM淺談ORM框架之Update篇
2020-10-26
ORM框架
手擼ORM淺談ORM框架之Query篇
2020-11-12
ORM框架
手擼ORM淺談ORM框架之Delete篇
2020-10-30
ORM框架delete
構建自己的框架去做技術選型
2024-11-21
框架
模仿vue自己動手寫響應式框架(四) - Vue物件構建
2020-07-22
Vue框架物件
對話openGauss社群技術委員會主席李國良：核心技術是買不來的。
2023-02-14
手擼ORM淺談ORM框架之基礎篇
2020-10-14
ORM框架
自己動手寫SQL執行引擎
2020-09-25
SQL
我們始終不能只靠技術來生活
2019-02-23
區塊鏈的核心技術是什麼？
2018-11-23
區塊鏈
自己動手實現一個EventBus框架
2018-04-24
框架
如果你想寫自己的Benchmark框架
2020-07-11
框架
手寫ORM入門篇（一）
2019-06-15
ORM
淺析MyBatis（二）：手寫一個自己的MyBatis簡單框架
2021-03-16
MyBatis框架
自己動手寫basic直譯器一
2018-11-13
自己動手寫個 Android客戶端
2018-04-26
Android客戶端
自己動手寫事件匯流排(EventBus)
2018-12-29
事件
自己動手寫Vector【Cherno C++教程】
2022-03-15
C++
寫給未來的自己
2019-02-05