Java：SpringBoot的使用

已于 2023-08-14 16:23:55 修改
阅读量3.6k 收藏 11
点赞数 2
分类专栏： Java 文章标签： java spring boot spring
于 2023-03-25 21:24:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Litt_White/article/details/129764663
版权

目录

一、Spring Boot 概述

Spring Boot：其最主要作用就是帮助开发人员快速的构建庞大的spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让开发人员关注业务而非配置。

二、Spring Boot 快速入门

★1、创建一个手动springboot工程

1.1 步骤

  1. 创建一个空项目，修改jdk版本和maven本地仓库。参考：Java：Idea创建项目和Spring工程基本使用
    在这里插入图片描述

  2. 创建一个module（spring_self）
    在这里插入图片描述

  3. 添加依赖(springboot父工程依赖 , web启动器依赖)
    在这里插入图片描述

  4. 编写启动引导类(springboot项目运行的入口)
    在这里插入图片描述

  5. 编写处理器Controller
    在这里插入图片描述
    在这里插入图片描述

  6. 启动项目

    直接运行main方法就行
    在这里插入图片描述

  7. 简化部署

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

    在这里插入图片描述

  8. 打包测试：

    项目打包成jar包，直接在目标服务器执行即可。

    在这里插入图片描述

1.2 SpringBoot-依赖管理特性

  1. 修改依赖的版本（在pom.xml中）
    <properties>
    <mysql.version>5.1.43</mysql.version>
</properties>

<dependencies>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
</dependencies>
  2. 开发导入starter场景启动器
    • 见到很多 spring-boot-starter-**:**就某种场景
    • 只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
    • 更多SpringBoot所有支持的场景：官网链接
    • 见到的 **-spring-boot-starter：是 第三方为我们提供的简化开发的场景启动器。
  3. 无需关注版本号，自动版本仲裁
    • 引入依赖默认都可以不写版本
    • 引入非版本仲裁的jar，要写版本号。

1.3 Lombok简化开发

Lombok用注解代替bean中类的有参/无参构造器、getter/setter、toString()等鸡肋代码。
使用步骤

  1. spring boot已经管理Lombok。直接引入依赖：pom.xml
 <dependency>
     <groupId>org.projectlombok</groupId>
     <artifactId>lombok</artifactId>
</dependency>
  1. IDEA中File->Settings->Plugins，搜索安装Lombok插件进行安装。
  2. 相关注解使用
    • @Data 替代getter/setter方法
    • @ToString 替代toString方法
    • @NoArgsConstructor 无参构造器
    • @AllArgsConstructor 有参构造器
    • @EqualsAndHashCode 替代hashcode
    • @Slf4j 代替日志打印的

Bean的类中使用说明

@NoArgsConstructor
//@AllArgsConstructor
@Data   
@ToString
@EqualsAndHashCode
public class User {
    private String name;
    private Integer age;

    private Pet pet;
	// 也可以单独写某一个有参构造器，需要注意要注释掉AllArgsConstructor
    public User(String name,Integer age){
        this.name = name;
        this.age = age;
    }
}

简化日志开发

@Slf4j
@RestController
public class HelloController {
    @RequestMapping("/hello")
    public String handle01(@RequestParam("name") String name){
        log.info("请求进来了....");
        return "Hello, Spring Boot 2!"+"你好："+name;
    }
}

2、创建一个自动springboot工程

2.1 步骤

  1. 在上面项目的基础上进行demo创建

  2. 创建一个module（Spring Initializr） 在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

  3. 编写启动引导类(springboot项目运行的入口)

  4. 编写处理器Controller

  5. 启动项目

这三步跟上面一样的

3、配置文件详解

springboot支持二种类型的配置文件

  • properties属性配置文件
  • yaml配置文件（好像后续用这个比较多，写起来方便）

配置文件必须放置在项目的类加载目录下, 并且名字必须是application

3.1 获取properties属性配置文件的信息

