Hibernate框架中,使用JDBC语法

/**
	 * 调用存储过程
	 * 
	 * @param PRONAME
	 * @return
	 */
	public CallableStatement citePro(final String PRONAME){
		Session session = getCurrentSession();
		CallableStatement pro = session.doReturningWork(new ReturningWork<CallableStatement>() {

			@Override
			public CallableStatement execute(Connection connection)
					throws SQLException {
				CallableStatement resultSet = connection.prepareCall(PRONAME);
				return resultSet;
			}
			
		});
		return pro;
		
	}

或者

/**
 * 使用JDBC执行sql语句
 * 
 * @return
 */
public void xx() throws SQLException {
	Session session = getCurrentSession();
	ResultSet resultSet=session.doReturningWork(
			new ReturningWork<ResultSet>() {
				@Override
				public ResultSet execute(Connection connection) throws SQLException {
					String sql="select * from tableName";
					PreparedStatement preparedStatement=connection.prepareStatement(sql);
					ResultSet resultSet=preparedStatement.executeQuery();
					return resultSet;
				}
			}
	);
	while (resultSet.next()){
		System.out.println("rs:"+resultSet.getString("authid"));
	}
}
就是这个doReturnWork方法,里面通过内部类,把resultset对象一层一层返回给这个doReturnWork,这样就可以像用jdbc一样使用hibernate了。


  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
