Spring Boot 框架 (持续完善中)

最新推荐文章于 2024-07-18 12:14:53 发布

故屿γ

最新推荐文章于 2024-07-18 12:14:53 发布

阅读量276

点赞数

分类专栏： # ————— Spring Boot 文章标签： spring boot

本文链接：https://blog.csdn.net/weixin_49770443/article/details/108527817

版权

————— Spring Boot 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

故屿1

Spring Boot 是什么？

Spring Boot 是一个基于 Spring 的套件，它帮我们预组装了 Spring 的一系列组件，以便以尽可能少的代码和配置来开发基于 Spring 的 Java 应用程序。

Spring Boot 和 Spring 是什么关系？

以汽车为例，如果我们想组装一辆汽车，我们需要发动机、传动、轮胎、底盘、外壳、座椅、内饰等各种部件，然后把它们装配起来。Spring 就相当于提供了一系列这样的部件，但是要装好汽车上路，还需要我们自己动手。而 Spring Boot 则相当于已经帮我们预装好了一辆可以上路的汽车，如果有特殊的要求，例如把发动机从普通款换成涡轮增压款，可以通过修改配置或编写少量代码完成。

因此，Spring Boot 和 Spring 的关系就是整车和零部件的关系，它们不是取代关系，试图跳过 Spring直接学习 Spring Boot 是不可取的。

Spring Boot 的目标就是提供一个开箱即用的应用程序架构，我们基于 Spring Boot 的预置结构继续开发，省时省力。

SpringBoot 核心思想

它的核心思想就是 COC 的运用，【Convention Over Configuration】约定优于配置，它是一种框架的编程理念，在 Spring 框架中，也是有 COC 理念，但是没有在 Spring Boot 彻底。
它的作用其实就是用来约少Spring框架项目的配置，它并没有添加新的技术，也不是什么新的框架。

项目目录结构

1. 它是基于 main 来运行的，打包成 jar 格式
2. 没有 webapp 目录
3. 内嵌 Tomcat 服务器，通过 application.properties 文件可以修改一些默认的配置
4. 在 resources 目录下生成了两个特殊的目录，一个是 static ，另一个 是 templates 目录
5. 生成了一个启动类和测试类，启动类是基于 @SpringBootApplication， 测试类是基于 @SpringBootTest

SpringBoot - ppt 【403.SpringBoot 开发指南全集锦篇】链接：

链接：https://pan.baidu.com/s/1UZizwsiJQZhUHODIl9SiHA
提取码：jf83

Spring boot 的 pom.xml 文件

最关键的是一段 parent 的引入，如下：

<!-- 引用spring-boot-starter 配置 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

注：此处引用的 spring boot 的版本是 2.1.8

Spring Boot 项目的配置文件

支持两种格式，一种是 .properties 属性文件，二种是 .yml 文件，默认文件名如下：

application.properties 文件 [默认]
属性文件的配置缺少层次表达，都是扁平的
冗余较高
优点是简单
application.yml 文件
YAML是一全新数据表达式语法，它支持层次结构，可以有效减少KEY值的冗余

YAML 语法规则

先来对比一下

#properties(示例来源于Springboot User guide):

environments.dev.url=http://dev.bar.com
environments.dev.name=Developer Setup
environments.prod.url=http://foo.bar.com
environments.prod.name=My Cool App
my.servers[0]=dev.bar.com
my.servers[1]=foo.bar.com

YAML 格式

#YAML格式
environments:
    dev:
        url: http://dev.bar.com
        name: Developer Setup
    prod:
        url: http://foo.bar.com
        name: My Cool App
my:
    servers:
        - dev.bar.com
        - foo.bar.com

YAML使用冒号加缩进的方式代表层级（属性）关系，使用短横杠(-)代表数组元素。

基本格式要求

1，YAML大小写敏感；
2，使用缩进代表层级关系；
3，缩进只能使用空格，不能使用TAB，不要求空格个数，只需要相同层级左对齐（一般2个或4个空格）

SpringBoot 整合 JDBC

在 pom.xml 中导入 spring-boot-starter-data-jdbc 或 spring-boot-starter-jdbc 依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

有了上面的依赖，就可以直接在你的 DAO 接口中注入 JdbcTemplate 对象

@Repository   //当然，也可以使用 @Component
public class StudentDaoImpl implements IStudentDao {

    @Autowired
    private JdbcTemplate template;
    
    //....
}

上面2步，就可以完成整合。

Spring Boot 整合 MyBatis

在pom.xml中导入 mybatis-spring-boot-starter 依赖，这个依赖中会间接依赖 spring-boot-starter-jdbc

<dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>

