Java的ActiveRecord框架原码及依赖包放出

最新推荐文章于 2021-02-16 07:43:11 发布
最新推荐文章于 2021-02-16 07:43:11 发布
阅读量174 收藏
点赞数
分类专栏： JAVA 文章标签： ActiveRecord 框架 Java SQL SQL Server

下面是我自己在前阵子为了工作上的需要来实现的一个ROR形式的Java中的ActiveRecord框架，其实可能会有一些瑕疵，希望朋友们测试，研究后给我好的意见，我的目的是想开源出来，大家共同进步。

 

下面的是主框架ActiveRecord

 

以mysql数据库为例，给出主要类的代码：

package com.abblie.jdbc.mysql;

import com.abblie.jdbc.Base;
import com.abblie.jdbc.anno.Table;
import com.abblie.jdbc.handler.RecordHandler;
import com.abblie.jdbc.iface.BaseActiveRecord;
import com.database.pool.DBConnect;

/**
 * <b>mysql数据库操作基础类封装过的方法： </b><br/>
 * 查询用方法：find(tag,param) <br/>
 * 添加用方法：add(obj) <br/>
 * 修改用方法：edit(obj)<br/>
 * 删除用方法：del(obj)<br/>
 */
public abstract class ActiveRecord extends Base implements BaseActiveRecord{
	
	public ActiveRecord() {
		super();
	}
	public ActiveRecord(Class clss) {
		this.clss=clss;
	}
	public ActiveRecord(DBConnect conn) {
		this.conn=conn;
	}
	public ActiveRecord(Class clss,String dbName) {
		this.clss=clss;
		this.dbName=dbName;
	}

