Spring整合SpringDataJpa步骤及注解说明

最新推荐文章于 2022-05-10 14:04:23 发布
最新推荐文章于 2022-05-10 14:04:23 发布
阅读量574 收藏 1
点赞数 5
分类专栏： 框架笔记 文章标签： JAVA JPA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33881464/article/details/87824247
版权

Spring整合SpringDataJpa步骤及注解说明

一、Spring整合SpringDataJpa步骤：

1.首先：创建数据库

	/*创建客户表*/
	CREATE TABLE cst_customer (
	  cust_id bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户编号(主键)',
	  cust_name varchar(32) NOT NULL COMMENT '客户名称(公司名称)',
	  cust_source varchar(32) DEFAULT NULL COMMENT '客户信息来源',
	  cust_industry varchar(32) DEFAULT NULL COMMENT '客户所属行业',
	  cust_level varchar(32) DEFAULT NULL COMMENT '客户级别',
	  cust_address varchar(128) DEFAULT NULL COMMENT '客户联系地址',
	  cust_phone varchar(64) DEFAULT NULL COMMENT '客户联系电话',
	  PRIMARY KEY (`cust_id`)
	) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

2.创建工程

3.pom.xml文件引入依赖jar包,内容如下：

	<properties>
		<spring.version>4.2.4.RELEASE</spring.version>
		<hibernate.version>5.0.7.Final</hibernate.version>
		<slf4j.version>1.6.6</slf4j.version>
		<log4j.version>1.2.12</log4j.version>
		<c3p0.version>0.9.1.2</c3p0.version>
		<mysql.version>5.1.6</mysql.version>
	</properties>

	<dependencies>
		<!-- junit单元测试 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.9</version>
			<scope>test</scope>
		</dependency>

		<!-- spring beg -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>1.6.8</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- spring end -->

		<!-- hibernate beg -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-entitymanager</artifactId>
			<version>${hibernate.version}</version>
		</dependency>
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-validator</artifactId>
			<version>5.2.1.Final</version>
		</dependency>
		<!-- hibernate end -->

		<!-- c3p0 beg -->
		<dependency>
			<groupId>c3p0</groupId>
			<artifactId>c3p0</artifactId>
			<version>${c3p0.version}</version>
		</dependency>
		<!-- c3p0 end -->

		<!-- log end -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>${log4j.version}</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>

		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<!-- log end -->


		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.version}</version>
		</dependency>

		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-jpa</artifactId>
			<version>1.9.0.RELEASE</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.2.4.RELEASE</version>
		</dependency>

		<!-- el beg 使用spring data jpa 必须引入 -->
		<dependency>
			<groupId>javax.el</groupId>
			<artifactId>javax.el-api</artifactId>
			<version>2.2.4</version>
		</dependency>

		<dependency>
			<groupId>org.glassfish.web</groupId>
			<artifactId>javax.el</artifactId>
			<version>2.2.4</version>
		</dependency>
		<!-- el end -->
	</dependencies>

4.创建Customer(客户)实体类Customer.java和接口CustomerDao.java

	1).在XX.XXXXX.domain下创建Customer.java,内容如下：
		package XX.XXXXX.domain;

		import javax.persistence.*;

		@Entity
		@Table(name = "cst_customer")
		public class Customer {
			@Id
			@GeneratedValue(strategy = GenerationType.IDENTITY)
			@Column(name = "cust_id")
			private Long custId;
			@Column(name = "cust_address")
			private String custAddress;
			@Column(name = "cust_industry")
			private String custIndustry;
			@Column(name = "cust_level")
			private String custLevel;
			@Column(name = "cust_name")
			private String custName;
			@Column(name = "cust_phone")
			private String custPhone;
			@Column(name = "cust_source")
			private String custSource;

			//Getter Setter toString...
		}
	2).在XX.XXXXX.dao下创建接口文件CustomerDao.java,内容如下：
		package XX.XXXXX.dao;

		import XX.XXXXX.domain.Customer;
		import org.springframework.data.jpa.repository.JpaRepository;
		import org.springframework.data.jpa.repository.JpaSpecificationExecutor;

		public interface CustomerDao extends JpaRepository<Customer,Long>,JpaSpecificationExecutor<Customer> {
		}

