SpringBoot集成JPA实现分页和CRUD

已于 2023-11-05 12:29:35 修改
阅读量230 收藏
点赞数
文章标签： spring boot 后端 java
于 2023-11-04 10:59:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41298636/article/details/134215411
版权

SpringBoot集成JPA实现分页和CRUD

文章目录


在这里插入图片描述
在这里插入图片描述
懒得敲代码，直接拷贝： SpringBoot集成JPA实现分页和CRUD

pom.xml

<?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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.moon</groupId>
    <artifactId>springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot</name>
    <description>springboot</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-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

        <!--要使用jsp添加这个-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <scope>provided</scope>
        </dependency>

        <!--数据库-->
        <!-- mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.30</version>
        </dependency>

        <!-- jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

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

</project>

application.properties

填自己的数据库和密码

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8
spring.datasource.username=
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.properties.hibernate.hbm2ddl.auto=update

###########################redis#########################
#Redis数据库索引（默认为0）
spring.redis.database=0
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=10
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
#连接池中的最大空闲连接
spring.redis.pool.max-idle=8
#连接池中的最小空闲连接
spring.redis.pool.min-idle=0
#连接超时时间（毫秒）
spring.redis.timeout=0

spring.jpa.show-sql=true

addCategory.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<div style="margin: 0px auto; width: 500px">
    <form action="updateCategory" method="post">
        name:<input name="name" value="${category.name}"><br>
        <button type="submit">提交</button>
    </form>
</div>

editCategory.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" isELIgnored="false"%>

<div style="margin: 0px auto; width: 500px">
    <form action="updateCategory" method="post">
        name:<input name="name" value="${c.name}"><br>
        <input name="id" type="hidden" value="${c.id}">
        <button type="submit">提交</button>
    </form>
</div>

hello.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" isELIgnored="false"%>

<div style="margin: 0px auto; width: 500px">
    <form action="updateCategory" method="post">
        name:<input name="name" value="${c.name}"><br>
        <input name="id" type="hidden" value="${c.id}">
        <button type="submit">提交</button>
    </form>
</div>

listCategory.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>

<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<div align="center"></div>
<div style="width: 500px;margin: 20px auto;text-align: center">
    <table align="center" border="1" cellspacing="0">
        <caption>员工<a href="addCategory">添加</a></caption>
        <thead>
        <tr>
            <th>id</th>
            <th>name</th>
            <th>编辑</th>
            <th>删除</th>
        </tr>
        </thead>
        <tbody>
        <c:forEach items="${page.content}" var="c" varStatus="st">
            <tr>
                <td>${c.id}</td>
                <td>${c.name}</td>
                <td><a href="editCategory?id=${c.id}">编辑</a></td>
                <td><a href="deleteCategory?id=${c.id}">删除</a></td>
            </tr>
        </c:forEach>
        </tbody>
    </table>
    <div>
        <a href="?start=0">【首页】</a>
        <a href="?start=${page.number-1}">【上一页】</a>
        <a href="?start=${page.number+1}">【下一页】</a>
        <a href="?start=${page.totalPages-1}">【末页】</a>
    </div>
    <div>

    </div>
</div>

Category

package com.moon.springboot.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

/**
 * @Author moon
 * @Date 2023/9/26 21:05
 * @Description
 */