	//调用数据库
	public DBConnect call(String dbName) {
		return super.call(dbName);
	}
	//调用数据库,带外连接
	public DBConnect call(DBConnect conn,String dbName) {
		this.conn=conn;
		return call(dbName);
	}
	//打开数据库连接(内连接)
	public DBConnect open() {
		return super.open();
	}
	//打开数据库连接(外连接)
	public DBConnect open(DBConnect conn) {
		return super.open(conn);
	}
	//关闭数据库连接(内连接)
	public void close() {
		super.close();
	}
	//关闭数据库连接(外连接)
	public void close(DBConnect conn) {
		super.close(conn);
	}
	//查询主方法(内连接)
	public Object find(int tag, Object... param) {
		open();
		Object obj = find_by_conn(conn, tag, param);
		close();
		return obj;
	}
	//外连接查询主方法
	public Object find_by_conn(DBConnect conn,int tag, Object... param) {
		Object obj = null;
		switch (tag) {
			case $ONE :
				obj = find_reone_by_conn(conn, param);
				break;
			case $PAGE :
				obj = find_page_by_conn(conn, param);
				break;
			case $ALL :
				obj = find_all_by_conn(conn, param);
				break;
			case $SQL :
				obj = find_sql_by_conn(conn, param);
				break;
			case $JOIN :
				obj = find_join_by_conn(conn, param);
				break;
			case $COUNT :
				obj = find_conver_by_conn(conn, $COUNT, param);
				break;
			case $MAX :
				obj = find_conver_by_conn(conn, $MAX, param);
				break;
			case $MIN :
				obj = find_conver_by_conn(conn, $MIN, param);
				break;
			case $SUM :
				obj = find_conver_by_conn(conn, $SUM, param);
				break;
			case $AVG :
				obj = find_conver_by_conn(conn, $AVG, param);
				break;
			case $CONVER :
				obj = find_conver_by_conn(conn, param);
				break;
			case $SOME :
				obj = find_some_by_conn(conn, param);
				break;
			default :
				obj = find_reone_by_conn(conn, param);
				break;
		}
		return obj;
	}
	//查询部分值的方法(内连接)
	public Object find_some(Object... param) {
		open();
		Object obj = find_some_by_conn(conn, param);
		close();
		return obj;
	}
	//查询部分值的方法(外连接)
	public Object find_some_by_conn(DBConnect conn, Object... param) throws NumberFormatException {
		int len=param.length;
		
		if (len < 2) {
			System.out.println("是否没有设置返回标签或者查询的参数没有齐全?");
			return null;
		}
		Object obj=null;
		Table table = getTable();
		int rtag = Integer.valueOf(param[0].toString());
		// 当只有要求字段查询时
		if (len == 2) {
			String[] fields = RecordHandler.getStrs(param[1].toString());
			int flen = fields.length;
			sql = "SELECT ";
			for (int i = 0; i < flen; i++) {
				if (i == (flen - 1)) {
					sql += fields[i];
				} else {
					sql += fields[i] + ",";
				}
			}
			sql += " FROM " + table.name();
			switch (rtag) {
				case $RONE :
					if (flen == 1) {
						sql += " LIMIT 0,1";
						obj = getOneBySql(conn, sql);
					} else {
						System.out.println("请求的查询条件错误,只能查询单个值对象!");
					}
					break;
				case $ROBJ :
					sql += " LIMIT 0,1";
					obj = getBeanBySql(conn, sql);
					break;
				case $RLIST :
					obj = getListBySql(conn, sql);
					break;
				default :
					System.out.println("请求的返回类型或要求的查询字段或者参数不齐全!");
					break;
			}
		}
		// 当有sql条件查询时
		if (len == 3) {
			String[] fields = RecordHandler	.getStrs(param[1].toString());
			int flen = fields.length;
			sql = "SELECT ";
			for (int i = 0; i < flen; i++) {
				if (i == (flen - 1)) {
					sql += fields[i];
				} else {
					sql += fields[i] + ",";
				}
			}
			sql += " FROM " + table.name();
			switch (rtag) {
				case $RONE :
					if (flen == 1) {
						sql += " WHERE " + param[2].toString()	+ " LIMIT 0,1";
						obj = getOneBySql(conn, sql);
					} else {
						System.out.println("request is error,your input feild must be only one!");
					}
					break;
				case $ROBJ :
					sql += " WHERE " + param[2].toString()	+ " LIMIT 0,1";
					obj = getBeanBySql(conn, sql);
					break;
				case $RLIST :
					sql += " WHERE " + param[2].toString();
					obj = getListBySql(conn, sql);
					break;
				default :
					System.out.println("your request type or input feild or input param is error!");
					break;
			}
		}
		// 当有其它参数条件时
		if (len > 3) {
			String[] fields = RecordHandler	.getStrs(param[1].toString());
			int flen = fields.length;
			sql = "SELECT ";
			for (int i = 0; i < flen; i++) {
				if (i == (flen - 1)) {
					sql += fields[i];
				} else {
					sql += fields[i] + ",";
				}
			}
			sql += " FROM " + table.name();
			switch (rtag) {
				case $RONE :
					if (flen == 1) {
						sql += " WHERE " + param[2].toString()	+ " LIMIT 0,1";
						obj = getOneByParam2(conn, sql, param);
					} else {
						System.out.println("request is error,your input feild must be only one!");
					}
					break;
				case $ROBJ :
					sql += " WHERE " + param[2].toString()	+ " LIMIT 0,1";
					obj = getBeanByParam2(conn, sql, param);
					break;
				case $RLIST :
					sql += " WHERE " + param[2].toString();
					obj = getListByParam2(conn, sql, param);
					break;
				default :
					System.out.println("your request type or input feild or input param is error!");
					break;
			}
		}
		return obj;
	}
	//聚合函数(内连接)
	public Object find_conver(Object... param) {
		open();
		Object obj=find_conver_by_conn(conn,param);
		close();
		return obj;
	}
	//聚合函数(外连接)
	public Object find_conver_by_conn(DBConnect conn, Object... param) throws NumberFormatException {
		int len=param.length;
		if(len<1) {
			System.out.println("The input params is not enough!");
			return null;
		}
		Object obj=null;
		int tags2=Integer.valueOf(param[0].toString());
		switch (tags2) {
			case $COUNT :
				obj = doConver(conn, "COUNT", param);
				break;
			case $MIN :
				obj = doConver(conn, "MIN", param);
				break;
			case $MAX :
				obj = doConver(conn, "MAX", param);
				break;
			case $SUM :
				obj = doConver(conn, "SUM", param);
				break;
			case $AVG :
				obj = doConver(conn, "AVG", param);
				break;
			default :
				break;
		}
		return obj;
	}
	//连接查询(内连接)
	public Object find_join(Object... param) {
		open();
		Object obj = find_join_by_conn(conn, param);
		close();
		return obj;
	}
	public Object find_join_inner(Object... param) {
		return find_join($INNER,param);
	}
	//连接查询(外连接)
	public Object find_join_by_conn(DBConnect conn, Object... param) throws NumberFormatException {
		int len=param.length;
		if (len < 1) {
			System.out.println("parameter is not complete");
			return null;
		}
		Object obj=null;
		int tags1 = Integer.valueOf(param[0].toString());// 采用什么连接查询
		if (len==1) {
			linkSql(tags1);
			obj = getListBySql(conn, sql);
		} else if(len==2){
			linkSql(tags1);
			String start = param[1].toString().toUpperCase();
			if (start.startsWith("ORDER")||start.startsWith("GROUP")) {
				sql += " " + param[1];
			}else {
				sql += " WHERE " + param[1];
			}
			obj = getListBySql(conn, sql);
		}else if (len>2) {
			//当有参数传入时
			linkSql(tags1);
			String start = param[1].toString().toUpperCase();
			if (start.startsWith("ORDER")||start.startsWith("GROUP")) {
				sql += " " + param[1];
			}else {
				sql += " WHERE " + param[1];
			}
			obj = getListByParam1(conn, sql, param);
		}
		return obj;
	}
	//SQL语句查询(内连接)
	public Object find_sql(Object...param) {
		open();
		Object obj=find_sql_by_conn(conn,param);
		close();
		return obj;
	}
	//SQL语句查询(外连接)
	public Object find_sql_by_conn(DBConnect conn, Object... param) throws NumberFormatException {
		int len=param.length;
		if (len < 2) {
			System.out.println("输入的参数不齐全!");
			return null;
		}
		Object obj=null;
		int tags = Integer.valueOf(param[0].toString());// 返回标志位
		sql = param[1].toString();
		if (len == 2) {
			switch (tags) {
				case $RONE :
					obj = getOneBySql(conn, sql);
					break;
				case $ROBJ :
					obj = getBeanBySql(conn, sql);
					break;
				case $RLIST :
					obj = getListBySql(conn, sql);
					break;
				default :
					obj = getOneBySql(conn, sql);
					break;
			}
		} else if (len > 2) {
			switch (tags) {
				case $RONE :
					obj = getOneByParam1(conn, sql, param);
					break;
				case $ROBJ :
					obj = getBeanByParam1(conn, sql, param);
					break;
				case $RLIST :
					obj = getListByParam1(conn, sql, param);
					break;
				default :
					obj = getOneByParam1(conn, sql, param);
					break;
			}
		}
		return obj;
	}
	//查询全部(内连接)
	public Object find_all(Object... param) {
		open();
		Object obj=find_all_by_conn(conn, param);
		close();
		return obj;
	}
	//查询全部(外连接)
	public Object find_all_by_conn(DBConnect conn, Object... param) {
		Object obj=null;
		int len=param.length;
		Table table = getTable();
		sql = "SELECT * FROM " + table.name();
		if (len == 0) {
			obj = getListBySql(conn, sql);
		} else if (len == 1) {
			String start = param[0].toString().toUpperCase();
			if (start.startsWith("ORDER")||start.startsWith("GROUP")) {
				sql += " " + param[0];
			}else {
				sql += " WHERE " + param[0];
			}
			obj = getListBySql(conn, sql);
		} else if (len > 1) {
			sql += " WHERE " + param[0];
			obj = getListByParam0(conn, sql, param);
		}
		return obj;
	}
	//分页查询(内连接)
	public Object find_page(Object... param) {
		open();
		Object obj=find_page_by_conn(conn, param);
			close();
		return obj;
	}