5.在resources下创建配置文件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:aop="http://www.springframework.org/schema/aop"
		   xmlns:context="http://www.springframework.org/schema/context"
		   xmlns:jdbc="http://www.springframework.org/schema/jdbc" xmlns:tx="http://www.springframework.org/schema/tx"
		   xmlns:jpa="http://www.springframework.org/schema/data/jpa" xmlns:task="http://www.springframework.org/schema/task"
		   xsi:schemaLocation="
			http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
			http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
			http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
			http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
			http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
			http://www.springframework.org/schema/data/jpa
			http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

		<!--1.创建entityManagerFactory容器给spring管理-->
		<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
			<property name="dataSource" ref="dataSource"></property>
			<!--实体类所在的包-->
			<property name="packagesToScan" value="XX.XXXXX.domain"></property>
			<!--jpa的实现厂家-->
			<property name="persistenceProvider">
				<bean class="org.hibernate.jpa.HibernatePersistenceProvider"></bean>
			</property>
			<!--jpa的供应商适配器-->
			<property name="jpaVendorAdapter">
				<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
					<!--配置是否自动创建数据库表 -->
					<property name="generateDdl" value="false" />
					<!--指定数据库类型 -->
					<property name="database" value="MYSQL" />
					<!--数据库方言：支持的特有语法 -->
					<property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
					<!--是否显示sql -->
					<property name="showSql" value="true" />
				</bean>
			</property>
			<!--jpa的方言 ：高级的特性 -->
			<property name="jpaDialect">
				<bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect"></bean>
			</property>
		</bean>
		<!--2.数据源-->
		<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
			<property name="user" value="用户名"></property>
			<property name="password" value="密码"></property>
			<property name="jdbcUrl" value="jdbc:mysql:///数据库名称"></property>
			<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		</bean>
		<!--3.整合spring dataJpa-->
		<jpa:repositories base-package="XX.XXXXX.dao" transaction-manager-ref="transactionManager"
						  entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
		<!--4.配置事务管理器-->
		<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
			<property name="entityManagerFactory" ref="entityManagerFactory"></property>
		</bean>

		<!--5.声明式事务，可以不用配置 -->

		<!-- 6. 配置包扫描-->
		<context:component-scan base-package="XX.XXXXX."></context:component-scan>

	</beans>

6.在XX.XXXXX.test下创建测试类SpecTest.java，内容如下：

	package XX.XXXXX.test;

	import XX.XXXXX.domain.Customer;
	import XX.XXXXX.util.JPAUtil;
	import org.junit.Test;

	import javax.persistence.EntityManager;
	import javax.persistence.EntityManagerFactory;
	import javax.persistence.EntityTransaction;
	import javax.persistence.Persistence;

	public class JpaTest {
		//增加
		@Test
		public void saveTest(){
			EntityManagerFactory factory = Persistence.createEntityManagerFactory("myJpa");//获取实体管理类工厂
			EntityManager em = factory.createEntityManager();//获取实体管理类
			EntityTransaction tx = em.getTransaction();//获取事务对象
			tx.begin();//开启事务

			Customer customer = new Customer();//创建对象
			customer.setCustName("百度");
			customer.setCustIndustry("搜索");

			em.persist(customer);//保存
			tx.commit();//提交事务

			em.close();//释放资源
			factory.close();
		}
	}

二、一对多、多对一用到的注解说明

@OneToMany:

作用：建立一对多的关系映射
属性：
	targetEntityClass：指定多的多方的类的字节码
	mappedBy：指定从表实体类中引用主表对象的名称。
	cascade：指定要使用的级联操作
	fetch：指定是否采用延迟加载
	orphanRemoval：是否使用孤儿删除

@ManyToOne

	作用：建立多对一的关系
	属性：
		targetEntityClass：指定一的一方实体类字节码
		cascade：指定要使用的级联操作
		fetch：指定是否采用延迟加载
		optional：关联是否可选。如果设置为false，则必须始终存在非空关系。

@JoinColumn