@Entity
@Table(name = "category_")
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Category {
    @Id
    //表明自增长方式
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Integer id;

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

CategoryDAO

package com.moon.springboot.dao;

import com.moon.springboot.pojo.Category;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * @Author moon
 * @Date 2023/9/26 21:18
 * @Description
 * 泛型<Category, Integer> 表示这个是针对Category类的DAO,Integer表示主键是Integer类型。
 * JpaRepository 这个父接口，就提供了CRUD, 分页等等一系列的查询了
 */
public interface CategoryDAO extends JpaRepository<Category, Integer> {
}

CategoryService

package com.moon.springboot.service;

import com.moon.springboot.pojo.Category;
import com.moon.springboot.util.Page4Navigator;
import org.springframework.data.domain.Pageable;

public interface CategoryService {

    public Page4Navigator<Category> list(Pageable pageable);

    public void save(Category category);

    public void delete(int id);

    public Category get(int id);
}

CategoryServiceImpl

package com.moon.springboot.service.impl;

import com.moon.springboot.dao.CategoryDAO;
import com.moon.springboot.pojo.Category;
import com.moon.springboot.service.CategoryService;
import com.moon.springboot.util.Page4Navigator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;



@Service
@CacheConfig(cacheNames="category")
public class CategoryServiceImpl implements CategoryService {

    @Autowired
    CategoryDAO categoryDAO;

    @Override
    @Cacheable(key="'category '+#p0.offset + '-' + #p0.pageSize ")
    public Page4Navigator<Category> list(Pageable pageable) {
        Page<Category> pageFromJPA=  categoryDAO.findAll(pageable);
        Page4Navigator<Category> page = new Page4Navigator<>(pageFromJPA,5);
        return page;
    }

    @Override
    @Cacheable(key="'category '+ #p0")
    public Category get(int id) {
        Category c =categoryDAO.getOne(id);
        return c;
    }

    @Override
    @CacheEvict(allEntries=true)
//  @CachePut(key="'category '+ #p0")
    public void save(Category category) {
        // TODO Auto-generated method stub
        categoryDAO.save(category);
    }

    @Override
    @CacheEvict(allEntries=true)
//  @CacheEvict(key="'category '+ #p0")
    public void delete(int id) {
        // TODO Auto-generated method stub
        categoryDAO.deleteById(id);
    }

}

Page4Navigator

在执行查询方法时，可以传入一个PageRequest对象，代表进行分页查询。
PageRequest对象代表了查询的条件和约束，通常包含当前页数，每页几条数据。
也可以在分页查询时指定Direction或Sort。

查询的结果为Page对象，包含当前页所及所有数据相关信息。
Page对象常用方法：
getTotalPages() 总共有多少页
getTotalElements() 总共有多少条数据
getNumber() 获取当前页码
getSize() 每页指定有多少元素
getNumberOfElements() 当前页实际有多少元素
hasContent() 当前页是否有数据
getContent() 获取当前页中所有数据（List）
getSort() 获取分页查询排序规则
isFirst() 当前页是否是第一页
isLast() 当前页是否是最后一页
hasPrevious() 是否有上一页
hasNext() 是否有下一页

package com.moon.springboot.util;

import java.util.List;

import org.springframework.data.domain.Page;

public class Page4Navigator<T> {
    Page<T> page4jpa;
    //导航分页的页码数
    int navigatePages;

    //要打印的总页数
    int totalPages;

    int number;

    long totalElements;

    int size;

    int numberOfElements;

    List<T> content;

    boolean isHasContent;

    boolean first;

    boolean last;

    boolean isHasNext;

    boolean isHasPrevious;

    int[] navigatepageNums;

    public Page4Navigator() {
        //这个空的分页是为了 Redis 从 json格式转换为 Page4Navigator 对象而专门提供的
    }

    public Page4Navigator(Page<T> page4jpa,int navigatePages) {
        this.page4jpa = page4jpa;
        this.navigatePages = navigatePages;

        totalPages = page4jpa.getTotalPages();

        number  = page4jpa.getNumber() ;

        totalElements = page4jpa.getTotalElements();

        size = page4jpa.getSize();

        numberOfElements = page4jpa.getNumberOfElements();

        content = page4jpa.getContent();

        isHasContent = page4jpa.hasContent();

        first = page4jpa.isFirst();

        last = page4jpa.isLast();

        isHasNext = page4jpa.hasNext();

        isHasPrevious  = page4jpa.hasPrevious();

        calcNavigatepageNums();

    }

    private void calcNavigatepageNums() {
        int navigatepageNums[];
        int totalPages = getTotalPages();
        int num = getNumber();
        //当总页数小于或等于导航页码数时
        if (totalPages <= navigatePages) {
            navigatepageNums = new int[totalPages];
            for (int i = 0; i < totalPages; i++) {
                navigatepageNums[i] = i + 1;
            }
        } else { //当总页数大于导航页码数时
            navigatepageNums = new int[navigatePages];
            int startNum = num - navigatePages / 2;
            int endNum = num + navigatePages / 2;

            if (startNum < 1) {
                startNum = 1;
                //(最前navigatePages页
                for (int i = 0; i < navigatePages; i++) {
                    navigatepageNums[i] = startNum++;
                }
            } else if (endNum > totalPages) {
                endNum = totalPages;
                //最后navigatePages页
                for (int i = navigatePages - 1; i >= 0; i--) {
                    navigatepageNums[i] = endNum--;
                }
            } else {
                //所有中间页
                for (int i = 0; i < navigatePages; i++) {
                    navigatepageNums[i] = startNum++;
                }
            }
        }
        this.navigatepageNums = navigatepageNums;
    }

    public int getNavigatePages() {
        return navigatePages;
    }

    public void setNavigatePages(int navigatePages) {
        this.navigatePages = navigatePages;
    }

    public int getTotalPages() {
        return totalPages;
    }

    public void setTotalPages(int totalPages) {
        this.totalPages = totalPages;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public long getTotalElements() {
        return totalElements;
    }

    public void setTotalElements(long totalElements) {
        this.totalElements = totalElements;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public int getNumberOfElements() {
        return numberOfElements;
    }

    public void setNumberOfElements(int numberOfElements) {
        this.numberOfElements = numberOfElements;
    }

    public List<T> getContent() {
        return content;
    }

    public void setContent(List<T> content) {
        this.content = content;
    }

    public boolean isHasContent() {
        return isHasContent;
    }

    public void setHasContent(boolean isHasContent) {
        this.isHasContent = isHasContent;
    }

    public boolean isFirst() {
        return first;
    }

    public void setFirst(boolean first) {
        this.first = first;
    }

    public boolean isLast() {
        return last;
    }

    public void setLast(boolean last) {
        this.last = last;
    }

    public boolean isHasNext() {
        return isHasNext;
    }

    public void setHasNext(boolean isHasNext) {
        this.isHasNext = isHasNext;
    }

    public boolean isHasPrevious() {
        return isHasPrevious;
    }

    public void setHasPrevious(boolean isHasPrevious) {
        this.isHasPrevious = isHasPrevious;
    }

    public int[] getNavigatepageNums() {
        return navigatepageNums;
    }

    public void setNavigatepageNums(int[] navigatepageNums) {
        this.navigatepageNums = navigatepageNums;
    }

}

RedisConfig

package com.moon.springboot.config;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.*;

import java.time.Duration;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    private RedisSerializer<String> keySerializer() {

        return new StringRedisSerializer();
    }

    private RedisSerializer<Object> valueSerializer() {
        return new GenericJackson2JsonRedisSerializer();//value值使用json序列化器
    }

    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {

        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();

        redisCacheConfiguration = redisCacheConfiguration.entryTtl(Duration.ofMinutes(30L))//设置缓存延时时间为30分钟
                .disableCachingNullValues()//如果是空值，不缓存
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(keySerializer()))//设置key值序列化
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(valueSerializer()));//设置value值序列化为json
        return RedisCacheManager.builder(RedisCacheWriter.nonLockingRedisCacheWriter(factory))
                .cacheDefaults(redisCacheConfiguration).build();

    }
}