注意：
application.properties 配置文件，可以修改多有springboot的配置内容，比如端口号等。
默认配置信息可以参考官方文档左下角的Application Properties内容。

在 resource 文件夹下面新建 application.properties 配置文件

spring.jdbc.datasource.driverClassName=com.mysql.jdbc.driver
spring.jdbc.datasource.url=jdbc:mysql:///springboot_01
spring.jdbc.datasource.username=root
spring.jdbc.datasource.password=root

新建 properties 包，创建类 DataSourceProperties

package com.atguigu.properties;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class DataSourceProperties {

    @Value("${spring.jdbc.datasource.driverClassName}")
    // 注入属性，把application.properties里的spring.jdbc.datasource.driverClassName对应的值，注入到driverClassName中
    private String driverClassName;
    @Value("${spring.jdbc.datasource.url}")
    private String url;
    @Value("${spring.jdbc.datasource.username}")
    private String username;
    @Value("${spring.jdbc.datasource.password}")
    private String password;

    // 生成get set 和 toString方法
    public String getDriverClassName() {
        return driverClassName;
    }

    public void setDriverClassName(String driverClassName) {
        this.driverClassName = driverClassName;
    }

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "DataSourceProperties{" +
                "driverClassName='" + driverClassName + '\'' +
                ", url='" + url + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

在 controller 的 hello 方法中获取配置信息

package com.atguigu.controller;

import com.atguigu.properties.DataSourceProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloSpringBoot {

    @Autowired
    private DataSourceProperties dataSourceProperties;

    @RequestMapping("/hello")
    public String hello(){
        System.out.println("dataSourceProperties = " + dataSourceProperties);
        return "Hello Spring Boot Self !";
    }
}

3.2 yaml配置文件写法

语法 :
1.数据结构用树形结构呈现，通过缩进来表示层级，
2.连续的项目通过减号 ” - ” 来表示
3.键值结构里面的key/value对用冒号 ” : ” 来分隔。
4.YAML配置文件的扩展名是yaml 或 yml

只需要把properties改成yaml文件即可

spring:
  jdbc:
    datasource:
      username: root
#      username: 有两个值的写法
#        - root
#        - root2
      password: root
      driverClassName: com.mysql.jdbc.driver.yaml
      url: jdbc:mysql:///springboot_01/yaml

★3.3 获取yaml属性配置文件的信息

开启 配置文件 的 自定义类绑定的配置提示

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

<!-- 下面插件作用是工程打包时，不将spring-boot-configuration-processor打进包内，让其只在编码的时候有用 -->
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <excludes>
                    <exclude>
                        <groupId>org.springframework.boot</groupId>
                        <artifactId>spring-boot-configuration-processor</artifactId>
                    </exclude>
                </excludes>
            </configuration>
        </plugin>
    </plugins>
</build>

在bean下新建 Person 类和 Pet 类在这里插入图片描述
新建application.yaml文件，并配置上属性
在这里插入图片描述

controller下新建HelloYml文件
在这里插入图片描述
测试接口：http://localhost:8080/person
在这里插入图片描述

4、多环境profile切换配置

spring boot项目中允许使用多个YAML配置文件。
这些文件名称必须为application-***.yml，并且在application.yml中激活。

demo案例
创建application-dev.yml文件

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql:///springboot
      username: root
      password: root

创建application-pro.yml文件

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql:///business
      username: business
      password: business

在 application.yml 文件中添加如下配置
激活配置文件

spring:
  profiles:
    active: dev // 修改active的值（dev/pro）可以切换配置文件

注意

  • 如果properties和yml文件都存在，不存在spring.profiles.active设置，如果有重叠属性，默认以properties优先。
  • 如果设置了spring.profiles.active，并且有重叠属性，以active设置优先。

三、Spring Boot 自动配置

1、@ConfigurationProperties注解

@ConfigurationProperties是SpringBoot提供的重要注解, 他可以将一些配置属性批量注入到bean对象。

application.yml配置文件

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.driver
      url: jdbc:mysql:///springboot_01
      username: root
      password: root

DataSourceProperties.java

public class DataSourceProperties {

    private String driverClassName;
    private String url;
    private String username;
    private String password;
    
    // 省略getter和setter.....
}

方式一 : 使用@Value一个个注入

@Component
public class DataSourceProperties {

    @Value("${spring.jdbc.datasource.driverClassName}")
    private String driverClassName;
    @Value("${spring.jdbc.datasource.url}")
    private String url;
    @Value("${spring.jdbc.datasource.username}")
    private String username;
    @Value("${spring.jdbc.datasource.password}")
    private String password;

    // 省略getter和setter.....
}

方式二 : 使用@ConfigurationProperties批量注入

第一步：批量注入

package com.atguigu.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSourceProperties2 {

    private String driverClassName;
    private String url;
    private String username;
    private String password;
    
     // 省略getter和setter.....
}

1、在类上通过@ConfigurationProperties注解声明该类要读取属性配置
2、prefix="spring.jdbc.datasource" 读取属性文件中前缀为spring.jdbc.datasource的值。前缀和属性名称和配置文件中的key必须要保持一致才可以注入成功
3、Spring Boot默认读取application.properties属性文件

第二步：开启@ConfigurationProperties注解使用

@EnableConfigurationProperties(DataSourceProperties2.class)
@RestController
public class HelloSpringBoot2 {

    @Autowired
    private DataSourceProperties2 dataSourceProperties2;

    @RequestMapping("/hello2")
    public String hello(){
        System.out.println("dataSourceProperties2 = " + dataSourceProperties2);
        return "Hello Spring Boot Self !";
    }
}

四、SpringBoot整合MVC（重要）

1. 创建module: springboot_mvc

2. 添加 起步依赖

在这里插入图片描述

3. 新建入口程序类 Application

 package com.atguigu;

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

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

4. 新建 javabean（entities-User.class）

public class User {
    private String username ;
    private String password ;
    private Integer age ;
    private String sex ;
    // ...省略了getter和setter，toString方法
}

5. 新建 UserController

package com.atguigu.controller;

import com.atguigu.entities.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

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

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

    @RequestMapping("/findAll")
    public List<User> findAll(){
        //查询所有
        List<User> users = new ArrayList<User>();

        User user1 = new User();
        user1.setUsername("杨过");
        user1.setPassword("123456");
        user1.setAge(18);
        user1.setSex("男");

        User user2 = new User();
        user2.setUsername("小龙女");
        user2.setPassword("654321");
        user2.setAge(18);
        user2.setSex("女");

        User user3 = new User();
        user3.setUsername("尹志平");
        user3.setPassword("666666");
        user3.setAge(19);
        user3.setSex("女");

        users.add(user1);
        users.add(user2);
        users.add(user3);

        return users ;

    }
}

