Spring Boot(搭建项目初学知识点，涵盖spring核心基础，数据库等知识）

吹泡泡的小叮当

已于 2024-04-07 20:40:24 修改

阅读量1.1k

点赞数 2

分类专栏： Spring全家桶文章标签： spring java spring boot docker 数据库

于 2020-02-19 18:06:26 首次发布

本文链接：https://blog.csdn.net/qq_41110241/article/details/104390519

版权

Spring全家桶专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1 使用Spring Boot2.x开发项目

1.1 Spring核心基础

面向对象编程

1.面向对象开发就是不断的创建对象，使用对象，指挥对象做事情
2.面向对象设计就是在管理和维护对象之间的关系

Spring框架解决了什么问题？

1.Spring 提出了一个很核心的概念—Spring IOC容器
2.我们实际上是通过Spring IOC的一个容器来进行所有的Bean的管理，通过这种Bean的管理，使得解放出来，使得我们可以专注于写业务代码，而不是不停的new对象
3.Spring框架是为了解决应用企业开发的复杂性而创建的

Spring框架核心

1.Spring Boot + Spring Cloud + Spring Cloud Data Flow
2.Spring Boot2.0 两种开发方式 Reactive Stack and Servlet Stack

1.1.1 Spring IOC

什么是Spring IOC？

1.一个系统需要生成多个对象，并且这些对象都需要管理
2.IOC -Inversion of Control 即 ’控制反转‘ ，是一种设计思想。在Java开发中，IOC意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接new控制

依赖注入（Dependency Inversion）

1.以玩具汽车为例子原始方法：从上往下，先设计汽车轮胎，再设计汽车底盘（依赖于汽车轮胎），最后设计汽车车架（依赖于汽车底盘），当要修改汽车轮胎的尺寸时候，那些依赖的部件都需要改变
2.使用依赖注入实现控制反转，即上层控制下层，将依赖部分逐渐注入被依赖的部分。依赖注入的时候，直接注入的是对象，而不是参数
3.依赖注入是将底层类作为参数传递给上层类，实现上对下的控制

Spring IOC容器

1.Bean: 在Spring中，管对象叫做Spring Bean
2.Spring IOC首先是依赖于配置信息，最常用的是通过注解的方式来配置Bean的一些具体信息
3.将Bean的配置信息通过注解的方式，或者xml或者其他的方式进行配置，配置完成以后，当Spring容器在启动的时候，会读取bean的一些配置信息，然后加载到了一个大容器里面（Bean定义注册表），根据注册表来实例化每一个对象，之后将Bean实例放到Spring容器中（Bean的缓存池），当需要用的时候，直接从缓存池中取出来即可
4.Spring IOC容器是如何实现的，有两个对应的接口：a.BeanFactory接口的简单容器 b.ApplicationContext应用上下文

1.1.2 Spring Bean

如何在Spring中定义和注入Spring bean？

Spring bean的使用方法

定义bean
@Component Spring基础的注解，被Spring管理的组件或bean
@Repository 用于持久层，数据库访问层，是用来直接访问数据库的
@Service 用于服务层，处理业务逻辑
@Controller 用于呈现层，（Spring-MVC），暴露给前端的入口
注入bean
@Autowired 默认是按照资源的类型class查找并注入的
@Resource 默认是按照资源的名称name查找并注入的
@Qualifier 采用@Autowired如果存在多个实现类的情况下，@Qualifier注解通过资源名称确定唯一性

Bean的作用域

spring中默认所有的bean都是作为单例(singleton)的形式创建的。不管bean被注入到其他的bean多少次，每次注入的都是同一个实例。

作用域类型	使用范围	作用域描述
singleton	所有Spring应用	默认值，IOC容器值存在单例
prototype	所有Spring应用	每当从IOC容器中取出一个 bean，则创建一个新的bean
session	Spring Web应用	HTTP会话
application	Spring Web应用	Web工厂生命周期
request	Spring Web应用	Web工程单次请求（request）
globalSession	Spring Web应用	在一个全局的Http Session中，一个Bean定义对应一个实例。实践中基本不使用

Spring bean的加载过程

转换为BeanName ----- 从缓存中加载实例 ----- 实例化bean ----- 检查parentBeanFactory -------初始化依赖的bean ---- 创建bean

1.1.3 Spring 约定编程

约定编程就是将内容织入到约定的流程中。

1.你需要记住约定的流程是什么？
2.然后完成对应的编码任务
3.你不需要知道底层设计者是怎么样将约定的内容植入对应的流程

约定编程案例
spring流程约定

1.目标对象：即被代理对象
2.连接点：被拦截的对象（方法）------图中的连接（runCar）
3.切面：定义切点各类通知和引入的内容（拦截器）
4.切点：使用正则表达式和指示器规则去匹配多个类的不同方法
5.通知：按照约定的流程下的方法
------------前置通知后置通知环绕通知事后返回通知异常通知
6.织入：通过动态代理技术，为原有服务对象生成代理对象，然后将与切点定义匹配的连接点拦截，并按照约定将各类通知织入约定流程的过程

只要按照一定的约定规则编程以后，就可以把自己的代码织入约定的流程中

1.1.4 Spring AOP

Spring AOP本质就是通过我们的约定，把对应的方法通过动态代理织入到约定的流程中

1.2 Docker构建环境

Docker的思想来自于集装箱，集装箱解决了什么问题？

Docker: 代码集装箱装卸工
Docker 提供了可将任何需要运送的代码进行封装，转移，管理的标准化工具
所有的软件交付工具，开发，测试，持续集成，部署，版本管理，运行环境，人员技能都按照docker进行统一
Docker就是操作系统级别的虚拟化方案
Docker是一个开源的引擎，可以轻松的为任何应用创建一个轻量级的，可移植的，自给自足的容器

Docker和虚拟机的区别

Docker容器和虚拟机有什么区别？

1.启动级别不在一个数量级上，秒级别和分级别
2.docker直接使用的是硬件资源（Docker Engine）VM还要中间过渡在资源利用率下，Docker是占有有优势的
3.docker利用的是系统的内核，直接加载libs和bins，而vm还需要安装操作系统

Docker的基本组成？

1.Docker镜像就像是一个只读的模板，用来创建Docker容器。（包含一个操作系统和一个mysql）
2.Docker利用容器来运行应用，容器是从镜像创建的运行实例。
3.仓库是集中存放的镜像文件的场所

Docker组成视图如下所示：

1.2.1 Docker安装

windows10家庭版安装步骤如下:

1、下载Docker
a. Docker可以支持在mac、windows、linux上安装。但是在windows系统中Docker目前仅有win10专业版和企业版的安装包，win7/win8/win10家庭版需要通过docker toolbox来安装。
b. 下载地址：http://mirrors.aliyun.com/docker-toolbox/windows/docker-toolbox/
c. Docker的有CE和EE版，CE为免费版，EE由公司支持的付费版，在此选择CE版本。

2、安装Docker
Docker安装比较简单，直接双击下载好的DockerToolbox的exe文件，然后按照默认选项执行安装，安装过程中会提示安装插件，点击同意即可。安装完成后会在桌面上生成三个图标.

3、运行Docker
双击桌面上的Docker Quickstart Terminal图标，进入Docker客户端

4、执行Docker命令
在Docker客户端中执行docker version来查看Docker版本

1.2.2 Docker镜像容器的常用命令

Docker命令操作

1.2.3 使用Docker提供MySql服务

1.2.4 使用Docker提供redis服务

1.3 SpringBoot核心

Spring boot是什么？

Spring boot不是Spring Framwork的升级版不是应用服务器不是代码生成器不是任何规范
Spring Boot是用来简化Spring项目的初始搭建和开发过程

Spring Boot的tex

1.创建可独立运行的Spring 应用程序
2.直接内嵌Yomcat Jetty等应用服务器
3.简化了项目的构建配置
4.自动配置Spring（核心功能）
5.提供了生产级功能，如指标，健康检查
绝对没有代码生成并且对XML也没有配置要求

Spring Boot的核心

1.自动配置—Auto Configuration
2.起步依赖–Starter Denpendency
3.Actuator（提供应用生产环境下的一些功能）
4.命令行界面-Spring Boot CLI

1.3.1 构建Spring Boot项目

创建maven项目引入starters依赖创建主程序启动运行

1.3.2 Spring Boot启动器

Spring Boot的版本仲裁中心

为什么导入依赖的时候Spring Boot会帮助我们定制了版本？
通过版本仲裁中心，在spring-boot-starters-parent中找到spring-boot-dependencies，里面定义了全部的版本号

场景启动器-Starters

例如：spring-boot-starters-web
1.帮我们导入了web模板运行所依赖的组件
2.Spring Boot将所有的功能场景都抽取出来，做成一个个的Starter，只要在项目中引入这些启动器，既可具备这些功能。

1.3.3 Spring Boot自动配置

Spring Boot的自动配置

1.基于添加的JAR依赖自动对Spring Boot应用程序进行配置(把jar包自动配置到spring容器中)
2.将项目包下的所有组件扫描到Spring容器中
3.将场景需要的所有组件注入到Spring容器，并且配置好这些组件

如何开启自动配置？

1.@SpringBootApplication----Spring Boot的一个主配置类
2.@EnableAutoConfiguration----真正的开启Spring的自动配置功能,真正核心的一个注解

自动配置的实现原理

1.第一个层面：将项目包下的所有组件扫描到Spring容器；
@AutoConfigurationPackage:自动配置包
2.第二个层面：将场景需要的所有组件导入Spring容器
META-INF/Spring.factories

1.3.4 定制动态Banner

1.在src/mian/resource路径下新建一个banner.txt文件
2.会借助第三方工具帮忙转化内容(http://www.network-science.de/ascii/)
3.banner.txt文件中填写好需要打印的字符串内容

1.3.5 Spring Boot项目的日志功能（logback）

日志功能需求

将关键数据打印在控制台
将关键数据打印在文件中
日志分类，根据日志不同类型打印到不同文件(info debug warn error等等）
不同的运行环境，打印不同的日志（Dev Test Pro）
日志自动压缩自动清理

Spring Boot的默认日志实现

日志门面 - SLF4J(Spring Boot的默认使用） -------抽象类
{commons logging jboss logging}
日志实现 - LogBack -------实现类
{Log4j Log4J2 java.util.logging}
例子: Logger logger = LoggerFactory.getLogger(hello.class); logger.info(“hello”);

Lombok安装与使用

Lombok能以简单的注解形式来简化Java代码，提高开发人员的开发效率
Lombok能够通过注解的方式，在编译时候自动为属性生成构造器，getting/setting equals hashcode toString方法
开发步骤
1.idea下安装LomBok插件
2.引入org.projectlombok
在需要日志功能的类上面添加@SLF4j的注解即可

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

@RestController
@Slf4j
public class helloController {
    @GetMapping("/hello")
    public String hello(){
        log.info("hello logger"); //默认用log即可（前提是有SLf4j的注解）
        return "hello me";
    }
}

logback介绍

1.Logback的特点：

更快的实现
非常充分测试
非常充分的文档
自动重新加载配置文件
自动压缩
自动去除旧的日志文件

logback日志配置

开发步骤

/resources目录下新建logback-spring.xml
格局规则配置logback-spring.xml
/resources目录下新建application.yml
配置项目环境和日志目录
-logger的常规配置–configuration
-appender：负责写日志的组件
-logger：用来设置某一个类的日志打印级别
-root：是根logger

1.4 Mybatis基础

1.4.1 Spring Data数据访问

Spring Data是什么？

在企业级Java EE引用开发中，对数据库的访问和操作是必须的，Spring Data旨在统一和简化对各类型持久化存储和访问
数据访问技术
-关系型数据库（MySQL）
-非关系型数据库（Redis）
-Map-reduce框架
-基于云的数据访问

Spring Data子项目

Commons -提供共享的基础框架，适合各个子项目使用，支持跨数据库持久化
Hadoop -基于Spring的Hadoop作业配置和一-个POJO编程模型的MapReduce作业
Key-Value - 集成了Redis和Riak，提供多个常用场景下的简单封装
Document-集成文档数据库:CouchDB和MongoDB并提供基本的配置映射和资料库支持
Graph-集成Neo4j提供强大的基于POJO的编程模型
Graph Roo AddOn - Roo support for Neo4j
JDBC Extensions -支持Oracle RAD、高级队列和高级数据类型
JPA-简化创建JPA数据访问层和跨存储的持久层功能
Mapping -基于Grails的提供对象映射框架，支持不同的数据库
Examples -示例程序、文档和图数据库
Guidance -高级文档

1.4.2 Mybatis核心知识

Mybatis数据操作流程

JDBC操作浏览
-编写SQL
-预编译
-设置参数
-执行SQL
-封装结构
Hibernate/JPA操作流程
-通过操作JavaBean就可以操作DB
Mybatis操作流程
-JavaBean和SQL分离（SQL是通过配置文件来管理），半自动方式，SQL是由程序员来控制的
Mybatis是支持定制化SQL 存储过程以及高级映射的优秀的持久层框架
Mybatis避免了几乎所有的JDBC代码和手动设置参数以及获取数据的结果集

Mybatis框架结构

Mybatis中分成三层：接口层、数据处理层、基础支撑层

接口层：提供一些API（数据查询接口、数据新增接口、数据更新接口等）
数据处理层：主要目的就是根据前面的调用请求来完成一次数据库操作
基础支撑层：负责一些最基础的支持，像连接、事务、配置、缓存（这些都是一个优秀的ORM框架所必备的-------ORM：对象关系映射）

Mybatis框架结构

首先,配置Configuration去读取mapping.xml整个的mapper映射，两种读取方式：一种是后缀是xml方式来读取；另一种是Java的一个Annotations的方式进行读取。比较简单的增删改查可以通过Annotations的方式。在这个过程中，会形成一个一个的Mapper，在整个过程中，会有一个比较详细的过程，会有一个sqlSessionFactory，通过它管理sqlSession （可以当成是对应数据库的一个session），之后在Executor这个层面，执行对应的数据操作，再往下有个叫 Mapped Statement，这是一个核心，当API发起一个请求的时候，他就会传入一个对应的SQL的id，然后这个id会在 Mapped Statement对象中查找对应的，就会把sql的输入映射参数进行解析，解析之后执行sql，然后进行输出。

1.4.3 SpringBoot整合Mybatis

Spring Boot整合Mybatis流程

引入所需要的启动器(MySQL+Mybatis)
配置数据源(访问到数据库）

datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/friday?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&useSSL=false&serverTimezone=UTC
    username: root
    password: 
    platform: mysql

mybatis:
  type-aliases-package: com.sxbang.friday.model
  mapper-locations: classpath:/mybatis-mappers/*
  configuration:
    mapUnderscoreToCamelCase: true

配置Mybatis（配置Java Bean，Java Bean要映射到数据表，配置Mapper，定义SQL的一些行为）
编写实体类（针对user表）
编写mapper映射接口
这种mapper接口有两种实现方式，一种是xml的形式，一种是注解的形式，包insert，delete，update ，select注解，value就是sql语句，最后那个接口的实现就是那个sql语句
编写测试代码（Junit测试）

1.4.4 整合Druid和配置数据源

Druid连接池介绍

连接池技术预先建立多个数据库连接对象，然后将连接对象保存到连接池中，当客户请求到来时，从池中取出一个连接对象为客户服务，当请求完成后，客户程序调用 close方法，将连接对象放回池中。

连接池配置

要先引入阿里的连接池启动器

		<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.10</version>
        </dependency>`

    # 连接池指定springboot2.02版本默认使用HikariCP 此处要替换成Druid
    # 下面为连接池的补充设置，应用到上面所有的数据源中
    type:com.alibaba.druid.pool.DruidDataSource
    # 初始化大小：最大 最小
    initialSize: 1
    minIdle: 3
    maxActive: 20
    # 配置获取连接等待超时的时间
    maxWait: 60000
    # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
    timeBetweenEvictionRunsMillis: 60000
    # 配置一个连接在池中的最小生存的时间，单位是毫秒
    minEvictableIdleTimeMillis: 30000
    validationQuery: select 'x'
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    # 是否缓存preparedStatement，打开PSCache，并且指定每个连接上PACache的大小。官方建议MySql下关闭
    poolPreparedStatements: true
    maxPoolPreparedStatementPerConnectionSize: 20
    # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,slf4j
    # 通过connectProperties属性来打开mergeSql功能；慢SQL记录
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000

验证连接池配置以及解决方案

要想真正连接初始化成功，还需要写一个配置类，写上@Configuration的注解

package com.sxbang.friday.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import javax.sql.DataSource;
@Configuration
public class DruidConfig {
    @Bean(destroyMethod = "close",initMethod = "init")
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource getDataSource(){
        return new DruidDataSource();
    }
}

1.4.5 使用注解方式完成数据表的CRD操作

@Mapper注解

为了把mapper这个DAO交给Spring管理
为了不需要再写mapper映射文件
添加@Mapper注解的接口生成一个实现类

@Select注解

考虑表字段和Java属性字段映射的问题

mapUnderscoreToCamelCase方式
数据库字段别名方式
@result/@ResultMap注解方式

    //result/@ResultMap注解方式
	@Select({"select id,user_name,user_password,user_email,user_info,head_img,create_time from sys_user where id = #{id}"})
	@Results(id="userMap", value={
			@Result(column="id", property="id", id=true),
		    @Result(column="user_name", property="userName"),
		    @Result(column="user_password ", property="userPassword"),
		    @Result(column="user_email", property="userEmail"),
		    @Result(column="user_info", property="userInfo"),
		    @Result(column="head_img", property="headImg", jdbcType=JdbcType.BLOB),
		    @Result(column="create_time", property="createTime", jdbcType=JdbcType.TIMESTAMP)
	})
	SysUser selectUserByUserId(Long id);
	
	@Select({"select * from sys_user"})
	@ResultMap("userMap")
	List<SysUser> selectUsers();

动态SQL：#{}和${}

在mybatis中，使用sql查询时，经常需要动态传递参数。大家往往会采用以下方式：

-- 以根据order_no 查询订单信息为例
-- ①
select * from order where order_no = #{orderNo}
-- ②
select * from order where order_no = '${orderNo}'

如果orderNo=’2017111695468435844135’，最后执行后的结果与下面的语句执行结果一样的，但是，有些情况下，我们只能使用其中的某一个。
动态sql 是mybatis优于其他ORM框架的一个重要原因之一。mybatis 在对 sql 语句进行预编译之前，会对 sql 进行动态解析，解析为一个BoundSql 对象，也是在此处对动态 SQL 进行处理的，使得#{}和${}在此处产生了差异。
#{}解析为一个JDBC中prepared statement的参数标记符,即：select * from order where order_no = ?
${}则仅仅是一个纯粹的字符串替换，即：select * from order where order_no = ‘2017111695468435844135’
使用${}在预编译之前已经不包含变量name了,而#{}的变量替换是在DBMS中

为什么需要预编译？

JDBC 中使用对象 PreparedStatement 来抽象预编译语句，使用预编译

预编译阶段可以优化 sql 的执行。预编译之后的 sql 多数情况下可以直接执行，DBMS 不需要再次编译，越复杂的sql，编译的复杂度将越大，预编译阶段可以合并多次操作为一个操作。
预编译语句对象可以重复利用。把一个 sql 预编译后产生的 PreparedStatement 对象缓存下来，下次对于同一个sql，可以直接使用这个缓存的 PreparedState 对象。

表名作为变量时，必须使用${}.表名是字符串，使用 sql 占位符替换字符串时会带上单引号 ‘’，这会导致 sql 语法错误.
@insert注解

不需要返回主键
返回自增主键：@Option --------@Options(useGeneratedKeys = true,keyProperty = “id”)

1.4.6 `使用配置方式完成数据表的U操作`

注解+xml的编写步骤

编写抽象方法

    @Update("update sys_user t set t.password = #{password} where t.id = #{id}")
	int changePassword(@Param("id") Long id, @Param("password") String password);

配置xml的扫描路径

mybatis:
  type-aliases-package: com.sxbang.friday.model
  mapper-locations: classpath:/mybatis-mappers/*
  configuration:
    mapUnderscoreToCamelCase: true

在配置的路径下创建文件夹mybatis-mappers,并且在该文件下编写mapper.xml

<?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.sxbang.friday.dao.UserDao">
	
	<update id="updateUser">
		update sys_user t
		<set>
			<if test="username != null">
				username = #{username},
			</if>
			<if test="nickname != null">
				nickname = #{nickname},
			</if>
			<if test="headImgUrl != null">
				headImgUrl = #{headImgUrl},
			</if>
			<if test="phone != null">
				phone = #{phone},
			</if>
			<if test="telephone != null">
				telephone = #{telephone},
			</if>
			<if test="email != null">
				email = #{email},
			</if>
			<if test="birthday != null">
				birthday = #{birthday},
			</if>
			<if test="sex != null">
				sex = #{sex},
			</if>
			<if test="status != null">
				status = #{status},
			</if>
			updateTime = #{updateTime}
		</set>
		where t.id = #{id}
	</update>

</mapper>

1.4.7 Junit单元测试

单元测试是测试应用程序功能是否能够按照需要正常运行
单元测试是一个对单一实体（类或方法）的测试
单元测试是软件公司提高产品质量、满足客户需求的重要环节
Junit是一个Java语言的单元测试框架

1.4.8 Spring事务以及事务传播行为

执行SQL的事务流程
Spring事务约定
声明式事务和编程式事务

声明式事务：@Transactional
编程式事务：TransactionTemplate

事务传播行为

传播行为是方法之间调用事务采取的策略问题

1.4.9 Spring事务隔离级别

未提交读（脏读）

允许一个事务读取另外一个事务没有提交的数据

读写提交

一个事务只能读取另一个事务已经提交的数据，不能读取未提交的数据。（克服脏读，产生不可重复读场景）

可重复读

克服读写提及哦中出现的不可重复读现象。（产生幻读场景）

串行化

要求所有的SQL按照顺序执行，它能够完全保证数据的一致性

@Transacttional（isolation = Isolation.READ_COMMITTED)

项目类型	脏读	不可重复读	幻读
未提交读	√	√	√
读写提交	×	√	√
可重复读	×	×	√
串行化	×	×	×

1.4.10 Spring事务最佳实践

@Transacttional用法？

@Transacttional 可以用在于接口、接口方法、类以及类方法上。
当作用于类上时，该类的所有public方法都将具有该类型的事务属性。
类内部方法调用本类内部的其他方式并不会引起事务行为。
@Transacttional注解只能应用到public方法上。

1.5 SpringMVC基础

项目结构

1.5.1 SpringMVC的工作流程

springMVC工作流程

DispatchServlet : 中央调度器
HandlerMapping : 处理器映射
Handler : 处理器
HandlerExecutionChain : 执行链
HandlerAdapter : 处理器适配器
ModelAndView对象
ViewResolver : 视图解析器

1.5.2 常用注解命令

常用注解

@Controller : 注解可以认为是被标注类的原型（stereotype），表明了这个类所承担的角色。DispatcherServlet会扫描所有注解了@Controller的类，检测其中通@RequestMapping注解配置的方法

@RestController 为了简化@Controller的工作，@ResponseBody+@Controller

@RequestMapping 映射 path/method 制定映射路径和方法 Params/headers 参数和头
@GetMapping / @PostMapping / @PutMapping / @DeleteMapping

@RequestBody ; 读取Request请求body的数据，绑定到pojo上，作为方法的入参，一般是post请求的时候才会使用这个请求，把参数丢在requestbody里面
@ResponseBody ：表示服务器返回的时候以一种什么样的方式进行返回，将内容或对象作为 HTTP 响应正文返回，值有很多，一般设定为json
@ResponseStatus ：返回常用的状态

定义映射关系

@RequestMapping — path/method 制定映射路径和方法 Params/headers 参数和头

映射方法入参

(一）、@PathVariable

// http://localhost:8080/springmvc/hello/101?param1=10&param2=20
@RequestMapping("/hello/{id}")
    public String getDetails(@PathVariable(value="id") String id,
    @RequestParam(value="param1", required=true) String param1,
    @RequestParam(value="param2", required=false) String param2){
.......
}

(二）、@RequestParam
该注解支持下面四种参数

defaultValue 如果本次请求没有携带这个参数，或者参数为空，那么就会启用默认值
name 绑定本次参数的名称，要跟URL上面的一样
required 这个参数是不是必须的
value 跟name一样的作用，是name属性的一个别名

// http://localhost:8080/springmvc/hello/101?param1=10&param2=20
public String getDetails(
    @RequestParam(value="param1", required=true) String param1,
        @RequestParam(value="param2", required=false) String param2){
...
}

(三）、POJO对象绑定请求参数

处理模型数据

ModelAndView
Map和Model
@SessionAttributes

SpringMVC的学习手册

1.5.3 Thymeleaf模板引擎

Thymeleaf表达式语法
th属性汇总

1.5.4 X-admin和静态资源

Spring Boot 默认指定静态资源到static目录

1.6 Friday项目构建

1.6.1 构建Friday项目

创建Spring Boot项目
配置logback日志
配置数据源&连接池
配置Mybatis
编写demo(Controller service dao model）

1.6.2 构建Friday页面布局

1.6.3 编写工具类

1.6.4 Layui的使用

2. 使用Spring Security完成认证和授权

2.1 权限管理系统的设置

2.1.1 基于RBAC的权限管理

2.1.2 基于RBAC的数据表设计

2.1.3 权限管理功能分析以及初始化数据访问层

2.2 用户管理功能

2.2.1 用户列表

2.2.2 分页功能

2.2.3 用户新增功能

2.2.4 修改用户功能

2.2.5 删除用户功能

2.2.6 模糊查询功能

2.3 角色管理功能

2.3.1 角色增删改查功能

2.3.2 树形结构实现

2.4 菜单管理功能

2.4.1 菜单增删改查功能

2.4.2 树形结构实现

2.4.3 Layui树形表格展示功能

2.5 权限管理（登录）

2.5.1 Spring Security安全框架开发分析

2.5.2 动态菜单生成

2.5.3 Spring Security用户认证逻辑

2.5.4 Spring Security定义用户验证流程

2.5.5 Spring Security控制授权

3. 项目开发的脚手架，作为基础项目

3.1 Druid数据源控制台

3.2 Swagger接口文档

3.3 修改密码功能

3.4自动生成代码功能

吹泡泡的小叮当

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
Spring Boot(搭建项目初学知识点，涵盖spring核心基础，数据库等知识）

1 使用Spring Boot2.x开发项目1.1 Spring核心基础面向对象编程1.面向对象开发就是不断的创建对象，使用对象，指挥对象做事情2.面向对象设计就是在管理和维护对象之间的关系Spring框架解决了什么问题？1.Spring 提出了一个很核心的概念—Spring IOC容器2.我们实际上是通过Spring IOC的一个容器来进行所有的Bean的管理，通过这...
复制链接

扫一扫