002_Spring Data JPA CRUD

最新推荐文章于 2022-07-14 19:17:58 发布
最新推荐文章于 2022-07-14 19:17:58 发布
阅读量468 收藏
点赞数
分类专栏： SpringData 文章标签： spring java 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/aihiao/article/details/122984804
版权

1. 创建一个名为spring-data-jpa-crud的Java项目, 同时添加相关jar包, 并添加JUnit能力。

2. 查看CrudRepository接口下的方法, 我们使用红色框中的方法。

3. 新建User.java

package com.bjbs.pojo;

import java.io.Serializable;
import java.util.Date;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import org.springframework.format.annotation.DateTimeFormat;

@Entity // 指定该类是实体类
@Table(name = "user") // 指定数据库表名(表名和实体类对应)
public class User implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id // 指定为主键
	@GeneratedValue(strategy = GenerationType.IDENTITY) // 指定主键生成策略
	@Column(name = "id") // 指定表中列名(列名和属性名对应)
	private Integer id;

	@Column(name = "name")
	private String name;

	@Column(name = "sex")
	private String sex;
	
	@Column(name = "birthday")
	@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
	private Date birthday;

	@Column(name = "address")
	private String address;

	public User() {
	}

	public User(String name, String sex, Date birthday, String address) {
		this.name = name;
		this.sex = sex;
		this.birthday = birthday;
		this.address = address;
	}

	public User(Integer id, String name, String sex, Date birthday, String address) {
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.birthday = birthday;
		this.address = address;
	}

	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 String getSex() {
		return sex;
	}

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

	public Date getBirthday() {
		return birthday;
	}

	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", name=" + name + ", sex=" + sex + ", birthday=" + birthday + ", address=" + address
				+ "]";
	}
}

4. 新建UserRepository.java

package com.bjbs.dao;

import org.springframework.data.repository.CrudRepository;
import com.bjbs.pojo.User;

/**
 * 参数一T: 当前需要映射的实体; 参数二 T: 当前映射的实体中的id的类型
 */
public interface UserRepository extends CrudRepository<User, Integer> {

}

5. 新建UserService.java

package com.bjbs.service;

import com.bjbs.pojo.User;

public interface UserService {
	User save(User user);

	Iterable<User> save(Iterable<User> users);
	
	User findOne(Integer id);
	
	Iterable<User> findAll();

	void delete(Integer id);

	void delete(User user);

	void delete(Iterable<User> users);
}

6. 新建UserServiceImpl.java

package com.bjbs.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.bjbs.dao.UserRepository;
import com.bjbs.pojo.User;
import com.bjbs.service.UserService;

@Service
@Transactional
public class UserServiceImpl implements UserService {
	@Autowired
	private UserRepository userRepository;

	@Override
	public User save(User user) {
		return userRepository.save(user);
	}

	@Override
	public Iterable<User> save(Iterable<User> users) {
		return userRepository.save(users);
	}

	@Override
	public User findOne(Integer id) {
		return userRepository.findOne(id);
	}

	@Override
	public Iterable<User> findAll() {
		return userRepository.findAll();
	}

	@Override
	public void delete(Integer id) {
		userRepository.delete(id);
	}

	@Override
	public void delete(User user) {
		userRepository.delete(user);
	}

	@Override
	public void delete(Iterable<User> users) {
		userRepository.delete(users);
	}
	
}

7. 新建TestUserRepository.java

package com.bjbs.test;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.bjbs.pojo.User;
import com.bjbs.service.UserService;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestUserRepository {
	@Autowired
	private UserService userService;
	
	/**
	 * 添加
	 */
	@Test
	public void addOne() {
		User user = new User("曹整", "男", new Date(), "河南省开封市");
		User userDb = userService.save(user);
		System.out.println(userDb);
	}
	
	/**
	 * 批量添加
	 */
	@Test
	public void addMore(){
		User caoShuo = new User("曹铄", "男", new Date(), "河南省开封市");
		User qingHe = new User("清河公主", "女", new Date(), "河南省开封市");
		List<User> users = new ArrayList<User>();
		users.add(caoShuo);
		users.add(qingHe);
		Iterable<User> usersDb = userService.save(users);
		for (User user : usersDb) {
			System.out.println(user);
		}
	}
	
	/**
	 * 根据id查询
	 */
	@Test
	public void findOne() {
		User userDb = userService.findOne(40);
		System.out.println(userDb);
	}
	
	/**
	 * 更新
	 */
	@Test
	public void update(){
		User userDb = userService.findOne(56);
		System.out.println(userDb);
		userDb.setAddress("河南省郑州市");
		userDb = userService.save(userDb);
		System.out.println(userDb);
	}
	
	/**
	 * 查询所有
	 */
	@Test
	public void findAll(){
		Iterable<User> usersDb = userService.findAll();
		for (User user : usersDb) {
			System.out.println(user);
		}
	}
	
	/**
	 * 根据id删除
	 */
	@Test
	public void deleteById(){
		userService.delete(50);
	}
	
	/**
	 * 根据用户删除, 必须设置主键id
	 */
	@Test
	public void deleteByUser(){
		User user = new User();
		user.setId(56);
		userService.delete(user);
	}
	
	/**
	 * 根据用户删除
	 */
	@Test
	public void deleteByUsers(){
		User user1 = new User();
		user1.setId(45);
		User user2 = new User();
		user2.setId(46);
		List<User> users = new ArrayList<User>();
		users.add(user1);
		users.add(user2);
		userService.delete(users);
	}
}