6. 启动项目

访问：http://localhost:8080/user/findAll
在这里插入图片描述

7. 访问静态资源目录

现在使用Spring Boot做开发 , 项目中没有webapp目录

在springboot中有一个叫做ResourceProperties的类，里面就定义了静态资源的默认查找路径。

默认的静态资源路径为：

  • classpath:/META-INF/resources/
  • classpath:/resources/
  • classpath:/static/
  • classpath:/public

我们只要静态资源放在这些目录中任何一个，SpringMVC都会帮我们处理。

我们习惯会把静态资源放在classpath:/static/ 目录下。

在这里插入图片描述
通过http://localhost:8080/index.html直接访问静态资源。

8. 自定义拦截器

SpringBoot没有XML配置文件 , 所以 需要借助一个WebMvcConfigurer类帮助我们注册拦截器 , 实现拦截器的具体步骤如下 :

  1. 编写一个拦截器
  2. 通过WebMvcConfigurer注册拦截器
    编写拦截器
package com.atguigu.interceptor;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@Component
public class MySpringMVCInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle---处理请求之前调用");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle---处理请求之后渲染视图之前调用");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion---渲染视图之后调用");

    }
}

注册拦截器

package com.atguigu.config;

import com.atguigu.interceptor.MySpringMVCInterceptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@SpringBootConfiguration //声明当前类是一个配置类
public class MyMVCConfig implements WebMvcConfigurer {
    // 注入我们创建的拦截器
    @Autowired
    private MySpringMVCInterceptor mySpringMVCInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(mySpringMVCInterceptor)
                .addPathPatterns("/user/findAll")//配置拦截的请求
                .excludePathPatterns("/index.html");
    }
}