jdbc: 1.数据库连接的方式: ODBC:开放式数据库连接。 C语言实现的,提供语言和(基于SQL的)数据库进行交互的“一致性”的接口 JDBC:java版本的ODBC JDBC连接数据库的步骤: 1.注册驱动(加载驱动): 注册的方式: 1.使用类加载器(使用反射的方式) Class.forName(driverName); 2.实例化Driver Driver driver = new oracle.jdbc.driver.OracleDriver(); DriverManager.registerDriver(driver); 3.加虚拟机参数jdbc.drivers -Djdbc.drivers=oracle.jdbc.driver.OracleDriver 4.从Jdk6.0以后要求,JDBC 4.0 Drivers 必须包括 META-INF/services/java.sql.Driver 文件,有了这个文件以后不需要在显示的使用Class.forName来进行驱动的注册 Oracle数据库进行连接的时候,使用的驱动类: 1.oracle.jdbc.driver.OracleDriver 2.oracle.jdbc.OracleDriver 2.建立连接 连接方式: 1.DriverManager(的getConnection其实也是调用的Driver.connect方法) getConnection(url);//没有用户名密码 //将用户名密码存放在java.util.Properties对象 getConnection(url,properties); getConnection(url,user,passwd); 2.直接调用Driver.connect方法执行 Driver d = new DriverClass(); d.connect(url,properties); 3.创建Statement: Statement: 1.创建时不需要传递sql语句,但是执行时需要传递sql语句 2.如果涉及到动态参数的传递,必须使用字符串拼接 PreparedStatement: 1.创建时就需要传递sql语句,执行的时候不需要传递sql语句 2.如果涉及到动态参数的传递,可以使用字符串拼接,也可以使用?占位的形式 给?号传值使用的是 pstmt.setType(index,value); index从1开始 3.提供预编译的功能,某种程度上可以避免sql注入的问题 4.提前做语法检查,在给?赋值的过程要求数据类型一定要匹配,这样在某种程度上可以避免因为数据类型不匹配而发生的异常 CallableStatement:主要用来执行pl/sql的一些过程,函数等。 1.写一条恒成立的select语句,无论你输入的条件是什么,总是能讲表的所有数据输出 select id,last_name from s_emp where '1' ='1'; where 1=1; findByOption(Integer age,String province,String gender){ String sql = select * from s_emp where 1=1; if(age!=null){ sql + "and age < age"; } if(province!=null){ sql + "and province=province"; } if(gender!=null){ sql + "and gender = gender"; } } 4.执行sql语句: execute:返回boolean类型的值,代表是否有结果集返回(如果执行select操作,是有ResultSet的,返回值为true) executeUpdate:返回int类型的值,代表的是,操作执行完成后,受影响的数据库的行计数(针对于insert,update,delete) executeQuery:返回的是ResultSet ResultSet:类似于指针或者游标的东西,里边保存的不是所有的结果,而是指向结果集的正上方。所以如果一旦连接关闭那么ResultSet将取不到值 5.处理结果 如果有结果集,处理结果集 ResultSet next(),每执行一次,向下移动一次,如果有值,返回true,如果没值返回false while(rs.next()){ rs.getType(index/columnName); 如果传的是index,那么索引是从1开始的。 select id,last_name from s_emp; 那么1代表的就是id,依次类推 } 6.关闭资源 先开的后关 D:\oraclexe\app\oracle\product\10.2.0\server\jdbc\lib\ojdbc14.jar linux下启动数据库监听的命令: lsnrctl start; "select id from s_emp where name = '"+name+"'"; table s_user( id , name, age) class User{ } //分别使用Statement对象和PreparedStatement对象实现 public class JDBCTest{ //查找s_user表所有的数据,并且返回他们的集合 public Collection<User> findAll(){ } //按照名字进行删除 public int deleteUser(String name){ } //将user对象的信息更新到数据库表 public int updateUser(User user){ } //讲User对象保存到数据库 public void insertUser(User user){ } } JDBC:本身自动帮我做事务管理的操作 AutoCommit = true; Connection.setAutoCommit(false); 正常: conn.commit(); 异常: conn.rollback(); JDBC批处理: addBatch executeBatch Statement PreparedStatement Statement{ 1.获取连接 getConnection(); 2.创建Statement conn.createStatement(); 3.执行sql语句 String sql .... insert delete update executeUpdate select ----- Result executeQuery 4.如果有结果集处理结果集 5.资源关闭 } Statement: update/delete/insert: stmtExecute(String sql){ 1.获取连接 getConnection(); 2.创建Statement conn.createStatement(); 3.执行sql语句 stmt.execute(sql); 4.资源关闭 } Select: stmtQuery(String sql,ResultHander handler){ 1.获取连接 getConnection(); 2.创建Statement conn.createStatement(); 3.执行sql语句 ResultSet set = executeQuery 4.如果有结果集处理结果集 handler!=null handler.handler(set); 5.资源关闭 } 结果集处理的规则: ResultHandler{ handler(ResultSet rs); } PreparedStatement update/delete/insert: pstmtExecute(String sql,PstmtSetter setter){ 1.获取连接 getConnection(); 2.创建PreparedStatement conn.prepareStatement(sql); if(setter!=null){ setter.setter(pstmt); } 3.执行sql语句 pstmt.execute(sql); 4.资源关闭 } ?设值的标准: PstmtSetter{ setter(PreparedStatement pstmt); } Select: stmtQuery(String sql,PstmtSetter setter,ResultHander handler){ 1.获取连接 getConnection(); 2.创建PreparedStatement conn.prepareStatement(); setter!=null setter.setter(pstmt); 3.执行sql语句 ResultSet set = executeQuery 4.如果有结果集处理结果集 handler!=null handler.handler(set); 5.资源关闭 } 结果集处理的规则: ResultHandler{ handler(ResultSet rs); } 表现层 业务逻辑层 持久层 java的对象分为: 1.域对象:主要作为信息的载体 2.行为对象:注重操作 Register(User user){ } insert(User user){ String sql = "insert into s_user( user.getId()+user.getName().......)"; } insert(User user){ save(user); } ORM Object Relational Class-Object 表 名字 表名 属性 字段(列) object 记录 User s_User id id name name passwd passwd insert into s_user(id,name,passwd) values(?,?,?); Hibernate:ORM的间件,或者说是实现了ORM的一个框架,对JDBC做了轻量级的封装。 ORM:使用元数据信息来描述对象和数据库之间的关系,并且能够自动实现java持久化对象到关系型数据库表的映射 脏检查:自动对缓存的数据进行检查,并且选择在合适的时机和数据库之间进行交互,以保持数据的一致性 延迟加载:从数据库还原对象的时候,不会立即对对象进行初始化,而是等到用到的时候才会进行初始化 Core: POJO hibernate.cfg.xml .hbm.xml Session: 1.轻量级的,创建和销毁不需要消耗很大的资源 2.非线程安全的 3.hibernate的一级缓存 4.介于Connection和Transaction之间的一个对象 5.hibernate用来做持久化操作的 SessionFactory 1.重量级的,创建和销毁需要消耗很大的资源,不建议频繁创建和销毁 2.线程安全的,一个数据库对应一个Sessionfactory(一般一个应用程序对应一个SessionFactory就够了) 3.是一个很大的缓存,本身维护了一个可配置的二级缓存 4.用来构建Session对象 Configuration 1.启动和配置Hibernate 2.读取hibernate的配置文件和映射文件 3.构建SessionFactory对象 Transaction 1.事务管理对象 Query 1.查询对象,HQL Criteria 1.hibernate提供的更面向对象的一种查询方式。 准备工作: 1.java的POJO对象存在 2.数据库,表得存在 3.hibernate的配置文件(hibernate.cfg.xml)得存在 4.POJO.hbm.xml文件存在 5.hibernate的jar包以及数据库的驱动包存在 Hibernate的编程: 1.构建Configuration对象读取配置文件 2.读取映射文件 3.构建SessionFactory对象 4.构建Session对象 5.开启事务 6.持久化操作 7.事务的提交(正常提交,不正常回滚) 8.关闭资源 主键增长策略: 1.increment:自动增长 select max(id) from table; 找到最大值之后+1赋给要持久化的对象 2.assigned:指派 hibernate不在自动生成主键值,需要你在插入时自己指明 3.hilo:高低值算法,由数据库表提供高值,程序提供低值 value = hi*(max_lo+1)+lo 4.sequences Cat: cid name color weight age --------------------------- 1.每个人都有一个地址 person{ id name } Address{ country province city street } table: id name country province city street Component:数据库采用一张表的设计,java采用两个类的设计 ----------------------------------- Employee: id name salary award amount table id name salary award formula: ---------------------------- 关系模型: 多对一: 订单和客户之间的关系 Order{ id amount customer } Customer{ id name } many-to-one:标签对于cascade的取值delete,delete-orphan,all-delete-orphan(只用unique属性值不为true不能出现)慎用 cascade:级联属性 none:不做任何级联操作 save-update:对当前对象执行save,update, saveOrupdate,会级联操作和它相关联的对象 delete:在删除当前对象的时候,级联删除和他相关联的对象 all: save-update+delete delete-orphan:解除关联关系时,删除和当前对象失去关联的对象 all-delete-orphan:all+delete-orphan 单向的一对多的关系,在进行关联关系的操作时,会执行不必要的update语句,所以,一般情况下,我们不会做单向一对多的映射。 inverse="true":让其一方放弃对关联关系的维护 一般在做双向多对一(一对多)关联关系映射的时候,一般会设置让一的一方放弃对关联关系的维护,以减少不必要的更新语句 一对一: 基于外键的一对一 Wife Husband id id name name h_id references Husband(id) unique 基于主键的一对一 Wife Husband id references Husband(id) id name name create table Husband( id number primary key, name varchar2(15) ); create table Wife( id number primary key references husband(id), name varchar2(15) ); 多对多: Teacher Student id id name name 桥表:s_t s_id t_id ------------------------------ 操作持久化对象: Hibernate对象的三种状态: Transient(瞬态): 1.由new关键字创建 2.没有和Session进行关联的 3.数据库没有对应的记录存在 4.操作不会影响数据库的数据 Persistent(持久态): 1.和Session之间有关联 2.在数据库有对应记录存在,并且有持久化标识 3.对持久对象的更动,会对数据库的数据产生影响。(自动脏检查机制) Detached(托管状态): 1.和Session失去关联 2.数据库有对应记录存在 3.对托管对象的更动,在托管期间不会影响数据库,但是将托管状态重新和数据库进行关联的时候会将托管对象重新变为持久态,那么在托管期间发生的更动也会被更新到数据库 get()/load():从数据库还原数据 get: 1.先从缓存进行查找,如果找到就直接返回 2.如果找不到,get()会立即发送sql语句到数据库查找数据,如果找到就返回,如果找不到返回null; load:(使用延迟加载策略) 1.load()方法默认要加载的对象一定存在,所以很放心的使用代理对象,等到用到的时候从缓存查找数据,如果找到,就返回,找不到发送sql语句到数据库查找,如果数据库没有对应记录存在,抛ObjectNotFoundException Hibernate的查询: 1.OID检索: get load 2.导航对象图查询: Customer ---- Order之间有对应关系 通过检索到Customer以后,想获取和Customer相关的对象,可以使用 cus.getOrders(); 3.HQL: Query sql: select name from t_cus; hql: select name from hiber.many2one.Customer query.list(); 直接发送一条select语句去表查找所有的属性 query.iterate(); 先发送一条select语句从表查找所有的id,然后根据id从缓存进行查找,找到就返回,找不到再发送sql语句按id从数据库进行查找,所以可能会产生N+1的问题 Customer order select from customer order where customer.id=order.c_id; 4.QBC(Query By Criteria) Criteria Restrictions Order Projections QBE(Query By Example) 5.sql A B 总额 《 4000 - 100 1900 2100 900 Session默认在遇到以下情况的时候会flush: 1.事务提交的时候 2.某些查询操作执行的时候(不是所有的查询) 3.当应用程序显示的调用session.flush操作的时候 悲观锁: LockMode LockMode.UPGRADE:借助于数据库的 select ... for update; 那么事务一定会等到上一个获取了锁的事务commit之后才执行,如果上一个事务一直不提交,那么它就一直等下去 LockMode.UPGRADE_NOWAIT: select ... for update nowait; nowait就是不等待,一旦在操作过程发现要操作的数据被加了锁,那么直接抛 ORA-00054: 资源正忙, 但指定以 NOWAIT 方式获取资源 乐观锁: 版本控制(version) 时间戳(timestamp)
ef-orm A Simple OR-Mapping framework on multiple databases. 使用手册(文)http://geequery.github.io/ef-orm/manual/EF-ORM-user-guide.docx  使用示例工程 https://github.com/GeeQuery/ef-orm/tree/master/orm-tutorial EF-ORM是一个轻量,便捷的Java ORM框架。并且具备若干企业级的应用特性,如分库分表、JTA事务等。 代码生成插件for eclipse(请在eclipseHelp/Install new software后输入地址并安装)http://geequery.github.io/plugins/1.3.x/特点一 EF的设计的一个主要目的是提高开发效率,减少编码工作,让开发者“零配置”“少编码”的操作数据库大部分功能。 例如:数据库查询条件的传入问题是所有ORM框架都不能回避的一个问题,所以我经常在想——既然我们可以用向DAO传入一个Entity来实现插入操作,为什么就不能用同样的方法来描述一个不以主键为条件的update/select/delete操作?为什么DAO的接口参数老是变来变去?为什么很多应用,自行设计开发类来描述各种业务查询条件才能传入DAO?为什么我们不能在数据访问层上花费更少的时间和精力?   JPA1.0和早期的H框架,其思想是将关系型数据库抽象为对象池,这极大的限制了本来非常灵活的SQL语句的发挥空间。而本质上,当我们调用某H框架的session.get、session.load、session.delete时,我们是想传递一个以对象形式表达的数据库操作请求。只不过某H框架要求(并且限制)我们将其视作纯粹的“单个”对象而已。JPA 2.0为了弥补JPA1.0的不足,才将这种Query的思想引入为框架的另一套查询体系——Criteria API。事实上针对单个对象的get/load/persist/save/update/merge/saveOrUpdate API和Criteria API本来就为一体,只不过是历史的原因被人为割裂成为两套数据库操作API罢了。   因此,对于关系型数据库而言——Entity和Query是一体两面的事物,所谓Query,可以包含各种复杂的查询条件,甚至可以作为一个完整的SQL操作请求的描述。为此,EF彻底将Entity和Query绑在了一起。这种思想,使得—— 开发人员需要编写的类更少。开发人员无需编写其他类来描述复杂的SQL查询条件。也无需编写代码将这些查询条件转换为SQL/HQL/JPQL。DAO层也不会有老要改来改去的接口和API,几乎可以做到零编码。 对单个对象进行CRUD的操作API现在和Criteria API合并在一起。Session对象可以直接提供原本要Criteria API才能提供实现的功能。API大大简化。 IQueryableEntity允许你将一个实体直接变化为一个查询(Query),在很多时候可以用来完成复杂条件下的数据查询。比如 ‘in (?,?,?)’, ‘Between 1 and 10’之类的条件。 xxQL有着拼装语句可读性差、编译器无法检查、变更维护困难等问题,但是却广受开发人员欢迎。这多少有历史原因,也有Criteria API设计上过于复杂的因素。两者一方是极端灵活但维护困难,一方是严谨强大而学习和编写繁琐,两边都是极端。事实上JPA的几种数据查询方式存在青黄不接的问题。选择查询语言xxQL,项目面临后续维护困难,跨数据库移植性差;选择Criteria API,代码臃肿,操作繁琐,很多人望而却步。EF的设计思想是使人早日摆脱拼装SQL/HQL/JPQL的困扰,而是用(更精简易用的)Criteria API来操作数据库。 基于轻量级Criteria API的操作方式,使得对数据库的变更和重构变得非常轻松,解决了SQL语句多对软件维护和移植造成产生的不利影响。 阅读推荐:第3、4章 特点二,将SQL的使用发挥到极致,解决SQL拼凑问题、数据库移植问题 大部分OLTP应用系统到最后都不免要使用SQL/JPQL,然而没有一个很好的方法解决SQL在多种数据库下兼容性的问题。 EF-ORM采用了独特的SQL解析和改写技术,能够主动检查并确保SQL语句或者SQL片段在各个数据库上的兼容性。 EF除了Criteria API以外,可以直接使用“SQL语句”或者“SQL片段”。但是这些SQL语句并不是直接传送给JDBC驱动的,而是 有着一个数据库方言层,经过方言层处理的SQL语句,就具备了在当前数据库上正确操作的能力。这相当于提供了一种能跨数据库操作的SQL语言。(E-SQL) E-SQL不但解决了异构数据库的语法问题、函数问题、特殊的写法问题,还解决了动态SQL问题、绑定变量扩展等特性。 对于各种常用SQL函数和运算符,都可以自动转换为当前数据库支持的方言来操作。其函数支持也要多于HQL支持的函数。 阅读推荐:第7、8章 特点三,可能是业界最快的ORM框架. 得益于ASM的动态代码生成技术,部分耗时操作通过动态代码固化为硬编码实现,EF-ORM的大部分操作性能要超过已知的其他框架。 实际性能测试表明,EF的大部分操作都要快于Hiberante和MyBatis, 部分操作速度甚至数十倍于上述框架。 EF在极限插入模式下,甚至刷新了每秒10万条写入的记录。远远超过了其他框架。 一个初步的性能测试:测试代码:http://geequery.github.io/ef-orm/manual/performance-test.rar 测试报告:http://geequery.github.io/ef-orm/manual/performance-compare.docx 阅读推荐:第9、17章 特点四,分库分表 开发过程参照了Hibernate Shards、Alibaba TDDL、Cobar等框架,也是基于词法分析器来提取SQL参数,并计算路由。 能支持分库维度含糊等场景下的分库分表。以及包括多库多表下的 order by , distinct, group by, having等操作。 阅读推荐:第10章 特点五,常用DDL操作的封装 从数据库元数据访问,到建表,创建约束,创建sequence等各种DDL操作进行了封装,用户无需编写各种SQL,可以直接通过API操作数据库结构。 尤其是ALTER TABLE等修改数据库的语句,各种不同的RDBMS都有较大语法差异。特点六、解决各种跨RDBMS的移植问题 1、DML操作、自增值处理与返回、查询这些不同数据库操作差异很大的东西,都了统一的封装。 2、DDL操作、建表、删表、trunacte,Sequence创建和TABLE模拟Sequence等,都做了支持。 3、对SQL语法操作和函数的改写与支持。其他特性轻量 该框架对应用环境、连接池、 是否为J2EE应用等没有特殊要求。可以和EJB集成,也可与Spring集成,也可以单独使用。整个框架只有两个JAR包,模块和功能都较为轻量。依赖少 整个框架只有三个jar库。间接依赖仅有commons-lang, slf4j等7个通用库,作为一个ORM框架,对第三方依赖极小。简单直接的API 框架的API设计直接面向数据库操作,不绕弯子,开发者只需要数据库基本知识,不必学习大量新的操作概念即可使用API完成各种DDL/DML操作。 最大限度利用编译器减少编码错误的可能性 API设计和元数据模型(meta-model)的使用,使得常规的数据库查询都可以直接通过Criteria API来完成,无需使用任何JPQL/HQL/SQL。可以让避免用户犯一些语法、拼写等错误。JPA2规范兼容 使用JPA 2.0规范的标准注解方式来定义和操作对象。(但整个ORM不是完整的JPA兼容实现)更高的性能 依赖于ASM等静态字节码技术而不是CGlib,使得改善了代理性能;依赖于动态反射框架,内部数据处理上的开销几乎可以忽略。操作性能接近JDBC水平。对比某H开头的框架,在写入操作上大约领先30%,在大量数据读取上领先50%以上。更多的性能调优手段 debug模式下提供了大量性能日志,帮您分析性能瓶颈所在。同时每个查询都可以针对batch、fetchSize、maxResult、缓存、级联操作类型等进行调整和开关,可以将性能调到最优。可在主流数据库之间任意切换 支持Oracle、MySQL、Postgres、MSSQL、GBase、SQLite、HSQL、Derby等数据库。除了API方式下的操作能兼容各个数据库之外,就连SQL的本地化查询也能使之兼容。JMX动态调节 可以用JMX查看框架运行统计。框架的debug开关和其他参数都可以使用JMX动态调整。动态表支持 表结构元数据的API也向用户开放,同时支持在使用过程,灵活调整映射关系,因此用户可以用API动态的创建表结构的模型,从而实现各种动态类型和表的映射(例如POJO包含一个Map,用于映射各种动态扩展的字段)企业级特性支持 SQL分析,性能统计,分库分表,Oracle RAC支持,读写分离支持 标签:eform

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值