	//分页查询(外连接)
	public Object find_page_by_conn(DBConnect conn, Object... param) throws NumberFormatException {
		int len=param.length;
		if (len < 2) {
			System.out.println("输入的参数不齐全!");
			return null;
		}
		Object obj=null;
		Table table = getTable();
		sql = "SELECT * FROM " + table.name();
		int page = Integer.valueOf(param[0].toString());
		int size = Integer.valueOf(param[1].toString());

		if (len == 2) {
			sql += " LIMIT " + size * (page - 1) + "," + size;
			obj = getListBySql(conn, sql);
		} else if (len == 3) {
			String start = param[2].toString().toUpperCase();
			if (start.startsWith("ORDER")||start.startsWith("GROUP")) {
				sql += " " + param[2] + " LIMIT " + size * (page - 1)+ "," + size;
			} else if(param[2].toString().length()>0){
				sql += " WHERE " + param[2] + " LIMIT " + size	* (page - 1) + "," + size;
			}else {
				sql +=param[2] + " LIMIT " + size	* (page - 1) + "," + size;
			}
			obj = getListBySql(conn, sql);
		} else if (len > 3) {
			sql += " WHERE " + param[2] + " LIMIT " + size * (page - 1)	+ "," + size;
			obj = getListByParam2(conn, sql, param);
		}
		return obj;
	}
	//返回单个值查询(内连接)
	public Object find_reone(Object... param) {
		open();
		Object obj = find_reone_by_conn(conn, param);
		close();
		return obj;
	}
	//返回单个值查询(外连接)
	public Object find_reone_by_conn(DBConnect conn, Object... param) {
		Object obj=null;
		int len=param.length;
		Table table = getTable();
		sql = "SELECT * FROM " + table.name();
		if (len == 0) {
			sql += " LIMIT 0,1";
			obj = getBeanBySql(conn, sql);
		} else if (len == 1) {
			String start = param[0].toString().toUpperCase();
			if ("DESC".equals(start)) {
				sql += " ORDER BY " + table.key() + " DESC LIMIT 0,1";
			} else if ("ASC".equals(start)) {
				sql += " ORDER BY " + table.key() + " ASC LIMIT 0,1";
			} else if (start.startsWith("ORDER")||start.startsWith("GROUP")) {
				sql += " " + param[0] + " LIMIT 0,1";
			} else {
				sql += " WHERE " + param[0] + " LIMIT 0,1";
			}
			obj = getBeanBySql(conn, sql);
		} else if (len > 1) {
			sql += " WHERE " + param[0] + " LIMIT 0,1";
			obj = getBeanByParam0(conn, sql, param);
		}
		return obj;
	}

