8.表名和类名不同，对表名进行配置
8.1在使用注解的实体类
//表名和类名不同，对表名进行配置；使用Table注解
@Table(name = "_teacher") //name后的为数据库中对应的表名
public class Teacher {}
执行TestCase时，console的语句
insert
into
_teacher
(name, title, id)
values
(?, ?, ?)
数据库中会出现_teacher，进行对表的操作。
8.2在使用配置文件时，/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/Student.hbm.xml
只要加上table属性对应的数据库中表的名称
<class name="Student" table="_student">
代码案例:
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 找不到entity，是因为这个类没改包名 -->
<hibernate-mapping package="com.zhuhw.hibernate.model">
<class name="Student" table="_student">
<!-- id主键；name=id对应的是Student中的getid() -->
<id name="id" ></id>
<property name="name" />
<property name="age" />
<!-- hibernater知道了怎么将class与表中的字段对应到一起了 -->
</class>
</hibernate-mapping>
出现的问题:
An AnnotationConfiguration instance is required to use <mapping class="com.zhuhw.hibernate.model.Teacher"/>
使用Configuration cf = new AnnotationConfiguration();
Configuration类只支持xml配置方式，AnnotationConfiguration扩展了Configuration类，同时支持xml配置和注解方式。
老师的价值就在项目上，在综合运用上。
从老美的认为:
1.查的能力
2.综合运用的能力
查询E:\zhuhw\hibernate\jar\hibernate-annotations-3.4.0.GA\doc\reference\zh_cn\html_single文档
用JPA的标准的
9.字段名和属性相同
a)默认为@Basic
b)xml中不用写column
例如:
@Basic //对数据库中，字段名和属性相同
public void setId(int id) {
this.id = id;
}
10.字段名属性不同
a)Annotation:@Column (直接写在get方法上)
b)xml:自己查询
注解方式代码案例:
/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/Teacher.java
//字段名属性不同a)Annotation:@Column
@Column(name = "_name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
执行结果:
console:
insert
into
_teacher
(_name, title, id)
values
(?, ?, ?)
数据库:增加_name与setName()对应。
xml方式，/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/Student.hbm.xml
<property name="name" column="_name" />
需要Hibernate API 中文版啊
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 找不到entity，是因为这个类没改包名 -->
<hibernate-mapping package="com.zhuhw.hibernate.model">
<class name="Student" table="_student">
<!-- id主键；name=id对应的是Student中的getid() -->
<id name="id" ></id>
<property name="name" column="_name" />
<property name="age" />
<!-- hibernater知道了怎么将class与表中的字段对应到一起了 -->
</class>
</hibernate-mapping>
11.不需要persistence的字段
a)Annotation:@Transient
b)xml:不写就好了（/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/Student.hbm.xml）
<property name="age" />不写
不要存到数据库中，
@Transient存储的时候把我当透明人就行了，不需要加到数据库中(就存到内存里就行了)
代码案例:
/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/Teacher.java
private String yourWifeName;
//不要存到数据库中
@Transient
public String getYourWifeName() {
return yourWifeName;
}
public void setYourWifeName(String yourWifeName) {
this.yourWifeName = yourWifeName;
}
12.映射日期与时间类型，指定时间精度
a)Annotation:@Temporal
b)xml:指定type
代码案例：
//映射日期与时间类型，指定时间精度
//通过@Temporal可以指定时间的精度
@Temporal(value=TemporalType.DATE)
public Date getBirthdate() {
return birthdate;
}
public void setBirthdate(Date birthdate) {
this.birthdate = birthdate;
}
正常的运行结果:
insert
into
_teacher
(birthdate, _name, title, yourWifeName, id)
values
(?, ?, ?, ?, ?)
insert
into
_teacher
(date, _name, title, yourWifeName, id)
values
(?, ?, ?, ?, ?)
把日期和时间都存起来了
@Temporal //通过@Temporal可以指定时间的精度
这里存在问题....
-----是没有按比如只有日期显示/时间显示
求解:
我错了
....写成Date date；关键字重复了... 所以木有生效呢
换下变量名称就ok了
2016-01-01
13.映射枚举类型
a)@Enumerared
b)xml:麻烦
数据库:
1.数据库存储String
/*@Enumerated(EnumType.STRING)
`zhicheng` varchar(255) DEFAULT NULL,*/
@Enumerated(EnumType.STRING)
A
2.数据库存储下标值
/*@Enumerated(EnumType.ORDINAL)
* 数据库存储下标值
`zhicheng` varchar(255) DEFAULT NULL,*/
@Enumerated(EnumType.ORDINAL)
生成一个enum类，
package com.zhuhw.hibernate.model;
public enum ZhiCheng {
A,B,C;
}
在/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/Teacher.java，
使用
//ZhiCheng enum
private ZhiCheng zhicheng;
public ZhiCheng getZhicheng() {
return zhicheng;
}
public void setZhicheng(ZhiCheng zhicheng) {
this.zhicheng = zhicheng;
}
14.字段映射的位置(field或者get方法)
a)best practice:保持gfield和 get set方法一致
15.@Lob
16.课外:CLOB BLOB类型的数据存储
17.课外:hibernate自定义数据类型
18.hibernate类型
在95%以上的没必要指定类型
由hibernate自动默认帮我们实现就好了。
本章节完整代码:
package com.zhuhw.hibernate.model;
import java.util.Date;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;
/*1.实体类(使用annotation进行实现，告诉hibernate是实体类，
* 不需要再建立Teacher.hbm.xml文件进行映射)
* 2.hibernate.cfg.xml进行配置即可
* 3.建立一个TeacherTest
*/
@Entity
//表名和类名不同，对表名进行配置
@Table(name = "_teacher")
public class Teacher {
private int id;
private String name;
private String title;
private Date birthdate;
//ZhiCheng enum
private ZhiCheng zhicheng;
/*@Enumerated(EnumType.STRING)
* 数据库存储String
`zhicheng` varchar(255) DEFAULT NULL,
*/
/*@Enumerated(EnumType.ORDINAL)
* 数据库存储下标值
`zhicheng` varchar(255) DEFAULT NULL,*/
@Enumerated(EnumType.ORDINAL)
public ZhiCheng getZhicheng() {
return zhicheng;
}
public void setZhicheng(ZhiCheng zhicheng) {
this.zhicheng = zhicheng;
}
//映射日期与时间类型，指定时间精度
//通过@Temporal可以指定时间的精度
@Temporal(value=TemporalType.DATE)
public Date getBirthdate() {
return birthdate;
}
public void setBirthdate(Date birthdate) {
this.birthdate = birthdate;
}
private String yourWifeName;
//不要存到数据库中
/*@Transient*/
public String getYourWifeName() {
return yourWifeName;
}
public void setYourWifeName(String yourWifeName) {
this.yourWifeName = yourWifeName;
}
//主键
@Id
public int getId() {
return id;
}
@Basic//对数据库中，字段名和属性相同
public void setId(int id) {
this.id = id;
}
//字段名属性不同a)Annotation:@Column
@Column(name = "_name")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
}
/hibernate_0100_HelloWorld/test/com/zhuhw/hibernate/model/TeacherTest.java
Junit Test Case
package com.zhuhw.hibernate.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 TeacherTest {
/*这个类TeacherTest一进来就被初始化了,在测试方法执行用已经初始化好的SessionFactory；
* 只初始化一次*/
public static SessionFactory sf = null;
@BeforeClass
public static void beforeClass(){
/*关于junit会出现吞掉bug，1.可以在下面的语句上加上try catch
* 2.或者加个main()方法，在main里面进行调用 beforeClass()*/
sf = new AnnotationConfiguration().configure().buildSessionFactory();
}
@Test
public void TestTeacherSave(){
Teacher t = new Teacher();
t.setId(14);
t.setName("zhuhw14");
t.setTitle("ccc14");
t.setBirthdate(new Date());
t.setYourWifeName("yourWifeName14");
t.setZhicheng(ZhiCheng.A);
//因为使用的annotation，所以Configuration要使用AnnotationConfiguration
/*Configuration cf = new AnnotationConfiguration();
SessionFactory sf = cf.configure().buildSessionFactory();*/
Session session = sf.openSession();
//在hibernate中执行操作要在一个事务里面
session.beginTransaction();
session.save(t);
session.getTransaction().commit();
session.close();
}
/*关于junit会出现吞掉bug，1.可以在下面的语句上加上try catch
* 2.或者加个main()方法，在main里面进行调用 beforeClass()*/
public void main() {
beforeClass();
}
@AfterClass
public static void afterClass(){
sf.close();
}
}
/hibernate_0100_HelloWorld/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>
<property name="connection.url">jdbc:mysql://localhost/hibernate</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<!-- JDBC connection pool (use the built-in) -->
<!--<property name="connection.pool_size">1</property>-->
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
<!-- Enable Hibernate's automatic session context management -->
<!--<property name="current_session_context_class">thread</property>-->
<!-- Disable the second-level cache -->
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</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 -->
<property name="hbm2ddl.auto">update</property>
<mapping resource="com/zhuhw/hibernate/model/Student.hbm.xml"/>
<mapping class="com.zhuhw.hibernate.model.Teacher"/>
</session-factory>
</hibernate-configuration>
/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/Student.java
package com.zhuhw.hibernate.model;
public class Student {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
private String name;
private int age;
}
/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/StudentTest.java
package com.zhuhw.hibernate.model;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
public class StudentTest {
public static void main(String[] args){
Student s = new Student();
s.setId(9);
s.setName("yuzhou9");
s.setAge(9);
Configuration cf = new AnnotationConfiguration();
SessionFactory sf = cf.configure().buildSessionFactory();
Session session = sf.openSession();
//在hibernate中执行操作要在一个事务里面
session.beginTransaction();
session.save(s);
session.getTransaction().commit();
session.close();
sf.close();
}
}
/hibernate_0100_HelloWorld/src/com/zhuhw/hibernate/model/Student.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- 找不到entity，是因为这个类没改包名 -->
<hibernate-mapping package="com.zhuhw.hibernate.model">
<class name="Student" table="_student">
<!-- id主键；name=id对应的是Student中的getid() -->
<id name="id" ></id>
<property name="name" column="_name" />
<property name="age" />
<!-- hibernater知道了怎么将class与表中的字段对应到一起了 -->
</class>
</hibernate-mapping>
package com.zhuhw.hibernate.model;
public enum ZhiCheng {
A,B,C;
}
/hibernate_0100_HelloWorld/src/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
相关推荐
在整合中，Hibernate负责数据持久化，通过注解配置，可以直接在实体类上声明字段与数据库表的对应关系，实现透明化的CRUD（创建、读取、更新、删除）操作。 4. Annotation（注解）：在Java中，注解是一种元数据，...
在“hibernate资料5”中，我们有两个关键的学习资源：016_尚学堂马士兵_Java视频教程_Hibernate3.3.2_hibernate基础配置.avi 和 017_尚学堂马士兵_Java视频教程_Hibernate3.3.2_Annotation字段映射位置.avi。...
5. **@Column**：用于指定字段映射到数据库表中的列。 6. **@ManyToOne/@OneToOne/@OneToMany/@ManyToMany**：这些注解用于定义实体之间的关系。 #### 四、JSR规范下的注解 1. **JSR 303/349（javax.validation...
2. 映射（Mapping）：实体和数据库表之间的关系通过XML或注解进行定义，包括字段映射、关联映射等。 3. 会话（Session）：它是持久化操作的入口，负责事务管理和对象状态的管理，提供了增删改查的基本操作。 4. 查询...
1. **配置与初始化**：Hibernate 3.3.2的配置文件（通常为hibernate.cfg.xml）是项目启动的基础，包含了数据库连接信息、缓存策略、事务管理等关键设置。初始化时，会通过SessionFactory构建器加载配置，并生成...
在本篇文章中，我们将详细探讨如何将Spring MVC与Hibernate结合，并利用注解（Annotation）进行配置。 首先，让我们了解这两个框架的基本概念。Spring MVC是Spring框架的一部分，它是一个用于构建Web应用的模型-...
Spring是一个全面的后端开发框架，提供依赖注入、AOP（面向切面编程）、MVC（模型-视图-控制器）等特性，而Hibernate则是一个强大的对象关系映射（ORM）工具，简化了Java应用与数据库之间的交互。当将两者结合使用并...
二、Hibernate注解基础 1. 实体类注解：`@Entity` `@Entity`注解用于标记一个Java类为数据库中的实体表，每个实例对应表中的一条记录。例如： ```java @Entity public class User { //... } ``` 2. 主键注解...
1. **配置与实体管理**： Hibernate通过`hibernate.cfg.xml`配置文件来设置数据库连接、缓存策略等。同时，它使用@Entity注解标识Java类为数据库实体。 2. **映射机制**： Hibernate支持XML映射文件（hbm.xml）和...
《Hibernate中文文档与Annotation》 Hibernate是一款开源的对象关系映射（ORM）框架，它极大地简化了Java应用程序对数据库的操作。Hibernate允许开发人员将Java对象模型与数据库表进行映射，从而避免了传统的JDBC...
《Hibernate Annotations中文帮助文档》是针对Java开发人员的一份详细指南，主要讲解如何使用Hibernate ORM框架中的注解来实现数据库对象的映射。该文档涵盖了从基础到高级的各种概念，帮助开发者更高效地管理和操作...
《Hibernate Annotation 中文文档》是Java开发者们的重要参考资料，它详细介绍了如何在Hibernate框架中使用注解进行对象关系映射（ORM）。Hibernate是一款强大的开源Java持久化框架，它简化了数据库与Java对象之间的...
**标题：“Hibernate继承映射(Annotation)详解”** 在Java持久化框架Hibernate中，继承映射是一种关键特性，它允许开发者将对象模型的继承结构映射到数据库的表结构。在传统的面向对象编程中，继承是实现代码复用和...
这篇文档主要讨论的是Hibernate Annotation的使用方法，以及它如何替代传统的XML配置文件（*.hbm.xml）进行对象-关系映射。 **1. Hibernate Annotation简介** Hibernate Annotation是Hibernate框架的一个扩展，它...
四、字段映射（Columns） 字段与数据库列的映射通过`@Column`注解实现，如指定列名、长度、是否可为空等： ```java @Entity public class User { @Id private Long id; @Column(name = "username", nullable = ...
3. **字段映射注解** - `@Column`：用于指定属性与数据库表的列之间的映射关系，可以设置列名、长度、是否允许为空等属性。 - `@GeneratedValue`：用于指定主键生成策略，例如自增（IDENTITY）、序列（SEQUENCE）...
而Hibernate注解则是其在ORM（对象关系映射）领域的进一步进化，它允许开发者将元数据直接嵌入到Java类和属性的声明中，从而避免了XML配置文件的繁琐。本篇将详细阐述Hibernate注解的相关知识。 一、Hibernate注解...
- **字段映射**： - **@Column**：用于指定字段的映射属性，如名称等。 - **关联关系映射**： - **一对一映射**： - 使用`@OneToOne`注解进行一对一映射配置。 - **多对一映射**： - 使用`@ManyToOne`注解进行...