首页 > 其他分享 >SpringBoot项目初始化搭建

SpringBoot项目初始化搭建

时间：2024-08-30 19:50:38浏览次数：5  
标签：初始化 事务 分页 springframework org import 搭建 public SpringBoot

SpringBoot项目搭建

创建SpringBoot项目

在这里插入图片描述
首先在IDEA编译器中创建SpringBoot项目，注意选择链接: 阿里云这个网址进行创建，可以选择Java17以下的版本，在这里插入图片描述
点击进行创建之后，这个页面可以选择需要引入的依赖，注意，我们这里SpringBoot的版本为2.6.13，不要选择3.0以上的版本，因为SpringBoot3.0版本需要Java17以上作为支持，我们在这个页面不需要选择任何依赖，阿里云作为镜像网站，其中代码会自动生成，我们不选择任何依赖就可以使用纯净版进行开发，进入项目以后我们可以手动进行依赖的引入。
在这里插入图片描述
进入项目，首先打开pom.xml文件，将依赖引入dependencies双标签中，引入依赖如下：

      <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.2.2</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

接下来我们就可以愉快的编程了。

事务

接下来我们可以先学习一下事务（transaction），在Java中，事务通常指的是数据库操作中的一个概念，它确保了数据库操作的原子性、一致性、隔离性和持久性（ACID属性）。在Java的数据库编程中，事务可以通过JDBC API来管理，也可以使用更高级的框架如JPA（Java Persistence API）或Spring Framework来简化事务管理。

  • 原子性（Atomicity）：事务中的所有操作要么全部完成，要么全部不完成，不会结束在中间某个点。

  • 一致性（Consistency）：事务必须保证数据库从一个一致性状态转换到另一个一致性状态。

  • 隔离性（Isolation）：并发执行的事务之间不会相互影响，每个事务都像是在独立运行。

  • 持久性（Durability）：一旦事务提交，它对数据库的修改就是永久性的，即使系统发生故障也不会丢失。

在Java中，可以通过以下方式管理事务：

  • JPA：通过实体管理器（EntityManager）来管理事务，可以在实体管理器上调用beginTransaction()开始事务，commit()提交事务，rollback()回滚事务。

  • Spring Framework：Spring提供了声明式事务管理，可以通过注解（如@Transactional）或编程式事务管理来控制事务的边界。

事务管理是确保数据完整性和一致性的关键机制，特别是在多用户环境中进行并发数据库操作时。

编程式事务

首先来讲一下"编程式事务"，指的是在编程过程中，通过代码显式地管理事务的开始、提交或回滚。在编程式事务中，开发者需要手动控制事务的生命周期，包括何时开始事务、何时提交事务以及在遇到错误时如何回滚事务。这种方法提供了更细粒度的控制，但同时也增加了代码的复杂性。
我们可以通过创建管理类来进行事务的开启，提交和回滚：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
import org.springframework.transaction.support.TransactionTemplate;

@Service
public class MyService {

    private final TransactionTemplate transactionTemplate;

    @Autowired
    public MyService(PlatformTransactionManager transactionManager) {
        this.transactionTemplate = new TransactionTemplate(transactionManager);
    }

    public void performTransaction() {
        transactionTemplate.execute(status -> {
            // 执行业务逻辑
            try {
                // 业务逻辑代码，例如数据库操作
                // 如果一切顺利，事务将自动提交
            } catch (Exception e) {
                // 如果发生异常，回滚事务
                status.setRollbackOnly();
                throw e;
            }
            return null; // 返回值
        });
    }
}

声明式事务

声明式事务（Declarative Transaction Management）是一种通过配置来管理事务的方式，它允许开发者将事务管理的逻辑与业务逻辑分离，从而使得代码更加清晰和易于维护。在声明式事务中，事务的边界和行为是通过配置或注解来定义的，而不是通过代码来显式控制。
在编程的过程中，由于声明式事务的高可维护性，所以我们经常使用声明式事务。
以下为声明式事务的代码示例：

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class MyService {

    @Transactional
    public void myTransactionalMethod() {
        // 业务逻辑代码
    }
}

我们只需要在控制业务逻辑的代码之前进行注解**@Transactional**，就可以开启事务，但是声明式事务默认只会判断运行时异常自动回滚，对受检时异常无法进行判断，所以我们就需要在其后面进行代码的添加。

@Override
//@Transactional   默认 只有运行时异常  会自动回滚
@Transactional(rollbackFor = Exception.class)//遇见运行时异常 或者 非运行时异常。都会回滚，前提是该方法内的异常抛出而非捕获
public boolean updateAll(Person person) throws FileNotFoundException {
    Long row = personMapper.updateAll(person);
    //int i = 5 / 0;//运行时异常
    //FileInputStream fileInputStream = new FileInputStream("xx");//IOException 非运行时异常
    return row != 0 ? true : false;
}

