知新_RL

这个屌丝很懒，什么也没留下！

热门标签

SpringBoot入门教程_springboot入门菜鸟教程

作者：知新_RL | 2024-05-16 01:24:43

踩

springboot入门菜鸟教程

Spring Boot入门教程

Spring Boot 是一种快速构建基于 Spring 框架的应用程序的工具，它能够大幅度减少开发者在项目配置、环境搭建等方面的时间和精力，使得开发者能够更加专注于应用程序本身的逻辑实现。本文将为初学者介绍学习 Spring Boot 的必要知识点。

1. Spring Boot 基础知识

1.1 Spring Boot 简介

Spring Boot 是一个基于 Spring 框架的开源项目，旨在帮助开发者快速构建、开发、测试和部署应用程序。Spring Boot 通过提供自动配置和预定义的依赖项，可以快速集成 Spring 框架的各个组件。

1.2 Spring Boot 的优势

Spring Boot 有以下优势：

简单快速：通过自动配置和预定义的依赖项，可以快速开发、测试和部署应用程序。
高效可靠：Spring Boot 使用了诸如 Tomcat、Jetty 等高效可靠的内置服务器。
可扩展性强：Spring Boot 具有丰富的插件和扩展机制，可以方便地与其他组件集成。

1.3 Spring Boot 的环境要求

Java 8 或更高版本。
Maven 3.3 或更高版本（如果使用 Maven）。

2. Spring Boot 快速入门

2.1 创建 Spring Boot 项目

我们可以使用 Spring Initializr 来快速创建一个 Spring Boot 项目。在浏览器中打开 https://start.spring.io/，选择相应的项目信息，然后点击“Generate”按钮即可。

2.2 编写代码

在创建好的 Spring Boot 项目中，我们可以编写 Java 代码来实现具体的业务逻辑。下面是一个简单的示例：

java

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello, Spring Boot!";
    }
}
1
2
3
4
5
6
7
8

该示例中，我们使用了 Spring Boot 的 @RestController 注解来标注一个 RESTful Web 服务的控制器，使用 @GetMapping 注解来指定一个 GET 请求的 URL 映射。当用户访问 /hello URL 时，将会调用 hello() 方法并返回 “Hello, Spring Boot!” 字符串。

2.3 运行项目

在完成代码编写后，我们可以使用以下命令来启动 Spring Boot 项目：

shell

mvn spring-boot:run
1

该命令会使用 Maven 来构建并启动项目。在 Spring Boot 启动后，我们可以通过访问 http://localhost:8080/hello 来访问该示例中的 Web 服务。

3. Spring Boot 常用功能

3.1 Web 应用程序开发

SpringBoot 提供了丰富的 Web 应用程序开发功能，包括：

3.1.1 RESTful Web 服务

在 Spring Boot 中，我们可以使用 @RestController 注解来标注一个控制器类，使用 @GetMapping、@PostMapping 等注解来指定不同 HTTP 请求的 URL 映射。例如：

java

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

    @Autowired
    private UserService userService;

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }

    @PostMapping
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

该示例中，我们使用了 @RestController 注解来标注一个 RESTful Web 服务的控制器，使用了 @RequestMapping 注解来指定该控制器处理 /users URL 前缀的请求。在控制器中，我们使用了 @Autowired 注解来自动注入一个 UserService 实例，使用了 @GetMapping 和 @PostMapping 注解来指定不同请求方法的 URL 映射，并使用 @PathVariable 和 @RequestBody 注解来获取 URL 参数和请求体中的数据。

3.1.2 模板引擎

Spring Boot 支持多种模板引擎，包括 Thymeleaf、FreeMarker、Velocity 等。我们可以使用这些模板引擎来方便地生成 HTML、XML 等文档。例如，使用 Thymeleaf 来生成 HTML 页面：

html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>Hello, Spring Boot!</title>
</head>
<body>
    <h1 th:text="${message}"></h1>
</body>
</html>
1
2
3
4
5
6
7
8
9
10

在控制器中使用 Model 类来传递数据：

java

@Controller
public class HelloController {

    @GetMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("message", "Hello, Spring Boot!");
        return "hello";
    }
}
1
2
3
4
5
6
7
8
9

3.1.3 静态资源处理

在 Spring Boot 中，我们可以将静态资源（如图片、CSS、JavaScript 文件等）放置在 src/main/resources/static 目录下，Spring Boot 将会自动为这些资源创建 URL 映射。例如，我们可以将一张图片放置在 src/main/resources/static/img 目录下，然后在 HTML 中使用以下代码来引用该图片：

html

<img src="/img/logo.png" alt="logo">
1

3.2 数据访问

Spring Boot 提供了多种数据访问方式，包括 JPA、Hibernate、MyBatis 等。下面是一个使用 JPA 的示例：

3.2.1 创建实体类

java

@Entity
@Table(name = "user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13

该实体类使用了 JPA 的注解来标识实体类，使用 @Table 注解来指定对应的数据库表名。在实体类中，我们使用了 @Id 和 @GeneratedValue 注解来指定主键生成策略，使用 @Column 注解来指定列的属性。

3.2.2 创建数据访问层

java

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
}
1
2
3

