为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 Spring Boot项目开发学习：从入门到实战

Spring Boot项目开发学习：从入门到实战

标签：
Java SpringBoot
概述

本文介绍了如何进行Spring Boot项目开发学习，涵盖了从环境搭建到创建第一个Spring Boot应用程序的全过程。首先介绍了Spring Boot的基本概念和特性，接着详细说明了开发环境的搭建步骤，最后通过实例展示了如何使用Spring Initializr创建并运行一个简单的Web应用。

Spring Boot简介与环境搭建

什么是Spring Boot

Spring Boot是由Pivotal团队提供的全新框架，其设计目标是简化新Spring应用的初始搭建以及开发过程。使用Spring Boot，你可以无需配置复杂的Spring XML配置，利用约定大于配置的原则来快速构建基于Spring的应用程序。

Spring Boot的主要特性包括：

  • 独立运行：内嵌Servlet容器，支持直接运行。
  • 自动配置：根据应用类型和路径自动配置。
  • 简化依赖：通过提供一系列开箱即用的依赖。
  • 内建一些好的实践：日志、安全、序列化等。
  • 不修改代码即可使用：可以修改一些配置来定制应用。
  • 生产就绪：支持运行时监控、生产指标和外部配置。

开发环境搭建

为了开发Spring Boot应用程序，你需要安装以下工具：

  • Java开发工具包（JDK）：确保安装了Java 8或更高版本。
  • 操作系统：Windows、Linux或macOS。
  • 开发工具：如IntelliJ IDEA或Spring Tool Suite（STS）。
  • Maven或Gradle：用于构建和管理项目依赖。

下面以Maven为例，介绍如何在IDEA中搭建Spring Boot开发环境：

  1. 下载并安装JDK：确保JDK版本不低于1.8。
  2. 安装IDEA：从官网下载并安装IntelliJ IDEA。
  3. 安装Maven：确保在环境变量中配置Maven的安装路径。
  4. 新建Spring Boot项目：
    • 打开IDEA，选择“File” -> “New” -> “Project”。
    • 选择“Spring Initializr”并点击“Next”。
    • 输入相关信息，如项目名、语言（Java）、Spring Boot版本等。
    • 选择依赖，例如Spring Web来构建一个简单的Web应用。
    • 点击“Next” -> “Finish”完成项目创建。
Spring Boot核心配置

Spring Boot应用可以通过application.properties或application.yml文件进行配置。以下是一些常用的配置项：

服务器配置

server.port=8080

日志配置

logging.level.root=INFO

数据源配置

spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
创建第一个Spring Boot应用程序

现在你已经搭建好了开发环境，接下来创建一个简单的Spring Boot应用程序。

  1. 创建Spring Boot项目：
    • 使用Spring Initializr创建一个新的Spring Boot项目，选择Java语言和Spring Web依赖。
    • 项目创建完成后，IDEA会自动下载并配置所需的库。
  2. 编写主程序：
    • 在项目根目录下找到Application.java文件，打开并编辑它。
    • 添加一个简单的HTTP端点，用于显示“Hello World”。
package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
public class DemoApplication {

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

    @RestController
    public class HelloController {
        @GetMapping("/")
        public String hello() {
            return "Hello World!";
        }
    }
}
  1. 运行项目：
    • 右键DemoApplication类，选择Run 'DemoApplication.main()'，或者使用IDEA的运行按钮来启动应用。
    • 打开浏览器访问http://localhost:8080，查看是否显示“Hello World!”。
控制器与RESTful服务开发

创建RESTful服务

在Spring Boot中，可以使用@RestController注解来创建RESTful服务。以下是一个简单的示例，展示如何创建一个用户资源管理的RESTful API。

  1. 创建用户实体类：
package com.example.demo;

public class User {
    private String id;
    private String name;

    // Getters and Setters
}
  1. 创建用户服务类：
package com.example.demo;

import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

@Service
public class UserService {
    private List<User> users = new ArrayList<>();

    public List<User> getAllUsers() {
        return users;
    }

    public User getUserById(String id) {
        return users.stream().filter(user -> user.getId().equals(id)).findFirst().orElse(null);
    }

    public User addUser(User user) {
        users.add(user);
        return user;
    }

    public User updateUser(User user) {
        User existingUser = getUserById(user.getId());
        if (existingUser != null) {
            existingUser.setName(user.getName());
        }
        return existingUser;
    }

    public boolean deleteUser(String id) {
        User user = getUserById(id);
        return users.remove(user);
    }
}
  1. 创建用户控制器类：
package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

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

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable String id) {
        User user = userService.getUserById(id);
        return user != null ? ResponseEntity.ok(user) : ResponseEntity.notFound().build();
    }

    @PostMapping
    public ResponseEntity<User> addUser(@RequestBody User user) {
        User savedUser = userService.addUser(user);
        return ResponseEntity.ok(savedUser);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable String id, @RequestBody User user) {
        User updatedUser = userService.updateUser(user);
        return updatedUser != null ? ResponseEntity.ok(updatedUser) : ResponseEntity.notFound().build();
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable String id) {
        boolean deleted = userService.deleteUser(id);
        return deleted ? ResponseEntity.noContent().build() : ResponseEntity.notFound().build();
    }
}
数据访问技术