通过定义异常的类型Exception.class，我们就可以将在业务中遇到的所有异常情况进行回滚，不会影响到数据库中的数据安全。

PageHelper

编程时在进行数据库操作时，我们经常会头疼limit分页操作，需要再SQL语句中定义，在业务层（Service）进行逻辑判断，所以在这里介绍一个关于数据分页的依赖PageHelper。
PageHelper 是一个用于帮助在 Java 项目中实现 MyBatis 分页查询的插件。它通过拦截 MyBatis 的执行器来实现分页功能，无需修改原来的 SQL 语句，使得开发者可以非常方便地进行分页处理。

主要特点：

  • 简单易用：只需要在查询方法前调用 PageHelper.startPage() 方法，传入页码和每页显示的记录数，就可以实现分页。

  • 无需修改 SQL：PageHelper 通过拦截 MyBatis 的执行器来实现分页，不需要修改原有的 SQL 语句。

  • 支持多种数据库：PageHelper 支持多种数据库，如 MySQL、Oracle、SQL Server 等。

  • 自动处理：PageHelper 会自动处理分页参数，开发者无需手动编写分页逻辑。

  • 支持多种分页参数：除了基本的页码和每页记录数，PageHelper 还支持其他分页参数，如排序、跳过 count 查询等。

依赖使用

首先我们需要再pom.xml中添加依赖配置。

<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper-spring-boot-starter</artifactId>
    <version>最新版本</version>
</dependency>

然后，在需要进行分页的查询方法前调用 PageHelper.startPage() 方法。

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class MyService {

    @Autowired
    private MyMapper myMapper; // MyBatis 的 Mapper 接口

    public PageInfo<MyEntity> selectPaged(int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<MyEntity> list = myMapper.selectAll(); // 执行查询
        return new PageInfo<>(list); // 返回分页信息
    }
}

最后，PageHelper 会自动处理分页，并将结果封装到 PageInfo 对象中，该对象包含了分页的详细信息，如总记录数、总页数、当前页码、每页记录数等。

常用方法

  1. startPage(int pageNum, int pageSize):

    • 开始分页，传入页码和每页数量。
    • pageNum 从 1 开始计数。
    • pageSize 表示每页显示的记录数。

  2. startPage(int pageNum, int pageSize, boolean count):

    • 开始分页，允许你选择是否进行 count 查询来获取总记录数。
    • count 参数默认为 true，如果设置为 false，则不会执行 count 查询。

  3. startPage(PageParams params):

    • 开始分页，使用 PageParams 对象来传递分页参数。
    • 允许更灵活的分页参数设置，如排序、是否进行 count 查询等。

  4. PageInfo getPageInfo(List list):

    • 将 MyBatis 查询的结果集合封装成 PageInfo 对象。
    • 通常与 startPage 方法配合使用。

  5. orderBy(String orderBy):

    • 设置排序参数，可以链式调用 startPage。
    • 例如：PageHelper.orderBy("id asc, name desc").startPage(pageNum, pageSize)

  6. PageInfo getPageInfo():

    • 获取最近一次分页的 PageInfo 对象。
    • 如果没有进行分页查询，会抛出异常。

  7. getTotal():

    • 获取最近一次分页查询的总记录数。
    • 需要在 startPage 方法中启用 count 查询。

  8. setPageRowBounds(int pageSize):

    • 设置全局的分页参数，包括每页记录数。
    • 这个设置会影响之后所有的分页查询。

  9. setPageRowBounds(int offset, int limit):

    • 使用 SQL 风格的分页参数设置分页。
    • offset 表示起始位置，limit 表示查询记录数。

  10. supportMethodsPage:

    • 静态变量，设置为 true 时，支持无参的 PageInfo 获取方法。

  11. clearPage():

    • 清除 PageHelper 的分页参数，通常在测试中使用。

  12. execSelect(Select select):

    • 执行分页查询并返回 PageInfo 对象。
    • 可以传递一个 Select 对象来定义查询。

跨域问题

在了解跨域问题之前，我们首先需要了解什么是同源策略。

  • 浏览器的同源政策要求，如果两个 URL 的协议、域名和端口都相同，那么这两个 URL 才被认为是同一个源。
  • 出于安全考虑，浏览器限制了来自不同源的文档或脚本对当前文档的读取或设置权限。

跨域问题（Cross-Origin Resource Sharing，简称 CORS）是 Web 浏览器中的一种安全机制，它限制了 Web 页面对不同源（域名、协议或端口）的资源的访问。这个机制的目的是为了保护用户信息不被恶意网站窃取。