	/**
	 * @param obj
	 * @param len
	 * @param param
	 * @return
	 */
	private Object doConver(DBConnect conn, String type, Object... param) {
		int len=param.length;
		Object obj=null;
		Table table = getTable();
		if (len == 1) {
			sql = "SELECT "+type+"("+table.key()+") AS ONE FROM "+table.name();
			obj=getOneBySql(conn, sql);
		}else if (len == 2) {
			sql = "SELECT "+type+"("+param[1].toString()+") AS ONE FROM "+table.name();
			obj=getOneBySql(conn, sql);
		}else if (len==3) {
			sql = "SELECT "+type+"("+param[1].toString()+") AS ONE FROM "+table.name()+" "+param[2].toString();
			obj=getOneBySql(conn, sql);
		}else if(len >3){
			sql = "SELECT "+type+"("+param[1].toString()+") AS ONE FROM "+table.name()+" "+param[2].toString();
			obj = getOneByParam2(conn, sql, param);
		}
		System.out.println(sql);
		return obj;
	}

	public int save(int tag, Object... param) {
		open();
		int i = save_by_conn(conn, tag, param);
		close();
		return i;
	}

	/**
	 * 添加 修改 删除
	 * 
	 * @param tag
	 * @param param
	 * @return int
	 */
	public int save_by_conn(DBConnect conn,int tag, Object... param) {
		int rel = 0;
		table = getTable();
		switch (tag) {
			case $ADD :
				// ADD
				rel = execute(conn, TSql.addSQL(clss, param[0]));
				break;
			case $MOD :
				// EDIT
				rel = execute(conn, TSql.editSQL(clss, param[0]));
				break;
			case $DEL :
				// DEL
				rel = execute(conn, TSql.delSQL(clss, Integer.valueOf(param[0].toString())));
				break;

			default :
				break;
		}
		return rel;
	}
//	 其它操作接口
	public int add_by_conn(DBConnect conn,Object... param) {
		return save_by_conn(conn,$ADD, this, param);
	}
	public int add(Object... param) {
		return save($ADD, this, param);
	}
	public int mod_by_conn(DBConnect conn,Object... param) {
		return save_by_conn(conn,$MOD, this, param);
	}
	public int mod(Object... param) {
		return save($MOD, this, param);
	}
	public int del_by_conn(DBConnect conn,Object id, Object... param) {
		return save_by_conn(conn,$DEL, id, param);
	}
	public int del(Object id, Object... param) {
		return save($DEL, id, param);
	}
	private void linkSql(int tags1) {
		switch (tags1) {
			case $LEFT :// 左连接
				sql = TSql.linkSql(clss, $LEFT);
				break;
			case $RIGHT :// 右连接
				sql = TSql.linkSql(clss, $RIGHT);
				break;
			case $INNER :// 内连接
				sql = TSql.linkSql(clss, $INNER);
				break;
			case $OUTER :// 外连接
				sql = TSql.linkSql(clss, $OUTER);
				break;
			case $CROSS :// 交叉连接
				sql = TSql.linkSql(clss, $CROSS);
				break;
			default :
				break;
		}
	}
}

 

 

