`

spring2.5集成jpa

阅读更多

所需jar包:

spring2.5:

aspectjrt.jar

aspectjweaver.jar

cglib-nodep-2.1_3.jar

common-annotations.jar

commons-logging.jar

log4j-1.2.15.jar

spring.jar

spring-webmvc-struts.jar

hibernate3.3:

antlr-2.7.6.jar

commons-collections-3.1.jar

dom4j-1.6.1.jar

ehcache-1.2.3.jar

ejb3-persistence.jar

hibernate3.jar

hibernate-annotations.jar

hibernate-commons-annotations.jar

javassist-3.9.0.GA.jar

jta-1.1.jar

slf4j-api-1.5.8.jar

slf4j-log4j12-1.5.8.jar

c3p0-0.9.1.2.jar

mysql-connector-java-5.1.7-bin.jar

数据库使用的是mysql5,脚本:

/*
MySQL Data Transfer
Source Host: localhost
Source Database: ssjdb
Target Host: localhost
Target Database: ssjdb
Date: 2010-3-30 18:47:37
*/

SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for student_
-- ----------------------------
DROP TABLE IF EXISTS `student_`;
CREATE TABLE `student_` (
  `id_` int(11) NOT NULL AUTO_INCREMENT,
  `name_` varchar(20) DEFAULT NULL,
  `sex_` varchar(20) DEFAULT NULL,
  `age_` int(11) DEFAULT NULL,
  `grade_` varchar(60) DEFAULT NULL,
  `class_` varchar(60) DEFAULT NULL,
  PRIMARY KEY (`id_`)
) ENGINE=MyISAM AUTO_INCREMENT=35 DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records 
-- ----------------------------
INSERT INTO `student_` VALUES ('2', 'student2', '男', '12', '一年级', '二班');
INSERT INTO `student_` VALUES ('3', 'student3', '男', '13', '一年级', '二班');
INSERT INTO `student_` VALUES ('4', 'student4', '女', '14', '一年级', '二班');
INSERT INTO `student_` VALUES ('5', 'student5', '女', '15', '一年级', '二班');
INSERT INTO `student_` VALUES ('6', 'student6', '男', '16', '二年级', '一班');
INSERT INTO `student_` VALUES ('7', 'student7', '男', '17', '二年级', '一班');
INSERT INTO `student_` VALUES ('8', 'student8', '女', '18', '一年级', '一班');
INSERT INTO `student_` VALUES ('9', 'story1', '男', '19', '一年级', '二班');
INSERT INTO `student_` VALUES ('10', 'story2', '女', '11', '一年级', '一班');
INSERT INTO `student_` VALUES ('11', 'story3', '男', '12', '二年级', '一班');
INSERT INTO `student_` VALUES ('12', 'story4', '女', '13', '一年级', '二班');
INSERT INTO `student_` VALUES ('13', 'story5', '男', '14', '一年级', '一班');
INSERT INTO `student_` VALUES ('14', 'story6', '男', '15', '一年级', '一班');
INSERT INTO `student_` VALUES ('15', 'story7', '女', '16', '一年级', '二班');
INSERT INTO `student_` VALUES ('16', 'story8', '男', '17', '一年级', '二班');
INSERT INTO `student_` VALUES ('17', 'story9', '男', '18', '一年级', '二班');
INSERT INTO `student_` VALUES ('18', 'story8', '男', '15', '一年级', '二班');
INSERT INTO `student_` VALUES ('19', 'story8', '男', '16', '一年级', '二班');

 实体类:

/**
 * 学生信息类
 */
@Entity
@Table(name = "student_")
public class Student implements java.io.Serializable {

	private static final long serialVersionUID = 2345820270183923971L;
	private Integer id;//主键
	private String name;//名字
	private String sex;//性别
	private Integer age;//年龄
	private String grade;//年级
	private String class_;//班级

	public Student() {
	}

	@Id
	@GeneratedValue(strategy = IDENTITY)
	@Column(name = "id_", unique = true, nullable = false)
	public Integer getId() {
		return this.id;
	}

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

	@Column(name = "name_", length = 20)
	public String getName() {
		return this.name;
	}

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

	@Column(name = "sex_", length = 20)
	public String getSex() {
		return this.sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	@Column(name = "age_")
	public Integer getAge() {
		return this.age;
	}

	public void setAge(Integer age) {
		this.age = age;
	}

	@Column(name = "grade_", length = 60)
	public String getGrade() {
		return this.grade;
	}

	public void setGrade(String grade) {
		this.grade = grade;
	}

	@Column(name = "class_", length = 60)
	public String getClass_() {
		return this.class_;
	}

	public void setClass_(String class_) {
		this.class_ = class_;
	}

}

 

persistence.xml配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
    http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd" version="1.0">
    
	<persistence-unit name="ssjPU" transaction-type="RESOURCE_LOCAL">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		<class>org.forever.xxxx.entities.Student</class>
		<properties>
			<property name="hibernate.connection.driver_class"
				value="com.mysql.jdbc.Driver" />
			<property name="hibernate.connection.url"
				value="jdbc:mysql://localhost:3306/paginationdb" />
			<property name="hibernate.connection.username" value="root" />
			<property name="hibernate.connection.password" value="root" />
			<property name="hibernate.hbm2ddl.auto" value="update"/>
			<property name="hibernate.show_sql" value="true"/>
		</properties>
	</persistence-unit>

</persistence>

 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">

	
	<!-- 1.配置数据源 -->
	<context:annotation-config />
     <context:component-scan base-package="org.forever.xxxx" />

	<bean id="dataSource"  
        class="com.mchange.v2.c3p0.ComboPooledDataSource"  
        destroy-method="close">   
        <property name="driverClass">   
            <value>com.mysql.jdbc.Driver</value>   
        </property>   
        <property name="jdbcUrl">   
            <value>jdbc:mysql://localhost:3306/ssjdb</value>   
        </property>   
        <property name="user">
            <value>root</value>   
        </property>   
        <property name="password">   
            <value>root</value>   
        </property> 
    </bean>
    
	<!-- 2.配置实体管理工厂 -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="persistenceUnitName" value="ssjPU" />
		<property name="dataSource" ref="dataSource"/>
	</bean>

	<!-- 3.配置jpa模板工具 -->
	<bean id="jpaTemplate" class="org.springframework.orm.jpa.JpaTemplate">
		<property name="entityManagerFactory" ref="entityManagerFactory"/>
	</bean>
	
	<!-- 4.配置事务环境 -->
	<bean id="myTxManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>
	
	<!-- 5.事务aop配置 -->
	<aop:config>
		<aop:pointcut id="bizMethod"
			expression="execution(* org.forever.xxxx.biz..*.*(..))" />
		<aop:advisor advice-ref="txAdvice" pointcut-ref="bizMethod" />
	</aop:config>

	<tx:advice id="txAdvice" transaction-manager="myTxManager">
		<tx:attributes>
			<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED" />
			<tx:method name="find*" read-only="true" propagation="NOT_SUPPORTED" />
			<tx:method name="*" propagation="REQUIRED" />
		</tx:attributes>
	</tx:advice>

</beans>

 测试类:

package org.forever.xxxx.test;

import java.util.List;

import org.forever.xxxx.entities.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.orm.jpa.JpaTemplate;

public class BeanTest {
	
	public static void main(String[] args) {
		
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		JpaTemplate jpaTemplate = (JpaTemplate) context.getBean("jpaTemplate");
		List<?> list =  jpaTemplate.find("select student from Student student");
		for (Object object : list) {
			Student student = (Student)object;
			System.out.println(student.getName());
		}
		
	}
}

 

0
0
分享到:
评论

相关推荐

    Spring2.5集成JPA

    《Spring2.5集成JPA深度解析》 在Java企业级开发中,Spring框架与Java Persistence API(JPA)的整合已经成为主流的持久层解决方案。本文将深入探讨Spring 2.5版本如何与JPA进行集成,以及在实际项目中的应用和配置...

    Spring2.5整合JPA

    在Spring 2.5版本中,它进一步增强了对Java Persistence API (JPA)的支持,使得开发者能够更加方便地将JPA集成到Spring应用中,实现数据持久化。JPA则是一种标准的ORM(对象关系映射)规范,它提供了一种将Java对象...

    Struts2,spring2.5与jpa的整合示例

    Struts2、Spring2.5和JPA是Java开发中常用的三大框架,它们在企业级应用开发中扮演着重要角色。Struts2作为MVC框架,负责处理HTTP请求和视图展示;Spring2.5则提供了强大的依赖注入(DI)和面向切面编程(AOP)功能...

    Spring2.5_JPA_Transaction_Demo

    本示例"Spring2.5_JPA_Transaction_Demo"专注于演示如何在Spring 2.5版本中结合JPA进行事务管理,这对于理解Spring和JPA的整合以及事务处理机制至关重要。 1. **Spring 2.5**:这是一个里程碑式的版本,引入了许多...

    Spring2.5整合JPA(Hibernate实现)所需的JAR包

    在本场景中,我们关注的是如何将Spring 2.5与JPA结合,并特别通过Hibernate作为JPA的实现来构建项目。以下是你提到的各个JAR包的作用和它们在整合过程中的角色: 1. **spring.jar**: 这是Spring框架的核心库,包含...

    spring2.5+jpa

    标题“spring2.5+jpa”表明我们正在讨论一个关于Spring框架2.5版本与Java Persistence API(JPA)的集成项目。这个项目可能是为了演示如何在Spring 2.5的环境中利用JPA来管理数据库操作。JPA是Java平台上的一个标准...

    struts2+spring2.5+jpa(基于注释)

    Spring2.5 是一个全面的后端框架,它不仅包含了依赖注入(DI)和面向切面编程(AOP)等功能,还提供了对其他技术如JDBC、JPA、Hibernate等的集成。在本项目中,Spring2.5主要负责管理Bean的生命周期,通过注解@Scope...

    struts2.0+spring2.5+JPA整合框架

    4. 在Spring中集成JPA:通过JpaTemplate或EntityManagerFactoryBean,配置JPA数据访问层。 5. 将Struts2和Spring整合:使用Spring的Struts2插件,将Spring的bean注入到Struts2的Action中。 在实际开发中,为了使...

    Spring2.5 + JPA(Hibernate)实现

    标题 "Spring2.5 + JPA(Hibernate)实现" 指的是在Spring框架的2.5版本中集成Java Persistence API (JPA),并利用Hibernate作为JPA的实现。这通常是为了在一个基于Spring的应用程序中实现数据持久化,提供一个灵活、...

    spring2.5 + jpa(hibernate3) 实例源码

    【标题】"spring2.5 + jpa(hibernate3) 实例源码"涉及的核心技术是Spring 2.5框架与Java Persistence API (JPA)的整合,其中JPA的具体实现是Hibernate 3。这个实例提供了如何在Spring环境中配置和使用JPA进行数据库...

    Struts1.3+spring2.5+JPA(hibernate) demo

    Struts1.3、Spring2.5和JPA(基于Hibernate)是Java Web开发中三个重要的框架,它们的集成使用可以构建出强大的企业级应用。这个"Struts1.3+spring2.5+JPA(hibernate) demo"提供了一个实践性的学习案例,帮助初学者...

    Struts2 + Spring2.5 + JPA(hibernate) + AJAX+ 实例

    Spring2.5还集成了对JPA的支持,可以方便地与ORM(对象关系映射)框架如Hibernate集成,以实现数据访问层的抽象。 **JPA (Java Persistence API)** 是Java平台上的标准持久化API,它定义了如何在Java应用中管理和...

    精通Spring2.5pdf书籍proSpring2.5

    在数据访问方面,Spring 2.5强化了对JDBC、Hibernate、JPA等持久层技术的集成,提供了统一的数据访问抽象,使得开发者可以更加专注于业务逻辑,而不必关心底层实现细节。例如,Spring的Template模式为JDBC操作提供了...

    Struts1.3 spring2.5 JPA 所需jia包

    Spring2.5 是Spring框架的一个较旧版本,它是一个全面的后端应用框架,不仅支持依赖注入(DI)和面向切面编程(AOP),还包含了对事务管理、数据访问集成、Web应用的支持。在Spring2.5中,你可以使用XML配置或注解来...

Global site tag (gtag.js) - Google Analytics