使用eclipse搭建spring-data-jpa项目 条件 分页 排序查询 事务

最新推荐文章于 2022-06-11 08:10:21 发布
最新推荐文章于 2022-06-11 08:10:21 发布
阅读量363 收藏
点赞数
分类专栏： Spring学习 文章标签： spring jpa eclipse java mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/linzeyang1997/article/details/111385886
版权

内容

我们要做什么

这篇文章是我借助Spring框架搭建的一个spring-data-jpa的后端demo，可以带条件并分页查询数据库记录，支持事务，希望对你有帮助。
Eclipse的朋友可以使用STS来快速构建你的spring项目，在Eclipse上方工具栏，点击Help-> Eclipse Marketplace, 搜索STS，那个Spring Tool Suite就是。Install之后，重启Eclipse, 你就可以像在IDEA里面一样快速生成一个spring项目啦！
在Eclipse Marketplace里搜索STS, 下载Spring项目开发套件(spring tool suite)
Eclipse新建spring starter project

你需要有这些准备

  • 可以联网的电脑 (能科学上网更佳)
  • 配置好JDK和Maven的Eclipse环境
  • 对spring-data框架有一定了解

代码及相关配置文件

pom文件

<?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"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>org.lzy.example</groupId>
	<artifactId>backend-practice</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>backend-practice</name>
	<description>Demo project for Spring Boot</description>

	 <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
         <java.version>1.8</java.version>
    </properties>

	<dependencies>
	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot</artifactId>
			<version>2.2.12.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
			<version>2.2.12.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
			<version>2.2.12.RELEASE</version>
		</dependency>
		
		 <dependency>
        	<groupId>com.alibaba</groupId>
        	<artifactId>druid</artifactId>
        	<version>1.0.29</version>
        </dependency>
        
        <dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>8.0.22</version>
	</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<version>2.2.12.RELEASE</version>
			<exclusions>
				<exclusion>
					<groupId>org.junit.vintage</groupId>
					<artifactId>junit-vintage-engine</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

application.properties文件

Spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
Spring.datasource.driverClassName=com.mysql.cj.jdbc.Driver
Spring.datasource.url=jdbc:mysql://[YOUR_DATABASE_URL_HERE]:3306/[YOUR_DATABASE_NAME_HERE]?characterEncoding=utf8
Spring.datasource.username=[YOUR_USERNAME_HRER]
Spring.datasource.password=[YOUR_PASSWORD_HRER]
Spring.jpa.properties.hibernate.show_sql=true
Spring.jpa.properties.hibernate.format_sql=true
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl

mysql数据库建表

Customer表

FieldTypePrimaryKeyauto_increment
idint主键自增
firstNamevarchar
lastNamevarchar

TrainInfo表

FieldTypePrimaryKeyauto_increment
idint主键自增
trainNumbervarchar
trainLeaveTimedate
trainStartStationvarchar

TicketRecord表

FieldTypePrimaryKeyauto_increment
idint主键自增
passengerNamevarchar
trainNumbervarchar

整体项目结构

package structure

各个代码文件

Customer.java

package org.lzy.example.entity;
import java.io.Serializable;

import javax.persistence.*;



// because no @Table annotation exists, it is assumed that this
// entity is mapped to a table named Customer
@Entity
public class Customer  implements Serializable {
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Long id;
	private String firstName;
	private String lastName;
	
	
	// for the sake of JPA
	protected Customer() {}
	
	public Customer(String firstName, String lastName) {
		this.firstName = firstName;
		this.lastName = lastName;
	}

	public Long getId() {
		return id;
	}

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

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	@Override
	public String toString() {
		return "Customer [id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + "]";
	}
	
	
}

TicketRecord.java

package org.lzy.example.entity;

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

@Entity
public class TicketRecord {
	
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Integer id;
	
	private String passengerName;
	
	private String trainNumber;

	public Integer getId() {
		return id;
	}

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

	public String getPassengerName() {
		return passengerName;
	}

	public void setPassengerName(String passengerName) {
		this.passengerName = passengerName;
	}

	public String getTrainNumber() {
		return trainNumber;
	}

	public void setTrainNumber(String trainNumber) {
		this.trainNumber = trainNumber;
	}

	public TicketRecord(String passengerName, String trainNumber) {
		super();
		this.passengerName = passengerName;
		this.trainNumber = trainNumber;
	}
	

}

TrainInfo.java

package org.lzy.example.entity;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@Entity
public class TrainInfo  implements Serializable {
	@Id 
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	private Integer id;
	
	@Temporal(TemporalType.TIMESTAMP)
	private Date trainLeaveTime;
	