8. 在src下新建application.properties

spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.25.138:3306/StudyMybatis?useSSL=true&useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=lyw123456

9. 在src下新建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa.xsd
	http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置读取properties文件的工具类 -->
	<context:property-placeholder location="classpath:application.properties" />

	<!-- 配置c3p0数据库连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="jdbcUrl" value="${spring.datasource.url}" />
		<property name="driverClass" value="${spring.datasource.driverClassName}" />
		<property name="user" value="${spring.datasource.username}" />
		<property name="password" value="${spring.datasource.password}" />
	</bean>

	<!-- Spring整合JPA 配置EntityManagerFactory -->
	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<!-- hibernate相关的属性的注入 -->
				<!-- 配置数据库类型 -->
				<property name="database" value="MYSQL" />
				<!-- 正向工程 自动创建表 -->
				<!-- <property name="generateDdl" value="true" /> -->
				<!-- 显示执行的SQL -->
				<property name="showSql" value="true" />
			</bean>
		</property>
		<!-- 扫描实体的包 -->
		<property name="packagesToScan">
			<list>
				<value>com.bjbs.pojo</value>
			</list>
		</property>
	</bean>

	<!-- 配置Hibernate的事务管理器 -->
	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

	<!-- 配置开启注解事务处理 -->
	<tx:annotation-driven transaction-manager="transactionManager" />

	<!-- 配置springIOC的注解扫描 -->
	<context:component-scan base-package="com.bjbs.service" />

	<!-- Spring Data JPA 的配置 -->
	<!-- base-package: 扫描dao接口所在的包 -->
	<jpa:repositories base-package="com.bjbs.dao" />
</beans>

10. 数据库user表

11. 测试添加用户方法 

12. 测试批量添加用户方法 

13. 测试根据id查询用户方法 

14. 测试更新用户方法

15. 测试查询所有用户 

16. 测试根据用户id删除用户 

17. 测试根据用户删除用户, 必须设置用户id 

18. 测试批量删除用户 