在这里插入图片描述

五、SpringBoot整合Spring Data JPA（了解）

JPA是Java Persistence API的简称，中文名Java持久层API。
持久层（数据访问层），其功能主要是负责数据库的访问。简单地说就是实现对数据表的增删改查等操作。

1. 创建module: springboot_jpa

2. 添加 起步依赖

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

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.2.RELEASE</version>
    <relativePath/>
</parent>

<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>

    <!-- springBoot JPA的起步依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- MySQL连接驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <!-- 配置使用redis启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

</dependencies>

3. 在application.yml中配置数据库和jpa的相关属性

logging:
  level:
    com.atguigu.dao: debug # 配置日志
spring:
  datasource:
    username: root
    password: root
    url: jdbc:mysql://127.0.0.1:3306/springboot?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    database: mysql
    show-sql: true
    generate-ddl: true
    hibernate:
      ddl-auto: update
      naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy
server:
  port: 18081

注意：Mysql8.x版本，连接时url需要指定时区，并且驱动类包名发生了变化。

4. 创建实体配置实体

package com.atguigu.entities;
import javax.persistence.*;

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

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;
    @Column(name = "username")
    private String username;
    @Column(name = "password")
    private String password;
    @Column(name = "name")
    private String name;
 
    //此处省略setter和getter方法... ...
}

5. 编写UserDao

package com.atguigu.dao;

import com.atguigu.entities.User;
import org.springframework.data.jpa.repository.JpaRepository;

public interface UserDao extends JpaRepository<User, Long> {
}

6. 编写service类

package com.atguigu.service;

import com.atguigu.entities.User;

import java.util.List;

public interface UserService {
    List<User> findAll();

    User getUserById(Long id);

    void saveUser(User user);

    void updateUser(User user);

    void delete(Long id);
}

package com.atguigu.service.impl;

import com.atguigu.dao.UserDao;
import com.atguigu.entities.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public List<User> findAll() {
        return userDao.findAll();
    }

    @Override
    public User getUserById(Long id) {
        return userDao.getOne(id);
    }

    @Override
    public void saveUser(User user) {
        userDao.save(user);
    }

    @Override
    public void updateUser(User user) {
        userDao.save(user);
    }

    @Override
    public void delete(Long id) {
        userDao.deleteById(id);
    }
}

7. 编写controller类

package com.atguigu.controller;

import com.atguigu.entities.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

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

    @Autowired
    private UserService userService;

    @RequestMapping("/findAll")
    public List<User> findAll(){
        List<User> all = userService.findAll();
        return all;
    }
}

8. 编写主程序类

测试运行，控制台打印信息

9. 注意

自动生成的表的存储引擎是MyISAM，此引擎不支持事务，需要该为InnoDB,

创建hibernate.properties配置文件添加以下配置
hibernate.dialect.storage_engine=innodb

删除表重写启动服务器

六. SpringBoot综合案例(应用)（重要）

1. 环境搭建

1.1 数据库准备

create database springboot character set utf8 ;

use springboot ; 

