Hibernate4添加:
a. Serializable id = session.save();
User user = new User(); // 瞬态
user.setXxx();
session.save(user); // user --> 持久化状态
b. void session.persist();
User user = new User(); // 瞬态
user.setXxx();
session.persist(user); // user --> 持久化状态
c. session.saveOrUpdate(); // 添加与修改
User user = new User(); // 瞬态
user.setXxx(); // 不要设置主键列对应的属性.
void = session.saveOrUpdate(user); // user --> 持久化状态
d. session.merge(); // 混合集成了添加与修改.
User user = new User(); // 瞬态
user.setXxx(); // 不要设置主键列对应的属性.
User u = session.merge(user); // user --> 瞬态，u --> 持久化状态
注意:
save()与persist()区别
1.save方法有返回值,它返回的是主键id。
persist没有返回值,需要通过对象的getId来获取
2.save方法会立即往数据库表中插入数据
persist方法会延迟往数据库表中插入数据(跟事务是否开启有关)
在事务开启之后执行这两个方法做添加都会立即生成sql语句
Hibernate4根据主键查询:
session.get(): 根据主键id查询
User user = (User)session.get(User.class, 1); // user : 持久化状态
立即从数据库表查询数据，返回对象.
session.load(): 根据主键id查询
User user = (User)session.load(User.class, 1); // user : 持久化状态
延迟从数据库表查询数据，一开始返回代理对象，当你真正要用到它的属性时，
才会生成查询语句到数据库表中查询数据。
当你要用到它的时候，要保证Session不能关闭。
Hibernate4修改:
持久化状态下：
User user = (User)session.get(User.class, 1); // user : 持久化状态
user.setXxx();
脱管状态下：
User u = new User(); // 瞬态
u.setId(1); // 脱管
session.update(u); // u --> 持久化状态
session.saveOrUpdate(u); // u --> 持久化状态
User user = session.merge(u); // u --> 脱管 user --> 持久化状态
Hibernate4删除:
持久化状态下：
User user = (User)session.get(User.class, 1); // user : 持久化状态
session.delete(user); // user --> 瞬态
脱管状态下：
User u = new User(); // u -> 瞬态
u.setId(3); // u -> 脱管
session.delete(u); // 瞬态
第一类
类名上
@Entity
将POJO转化成持久化类。
@Table
把持久化类转化成表的相关信息
name：指定表名
schema ：指定将数据表存入哪个数据库,schema或者catalog只能指定一个.
catalog：指定将数据表存入哪个数据库,schema或者catalog只能指定一个.
indexes: 用于指定表的引索列
@Index(columnList="数据表中的列名", name="索引名")
indexes={@Index(), @Index()}
uniqueConstraints：用于指定唯一约束
@uniqueConstraint(columnNames={"列名","列名"}, name="唯一约束名")
@DynamicInsert
动态插入，根据持久化对象的属性是否有值明确生成insert语句。
@DynamicUpdate
动态修改，它会判断持久化对象中属性，哪些属性值发生了改变就会生成update的语句。(持久化状态下做修改)
@SelectBeforeUpdate
修改之前先查询，查询得到持久化对象再与脱管状态下的对象进行比较,哪些属性值发生了改变就会生成update的语句。(脱管状态下做修改)
第二类
主键上
@Id
主键列
@GeneratedValue(strategy=GenerationType.AUTO)
指定了主键自增长策略
GenerationType.IDENTITY: 适宜MySQL、SqlServer有自增长列的数据库。
GenerationType.SEQUENCE：适宜Oracle这种没有自增长有sequence的数据库。
GenerationType.AUTO：让Hibernate根据数据库方言自动选择主键生成策略。
GenerationType.TABLE: 适宜所有的数据库,因为它会单独生成一张表来维护主键生成。
@Embedded
复合主键
@AttributeOverrides
指定复合主键中的列表
@AttributeOverrides({@AttributeOverride(name="firstName", column=@Column(name="F_NAME")),@AttributeOverride(name="lastName", column=@Column(name="L_NAME"))})
第三类
普通属性上
@Column
持久化类中属性转化成数据库表中列的相关信息
name：指定列名。
length: 该列支持的长度。
precision：有效的总位数。(BigDecimal类型才有效)
scale：小数点的位数。(BigDecimal类型才有效)
unique： 唯一约束。
nullable：非空约束。
insertable：是否允许插入true：允许 false: 不允许。
updatable：是否允许修改true：允许 false: 不允许。
columnDefinition ：指定列的定义。columnDefinition="int(11) not null default 20"
@Lob
映射大的二进制数或者文本
@Temporal
修饰日期类型Date
TemporalType.DATE : yyyy-MM-dd
TemporalType.TIME : HH:mm:ss
TemporalType.TIMESTAMP : yyyy-MM-dd HH:mm:ss
@Transient
指定不是持久化属性
transient关键字修饰不需要序列化的属性,同时用它也能指定不是持久化的属性。
第四类
集合属性上(List/Set/Map/Array)
当持久化中有一个属性是集合(Set、List、Map).
集合属性会单独生成一张表
定义集合属性时面向接口，并且集合属性需要程序员自己初始化
private List list = new ArrayList();
@ElementCollection
指定加载策略/指定集合中的元素类型
@ElementCollection(fetch=FetchType.LAZY,targetClass=String.class)
fetch=FetchType.EAGER: 立即加载 / fetch=FetchType.LAZY: 延迟加载
targetClass 集合中元素的类型
@CollectionTable
指定集合的表名
@CollectionTable(name="info")
List集合(有序集合)
@OrderColumn
指定排序列
@OrderColumn(name="o_id")
@Embeddable
说明此类是集合中的元素
Set集合(无序集合)
@Embeddable
注意:
Set集合生成表默认是没有主键列的。如果想要生成主键列，需要为Set集合的元素类的属性上添加非空约束！
@Column(nullable:false)
Set集合生成表的主键列：【外键列 + Set集合的元素列】
Map集合(有Map的key)
@MapKeyColumn
@Embeddable
注意
Map集合生成表的主键列：【外键列 + Map的Key】
第五类
关联映射
单向关联
一对一
//学生表中增加一个关联id
@OneToOne(fetch=FetchType.LAZY,targetEntity=Teacher.class)
@JoinColumn(name="t_id",referencedColumnName="id")
private Teacher teacher;
一对多
//学生表中增加一个关联id
@OneToMany(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teacher")//延迟加载,指定关联的持久化类,指定哪些维护关联关系
@JoinColumn(name="t_id",referencedColumnName="id")
private Set students = new HashSet();
多对一
//学生表中增加一个关联id
@ManyToOne(fetch=FetchType.LAZY,targetEntity=Teacher.class)
@JoinColumn(name="t_id",referencedColumnName="id")
private Set students = new HashSet();
多对多
@ManyToMany(fetch=FetchType.LAZY,targetEntity=Teacher.class)
@JoinTable(name="t_tea_stu",joinColumns=@JoinColumn(name="s_id",referencedColumnName="id"),inverseJoinColumns=@JoinColumn(name="t_id",referencedColumnName="id"))
private Set teachers = new HashSet();
双向关联
一对一
注解:@OneToOne
@OneToOne(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teacher")
private Student student;
@OneToOne(fetch=FetchType.LAZY,targetEntity=Teacher.class)
@JoinColumn(name="t_id",referencedColumnName="id",unique=true)
private Teacher teacher;
一对多
一端(主表):@OneToMany
@OneToMany(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teacher")//延迟加载,指定关联的持久化类,指定哪些维护关联关系
private Set students = new HashSet();
多端(从表):@ManyToOne
生成外键列
@ManyToOne(fetch=FetchType.LAZY,targetEntity=Teacher.class)//延迟加载,指定关联的持久化类
@JoinColumn(name="t_id",referencedColumnName="id",foreignKey=@ForeignKey(name="fk_tea_stu"))//生成外键列t_id,关联Teacher类中的id
private Teacher teacher;
保存主表,再保存从表
级联级别
@OneToMany(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teacher",cascade=CascadeType.REMOVE,orphanRemoval=true)
CascadeType.REMOVE 级联删除
orphanRemoval=true 删除孤儿记录
在不删除老师的基础上,把学生删除
以后千万不要配置@ManyToOne(fetch=FetchType.LAZY,targetEntity=Teacher.class,cascade=CascadeType.REMOVE)
CascadeType.REMOVE 级联删除,以后千万不要配置
多对多
注解
@ManyToMany
生成中间表来维护关联关系
用Set集合定义关联属性, set集合中的元素是关联的持久化类
@ManyToMany(fetch=FetchType.LAZY,targetEntity=Student.class,mappedBy="teachers")
private Set students = new HashSet();
@ManyToMany(fetch=FetchType.LAZY,targetEntity=Teacher.class)
@JoinTable(name="t_tea_stu",joinColumns=@JoinColumn(name="s_id",referencedColumnName="id"),inverseJoinColumns=@JoinColumn(name="t_id",referencedColumnName="id"))
private Set teachers = new HashSet();
第六类
继承映射
第一种方式(SINGLE_TABLE)：所有子类中属性都生成到父类表中(一张表)
@Entity @Table(name="parent")
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="DC", discriminatorType=DiscriminatorType.INTEGER)// 辨别者列
@DiscriminatorValue("1") // 辨别者列值
public class Person{}
//子类
@Entity
@DiscriminatorValue("2") // 辨别者列值
public class Teacher{}
注意:
所有子类属性中不能加非空约束
第二种方式(JOINED)：所有的子类与父类都会单独生成表(子类表的中主键列同时也是外键列,它引用顶级父类表中的主键列).
@Entity @Table(name="parent")
@Inheritance(strategy=InheritanceType.JOINED)
public class Person{}
//子类
@Entity @Table(name="teacher")
public class Teacher{}
注意:查询时会出现很多join语句
第三种方式(TABLE_PER_CLASS)：所有的子类与父类都会单独生成表，子类会把父类中的属性继承过来生成在自己的表中。
@Entity @Table(name="parent")
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
public class Person{}
//子类
@Entity @Table(name="teacher")
public class Teacher{}
注意:
这种策略主键不能用自增长
查询时会出现union运算
映射文件说明
hibernate-mapping 根元素
package
指定包名,如果没有指定，本文件出现的所有实体类必须带上完整包名.如果指定，就可以不带完整包名。
auto-import
默认为true 自动导入，在进行hql查询的时候不用写包名！
如果设置为false，在hql查询的时候需要指定包名，如：session.createQuery("from cn.itcast.entity.User");
schema
库名
class 类映射一个表
name 类名，是否指定完整路径看package
table 表名
id 主键映射
name 属性名
column 表字段名，不写也可以
generator 主键策略
native 自增长(根据底层数据库的能力选择 identity、sequence )
identity MySql中自增长的方式
sequence Oracle中以序列的方式实现自增长!
increment 也是自增长但不能处理并发问题!
assigned 手动指定主键的值
uuid uuid值作为主键
foreign 外键策略(一对一映射时候用到)
property 其它字段映射
name 属性名
column 表字段名，不写也可以。如果字段是数据的关键字使用反引号 `desc`
length 指定字符类型的长度，默认255
type 指定字段类型
hibernate支持的类型默认都是小写
string/java.lang.String
date/timestamp/ 如果属性是java.util.Date类型,字段映射没有指定类型,默认是datetime类型
unique
唯一约束
not-null
不能为空约束
代码方式建表
加载hibernate.cfg.xml
Configuration cfg = new Configuration().configure();
工具类
SchemaExport export = new SchemaExport(cfg);
建表-参数1：是否打印生成的sql到控制台-参数2：是否执行生成的sql
export.create(true, true);
查询方式
get主键查询
User user = (User) session.get(User.class, 1);
立即从数据库表中查询数据
load对象导航查询(懒加载查询)
user = (User) session.load(User.class, 1);
延迟从数据库表查询数据,一开始返回一个代理对象,当真正用到属性的时候,再到数据库表中查询
注意:用它时保证session不要被关闭
Hql查询
Hibernate Query Language
Hibernate查询语句
步骤:
获得Session
写hql语句
查询数据库获得Query对象
如果有占位符,就需要对占位符赋值 query.setParameter();
如果需要分页limit赋值 query.setFirstResult(start); query.setMaxResults(size);
获取查询查询结果
如果本次查询有多条记录返回：query.list();
如果本次查询只有一条记录返回：query.uniqueResult();
from字句
List students = session.createQuery("from Student").list();
List students = session.createQuery("from Student as stu").list();
List students = session.createQuery("from Student stu").list();
User user =(User) session.createQuery("from User where id=1").uniqueResult();
select字句
List students = session.createQuery("select s from Student as s").list();
List names = session.createQuery("select s.name from Student s").list();
List lists = session.createQuery("select s.name,s.age from Student s").list();
List lists = session.createQuery("select name,age from Student").list();
分页
Query query = session.createQuery("select s from Student s");
query.setFirstResult(0);
query.setMaxResults(5);
List students = query.list();
select new 字句
可以改变List集合中存放什么
List> list = session.createQuery("select new map(s.name,s.age) from Student s").list();
List> list = session.createQuery("select new list(s.name,s.age) from Student s").list();
List list = session.createQuery("select new com.shuai.domain.User(name,age) from Student").list();
关联(持久化类)与连接(数据库表)
隐式关联(不需要写join语句)
查询时,关联的属性是一个持久化类。
List students = session.createQuery("select s from Student s where s.teacher.id=?").setParameter(0,1).list();
显示关联(需要写join语句)
查询时,关联属性是一个Set集合
Teacher t = (Teacher)session.createQuery("select t from Teacher t inner join t.students where t.students.id=?").setParameter(1,1).uniqueResult();
抓取连接(查询延迟的属性)
查询时,关联属性配置了延迟加载的,但本次查询要查询出来 join fetch关联的属性
List students = session.createQuery("select s from Student s join fetch s.teacher").list();
排序 order by
List students = session.createQuery("select s from Student s order by s.age asc").list();
分组 group by
List list = session.createQuery("select count(s),s.teacher.name from Student s group by s.teacher.name").list();
分组过滤 having
List list = session.createQuery("select count(s),avg(s.score),sum(s.score),s.teacher.name from Student s group by s.teacher.name having s.teacher.id=?").setParameter(0,1).list();
聚合函数 count/sum/max/min/avg
count
Long count = (Long)session.createQuery("select count(*) from Student").uniqueResult();
sum
Double sum = (Double)session.createQuery("select sum(score) from Student").uniqueResult();
max
Float max = (Float)session.createQuery("select max(score) from Student").uniqueResult();
min
Float min = (Float)session.createQuery("select min(score) from Student").uniqueResult();
avg
Float avg = (Float)session.createQuery("select avg(score) from Student").uniqueResult();
where字句部分(查询过滤部分)
Hibernate的where子句部分能支持的运算符，表达式、函数特别多，用法与sql语句是一样的
常用的表达式、运算符、函数
=、<、<=、>、>=、!=、and、or、distinct、between...and 、like、concat()、is null, is not null, is empty, is not empty、second(...),minute(...), hour(...), day(...), month(...)
支持EJB-QL 3.0的函数
trim(), lower(), upper(), length(), abs(), sqrt(), bit_length(), mod()
支持操作集合属性的函数
size()|size, minelement(), maxelement(), minindex(), maxindex()
使用
List students = session.createQuery("select s from Student s where s.name like ?8").setParameter("9","%小%").list();
List students = session.createQuery("select s from Student s where s.name like concat('%',?2,"%")").setParameter("2","小").list();
List students = session.createQuery("select s from Student s where s.name is not null").list();
List students = session.createQuery("select s from Student s where trim(s.name) like ?").setParameter(0,"%帅%").list();
List students = session.createQuery("select s from Student s where length(s.name) = ?").setParameter(0,"%帅%").list();
List students = session.createQuery("select s from Student s where sqrt(s.id)=?").setParameter(0,1.0d).list();
List students = session.createQuery("select s from Student s where bit_length(s.name)=?").setParameter(0,32L).list();
List students = session.createQuery("select s from Student s where mod(s.id,?)=?").setParameter(0,2).setParameter(1,0).list();
List orders = session.createQuery("select o from Order o where size(o.orderItems) =?").setParameter(0,3).list();
List orders = session.createQuery("select o from Order o where minelement(o.orderItems) =?").setParameter(0,100).list();
List orders = session.createQuery("select o from Order o where maxelement(o.orderItems) =?").setParameter(0,100).list();
List orders = session.createQuery("select o from Order o where maxindex(o.orderItems) =?").setParameter(0,1).list();
List orders = session.createQuery("select o from Order o where minindex(o.orderItems) =?").setParameter(0,1).list();
子查询
hibernate的子查询与SQL语句的中子查询一样，子查询部分放在in、not in里面
使用
List students = session.createQuery("select s from Student as s where s.id in(select t.id from Teacher t)").list();
多态查询
当你的持久化类存在继承关系时，你查询父类时，它会把父类所有的对象查询出来，而且也会把所有子类对象查询出来。
使用
List
hibernate批处理
概述
如果有10w条数据需要一次性插入到数据库表.这个时候用Hibernate做添加的话有可能会出现内存溢出
批量添加
for(int i = 0; i < 100000; i++){
Teacher t = new Teacher();
session.save(t);
// t : 持久化状态，持久化状态的对象是放在Session的一级缓存中,因为一级缓存是放在内存中.(10w对象存放在内存中)
// 当一级缓存中的对象达到一定数量，那就把一级缓存中的对象同步到底层的数据库，再清空一级缓存，释放内存
if (i % 10 == 0){
// 把一级缓存中的对象同步到底层的数据库
session.flush();
// 清空一级缓存，释放内存
session.clear();
}
}
session.commit();
批量修改
for (int i = 1; i <= 100000; i++){
// t : 持久化状态，持久化状态的对象是放在Session的一级缓存中,因为一级缓存是放在内存中.(10w对象存放在内存中)
Teacher t = (Teacher)session.get(Teacher.class, i);
t.setAge(28);
// 当一级缓存中的对象达到一定数量，那就把一级缓存中的对象同步到底层的数据库，再清空一级缓存，释放内存
if (i % 10 == 0){
// 把一级缓存中的对象同步到底层的数据库
session.flush();
// 清空一级缓存，释放内存
session.clear();
}
}
session.commit();
批量删除
for (int i = 1; i <= 100000; i++){
// t : 持久化状态，持久化状态的对象是放在Session的一级缓存中,因为一级缓存是放在内存中.(10w对象存放在内存中)
Teacher t = (Teacher)session.get(Teacher.class, i);
session.delete(t);
// 当一级缓存中的对象达到一定数量，那就把一级缓存中的对象同步到底层的数据库，再清空一级缓存，释放内存
if (i % 10 == 0){
// 把一级缓存中的对象同步到底层的数据库
session.flush();
// 清空一级缓存，释放内存
session.clear();
}
}
session.commit();
DML风格的HQL语句
概述
DML : Data Manipulation Language (DML) the statements: INSERT, UPDATE, DELETE
语法 ：( UPDATE | DELETE ) FROM? EntityName (WHERE where_conditions)?.
操作DML风格HQL的步骤
获取Session
写DML风格的hql语句
Query query = session.createQuery(hql);
如果hql语句中有占位符需要设置参数值: query.setParameter(i, "值").
int res = query.executeUpdate();
使用
全部修改
String sql = "update from Teacher set age = ?";
int res = session.createQuery(sql).setParameter(0,20).executeUpdate();
条件修改
String sql = "update from Teacher set age = ? where id < ?";
int res = session.createQuery(sql).setParameter(0,20).setParameter(1,100).executeUpdate();
条件删除
String sql = "delete from Teacher t where t.age = ?";
int res = session.createQuery(sql).setParameter(0,40).executeUpdate();
hibernate数据过滤
概述
当你做查询时，有一个查询条件永远是固定的
使用数据过滤的步骤
1.定义数据过滤
@FilterDef()
2.指定哪些持久类使用该数据过滤
@Filter()
3.开启该数据过滤
session.enableFilter("数据过滤的名称").setParameter("定义的过滤字段名称",过滤字段的值);
使用
1.
@FilterDef(name="ageFilter", parameters={@ParamDef(name="minAge", type="int")})
public class Teacher{}
2.
@Filter(name="ageFilter", condition="age > :minAge")
public class Student{}
3.
session.enableFilter("ageFilter").setParameter("minAge", 20);
List students = session.createQuery("select t from Student t").list();
刚在一台IBM Xserver服务器上装了RedHat Linux Enterprise AS 4，为了提高网络的可靠性配置双网卡绑定。
一、环境描述
我的RedHat Linux Enterprise AS 4安装双口的Intel千兆网卡，通过ifconfig -a命令看到eth0和eth1两张网卡。
二、双网卡绑定步骤：
2.1 修改/etc/sysconfig/network
1.AdviceMethods.java
package com.bijian.study.spring.aop.schema;
public class AdviceMethods {
public void preGreeting() {
System.out.println("--how are you!--");
}
}
2.beans.x
包括Spark Streaming在内的实时计算数据可靠性指的是三种级别：
1. At most once，数据最多只能接受一次，有可能接收不到
2. At least once, 数据至少接受一次，有可能重复接收
3. Exactly once 数据保证被处理并且只被处理一次，
具体的多读几遍http://spark.apache.org/docs/lates
具体思路参见：http://zhedahht.blog.163.com/blog/static/25411174200712895228171/
import java.util.ArrayList;
import java.util.List;
public class MinStack {
//maybe we can use origin array rathe
日期转换函数的详细使用说明
DATE_FORMAT(date,format) Formats the date value according to the format string. The following specifiers may be used in the format string. The&n