	private String trainStartStation;
	
	private String trainNumber;

	public Integer getId() {
		return id;
	}

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

	public Date getTrainLeaveTime() {
		return trainLeaveTime;
	}

	public void setTrainLeaveTime(Date trainLeaveTime) {
		this.trainLeaveTime = trainLeaveTime;
	}

	public String getTrainStartStation() {
		return trainStartStation;
	}

	public void setTrainStartStation(String trainStartStation) {
		this.trainStartStation = trainStartStation;
	}

	public String getTrainNumber() {
		return trainNumber;
	}

	public void setTrainNumber(String trainNumber) {
		this.trainNumber = trainNumber;
	}
	
}

CustomerRepository.java

package org.lzy.example.repository;

import org.lzy.example.entity.Customer;
import org.springframework.data.repository.CrudRepository;
import java.util.List;

public interface CustomerRepository extends CrudRepository<Customer, Long> {
	List<Customer> findByLastName(String lastName);
	
	Customer findById(long id);
}

TicketRecordRepository.java

package org.lzy.example.repository;

import org.lzy.example.entity.TicketRecord;
import org.springframework.data.repository.CrudRepository;

public interface TicketRecordRepository extends CrudRepository<TicketRecord, Long> {
	
}

TrainInfoRepository.java

package org.lzy.example.repository;

import java.util.List;

import org.lzy.example.entity.TrainInfo;
import org.springframework.data.domain.Pageable;
import org.springframework.data.repository.PagingAndSortingRepository;
import org.springframework.data.repository.query.Param;

public interface TrainInfoRepository extends PagingAndSortingRepository<TrainInfo, Long> {
	
	List<TrainInfo> findByTrainNumber(String trainNumber);
	
	List<TrainInfo> findByTrainStartStation(String station, Pageable pageable);
}

NoThisTrainException.java

package org.lzy.example.exception;

public class NoThisTrainException extends RuntimeException {
	// 有参构造器
	public NoThisTrainException(String message){ 
		super(message); 
		}
	
}

CustomerServiceController.java

package org.lzy.example.controller;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.lzy.example.entity.Customer;
import org.lzy.example.repository.CustomerRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class CustomerServiceController {
	
	@Autowired
	private CustomerRepository customerRepository;
	
	@RequestMapping("/customer/add")
	public Map<String, Object> add(@RequestBody(required=false) Customer customer){
		Map<String, Object> resultMap = new HashMap<String, Object>();
		
		customerRepository.save(customer);
		resultMap.put("msg", "ok");
		return resultMap;
		
	}
	
	@RequestMapping("/customer/query_all")
	public Map<String, Object> query_all(){
		Map<String, Object> resultMap = new HashMap<String, Object>();
		
		List<Customer> allCustomers = (List<Customer>) customerRepository.findAll();
		resultMap.put("msg", "ok");
		resultMap.put("data", allCustomers);
		resultMap.put("total", allCustomers.size());
		return resultMap;
		
	}
}

TrainServiceController.java

package org.lzy.example.controller;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.lzy.example.entity.TicketRecord;
import org.lzy.example.entity.TrainInfo;
import org.lzy.example.exception.NoThisTrainException;
import org.lzy.example.repository.CustomerRepository;
import org.lzy.example.repository.TicketRecordRepository;
import org.lzy.example.repository.TrainInfoRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.domain.Sort.Order;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TrainServiceController {
	
	@Autowired
	private CustomerRepository customerRepostitory;
	
	@Autowired
	private TrainInfoRepository trainInfoRepository;
	
	@Autowired
	private TicketRecordRepository ticketRecordRepository;
	
	@RequestMapping("/trainService/query/station/{stationName}/{page}/{size}")
	public Map<String, Object> queryStation(@PathVariable("stationName") String station, 
			@PathVariable("page") Integer page,
			@PathVariable("size") Integer size) {
		Map<String, Object> returnMap = new HashMap<String, Object>();
        PageRequest pageRequest =  PageRequest.of(page-1, size,Direction.DESC, "trainLeaveTime", "trainNumber");
		List<TrainInfo> t = trainInfoRepository.findByTrainStartStation(station, pageRequest);
		returnMap.put("data", t);
		returnMap.put("total", t.size());
		returnMap.put("page", page);
		returnMap.put("size", size);
		
		return returnMap;
	}
	
	@Transactional
	@RequestMapping("/trainService/order/submit/{train_no}/{p_name}")
	public Map<String, Object> submitTrainTicketOrder(@PathVariable("train_no") String trainNumber,
			@PathVariable("p_name") String passengerName){
		Map<String, Object> returnMap = new HashMap<String, Object>();
		//1  向TicketRecord表插入一条购票记录
		TicketRecord tr = new TicketRecord(passengerName, trainNumber);
		ticketRecordRepository.save(tr);
		
		//2  在TrainInfo表里查询是否有这趟列车存在
		String resultStatus = "购票失败";
		List<TrainInfo> ti = trainInfoRepository.findByTrainNumber(trainNumber);
//		System.out.println(ti.size());
		if (ti.size() != 0)
			resultStatus = "购票成功";
		else
			throw new NoThisTrainException("查询不到该趟列车！");
		
		
		returnMap.put("result", resultStatus);
		return returnMap;
		
		
	}

}

