【Spring Boot】Spring Boot框架

简九安

已于 2022-11-24 11:57:40 修改

阅读量909

点赞数

分类专栏： java-框架&分布式系统文章标签： spring boot java spring

于 2022-11-21 15:56:22 首次发布

本文链接：https://blog.csdn.net/qq_53844890/article/details/127895624

版权

java-框架&分布式系统专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章目录

Spring Boot
1. 概念
- 特点及其好多
2. springBoot的初体验
- 2.1 .步骤:
3. 配置文件
4. Spring Boot 自动配置
5.Spring Boot常用启动器
6. 综合案例
7.Spring Boot 引入其他组件
8. SpringBoot 项目打包部署

Spring Boot

springBoot的自动装配,springBoot的主要注解自定义拦截器一个小的总和案例打包部署

1. 概念

springBoot是spring的一个子框架,可以做到开箱即用 ,尽可能的减少xml的配置,约定大于配置

特点及其好多

自动装配 : 在SSM框架搭建需要完成很多的配置,但是在springBoot全部已经配置好了
起步依赖: 使用某一一个依赖,直接添加这个依赖的启动器即可,不用引入很多jar包,也不用担心jar包的冲突和整合
简化了spring应用的初始搭建
简单,快速,方便

2. springBoot的初体验

在实践中学习

完成一个浏览器输入地址/路径页面显示内容
例如输入http://localhost:8080/hello 页面上输出 hello SpringBoot初体验

2.1 .步骤:

创建一个Maven项目
添加SpringBoot父工程的依赖,web启动器
创建启动类(项目运行的入口)
编写配置文件(默认路径是8080,也可以不设置)
编写一个Contrller类
启动项目

2.1.1创建项目

在这里插入图片描述

2.1.2 加入依赖

 <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-web</artifactId>
        </dependency>
    </dependencies>

2.1…3 启动类

底层会扫描该类所在包和子包的文件

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

2.1.4 controller类

@RestController //=@Controller+@ResponesBody 那么该类下面的方法都带入响应注解

@RestController  //=@Controller+@ResponesBody  那么下面的方法都带入响应注解
@EnableConfigurationProperties(DataSourceProperties.class)
public class LmqController {

    @Autowired
    private DataSourceProperties dataSourceProperties;
    @RequestMapping("/hello")
    public String hell(){
        System.out.println("dataSourceProperties = " + dataSourceProperties);
        return "你好  springBoot!!  yml";
    }
}

2.1.5 测试

在这里插入图片描述

3. 配置文件

springboot支持二种类型的配置文件
properties属性配置文件
yaml配置文件
配置文件必须放置在项目的类加载目录下, 并且名字必须是application
springboot项目在运行的时候会自动加载这些配置文件
同级目录下打开：spring-configuration-metadata.json

为什么配置文件要创建在resource目录下,和必须有application
因为打开springBoot的启动依赖.点击spring-boot-starter-parent

3.1 配置属性文件

