hibernate操作大对象

    hibernate操作大对象示例，至于能存入多大的数据量，就由mysql的大数据字段来决定，还有就是运行时文件流转换过程有没有超出内存的大小来决定的。

 

1 Student.java

package entity;

import java.io.Serializable;
import java.sql.Blob;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class Student implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	@Id
	@GeneratedValue(strategy=GenerationType.AUTO) 
	private Integer id;
	
	@Column(length=20)
	private String name;
	@Column(nullable=true)
	private Blob file = null;//这里不要起个blob的名字作为数据库的字段，因为它是数据库的关键字，这样hibernate会出错的。
	
	
	public Student(){
	}


	public Integer getId() {
		return id;
	}


	public void setId(Integer id) {
		this.id = id;
	}


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public Blob getFile() {
		return file;
	}


	public void setFile(Blob file) {
		this.file = file;
	}
	
}

 

2 StudentServer.java

package server;

import entity.Student;

public interface StudentServer {

	public void save(Student student);
	public Student getByid(Integer id);
	
}

 

3 StudentServerImpl.java

package server.impl;

import javax.annotation.Resource;

import org.hibernate.Hibernate;
import org.hibernate.SessionFactory;
import org.springframework.transaction.annotation.Transactional;

import server.StudentServer;

import entity.Student;


@Transactional
/*
 * 没加入@Transactional会产生如下异常：
 org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here
	at org.springframework.orm.hibernate3.SpringSessionContext.currentSession(SpringSessionContext.java:63)
	at org.hibernate.impl.SessionFactoryImpl.getCurrentSession(SessionFactoryImpl.java:574)
	at biao.scut.server.impl.StudentServerImpl.save(StudentServerImpl.java:21)
	at Junit.StudentServerTest.testSave(StudentServerTest.java:34)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
	at java.lang.reflect.Method.invoke(Unknown Source)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
	at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
	at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:73)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:46)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:180)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:41)
	at org.junit.runners.ParentRunner$1.evaluate(ParentRunner.java:173)
	at org.junit.internal.runners.statements.RunBefores.evaluate(RunBefores.java:28)
	at org.junit.internal.runners.statements.RunAfters.evaluate(RunAfters.java:31)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:220)
	at org.eclipse.jdt.internal.junit4.runner.JUnit4TestReference.run(JUnit4TestReference.java:46)
	at org.eclipse.jdt.internal.junit.runner.TestExecution.run(TestExecution.java:38)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:467)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:683)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:390)
	at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:197)
 
 */
public class StudentServerImpl implements StudentServer {

	@Resource SessionFactory sessionFactory;
	
	@Override
	public Student getByid(Integer id) {
		Student student = (Student) sessionFactory.getCurrentSession().get(Student.class, id);
		Hibernate.initialize(student.getFile());
		return student;
	}

	@Override
	public void save(Student student) {
		sessionFactory.getCurrentSession().persist(student);
	}

}

 

4 大对象数据操作主要的实现部分：

package Junit;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.Blob;
import java.sql.SQLException;

import org.hibernate.Hibernate;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import server.StudentServer;

import entity.Student;


public class StudentServerTest {

/*	//这里的java项目，而不是web项目，所以不能用注解方式
	@Resource private StudentServer studentServer;*/
	private static StudentServer studentServer;
	
	
	
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		
		//实例化spring容器,这里不用@Resource注解来做，是因为这里没放到服务器就可以运行，当把项目放入到服务器中，那就可以直接用注解的简便方式来引用spring配好的Bean
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
		//用容器获取一个bean,这些bean要在配置文件里有的
		studentServer = (StudentServer)applicationContext.getBean("studentServer");
	}

	@Test
	public void testSave() {
		Student student = new Student();
		student.setName("dianying");
		File file = new File("d:\\e.rmvb");
		FileInputStream fis = null;
		Blob temp;
		
		try {
			fis = new FileInputStream(file);
			temp = Hibernate.createBlob(fis);
//			fis.close();
			student.setFile(temp);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		studentServer.save(student);
		try {
			fis.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	@Test
	public void testGetByid() {
		Student student = studentServer.getByid(22);
		Blob fileBlob = student.getFile();
		File out = new File("D:\\bb");//ce.rmvb
		FileOutputStream fos;
		BufferedOutputStream bos;
		
		
		
		InputStream is;
		BufferedInputStream bis;
		byte[] b = new byte[1024];
		
		try {
			fos = new FileOutputStream(out);
			bos = new BufferedOutputStream(fos);
			
			is = fileBlob.getBinaryStream();
			bis = new BufferedInputStream(is);
			
			
			while( bis.read(b) != -1 ){
				bos.write(b);
			}
			bos.close();
			fos.close();
			
			bos.close();
			is.close();
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}

}

 

5 spring配置

<?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: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-2.5.xsd
           http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
           http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
	 <context:annotation-config/>
	 <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
	    <property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>
	    <property name="url" value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=UTF-8"/>
	    <property name="username" value="root"/>
	    <property name="password" value=""/>
	     <!-- 连接池启动时的初始值 -->
		 <property name="initialSize" value="1"/>
		 <!-- 连接池的最大值 -->
		 <property name="maxActive" value="500"/>
		 <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->
		 <property name="maxIdle" value="2"/>
		 <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->
		 <property name="minIdle" value="1"/>
	  </bean>

	  
 <!-- 下面是用hiberanate的二级缓存的配置，先生成sessionFactory，再将数据源（上面配好的），注入到这里的name=dataSource这里来-->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
	     <property name="dataSource" ref="dataSource"/>
		<!-- 下面完成hiberate的配置映射文件，它可以有多条的映射文件列表 -->
		<property name="annotatedClasses">  
         <list>  
           <value>entity.Student</value>  
         </list>  
       </property>
		
		 <!-- 下面是对hibernate的属性的设置 -->
	     <property name="hibernateProperties">
		    <value>
		        hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
		        hibernate.hbm2ddl.auto=update
		        hibernate.show_sql=true
		        hibernate.format_sql=true
		        hibernate.cache.use_second_level_cache=true<!-- 使用二级缓存 -->
       	        hibernate.cache.use_query_cache=false
        	    hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
		      </value>
	     </property>
	</bean>

	
<!-- 下面是配置事务管理器 -->
	<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
	  	<property name="sessionFactory" ref="sessionFactory"/><!-- 将上面的（ref="sessionFactory"）交由事务管理器（name="sessionFactory"）来管理 -->
	</bean>
	
<!-- 下面是打开注解的支持，并设置了事务管理器 （上面配置的事务管理器）-->	
	<tx:annotation-driven transaction-manager="txManager"/>
	<!-- 下面将bean交给spring容器管理，就可以使用依赖注入的方式来引用bean -->
	<bean id="studentServer" class="server.impl.StudentServerImpl"/>
</beans>