Hibernate笔记整理完整版
Tarena
数据库连接池 --> <!--
<property name="connection.pool_size">1</property> 必配参数 通过dialect（方言) 来弥补数据库之间的差异 -->
<property name="dialect"> </property> <!-调试工具
默认的配置文件hibernate.cfg.xml
conf.configure();//默认加载src/hibernate.cfg.xml //创建SessionFactory SessionFactory factory=conf.buildSessionFactory(); //创建Session:与数据库之间的通话(类似于Connection) Session session=factory.openSession(); //获得事务 Transaction tx=session.getTransaction(); //开启事务 tx.begin();
Tarena
ng.Integer ng.String java.sql.Date b. Hibernate 类型 integer,double,long, string date,time,timestamp true_false,yes_no---相当于 boolean 类型
return sessionFactory.open行查询方法： public void testFindAll(){ Session session=HibernateUtils.getSession();
Tarena
//HQL 查询语句 hibernate query language 面向对象的查询语句
hibernate运行时加载的Hibernate映射配置文件 --> <mapping resource="tarena/xuesheng/entity/User.hbm.xml"/>
3） Hibernate 映射文件（可以有 n 个） ：用于指明类和表之间的对应关系， Hibernate 根据该文件生成 SQL 语句；映射名称为*.hbm.xml 推荐：类名 Emp，映射文件 Emp.hbm.xml ----------*.hbm.xml <?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="er" table="t_user1"> <id name="id" column="id" type="integer"> <generator class="identity"></generator> </id> <property name="name" column="name" type="string"> </property> </class> </hibernate-mapping> 4） 测试类 TestUser.java public class Test3{ @Test public void test1(){
Query query=session.createQuery(“from User”);//User 类名 ---from User where List<User>list=query.list(); session.close(); for(User user:list){ }
System.out.println(user.getId()+””+user.getNickname());
Tarena
//创建一个User对象 User user=new User(); user.setName("kobe"); //调用Hibernate的API用于装载Hinernate配置文件 Configuration conf=new Configuration(); //在类路径中装载
//如果配置文件关联了映射文件，同时也装载了映射信息 //如果装载指定的配置文件
org.hibernate.dialect.MySQLDialect
hibernate执行sql语句时，在控制台显示 --> <!--
<property name="show_sql">true</property>
</hibernate-configuration>
</session-factory>
----------核心 API: Configuration:配置和映射文件加载----Hibernate 主配置，映射文件 另一种方法：程序块中追加类----conf.addClass(User.class)进行追加 SessionFactory:session 对象工厂 .getSession()---获得 Session Session:用于进行增删改操作 .get(对象名.class,主键条件值) .createQuery(“from 对象名”);--创建 Query 对象 session.close();---关闭连接 Transaction：用于事务管理（无法自动提交，需要手动代码 commit） Transaction tx=session.beginTransaction();---开始事务 mit();---提交事务 Query:用于查询（是结果集对象）---是 HQL（hibernate query language）语言 List<对象名>list=query.lsit();---查询结果返回为集合 Iterator it=query.iterator();---返回迭代器 3. 主键生成方式 常用主键生成方式： 1） identity:用于自动生成主键方式，除了 Oracle 不支持，其他数据库一般都支持 （较常用） 。 2） sequence:Oracle 中使用，用序列生成 ID 主键:先调用指定的序列获取值，然后 再执行插入操作，写入数据表主键字段。 3） native: 主键生成方式如果是 native ，就看配置文件 hibernate.cfg.xml 中方言 <property name=”dialect”>是什么； 如果方言是 Mysql， 相当于 identity,如果方言 是 Oracle，相当于 sequence 4）increament:先获取主键最大值，然后再执行最大值+1，执行插入。 （并发性太高 系统不安全） 5）assigned:告诉 Hibernate 框架忽略主键值的生成，程序员需要显示指定值。 uuid:采用 UUID 算法生成一个主键值（字符串） hilo:采用高地位算法生成一个主键值（数值） 4. Hibernate 数据类型（了解） Hbm.xml 映射文件<property type=””>可以使用两种类型：推荐使用 Hibernate 类型 a. java 类型
6. Hibernate 框架特性： （1）一级缓存：每个 Session 对象都有一个一级缓存，当对某个对象获取时，首先 去一级缓存中获取，没有采取数据库查询。 当数据被缓存到 session 中时， session 就要负责维护缓存中的数据，这是 Hibernate 的重要机制：一级缓存机制。 理解： 1）如果 session 被查询，session 将先到缓存中查找是否有被查询的对象，找到则直接 取出，否则才查询数据库。 2）session 需要负责实时维护在缓存中的数据，保证缓存中的数据与数据库中数据一致 性，一旦用户对缓存中的数据做了修改，session 立刻将数据更新到数据库中。 3）当 session 关闭后，将销毁一级缓存。 4）一个 session 对象不能访问其他 session 对象的一级缓存。 ThreadLocal 利用一级缓存：利用 ThreadLocal 实现在多个类中只使用同一个 session 对象， 改造 HibernateUtil 的 getSession()方法，目的是为了保障多次调用 getSession() 方法返回同一 个 session，这样后续查询数据，可以从缓存中获取。-----session 与线程绑定 注意：当希望在多个类中调用 session ，则不要关闭 session(session.close()), 否则，其他 类将使用不到 session 对象。 ----------修改 HinernateUtil 工具类 public class HibernateUtil { public static Configuration conf; private static SessionFactory sessionFactory;
//插入数据,或者删除，更新数据 session.save(user);//delete(user),update(user), //提交事务 mit();
}
}
//关闭session session.close();
----------封装为 HibernateUtil: public class HibernateUtil { public static Configuration conf; private static SessionFactory sessionFactory; static{ conf=new Configuration(); conf.configure(); sessionFactory=conf.buildSessionFactory(); } public static Session getSession(){
强人Hibernate文档笔记(上中下)
强人Hibernate文档笔记（上）Hibernate文档笔记共分为三个部分，此处是第一部分，讲述了对象定义、实例状态、JMX 集成和JCA 支持四个部分的内容。
一、对象定义.hibernate.SessionFactory对于单个数据库，被编译的映射，是一个线程安全的缓冲区。
是一个Session和ConnectionProvider客户端的工厂。
拥有可选的对过程级和集群级重复利用的数据的缓存（二级缓存）。
.hibernate.Session单线程、短生命周期的在应用程序和持久化存储系统之间的一个会话对象。
封装了一个JDBC连接。
是一个事务的工厂。
拥有强制的对持久化对象的缓存（一级缓存），当通过标识浏览对象之间关系和查找对象时使用。
3.Persistent objects and collections包含执久化状态和业务功能的短生命周期的、单线程对象。
可以是POJOs，通常是和Session（严格说，是单个Session）相关联的对象。
Session一关闭，他们将和Session 分离，可以自由的使用在应用层的任何地方。
（也就是说，作为传输对象使用（Transfer Object）。
）4.Transient and detached objects and collections不和当前Session关联的持久化类的实例。
他们可以被应用程序在不持久化时实例化，也可以被关闭的Session实例化。
.hibernate.Transaction （可选）应用程序用来指定一个原子操作的单线程、短生命周期的对象。
低层JDBC、JTA、CORBA 事务的抽象程序。
在相似的情况下，一个Session可以同时横跨多个事务。
事务划分，既可以使用低层的APIs，也可以使用Transaction。
.hibernate.connection.ConnectionProvider （可选）JDBC连接或JDBC连接池的工厂。
Hibernate笔记完整版
day1一. hibernate数据持久化组件对象持久化(Object Persistence):把数据保存在永久存储介质中（数据库）1.为什么要持久化:a.内存是暂时存储设备,断电后数据易丢失b.网络传输无法传输内存中的对象，需要将对象外化c.内存中数据查询,组织不方便d.内存只能存储少量数据2.怎样持久化a.对象序列化 --> 二进制流合并存储,粒度大,无规律不支持检索只适合少数个别对象的序列化b.用JDBC/EJB/ORM 将数据存入数据库用JDBC:(Java DB Connection)优点:底层开发,控制力强(细); 效率最高; 标准的(SQL)JDBC,有可移植性缺点:过于复杂; 代码量大; 可维护性差(代码重用性低);用EJB:(Entity Java Bean)优点:直接自动生成JDBC代码; 持久对象(PO)的状态由服务器管理; 声明式的事务缺点:功能不全(特殊的组件,不能做继承关系); EJB容器是侵入性容器,失去OO的优点; 调试更复杂用ORM:（object relation mapping）对象关系映射优点:自动生成JDBC(代码量下降); 使用(plain oldest java object---pojo),非侵入型; 提供状态管理; 难度下降,不需要容器缺点:由于开源, 文档少; bug多; 技术支持差结论: 用java开发-->必须将数据持久化-->用数据库持久化-->须用ORM-->需要用Hibernate二. Hibernate1.POJO类plain oldest java object,就是标准的Java Bean。
2.HibernateHibernate -->一个可以自动的根据xml完成对象关系映射，并持久化到数据库的开源组件。
其底层也是由JDBC实现的。
hibernate是通过xml文件的配置，对数据库的底层的方言，以及数据库连接所需的信息，以及连接数据库的驱动。
Hibernate课堂笔记
Hibernate部分学习笔记讲师:梁建全liangjq@目录Hibernate部分学习笔记 (1)Day01 (5)一、Hibernate基本概念 (5)1、Hibernate是什么，有什么作用和好处 (5)2、Hibernate实现原理 (5)3、Hibernate框架主要结构 (5)二、Hibernate基本应用 (6)1、Hibernate使用步骤 (6)三、映射类型 (9)1、Hibernate映射类型主要有以下几种： (9)四、主键生成 (10)Day02 (11)一、Hibernate框架的基本特性 (11)1、Hibernate一级缓存 (11)A.一级缓存的特点 (11)B.一级缓存的好处 (11)C.使用建议 (11)2、Hibernate对象持久性 (13)3、Hibernate延迟加载 (14)A.针对于以下方法，Hibernate默认使用延迟加载机制： (14)B.Session的get和load方法区别： (14)C.延迟实现原理 (15)D.Hibernate框架如何动态生成一个代理类 (15)E.使用建议 (15)二、Hibernate综合练习 (15)前期案例：任务列表示例重构（采用Struts2+Hibernate） (15)A.Hibernate前期准备 (15)B.为了更好使用一级缓存，采用ThreadLocal封装Session (16)C.采用Hibernate重构ProjectDAO (17)D.为了支持延迟加载API，采用拦截器实现OpenSessionInView模式 (18)Day03 (20)一、什么是关联映射，有什么好处 (20)二、一对多关联映射 (20)示例：d_order和d_item存在一对多的业务关系 (20)一对多关系映射的实现步骤： (20)三、多对一关联映射 (21)多对一关系映射实现步骤： (21)四、关联操作 (22)1、关联查询 (22)2、利用lazy属性控制延迟加载 (22)3、级联操作（采用关系级联方式进行添加、删除、更新操作） (22)A.在关联属性映射部分添加cascade属性，可以指定以下属性 (22)B.Inverse属性的作用 (22)C.级联添加 (23)D.级联删除 (23)Day04 (24)一、如何使用Myeclipse生成映射文件和实体类? (24)1、如何根据DB生成实体类和映射文件 (24)A.利用Myeclipse追加Hibernate框架步骤: (24)B.利用Myeclipse根据表生成实体类和映射文件 (26)二、多对多关系映射 (29)三、继承关系映射 (30)1、继承关系映射（1） (30)A.首先将Book继承自Product类 (30)B.修改Book.hbm.xml描述信息 (30)2、继承关系映射(2)---理解 (31)Day05 (33)一、其他映射 (33)1、List集合映射 (33)2、formula子查询映射 (33)3、Component组件映射 (34)4、联合主键映射 (35)案例：采用联合主键映射+组件映射对t_person表进行操作。
韩顺平 hibernate笔记
◆hibernate是什么?1.hibernate 是一个框架(framework)2.hibernate 是一个orm框架[]●orm (object relation mapping) 对象关系映射框架o object -> 业务层(只对对象操作)r relation-> 关系数据库m mapping 对象关系映射文件3.hibernate 处于我们项目的持久层位置(正因为如此，所以有人又把hibernate称为持久层框架)4.hibernate 实际上就是对jdbc进行了轻量级的封装.5.hibernate 的基础还是我们java 反射机制●除了hiberante 这个orm框架，还有一些:apache ojb / toplink / ibatis / ejb cmpApache OJB （）Cayenne （）Jaxor （）Hibernate（）iBatis （）jRelationalFramework （）mirage （）SMYLE （）TopLink （）把对象持久化: 把对象的信息保存到数据库或者是文件.总结: hibernate 是对jdbc进行轻量级封装的orm 框架，充当项目的持久层.◆为什么需要hibernate?◆快如入门案例:hiberante 可以用在j2se 项目，也可以用在j2ee (web项目中)struts是web框架,所以用在web项目我们使用手动配置hibernate方式开发一个hibernate 项目，完成crud操作。
开发流程1.创建一个项目2.画出一个简单项目框架示意图3.引入hibernate 开发包(从网上下载google hibernate ),完后我们4.开发hibernate 有三种方法（开发顺序）我们使用第二种开发项目创建employe 表.create table employee(id number primary key,name varchar2(64) not null,email varchar2(64) not null,hiredate date not null)创建一个序列，将来用于主键的自增长:--创建一个序列create sequence emp_seqstart with 1increment by 1minvalue 1nomaxvaluenocyclenocache5.开发domain对象和对象关系映射文件对象关系映射文件：作用是用于指定domain对象和表的映射关系. ,该文件的取名有规范: domain对象.hbm.xml,一般我们放在和domain对象同一个文件夹下(包下)我们的Employee.hbml.xml配置文件：<!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.hsp.domain"><class name="Employee" table="employee"><!-- id元素用于指定主键属性--><id name="id" column="id" type="ng.Integer"><!-- 该元素用于指定主键值生成策略hilo native increment sequence uuid --><generator class="sequence"><param name="sequence">emp_seq</param></generator></id><!-- 对其它属性还有配置--><property name="name" type="ng.String"><column name="name" not-null="false" /></property><property name="email" type="ng.String" ><column name="email" not-null="false"/></property><property name="hiredate" type="java.util.Date"><column name="hiredate" not-null="false" /></property></class></hibernate-mapping>6.手动配置我们的hibernate.cfg.xml文件，该文件用于配置连接的数据库的类型，driver, ,用户名，密码,url ....同时管理对象关系映射文件,该文件的名称，我们一般不修改.hibernate.cfg.xml配置文件<?xml version="1.0" encoding="utf-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><!-- hibernate 设计者，给我们提供了一写常用的配置--><!-- 配置使用的driver --><property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property> <property name="ername">scott</property><property name="connection.password">tiger</property><property name="connection.url">jdbc:oracle:thin:@127.0.0.1:1521:orclhsp</property> <!-- 配置dialect方言,明确告诉hibernate连接是哪种数据库--><property name="dialect">org.hibernate.dialect.OracleDialect</property><!-- 显示出对于sql --><property name="show_sql">true</property><!-- 指定管理的对象映射文件--><mapping resource="com/hsp/domain/Employee.hbm.xml"/></session-factory></hibernate-configuration>7.测试文件TestMain.javapackage com.hsp.view;import com.hsp.util.*;import java.util.Date;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.*;import com.hsp.domain.Employee;public class TestMain {/*** @param args*/public static void main(String[] args) {//查询[load]->hql语句(hibernate query language)}public static void delEmp() {//删除//获取一个sessionSession session=MySessionFactory.getSessionFactory().openSession();Transaction ts=session.beginTransaction();//删除1.先获取该雇员，然后删除Employee emp=(Employee) session.load(Employee.class, 3);session.delete(emp);mit();session.close();}public static void updateEmp() {// TODO Auto-generated method stub//修改用户//获取一个会话Session session=MySessionFactory.getSessionFactory().openSession();Transaction ts=session.beginTransaction();//修改用户1. 获取要修改的用户，2.修改//load是通过主键属性，获取该对象实例.<--->表的记录对应Employee emp=(Employee) session.load(Employee.class, 3);emp.setName("韩顺平8");//update...emp.setEmail("abc@");mit();session.close();}public static void addEmployee() {//我们使用hibernate完成crud操作[这里我们只见对象，不见表]//现在我们不是用service ,直接测试.//1。
马士兵hibernate学习笔记(文字整理版)
马士兵hibernate学习笔记(文字整理版)课程容 (5)1 HelloWorld (5)2 Hibernate原理模拟 - 什么是O/R Mapping以及为什么要有O/R Mapping (5)3 常见的0/R框架(了解) (5)4 hibernate基础配置（重点） (5)5 ID生成策略（重点 AUTO) (5)6 Hibernate核心开发接口介绍（重点） (5)7 对象的三种状态（了解） (5)8 关系映射（重点） (5)9 Hibernate査询（HQL) (5)10 在Struts基础上继续完善BBS200 (5)11 性能优化（重点） (5)12 补充话题 (5)风格 (5)1 先脉络，后细节 (5)2 先操作，后原理 (5)3 重Annotation,轻xml配置文件 (5)资源 (5)1 . (5)2 hibernate zh_CN文档 (5)3 hibernate annotation references (5)环境准备 (5)1 下载hibernate-distribution-3.3.2.GA-dist (5)2 下载hibernate-annotations-3[1].4.0.GA (5)3 注意阅读hibernate compatibility matrix(hibernate download) (5)4 下载slf4jl.5.8 (6)Hibernate HelloWorld (6)1 建立新java 项目,名为hibernate_0100_HelloWorld (6)2 学习建User-library-hibernate,并加入相应的jar包 (6)3 引入mysql的JDBC驱动包 (6)4 在mysql中建立对应的数据库以及表 (6)5 建立hibernate 配置文件hibernate.cfg.xml (6)6 建立Student 类 (6)7 建立Student 映射文件 Student.hbm.xml (6)8 将映射文件加入到hibernate.cfg.xml中 (6)9 写测试类Main,在Main中对Student对象进行直接的存储测试 (6)10 FAQ： (6)11 Note: (6)12 建立能力 (7)建立 Annotation 版本的 HelloWorld (7)1 创建teacher 表，create table teacher (id int primary key, name varhcar(20), title varchar(lO)); (7)2 创建Teacher 类 (7)3 在hibernate lib 中加入annotation的jar包 (7)4 参考Annotaion文档建立对应的注解 (7)5 在hibernate.cfg.xml中建立映射<mapping class:.../〉 . (7)6 参考文裆进行测试（注意文裆中缺少configure()的小bug) (7)7 FAQ: 不给提示 (7)What is and Why 0/R Mapping (7)1 JDBC操作数据库很繁琐 (7)2 Sql语句编写并不是面向对象的 (7)3 可以在对象和关系表之间建立关联来简化编程 (7)4 0/R Mapping 简化编程 (7)5 0/R Mapping跨越数据库平台 (7)6 Hibernate_0200_OR_Mapping_Simulation (7)0/R Mapping Frameworks (7)1 hibernate (7)2 toplink (8)3 jdo (8)4 JPA (8)Hibernate基础配置 (8)1 对应项目：Hibernate_0300_BasicConfiguration (8)2 介绍MSQL的图形化客户端 (8)3 hibernate.cfg.xml: hbni2ddl.auto (8)4 搭建日志环境并配置显示DDL语句 (8)5 搭建jUnit环境 (8)6 hibernate.cfg.xml：show_sql (8)7 hibernate.cfg.xml：format_sql (8)8 表名和类名不同,对表名进行配置 (8)9 字段名和属性相同 (8)10 字段名和属性名不同 (8)11 不需要psersistence的字段(不用列) (8)12 映射日期与时间类型，指定时间精度 (8)13 映射枚举类型( 比较少用) (9)14 字段映射的位置（field或者get方法） (9)15 Lob (9)16 课外：CLOBBLOB类型的数据存取 (9)17 课外：Hibernate自定义数据类型 (9)18 hibernate 类型 (9)ID生成策略 (9)1 对应项目：hibernate_0400_ID (9)2 注意： (9)3 xml生成id (9)4 注解方式：GeneratedValue (9)5 FAQ; (10)6 联合主键 (10)核心幵发接口介绍 (12)1 hibernate_0500_CoreAPI (12)2 Hibernate API文档需要单独下载 (12)3 Configuration (12)4 SessoinFactor (12)5 Session (12)6 SchemaExport (自动建表) (13)7 Query 接口 (13)8 Note： (13)三种对象状态 (14)1 上一个 project (14)2 三种状态的区分关键在于 (14)3 三种状态： (14)4 对这三种状态需要关注的问题是在该状态下如果进行数据库的操作会发生什么结果，比如改变属性的 (14)关系映射(重要) (15)对象之间的关系 (15)1 这里的关系映射指的是对象之间的关系，并不是指数据库的关系，本章解决的问题是当对象之间处于 (15)2 简化问题： (15)3 —对一 (15)4 —对多 (15)5 组件映射 (15)一对一关联 (16)1 一对一单向外键关联 (16)2 一对一双向外键关联 (16)3 一对一单向主键关联（不重要） (17)4 一对一双向主键关联（不重要） (17)5 联合主键 (17)组件映射 (17)1 项目：hibernate_1100_component (17)2 对象关系：一个对象是另外一个对象的一部分 (17)3 数据库表：一表 (17)4 annotation: Embeddable Embbeded (17)5 xml: 使用<component,例如: (18)多对一与一对多 (18)1 多对一单向关联 (18)2 一对多单向关联 (19)3 一对多（多对一）双向关联 (19)多对多 (20)1 单向关联： (20)2 双向关联： (21)关联关系中的CRUD_Cascade_Fetch (21)1 hibernate_1700_one2many_many2one_bi_crud (21)2 设定cascade以设定在持久化时对于关联对象的操作（CUD，R归Fetch管） (21)3 cascade仅仅是帮我们省了编程的麻烦而已，不要把它的作用看的太大 (21)4 铁律：双向关系在程序中要设定双向关联 (22)5 铁律：双向mappedBy (22)6 fetch (22)7 Update时ManyToOne()中的cascade参数关系 (22)8 Delete时ManyToOne()中的cascade关系 (22)9 O/RMapping 编程模型 (23)10 要想删除或者更新先做load,除了精确知道ID之外 (23)11 如果想消除关联关系，先设定关系为null.再删除对应记录，如果不删记录，该记录变成垃圾数据 (23)12 练习：多对多的CRUD (23)关系映射总结 (24)1 什么样的关系，设计什么样的表，进行什么样的映射 (24)2 CRUD,按照自然的理解即可（动手测试） (24)集合映射（不太重要） (24)1 项目名称：hibernate_1800_Collections_Mapping (24)2 Set (24)3 List (与Set差不多多个OrderBy) (24)4 Map (24)继承映射（不太重要） (24)1 三种方式 (24)作业: (24)1 学生课程、分数的设计(重要) (24)2 设计： (25)3 树状结构的设计（至关重要） (25)Hibernate 查询(Query Language) (26)HQL vs EJBQL (26)1 NativeSQL >HQL.> EJBQL(JPQL 1.0) > QBC(Query By Criteria) > QBE(Query By Example)" 262 总结：QL应该和导航关系结合，共同为査询提供服务。
Hibernate笔记
Main.java
package com.it315.main; import java.util.Date; import org.hibernate.Session; import org.hibernate.Transaction; import er; import ls;
批注 [z3]: 连接数据库的 URL 地址。 批注 [z4]: 用户名。 批注 [z5]: 密码。 批注 [z6]: 每次加载 hibernate，重 新创建数据库表结构， 这就是导致数 据库表数据丢失的原因。 批注 [z7]: 显示生成的 SQL 语句。 批注 [z8]: 指定映射文件的路径。 批注 [z2]: 数据库驱动的名称。 批注 [z1]: 数据库的方言。
注意：初始化的代码是很耗资源的，所以将上面代码修改为：
HibernateUtils.java package com.it315.util; import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public final class HibernateUtils { private static SessionFactory sessionFactory; static { Configuration cfg = new Configuration(); sessionFactory = cfg.configure().buildSessionFactory(); } public static Session getSession(){ return sessionFactory.openSession(); } }
hibernate4学习笔记
hibernate4学习笔记Hibernate4学习笔记本⼈全部以⾃学为主，在⽹上收集各种学习资料，总结归纳学习经验，现将学习路径给予⼤家分享。
此次学习的hibernate的版本是：hibernate-release-4.2.4.Final（截⽌2015年7⽉31⽇最新版），JAVA的版本是：java8.0，使⽤的开发⼯具是：Eclipse Mars Release (4.5.0)。
第⼀天：Hibernate4基础知识和HelloWorld简单编程Hibernate是⼀种半成品ORM框架，对数据库持久化操作，程序员对数据库的操作转换成对对象的操作。
ORM 采⽤元数据来描述对象-关系映射细节, 元数据通常采⽤XML 格式, 并且存放在专门的对象-关系映射⽂件中。
HelloWorld简单编程1、准备Hibernate环境（1）导⼊Hibernate的Jar包，如下：（2）导⼊Mysql驱动包，我⽤的数据库是：Mysql 5.0，数据库驱动包如下：以上所有Jar加完毕之后，需要加⼊到Eclipse⾃⾝系统⾥⾯，具体如下：以上操作完毕之后，Hibernate的环境就算搭建完毕，下⾯就可以进⼀步操作。
2、配置hibernate.cfg.xml⽂件，主要是对数据库的连接，具体如下："-//Hibernate/Hibernate Configuration DTD 3.0//EN""/doc/63fa364d5022aaea998f0fde.html /hibernate-configuration-3.0.dtd ">rootmysqlname="connection.driver_class">com.mysql.jdbc.Driver jdbc:mysql:///Test(或者：jdbc:mysql://localhost:3306/Test)name="dialect">org.hibernate.dialect.MySQLInnoDBDialecttruetrueupdate3、编写⼀个实例类News.java，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;public class News {private Integer id;private String title;private Date date;public Integer getId() {return id;}public void setId(Integer id) {this.id = id;}public String getTitle() {return title;}public void setTitle(String title) {this.title = title;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public Date getDate() {return date;}public void setDate(Date date) {this.date = date;}public News(String title, String author, Date date) { super();this.title = title;this.author = author;this.date = date;}public News(){}@Overridereturn"News [id="+ id+ ", title="+ title+ ", author="+ author + ", date=" + date + "]";}}4、创建News.hbm.xml配置映射⽂件，具体代码如下："/doc/63fa364d5022aaea998f0fde.html /hibernate-mapping-3.0.dtd">5、将映射⽂件News.hbm.xml指定到hibernate.cfg.xml配置⽂件⾥⾯，即在hibernate.cfg.xml⽂件⾥加⼊⼀⾏映射代码，具体如下：6、创建hibernate API操作测试类（Juit测试），验证hibernate的优势效果，具体代码如下：package com.hibernate.helloworld;import java.sql.Date;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.Transaction;import org.hibernate.cfg.Configuration;import org.hibernate.service.ServiceRegistry;import org.hibernate.service.ServiceRegistryBuilder;import org.junit.Test;public class HibernateTest {@Testpublic void test() {//1. 创建⼀个 SessionFactory 对象SessionFactory sessionFactory=null;//1). 创建 Configuration 对象: 对应 hibernate 的基本配置信息和对象关系映射信息Configuration configuration=new Configuration().configure();//4.0 之前这样创建//sessionFactory=configuration.buildSessionFactory();//2). 4.0以后创建⼀个 ServiceRegistry 对象: hibernate 4.x 新添加的对象//hibernate 的任何配置和服务都需要在该对象中注册后才能有效.ServiceRegistry serviceRegistry=newServiceRegistryBuilder().applySettings(configuration.getProperties() ).buildServiceRegistry();sessionFactory=configuration.buildSessionFactory(serviceRegistry) ;//2. 创建⼀个 Session 对象Session session=sessionFactory.openSession();//3. 开启事务Transaction transaction=session.beginTransaction();//4. 执⾏保存操作News news = new News("Java12345", "ATGUIGU", new Date(new java.util.Date().getTime()));session.save(news);//5. 提交事务/doc/63fa364d5022aaea998f0fde.html mit();//6. 关闭 Sessionsession.close();//7. 关闭 SessionFactory 对象sessionFactory.close();}}7、测试结果如下：（1）数据库⾥⾯的结果如下：（2）Eclipse下的语句⽣成如下：以上就是简单Hibernate的测试，总结：1、不需要在数据库⾥⾯创建任何数据，由hibernate ⾃动⽣成；2、代码简单易理解，不复杂，测试数据只需要先创建以下⼏个步骤：SessionFactory-→Session-→Transaction-→session操作数据库-→提交-→关闭；3、不需要写SQL 语句，从头到尾没有写⼀条SQL语句，反⽽Hibernate帮我们⽣成SQL语句。
Hibernate笔记总结
1）show_sql:true2）hibernate.cfg.xml 移到 srcHibernateSessionFactory:location…3)主键生成策略:sequenceassigned:应用程序指定-------------------dao(UserInfo)1)添加,删除，更新public void saveUser(UserInfo user)throws Exception{ //1得到sessionSession session=HibernateSessionFactory.getSession();//2.声明事务Transaction tx =session.beginTransaction();//3.保存session.save(user);//delete,update//4.提交mit();//5.关闭HibernateSessionFactory.closeSession();}2)根据userId得到UserInfopublic UserInfo getUserById(userId)throws Exception{ UserInfo user = null;user =(UserInfo)session.get(UserInfo.class,userId);return user;}/*** 根据 id得到商品信息* (复选框多个id传递)* @return*/public St ring getGoodsById() {HttpServletRequest resquest=ServletActionContext.getRequest();String[] ids=resquest.getParameterValues("id");for (int i = 0; i < ids.length; i++){try {goods = gb.getGoodsById(Long.parseLong(ids[i]));} catch (Exception e) {e.printStackTrace();}goodslist.add(goods);System.out.println(goodslist.size());}if (goodslist != null) {return SUCCESS;} else {return INPUT;}}/*** 根据id得到订单信息* @return*/(单个id传递)public String getOrdersByid() {HttpServletRequest resquest=ServletActionContext.getRequest();String id=resquest.getParameter("id");try {orders = ob.getOrdersByid(Long.parseLong(id));} catch (Exception ex) {ex.printStackTrace();return INPUT;}if(orders!=null){return SUCCESS;}else{return INPUT;}}3)根据userName实现模糊查询public List<UserInfo> getUserByName(uname){Criteria c = session.createCriteria(Userinfo.class);c.add(Restrictions.like(“userName”,”%”+uname +”%”)); List<UserInfo> userList =c.list();return userList;}public List<UserInfo> getUserByName(uname){String hql=”from UserInfo u where erName like ?”; Query q=session.createQuery(hql);q.setString(0,”%”+uname+”%”);List<UserInfo> userList =q.list();return userList;}4)登陆:public UserInfo getUserByLoginId(String loginId)throws Exception{UserInfo user = null;Criteria c =session.createCriteria(UserInfo.class);c.add(Restrictions.eq(“loginId”,loginId));user=(UserInfo)c.uniqueResult();return user;}5)得到总的记录数(分页)public int getT otalCount()throws Exception{Query query =session.createQuery(“from UserInfo”);int num=query.list().size();return num;}public int getT otalCount()throws Exception{Criteria c =session.createCriteria(UserInfo.class);int num= c.list().size();return num;}public int getT otalCount()throws Exception{Query query=session.createQuery(“select count(u) from UserInfo u”);int num=(Integer)query.uniqueResult();return num;}6)分页:public List<UserInfo> getUserListByPage(int nowpage,int pageSize)throws Exception{Criteria c =session.createCriteria(UserInfo.class);c.setFirstResult((nowpage-1)*pageSize);c.setMaxResults(pageSize);c.addOrder(Order.desc(“ctime”));List<UserInfo> list=c.list();return list;}public List<UserInfo> getUserListByPage(int nowpage,int pageSize)throws Exception{ Query query=session.createQuery(“from UserInfo u order by u.ctime ”);query.setFirstResult((nowpage-1)*pageSize);query.setMaxResults(pageSize);List<UserInfo> list=query.list();return list;}登陆/*** 用户登录(dao实现)*/public Userinfo login(String username)throws Exception {List<Userinfo> userinfolist=super.getHibernateTemplate().find("from Userinfo u where ername='"+username+"'");Userinfo userinfo=null;if(userinfolist.size()>0){userinfo=userinfolist.get(0);}return userinfo;1) }2)Biz实现：/*** 用户登录*/public Userinfo login(String username, String userpassword)throws Exception {//调用方法Userinfo userinfo=userinfodao.login(username);if(userinfo!=null){if(!userinfo.getUserpassword().equals(userpassword)){throw new Exception("密码错误");}}else{throw new Exception("用户名错误");}return userinfo;}3)}public UserInfo isLogin(String loginId,String pwd)throws Exception{UserInfo user=null;try{user= userDao.getUserByLoginId(loId);if(user==null)throw new Exception(“用户名不存在”);else if(!user.getLoginPwd().equals(pwd))throw new Exception(“密码不正确”);elsereturn user;}catch(Exception ex){throw new Exception(ex.getMessage());}}4)得到总页数public int getT otalPages(int pageSize)throws Exception{//1.得到总记录数int totalCount=userDao.getT otalCount();//2.得到总的页数int totalPage = totalCount/pageSize;totalPage=totalCount%pageSize==0?totalPage:totalPage+1;return totalCount;}Action里：/*** 分页* @return*/public String getAll(){//设置当前页为1this.nowPage=1;try{this.nowPage=this.page;}catch(Exception e){}try{//获取总记录数(调用方法)int totalnum=movebookingbiz.getTotalnum().size();//获取总页数(把totalnum作为参数用)this.totalPage=totalnum%5==0?totalnum/5:totalnum/5+1;//判断if(nowPage>=totalPage){nowPage=totalPage;}if(nowPage<=1){nowPage=1;}//调用方法this.mblist=movebookingbiz.getMoveBookingListByPage(this.nowPage,5);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();return INPUT;}return SUCCESS;}Basedao:/*** 分页显示*/public List<MoveBooking> getMoveBookingListByPage(final int nowPage, final int pageSize) throws Exception {List<MoveBooking> mblist=this.getHibernateTemplate().executeFind(new HibernateCallback() {public Object doInHibernate(Session session)throws HibernateException, SQLException { Criteria c =session.createCriteria(MoveBooking.class);c.setFirstResult((nowPage-1)*pageSize);c.setMaxResults(pageSize);c.addOrder(Order.desc("mbcontact"));List<MoveBooking> movebookinglist=c.list();return movebookinglist;}});return mblist;}得到总数;/*** 得到总数*/public List<MoveBooking> getTotalnum() throws Exception {return list;}Jsp;<c:forEach var="list"items="${mblist }"><tr><td>${list.mbarea}</td><td>${list.mbcartype}</td><td><fmt:formatDate value="${list.mbmovedate}"pattern="yyyy-MM-dd"/></td><td>${list.mbcontact}</td><td>${list.mbphone}</td><td><c:if test="${list.mbstatus=='0 ' }">未处理</c:if><c:if test="${list.mbstatus=='1 ' }">已派车</c:if><c:if test="${list.mbstatus=='2 ' }">已结束</c:if></td><td align="center"><input type="submit"name="button"id="button"value="处理"<c:if test="${list.mbstatus=='2' }">disabled="disabled"</c:if>onclick="javascript:location.href='toEdit.action?id=${list.mbid}'" /><input type="submit"name="button2"id="button2"value="详情"onclick="javascript:location.href='toView.action?id=${list.mbid}'"/></td></tr></c:forEach><a href="getAll.action?page=1">首页</a><a href="getAll.action?page=${nowPage-1 }">上一页</a><a href="getAll.action?page=${nowPage+1 }">下一页</a><a href="getAll.action?page=${totalPage }">末页</a>批量删除：Biz实现:/*** 批量删除*/public void deleteByIds(String arraylist) throws Exception {String ids[] = arraylist.split(",");List<Userinfo> userlist = new ArrayList<Userinfo>();for (int i = 0; i < ids.length; i++) {Userinfo info = userdao.getUserById(Integer.parseInt(ids[i]));userlist.add(info);}userdao.deleteByIds(userlist);}//声明sessionprivate Map<String,Object> session;session=ActionContext.getContext().getSession();/*** 将上传的图片文件保存到字符数组中* @param photo* @return* @throws Exception*/public static byte[] toByteArray(File photo)throws Exception{FileInputStream fis=new FileInputStream(photo);BufferedInputStream bis=new BufferedInputStream(fis);ByteArrayOutputStream baos=new ByteArrayOutputStream();int c=bis.read();while(c!=-1){baos.write(c);c=bis.read();}bis.close();byte[] rtn=baos.toByteArray();baos.close();return rtn;}/*** 生成略缩图保存到字符数组中* @param srcfile* @return*/public static byte[] buildthumbnail(File srcFile){byte[] rtn=null;//创建对象Logger log= Logger.getLogger(PhotoAction.class);try{//构造Image对象Image src=ImageIO.read(srcFile);//得到原图宽int oldWidth = src.getWidth(null);//得到原图高int oldHeight= src.getHeight(null);log.debug("old width is"+oldWidth);log.debug("old height is"+oldHeight);float divWidth=200f;//略缩图宽int newWidth=200;//略缩图高int newHeight=0;float tmp;if(oldWidth>newWidth){tmp=oldWidth/divWidth;//计算略宿图宽高newWidth=Math.round(oldWidth / tmp);newHeight=Math.round(oldHeight / tmp);log.debug("tmp scale is"+ tmp);}else{newWidth=oldWidth;newHeight=oldHeight;}int imageHeight=100;int imageWidth=200;log.debug("new width is" + newWidth);log.debug("new height is" + newHeight);BufferedImage bufferedImage=newBufferedImage(imageWidth,imageHeight,BufferedImage.TYPE_INT_BGR);Graphics2D graphics2D = (Graphics2D)bufferedImage.createGraphics();graphics2D.setBackground(Color.WHITE);graphics2D.clearRect(0, 0, imageWidth, imageHeight);//绘制缩小后的图bufferedImage.getGraphics().drawImage(src, 0, 0, newWidth, newHeight, null);ByteArrayOutputStream baos=new ByteArrayOutputStream();BufferedOutputStream bos=new BufferedOutputStream(baos);JPEGImageEncoder encoder = JPEGCodec.createJPEGEncoder(bos);encoder.encode(bufferedImage);rtn=baos.toByteArray();bos.close();baos.close();}catch(Exception ex){log.debug(ex);}finally{}return rtn;}日期格式化：return rtn;<fmt:formatDate value=”${re.dsfsdf}” pattern=”yyyy-MM-dd”/>。
Hibernate学习笔记
2、数据库设计：同上
3、annatation:@OneToMany 默认情况下当多对多处理、会创建一个临时表
4、解决方法： @OneToMany
@JoinColumn(name="groupID")
5、XML：<set name="setname">
public Set<Student> getStudent(){
return student;
}
<key-property name="id"></key-property>
<key-property name="name"></key-property>
</composite-id>
<property name="age"></property>
-------------6----------------
一对一：oneToOne
@JoinColumn(name="wifeID") 使用外键列进行实体的关联.
Annatation配置一对一的双向外键关联:
@OneToOne(mappedBy = "wifeID")
示例：在wife类中的getHusband()方法上注解
只要有双向关联mappedBy必设置 定义一边即可
分布式事务：同时对两个数据库进行操作、但此操作又属于同一事务.需要web服务器支持（Tomcat不能实现）
------对象的三种状态--------
Hibernate笔记
hibernate缓存一、hibernate一级缓存（1）hibernate支持两个级别的缓存，默认只支持一级缓存；（2）每个Session内部自带一个一级缓存；（3）某个Session被关闭时，其对应的一级缓存自动清除；（4）save、update、saveOrupdate、load、get、list、iterate、lock方法都会向缓存中存对象.（5）可以从缓存中读数据的只有： get、load、iterate（6）Query对象默认情况下不读缓存，如果要使其支持缓存，则要通过语法：query.setCacheable(true)；<property name="e_query_cache">true</property>（7）打开query缓存后，只有查询条件与以前的查询完全相同时，才会在缓存中匹配成功.（8）Criteria对缓存支持不足；（9）一级缓存不能控制缓存中的对象数量，要注意大批量操作数据时可能造成的内存溢出，可以利用清除缓存.session.clear() 清除缓存中所有对象session.evict(user) 清除指定对象二、hibernate二级缓存* save、update、saveOrupdate、load、get、list、query、Criteria方法都会填充二级缓存* get、load、iterate会从二级缓存中取数据* session.save(user) 如果user主键使用“native”生成，则不放入二级缓存.(1)开启二级缓存<property name="e_second_level_cache">true</property>(2)为hibernate指定二级缓存的实现类<property name="cache.provider_class">org.hibernate.cache.OSCacheProvider</property>(3)为OSCache缓存创建配置文件(需要hibernate_Advance_Surpport_lib)src/oscache.properties修改配置中的:cache.capacity=1000 指定缓存可以容纳多少对象(4)指明哪些类需要放入二级缓存，需要长期使用到的对象才有必要放入二级缓存<class-cache class="entity.PetInfo" usage="read-only" /> //不允许更新缓存中的对象<class-cache class="entity.PetInfo" usage="read-write" /> //允许更新缓存中的对象或在orm文件中：<class name="entity.PetInfo" table="PetInfo" schema="dbo" catalog="epet"><cache usage="read-only"/>...</class>(5)如果需要清除二级缓存，使用下面语法sessionFactory.evict(User.class) 清除所有usersessionFactory.evict(User.class,Id) 清除指定userJPA注解1、@Entity(name="EntityName")必须,name为可选,对应数据库中一的个表2、@Table(name="",catalog="",schema="")可选,通常和@Entity配合使用,只能标注在实体的class定义处,表示实体对应的数据库表的信息name:可选,表示表的名称.默认地,表名和实体名称一致,只有在不一致的情况下才需要指定表名catalog:可选,表示Catalog名称,默认为Catalog("").schema:可选,表示Schema名称,默认为Schema("").3、@id必须@id定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.置于getXxxx()前.4、@GeneratedValue(strategy=GenerationType,generator="")可选strategy:表示主键生成策略,有AUTO,INDENTITY,SEQUENCE 和TABLE 4种,分别表示让ORM框架自动选择,根据数据库的Identity字段生成,根据数据库表的Sequence字段生成,以有根据一个额外的表生成主键,默认为AUTOgenerator:表示主键生成器的名称,这个属性通常和ORM框架相关,例如,Hibernate可以指定uuid等主键生成方式.示例:@Id@GeneratedValues(strategy=StrategyType.SEQUENCE)public int getPk() {return pk;}5、@Basic(fetch=FetchType,optional=true)可选@Basic表示一个简单的属性到数据库表的字段的映射,对于没有任何标注的getXxxx()方法,默认即为@Basicfetch: 表示该属性的读取策略,有EAGER和LAZY两种,分别表示主支抓取和延迟加载,默认为EAGER.optional:表示该属性是否允许为null,默认为true示例:@Basic(optional=false)public String getAddress() {return address;}6、@Column可选@Column描述了数据库表中该字段的详细定义,这对于根据JPA注解生成数据库表结构的工具非常有作用.name:表示数据库表中该字段的名称,默认情形属性名称一致nullable:表示该字段是否允许为null,默认为trueunique:表示该字段是否是唯一标识,默认为falselength:表示该字段的大小,仅对String类型的字段有效insertable:表示在ORM框架执行插入操作时,该字段是否应出现INSETRT语句中,默认为true updateable:表示在ORM框架执行更新操作时,该字段是否应该出现在UPDATE语句中,默认为true.对于一经创建就不可以更改的字段,该属性非常有用,如对于birthday字段.columnDefinition:表示该字段在数据库中的实际类型.通常ORM框架可以根据属性类型自动判断数据库中字段的类型,但是对于Date类型仍无法确定数据库中字段类型究竟是DATE,TIME还是TIMESTAMP.此外,String的默认映射类型为VARCHAR,如果要将String类型映射到特定数据库的BLOB或TEXT字段类型,该属性非常有用.示例:@Column(name="BIRTH",nullable="false",columnDefinition="DATE")public String getBithday() {return birthday;}7、@Transient可选@Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性.如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic示例://根据birth计算出age属性@Transientpublic int getAge() {return getYear(new Date()) - getYear(birth);}8、@ManyToOne(fetch=FetchType,cascade=CascadeType)可选@ManyToOne表示一个多对一的映射,该注解标注的属性通常是数据库表的外键optional:是否允许该字段为null,该属性应该根据数据库表的外键约束来确定,默认为truefetch:表示抓取策略,默认为FetchType.EAGERcascade:表示默认的级联操作策略,可以指定为ALL,PERSIST,MERGE,REFRESH和REMOVE中的若干组合,默认为无级联操作targetEntity:表示该属性关联的实体类型.该属性通常不必指定,ORM框架根据属性类型自动判断targetEntity.示例://订单Order和用户User是一个ManyToOne的关系//在Order类中定义@ManyToOne()@JoinColumn(name="USER")public User getUser() {return user;}9、@JoinColumn可选@JoinColumn和@Column类似,介量描述的不是一个简单字段,而一一个关联字段,例如.描述一个@ManyToOne的字段.name:该字段的名称.由于@JoinColumn描述的是一个关联字段,如ManyToOne,则默认的名称由其关联的实体决定.例如,实体Order有一个user属性来关联实体User,则Order的user属性为一个外键,其默认的名称为实体User的名称+下划线+实体User的主键名称示例:见@ManyToOne10、@OneToMany(fetch=FetchType,cascade=CascadeType)可选@OneToMany描述一个一对多的关联,该属性应该为集体类型,在数据库中并没有实际字段.fetch:表示抓取策略,默认为ZY,因为关联的多个对象通常不必从数据库预先读取到内存cascade:表示级联操作策略,对于OneToMany类型的关联非常重要,通常该实体更新或删除时,其关联的实体也应当被更新或删除例如:实体User和Order是OneToMany的关系,则实体User被删除时,其关联的实体Order也应该被全部删除示例:@OneTyMany(cascade=ALL)public List getOrders() {return orders;}11、@OneToOne(fetch=FetchType,cascade=CascadeType)@OneToOne描述一个一对一的关联fetch:表示抓取策略,默认为ZYcascade:表示级联操作策略示例:@OneToOne(fetch=ZY)public Blog getBlog() {return blog;}12、@ManyToMany可选@ManyToMany 描述一个多对多的关联.多对多关联上是两个一对多关联,但是在ManyToMany描述中,中间表是由ORM框架自动处理targetEntity:表示多对多关联的另一个实体类的全名,例如:package.Book.classmappedBy:表示多对多关联的另一个实体类的对应集合属性名称示例:User实体表示用户,Book实体表示书籍,为了描述用户收藏的书籍,可以在User和Book之间建立ManyToMany关联@Entitypublic class User {private List books;@ManyToMany(targetEntity=package.Book.class)public List getBooks() {return books;}public void setBooks(List books) {this.books=books;}}@Entitypublic class Book {private List users;@ManyToMany(targetEntity=ers.class, mappedBy="books")public List getUsers() {return users;}public void setUsers(List users) {ers=users;}}两个实体间相互关联的属性必须标记为@ManyToMany,并相互指定targetEntity属性,需要注意的是,有且只有一个实体的@ManyToMany注解需要指定mappedBy属性,指向targetEntity的集合属性名称利用ORM工具自动生成的表除了User和Book表外,还自动生成了一个User_Book表,用于实现多对多关联13、@MappedSuperclass可选@MappedSuperclass可以将超类的JPA注解传递给子类,使子类能够继承超类的JPA注解示例:@MappedSuperclasspublic class Employee() {....}@Entitypublic class Engineer extends Employee {.....}@Entitypublic class Manager extends Employee {.....}14、@Embedded可选@Embedded将几个字段组合成一个类,并作为整个Entity的一个属性.例如User包括id,name,city,street,zip属性.我们希望city,street,zip属性映射为Address对象.这样,User对象将具有id,name和address这三个属性.Address对象必须定义为@Embededable示例:@Embeddablepublic class Address {city,street,zip}@Entitypublic class User {@Embeddedpublic Address getAddress() {..........}}Hibernate验证注解注解适用类型说明示例@Pattern String 通过正则表达式来验证字符串@attern(regex=”[a-z]{6}”) @Length String 验证字符串的长度@length(min=3,max=20) @Email String 验证一个Email地址是否有效@email@Range Long 验证一个整型是否在有效的范围内@Range(min=0,max=100) @Min Long 验证一个整型必须不小于指定值@Min(value=10)@Max Long 验证一个整型必须不大于指定值@Max(value=20)@Size 集合或数组集合或数组的大小是否在指定范围内@Size(min=1,max=255)以上每个注解都可能性有一个message属性，用于在验证失败后向用户返回的消息，还可以三个属性上使用多个注解关系对象映射介绍,jpaTableTable用来定义entity主表的name，catalog，schema等属性。