在``resource`文件中创建application.properties配置文件

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

3.2 新建 properties 包，创建类 DataSourceProperties

@Component
@Data
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;
}

3.3 yml配置文件

yml配置文件的特征：
1.树状层级结构展示配置项；
2.配置项之间如果有关系的话需要分行，空两格；
3.配置项如果有值的话，那么需要在 :之后空一格再写配置项值

yaml与properties配置文件除了展示形式不相同以外，其它功能和作用都是一样的

3.4 多环境配置profiles配置

我们刚刚说过在Spring Boot项目中配置文件的名称只能是application , 如果我们把所有的配置全都写在一个配置文件中如果配置项比较多, 配置文件就会显得比较复杂和臃肿 ! 不利于后期的项目维护和开发
例如下面几个场景 :
1.因为开发环境的变化, 我们需要修改配置文件中某一个配置项的值（比如之前是mysql数据库，切换成oracle数据库）
2.项目开发完成需要上线了 , 需要把一些环境修改成正式环境（开发，测试，上线，多环境切换）
解决方案 :使用profiles拆分配置

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

例如有application-dev.yml ,application-pro.yml配置文件.那么就可以有一个application.yml文件,active后面值是哪个配置文件的-**那么就使用那个配置文件

spring:
  profiles:
    active: dev

4. Spring Boot 自动配置

先了解一个注解

4.1 @ConfigurationProperties注解

可以将一些配置属性批量的注入到bean对象
application.yml

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

4.1.1 使用@Value

@Component
@Data  //记得引入依赖lombok
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;

4.1.2 使用@ConfigurationProperties

根据源码分析,所以才会这样写

@Component
@Data
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSourceProperties2 {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
}

@ConfigurationProperties 配置属性类

@EnableConfigurationProperties (配置属性类.class) --开启@ConfigurationProperties 注解,

@SpringBootApplication注解

@SpringBootConfiguration 代表这个类就是一个配置类本质就是一个@Cfinguration注解

@ComponentScan:组件扫描,扫描启动类所在的包或者子包的注解

@EnableAutoConfiguration:自动配置注解,添加了会自动去读去spring.factories配置文件中的自动配置类

4.2 自动装配

① 会在SpringApplication中找到初始化方法

在这里插入图片描述

进入该方法,然后找到加载工厂的名字
进入LoadFactoryNames 找倒加载属性类

进入加载属性类找到了spring.factories,如果有设置配置那么执行设置的配置,如果没有那么就使用默认
在这里插入图片描述

 Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");

例如配置属性 ->1 加载spring.factories,2 加载自动配置类,自动配置类加载完后,3 去加载配置属性类,根据配置属性类读取项目的配置, 读不到就是用默认配置

4.3 自定义启动器

其中包含一种数据源和多种数据源

4.3.1 新建一个项目springboot-jdbc-zj-starter

引入依赖


  <parent>
       <groupId>org.springframework.boot</groupId>
       <version>2.2.2.RELEASE</version>
       <artifactId>spring-boot-starter-parent</artifactId>
   </parent>
   <dependencies>
   <!--引入spring‐boot‐starter；所有starter的基本配置-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter</artifactId>
   </dependency>

   <!--自动配置连接池-->
   <dependency>
       <groupId>com.alibaba</groupId>
       <artifactId>druid</artifactId>
       <version>1.1.12</version>
   </dependency>

       <!---->
   <dependency>
       <groupId>c3p0</groupId>
       <artifactId>c3p0</artifactId>
       <version>0.9.1.2</version>
   </dependency>

       <!--配置属性类的显示-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-configuration-processor</artifactId>
       <optional>true</optional>
   </dependency>
       <dependency>
           <groupId>org.projectlombok</groupId>
           <artifactId>lombok</artifactId>
       </dependency>
   </dependencies>

4.3.1.1 配置启动类

@SpringBootConfiguration
@EnableConfigurationProperties(DataSourceProperties.class)
public class DataSourceAutoConfiguration {

    @Autowired
    private DataSourceProperties dataSourceProperties;

    @Bean
  //这种是多种数据源的配置  ,如果就一种数据源就不用加上属性havingValue = "druid"
    @ConditionalOnProperty(value = "spring.jdbc.datasource.type",havingValue = "druid")
    public DataSource createDataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(dataSourceProperties.getDriverClassName());
        dataSource.setUrl(dataSourceProperties.getUrl());
        dataSource.setPassword(dataSourceProperties.getPassword());
        dataSource.setUsername(dataSourceProperties.getUsername());
        return dataSource;
    }

    @Bean
    @ConditionalOnProperty(value = "spring.jdbc.datasource.type",havingValue = "c3p0")
    public DataSource createC3P0DataSource() throws PropertyVetoException {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(dataSourceProperties.getDriverClassName());
        dataSource.setJdbcUrl(dataSourceProperties.getUrl());
        dataSource.setPassword(dataSourceProperties.getPassword());
        dataSource.setUser(dataSourceProperties.getUsername());
        return dataSource;
    }
}

4.3.1.2 配置属性类

/*
* 属性配置类
* */
@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
@ConfigurationProperties(prefix = "spring.jdbc.datasource")
public class DataSourceProperties {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
}

4.3.1.3 配置文件

是根据自动配置的路径一样的

/resource/WETA-INF/spring.factories

org.springframework.boot.autoconfigure.EnableAutoConfiguration=DataSourceAutoConfiguration类的全类名

4.3.2 打包`install`

4.3.3 引用自定义启动类

引入依赖

   <dependency>
            <groupId>com.zjia</groupId>
            <artifactId>springboot-jdbc-zj-starter</artifactId>
            <version>1.0-SNAPSHOT</version>
  </dependency>

新建 application-datasource.yml
如果配置文件中配置了spring.jdbc.datasource.type=c3p0使用c3p0数据源
如果配置文件中配置了spring.jdbc.datasource.type=druid使用druid数据源

spring:
  jdbc:
    datasource:
      driverClassName: com.mysql.jdbc.Driver
      url: jdbc:mysql:///springboot_01
      username: root 
      password: root
      type: druid  #如果使用的是多种数据源要指定其中的一种

application.yml

spring:
  profiles:
    active: datasource
    #多种配置文件.使用application-** = active值的哪一个配置文件

注入连接池

@RestController
public class DataSourceController {
    @Autowired
    private  DataSource dataSource;//sql的jar包

    @RequestMapping("/dat")
    public String dat(){
        System.out.println("dataSource = " + dataSource.getClass());
        return "自动装配";
    }
}

5.Spring Boot常用启动器

5.1 Spring Boot整合MVC

新建一个项目 springboot02-01mvc

5.1.1 引入依赖

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

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

        <!--方便创建bean对象-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.14</version>
        </dependency>
    </dependencies>

5.1.2 创建启动类

com.zjia.Application.java

package com.zjia;

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);
    }
}

5.1.3 创建bean对象

com.zjia.pojo.User.java

package com.zjia.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String name;
    private Integer age;
}

5.1.4 创建Controller

package com.zjia.controller;

import com.zjia.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

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

@Controller
public class UserController {
    //接口
    @ResponseBody
    @RequestMapping("/findAll")
    public List<User> findAll(){
        List<User> userList = new ArrayList<>();
        userList.add(new User(1,"张三",22));
        userList.add(new User(2,"李四",22));
        userList.add(new User(3,"王五",22));
        return userList;
    }
}

5.1.5 测试

在这里插入图片描述

5.1.6 引入静态资源

在WEB开发中我们经常需要引入一些静态资源 , 例如 : HTML , CSS , JS , 图片等 ,
如果是普通的项目静态资源可以放在项目的webapp目录下现在使用Spring Boot做开发 , 项目中没有webapp目录 ,
我们的项目是一个jar工程，那么就没有webapp，我们的静态资源该放哪里呢？
在springboot中有一个叫做ResourceProperties的类，里面就定义了静态资源的默认查找路径

静态资源的路径:

classpath:/META-INF/resources/
classpath:/resources/
classpath:/static/
classpath:/public
当然也可以自定义

然后执行顺序和配置的顺序一样,如果想改变那么可以在配置文件改变

使用默认的静态资源,浏览器直接输入 http://localhost:8080/index.html
使用自定义覆盖默认的:http://localhost:8080/index.html

5.1.7 配置拦截器

web开发中的拦截器也是我们经常需要使用的组件,可以帮我们完成一些日志记录 , 数据过滤 , 请求过滤等等很多功能，回顾一下SpringMVC中配置拦截器的步骤 :

\1. 编写一个拦截器(实现HandlerInterceptor接口),重写preHandle,postHandl,afterCompletion方法

\2. 注册拦截器(mvc:interceptors)

springmvx.xml

<!--拦截器-->
<mvc:interceptors>

  <ref bean="secondInterceptor"></ref>
  <!--以下两种方式的配置默认对所有请求所对应的控制器方法进行拦截-->
  <!--   <bean class="com.zjia.interceptor.FristInterceptor"></bean>-->
  <!--<ref bean="firstInterceptor" />-->
  <mvc:interceptor>
    <!-- 配置需要拦截的请求
       /*表示上下文路径下任意一次目录的请求
       /**表示所有请求   -->
    <mvc:mapping path="/**"/>
    <!--配置不需要拦截的请求-->
    <mvc:exclude-mapping path="/hello"/>
    <ref bean="firstInterceptor" />
  </mvc:interceptor>
</mvc:interceptors>
<!--

在spring Boot中

/**
 * 定义一个拦截器
 * 但是还需要去注册一个拦截器
 * 如果不注册那么不管用
 */
@Component
public class MyInterceptor  implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("拦截器的preHandler方法  执行在controller之前");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("拦截器...postHandle执行...Controller执行后，DispatcherServlet响应数据前");

    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("拦截器...afterCompletion执行...DispatcherServlet响应数据后");
    }
}

注册一个拦截器

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Autowired
    private MyInterceptor myInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor)  //添加拦截器
        .addPathPatterns("/**"); //拦截的路径
    }
}

5.2 springBoot整合Spring Data JPA

简化了我们持久层开发工作,可以让项目的持久层可以不用写具体的实现代码,简单的sql语句也可以不用自己写(但是封装的一般比自己的写的麻烦),直接写一个继承与JpaRepository,也不需要写实现类

创建maven项目 springboot02-02jpa

5.2.1 引入依赖

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

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

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

    </dependencies>

5.2.2 application.yml

在application.yml中配置数据库和jpa的相关属性
启动的端口号为1808

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

5.2.3 实体类

可以通过实体类在已有的数据库中创建表

package com.zjia.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import javax.persistence.*;

@AllArgsConstructor
@NoArgsConstructor
@Data
@Entity  //标记为实体类
@Table(name="jpa_user") //绑定表名,数据库没有此表则创建,有这使用
public class User {
    @Id //标记为主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) //主键自增长
    //@Column(name = "id") //绑定的列明,当列明与属性名一样时,可以忽略不写
    private Integer id;
    private String name;
    private Integer age;
}

5.2.4 启动类和三层架构

启动类
Application 启动类所放的位置很重要,因为扫描的是启动类所在包的文件和子包的文件,java目录不是包

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

UserController

@Controller
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 查询所有
     * @return
     */
    @GetMapping("findAll")
    public List<User> findAll(){
       return userService.findAll();
    }

    /**
     * 添加
     * @param user
     * @return
     */
    @PostMapping("/add")
    public User add(User user){
        return userService.add(user);
    }

    /**
     * 修改
     */
    @PostMapping("/update")
    public User update(User user){
        return userService.update(user);
    }

    @DeleteMapping("/delete")
    public String delete(Integer id){
        userService.delete(id);
        return "删除成功";
    }
}

UserService 接口

public class UserService{
     List<User> findAll();
     User add(User user);//在SSM框架写的添加返回值是int 类型
     user update(User user);
     User update(User user);
     void delete(Integer id);

}

UserServiceImpl

@Service
public class ServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

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

    @Override
    public User add(User user) {
        //如果存在则修改,不存在则添加
        return userDao.save(user);
    }

    @Override
    public User update(User user) {
        return userDao.save(user);
    }

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

UserDao

package com.zjia.dao;

import com.zjia.pojo.User;
import org.springframework.data.jpa.repository.JpaRepository;

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

5.2.5 测试的方法

就算项目有单元测试类 ,那也必须有启动类

测试的方法有两种

下载软件 ApiPost,在软件中通过接口的路径测试
写单元测试类对服务层实现类进行测试

方式一:ApiPost工具

选择接口方法使用的请求方式,然后输入路径就可以测试接口是否正确

方式二 : junit5 / junit4

使用junit5 和 junit4 区别

SpringBoot的单元测试类所在的包必须要与启动类所在的包一致，或者是其子包
SpringBoot + junit5写法
     @SpringBootTest
     
     @Test  org.junit.jupiter.api.Test  


SpringBoot + junit4写法
     @RunWith(SpringRunner.class)
     @SpringBootTest
     
     @Test  org.junit.Test  

例如 junit5

package com.zjia;


import com.zjia.pojo.User;
import com.zjia.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
public class JpaTest2 {

    @Autowired
    private UserService userService;

    /**
     * 添加
     */
    @Test
    public void add(){
        User user = new User(null, "AAA", 18);
        User add = userService.add(user);
        System.out.println(add);
    }

    /**
     * 修改
     */
    @Test
    public void update(){
        User user = new User(6, "CCC", 28);
        User update = userService.update(user);
        System.out.println(update);
    }

    /**
     * 删除
     */
    @Test
    public void delete(){
        Integer id = 6;
        userService.delete(id);
        System.out.println("删除成功");
    }

    /**
     * 查询
     */
    @Test
    public void select(){
        List<User> userList = userService.findAll();
        userList.forEach(System.out::println);
    }
}

注意

自动生成的表的存储引擎是MyISAM，此引擎不支持事务，需要改为InnoDB,删除数据库对应的表重写启动服务器

创建hibernate.properties配置文件添加以下配置

hibernate.dialect.storage_engine=innodb

6. 综合案例

6.1 环境搭建

6.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');

6.1.2 创建Maven项目 `springboot_case`

6.1.3 导入依赖

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

    <dependencies>
        <!--web启动器-->
        <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>
        </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>
        </dependency>
        <!--druid启动器-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--TkMybatis通用mapper启动器-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper-spring-boot-starter</artifactId>
            <version>2.1.5</version>
        </dependency>

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

        <dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-launcher</artifactId>
            <version>1.5.2</version>
        </dependency>

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

6.1.4 创建启动类

Application

方案一：每个Mapper接口上都写注解 @Mapper * 方案二：启动类上直接扫描包 @MapperScan(basePackages = “com.atguigu.mapper”)

@SpringBootApplication
@MapperScan(basePackages = "com.zjia.mapper")  //生成接口的代理类,这样每一个接口都不用再去写
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

6.2 表现层

6.2.1 新建工具类

Result

@Data
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;
        }
}

6.2.2 表现层代码

UserController

@RestController
public class UserController {
    @Autowired
    private UserService userService;

    //查询所有
    @GetMapping("/findAll")
    public Result findAll(){
        List<User> userList = userService.findAll();
        return Result.ok(userList);
    }

}

6.3 业务层

6.3.1 接口

UserService

public interface UserService {
    //查询所有
    List<User> findAll();

}

6.3.2 实现类

UserServiceImpl

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

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

6.4 数据访问层

6.4.1 编写配置文件

application.yml

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

6.4.2 编写实体类

@NoArgsConstructor
@Table(name="tb_user")
@Entity //实体类
public class User {
    @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;
}

6.4.3 Mapper接口

UserMapper

//@org.apache.ibatis.annotations.Mapper  //可以在每一个接口都添加,也可以在启动类上添加
public interface UserMapper extends Mapper<User> {

}

6.5 引入静态文件

需要打包一下,因为target没有静态文件的

在resources目录下创建static目录 , 将提供的页面复制进来 , 修改即可 :

· 页面异步请求的端口和服务器端口一致

· 页面异步请求访问的路径和对应的表现层控制方法路径要致

· 页面异步请求参数名称和和对应的表现层控制方法参数一致

6.6 页面展示

在这里插入图片描述

6.2 使用-redis缓存

需要在VM虚拟机上启动redis, (我的redis是下载在opt/myRedis目录下) 那么就是进入该目录,① redis-service redis.conf 回车② redis-cli 回车进入
在这里插入图片描述

那么实体类要实现序列化, 就是实现Serializable接口,因为是直接存储到redis的,而不是像之前是转换为json后存储的,
在这里插入图片描述

6.2.1 引入依赖

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

6.2.1 application.yml

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


  redis:
    host: 192.168.38.128
    port: 6379

6.2.3 修改业务层代码

UserServiceImpl

public List<User> findAll() {
        //1.查询redis中是否有数据（缓存）>>>>>>>>>>>>>>

        //绑定一个string类型的key,key的名称是 user-list
        BoundValueOperations userListKey = redisTemplate.boundValueOps("user-list");
        //获取key对应的值
        List<User> userList = (List<User>) userListKey.get(); //IO反序列化 取数据
        if(userList == null){
            //2.Redis中没有数据，查询mysql >>>>>>>>>>>>>>
            userList = userMapper.selectAll();
            //将查询到的数据保存到redis中（缓存数据）   IO序列化存储
            userListKey.set(userList);

            System.out.println("Redis中没有数据，查询mysql >>>>>>>>>>>>>>");
        }else{
            System.out.println("Redis中有数据，返回缓存的数据 >>>>>>>>>>>>>>");
        }

        //返回数据
        return userList;
    }

7.Spring Boot 引入其他组件

待完成…

8. SpringBoot 项目打包部署

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

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

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

④ 执行之后可以在控制台看到打包的日志信息, 其中有生成的包的位置

打开指定目录就可以发现有一个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 .

⑤ 简单总结