CREATE TABLE `tb_user` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `gender` varchar(5) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `address` varchar(32) DEFAULT NULL,
  `qq` varchar(20) DEFAULT NULL,
  `email` varchar(50) DEFAULT NULL,
  `username` varchar(20) NOT NULL,
  `phone` varchar(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `user_username_uindex` (`username`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

INSERT INTO `tb_user` VALUES (1,'黄蓉','女',38,'桃花岛','212223390222','huangrong222@qq.com','huangrong','15600003333'),(2,'黄老邪','男',58,'湖北省武汉市','212223390','huanglaoxie@qq.com','huanglaoxie','15872320405'),(3,'小龙女','男',18,'湖北省荆门市','212223390','xiaolongnv@qq.com','xiaolongnv','15600004444'),(7,'杨过','男',30,'扬州','212223390','yangguo@qq.com','yangguo','15600005555');

1.2 创建项目及包结构

创建项目 springboot_case

1.3 导入依赖

<?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 http://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.2.2.RELEASE</version>
    </parent>

    <dependencies>
        <!--单元测试启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

        <!--通用mapper启动器依赖-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>
        <!--JDBC启动器依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <!--<version>5.1.47</version>-->
        </dependency>
        <!--druid启动器依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--web启动器依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!--spring boot actuator依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <!--编码工具包-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>

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

    </dependencies>

    <build>
        <plugins>
            <!--spring boot maven插件 , 可以将项目运行依赖的jar包打到我们的项目中-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
    
</project>

1.4 创建启动类

package com.atguigu;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import tk.mybatis.spring.annotation.MapperScan;

@SpringBootApplication
@MapperScan(basePackages = "com.atguigu.dao") // 扫描Mapper接口
@EnableTransactionManagement // 开始事务注解支持
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

2. 数据访问层

2.1 编写配置文件application.yml

server:
  port: 10001
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql:///springboot?serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource
mybatis:
  type-aliases-package: com.atguigu.pojo

2.2 编写实体类User

package com.atguigu.pojo;

import java.io.Serializable;

@Entity
@Table(name = "tb_user")
public class User implements Serializable {
@Id
    private Integer id;
    private String name;
    private String gender;
    private Integer age;
    private String address;
    private String qq;
    private String email;
    private String username;
    private String phone;
	// …省略了getter和setter方法和toString方法
}

2.3 Mapper接口和映射配置

package com.atguigu.dao;

import com.atguigu.pojo.User;
import tk.mybatis.mapper.common.Mapper;
import java.util.List;

public interface UserMapper extends Mapper<User> {
}

2.4 编写测试代码

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {

    @Autowired
    private UserMapper userMapper ;

    @Test
    public void findAll() {
        List<User> users = userMapper.selectAll();
        System.out.println(users);
    }
}

3. 业务层

3.1 编写接口

public interface UserService {

    /**
     * 查询所有用户信息
     * @return
     */
    public List<User> findAll();
}

3.2 编写实现类

package com.atguigu.service.impl;

import com.atguigu.dao.UserMapper;
import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {
    @Autowired
private UserMapper userMapper;

@Override
@Transactional(readOnly = true ,propagation = Propagation.SUPPORTS)
    public List<User> findAll() {
        return userMapper.selectAll();
    }
}

3.3 编写测试代码

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserServiceTest {

    @Autowired
    private UserService userService;

    @Test
    public void findAll() {
        List<User> users = userService.findAll();
        System.out.println(users);
    }
}

Spring Boot整合单元测试 , 需要在测试类上添加二个注解

  1. @RunWith(SpringRunner.class)指定Junit核心运行类
  2. @SpringBootTest 指定这是一个Spring Boot的测试类, 运行时会自动加载Spring Boot运行环境

4. 表现层

4.1 引入起步依赖

<!--Web起步依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<!--编码工具包-->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
</dependency>

4.2 新建工具类

package com.atguigu.utils;

import java.io.Serializable;

public class Result implements Serializable {
    private boolean status ; //响应状态  true  false
    private String msg ;  // 响应信息
    private Object data ;  //处理成功的响应数据

    public static Result ok(Object data){
        Result result = new Result();
        result.setStatus(true);
        result.setData(data);
        return  result ;
    }

    public static Result error(String msg){
        Result result = new Result();
        result.setStatus(false);
        result.setMsg(msg);
        return  result ;
    }
    
    // 生成set get tostring方法
    
}

4.3 编写表现层代码

@Controller
@RequestMapping(path = "/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查询所有用户信息
     * @return
     */
    @RequestMapping(path = "/findAll")
    @ResponseBody
    public Result findAll() {
        List<User> users = userService.findAll();
        return Result.ok(users);
    }
}

4.4 代码测试

使用postman进行测试
在这里插入图片描述

5 页面展示

在resources目录下创建static目录 , 将提供的页面复制进来 , 修改即可 :
• 页面异步请求的端口和服务器端口一致
• 页面异步请求访问的路径和对应的表现层控制方法路径要致
• 页面异步请求参数名称和和对应的表现层控制方法参数一致
在这里插入图片描述

修改之后, 访问页面即可 : localhost:10001/list.html
在这里插入图片描述

6 缓存优化

6.1 缓存需求

在这里插入图片描述

6.2 引入起步依赖

<!--springboot整合redis启动器-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

6.3 编写配置文件

spring:
  redis: # 配置redis
    host: 192.168.6.100
    port: 6379

6.4 修改业务层实现类代码

package com.atguigu.service.impl;

import com.atguigu.mapper.UserMapper;
import com.atguigu.pojo.User;
import com.atguigu.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper ;
    @Autowired
    private RedisTemplate redisTemplate ;

    @Override
    @Transactional(readOnly = true ,propagation = Propagation.SUPPORTS)
    public List<User> findAll() {
        //从缓存中查询数据  规定存储用户信息使用string类型进行存储, 存储的key就是userList
        List<User> userList = (List<User>) redisTemplate.boundValueOps("userList").get();
        //如果缓存中没有数据, 查询数据库 , 将查询到的数据放入缓存
        if(userList==null){
            userList = userMapper.findAll();
            redisTemplate.boundValueOps("userList").set(userList);
            System.out.println("从数据库中查询...");
        }else {
            System.out.println("从缓存中查询.....");
        }

        //如果缓存中有数据, 直接返回
        return userList ;
    }
}

七. Spring Boot项目打包部署(应用)

7.1 项目打包

  1. 在pom.xml中配置Spring Boot项目的maven插件

    <build>
    <plugins>
        <!-- 打jar包时如果不配置该插件，打出来的jar包没有清单文件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

  2. 运行maven的打包命令 : package
    在这里插入图片描述

  3. 打包之前我们需要跳过测试 , 如果不跳过测试那么我们编写的测试类都会被maven自动执行, 可能会出现错误,导致打包不成功
    在这里插入图片描述

  4. 执行之后可以在控制台看到打包的日志信息, 其中有生成的包的位置
    在这里插入图片描述

打开指定目录就可以发现有一个jar包存在 。
仔细观察其实我们会发现 , 在target目录下其实会存在二个jar包 ,

  • 一个是springboot_02-1.0-SNAPSHOT.jar
  • 一个是springboot_02-1.0-SNAPSHOT.jar.original ,

那么这两个jar包有什么区别呢?
我们如果是普通项目打包那么就只会得到一个jar包 , 这个jar包中不包含项目的一些依赖jar包

但是我们现在是一个Spring Boot项目 , 我们希望打完的包能够直接运行, 所以项目中就必须包含他的依赖jar包 , 我们之前在pom.xml中配置一个Spring Boot的maven插件可以在普通包的基础上将我们项目的一些运行及依赖信息打进jar包里面 , 打完包之后将原来的普通包改名为xxx.jar.original , 新打的包为xxx.jar .

  1. 简单总结一下 :
  • .jar.original 是普通jar包，不包含依赖
  • .jar 是可执行jar包，包含了pom中的所有依赖，可以直接用java -jar 命令执行
  • 如果是部署，就用.jar , 如果是给别的项目用，就要给.jar.original这个包

7.2 项目运行

打开命令行运行打出来的包；使用命令：java –jar 包全名
java -jar springboot_02-1.0-SNAPSHOT.jar

Litt_White
关注
专栏目录
Java框架-SpringBoot
zhangxuelong461的博客
02-17 5670
1. SpringBoot简介 SpringBoot是一个默认就集成了绝大部分常规开发时都使用的依赖、完成了绝大部分的常规配置、基于SpringMVC的框架。 SpringBoot的核心思想是约定大于配置，因为在传统的SSM项目中，创建项目后，需要自定义大量的配置，而不同的项目的配置却大同小异，甚至就是完全相同，所以，SpringBoot就直接完成了相关的配置，并要求使用者遵循配置值的约定，例如它...
word源码java-springboot:springboot学习
06-05
word源码java SpringBoot 项目目录 两个项目 配置使用 ==chapter2-7-1 springboot 集成 HttpClient == ==chapter2-0-8 springboot 集成 MockMvc和Swagger2== 工程配置 ==chapter0-0-0 springboot demo== ==chapter0-...
Java Spring Boot 全面教程
极客代码
03-28 4034
Spring Boot 是一种基于 Java 的开源框架，由 Pivotal Software 开发，旨在简化新 Spring 应用程序的初始化、配置和部署过程。它遵循约定优于配置的原则，通过内嵌的Tomcat、Jetty或Undertow等容器，使得开发者能够快速构建独立运行的、生产级别的基于Spring框架的应用程序。Spring Boot 包含了大量的自动配置功能，可智能识别已存在的库并配置相应组件，从而减少手动配置的工作量。
【Java】Spring Boot 教程
最新发布
Young_Pro的博客
08-23 2237
Spring Boot是一个开源的Java框架，旨在简化Spring应用的创建和部署过程。它提供了一种快速和简便的方式来设置、配置和运行新的Spring应用程序，通过“约定优于配置”的原则，减少了传统Spring应用中大量的XML配置，使得开发者能够更加专注于业务逻辑的实现，从而加速开发周期，并轻松创建独立运行的、生产级别的基于Spring的应用程序。在 Spring Boot 中，依赖管理是非常重要的一部分。它通过简化依赖项的引入和版本管理，大大简化了项目的构建和维护过程。
java-springboot
manyi8634的博客
05-16 4326
Spring Boot使得创建独立的，基于生产级别的基于Spring的应用程序变得容易，您可以“运行”它们。大多数Spring Boot应用程序需要最少的Spring配置。SpringBoot其实就是构建Spring应用程序的“脚手架”，能够帮助我们快速的搭建一个Spring项目，并且尽可能减少XML的配置，做到“开箱即用”，让程序员只需要关注业务而不是配置！添加分页启动类</</</</在需要分页位置通过PageHelper.startPage(page,size)启动分页。
Spring Boot——开发新一代Spring应用
weixin_30861459的博客
08-23 202
Spring官方网站本身使用Spring框架开发，随着功能以及业务逻辑的日益复杂，应用伴随着大量的XML配置文件以及复杂的Bean依赖关系。随着Spring 3.0的发布，Spring IO团队逐渐开始摆脱XML配置文件，并且在开发过程中大量使用“约定优先配置”（convention over configuration）的思想来摆脱Spring框架中各类繁复纷杂的配...
java-spring boot光速入门教程（超详细！！）
边走、边悟、迟早变好
07-08 1929
SpringBoot是由Pivotal团队研发的，SpringBoot并不是一门新技术，只是将之前常用的Spring，SpringMVC，data-jpa等常用的框架封装到了一起，帮助你隐藏这些框架的整合细节，实现敏捷开发。SpringBoot就是一个工具集。SpringBoot特点：SpringBoot项目不需要模板化的配置。SpringBoot中整合第三方框架时，只需要导入相应的starter依赖包，就自动整合了。
Java后端开发框架：SpringBoot与SpringCloud+编程知识+开发技术+后端开发框架介绍
06-13
Java后端开发框架：SpringBoot与SpringCloud+编程知识+开发技术+后端开发框架介绍； Java后端开发框架：SpringBoot与SpringCloud+编程知识+开发技术+后端开发框架介绍； Java后端开发框架：SpringBoot与SpringCloud+...
Java毕业设计项目：SpringBoot旅游网站.zip
05-03
Java毕业设计项目：SpringBoot旅游网站 Java毕业设计项目：SpringBoot旅游网站 Java毕业设计项目：SpringBoot旅游网站 Java毕业设计项目：SpringBoot旅游网站 Java毕业设计项目：SpringBoot旅游网站 Java毕业...
基于Java的毕业设计项目源码：SpringBoot高校教材征订管理系统.zip
05-14
基于Java的毕业设计项目源码：SpringBoot高校教材征订管理系统 教材征订系统，是一款基于后台springboot前端thymeleaf框架的开发的教材征订管理系统，主要功能有领书管理，订书管理，系统管理和特殊处理等功能。 ...
一个Java的金牌榜项目源码，启蒙+提高（重点架构：springboot+redis+jdk1.8）.zip
05-05
一个Java的金牌榜项目源码，启蒙+提高（重点架构：springboot+redis+jdk1.8） 一个Java的金牌榜项目源码，启蒙+提高（重点架构：springboot+redis+jdk1.8） 一个Java的金牌榜项目源码，启蒙+提高（重点架构：...
Java 系列之 Springboot
cheers_bin的博客
03-09 2622
以上是总结的Spring boot 原理、搭建过程、整合Mybatis、整合logbacks、整合PageHelper、拓展了打包、异常处理、拦截器等，共自己及大家学习。
java-Spring Boot
qq_40301475的博客
04-02 981
Spring Boot 1. Spring Boot简介 2. Spring Boot快速入门 3. Spring Boot原理分析 4. Spring Boot配置文件 5. Spring Boot与整合其他技术 5.1 Spring Boot整合Mybatis 5.2 Spring Boot整合Junit 5.3 Spring Boot整合Spring Data JPA
【JAVA】Spring Boot
m0_56492261的博客
03-18 408
Spring Boot 对上述 spring 的缺点进行的改善和优化，基于约定优于配置的思想.可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。项目的依赖管理也是一件耗时耗力的事情,在环境搭建时，需要分析要导入大量库的坐标，而且还需要分析导入与之有依赖关，一旦选错依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。虽然 spring 的组件代码是轻量级的,但它的配置却是重量级的。
JavaEE之Spring Boot的使用
学习永不止步
05-04 960
八、Spring Boot Spring 诞生时是 Java 企业版（Java Enterprise Edition，JEE，也称 J2EE）的轻量级代替品。无需开发重量级的 Enterprise JavaBean（EJB），Spring 为企业级 Java 开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java 对象（Plain Old Java Object，POJO）实现了 EJB 的功能。虽然 Spring 的组件代码是轻量级的，但它的配置却是重量级的。 Spring Boot
Java---SpringBoot---SpringBoot
東三城的博客
12-01 2569
SpringBoot快速入门，配置文件，SpringBoot整合junit，SpringBoot整合mybatis
Java---SpringBoot详解一
袁震的博客
07-11 1021
人性本善亦本恶， 喜怒哀乐显真情。 寒冬暖夏皆有道， 善恶终归一念间。 善念慈悲天下广， 恶行自缚梦难安。 人心如镜自省照， 善恶分明照乾坤。
Java学习篇——SpringBoot
热门推荐
zhang19971014的博客
04-19 1万+
1. 关于Spring Boot Spring Boot框架主要解决了创建工程后需要进行繁琐的配置的问题，是一个“开箱即用”的框架，其核心思想是“约定大于配置”。 （多数已约定好该怎么做，不需要配置） 2. 创建Spring Boot工程 使用IntelliJ IDEA的创建向导中的Spring Initializer即可创建Spring Boot工程。 在创建时，如果https://start.spring.io无响应，可尝试替换为https://start.springboot.io...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值