该数据访问层接口继承了 Spring Data JPA 的 JpaRepository 接口，实现了对实体类 User 的 CRUD 操作。

3.2.3 创建服务层

java

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

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

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

    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

该服务层使用了 @Autowired 注解来自动注入一个 UserRepository 实例，实现了对实体类 User 的查询和保存操作。

3.3 缓存支持

Spring Boot 提供了对多种缓存系统的支持，包括 Ehcache、Redis、Guava 等。我们可以通过简单地配置来使用这些缓存系统。下面是一个使用 Redis 缓存的示例：

3.3.1 配置 Redis

yaml

spring:
  redis:
    host: localhost
    port: 6379
1
2
3
4

该配置将 Redis 的地址和端口号配置为 localhost 和 6379。

3.3.2 使用 Redis

java

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private RedisTemplate<String, User> redisTemplate;

    public User getUser(Long id) {
        String key = "user:" + id;
        User user = redisTemplate.opsForValue().get(key);
        if (user == null) {
            user = userRepository.findById(id).orElse(null);
            if (user != null) {
                redisTemplate.opsForValue().set(key, user);
            }
        }
        return user;
    }

    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

该服务层使用了 @Autowired 注解来自动注入一个 RedisTemplate 实例，使用 Redis 来缓存查询结果。在查询用户时，先在 Redis 中查找，如果没有找到，则查询数据库并将结果保存到 Redis 中。

3.4 安全支持

Spring Boot 提供了多种安全支持，包括基于表单的身份认证、基于 HTTP Basic 的身份认证、OAuth2 认证等。我们可以通过简单的配置来使用这些安全支持。下面是一个使用基于表单的身份认证的示例：

3.4.1 配置用户信息

java

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
                .withUser("user").password("{noop}password").roles("USER")
                .and()
                .withUser("admin").password("{noop}password").roles("ADMIN");
    }

    // ...
1
2
3
4
5
6
7
8
9
10
11
12
13

该配置类使用了 @Configuration 和 @EnableWebSecurity 注解来指定该类是一个配置类，并开启 Spring Security 的 Web 安全支持。在 configure 方法中，我们使用了 auth.inMemoryAuthentication() 方法来配置基于内存的用户信息，使用 withUser 方法来指定用户名和密码，使用 roles 方法来指定用户角色。

3.4.2 配置安全规则

java

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    // ...

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
                .antMatchers("/admin/**").hasRole("ADMIN")
                .antMatchers("/**").hasAnyRole("USER", "ADMIN")
                .and()
                .formLogin();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

该配置类使用了 @Override 和 protected void configure(HttpSecurity http) 方法来配置安全规则。在该方法中，我们使用了 http.authorizeRequests() 方法来配置请求授权规则，使用 antMatchers 方法来指定匹配请求路径的模式和相应的角色。在本示例中，我们使用 hasRole 方法来指定需要的角色，也可以使用 hasAnyRole 方法来指定多个角色。最后，我们使用 formLogin 方法来开启基于表单的身份认证。

3.5 Web 支持

Spring Boot 提供了对 Web 开发的全面支持，包括基于 Spring MVC 的 Web 开发、WebSocket 支持、REST API 开发、模板引擎等。下面是一个使用 Spring MVC 的示例：

3.5.1 创建控制器

java

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }

    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        return userService.createUser(user);
    }

    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

该控制器使用了 @RestController 注解来标识该类是一个控制器，并自动将响应结果转换为 JSON 格式。在该控制器中，我们使用了 @Autowired 注解来自动注入一个 UserService 实例，实现了对用户信息的查询和创建操作。

3.5.2 配置 Spring MVC

java

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
                .allowedOrigins("*")
                .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
                .allowedHeaders("*");
    }

    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13

该配置类使用了 @Configuration 注解来标识该类是一个配置类，并实现了 WebMvcConfigurer 接口。在该配置类中，我们使用了 addCorsMappings 方法来配置跨域访问规则，使用 allowedOrigins 方法来指定允许跨域访问的源，使用 allowedMethods 方法来指定允许的 HTTP 方法，使用 allowedHeaders方法来指定允许的请求头。

3.6 数据库支持

Spring Boot 提供了对多种数据库的支持，包括关系型数据库（如 MySQL、PostgreSQL、Oracle）、NoSQL 数据库（如 MongoDB）等。下面是一个使用 MySQL 数据库的示例：

3.6.1 创建实体类

java

@Entity
@Table(name = "user")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

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

    @Column(name = "age")
    private Integer age;

    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

该实体类使用了 JPA 的注解来指定实体类对应的数据库表、主键和字段名等信息。在本示例中，我们使用了 @Entity 注解来指定该类是一个实体类，使用 @Table 注解来指定对应的数据库表名，使用 @Id 和 @GeneratedValue 注解来指定主键和自增长策略，使用 @Column 注解来指定字段名。

3.6.2 创建 DAO 接口

java

@Repository
public interface UserRepository extends JpaRepository<User, Long> {

