Spring Data JPA介绍与CRUD实战演练

于 2024-06-21 19:32:58 发布
阅读量975 收藏 27
点赞数 27
分类专栏： Java项目 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zcs2312852665/article/details/139868219
版权

文章目录

一、Spring Data JPA 简介

Spring Data JPA 是 Spring 框架中的一个模块，它旨在简化 Java Persistence API (JPA) 的使用，进而简化数据访问层的开发。JPA 是 Java 平台上用于管理关系数据库的对象关系映射(ORM)的标准。而 Spring Data JPA 在此基础之上提供了额外的抽象层，允许开发者以更简洁的方式编写数据访问代码，无需手动编写大量的实现代码。

核心特点包括：

  1. 简化 CRUD 操作：通过继承 JpaRepository 或其他 Spring Data 提供的接口，你可以直接在自定义的 Repository 接口中声明方法，而无需编写实现。Spring Data JPA 会根据方法名自动生成查询语句。

  2. 方法命名查询：依据一定的命名规则，Spring Data JPA 能够根据 Repository 接口中的方法名称自动生成 SQL 或 HQL 查询语句，例如 findByUsernameAndPassword 会自动转换为寻找匹配用户名和密码的查询。

  3. 查询DSL：除了方法命名查询，它还提供了强大的查询dsl（领域特定语言），允许构建类型安全的复杂查询。

  4. 分页与排序：轻松实现数据的分页查询和排序功能。

  5. 事务管理：集成 Spring 的事务管理，使得数据操作更加安全可靠。

  6. 动态查询：支持 Criteria API 和 Specifications，可以构建复杂的动态查询条件。

  7. 减少样板代码：大量减少了传统 JPA 开发中需要编写的 DAO 层实现代码，提高开发效率。

  8. 扩展性：虽然提供了很多开箱即用的功能，但同时也允许开发者自定义查询逻辑，保持了高度的灵活性。

通过这些特性，Spring Data JPA 成为了快速开发 Java 应用，特别是那些需要与关系型数据库交互的应用的首选框架之一。开发者只需关注业务逻辑，而不必过多担忧数据访问层的细节。

二、Spring Data JPA 与 MyBatis Plus 比较

Spring Data JPA 和 MyBatis Plus 是两种不同的持久层框架，它们各有特色，适用于不同场景和需求。以下是它们之间的一些关键区别：

设计哲学和抽象层次

  • Spring Data JPA 基于 JPA 规范，提供了高度抽象的数据访问层，允许开发者以面向对象的方式操作数据库，减少了直接编写 SQL 的需要。它通过方法命名约定来自动生成查询，支持实体映射和事务管理，更适合那些希望快速开发、遵循 Java EE 标准且偏好 ORM（对象关系映射）的项目。

  • MyBatis Plus 则是对 MyBatis 的增强，它依然保留了 MyBatis 手动编写 SQL 的灵活性，同时加入了许多开箱即用的功能，如常见的 CRUD 操作、分页、性能优化等。MyBatis Plus 更加适合需要高度定制 SQL 查询、对性能有严格要求或者需要直接控制 SQL 执行的场景。

SQL 控制

  • Spring Data JPA 主要通过方法命名约定来自动生成 SQL，虽然也支持 @Query 注解来自定义 SQL，但其强项在于无须编写 SQL 即可完成大部分 CRUD 操作。

  • MyBatis Plus 支持 SQL 的完全自定义，这为开发者提供了更大的灵活性，特别是在处理复杂的联表查询和性能优化时更为明显。它还提供了 MapKey 注解等特性，便于在多表关联查询中进行数据关联。

学习曲线和技术要求

  • Spring Data JPA 因其高度抽象，初学者可能更容易上手，但深入理解和调试 ORM 映射问题可能需要更多专业知识。

  • MyBatis Plus 虽然需要手动编写 SQL，但对 SQL 较熟悉的开发者可能会觉得这种方式更直接、可控，学习成本相对较低，尤其是在已有 MyBatis 使用经验的基础上。