我们需要在 application.yml 配置文件中加入对 mybatis的配置，如下

# mybatis config
mybatis:
  type-aliases-package: com.hc.springboot.entity
  mapper-locations: classpath*:mapper/**/*.xml

编写 mybatis 的接口, 并且要打上 @Mapper 注解

package com.hc.springboot.mapper;

import com.hc.springboot.entity.Account;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

/*****
 * DAO接口，也就是数据持久层接口，本例采用mybatis来实现
 */
@Mapper   //如果没有这个注解，则此类的实例不会被IOC容器管理
public interface IAccountMapper {

    void save(Account account);

    void delete(Integer id);

    void update(Account account);

    Account findById(Integer id);

    Account findByAccountNo(String no);

    List<Account> findAll();

}

编写 mybatis 的映射文件, 一般是存放在 resources 目录下，在上面第2步中，我们指定了 mapper-locations

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hc.springboot.mapper.IAccountMapper">

    <insert id="save" parameterType="account">
        insert into tbl_account(accountNo,idcard,balance,pinCode)
        values(#{accountNo},#{idcard},#{balance},#{pinCode})
    </insert>

    <delete id="delete" parameterType="int">
        delete from tbl_account where id = #{value}
    </delete>

    <update id="update" parameterType="account">
        update tbl_account set
            accountNo=#{accountNo},
            idcard=#{idcard},
            balance=#{balance},
            pinCode=#{pinCode}
            where id = #{id}
    </update>

    <select id="findById" parameterType="int" resultType="account">
        select * from tbl_account where id = #{value}
    </select>

    <select id="findByAccountNo" parameterType="string" resultType="account">
         select * from tbl_account where accountNo = #{value}
    </select>

    <select id="findAll" resultType="account">
        select * from tbl_account
    </select>
</mapper>

Spring Boot 与 JPA 集成

首先我们了解一下持久层的技术和框架
持久层最核心的技术就是 JDBC 【由ORACLE制定的JAVASE中的一个技术标准】
持久层ORM框架有很多，主要有：

Hibernate 框架

一个全自动的ORM框架，程序员无需编写SQL命令，总是以对象的方式与表进行数据互换，所以，在做多表查询时，效率不是很高。

mybatis 框架

一个半自动的ORM框架，程序员是要写原生态的SQL命令，所以说，它的效率方面比Hibernate框架要高，但是，没有Hibernate那么"智能"。

JPA 【Java Persistence Api】是 JAVAEE 规范，它的目的是为了整合现有的 ORM 框架，由这些 ORM 框架去实现这个规范。
所以，Hibernate框架后来也遵守 JPA 规范。
Spring Data Jpa, 也是 JPA 的一个实现，是在 Hibernate 的基础上实现了 JPA。

Spring Boot 与 Spring Data Jpa 整合

在 pom.xml 中导入相关的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>

注： spring-boot-starter-data-jpa 由以下几个主要依赖组成：

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-jdbc</artifactId>
      <version>2.1.8.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>javax.transaction</groupId>
      <artifactId>javax.transaction-api</artifactId>
      <version>1.3</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>javax.xml.bind</groupId>
      <artifactId>jaxb-api</artifactId>
      <version>2.3.1</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.hibernate</groupId>
      <artifactId>hibernate-core</artifactId>
      <version>5.3.11.Final</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.data</groupId>
      <artifactId>spring-data-jpa</artifactId>
      <version>2.1.10.RELEASE</version>
    </dependency>

可以看出，上面引用了 spring-data-jpa 组件，这个组件就是 Spring Data Jpa 实现，而且也引用了 hibernate 框架。

在 application.yml 中加入对 jpa 的配置，如下：

# jpa config
spring: 
  jpa:
    generate-ddl: true
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        dialect: org.hibernate.dialect.MySQL5Dialect

定义你自己的持久层接口，继承 JpaRepository 接口即可。[在 spring framework 的 API 中是没有这个接口，要去 spring data 框架下去查看其 API ]

注：Spring Data 框架是包含 Spring Data JPA
```
 我们来看一下此接口的层次结构：
   Repository<T, ID>   
 		 \\-   JpaRepository <T, ID>
 					\\- PagingAndSortingRepository<T, ID>
 			\\-   JpaRepository <T, ID>
```

在你自己定义的接口上打上 @Repository 注解【可选】

实体类上要写 JPA 的注解，常用的注解有：

 @Entity
 @Table
 @Id
 @GenerateValue
 @Column
 @OneToMany
 @ManyToOne
 @ManyToMany
	 ...

如：

package com.hc.springboot.entity;

import lombok.Data;

import javax.persistence.*;
import java.util.Date;

@Data
@Entity
@Table(name = "TBL_ISSUE")
public class Issue {

    @Id
    @GeneratedValue
    private Long id;
    @Column
    private String title;
    @Column
    private String content;
    @Column
    private Date start_date;
    @Column
    private int status;
}

附录格式：

application.yml 文件

server:
  port: 9090
  servlet:
    context-path: /app

# connection pool
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/spring_demo?characterEncoding=UTF8&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver
    username: root
    password: 123456

  # jpa config
  jpa:
    generate-ddl: true
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true
        dialect: org.hibernate.dialect.MySQL5Dialect

Spring Data JPA 的 API 分析

Repository<T, ID>

标记接口

CrudRepository<T, ID>

save(T)
findById(ID id)
findAll()
…

PagingAndSortingRepository<T, ID>

findAll(Pagable p)
findAll(Sort sort)

JpaRepository<T, ID> extends QueryByExampleExecutor

flush()
saveAndFlush()
…

复杂的查询

QBE, Query By Example

JPA 查询方法名与对应生成的 SQL

其方法名规则命名查询和详细查询语法  见如下参考

参考文档

Spring Boot 与视图技术整合

与 JSP 的整合

注：由于 Spring Boot 对 JSP 的支持很不友好，所以，如果一定要整合 JSP 做为视图技术的话，则需要做如下操作
在 pom.xml 中，导入如下依赖
<dependency>
   <groupId>org.apache.tomcat.embed</groupId>
   <artifactId>tomcat-embed-jasper</artifactId>
   <scope>provided</scope>
</dependency>

<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>jstl</artifactId>
</dependency>
由于 spring Boot 项目是没有 webapp 目录的，而且打包也是 jar 包，所以，还需要手动创建 webapp/WEB-INF/jsp 目录，把你的 jsp 文件放在此目录下

在 application.yml 文件中，添加 JSP 视图解析配置，如下：
spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp
编写控制器如下
@RequestMapping(value = "/issue/list")
    public String listIssue(Model model) {
        List<Issue> issues = issueJpa.findAll();
        //
        model.addAttribute("ISSUE_LIST", issues);
        //
        return "issue/list"; // /WEB-INF/jsp/ issue/list  .jsp
    }
以上就是在 Spring Boot 中整合 JSP 的方式，非常不推荐，如果一定要用 JSP 为视图，那也没有办法，可以参考直接使用 Spring MVC + JSP

与 Thymeleaf 的整合

Spring Boot 对 Thymeleaf 页面模板技术的支持是很好的，所以，也是推荐大家使用 thymeleaf 技术，整合步骤如下：

在 pom.xml 中，导入 thymeleaf 依赖，如下：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

在 application.yml 中，添加如下配置

spring:   
  thymeleaf:
    cache: false         # 开发模式下，关闭缓存
    encoding: UTF-8      # 编码，默认也是 UTF-8
    mode: HTML           # 显示模式
    prefix: classpath:/templates/thymeleaf/ # 自定义的thymeleaf页面模板位置，要加classpath
    suffix: .html      # 页面以 .html 结尾
    servlet:
      content-type: text/html    # 内容类型

开发控制器，如下：

	@RequestMapping(value = "/issue/list")
    public String listIssue(Model model) {
        List<Issue> issues = issueJpa.findAll();
        //
        model.addAttribute("ISSUE_LIST", issues);
        //
        return "issue/list"; // /templates/thymeleaf/ issue/list  .html
    }

静态资源的访问

在 application.yml 中，直接添加如下配置即可
spring:   
  mvc:
    static-path-pattern: /static/**     # ** 表示多级子目录

Thymeleaf 页面模板技术的语法

在你的 HTML 页面中，加入如下的命名空间

<html lang="en" xmlns:th="http://www.thymeleaf.org">

有关 thymeleaf3 的语法知识，请见如下参考

参考文档

回到顶部

Note:
欢迎点赞，留言，转载请在文章页面明显位置给出原文链接
知者，感谢您在茫茫人海中阅读了我的文章
没有个性哪来的签名！
详情请关注点我
持续更新中

故屿γ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring Boot 框架 (持续完善中)

目录标题Spring Boot 是什么？Spring Boot 和 Spring 是什么关系？Spring Boot 是什么？Spring Boot是一个基于Spring的套件，它帮我们预组装了Spring的一系列组件，以便以尽可能少的代码和配置来开发基于Spring的Java应用程序。Spring Boot 和 Spring 是什么关系？以汽车为例，如果我们想组装一辆汽车，我们需要发动机、传动、轮胎、底盘、外壳、座椅、内饰等各种部件，然后把它们装配起来。Spring就相当于提...
复制链接

扫一扫