`

hibernate向Oracle写入数据step by step

    博客分类：
  • J2EE
HibernateOracle数据结构log4jJDBC 
阅读更多

说明：
1.表结构定义：

  1. <?xml version='1.0' encoding='utf-8'?>  
  2. <!DOCTYPE hibernate-configuration PUBLIC   
  3.         "-//Hibernate/Hibernate Configuration DTD 3.0//EN"   
  4.         "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">  
  5. <hibernate-configuration>  
  6. <session-factory>  
  7.     <!-- 以下是Oracle配置 -->  
  8.     <!-- Oracle驱动程序位置：D:\oracle\ora92\jdbc\lib（前提是你安装了Oracle） -->  
  9.     <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>  
  10.     <property name="connection.url">jdbc:oracle:thin:@localhost:1521:rosy</property>  
  11.     <property name="connection.username">MYLAB</property>  
  12.     <property name="connection.password">TEST</property>  
  13.     <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>  
  14.     <!-- MySQL配置，其驱动程序可以到官方网站下载 -->  
  15.         <property name="connection.driver_class">org.gjt.mm.mysql.Driver</property>  
  16.         <property name="connection.url">jdbc:mysql://localhost:3306/user</property>  
  17.         <property name="connection.username">root</property>  
  18.         <property name="connection.password">111111</property>    
  19.         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  
  20.     <!-- sql server 第三方驱动插件下载地址 -->  
  21.     <!-- "http://sourceforge.net/project/showfiles.php?group_id=33291&package_id=25350&release_id=369359" -->  
  22.         <property name="connection.driver_class">net.sourceforge.jtds.jdbc.Driver</property>  
  23.         <property name="connection.url">jdbc:jtds:sqlserver://localhost:1433/j2eeone</property>  
  24.         <property name="connection.username">sa</property>  
  25.         <property name="connection.password">TEST</property>  
  26.     <!-- JDBC connection pool (use the built-in) -->  
  27.     <property name="connection.pool_size">1</property>  
  28.     <!-- Enable Hibernate's automatic session context management -->  
  29.     <property name="current_session_context_class">thread</property>  
  30.     <!-- Disable the second-level cache  -->  
  31.     <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>  
  32.     <!-- Echo all executed SQL to stdout -->  
  33.     <property name="show_sql">true</property>  
  34.     <!-- Drop and re-create the database schema on startup -->  
  35.     <!-- <property name="hbm2ddl.auto">create</property> -->  
  36.     <property name="myeclipse.connection.profile">mylab</property>  
  37.     <mapping resource="org/danlley/common/setting/Classes.hbm.xml" />  
  38.     <mapping resource="org/danlley/common/setting/Department.hbm.xml" />  
  39.     <mapping resource="org/danlley/common/setting/Employee.hbm.xml" />  
  40.     <mapping resource="org/danlley/common/setting/Orgunit.hbm.xml" />  
  41.     <mapping resource="org/danlley/common/setting/Speciality.hbm.xml" />  
  42.     <mapping resource="org/danlley/common/setting/Students.hbm.xml" />  
  43.     <mapping resource="org/danlley/common/setting/Subcampus.hbm.xml" />  
  44.     <mapping resource="org/danlley/common/setting/Subject.hbm.xml" />  
  45. </session-factory>  
  46. </hibernate-configuration>  

3.对象-映射文件定义：

xml 代码
  1. <!---->xml version="1.0"?>  
  2. <!---->
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  4. <!---->  
  5. <hibernate-mapping>  
  6.     <class name="org.danlley.common.dao.Classes" table="CLASSES">  
  7.         <id name="classno" type="java.lang.String">  
  8.             <column name="CLASSNO" length="32" />  
  9.             <generator class="assigned">generator>  
  10.         id>  
  11.         <property name="classname" type="java.lang.String">  
  12.             <column name="CLASSNAME" length="32" />  
  13.         property>  
  14.         <property name="gradeyear" type="java.lang.Long">  
  15.             <column name="GRADEYEAR" precision="4" scale="0" />  
  16.         property>  
  17.         <property name="classOthername" type="java.lang.String">  
  18.             <column name="CLASS_OTHERNAME" length="32" />  
  19.         property>  
  20.         <property name="balance" type="java.lang.Double">  
  21.             <column name="BALANCE" precision="11" />  
  22.         property>  
  23.         <property name="tmpclassno" type="java.lang.String">  
  24.             <column name="TMPCLASSNO" />  
  25.         property>  
  26.         <property name="departmentid" type="java.lang.String">  
  27.             <column name="DEPARTMENTID" length="32" />  
  28.         property>  
  29.     class>  
  30. hibernate-mapping>  

4.持久化类定义：

java 代码
  1. package org.danlley.common.dao;   
  2.   
  3. import java.util.HashSet;   
  4. import java.util.Set;   
  5.   
  6. /**  
  7.  * Classes generated by MyEclipse - Hibernate Tools  
  8.  */  
  9. public class Classes implements java.io.Serializable{   
  10.   
  11.     private static final long serialVersionUID=2852176058532746351L;   
  12.     private String classno;   
  13.     private String classname;   
  14.     private Long gradeyear;   
  15.     private String classOthername;   
  16.     private Double balance;   
  17.     private String tmpclassno;   
  18.     private String departmentid;   
  19.   
  20.     // Constructors   
  21.   
  22.     /** default constructor */  
  23.     public Classes(){}   
  24.   
  25.     /** minimal constructor */  
  26.     public Classes(String classno){   
  27.         this.classno=classno;   
  28.     }   
  29.   
  30.     /** full constructor */  
  31.     public Classes(String classno,String classname,Long gradeyear,String classOthername,   
  32.                     Double balance,String tmpclassno,String departmentid){   
  33.         this.classno=classno;   
  34.         this.classname=classname;   
  35.         this.gradeyear=gradeyear;   
  36.         this.classOthername=classOthername;   
  37.         this.balance=balance;   
  38.         this.tmpclassno=tmpclassno;   
  39.         this.departmentid=departmentid;   
  40.     }   
  41.   
  42.     // Property accessors   
  43.   
  44.     public String getClassno(){   
  45.         return this.classno;   
  46.     }   
  47.   
  48.     public void setClassno(String classno){   
  49.         this.classno=classno;   
  50.     }   
  51.   
  52.     public String getClassname(){   
  53.         return this.classname;   
  54.     }   
  55.   
  56.     public void setClassname(String classname){   
  57.         this.classname=classname;   
  58.     }   
  59.   
  60.     public Long getGradeyear(){   
  61.         return this.gradeyear;   
  62.     }   
  63.   
  64.     public void setGradeyear(Long gradeyear){   
  65.         this.gradeyear=gradeyear;   
  66.     }   
  67.   
  68.     public String getClassOthername(){   
  69.         return this.classOthername;   
  70.     }   
  71.   
  72.     public void setClassOthername(String classOthername){   
  73.         this.classOthername=classOthername;   
  74.     }   
  75.   
  76.     public Double getBalance(){   
  77.         return this.balance;   
  78.     }   
  79.   
  80.     public void setBalance(Double balance){   
  81.         this.balance=balance;   
  82.     }   
  83.   
  84.     public String getTmpclassno(){   
  85.         return this.tmpclassno;   
  86.     }   
  87.   
  88.     public void setTmpclassno(String tmpclassno){   
  89.         this.tmpclassno=tmpclassno;   
  90.     }   
  91.   
  92.     public String getDepartmentid(){   
  93.         return this.departmentid;   
  94.     }   
  95.   
  96.     public void setDepartmentid(String departmentid){   
  97.         this.departmentid=departmentid;   
  98.     }   
  99. }   
  100.     
  101.   
  102.     
  103.   
  104.   
  105. 4.实现数据写入   
  106.   
  107.   
  108. (1)接口定义：   
  109. package org.danlley.common.daoimpl;   
  110. import java.util.List;   
  111. import org.danlley.common.dao.Classes;   
  112. import org.danlley.common.dao.Department;   
  113. import org.danlley.common.dao.Speciality;   
  114.   
  115. public interface ClassesDAO{   
  116.     public Object addClasses(Classes classes)throws Exception;   
  117. }   
  118.   
  119. (2)实现   
  120.   
  121.     public Object addClasses(Classes classes) throws Exception{   
  122.         Session session=HibernateUtil.getSessionFactory().getCurrentSession();   
  123.         session.beginTransaction();   
  124.         session.saveOrUpdate(classes);   
  125.         session.getTransaction().commit();   
  126.         return null;   
  127.     }   
  128.     public Classes createClassesNode(String classno,String classname,Long grade){   
  129.         Classes cls=new Classes();   
  130.         cls.setClassno(classno);   
  131.         cls.setClassname(classname);   
  132.         cls.setGradeyear(new Long(2007));   
  133.         return cls;   
  134.     }   
  135.     public static void main(String[] args){   
  136.         try{   
  137.             ClassesDAOImpl classesDAOImpl=new ClassesDAOImpl();   
  138.             Session session=HibernateUtil.getSessionFactory().getCurrentSession();   
  139.             session.beginTransaction();   
  140.             //this section will begin to code the add classes   
  141.             String classno="danlley's first test!";   
  142.             String classname=classno;   
  143.             Classes cls=classesDAOImpl.createClassesNode(classno,classname,new Long(2007));   
  144.             classesDAOImpl.addClasses(cls);   
  145.         }catch(Exception e){   
  146.             e.printStackTrace();   
  147.         }   
  148.     }   


5.log4j.properties

properties 代码
  1. ### direct log messages to stdout ###   
  2. log4j.appender.stdout=org.apache.log4j.ConsoleAppender   
  3. log4j.appender.stdout.Target=System.out   
  4. log4j.appender.stdout.layout=org.apache.log4j.PatternLayout   
  5. log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n   
  6.   
  7. log4j.rootLogger=warn, stdout   
  8.   
  9. log4j.logger.org.hibernate=info   
  10. #log4j.logger.org.hibernate=debug   
  11.   
  12. ### log JDBC bind parameters ###   
  13. log4j.logger.org.hibernate.type=info   
  14. #log4j.logger.org.hibernate.type=debug   
  15.   
  16. ### log schema export/update ###   
  17. log4j.logger.org.hibernate.tool.hbm2ddl=debug   

6.编写ant脚本：

xml 代码
  1. <project name="hibernate-tutorial" basedir="." default="build">  
  2.  <property name="src.dir" value="src/main/java" />  
  3.  <property name="web.dir" value="webroot" />  
  4.  <property name="build.dir" value="${web.dir}/WEB-INF/classes" />  
  5.  <path id="master-classpath">  
  6.   <fileset dir="lib">  
  7.    <include name="*.jar" />  
  8.   fileset>  
  9.   <pathelement path="${build.dir}" />  
  10.  path>  
  11.  <path id="client.class.path">  
  12.   <fileset dir="lib">  
  13.    <include name="*.jar" />  
  14.   fileset>  
  15.   <pathelement location="${build.dir}/classes" />  
  16.  path>  
  17.  <target name="clean" description="Clean output directories">  
  18.   <delete>  
  19.    <fileset dir="${build.dir}">  
  20.     <include name="**/*.class" />  
  21.     <include name="**/*.xml" />  
  22.     <include name="**/*.properties" />  
  23.    fileset>  
  24.   delete>  
  25.  target>  
  26.  <target name="prepare">  
  27.   <mkdir dir="${build.dir}" />  
  28.   <copy todir="${build.dir}">  
  29.    <fileset dir="${src.dir}">  
  30.     <include name="**/*.hbm.xml" />  
  31.    fileset>  
  32.   copy>  
  33.   <copy todir="${build.dir}">  
  34.    <fileset dir="${src.dir}">  
  35.     <include name="**/*.cfg.xml" />  
  36.     <include name="**/*.properties" />  
  37.    fileset>  
  38.   copy>  
  39.  target>  
  40.  <target name="build" depends="prepare" description="">  
  41.   <javac destdir="${build.dir}" target="1.5" debug="true" deprecation="false" optimize="false" failonerror="false">  
  42.    <src path="${src.dir}" />  
  43.    <classpath refid="master-classpath" />  
  44.   javac>  
  45.  target>  
  46.  <target name="run.client" depends="build">  
  47.   <java classname="org.danlley.common.daoimpl.ClassesDAOImpl" classpathref="master-classpath">  
  48.    <<span class="tag-na

  1. CREATE TABLE CLASSES   
  2. (   
  3.   CLASSNO          VARCHAR2(32 BYTE)            NOT NULL,   
  4.   CLASSNAME        VARCHAR2(32 BYTE),   
  5.   SUBCAMPUSID      VARCHAR2(32 BYTE),   
  6.   SPECIALITYID     VARCHAR2(32 BYTE)            NOT NULL,   
  7.   GRADEYEAR        NUMBER(4),   
  8.   MONITOR_ID       VARCHAR2(32 BYTE),   
  9.   CLASS_OTHERNAME  VARCHAR2(32 BYTE),   
  10.   CLASS_CHARGEID   VARCHAR2(32 BYTE),   
  11.   BALANCE          NUMBER(11,2),   
  12.   TMPCLASSNO       VARCHAR2(255 BYTE),   
  13.   DEPARTMENTID     VARCHAR2(32 BYTE)   
  14. )  

2.配置文件：我用的Oracle数据库，如果大家是其他数据库的话可以参考我的注释部分。

xml 代码
分享到：
| 用hibernate的HQL（面向对象的查询语言） ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    JDBC+Hibernate将Blob数据写入Oracle

    以下是对“JDBC+Hibernate将Blob数据写入Oracle”这一主题的深入解析。 ### JDBC与Oracle BLOB的交互 #### 1. 理解Oracle BLOB特性 在Oracle中，BLOB用于存储大量的二进制数据，如图像文件。与传统的文本或数字...

    HIbernate与oracle数据库应用例子

    通过上述步骤，开发者可以在Java应用中高效地使用Hibernate与Oracle数据库进行数据操作。实践过程中，应不断优化和调整，以适应不同场景的需求。在实际项目中，还需要关注性能监控、异常处理、安全防护等方面，确保...

    Hibernate实现Oracle中数据的增删改查

    本篇将详细介绍如何使用Hibernate在Oracle数据库中实现数据的增删改查操作。 首先，我们需要了解Hibernate的基本概念。Hibernate是一个对象关系映射（ORM）框架，它通过XML或注解方式将Java类与数据库表进行映射，...

    hibernate连接oracle的jar包

    在Java开发领域，Hibernate是一个非常流行的对象关系映射（ORM）框架，它简化了数据库操作，使得开发者可以使用面向对象的方式来处理数据。Oracle则是一种强大的关系型数据库管理系统，广泛应用于企业级应用。当我们...

    使用JDBC和Hibernate来写入Blob型数据到Oracle中

    要将Blob型数据写入Oracle数据库，我们可以使用两种常见的技术：JDBC（Java Database Connectivity）和Hibernate。JDBC是Java与数据库交互的标准API，而Hibernate则是一个ORM（Object-Relational Mapping）框架，...

    hibernate 调用oracle函数

    本文将深入探讨如何在Hibernate中调用Oracle的函数，以实现高效的数据操作。 首先，我们需要理解Hibernate的核心理念，它允许开发者通过面向对象的方式来处理数据库操作，而无需编写大量的SQL语句。Hibernate通过...

    基于注解的springMVC+hibernate+oracle包含数据库查询

    在SpringMVC和Hibernate的集成中，我们需要配置数据源，使用JDBC驱动连接Oracle数据库。`spring-context.xml`配置文件中通常会包含`&lt;bean&gt;`标签来定义DataSource，使用`ojdbc.jar`驱动，并通过`...

    springmvc+hibernate+oracle基础框架

    《构建基于SpringMVC、Hibernate和Oracle的基础框架》 在现代企业级应用开发中，SpringMVC、Hibernate和Oracle的组合被广泛应用于构建强大的后端系统。这些技术各自扮演着关键角色，共同构成了一个高效、稳定的开发...

    基于struts+spring+hibernate+oracle的移动ssh项目源码

    基于struts+spring+hibernate+oracle的移动ssh项目源码 基于struts+spring+hibernate+oracle的移动ssh项目源码 基于struts+spring+hibernate+oracle的移动ssh项目源码 基于struts+spring+hibernate+oracle的移动ssh...

    Myeclipse 10.0 + Hibernate 4.3.5 连接 Oracle 11G的演示代码

    Hibernate 4.3.5 连接 Oracle 11G的演示代码" 描述的是一个整合项目，它将Myeclipse 10.0集成开发环境、Hibernate 4.3.5对象关系映射框架与Oracle 11G数据库相结合，用于演示如何在这样的环境中建立数据连接并执行...

    hibernate向oracle插入图片

    【标题】：“Hibernate向Oracle插入图片”的实现方法与步骤 在Java开发中，有时我们需要将图片数据存储到数据库中，特别是在构建支持用户上传图片的Web应用时。Oracle数据库是常用的数据库系统之一，而Hibernate...

    hibernate映射Oracle中LONG类型

    "hibernate映射Oracle中LONG类型" Hibernate 框架映射 Oracle 中的 LONG 类型字段是一种复杂的技术问题。Oracle 中的 LONG 类型字段是一种特殊的数据类型，用于存储可变长字符串，最大长度限制是 2GB。这与 Java ...

    J2EE开发使用Hibernate所需要的jar文件，Oracle驱动

    而Hibernate则是一个强大的对象关系映射（ORM）工具，它简化了Java与数据库之间的交互，使得开发者可以使用面向对象的方式来操作数据。在使用Hibernate进行J2EE开发时，需要依赖特定的jar文件来连接到数据库，尤其是...

    使用hibernate对oracle读取blob

    Hibernate作为一款流行的ORM（对象关系映射）框架，提供了与Oracle数据库交互的简便方式，包括处理Blob数据。本文将详细介绍如何使用Hibernate和JDBC读取和存储Oracle数据库中的Blob对象。 ### 1. Hibernate Blob...

    hibernate存取oracle的clob

    hibernate存取oracle的clob

    市调管理系统struts2+hibernate+oracle

    【标题】"市调管理系统struts2+hibernate+oracle"揭示了这是一个基于Java技术栈的Web应用程序，主要用于市场调查数据的管理。系统利用了Struts2作为MVC框架，Hibernate作为对象关系映射（ORM）工具，以及Oracle...

    hibernate query调用oracle存储过程

    Oracle数据库作为企业级的主流数据库系统，提供了丰富的存储过程和函数功能，以实现复杂的数据处理逻辑。而Hibernate作为一种流行的Java持久化框架，它允许开发者通过ORM（对象关系映射）方式与数据库进行交互。本篇...

    jsp+hibernate+oracle出库单模块

    在这个模块中，开发人员使用了JavaServer Pages（JSP）作为前端展示技术，Hibernate作为持久层框架来处理数据库交互，而Oracle数据库则作为数据存储系统，提供了强大的数据管理和事务处理能力。 【描述】提到的...

    hibernate链接oracle

    本文通过具体的XML配置示例详细介绍了如何使用Hibernate框架连接Oracle数据库，包括数据源的配置、SessionFactory的初始化、事务管理以及业务服务的设置等关键步骤。掌握了这些配置之后，开发者就可以更加高效地进行...

    test_hibernate_oracle_03.zip_Insert _hibernate_oracle_query_upda

    4. **Query**：在Hibernate中，可以通过HQL（Hibernate查询语言）或Criteria API进行数据查询，这两种方式都比直接写SQL更具有面向对象的特点。 5. **Update**：更新数据库记录也是Hibernate的重要功能，通过调用...

Magicbox
Global site tag (gtag.js) - Google Analytics