在Spring Boot中，可以使用Spring Data JPA进行数据库操作。以下是一个简单的示例，展示如何使用Spring Data JPA进行数据库操作。

  1. 创建用户实体类：
package com.example.demo;

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

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

    // Getters and Setters
}
  1. 创建用户仓库接口：
package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}
  1. 创建用户服务类：
package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

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

    public User getUserById(Long id) {
        return userRepository.findById(id).orElse(null);
    }

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

    public User updateUser(User user) {
        if (userRepository.existsById(user.getId())) {
            user.setId(user.getId());
            return userRepository.save(user);
        }
        return null;
    }

    public boolean deleteUser(Long id) {
        userRepository.deleteById(id);
        return !userRepository.existsById(id);
    }
}
  1. 创建用户控制器类：
package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

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

    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = userService.getUserById(id);
        return user != null ? ResponseEntity.ok(user) : ResponseEntity.notFound().build();
    }

    @PostMapping
    public ResponseEntity<User> addUser(@RequestBody User user) {
        User savedUser = userService.addUser(user);
        return ResponseEntity.ok(savedUser);
    }

    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        User updatedUser = userService.updateUser(user);
        return updatedUser != null ? ResponseEntity.ok(updatedUser) : ResponseEntity.notFound().build();
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        boolean deleted = userService.deleteUser(id);
        return deleted ? ResponseEntity.noContent().build() : ResponseEntity.notFound().build();
    }
}
实战案例：构建简单博客应用

需求分析

构建一个简单的博客应用通常需要以下几个功能模块：

  • 用户认证
  • 文章管理
  • 评论管理

用户认证

创建用户实体类

package com.example.demo;

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

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String password;

    // Getters and Setters
}

创建用户仓库接口

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
    User findByUsername(String username);
}

创建用户服务类

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    public Optional<User> findUserByUsername(String username) {
        return userRepository.findByUsername(username);
    }

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

创建用户控制器类

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {
    @Autowired
    private UserService userService;
    @Autowired
    private PasswordEncoder passwordEncoder;

    @PostMapping("/register")
    public User registerUser(@RequestBody User user) {
        user.setPassword(passwordEncoder.encode(user.getPassword()));
        return userService.saveUser(user);
    }
}

文章管理

创建文章实体类

package com.example.demo;

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

@Entity
public class Post {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;
    @ManyToOne
    private User author;

    // Getters and Setters
}

创建文章仓库接口

package com.example.demo;

import org.springframework.data.jpa.repository.JpaRepository;

public interface PostRepository extends JpaRepository<Post, Long> {
}

创建文章服务类

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class PostService {
    @Autowired
    private PostRepository postRepository;

    public List<Post> getAllPosts() {
        return postRepository.findAll();
    }

    public Post createPost(Post post) {
        return postRepository.save(post);
    }

    public Post getPostById(Long id) {
        return postRepository.findById(id).orElse(null);
    }

    public Post updatePost(Post post) {
        if (postRepository.existsById(post.getId())) {
            return postRepository.save(post);
        }
        return null;
    }

    public boolean deletePost(Long id) {
        postRepository.deleteById(id);
        return !postRepository.existsById(id);
    }
}

创建文章控制器类

package com.example.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@RestController
@RequestMapping("/posts")
public class PostController {
    @Autowired
    private PostService postService;

    @GetMapping
    public List<Post> getAllPosts() {
        return postService.getAllPosts();
    }

    @GetMapping("/{id}")
    public Post getPostById(@PathVariable Long id) {
        return postService.getPostById(id);
    }

    @PostMapping
    public Post createPost(@RequestBody Post post) {
        return postService.createPost(post);
    }

    @PutMapping("/{id}")
    public Post updatePost(@PathVariable Long id, @RequestBody Post post) {
        return postService.updatePost(post);
    }

    @DeleteMapping("/{id}")
    public boolean deletePost(@PathVariable Long id) {
        return postService.deletePost(id);
    }
}
部署与运行

打包Spring Boot应用程序

打包Spring Boot应用程序，生成可执行的JAR文件：

mvn package

部署到Tomcat服务器

将生成的JAR文件部署到Tomcat服务器：

java -jar target/*.jar

部署到Docker容器

使用Docker部署Spring Boot应用：

  1. 创建Dockerfile：
FROM openjdk:11-jre-slim
COPY target/*.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]
  1. 构建并运行Docker镜像：
docker build -t spring-boot-app .
docker run -p 8080:8080 spring-boot-app

通过以上步骤，你已经掌握了Spring Boot项目开发的基础知识，并构建了一个简单的博客应用。同时，你也了解了如何打包和部署Spring Boot应用到不同的环境中。

点击查看更多内容
发表于 2024.12.18 13:35， 共 139 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

慕码人8056858

手记
篇
粉丝
351
获赞与收藏
1323

关注作者，订阅最新文章

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消