在我们进行本机的操作时，由于服务器端与客户端浏览器的协议，域名相同，都为http://127.0.0.1，端口一般为3306（数据库），与8080（浏览器），这样由于同源策略，响应就会被浏览器拦截，数据就无法响应在浏览器上，所以在开发过程中，我们就需要先解决一下跨越问题。

JSONP（JSON with Padding）

JSONP 是一种早期用来解决浏览器同源策略限制的方法，主要用在跨域 HTTP 请求中。由于 <script> 标签的加载不受同源政策的限制，JSONP 利用这一特性来实现跨域数据传输。

工作原理：

  1. 客户端：在客户端页面中，通过 JavaScript 动态创建一个 <script> 标签，并将其 src 属性设置为需要请求的跨域 URL。这个 URL 通常包含一个查询参数，如 callback，用于指定一个函数名，该函数用于处理返回的数据。
  2. 服务器：服务器接收到请求后，将数据包装在客户端指定的函数调用中，然后返回。例如，如果客户端请求的 URL 是 http://example.com/data?callback=myCallback，服务器会返回 myCallback({"key":"value"})。
  3. 浏览器：浏览器解析这个脚本，执行其中的 myCallback 函数，并将数据作为参数传入。

代码示例

前端配置：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>JSONP Example</title>
    <script>
        // 定义回调函数，用于处理从服务器返回的数据
        function handleData(data) {
            console.log('Received data:', data);
            // 在这里处理数据
        }
    </script>
</head>
<body>
    <!-- 动态创建script标签来发送JSONP请求 -->
    <script>
        var script = document.createElement('script');
        script.src = 'http://yourserver.com/jsonp?callback=handleData'; // 假设服务器端接受callback参数
        document.head.appendChild(script);
    </script>
</body>
</html>

后端配置：

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

public class JsonpServlet extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String callback = request.getParameter("callback");
        if (callback == null || callback.isEmpty()) {
            response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
            return;
        }

        // 创建一个简单的JSON对象
        String jsonpData = "{\"key\":\"value\"}";

        // 包装JSONP响应
        String responseData = callback + "(" + jsonpData + ");";

        // 设置响应类型为JavaScript
        response.setContentType("application/javascript");
        response.setCharacterEncoding("UTF-8");

        // 输出响应
        PrintWriter out = response.getWriter();
        out.print(responseData);
        out.flush();
    }
}

CORS（Cross-Origin Resource Sharing）

CORS 是现代浏览器支持的一种官方标准，用于允许或限制网页从不同源加载资源。它通过服务器设置特定的 HTTP 响应头来控制跨域请求的权限。

工作原理：

  1. 预检请求：对于可能对服务器数据产生副作用的请求（如 POST、PUT、DELETE），浏览器会先发送一个预检请求（OPTIONS 请求），询问服务器是否允许实际的请求。
  2. 服务器响应：服务器在响应中包含 Access-Control-Allow-Origin 头，指定哪些源可以访问资源。如果允许跨域请求，服务器还会处理其他相关的 CORS 头，如 Access-Control-Allow-Methods 和 Access-Control-Allow-Headers。
  3. 浏览器处理：浏览器根据服务器的响应头决定是否执行实际的请求。如果服务器允许，浏览器会执行请求并处理响应。

代码示例

在Spring框架中，可以使用@CrossOrigin注解来轻松配置CORS。这个注解可以添加到控制器、控制器方法或全局配置中。

1，全局CORS配置
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("http://example.com")
                .allowedMethods("GET", "POST", "PUT", "DELETE")
                .allowedHeaders("*")
                .allowCredentials(true);
    }
}
}
2. 使用Spring Boot
spring.mvc.cors.allowed-origins=http://example.com
spring.mvc.cors.allowed-methods=GET,POST,PUT,DELETE
spring.mvc.cors.allowed-headers=*
spring.mvc.cors.allow-credentials=true
3. 使用Servlet过滤器
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class CorsFilter implements Filter {

    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws IOException, ServletException {
        HttpServletResponse response = (HttpServletResponse) res;
        HttpServletRequest request = (HttpServletRequest) req;
        response.setHeader("Access-Control-Allow-Origin", "http://example.com");
        response.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS, DELETE, PUT");
        response.setHeader("Access-Control-Allow-Headers", "x-requested-with, Content-Type");
        response.setHeader("Access-Control-Max-Age", "3600");
        response.setHeader("Access-Control-Allow-Credentials", "true");

        if ("OPTIONS".equalsIgnoreCase(request.getMethod())) {
            response.setStatus(HttpServletResponse.SC_OK);
        } else {
            chain.doFilter(req, res);
        }
    }

    public void init(FilterConfig filterConfig) {}

    public void destroy() {}
}

然后在web.xml中注册过滤器：

<filter>
    <filter-name>CorsFilter</filter-name>
    <filter-class>com.example.CorsFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>CorsFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