BackendPracticeApplication.java

package org.lzy.example;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class BackendPracticeApplication {

	public static void main(String[] args) {
		SpringApplication.run(BackendPracticeApplication.class, args);
	}

}

记录我遇到的坑

  1. entity的那些类一定不要忘记生成setter/gettter方法，否则在controller里的getContent()只会记录元素个数，不会显示出内容！！
  2. 数据库表最好把主键设置为自增，然后GenerationType用IDENTITY。
  3. 之前我自己而外在entity的类前加上@Table(name=“Customer”), 但是这样做它有时还是会显示Table ‘xxx.Customer’ does not exist, 所以我干脆不要这个注释了，但是application.properties里面别忘了
spring.jpa.hibernate.naming.physical-strategy=org.hibernate.boot.model.naming.PhysicalNamingStrategyStandardImpl
  1. TrainServiceController.java这个类里的submitTrainTicketOrder方法，如果不加@Transactional注解，好像是不能支持事务的。大家可以自己测试一下。
  2. 下面这行代码产生的 ti 不能使用 == null 来判断是否查询到记录(即使查不到它也不为null), 应该用 ti.size() != 0来判断，血的教训。。。
List<TrainInfo> ti = trainInfoRepository.findByTrainNumber(trainNumber);
// 如果查询不到记录
//  System.out.println(ti.size());  0
//  System.out.println(ti==null);  false
  1. 【补充】如果你突然遇到 No default constructor for entity 这个报错，看看实体类里有没有空构造器，没有的话创建一个 protected Xxxx() {} 然后再运行试试？

谢谢大家的捧场，如果有任何问题可以留言，我会时不时回来看的。