    // ...
}
1
2
3
4
5

该 DAO 接口使用了 @Repository 注解来标识该接口是一个数据访问对象，使用了 JpaRepository<User, Long> 泛型来指定实体类和主键类型。在该接口中，我们可以定义各种数据访问方法，例如查询、新增、修改和删除等。

3.6.3 配置数据源和 JPA

java

@Configuration
@EnableJpaRepositories(basePackages = "com.example.demo.repository")
@EnableTransactionManagement
public class JpaConfig {

    @Autowired
    private Environment env;

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
        dataSource.setUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));
        dataSource.setPassword(env.getProperty("spring.datasource.password"));
        return dataSource;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
        emf.setDataSource(dataSource());
        emf.setPackagesToScan("com.example.demo.entity");
        emf.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
        emf.setJpaProperties(jpaProperties());
        return emf;
    }

    @Bean
    public PlatformTransactionManager transactionManager() {
        JpaTransactionManager tm = new JpaTransactionManager();
        tm.setEntityManagerFactory(entityManagerFactory().getObject());
        return tm;
    }

    private Properties jpaProperties() {
        Properties properties = new Properties();
        properties.setProperty("hibernate.hbm2ddl.auto", "update");
        properties.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQL5InnoDBDialect");
        return properties;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

该配置类使用了 @Configuration 注解来标识该类是一个配置类，并使用了 @EnableJpaRepositories 和 @EnableTransactionManagement 注解来开启 Spring Data JPA 的支持和事务管理支持。在该配置类中，我们使用了 dataSource方法来配置数据源，使用 entityManagerFactory 方法来配置实体管理器工厂，使用 transactionManager 方法来配置事务管理器。在 jpaProperties 方法中，我们指定了使用 Hibernate 作为 JPA 的实现，指定了自动更新数据库结构和 MySQL 数据库方言等信息。

3.6.4 编写控制器

java

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

    @Autowired
    private UserRepository userRepository;

    @GetMapping("")
    public List<User> listUsers() {
        return userRepository.findAll();
    }

    @GetMapping("/{id}")
    public User getUser(@PathVariable Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
    }

    @PostMapping("")
    public User createUser(@RequestBody User user) {
        return userRepository.save(user);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody User user) {
        User existingUser = userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
        existingUser.setName(user.getName());
        existingUser.setAge(user.getAge());
        // ...
        return userRepository.save(existingUser);
    }

    @DeleteMapping("/{id}")
    public void deleteUser(@PathVariable Long id) {
        userRepository.deleteById(id);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

该控制器使用了 @RestController 和 @RequestMapping 注解来标识该类是一个 RESTful API 的控制器，使用了 @Autowired 注解来注入 DAO 对象。在该控制器中，我们定义了各种 HTTP 方法来处理用户的增删改查请求，例如 listUsers 方法用于查询所有用户，getUser 方法用于查询单个用户，createUser 方法用于新增用户，updateUser 方法用于修改用户，deleteUser 方法用于删除用户。

3.6.5 运行应用程序

现在，我们可以通过运行 Spring Boot 应用程序来测试以上示例。首先，我们需要启动一个 MySQL 数据库，并创建名为 test 的数据库。然后，我们需要在 application.properties 文件中配置数据源和 JPA 相关信息，例如：

arduino

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?useSSL=false&serverTimezone=UTC&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=123456

spring.jpa.hibernate.ddl-auto=update
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5InnoDBDialect
1
2
3
4
5
6
7

最后，我们可以运行应用程序并测试 RESTful API。例如，使用 cURL 命令查询所有用户：

bash

$ curl http://localhost:8080/users
[{"id":1,"name":"Tom","age":20},{"id":2,"name":"Jerry","age":21}]
1
2

使用 cURL 命令查询单个用户：

bash

$ curl http://localhost:8080/users/1
{"id":1,"name":"Tom","age":20}
1
2

使用 cURL 命令新增用户：

bash

$ curl -X POST http://localhost:8080/users -H "Content-Type: application/json" -d '{"name": "Mike", "age": 22}'
{"id":3,"name":"Mike","age":22}
1
2

使用 cURL 命令修改用户：

ruby

$ curl -X PUT http://localhost:8080/users/3 -H "Content-Type: application/json" -d '{"name": "John", "age": 23}'
{"id":3,"name":"John","age":23}
1
2

使用 cURL 命令删除用户：

shell

$ curl -X DELETE http://localhost:8080/users/3
1

以上就是一个简单的 Spring Boot 应用程序的示例，我们通过 Spring Boot 快速搭建了一个基于 JPA 和 MySQL 的 RESTful API。通过这个示例，我们学习了如何创建 Spring Boot 应用程序，如何配置数据源和 JPA，如何编写控制器处理 HTTP 请求，以及如何运行 Spring Boot 应用程序。当然，这只是一个简单的示例，实际开发中还需要考虑很多问题，例如安全性、性能等。如果您想深入学习 Spring Boot，建议阅读更多相关文档和书籍，同时积极参与社区，与其他开发者交流学习经验。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/576069