性能与优化

  • Spring Data JPA（及底层的 Hibernate）由于其抽象层次较高，可能会在某些简单查询上略逊于直接编写 SQL 的框架。但它提供了缓存管理、延迟加载等特性，对提高整体应用性能有帮助。

  • MyBatis Plus 直接控制 SQL，因此在查询优化和性能调优上有更多空间，特别是对于复杂的查询场景，能够通过精确控制 SQL 来达到更好的性能。

综合考虑

选择 Spring Data JPA 还是 MyBatis Plus，通常取决于项目的需求、团队的技术栈偏好以及对 SQL 控制的需求程度。如果项目追求快速开发、代码的简洁性，且对 SQL 的直接控制需求不高，Spring Data JPA 是个不错的选择。相反，如果项目需要复杂的 SQL 查询、高度的性能优化，或者团队更倾向于 SQL 的直接操控，MyBatis Plus 可能更加合适。在实际应用中，两者并非互斥，根据具体模块的需求混合使用也是常见做法。

三、SpringDataJpa实战演练

1. 创建user表

CREATE TABLE `user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(50) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=130 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci

2. 搭建Spring Boot开发环境

目录结构如下：

springboot-template-jpa
│  pom.xml
│  springboot-template-jpa.iml
│
├─src
│  └─main
│      ├─java
│      │  └─com
│      │      └─zcs
│      │          │  Application.java
│      │          │
│      │          ├─common
│      │          │      Result.java
│      │          │
│      │          ├─config
│      │          ├─controller
│      │          │      UserController.java
│      │          │
│      │          ├─domain
│      │          ├─entity
│      │          │      User.java
│      │          │
│      │          ├─mapper
│      │          ├─repository
│      │          │      UserRepository.java
│      │          │
│      │          ├─service
│      │          │      UserService.java
│      │          │
│      │          └─utils
│      └─resources
│              application.yml

3. 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.7.15</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zcs</groupId>
    <artifactId>springboot-template-jpa</artifactId>
    <version>1.0.0</version>
    <name>springboot-template</name>
    <description>springboot-template</description>

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

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

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

        <!-- 引入Spring Boot Actuator的起步依赖，用于监控和管理生产环境中的应用程序 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>4.3.0</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.3.1</version>
        </dependency>

        <!-- 数据库驱动，例如MySQL -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.15</version>
            <scope>runtime</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.oracle.database.jdbc/ojdbc8 -->
        <dependency>
            <groupId>com.oracle.database.jdbc</groupId>
            <artifactId>ojdbc8</artifactId>
            <version>21.5.0.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.microsoft.sqlserver/mssql-jdbc -->
        <dependency>
            <groupId>com.microsoft.sqlserver</groupId>
            <artifactId>mssql-jdbc</artifactId>
            <version>9.4.1.jre8</version>
        </dependency>

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

        <!-- Spring Boot Starter Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>2.0.0</version>
        </dependency>

        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.7</version>
        </dependency>

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

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

        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter-test</artifactId>
            <version>2.3.1</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <includeSystemScope>true</includeSystemScope>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

4. application.yml文件内容

server:
  port: 8090
---
spring:
  web:
    resources:
      static-locations: classpath:/static/
  datasource:
    dynamic:
      primary: master # 设置默认数据源
      strict: false # 设置严格模式，true则未匹配到数据源时抛异常，false则使用默认数据源
      datasource:
        master: # 池名称
          url: jdbc:mysql://192.168.145.103:3306/test?useSSL=false&useUnicode=true&characterEncoding=UTF-8
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver
      druid:
        validation-query: "select 1"
---
mybatis:
  configuration:
    map-underscore-to-camel-case: true
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
---
# 开启所有Actuator的端点暴露，以便可以通过HTTP进行访问
management:
  endpoints:
    web:
      exposure:
        include: "*"
  # 配置健康端点的详细程度，always表示总是显示完整的健康信息
  endpoint:
    health:
      show-details: always

5. Application.java

package com.zcs;

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

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

6. Result.java

package com.zcs.common;

import lombok.Data;

@Data
public class Result<T> {
    private int code;
    private int success;
    private String msg;
    private T data;

    public Result(int code, String msg, int success) {
        this.code = code;
        this.msg = msg;
        this.success = success;
    }

    public Result(int code, String msg, int success, T data) {
        this.code = code;
        this.msg = msg;
        this.success = success;
        this.data = data;
    }

    public static <T> Result<T> success() {
        return new Result<>(200, "", 0);
    }

    public static <T> Result<T> success(String msg) {
        return new Result<>(200, msg, 0);
    }

    public static <T> Result<T> success(String msg, T data) {
        return new Result<>(200, msg, 0, data);
    }

    public static <T> Result<T> error(int code, String message) {
        return new Result<>(code, message, -1);
    }

    public static <T> Result<T> error(int code, String message, T data) {
        return new Result<>(code, message, -1, data);
    }
}

7. User.java

package com.zcs.entity;

import lombok.Data;

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

@Data
@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    private String name;
    private Integer age;
}

8. UserRepository.java

package com.zcs.repository;

import com.zcs.entity.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface UserRepository extends JpaRepository<User, Integer> {
    @Select("SELECT * FROM user WHERE id = #{id}")
    User getUserById(Integer id);

}

9. UserService.java

package com.zcs.service;

import com.zcs.entity.User;
import com.zcs.repository.UserRepository;
import org.springframework.data.domain.*;
import org.springframework.data.repository.query.FluentQuery;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.nio.file.DirectoryStream;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;

@Service
public class UserService {

    @Resource
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }

    public List<User> getAllUsersByIds(List<Integer> ids) {
        return userRepository.findAllById(ids);
    }

    public User getUserById(Integer id) {
        return userRepository.getUserById(id);
    }

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

    public User insertOrUpdateAndFlushUser(User user) {
        return userRepository.saveAndFlush(user);
    }

    public String deleteById(Integer id) {
        boolean b = userRepository.existsById(id);
        if (b) {
            userRepository.deleteById(id);
            return "数据删除成功";
        }
        return "要删除的数据不存在";
    }

    public boolean existsById(Integer id) {
        return userRepository.existsById(id);
    }

    public Optional<User> findOne(String name) {
        User probeUser = new User(); // 假设User类有name属性
        probeUser.setName(name); // 设置你想查询的名字
        // 创建一个ExampleMatcher来定义匹配规则，例如忽略大小写等
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withIgnoreCase() // 忽略属性比较时的大小写
                .withStringMatcher(ExampleMatcher.StringMatcher.EXACT); // 使用"contains"方式匹配字符串
        // 创建Example实例
        Example<User> example = Example.of(probeUser, matcher);
        Function<FluentQuery.FetchableFluentQuery<User>, Optional<User>> one = FluentQuery.FetchableFluentQuery::first;
        // 使用findOne方法根据example查询
        return userRepository.findBy(example, one);
    }

    public Optional<User> getUserByName(String name) {
        User probeUser = new User(); // 假设User类有name属性
        probeUser.setName(name); // 设置你想查询的名字
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withIgnoreCase() // 忽略大小写匹配
                .withStringMatcher(ExampleMatcher.StringMatcher.EXACT); // 精确匹配
        Example<User> example = Example.of(probeUser, matcher);
        Function<FluentQuery.FetchableFluentQuery<User>, Optional<User>> queryFunction = FluentQuery.FetchableFluentQuery::first;
        return userRepository.findBy(example, queryFunction);
    }

    public List<User> getAllUserByName(String name) {
        User probeUser = new User(); // 假设User类有name属性
        probeUser.setName(name); // 设置你想查询的名字
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withIgnoreCase() // 忽略大小写匹配
                .withStringMatcher(ExampleMatcher.StringMatcher.EXACT); // 精确匹配
        Example<User> example = Example.of(probeUser, matcher);
        Function<FluentQuery.FetchableFluentQuery<User>, List<User>> all = FluentQuery.FetchableFluentQuery::all;
        return userRepository.findBy(example, all);
    }

    public List<User> getAllUserByNameAndAge(String name, Integer age) {
        User probeUser = new User(); // 假设User类有name属性
        probeUser.setName(name); // 设置你想查询的名字
        probeUser.setAge(age); // 设置你想查询的名字
        ExampleMatcher matcher = ExampleMatcher.matching()
                .withIgnoreCase() // 忽略大小写匹配
                .withStringMatcher(ExampleMatcher.StringMatcher.EXACT); // 精确匹配
        Example<User> example = Example.of(probeUser, matcher);
        // Function<FluentQuery.FetchableFluentQuery<User>, Optional<User>> queryFunction = query -> query.one();
        Function<FluentQuery.FetchableFluentQuery<User>, List<User>> all = FluentQuery.FetchableFluentQuery::all;
        // Function<FluentQuery.FetchableFluentQuery<User>, Stream<User>> stream = FluentQuery.FetchableFluentQuery::stream;
        return userRepository.findBy(example, all);
    }

    public Page<User> getUsers(int pageNumber, int pageSize) {
        // 创建Pageable对象，参数分别是页码（从0开始）和页面大小
        Pageable pageable = PageRequest.of(pageNumber, pageSize);
        // 调用findAll方法传入Pageable对象进行分页查询
        return userRepository.findAll(pageable);
    }
}

10. UserController.java

package com.zcs.controller;

import com.zcs.common.Result;
import com.zcs.entity.User;
import com.zcs.repository.UserRepository;
import com.zcs.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.List;
import java.util.Optional;

@Slf4j
@RestController
@RequestMapping("/users")
public class UserController {
    @Resource
    private UserRepository userRepository;

    @Resource
    private UserService userService;

    @GetMapping
    public List<User> getAllUsers() {
        return userService.getAllUsers();
    }

    // 根据id查询user
    @GetMapping("/{id}")
    public Result<User> getById(@PathVariable Integer id) {
        User user = userRepository.findById(id).get();
        return Result.success("success", user);
    }

    // 查询user表的行数
    @GetMapping("/count")
    public Result<Long> count() {
        long count = userRepository.count();
        return Result.success("success", count);
    }

    // 根据name查询匹配到的第一条数据
    @GetMapping("/findOne")
    public Result<Optional<User>> findOne(@RequestParam String name) {
        Optional<User> userServiceOne = userService.findOne(name);
        return Result.success("success", userServiceOne);
    }

    // 根据id列表（用逗号分隔）查询user
    @GetMapping("/ids/{ids}")
    public Result<List<User>> getAllUsersByIds(@PathVariable List<Integer> ids) {
        List<User> allUsersByIds = userService.getAllUsersByIds(ids);
        return Result.success("success", allUsersByIds);
    }

    // 根据id查询user
    @GetMapping("/id/{id}")
    public Result<User> getUserById(@PathVariable Integer id) {
        User userById = userService.getUserById(id);
        return Result.success("success", userById);
    }

    // 根据name查询user匹配到的第一个数据
    @GetMapping("/getUserByName")
    public Result<Optional<User>> getUserByName(@RequestParam String name) {
        Optional<User> userByName = userService.getUserByName(name);
        return Result.success("success", userByName);
    }

    // 根据name查询匹配到的所有user
    @GetMapping("/getAllUserByName")
    public Result<List<User>> getAllUserByName(@RequestParam String name) {
        List<User> allUserByName = userService.getAllUserByName(name);
        return Result.success("success", allUserByName);
    }

    // 根据name和age查询匹配到的所有user
    @GetMapping("/getAllUserByNameAndAge")
    public Result<List<User>> getAllUserByNameAndAge(@RequestParam String name, @RequestParam Integer age) {
        List<User> allUserByName = userService.getAllUserByNameAndAge(name, age);
        return Result.success("success", allUserByName);
    }

    // 根据id查询数据是否存在
    @GetMapping("/exists/{id}")
    public Result<Boolean> existsById(@PathVariable Integer id) {
        boolean b = userService.existsById(id);
        return Result.success("success", b);
    }

    // 插入或更新user
    @PostMapping
    public Result<User> insertOrUpdateUser(@RequestBody User user) {
        User user1 = userService.insertOrUpdateUser(user);
        return Result.success("success", user1);
    }

    // 插入或更新user，且刷新
    @PutMapping
    public Result<User> insertOrUpdateAndFlushUser(@RequestBody User user) {
        User user1 = userService.insertOrUpdateAndFlushUser(user);
        return Result.success("success", user1);
    }

    // 根据id删除数据
    @DeleteMapping("/{id}")
    public Result<String> deleteById(@PathVariable Integer id) {
        String string = userService.deleteById(id);
        return Result.success("success", string);
    }

    // 分页查询
    @GetMapping("/page")
    public Result<Page<User>> getUsersByPage(@RequestParam int pageNumber, @RequestParam(defaultValue = "10") int pageSize) {
        Page<User> users = userService.getUsers(pageNumber, pageSize);
        return Result.success("success", users);
    }

}
BigDataMagician
关注
  • 27
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringData JPA 答案整理，最新面试题
Miss_SunHengYang的博客
07-18 361
根据需求选择适合的继承策略，如单表继承（@Inheritance(strategy = InheritanceType.SINGLE_TABLE)）、每类一表继承（@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)）或连接表继承（@Inheritance(strategy = InheritanceType.JOINED)）。通过@EntityGraph注解的attributePaths属性指定需要立即加载的关联对象，减少懒加载带来的性能问题。
一步一步搭建Spring/SpringMVC/SpringJPA整合的示例项目
菜园里的一只鸟
09-21 180
文章内容输出来源：拉勾教育Java高薪训练营 文章目录目标整体思路实现过程数据库准备创建项目Spring与Spring JPA的整合整合Spring MVC实现用户登录功能简历的CRUD功能实现项目代码 目标 项目的主要目标是，将SSS三个主流框架进行整合，并实现简单的用户登录，展示简历的列表、添加、编辑、删除的功能 SSS = Spring + Spring JPA + Spring MVC 整体思路 分为以下三个步骤： 1、整合Spring+Spring JPA 2、整合Spring MVC 3.
Spring Data JPA 学习笔记
LoVin'i7
10-06 183
Spring Data JPA 使用笔记 一、JPA 介绍 JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。 一句话，JPA 只是一种接口、一种规范、比如Hibernate、OpenJPA 这些就属于Jpa的具体实现。 二、Spring Data JPA 解决的问...
springboot分页查询_Spring Boot整合Spring Data JPA以及整合Ehcache缓存
weixin_39823017的博客
12-03 104
训练大纲(第114天)大家如果想快速有效的学习，思想核心是“以建立知识体系为核心”，具体方法是“守破离”。确保老师课堂上做的操作，反复练习直到熟练。第219次(SpringBoot)学习主题：SpringBoot学习目标：对应视频: http://www.itbaizhan.cn/course/id/85.html对应文档:无对应作业 SpringBoot整合Spring Data JPA步骤-(...
Spring Boot QuickStart (5) - Spring Data JPA
weixin_33901641的博客
07-03 114
接(4) - Database 系列. Java Persistence API，可以理解就是 Java 一个持久化标准或规范，Spring Data JPA 是对它的实现。并且提供多个 JPA 厂商适配，如 Hibernate、Apache 的 OpenJpa、Eclipse的EclipseLink等。 spring-boot-star...
SSM（Spring, Spring MVC, MyBatis）开发实战
yootk的博客
11-13 697
SSM是当今Java项目开发行业使用官方的开发框架整合，其在Spring框架的基础上进行了有效的功能扩充，使其可以轻松的实现企业级系统平台的搭建。本书在《Spring开发实战》图书的基础上，继续深入编写，除了包含有基础的SSM整合开发之外（SpringMVC + MyBatis），还扩展了SSM开发的技术范围（SpringSecurity、MyBatis-Plus、Spring Batch），并且给出了三个完整的案例以及综合项目实战。
ES & SpringData ES
weixin_41942838的博客
04-26 388
ES & SpringData ES 1 Elasticsearch编程操作 1.1.1 工程搭建 (1)搭建工程 我们首先搭建一个新的工程，坐标如下 <groupId>com.itheima</groupId> <artifactId>elasticsearch-day2-demo1</artifactId> <version>1.0-SNAPSHOT</version> (2)pom.xml依赖 <?xml vers
Spring Boot Thymeleaf H2数据库CRUD示例
allway2的博客
01-27 763
Thymeleaf + Spring Boot - Complete Tutorial (Step by Step with Source Codes) - Kindson The Geniushttps://www.kindsonthegenius.com/thymeleaf-spring-boot-complete-tutorial-step-by-step-with-source-codes/ 1. Thymeleaf 简介（视频） 在本演练中，我们将构建一个应用程序来存储学生记录。用户将能够：.
Spring 与 Spring Boot：深入解析
热门推荐
weixin_44976692的博客
01-04 2万+
Spring 提供全面的功能，而 Spring Boot 通过简化配置、提供约定的方式，加速了项目的构建。Spring Boot 是 Spring 生态系统的一个子项目，专注于简化 Spring 应用的开发和部署。通过提供约定大于配置的方式，Spring Boot 显著降低了开发者的工作量，使得快速创建独立、基于 Spring 的应用变得轻而易举。这些例子进一步展示了 Spring Boot 在不同方面的简化和自动化，使得开发者能够更专注于业务逻辑的实现，提高了整体开发效率。
Spring Data JPA讲义_Java高薪训练营1
08-03
Spring Data JPA 是 Spring 框架的一部分，提供了一些基本的数据访问功能，例如 CRUD（Create, Read, Update, Delete）操作。它支持多种数据库管理系统，包括 MySQL、 PostgreSQL、 Oracle 等。 Spring Data JPA ...
springboot-spring-data-jpa项目练习
08-14
SpringBoot与Spring Data JPA是Java开发中常用的两个框架，它们极大地简化了Web应用和数据库交互的复杂性。本项目练习旨在帮助开发者深入理解和实践这两个技术的集成与使用。 Spring Boot是一个快速开发框架，它...
spring+springmvc+jpa+thymeleaf 练习demo项目源码
11-27
Spring Data JPA提供了强大的Repository接口，使得CRUD（创建、读取、更新、删除）操作变得极其简单，同时支持自定义查询方法。 Thymeleaf是一个现代的服务器端HTML模板引擎，特别适合前后端分离的开发模式。与JSP...
人工智能-项目实践-信息检索-专利检索系统Spring
最新发布
02-29
Spring Boot预配置了许多常见的设置，如嵌入式Tomcat服务器、Spring Data JPA、Spring Security等，使得开发者能够快速搭建应用程序。Spring Data模块则负责数据库交互，通过Repository接口，可以方便地执行CRUD操作...
2021-spring-bootcamp:2021年Spring训练营
03-14
4. **Spring Data JPA**：探索Spring Data JPA，它是Spring框架的一部分，用于简化数据库访问，支持ORM框架如Hibernate，学习如何定义Repository接口并实现CRUD操作。 5. **RESTful API设计**：学习如何使用Spring ...
spring-framework-4.3.14.RELEASE
03-15
7. **实战演练** - **快速入门**：创建第一个Spring MVC应用，理解配置、控制器和视图的交互。 - **数据库操作**：集成JPA或Hibernate进行数据访问，实现CRUD操作。 - **事务管理**：使用Spring的声明式事务管理...
tech-talk-spring-boot:在 2014 年 7 月的一次技术演讲中介绍了 Spring Boot 演练
06-11
创建此项目的命令： spring init -d=data-rest,data-jpa --build=gradle tech-talk-spring-boot 使用生成您的 Gradle 构建文件。 ###Building and running 构建项目： ./gradlew build 运行应用程序： java -jar ...
19Spring项目：19Spring项目
02-22
3. Spring Data JPA或MyBatis进行持久化操作，以及与数据库的交互。 4. Spring Security的基本认证与授权机制，如何实现用户登录和权限控制。 5. Spring Cloud组件，如Eureka、Zuul、Hystrix等，用于微服务治理。 6....
spring_learn
06-16
Spring Data支持JPA、MongoDB、Redis等多种数据库，简化了数据访问的操作，如CRUD操作和查询构建。 七、Spring Security Spring Security是一个强大的安全框架，提供了认证和授权的解决方案。它能够保护Web应用免受...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

BigDataMagician

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值