1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

<?xml version="1.0" encoding="UTF-8"?>
<beans
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:p="http://www.springframework.org/schema/p"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"

	xsi:schemaLocation="
	http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
	http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
">
<!--mysql数据库的配置
 	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	 <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
	</bean>
-->  
  
<!--Oracle数据库的配置 -->	
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
		<property name="url"
			value="jdbc:oracle:thin:@localhost:1521:orcl">
		</property>
		<property name="username" value="scott"></property>
		<property name="password" value="tiger"></property>
	</bean>
	
<bean id="sessionFactory"
		class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
		<property name="dataSource"><ref bean="dataSource" /></property>
		<property name="hibernateProperties">
			<props>
<!--MySql数据库方言	org.hibernate.dialect.MySQLDialect	-->
				<prop key="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop>
				<prop key="hibernate.show_sql">true</prop> <!--控制台打印sql-->
				<prop key="hibernate.format_sql">true</prop>   <!--打印sql格式转换-->
			</props>
		</property>
	<property name="packagesToScan">   <!--扫描关系映射-->
	<list><value>com.lx.vo</value></list>
	</property>
</bean>
	
<!-- 	启用注解扫描 -->
<context:component-scan base-package="com.lx.controller"  />
<context:component-scan base-package="com.lx.impl"  />
<!-- 1创建事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
	<property name="sessionFactory" ref="sessionFactory"></property>
</bean>

<!-- 开启事务注解驱动 -->
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>

</beans>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

@Entity //表示为实体类 导入都是此包下的import javax.persistence.*
@Table(name="users") //设置数据库中的表名
public class Users {
//这里使用的数据库是Oracle使用了序列，所以要声明一个序列SequenceGenerator,再设置一个别名，可以引用它
  //allocationSize表示每次增长的长度。
@SequenceGenerator(name="seq_users",sequenceName="seq_users" ,allocationSize=1)
@Id //id表示是数据库的主键       strategy表示引用的@SequenceGenerator的名称
@GeneratedValue(strategy = GenerationType.SEQUENCE,generator = "seq_users")
private Integer	users_id  ;
//用来限制列名，列唯一，列为null  
@Column(name = "id", unique = true, nullable = false)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

package com.lx.impl;
import org.hibernate.SessionFactory;
import org.hibernate.query.Query;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;
@Transactional  //因为有事务，所以可以不再开启事务。
@Repository
public class BaseDaoImpl  {
    @Autowired
    private SessionFactory sessionFactory;
  //获得currentSession
      public Session getCurrentSession() {
        return sessionFactory.getCurrentSession();
    }
    //删除
    public void delete(Object obj) {
        sessionFactory.getCurrentSession().delete(obj);
    }
    //添加
    public void save(Object obj) {
        sessionFactory.getCurrentSession().save(obj);
    }
    //通过hql查询
    public List selectManyByHql(String hql) {
        return     sessionFactory.getCurrentSession().createQuery(hql).list();
    }
    //修改
    public void update(Object obj) {
        sessionFactory.getCurrentSession().update(obj);
    }

    //通过Id查找一条
    public Object selectOneById(Class cls, Integer id) {
        return     sessionFactory.getCurrentSession().get(cls, id);
    }

    //通过hql查询一条
    public Object selectOneByHql(String hql) {
        return     sessionFactory.getCurrentSession().createQuery(hql).uniqueResult();
    }

    //实现分页
    public List selectByPage( String hql, Integer current, Integer pageSize){
        Query query=sessionFactory.getCurrentSession().createQuery(hql);
        query.setFirstResult(current);
        query.setMaxResults(pageSize);
        return query.getResultList();
    }
    //统计所有数据条数
    public Integer selectTotalCount( String hql){
        Query query=sessionFactory.getCurrentSession().createQuery(hql);
        Long count=(Long) query.uniqueResult();
        return count.intValue();
    }

    public SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

1
2
3
4

//一个短消息，对应一个发送人
@OneToOne(fetch=FetchType.LAZY,optional=false)
@JoinColumn(name="creator",insertable = false,updatable = false) 
private ZzEmployee employee;

1
2
3

@OneToMany(cascade=CascadeType.ALL,fetch=FetchType.LAZY)
@JoinColumn(name="xiaoxiid")
private List<XxXiaoxijieshou> receive=new ArrayList<XxXiaoxijieshou>();

1
2
3

@ManyToOne(targetEntity=XxDuanxiaoxi.class,fetch=FetchType.LAZY)
@JoinColumn(name="xiaoxiid",insertable=false,updatable=false)
private XxDuanxiaoxi shortInfo;

1
2
3
4
5
6
7
8
9

//角色 员工多对多
//连接第三张表为qx_role_user，没有主键，
//@JoinColumn第三表中，本bean存储的字段为
//inverseJoinColumns第三表中，连接员工bean存储的字段为
	@ManyToMany()
	@JoinTable(name="qx_role_user",
	joinColumns= {@JoinColumn(name="roleid")},
	inverseJoinColumns= {@JoinColumn(name="eid")})
	private Set<ZzEmployee> emps=new HashSet<ZzEmployee>();

1
2
3
4
5
6
7

//自关联 一对多，一个父亲功能下，有多个子功能 
//parentoid为自身bean的Id
	@OneToMany(fetch=FetchType.LAZY,
			cascade=CascadeType.ALL,
			orphanRemoval=true)
	@JoinColumn(name="parentoid",insertable=false,updatable=true)
	private List<QxFunction> children=new ArrayList<QxFunction>();

1
2
3

	Object obj=query.uniqueResult();//不存在 会返回为null
	List obj=query.list();//list 即使size=0也不会返回为null
//在含有一对多集合的关系中，即使抓取的集合为0，集合也不是==null

1
2
3
4
5
6
7
8
9

Query query=session.createQuery("select avg(did) from testdeptBean");
Object obj=query.uniqueResult(); //可以直接获得结果不需要遍历
COUNT 返回Long对象 
MAX MIN 返回类型是跟所使用的字段类型有关 
AVG 返回Double  
SUM 如使用字段是整形，返回Long,若字浮点,返回浮点
//是Long时 可以这样处理。
Long obj=(Long)obj1;
Integer in=obj.intValue();

1
2
3
4

//设置开始位置 从0开始  显示两条数据
query.setFirstResult(2);
//设置每页记录数
query.setMaxResults(2);

1
2
3

Query query=session.createQuery(
  "select new Users(users_name) from Users where users_name=?1");
query.setParameter(1,users_name);

1
2
3
4
5
6
7

//别名：要求必须以冒号开头:  list.setParameter()/setInteger也可以
String hql = "from Student where age > :myage and score < :myscore";   
Query createQuery = session.createQuery(hql);
List<Student> list = createQuery
  .setParameter("myage", 21)
  .setParameter("myscore", 95)
  .list();

1
2
3

//操作集合:查找经历等于二的员工size: from Staff s  where s.experiences.size=2
//子查询：查找经历大于1的: from Staff s  where 1<(select count(e) from s.experiences e) 
//in:与”=any”等价:表示子查询语句返回的所有记录