CategoryController

package com.moon.springboot.web;

import com.moon.springboot.pojo.Category;
import com.moon.springboot.service.CategoryService;
import com.moon.springboot.util.Page4Navigator;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class CategoryController {
    @Autowired
    CategoryService categoryService;

    @RequestMapping("/listCategory")
    public String listCategory(Model m,@RequestParam(value = "start", defaultValue = "0") int start,@RequestParam(value = "size", defaultValue = "5") int size) throws Exception {
        start = start<0?0:start;
        Sort sort = Sort.by(Sort.Direction.DESC, "id");
        Pageable pageable = PageRequest.of(start, size, sort);
        Page4Navigator<Category> page =categoryService.list(pageable);
        m.addAttribute("page", page);
        return "listCategory";
    }

    @RequestMapping("/addCategory")
    public String addCategory(Category c) throws Exception {
        categoryService.save(c);
        return "redirect:listCategory";
    }
    @RequestMapping("/deleteCategory")
    public String deleteCategory(Category c) throws Exception {
        categoryService.delete(c.getId());
        return "redirect:listCategory";
    }
    @RequestMapping("/updateCategory")
    public String updateCategory(Category c) throws Exception {
        categoryService.save(c);
        return "redirect:listCategory";
    }
    @RequestMapping("/editCategory")
    public String editCategory(int id,Model m) throws Exception {
        Category c= categoryService.get(id);
        m.addAttribute("c", c);
        return "editCategory";
    }
}

HelloController

package com.moon.springboot.web;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.text.DateFormat;
import java.util.Date;

/**
 * @Author moon
 * @Date 2023/9/25 21:17
 * @Description
 */

