spring加入hibernate（注解版）

来源：互联网发布：java脚本语言编辑：程序博客网时间：2024/05/29 09:25

1、包依赖

Pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

<groupId>com.erik.spring</groupId>

<version>0.0.1-SNAPSHOT</version>

<url>http://maven.apache.org</url>

<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

</properties>

<groupId>org.springframework</groupId>

<artifactId>spring-context</artifactId>

<version>3.0.0.RELEASE</version>

<scope>runtime</scope>

</dependency>

</dependency>

</dependency>

</dependency>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-test</artifactId>

<version>3.0.0.RELEASE</version>

<scope>compile</scope>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-annotations</artifactId>

<scope>compile</scope>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-commons-annotations</artifactId>

<scope>compile</scope>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate</artifactId>

<version>3.5.4-Final</version>

<scope>compile</scope>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

<groupId>com.oracle</groupId>

<artifactId>classes12</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring-orm</artifactId>

<version>3.0.0.RELEASE</version>

<scope>compile</scope>

</dependency>

</dependencies>

</project>

注意1、是否正常连接到maven仓库，spring的版本是否一致，此处用的是3.0.0

特别说明的是，此处用的是spring-orm提供了hibernate支持，而不用spring-hibernate，原因是后者我不会用

2.hibernate资源配置文件

先看下配置好的项目目录结构

其中test中的application.test.properties,applicationContect-test.xml和main下的两个文件基本一致。

application.properties：

#jdbc settings

jdbc.driver=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://localhost:3306/hibernate

jdbc.username=root

jdbc.password=root

#hibernate settings

hibernate.dialect=org.hibernate.dialect.MySQLDialect

hibernate.show_sql=true

hibernate.format_sql=false

以上是MYSQL的连接

#jdbc settings

jdbc.driver=oracle.jdbc.driver.OracleDriver

jdbc.url=jdbc:oracle:thin:@192.168.3.216:1522:orcl

jdbc.username=suqiutest

jdbc.password=suqiutest

#hibernate settings

hibernate.show_sql=true

hibernate.format_sql=false

hibernate.generate_statistics=true

hibernate.dialect=org.hibernate.dialect.Oracle10gDialect（版本可能会有问题，可以用org.hibernate.dialect.OracleDialect）

以上是oracle的连接

applicationContext.xml：

<?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:context="http://www.springframework.org/schema/context"

xmlns:util="http://www.springframework.org/schema/util"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">

<description>Spring公共配置文件 </description>

<bean

class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<list>

<value>classpath*:/application.properties</value>

</list>

</property>

</bean>

<!- 持久化用到springJDBC，涉及到文章类型字段的操作-->

<bean id="nativeJdbcExtractor"

class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor" lazy-init="true" />

<bean id="lobHandler" class="org.springframework.jdbc.support.lob.OracleLobHandler"

lazy-init="true">

</property>

</bean>

<context:component-scan base-package="com.syz.test.hibernate,com.syz.test.entity" />

<bean id="dataSource"

class="org.springframework.jdbc.datasource.DriverManagerDataSource">

</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

</property>

<props>

<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>

<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>

<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>

</props>

</property>

</bean>

</beans>

至此，hibernate的sessionfactory Bean配置完毕，接下来进行注入的配置。

3、将sessionFactory注入到需要的类中

注入配置很简单，按上次的注入的三种方式任何一种都可以。

package com.syz.test.hibernate;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;

import org.junit.Test;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;

@ContextConfiguration(locations = { "/applicationContext.xml" })

