java框架简介1----Hibernate架构使用方法简介

Hibernate使用说明：
程序设计的开始部分就是模型抽象，在开始编码，最先实现的部分也是model。
数据库中储存的是要持久化的数据，数据库表的设计对整个工程的难易程度和代价起到了至关重要的作用。
Hibernate 可以根据实体类自动生成数据库的表和表间关系。并采用HQL语句进行查询（不是用SQL那个太过时了！！）
示例：



 
 
下面生成一个java的实体类（说明下：实体类就是内部全是属性（字段），让后就只有get和set方法，一般情况下一个实体类对应一个表）
Student.java:
package com.guan.HibernateTest.model;
 
import java.util.Date;
 
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
 
@Entity//表明这是个实体类
@Table(name="学生")//这个实体对应数据库中的表叫做”学生”
public class Student {
 
    private String name;
    private int id;
    private String studentId;
    private Date birthDay;
   
    @Column(length=32,nullable=false)//用来设定数据库表字段的属性
    public String getName() {
       return name;
    }
    public void setName(String name) {
       this.name = name;
    }
   
    @GeneratedValue//表明表的主键要采用自动增长的整型
    @Id//表明这是表的主键
    public int getId() {
       return id;
    }
    public void setId(int id) {
       this.id = id;
    }
   
    @Column(name="学号")//这个字段指定了表中的字段名字
    public String getStudentId() {
       return studentId;
    }
    public void setStudentId(String studentId) {
       this.studentId = studentId;
    }
    public Date getBirthDay() {
       return birthDay;
    }
    public void setBirthDay(Date birthDay) {
       this.birthDay = birthDay;
    }
}
 
 
上面student的实体类的定义，下面要将这个实体映射到具体的数据库。首先要知道数据库是哪一个，然后Hibernate要知道要将那些类映射到数据库中。下面给出Hibernate的配置文档。当Hibernate的架构被创建时，会自动寻找这个文档（一般根据文档名字寻找，通常叫做hibernate.cfg.xml放在src目录中）解析文档，完成映射。
hibernate.cfg.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 
<hibernate-configuration>
 
    <session-factory>
 
        <!-- Database connection settings 这里是数据库映射-->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!—驱动名字，不同的数据库提供了不同的驱动，本次使用的是mysql -->
        <property name="connection.url">jdbc:mysql://localhost/guanxinquan</property>
<!—连接字符串，说明要使用的是mysql中的哪一个数据库，注意localhost说明这个mysql安装在本地计算机上，也可以用远程的ip地址，这样就可以访问远程的数据库，guanxinquan是数据库的名字-->
        <property name="connection.username">root</property>
        <property name="connection.password">gxq</property>
 
        <!-- JDBC connection pool (use the built-in) -->
       
        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
   
        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
       <property name="current_session_context_class">thread</property>
        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>
       <property name="format_sql">true</property>
        <!-- Drop and re-create the database schema on startup -->
<!—自动生成数据库中的表，在更一般的情况下，表是由DBA生成的-->
        <property name="hbm2ddl.auto">create</property>
<!—需要映射成数据库中表的类-->
       <mapping class="com.guan.HibernateTest.model.Student"/>
    </session-factory>
 
</hibernate-configuration>
 
需要说明的是，由于程序中没有任何和数据库相关的信息，所以如果需要更换数据库，那么只需要修改这个配置文档中相应的字段，比如：我们想要把mysql数据库换成Oracle那么仅需将配置文件中的相关信息替换成Oracle就可以了，不需要修改程序代码，这是一种松耦合。
另外，我们新加入一个实体类，就在mapping中添加这个实体类的映射，是相当方便的。
Ps：您可能会想上面的配置文档好复杂呀，根本记不住。实际上我们也不需要记住，只要会读就行，因为在大多数情况下，配置的相应字段就是这些，一般情况下我们拷贝一个这样的文件，然后根据具体情况稍作修改就ok了！
 
下面需要写一个Test，来测试HibernateTest程序：
package com.guan.HibernateTest.model;
 
import java.util.Date;
 
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
 
public class StudentModelTest {
   
    private static SessionFactory sessionFactory = null;
   
    @BeforeClass//这个是junit标记，在类被创建前执行
    public static void beforeClass()
    {
       sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
    }
   
    @Test//junit测试标记，这样不同过main函数就可以直接执行这个函数
    public void createStudentTest()
    {
       Student student = new Student();//创建一个对象，并设置属性
       student.setBirthDay(new Date());
       student.setName("张三");
       student.setStudentId("S05080412");
      
       Session session = sessionFactory.openSession();//打开上下文
       session.beginTransaction();//开始一次事务（事务是数据库术语）
       session.save(student);//将创建的学生信息保存到数据库
       session.getTransaction().commit();//提交事务，真正的保存到数据库
       session.close();//关闭上下文，释放空间
    }
    //没有一条sql语句！！注意Hibernate中提倡的是HQL语句！！简单高效！！
 
    @AfterClass//junit标记，在类消除时执行，注意这个消除并不是对象，而是整个类结束。
    public static void afterClass()
    {
       sessionFactory.close();
    }
   
//在junit中无需有main函数，一般情况下还是写一个，有时通过这个main函数可以检测出Hibernate配置文件中的错误
    public static void main(String[] args){
      
       beforeClass();//这个main只有这一句，这是比较标准的写法
    }
}
 
接下来，需要配置一个log4j的配置文档，对数据库的操作会记录在一个文档中。这样省了自己写log那么麻烦，而且在调试阶段log4j相当有用。
log4j.properties
### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
 
### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n
 
### set log levels - for more verbose logging change 'info' to 'debug' ###
 
log4j.rootLogger=warn, stdout
 
#log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug
 
### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug
 
### log just the SQL
#log4j.logger.org.hibernate.SQL=debug
 
### log JDBC bind parameters ###
#log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug
 
### log schema export/update ###
log4j.logger.org.hibernate.tool.hbm2ddl=debug
 
### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug
 
### log cache activity ###
#log4j.logger.org.hibernate.cache=debug
 
### log transaction activity
#log4j.logger.org.hibernate.transaction=debug
 
### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug
 
### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace
 
你无需关心文档中写的是什么，实际上在测试阶段这样配置就行了，直接把文件拷贝过去就行，根本无需修改文件中的内容。注意文件名字别写错了log4j.properties。
 
最后，激动人心的时刻到了！！
我们用这样的方式执行程序：



 
 
说明：右键点击createStudentTest->弹出菜单中run as->Junit Test
Log4j将会输出如下内容：其中开始创建了一个叫做“学生”的表，然后向表中添加了一条记录。
 
 


这样，一个Hibernate框架的简单介绍就这样了，要想学习更多，请参考其文档（在其目录中有）。
附录 需要的jar包：
这些jar是Hibernate架构必须的，从各自架构的官方网站上都能找到。其中log4j是日志架构，annotations是Hibernate注解库，distribution是Hibernate架构，junit是测试架构，slf4j是日志接口。另外，我用的是mysql，所以也引入了mysql的驱动包。
 
 
 




 
包的引用方法：
先创建一个lib目录，然后将要添加的包拷贝到lib目录，刷新工程，然后
 
得到如下：



 
然后 Add JARS 把相应的包添加其中。