@Controller
public class HelloController {

    @RequestMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("now", DateFormat.getDateTimeInstance().format(new Date()));
        return "hello";
    }

    @RequestMapping("/hello_1")
    public String hello_1(Model model) {
        model.addAttribute("now", DateFormat.getDateTimeInstance().format(new Date()));
        return "hello_1";
    }
}
lmoon33
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot集成jpa 一篇就够了 超详细
cmx1060220219的博客
05-21 7万+
SpringBoot集成jpa 网上有很对jpa的介绍，但是都不是很全，这边根据公司的实际使用情况进行的总结。 JPA、Hibernate、Spring data jpa之间的关系 主要参考https://my.oschina.net/u/3080373/blog/1828589 大家可以读一下这篇文章 什么是JPA？ 全称Java Persistence API，可以通过注解或者XML描述【对象-关系表】之间的映射关系，并将实体对象持久化到数据库中。 为我们提供了： 1）ORM映射元数据：JPA支持XML
springboot集成jpa
11-07
SpringBoot集成JPA是现代Java应用开发中常见的一种技术组合，它使得数据库操作变得简单而高效。SpringBoot简化了Spring框架的配置，而Java Persistence API (JPA) 则是Java平台上的对象关系映射（ORM）标准，它允许...
SpringBoot集成JPA及基本使用
JingAi_jia917的博客
04-24 1642
本篇从JDBC、ORM、JPA、Spring Data JPA说起，分享了SpringBoot集成JPA的实现、Repository的命名规则以及InvalidDefinitionException异常的处理
SpringBoot 整合 JPA 实现CRUD
码小呆的博客
05-08 790
描述: Spring Data JPA为Java Persistence API（JPA）提供了存储库支持。它简化了需要访问JPA数据源的应用程序的开发。官方文档，请先阅读。 JPA 核心概念: Spring Data存储库抽象中的中央接口是Repository。它需要域类以及域类的ID类型作为类型参数来进行管理。该接口主要用作标记接口，以捕获要使用的类型并帮助您发现扩展该接口的接口 。 该接口中是没有任何的接口方法，所有的操作实现是子接口去实现： @Indexed public interface Rep
SpringBoot集成 JPA 框架 + 基本代码
qq_49139682的博客
10-29 1982
SpringBoot集成 JPA 框架 1.jpa的概述 1.1 什么是jpa呢？ JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 [1] Sun引入新的JPA ORM规范出于两个原因：其一，简化现有Java EE和Java SE应用开发工作；其二，Sun希望整合ORM技术，实现天下归一。 1.2 jpa具有什么优势？ 2.1标准化 JPA 是 JCP 组织发布的 Java E
【SpringBoot新手篇】SpringBoot集成JPA
输入技术、输出想法
04-30 2911
SpringBoot整合JPASpring Boot Jpa 介绍首先了解 Jpa 是什么？Spring Data JPA特征整合SpringData JPAPomymlentityRepositoryUserServiceUserServiceImplcontroller首页展示高级查询功能预先生成方法自定义简单查询复杂查询分页查询限制查询 Spring Boot Jpa 介绍 首先了解 Jpa 是什么？ Jpa (Java Persistence API)是 Sun官方提出的Java 持久化规范。它为
springboot JPA（CRUD+分页）
m0_65995252的博客
06-11 194
Spring Boot JPA是一种流行的Java框架，它提供了快速开发Web应用程序的工具和功能。它是一个基于Spring框架的开源项目，可以帮助开发人员轻松地创建基于Java的应用程序。Spring Boot JPA还提供了与Hibernate等ORM框架的集成，使开发人员能够更轻松地管理数据库和数据访问。它还提供了许多其他功能，如自动配置和嵌入式服务器，以简化开发过程。总之，Spring Boot JPA是一个非常有用的框架，可以帮助开发人员快速构建高质量的Java应用程序。
SpringBoot快速集成JPA
何哥的博客
09-23 679
前言：一说JavaWeb，很多小伙伴都知道SSH，这个H代表的就是Hibernate框架，可是什么又是JPA呢？相信许多刚入门的小伙伴听说过但不是特别清楚，首先JPA的全称叫做Java Persistence API，JPA是一个基于O/R映射的标准规范，在这个规范中，JPA只定义标准规则，不提供实现，使用者则需要按照规范中定义的方式来使用。目前JPA的主要实现有Hibernate、EclipseLink、OpenJPA等，事实上，由于Hibernate在数据访问解决技术领域的霸主地位，JPA的标准基本是由
Springboot集成Mybatisplus,轻松CRUD
09-09 1309
作为业务开发，和数据库交互，对业务数据进行CRUD的操作就是项目中最常见的要求了，从最原始的JDBC的操作，到现在的最广泛的JPA，Hibernete， MyBatis等ORM的架构；无不都是在实现和数据库进行交互的实现；在我们的业务开发里，数据库作为业务数据和用户数据的最终落地的归宿；使得我们的数据库CRUD操作成为一个程序员不可缺少的工作要求；虽然笔者觉得CRUD是个不需要太多技术要求的工作；但是作为程序员我们还是必须掌握这个技巧；
【SpringBoot整合JPA框架（hibernate实现）详解】（附详细代码）
qq_45759093的博客
02-20 2918
Java Persistence API（JPA）是Java EE和Java SE平台的一部分，提供了一种简单的对象关系映射（ORM）机制，用于将Java对象持久化到关系型数据库中。JPA通过注解或XML配置文件实现实体类与数据库表之间的映射，简化了数据库操作的过程。
SpringBoot+JPA
04-03
- 创建Repository接口：基于JpaRepository或CrudRepository，自定义方法即可自动实现相应的CRUD操作。 5. **自动配置** SpringBoot的自动配置会根据添加的依赖，自动配置相关的bean，如EntityManagerFactory、...
SpringBoot+JPA + Security +分页
04-12
通过`spring-boot-starter-data-jpa`起步依赖，我们可以轻松地集成JPA（Java Persistence API），这是一个用于操作数据库的ORM（对象关系映射）标准，它简化了数据库操作。 JPA是Java EE的一部分，它允许我们用面向...
springboot-jpa
11-16
本文将深入探讨如何在Spring Boot项目中集成JPA，实现数据库操作的便捷与高效。 ### 1. Spring Boot与JPA简介 Spring Boot是Spring框架的扩展，旨在简化Spring应用的初始搭建以及开发过程。它提供了一种快速开发新...
Spring Boot
hai40587的博客
08-02 1136
在处理 Spring Boot 应用中的循环依赖问题时，重要的是要保持清晰的头脑和耐心。首先，要仔细分析问题的成因和上下文环境；其次，要尝试多种解决方案并评估其优缺点；最后，要关注应用的性能和稳定性，确保所采取的解决方案不会对应用产生负面影响。通过不断地学习和实践，我们可以逐渐掌握处理循环依赖的技巧和方法，为构建高性能、稳定的 Spring Boot 应用打下坚实的基础。
【Spring Boot】配置 Spring Security
书山有路，学海无涯。记录成长，追逐梦想
08-02 906
Spring Security 提供了声明式的安全访问控制解决方案（仅支持基于 Spring 的应用程序），对访问权限进行认证和授权，它基于 Spring AOP 和 Servlet 过滤器，提供了安全性方面的全面解决方案。
基于Spring boot + Vue的灾难救援系统
NPCS_JQ的博客
08-02 459
以脚手架项目为基础完成的1.主页：echarts展示的图表2.系统管理：用户管理，角色管理，字典管理，菜单管理，日志管理3.文件管理：生成文件4.文章管理：集合富文本写文章5.公告管理：公告的管理6.轮播图管理：前台首页的轮播图7.灾难类型管理8.灾难记录9..资源调度10.预案管理11.科普信息。
Spring Boot 实现异步处理多个并行任务
心猿意码
08-02 526
在现代Web应用开发中，异步处理和多任务并行处理对于提高系统的响应性和吞吐量至关重要。Spring Boot 提供了多种机制来实现异步任务处理，本文将介绍如何利用这些机制来优化您的应用程序性能。
Spring Boot常用注解
最新发布
东皋长歌的专栏
08-03 1462
Component注解是一个通用的注解，可以用来标注任何Spring管理的bean，像@Service，@Controller，@Repository都是@Component注解的别名。用途：@Data是一个复合注解，集成了@Getter，@Setter，@ToString，@EqualsAndHashCode，@RequiredArgsConstuctor等注解。用途：用于标识控制层组件，是@Component注解的别称，用于标识Spring MVC控制器，处理Web请求并返回视图。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值