作用：用于定义主键字段和外键字段的对应关系。
	 属性：
		name：指定外键字段的名称
		referencedColumnName：指定引用主表的主键字段名称
		unique：是否唯一。默认值不唯一
		nullable：是否允许为空。默认值允许。
		insertable：是否允许插入。默认值允许。
		updatable：是否允许更新。默认值允许。
		columnDefinition：列的定义信息
InMyHeart丿
关注
  • 5
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Spring整合SpringDataJpa
weixin_45921969的博客
03-16 308
Spring整合SpringDataJpa spring整合jpa的方式是将jpa采用工厂模式管理，我们通过spring的编写方式使用jpa 那么来看看具体代码： 首先是maven的引入： <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
SpringMVC+Spring+Spring-Data-JPA整合-完整Demo
02-27
SpringMVC+Spring+Spring-Data-JPA整合-完整Demo
Spring常用注解
renxyz的专栏
09-15 1401
看到一篇讲解注解的文章，讲的太好了，文章转载地址 http://www.cnblogs.com/xdp-gacl/p/3495887.html 具体如下： 使用注解来构造IoC容器 用注解来向Spring容器注册Bean。需要在applicationContext.xml中注册。 如：在base-package指明一个包 1 context:component-sca
spring mvc 集成 spring data jpa
wyc2410的专栏
03-13 847
一、准备工作 建立springmvc项目，添加spring data jpa 需要依赖 jar 包， org.springframework.data spring-data-jpa 1.6.0.RELEASE org.springframework.data spring-data-commons 1.9.2.RE
spring、springMVC、springData、jpa项目整合
scry丶坏坏的博客
01-09 620
本博客内容是sssp（spring、spingMVC、springData、jpa）项目的整合过程，希望此内容能够帮到有需要的人。 环境介绍：eclipse、jdk1.8、spring4.2.5 一、在eclipse中新建dynamic web project。 二、加入spring 加入spring必须的jar包（其中包含了spring和springMVC所需要的jar包）： com
Spring Boot整合Spring Data JPA过程解析
08-25
Spring Boot整合Spring Data JPA过程解析 Spring Boot是一种流行的Java框架，用于...通过上述步骤，我们可以将Spring Boot与Spring Data JPA集成，实现了JPA的持久层功能，从而简化了数据库访问和实体类的映射关系。
Spring-Data-JPA整合MySQL和配置的方法
08-27
【Spring Data JPA 整合 MySQL】：Spring Data JPA 是一种基于 Java Persistence API (JPA) 的数据访问层框架，由 Spring 框架提供，它简化了对数据库的操作，通过 Repository 接口即可实现对数据库的增删查改。...
Spring Data JPA学习
08-10
下面是Spring Data JPA的特征和配置步骤： 一、支持基于Spring和JPA构建存储库 Spring Data JPA提供了一个基于Spring的存储库实现，可以使用Spring的依赖注入和AOP等特性来简化存储库的开发。同时，它也支持JPA...
从最基本的Java工程搭建SpringMVC+SpringDataJPA+Hibernate
09-02
以上就是从一个基础的Java工程逐步构建到集成Spring、SpringMVC、SpringDataJPA+Hibernate的过程。这个过程展示了如何配置Maven工程、转换为Web工程、集成Spring框架、SpringMVC和数据访问层。理解这些步骤有助于你...
Spring Boot+Jpa多数据源配置的完整步骤
08-26
Spring Boot+Jpa多数据源配置的完整步骤 Spring Boot作为一款现代化的Java开发框架，提供了许多优秀的特性和配置项，其中JPA（Java Persistence API）是Java EE中的一种持久化API，用于简化数据库操作。然而，在...
SpringData和Spring和JPA的整合
07-28
这里主要是整合后的空白框架
spring data jpa 注解实战使用（超详细）
renguiriyue的博客
12-12 301
spring data jpa 注解实战使用项目搭建建立简单的实体类 sql实体类干起来~service 代码跑起来~ 用hibernate 开发了一段时间，觉得自己不够规范，所以打算整理整理。这篇博文从实战的角度来编写了，每个用到的注解我会细细的描述一下。如有不规范的地方，也请道友及时指正。 项目搭建 建立简单的实体类 sql 先创建两张没有关联的表 DROP TABLE IF EXISTS `...
Spring Data JPA注解
weixin_43689040的博客
05-05 809
一，基本注解 1.@table 2.@Id&@IdClass 3.@GeneratedValue 4.@Column 5.@Enumerated 二，关联关系注解 1.一对多
springdata jpa 注解详解
八点二十四分
03-23 421
@Entity @Table(name = "t_user") @Data public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String url; ...
Spring Data JPA 常用注解
一只特立独行的猪
04-30 336
1. 创建表 @Entity声明该类对应一个数据表实体（万事万物皆为对象）。 @Table 设置表名 @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private St...
spring data jpa及常用注解总结
m0_46880425的博客
05-10 472
详解 spring data jpa
Spring Data JPA中常用的注解详解
Rsun2018的博客
03-22 1237
我们先看看类前面的两个注解 @Entity 标识这个实体类是一个JPA实体，告诉JPA在程序运行的时候记得生成这个实体类所对应的表 @Table（name = "自定义的表名"） 自定义设置这个实体类在数据库所对应的表名 @Id 把这个类里面所在的变量设置为主键Id @GeneratedValue 设置主键的生成策略，这种方式依赖于具体的数据库，如果数据库不支持自增主键，那么这个类型是没...
Spring Data JPA中的几个常用注解
一个人的青春战役的博客
01-18 269
今天上午在家看了一上午书，反正现在也无事可做，就把今天书上自己感觉有用的内容写下来，一方面是分享给大家，另一方面也当做个笔记。 @Param用法 默认情况下，参数是通过顺序绑定在查询语句上的。这使得查询方法对参数位置的重构容易出错。为了解决这个问题，可以使用**@Param**注解指定方法参数的具体名称，可以通过绑定的参数名字做查询条件。 @Query(“select u from User u ...
[JavaWeb][Spring][使用注解配置Spring][Spring/SpringMVC/SpringDataJPA/MyBatis]
一个自我学习的记录之处
09-15 840
[JavaWeb][Spring][使用注解配置Spring] [JavaWeb][Spring][使用注解配置Spring] 前言 Spring+Spring MVC+Spring Data JPA 依赖项 目录结构 整合 Spring 核心 SpringMVC Spring Data JPA 日志配置 Spring+Spring MVC+MyBatis 依赖项 整合 MyBati...
springboot整合Spring Data JPA
最新发布
07-14
要在Spring Boot中整合Spring Data JPA，可以按照以下步骤进行操作： 1. 添加依赖：在项目的pom.xml文件中添加Spring Data JPA的依赖。可以使用以下依赖项： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> ``` 2. 配置数据源：在Spring的配置文件中配置数据源，例如application.properties或application.yml文件。根据你使用的数据库类型，配置对应的数据源相关信息，如数据库连接URL、用户名、密码等。 3. 定义实体类：创建与数据库表对应的实体类，并使用JPA注解进行映射。例如，在实体类上使用@Entity注解，指定表名、字段名，以及关系映射等。 4. 创建DAO接口：创建一个继承自JpaRepository或其子接口的DAO接口。这个接口将提供一些常用的CRUD操作方法，无需手动实现。 5. 编写业务逻辑：在Service层中编写业务逻辑代码，并调用DAO接口中定义的方法进行数据访问和操作。 6. 运行程序：启动Spring Boot应用程序，Spring Boot会自动创建数据源、实体类和DAO接口的实现，并根据需要执行数据库操作。 以下是一个简单的示例： 1. 创建实体类： ```java @Entity @Table(name = "users") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; // getters and setters } ``` 2. 创建DAO接口： ```java public interface UserRepository extends JpaRepository<User, Long> { // 可以在此接口中添加自定义的查询方法 } ``` 3. 编写业务逻辑： ```java @Service public class UserService { @Autowired private UserRepository userRepository; public List<User> getAllUsers() { return userRepository.findAll(); } public User getUserById(Long id) { return userRepository.findById(id).orElse(null); } public User saveUser(User user) { return userRepository.save(user); } public void deleteUser(Long id) { userRepository.deleteById(id); } } ``` 通过以上步骤，你就可以在Spring Boot应用程序中使用Spring Data JPA进行数据库访问和操作了。可以通过注入UserService来调用相应的方法，实现对数据库的增删改查操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值