public class HibernateTest extends AbstractJUnit4SpringContextTests{

@Autowired

@Qualifier("app")

public App app ;

public void setApp(App app){

this.app = app;

}

public App getApp() {

return app;

}

@Resource(name="sessionFactory")

public SessionFactory sessionFactory;

@Test

public void testApp(){

System.out.println(sessionFactory);

System.out.println(app.getPerson().getName());

System.out.println(app.getPerson().getAge());

}

4.运行测试

Log4j.properties加入：log4j.logger.org.hibernate=debug

运行：org.hibernate.impl.SessionFactoryImpl@68cd79

shiyuezhong

5.完善hibernate的增删改查

（1）项目目录结构图

dao和dao.impl中分别放置dao的接口和他的实现类

entity放置实体类

Test源文件夹下的dao放置dao的测试类

以test结尾的包是前几次留下来的，为了项目的连贯性，不去删除他，在本项目中是没用的。

（2）创建person表

DROP TABLE IF EXISTS `person`;

CREATE TABLE `person` (

`Id` varchar(255) NOT NULL DEFAULT '',

`name` varchar(255) DEFAULT NULL,

`age` int(11) DEFAULT NULL,

PRIMARY KEY (`Id`)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

现在用的是mysql数据库，oracle类似

（3）配置实体类

package com.syz.test.entity;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity

// 注意不是hibernate的

@Table(name = "PERSON")

// 注意不是hibernate的

public class Person {

public String pid;

public String name;

public Integer age;

// 实体类的id，id生成策略是uuid

@Id

@Column(name = "ID", unique = true, nullable = false, length = 32)

@GeneratedValue(generator = "paymentableGenerator")

@GenericGenerator(name = "paymentableGenerator", strategy = "uuid")

public String getPid() {

return pid;

}

public void setPid(String pid) {

this.pid = pid;

}

@Column(name = "name", length = 255)

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

@Column(name = "age", precision = 11, scale = 0)

public Integer getAge() {

return age;

}

public void setAge(Integer age) {

this.age = age;

}

关于hibernate实体类的详细介绍这边先不交代（具体参考文档），先把整个项目完善。

（4）配置文件中加入spring的事务机制

</bean>

<tx:annotation-driven transaction-manager="transactionManager" />

要加入这个头部必须加入tx和aop的引用

完整的applicationContext.xml：

<?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:context="http://www.springframework.org/schema/context"

xmlns:util="http://www.springframework.org/schema/util"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd

http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<description>Spring公共配置文件 </description>

<list>

<value>classpath*:/application.properties</value>

</list>

</property>

</bean>

<bean id="nativeJdbcExtractor"

class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor"

lazy-init="true" />

<bean id="lobHandler" class="org.springframework.jdbc.support.lob.OracleLobHandler"

lazy-init="true">

</property>

</bean>

<context:component-scan base-package="com.syz.test.hibernate,com.syz.test.entity" />

<bean id="dataSource"

class="org.springframework.jdbc.datasource.DriverManagerDataSource">

</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

</property>

<props>

<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>

<prop key="hibernate.format_sql">${hibernate.format_sql}</prop>

<prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>

</props>

</property>

</bean>

<bean id="transactionManager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</bean>

<tx:annotation-driven transaction-manager="transactionManager" />

</beans>

Ok,很简单，基本的环境搭建完成。

(5)写dao类

接口PersonDao.java：

package com.syz.test.dao;

import java.util.List;

import com.syz.test.entity.Person;

public interface PersonDao{

public void save(Person p);

public void delete(Person p);

public void update(Person p);

public Person findById(String id);

public List<Person> list();

}

实现类PersonDaoImpl.java：

package com.syz.test.dao.impl;

import java.util.List;

import org.hibernate.HibernateException;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.orm.hibernate3.HibernateCallback;

import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import com.syz.test.dao.PersonDao;

import com.syz.test.entity.Person;

@Service

@Transactional

public class PersonDaoImpl extends HibernateDaoSupport implements PersonDao {

// 要使用之前，得注入sessionfactory

@Autowired

public void setSessionFactory0(SessionFactory sessionFactory) {

super.setSessionFactory(sessionFactory);

}

@Transactional

public void save(Person p) {

getHibernateTemplate().saveOrUpdate(p);

}

@Transactional

public void delete(Person p) {

getHibernateTemplate().delete(p);

}

@Transactional

public void update(Person p) {

getHibernateTemplate().saveOrUpdate(p);

}

@Transactional(readOnly = true)

public Person findById(String id) {

return getHibernateTemplate().load(Person.class, id);

}

@SuppressWarnings("unchecked")

@Transactional(readOnly = true)

public List<Person> list() {

return (List<Person>) getHibernateTemplate().executeWithNativeSession(

new HibernateCallback<Object>() {

public Object doInHibernate(Session session)

throws HibernateException {

Query query = session.createQuery("from Person as obj");

return query.list();

}

});

}

（6）测试类

PersonDaoTest.java

package com.syz.test.hibernate;

import java.util.List;

import javax.annotation.Resource;

import org.junit.Test;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;

import com.syz.test.dao.PersonDao;

import com.syz.test.entity.Person;

@ContextConfiguration(locations = { "/applicationContext.xml" })

public class PersonDaoTest extends AbstractJUnit4SpringContextTests {

@Resource(name = "personDaoImpl")

/*@Autowired

@Qualifier("personDaoImpl") 这两行代码和上面一行效果一样*/

public PersonDao personDao;

@Test

public void testListPerson() {

List<Person> ll = personDao.list();

for (Person p : ll) {

System.out.println(p.getName());

System.out.println(p.getAge());

}

Ok,配置完成，运行测试可以看到效果。可以打印出数据库person表里面的数据

0 0