ErrorPlayer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
用Eclipse生成JPA元模型的方法
08-29
下面小编就为大家带来一篇用Eclipse生成JPA元模型的方法。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring-data-jpa：简化了创建基于JPA的数据访问层的开发
02-03
- **依赖管理**：在项目中添加Spring Data JPA和JPA供应商（如Hibernate、EclipseLink）的依赖。 - **配置数据源**：配置数据源连接，包括数据库URL、用户名、密码等。 - **配置JPA**：设置实体扫描路径，指定JPA...
Elicpse中搭建SpringData+jpa
wazz753的专栏
05-17 446
Elicpse中搭建SpringData+jpa 首选先附上整个案例的工程结构图 jpa_springData_test1 src com.lhc.bean Dept6.java com.lhc.dao DeptDao3.java DeptDao3Impl.java IDeptDao.java IDeptDao2.java MyRepository.java com.lhc
Eclipse中搭建spring+jpa
wazz753的专栏
05-17 455
Eclipse中搭建spring+jpa   Spring JPA通过为用户统一创建和销毁EntityManager，进行事务管理，简化JPA的配置等使用户的开发更加简便。   创建一个java项目或web项目   添加jar包 antlr-2.7.7.jar c3p0-0.9.2.1.jar com.springsource.net.sf.cglib-2.2.0.j
Spring Boot：整合Spring Data JPA
朝雨忆轻尘
06-18 178
综合概述 JPA是Java Persistence API的简称，是一套Sun官方提出的Java持久化规范。其设计目标主要是为了简化现有的持久化开发工作和整合ORM技术，它为Java开发人员提供了一种ORM工具来管理Java应用中的关系数据。 简而言之，JPA提供了使用面向对象的方式操作数据库的功能。JPA充分吸收了现有Hibernate，TopLink，JDO等ORM框架的优势，具有易于使用、...
在eclipse上使用springboot集成springdata JPA将数据库的内容分页显示到网页上
weixin_42311416的博客
09-10 722
springboot使用springdata JPA连接数据库开始接触springboot新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchar...
spring-data-JPA帮助文档
07-21
Spring Data JPA的动态查询功能允许开发者在运行时构建查询，例如通过Specification接口，可以创建复杂的查询条件，动态地组合多个条件。 九、事件监听 Spring Data JPA支持实体生命周期事件的监听，如@PrePersist...
spring-data-jpa-master.rar
10-15
《Spring Data JPA 深度解析与实战指南》 Spring Data JPA 是 ...通过深入学习和实践 Spring Data JPA，开发者可以更好地利用 JPA 的优势，减少数据库操作的繁琐工作，专注于业务逻辑，提升项目开发的效率和质量。
Spring-Data-JPA:Spring Data JPA的一个demo
05-29
在项目中使用Spring Data JPA，首先需要在Maven或Gradle的依赖管理中引入Spring Data JPA和所选的JPA提供商（如Hibernate、EclipseLink等）。接着，配置`persistence.xml`文件或使用Spring Boot的自动配置来设置...
spring-data-commons-1.7.2.RELEASEspring-data-jpa-1.5.2.RELEASE-java datajpa
09-11
5. **Integration with ORMs**：Spring Data JPA 可以与各种 JPA 实现（如 Hibernate、EclipseLink 等）配合使用，为不同的 ORM 解决方案提供统一的编程模型。 6. **Custom Query Methods**：开发者可以定义自己的...
分页显示（java+jsp+eclipse+tomcat）
07-31
1、定义的数据库连接类，实现了数据库连接、查询、修改等操作； 2、定义的分页显示类，对分页进行处理； 3、jsp文件进行分页显示； （已测试成功，希望能帮到各位）
eclipse基于mysql分页的方法实现
10-22
eclipse基于mysql分页的方法实现
在Eclipse下搭建JPA项目(HIbernate + MySQL)
oscar999的专栏
06-03 1117
Hibernate 作为使用最为广泛的ORM框架，　也是Spring框架默认使用的JPA实现。Hibernate + MySQL组合也是实战开发中使用最为常见的组合。 本篇介绍基于Eclipse 的Hibernate+MySQL的JPA项目的搭建
用eclipse写的一个简单的JPA例子
fei的专栏
05-17 3287
首先新建一个JPA工程：
eclipse中搭建springboot学习（11）---JPA使用4（分页查询）
Gr_lbxx的博客
10-26 344
StudentScoreService添加方法 /**      * 分页查询 无查询条件      *       * @param page      * @param size      * @return      */     public Page&lt;StudentDTO&gt; findStudent(Integer page, Integer size) {        ...
eclipse和MySQL分页查询_分页查询信息eclipse+jdbc+mysql.docx
weixin_39628041的博客
01-26 195
分页查询信息eclipsejdbcmysql分页查询信息 使用jdbc连接mysql数据库实现分页查询任务通过mysql数据库提供的分页机制，实现商品信息的分页查询功能，将查询到的信息显示到jsp页面上。本项目时一个简单的运用eclipse+jdbc+mysql的小程序。连接的数据库名称为db_database11，属性如下： 1.创建名为com.pmf.bean的包，包中是名为Prod...
SpringData示例
这是一个开始认识世界的博客
06-01 2385
网址:https://blog.csdn.net/xubaifu1997/article/details/66476446最终参考网址https://blog.csdn.net/linzhiqiang0316/article/details/52609162此处我使用 Intellij 的 spring initializer 创建上图为我添加的依赖这部分内容主要是自动生成实体类所需要的内容先绑定...
快速搭建JPA开发环境 （Eclipse+Maven+EclipseLink+MySQL）
oscar999的专栏
06-11 752
本篇介绍如何在Windows快速搭建一个最简洁的JPA开发的环境。 * 开发工具： Eclipse * JPA实现： EclipseLink * 依赖管理工具：Maven * 数据库 : MySQL
Spring Data JPA介绍与Spring的整合
Charge8的博客
07-06 521
一、JPA 、Hibernate、Spring Data JPA与Spring Data简介 1、什么是JPA？ JPA（Java Persistence API）是Sun官方提出的Java持久化API规范。可以通过JDK 5.0注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持久化到数据库中。主要是为了简化现有的持久化开发工作和整合ORM技术，使得应用程序以统一的方式访问持久层。 2、什么是Hibernate？ Hibernate 是一个开源的全自动的ORM框架，它对JDBC进行了非
JDBC中的分页查询
Coder_Hello_World的博客
11-19 343
工具:Myeclipse(Eclipse): 知识点:JDBC中的分页 jar包: commons-collections4-4.0.jar commons-dbcp-1.4.jar commons-pool-1.6.jar Oracle 11g 11.2.0.1.0 JDBC_ojdbc6.jar 代码都是基于自己写的连接池技术,,已经分享过了 url:http://blog

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值