时间关系，以后慢慢介绍。

 

下面给出我的项目中调用这个框架的部分代码以用参考。目的只想大家能把这个框架用起来，不断改进，不断优化。以达到让Java的敏捷开发。

 

主要Action中代码：CompanyAction.java

package action;

import com.util.lang.StringUtil;

import bean.Company;

@SuppressWarnings("serial")
public class CompanyAction extends BaseAction {

	private Company company;
	public CompanyAction() {
		company = new Company();
	}
	public String list() {
		tag("list");
		set("list", company.find_all());
		return SUCCESS;
	}
	public String toadd() {
		tag("toadd");
		set("list", company.find_all());
		return SUCCESS;
	}
	public String add() {
		tag("toadd");
		// 检查输入
		if (StringUtil.isEmpty(company.getCname())) {
			set("list", company.find_all());
			msg("公司名称不能为空!");
			return SUCCESS;
		}
		company.add();
		msg("公司添加成功!");
		return list();
	}
	public String tomod() {
		tag("tomod");
		set("list", company.find_all());
		company = (Company) company.find_reone("id=?", get("id"));
		return SUCCESS;
	}
	public String mod() {
		tag("mod");
		// 检查输入
		if (StringUtil.isEmpty(company.getCname())) {
			set("list", company.find_all());
			msg("公司名称不能为空!");
			return SUCCESS;
		}
		if (company.getId()==company.getPid()) {
			set("list", company.find_all());
			msg("上级公司不能选择本公司!");
			return SUCCESS;
		}
		company.mod();
		msg("公司修改成功!");
		return list();
	}
	public String del() {
		company.del(get("id"));
		msg("公司删除成功!");
		return list();
	}
	public Company getCompany() {
		return company;
	}
	public void setCompany(Company company) {
		this.company = company;
	}
}

 

 

 

对应的Bean类代码是：Company.java

 
package bean;

import java.io.Serializable;

import com.abblie.jdbc.anno.Table;
import com.abblie.jdbc.mysql.ActiveRecord;

@SuppressWarnings("serial")
@Table(name = "company", key = "id")
public class Company extends ActiveRecord implements Serializable {

	private int id;
	private int pid;
	private String cname;
	private String address;
	private String logo;
	private String website;
	private String note;