总的来说，CORS 是现代 Web 开发中推荐使用的跨域解决方案，因为它提供了更好的安全性和灵活性。JSONP 虽然在某些情况下仍然有用，但其局限性和安全风险使其逐渐被 CORS 所取代。

标签：初始化,事务,分页,springframework,org,import,搭建,public,SpringBoot
From： https://blog.csdn.net/weixin_63405049/article/details/141724070

相关文章

  • Linux驱动（一）：环境搭建及介绍
    目录前言一、硬件配置及SDK包1.硬件核心芯片2.瑞芯微原厂SDK包二、环境镜像文件的获取1.镜像文件的组成及启动流程2.获取环境所需的镜像文件2.1uboot.img2.2boot.img2.3rootfs.img2.4整体编译三、镜像文件烧录前言  自用自用自用，晚上睡觉前复盘用。当然，也......
  • 使用devpi-server搭建pypi本地缓存服务器
    使用缓存机制可以显著减少对外部源的请求量，从而提高下载速度，并降低被源站封禁的风险。下面详细解释如何在本地服务器上设置和使用pip缓存机制。缓存机制的基本原理缓存机制的原理是在本地服务器上保存已经下载过的Python包，当其他服务器请求同样的包时，本地服务器可以直接提供，......
  • springboot 接口接收参数的注解介绍（@RequestParam，@PathVariable，@RequestBody 等）
    springboot接收参数的注解介绍（使用方法）在SpringBoot中，接收参数的方式主要依赖于SpringMVC提供的注解。这些注解帮助你将HTTP请求中的参数绑定到控制器（Controller）方法的参数上。以下是一些常用的接收参数的注解：1.@RequestParam用法：用于将HTTP请求参数绑定到控制器的方......
  • springboot+vue安心养老一站通服务系统的设计与实现【程序+论文+开题】计算机毕业设计
    系统程序文件列表开题报告内容研究背景随着社会老龄化的加速，养老问题已成为全球性的社会挑战。传统的养老模式面临着资源分配不均、服务效率低下、信息孤岛等诸多问题，难以满足老年人日益增长的多元化、个性化需求。在此背景下，安心养老一站通服务系统的设计与实现显得尤为重......
  • springboot+vue爱心捐赠系统【程序+论文+开题】计算机毕业设计
    系统程序文件列表开题报告内容研究背景在当今社会，随着经济的快速发展与信息技术的日益普及，公益慈善事业逐渐成为连接社会爱心与需要帮助群体的重要桥梁。然而，传统的捐赠方式往往存在信息不对称、流程繁琐、透明度不足等问题，限制了公益资源的有效配置与利用。因此，构建一个高......
  • springboot+vue爱心慈善公益系统【程序+论文+开题】计算机毕业设计
    系统程序文件列表开题报告内容研究背景在当今社会，随着经济的快速发展与人民生活水平的日益提高，社会各界对于慈善公益事业的关注度与参与度也显著提升。然而，传统的慈善捐赠方式往往存在信息不对称、流程繁琐、透明度不足等问题，限制了公益资源的高效配置与利用。特别是在互联......
  • 快速搭建一款可交互式的「地理空间」应用
    GreppoGitHub上的开源Python框架，可快速搭建一款可交互式的「地理空间」应用。该框架提供了一整套完整工具包，让你可以轻松打通数据、算法、可视化UI等模块，构建一款交互式应用。https://github.com/greppo-io/greppo ......
  • 【开源分享】2024PHP在线客服系统源码 带搭建教程
    PHP在线客服系统主要功能：用户信息用户提交：新用户可以通过表单留言输入相关信息，如用户名、密码、邮箱等，完成后获得唯一的用户ID和密码。客服管理客服信息管理：管理客服人员的基本信息，如姓名、工号、权限等。客服工作状态：实时显示客服人员的在线/离线状态，方便客户选择合适的......
  • SpringBoot原理
    目录一、配置优先级二、Bean管理1.获取Bean（1）三种方式（2）获取示例 2.Bean作用域 3.第三方Bean 三、SpringBoot原理1.起步依赖2.自动配置（1）概述（2）准备工作 （3）@Import （4）模拟过程3.自动配置原理（1）源码跟踪 （2）@Conditional （3）自定义start业务场景需求 步骤具......
  • FFmpeg开发笔记（四十八）从0开始搭建直播系统的开源软件架构
    音视频技术的一个主要用途是直播，包括电视直播、电脑直播、手机直播等等，甚至在线课堂、在线问诊、安防监控等应用都属于直播系统的范畴。由于直播系统不仅涉及到音视频数据的编解码，还涉及到音视频数据的实时传输，因此直播领域采用的网络技术标准比较高，实现起来也比一般的WEB系统复杂......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99