JPA中的多对多
qq_42836176的博客
12-05 1845
4.1 示例分析 我们采用的示例为用户和角色。 用户：指的是咱们班的每一个同学。 角色：指的是咱们班同学的身份信息。 比如A同学，它是我的学生，其中有个身份就是学生，还是家里的孩子，那么他还有个身份是子女。 同时B同学，它也具有学生和子女的身份。 那么任何一个同学都可能具有多个身份。同时学生这个身份可以被多个同学所具有。 所以我们说，用户和角色之间的关系是多对多。 4.2 表关系建立 多对多的表关...
Spring Data jpa 多对多关系使用
weixin_45854365的博客
05-05 256
user实体类 import com.fasterxml.jackson.annotation.JsonFormat; import com.fasterxml.jackson.annotation.JsonIgnoreProperties; import io.swagger.annotations.ApiModel; import io.swagger.annotations.ApiModel...
SpringData JPA的多对多操作
OceanStar的博客
01-19 686
明确表关系 用户和角色之间的关系是多对多。 多对多的表关系建立靠的是中间表，其中用户表和中间表的关系是一对多，角色表和中间表的关系也是一对多，如下图所示： 实体类关系建立以及映射配置 1、创建一个不使用maven的模块 2、引入pom坐标 <properties> <spring.version>4.2.4.RELEASE</spring.ver...
SpringDataJpa多对多关联关系
Mr_chen的博客
11-19 1016
SpringDataJpa多对多关联关系 前言 案例Github地址(可以用git clone 到本地) 今天为大家分享：SpringDataJpa多对多关联关系。 前面讲了SpringDataJpa自定义查询语句(JPQL)，请查看博主的SpringDataJpa系列文章。欢迎关注！ 多对多实体关系 我们来介绍一下表与表之间的多对多关系。这种关系在CRM管理系统中用的非常多（比如：用户和角...
Spring Data JPA 多对多
weixin_42494845的博客
08-24 315
一个用户可以有多个角色 一个角色也可以有多个用户 用户和角色为多对多关系 表关系建立 用户类 package domain; import javax.persistence.*; import java.util.HashSet; import java.util.Set; @Entity @Table(name = "user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
六、Spring Data JPA多对多操作
a2231476020的博客
06-26 2369
1、多对多表的保存操作 实体类： @Entity @Table(name = "sys_user") public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) @Column(name="user_id") private Long userId; @Column...
spring-data-jpa-examples-master.rar_spring data jpa
09-19
【标题】"spring-data-jpa-examples-master.rar_spring data jpa" 提供了一个关于Spring Data JPA的实际应用示例，这是一个广泛使用的Java框架，它简化了与数据库的交互，特别是通过JPA（Java Persistence API）进行...
毕业设计&课设_Spring Data JPA 与 MySQL postgreSQL 交互实现 CRUD API 示例.zip
最新发布
11-15
本项目旨在通过Spring Data JPA与MySQL和PostgreSQL这两种流行的开源数据库进行交互，实现创建、读取、更新和删除（CRUD）操作的API示例，为计算机科学与技术领域的专业人士提供了一个实践平台。 在该项目中，...
filesystem-master_java_springdatajpa_springboot_hibernate_文件服务器_
10-03
标题 "filesystem-master_java_springdatajpa_springboot_hibernate_文件服务器_" 暗示了一个项目，它涉及使用Java技术栈，特别是Spring Data JPA、Spring Boot和Hibernate，来构建一个文件服务器。这个项目可能重点...
zk_spring_jpa_todo.rar_jpa_spring jpa zk_zk_zk todo.zip_zk bs
09-22
2. **Repository**：创建一个`TodoRepository.java`接口，继承自Spring Data JPA的`JpaRepository`，提供基本的CRUD操作。 3. **服务层**：创建`TodoService.java`，用于业务逻辑处理，调用Repository进行数据库...
JPA一对一，一对多，多对多关系映射
05-14
JPA一对一，一对多，多对多关系映射，面向对象领域
Spring-Data-JPA 定义实体类关系:多对多(增删改查)
zhouzhiwengang的专栏
09-10 6067
Spring-Data-JPA 关系描述（多对多）　 实体Book：书籍。 　　实体Author：作者。 　　书籍和作者是多对多的关系。一本书籍可以由很多的作者编写，一个作者也可以编写写很多本书。 　　JPA中使用@ManyToMany来注解多对多的关系，由一个关联表来维护。这个关联表的表名默认是：主表名+下划线+从表名。(主表是指关系维护端对应的表,从表指关系被维护端对应的表)。这个关联表只有两个外键字段，分别指向主表ID和从表ID。字段的名称默认为：主表名+下划线+主表中的...
（三）springDataJPA的一对一，一对多
weixin_43189971的博客
07-14 946
1.常见注解 2.一对多 3.多对一
SpringDataJPA-3
ginger_mr的博客
09-19 344
文章目录Specifications动态查询1.使用Specifications完成条件查询2.方法对应关系多表设计1.表之间关系的划分2.在JPA框架中表关系的分析步骤JPA中的一对多1.示例分析2.表关系建立3.实体类关系建立以及映射配置4.映射的注解说明5.一对多的操作JPA中的多对多1.示例分析2.表关系建立3.实体类关系建立以及映射配置4.映射的注解说明5.多对多的操作Spring Data JPA中的多表查询1.对象导航查询 Specifications动态查询 有时我们在查询某个实体的时候，给
一篇文章带你搞定 SpringDataJpa 中的多对多的多表设计
南淮北安的博客
07-20 1322
前面已经学习了：一篇文章带你搞定 SpringDataJpa 中的一对多的多表设计 本篇文章来学习SpringDataJpa 中的多对多的多表设计 文章目录一、前期配置二、多对多放弃维护权三、级联添加三、级联删除 一、前期配置 案例：用户和角色（多对多关系） 用户 角色 分析步骤： 明确表关系：多对多关系 确定表关系（描述 外键|中间表）：中间间表 编写实体类，再实体类中描述表关系（包含关系） 用户：包含角色的集合 角色：包含用户的集合 配置映射关系 （1）实体类 User： @Entity
SpringDataJpa的使用 -- 一对一、一对多、多对多 关系映射
十七的博客
07-06 1301
SpringDataJpa的使用 -- 一对一、一对多、多对多 关系映射
springdataJPA 一对一
m0_64892750的博客
04-06 1204
导入依赖 <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-jpa</artifactId> </dependency> <!-- https://mvnrepository.com/artifact/junit/junit --> <dep
Spring Data JPA -- 多表操作(一对多)
qq_42109746的博客
02-24 1380
前言 在实际的开发中，一对多是家常便饭。举个栗子，比如一个部门，在部门里面包含了多个员工，其中，部门就是一，而员工当然就是多。接下来就以这个栗子进行开发。 以下是我所用到的表数据： 表employee: 表department： 1.新建两个实体类 Employee类： package com.chen.domain.entity; import lombok.Getter;...
Spring Boot与Spring Data JPA的CRUD实践教程
- 使用Spring Data JPA提供的Repository接口（比如JpaRepository）实现对数据库的CRUD操作。 - 学习使用Repository接口中预定义的方法进行增删改查。 - 自定义Repository接口方法来实现特定的业务逻辑。 4. Web...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值