	public String getLogo() {
		return logo;
	}
	public String getWebsite() {
		return website;
	}
	public void setLogo(String logo) {
		this.logo = logo;
	}
	public void setWebsite(String website) {
		this.website = website;
	}
	public String getAddress() {
		return address;
	}
	public String getCname() {
		return cname;
	}
	public int getId() {
		return id;
	}
	public String getNote() {
		return note;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	public void setCname(String cname) {
		this.cname = cname;
	}
	public void setId(int id) {
		this.id = id;
	}
	public void setNote(String note) {
		this.note = note;
	}
	public int getPid() {
		return pid;
	}
	public void setPid(int pid) {
		this.pid = pid;
	}
}

 

 

 

后面是相关包，包中有原代码可以查看，直接导入Eclipse就行了。

有两个配置文件要给出：

web.prop

 

 
[configfile]
dbconfigfile=server_db.prop

 

server_db.prop

[dbconfig]
dblist=server
logfile=d:\\server.log
dbdefault=server
sqlout=true

[server]
url=jdbc:mysql://localhost/server?useUnicode=true&characterEncoding=UTF-8
username=root
password=111111
maxconn=10
driver=org.gjt.mm.mysql.Driver

 

iteye_1364
关注
专栏目录
ObjectiveSql：ObjectiveSQL是Java中基于ActiveRecord模式的ORM框架，该框架鼓励快速开发和整洁，代码最少且约定俗成的配置
01-30
我很抱歉最近没有对此图书馆的关注。 忙着做其他事情，我没有时间去维护它。 我将在2个月后回来。 谢谢大家（20200120） （20200120）我会在大约两个月后回来继续更新维护它。谢谢大家的支持！（20200120） ObjectiveSQL是Java中基于ActiveRecord模式的ORM框架，该框架鼓励快速开发和清理，使用最少的代码以及约定优于配置。 产品特点 通过一个注释，您的Class具有SQL编程的全功能 易于进行关系（ has_one ， has_many和belongs_to ）查询和分页查询 使用Java语法编写SQL表达式（ arithmetic ， comparison和logical ） 为什么选择 如果您的项目专注于基于关系数据库的数据分析，以及SQL语句中的许多算术表达式。 ObjectiveSQL将帮助您使用Java语法方便且安全地编写表达式 如果您不想编写数据库访问和各种配置文件的Java代码，ObjectiveSQL的动态代码生成将帮助您无需编码即可访问数据库 性能（Oracle JMH） 安装 IntelliJ IDEA插件安装 Prefere
activerecord_基于ActiveRecord的持久性框架达到0.3.1
06-24 78
Ar4j 0.3.1现已推出！ Ar4j是基于ActiveRecord设计模式的持久性框架。 它使用Spring 3.0 JDBC / SimpleJdbc，并允许使用支持DB的POJO与数据库接口。 它将数据访问与实际的数据bean结合在一起，并通过实现接口而不扩展类来提供功能。 此版本删除了JSON包装器功能，并且上下文现在是不可变的，这将允许将来进行一些内部缓存。 也有许多错误修...
java的framework框架_Java框架技术（framework technology）
weixin_35547906的博客
02-16 869
1.hibernate框架：对JDBC做了轻量级的封装的框架ORM:对象关系映射 即数据库表和持久化类的映射关系持久层框架：优秀的JAVA持久化(即保存到ROM中)层解决框架在Eclipse中使用Hibernate:1.导入jar包，在/required文件夹下的8个必须的jar包(另外还有/optional下可选的jar包)antlr-2.7.7.jardom4j-1.6.1.jar：xml...
Active Record 驱动框架:简介
行成于思，形之于文
02-21 489
Active Record        （中文名：活动记录）是一种领域模型模式，特点是一个模型类对应关系型数据库中的一个表，而模型类的一个实例对应表中的一行记录。Active Record 和 Row Gateway （行记录入口）十分相似，但前者是领域模型，后者是一种数据源模式。关系型数据库往往通过外键来表述实体关系，Active Record 在数据源层面上也将这种关系映射为对象的关联和聚
Java敏捷持久层-ROR-ActiveRecord持久层框架的Java实现
08-01
ROR-ActiveRecord持久层框架的Java实现
Patron-ActiveRecord:JAVA中的Active Record持久性模式示例
05-13
"Patron-ActiveRecord" 这个标题指的是一个项目或者库，它在JAVA中实现了Active Record持久性模式。Active Record是面向对象数据库映射（Object-Relational Mapping, ORM）的一种实现方式，它将数据库操作与业务对象...
全面学习Mybatis插件之Mybatis-Plus_Java框架视频教程
11-05
有一定的Java以及Mybatis框架的基础。 从0开始全面讲解Mybatis-Plus框架 l 快速入门 n Mybatis + MP 整合 n Spring + Mybatis + MP 整合 n SpringBoot + Mybatis + MP 整合 n 通用CRUD的全面讲解 n 配置 l 高级用法...
Neo:Orm框架：基于ActiveRecord思想开发的至简化且功能很全的Orm框架
05-14
Neo是一个基于JDBC开发的至简化框架，采用ActiveRecord的思想进行设计，名字源于《黑客帝国》男主角名字，为连接虚拟与现实的救世主，取名Neo寓意为链接数据和逻辑。源头来自于之前接触的一些不错的Orm框架，也有...
基于ActiveRecord思想开发的至简化的java的Orm框架.zip
最新发布
03-23
本压缩包“基于ActiveRecord思想开发的至简化的java的Orm框架.zip”显然提供了一个简化版的Java ORM解决方案。 在ORM框架中，ActiveRecord模式的主要特点包括： 1. **对象-关系映射**：ORM框架的核心功能是将Java...
基于 Java 的 Active Record 开源项目
weixin_33806300的博客
05-23 455
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringBoot中使用ActiveRecordPlugin插件
suxiaoqiuking的博客
01-08 7421
在写分享前先看了看jfinal-3.3的文档章节：5.13 任意环境下使用 ActiveRecord ActiveRecordPlugin 可以独立于 java web 环境运行在任何普通的 java 程序中，使用方式极 度简单，相对于 web 项目只需要手动调用一下其 start() 方法即可立即使用。以下是代码示例： public class ActiveRecordTest {    
**maven项目导入spring相关jar包版本兼容问题**
不醉也无归-kleine
11-02 1014
maven项目导入spring相关jar包版本兼容问题 启动出现的异常如下： 十一月 02, 2018 10:56:12 上午 org.apache.tomcat.util.digester.SetPropertiesRule begin 警告: [SetPropertiesRule]{Server/Service/Engine/Host/Context} Setting property ‘so...
什么是ActiveRecord模式
麥希穆斯
09-27 2353
ActiveRecord 也属于 ORM 层，由 Rails 最早提出，遵循标准的 ORM 模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。 ActiveRecord 的主要思想是：
activerecord java_ActiveRecord比ORM更坏
weixin_30536391的博客
02-13 428
ORM已经不好了，ActiveRecord其实比ORM更坏，因为它隐藏对象其实是数据容器这样的事实，如果说ORM是将真正对象变成数据容器，那么ActiveRecord还隐瞒了这样事实，也就是说，如果说ORM做了偷梁换柱的坏事，ActiveRecord不但做了，还隐瞒自己做的坏事。这是来自作者曾经在2014年提出ORM是反模式的观点，ORM作为一个非常流行的设计模式，是在一个螺丝壳中，把真正对象变成...
ActiveReport14爬坑指南-JavaWeb项目如何调用JSviewer报表服务
QIANG_HAO的博客
05-22 1042
1. 将JSviewer所需文件引入web项目 将ASP.net项目下的wwwroot文件复制web项目中，以便页面的样式和函数加载 2. 创建Jsp页面 jsp页面代码参考： <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %> <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
MyBatis-Plus ActiveRecord模式的CRUD
贱男
06-16 3918
一、引言 ActiveRecord模式简单一点来说就是通过实体来进行对单表增删改查操作。 说实话，这种操作方式小编之前确实还没见过，虽然这种方式在实际项目开发中还是有很多局限性的，但是如果说面试需要上机实现单表的增删改查，这种方式简直太简单了。 emmmmm，那么就开始说说怎么使用吧。 二、具体操作 步骤一：Mapper对象要先继承BaseMapper对象 /** * <p&...
Active Record 设计模式原理及简单实现
glowd的专栏
04-19 864
转载自：http://blog.csdn.net/fanhengguang_php/article/details/54964490 概述 本文简要介绍Active Record 设计模式。Active Record 是一种数据访问设计模式，它可以帮助你实现数据对象Object到关系数据库的映射。 应用Active Record 时，每一个类的实例对象唯一对应一个数据库表的一行(一对一关系)...
activerecord中拼接SQL语句
baixiaoshi的专栏
06-06 1208
开发这么长时间了，相对activerecord做一些解释，一般很多的框架都会有这个东西，先说优点 利用activerecord 组合数据是挺方便的，但是如果是多条件查询的话，我们就需要手动的拼接每一个对象了, 例如在CI中 $sqlobj = $this->db->select() ; if(condition) { $sqlobj = $sqlobj->limit*(10
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值