基础
Spring 是一款开源的轻量级 Java 开发框架，旨在提高开发人员的开发效率以及系统的可维护性。Spring 最核心的思想就是不重新造轮子，开箱即用，提高开发效率。
AOP:（Aspect Oriented Programming）面向切面编程
DAO:(Data Access Object) 数据访问对象
ORM:(Object Relation Mapping)对象关系映射
IoC:(Inversion of Control In)控制反转
DI: (Dependency Injection) 依赖注入
spring是一个IOC和AOP的容器框架。
IOC：控制反转，对象创建责任的反转,负责实例化，定位，配置应用程序中的对象及建立这些对象间的依赖。
AOP：面向切面编程，定义一个切面，在切面的纵向定义处理方法，处理完成之后，回到横向业务流
容器：包含并管理应用对象的生命周期，就好比用桶装水一样，spring就是桶，而对象就是水
spring4.x
Spring5.x
常用模块
- spring core：框架的最基础部分，提供 ioc 和依赖注入特性。
- spring context：构建于 core 封装包基础上的 context 封装包，提供了一种框架式的对象访问方法。
- spring dao：Data Access Object 提供了JDBC的抽象层。
- spring aop：提供了面向切面的编程实现，让你可以自定义拦截器、切点等。
- spring Web：提供了针对 Web 开发的集成特性，例如文件上传，利用 servlet listeners 进行 ioc 容器初始化和针对 Web 的 ApplicationContext。
- spring Web mvc：spring 中的 mvc 封装包提供了 Web 应用的 Model-View-Controller（MVC）的实现。
Spring是如何简化开发
- 基于POJO的轻量级和最小侵入性编程
- 通过依赖注入和面向接口实现松耦合
- 基于切面和惯例进行声明式编程
- 通过切面和模板减少样板式代码
Spring的优缺点
优点：
1，方便解耦，简化开发：
通过spring提供的IOC容器,我们可以将对象之间的依赖关系交由Spring进行控制,避免原编码所造成过度程序耦合;有了spring,用户不再为了单列模式类,属性文件解析等这些很底层的需求编写代码,可以专注于上层的应用的
2，AOP编程的支持:
通过spring提供的AOP功能方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付.spring的AOP支持允许将一些通用任务如安全,事务,日志等进行集中式管理,从而提供了更好的复用
3，声明事务的支持:
在spring中,我们可以从单调烦闷的事务管理代码中解脱出来,通过声明方式灵活地进行事务的管理,提高开发效率和质量
4，方便程序的测试:
可以用非容器依赖编程方式进行几乎所有的测试工作,在spring里,测试不在是昂贵的操作,而是随手课做的事情没列入spring对junit4支持,可以通过注解方便的测试spring程序
5，方便集成各种框架:
spring不排斥各种优秀的开源框架,相反,spring可以降低各种框架的使用难度,spring提供了对各种哟毓秀框架(如Strust,Hibernate,Hessian,Quartz)等的直接支持.
6，降低javaEE API的使用难度:
spring对很多难用的java EE API(如JDBC,javaMail,远程调用等)提供了一个薄薄的封装层,通过spring的简易封装,这些java EE API的使用难度大大降低.
7，非侵入式设计
Spring是一种非侵入式(non-invasive)框架，它可以使应用程序代码对框架的依赖最小化。
缺点：
1、中断了应用程序的逻辑，使代码变得不完整，不直观。此时单从Source无法完全把握应用的所有行为。
2、将原本应该代码化的逻辑配置化，增加了出错的机会以及额外的负担。
3、时光倒退，失去了IDE的支持。在目前IDE功能日益强大的时代，以往代码重构等让人头痛的举动越来越容易。而且IDE还提供了诸多强大的辅助功能，使得编程的门槛降低很多。通常来说，维护代码要比维护配置文件，或者配置文件+代码的混合体要容易的多。
4、调试阶段不直观，后期的bug对应阶段，不容易判断问题所在。
5、spring像一个胶水，将框架黏在一起，后面拆分的话就不容易拆分了。
包名
model（entity）
model是模型的意思，与entity、domain、pojo类似，是存放实体的类，类中定义了多个类属性，并与数据库表的字段保持一致，一张表对应一个model类。 主要用于定义与数据库对象应的属性，提供get/set方法,tostring方法,有参无参构造函数。
dao（mapper）
又被成为mapper层，叫数据持久层，先设计接口，然后在配置文件中进行配置其实现的关联。 dao层的作用为访问数据库，向数据库发送sql语句，完成数据的增删改查任务。 数据持久化操作就是指，把数据放到持久化的介质中，同时提供增删改查操作，比如数据通过hibernate插入到数据库中
service
业务逻辑层，完成功能的设计 和dao层一样都是先设计接口，再创建要实现的类，然后在配置文件中进行配置其实现的关联。接下来就可以在service层调用dao层的接口进行业务逻辑应用的处理。 service的impl是把mapper和service进行整合的文件 封装Service层的业务逻辑有利于业务逻辑的独立性和重复利用性。
controller
控制层，控制业务逻辑service，控制请求和响应，负责前后端交互 controller层主要调用Service层里面的接口控制具体的业务流程，控制的配置也要在配置文件中进行
Spring IoC 的了解
IoC（Inverse of Control:控制反转） 是一种设计思想，而不是一个具体的技术实现。IoC 的思想就是将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理。不过， IoC 并非 Spring 特有，在其他语言中也有应用。
为什么叫控制反转？
- 控制 ：指的是对象创建（实例化、管理）的权力
- 反转 ：控制权交给外部环境（Spring 框架、IoC 容器）
将对象之间的相互依赖关系交给 IoC 容器来管理，并由 IoC 容器完成对象的注入。这样可以很大程度上简化应用的开发，把应用从复杂的依赖关系中解放出来。 IoC 容器就像是一个工厂一样，当我们需要创建一个对象的时候，只需要配置好配置文件/注解即可，完全不用考虑对象是如何被创建出来的。
在实际项目中一个 Service 类可能依赖了很多其他的类，假如我们需要实例化这个 Service，你可能要每次都要搞清这个 Service 所有底层类的构造函数，这可能会把人逼疯。如果利用 IoC 的话，你只需要配置好，然后在需要的地方引用就行了，这大大增加了项目的可维护性且降低了开发难度。
在 Spring 中， IoC 容器是 Spring 用来实现 IoC 的载体， IoC 容器实际上就是个 Map（key，value），Map 中存放的是各种对象。
Spring 时代我们一般通过 XML 文件来配置 Bean，后来开发人员觉得 XML 文件来配置不太好，于是 SpringBoot 注解配置就慢慢开始流行起来。
Spring Bean？
简单来说，Bean 代指的就是那些被 IoC 容器所管理的对象。
我们需要告诉 IoC 容器帮助我们管理哪些对象，这个是通过配置元数据来定义的。
配置元数据可以是 XML 文件、注解或者 Java 配置类。
将一个类声明为 Bean 的注解有哪些?
@Component：通用的注解，可标注任意类为Spring组件。如果一个 Bean 不知道属于哪个层，可以使用@Component注解标注。@Repository: 对应持久层即 Dao 层，主要用于数据库相关操作。@Service: 对应服务层，主要涉及一些复杂的逻辑，需要用到 Dao 层。@Controller: 对应 Spring MVC 控制层，主要用户接受用户请求并调用 Service 层返回数据给前端页面
注入 Bean 的注解有哪些？
Spring 内置的 @Autowired 以及 JDK 内置的 @Resource 和 @Inject 都可以用于注入 Bean。
Bean的实例化
（1）使用构造函数实例化
<!-- 构造器实例化 （无参构造函数） -->
<!-- 默认情况下使用的方式，会自动调用无参构造函数 原理：反射
Class clz = Class.forName(""); clz.newInstance();
-->
<bean id="userService" class="cn.zj.spring.service.UserService"/>（2）静态工厂方法实例化
<!-- 静态工厂实例化 -->
<bean id="userService" class="cn.zj.spring.service.UserServiceFactory"
factory-method="getObject" />
/**
* 静态工厂
* @author
*
*/
public class UserServiceFactory {
public static UserService getObject() {
System.out.println("静态工厂创建了UserService对象");
return new UserService();
}
}（3）实例化工厂
<!-- 实体工厂实例化 -->
<bean id="userService2Factory" class="cn.zj.spring.service.UserService2Factory"/>
<bean id="userService" factory-bean="userService2Factory" factory-method="getObject"/>
/**
* 实体工厂
* @author lgx
*
*/
public class UserService2Factory {
public UserService getObject() {
System.out.println("实体工厂创建了UserService对象");
return new UserService();
}（4）实现FactoryBean接口实例化：实例工厂变种
<!-- 实现FactoryBean接口实例化：实例工厂变种 -->
<bean id="userService"
class="cn.zj.spring.service.UserService3Factory" />
public class UserService3Factory implements FactoryBean<UserService>{
//返回一个对象
@Override
public UserService getObject() throws Exception {
System.out.println("实现FactoryBean实例化");
return new UserService();
}
//返回对象的类型
@Override
public Class<?> getObjectType() {
return null;
}
//是否单例，true是，false不是
@Override
public boolean isSingleton() {
return false;
}Bean的生命周期
初始化容器
1.创建对象(内存分配)
2.执行构造方法
3.执行属性注入(set操作)
==4.执行bean初始化方法==
使用bean
1.执行业务操作
关闭/销毁容器
==1.执行bean销毁方法==
(3)关闭容器的两种方式:
ConfigurableApplicationContext是ApplicationContext的子类
close()方法
registerShutdownHook()方
DI依赖注入
- 谁依赖于谁？
当然是应用程序依赖于IoC容器；
- 为什么需要依赖？
应用程序需要IoC容器来提供对象需要的外部资源；
- 谁注入谁？
很明显是IoC容器注入应用程序某个对象，应用程序依赖的对象；
- 注入了什么？
就是注入某个对象所需要的外部资源（包括对象、资源、常量数据）。
- IoC和DI有什么关系呢？
其实它们是同一个概念的不同角度描述，由于控制反转概念比较含糊（可能只是理解为容器控制对象这一个层面，很难让人想到谁来维护对象关系），所以2004年大师级人物Martin Fowler又给出了一个新的名字：“依赖注入”，相对IoC 而言，“依赖注入”明确描述了“被注入对象依赖IoC容器配置依赖对象”。通俗来说就是IoC是设计思想，DI是实现方式。
1、构造函数注入
我们可以通过 Bean 的带参构造函数，以实现 Bean 的属性注入。
使用构造函数实现属性注入大致步骤如下：
- 在 Bean 中添加一个有参构造函数，构造函数内的每一个参数代表一个需要注入的属性；
- 在 Spring 的 XML 配置文件中，通过 <beans> 及其子元素 <bean> 对 Bean 进行定义；
- 在 <bean> 元素内使用 <constructor-arg> 元素，对构造函数内的属性进行赋值，Bean 的构造函数内有多少参数，就需要使用多少个 <constructor-arg> 元素。
2、setter 注入
我们可以通过 Bean 的 setter 方法，将属性值注入到 Bean 的属性中。
在 Spring 实例化 Bean 的过程中，IoC 容器首先会调用默认的构造方法（无参构造方法）实例化 Bean（Java 对象），然后通过 Java 的反射机制调用这个 Bean 的 setXxx() 方法，将属性值注入到 Bean 中。
使用 setter 注入的方式进行属性注入，大致步骤如下：
- 在 Bean 中提供一个默认的无参构造函数（在没有其他带参构造函数的情况下，可省略），并为所有需要注入的属性提供一个 setXxx() 方法；
- 在 Spring 的 XML 配置文件中，使用 <beans> 及其子元素 <bean> 对 Bean 进行定义；
- 在 <bean> 元素内使用 <property> 元素对各个属性进行赋值
3、短命名空间注入
Spring 框架提供了 2 种短命名空间，可以简化 Spring 的 XML 配置，如下表。
短命名空间 简化的 XML 配置 说明 p 命名空间 <bean> 元素中嵌套的 <property> 元素 是 setter 方式属性注入的一种快捷实现方式 c 命名空间 <bean> 元素中嵌套的 <constructor> 元素 是构造函数属性注入的一种快捷实现方式 p 命名空间注入
p 命名空间是 setter 方式属性注入的一种快捷实现方式。通过它，我们能够以 bean 属性的形式实现 setter 方式的属性注入，而不再使用嵌套的 <property> 元素，以实现简化 Spring 的 XML 配置的目的。
首先我们需要在配置文件的 <beans> 元素中导入以下 XML 约束。
- xmlns:p="http://www.springframework.org/schema/p"
在导入 XML 约束后，我们就能通过以下形式实现属性注入。
- <bean id="Bean 唯一标志符" class="包名+类名" p:普通属性="普通属性值" p:对象属性-ref="对象的引用">
使用 p 命名空间注入依赖时，必须注意以下 3 点：
- Java 类中必须有 setter 方法；
- Java 类中必须有无参构造器（类中不包含任何带参构造函数的情况，无参构造函数默认存在）；
- 在使用 p 命名空间实现属性注入前，XML 配置的 <beans> 元素内必须先导入 p 命名空间的 XML 约束。
4、集合注入
AOP
AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构。
OOP(Object Oriented Programming)面向对象编程
我们都知道OOP是一种编程思想，那么AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序
作用:在不改变原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代理模式。
前面咱们有技术就可以实现这样的功能即代理模式。
核心
代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行
切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
切面（Aspect）：描述通知与切入点的对应关系
目标对象（Target）：被代理的原始对象成为目标对象
我们准备了一个环境，整个环境的内容我们暂时可以不用关注，最主要的类为:BookDaoImpl
@Repository
public class BookDaoImpl implements BookDao {
public void save() {
//记录程序当前执行执行（开始时间）
Long startTime = System.currentTimeMillis();
//业务执行万次
for (int i = 0;i<10000;i++) {
System.out.println("book dao save ...");
}
//记录程序当前执行时间（结束时间）
Long endTime = System.currentTimeMillis();
//计算时间差
Long totalTime = endTime-startTime;
//输出信息
System.out.println("执行万次消耗时间：" + totalTime + "ms");
}
public void update(){
System.out.println("book dao update ...");
}
public void delete(){
System.out.println("book dao delete ...");
}
public void select(){
System.out.println("book dao select ...");
}
}代码的内容相信大家都能够读懂，对于save方法中有计算万次执行消耗的时间。
当在App类中从容器中获取bookDao对象后，分别执行其save,delete,update和select方法后会有如下的打印结果:
这个时候，我们就应该有些疑问?
-
对于计算万次执行消耗的时间只有save方法有，为什么delete和update方法也会有呢?
-
delete和update方法有，那什么select方法为什么又没有呢?
这个案例中其实就使用了Spring的AOP，在不惊动(改动)原有设计(代码)的前提下，想给谁添加功能就给谁添加。这个也就是Spring的理念：
-
无入侵式/无侵入式
(1)Spring的AOP是对一个类的方法在不进行任何修改的前提下实现增强。对于上面的案例中BookServiceImpl中有save,update,delete和select方法,这些方法我们给起了一个名字叫==连接点==
(2)在BookServiceImpl的四个方法中，update和delete只有打印没有计算万次执行消耗时间，但是在运行的时候已经有该功能，那也就是说update和delete方法都已经被增强，所以对于需要增强的方法我们给起了一个名字叫==切入点==
(3)执行BookServiceImpl的update和delete方法的时候都被添加了一个计算万次执行消耗时间的功能，将这个功能抽取到一个方法中，换句话说就是存放共性功能的方法，我们给起了个名字叫==通知==
(4)通知是要增强的内容，会有多个，切入点是需要被增强的方法，也会有多个，那哪个切入点需要添加哪个通知，就需要提前将它们之间的关系描述清楚，那么对于通知和切入点之间的关系描述，我们给起了个名字叫==切面==
(5)通知是一个方法，方法不能独立存在需要被写在一个类中，这个类我们也给起了个名字叫==通知类==
至此AOP中的核心概念就已经介绍完了，总结下:
-
连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等
-
在SpringAOP中，理解为方法的执行
-
-
切入点(Pointcut):匹配连接点的式子
-
在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法
-
一个具体的方法:如com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
-
匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法
-
-
连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。
-
-
通知(Advice):在切入点处执行的操作，也就是共性功能
-
在SpringAOP中，功能最终以方法的形式呈现
-
-
通知类：定义通知的类
-
切面(Aspect):描述通知与切入点的对应关系。
注解开发
启动注解功能
- 启动注解扫描，加载类中配置的注解项
<context:component-scan base-package="packageName"/>
- 说明：
- 在进行包所扫描时，会对配置的包及其子包中所有文件进行扫描
- 扫描过程中以文件夹递归迭代的形式进行的
- 扫描过程仅读取合法的java文件
- 扫描时仅读取spring可识别的注解
- 扫描结束后会将可识别的有效注解转化为spring对应的资源加入IoC容器
- 注意：
- 无论是注解格式还是XML配置格式，最终都是将资源加载到IoC容器中，差别仅仅是数据读取方式不同
- 从加载效率上来说注解优于XML配置文件
mybatis的常用注解
| 注解 | 说明 |
|---|---|
| @Insert | 实现新增 |
| @Delete | 实现删除 |
| @Update | 实现更新 |
| @Select | 实现查询 |
| @Result | 实现结果集封装 |
| @Results | 可以与@Result 一起使用，封装多个结果集 |
| @ResultMap | 实现引用@Results 定义的封装 |
| @One | 实现一对一结果集封装 |
| @Many | 实现一对多结果集封装 |
| @SelectProvider | 实现动态 SQL 映射 |
| @CacheNamespace | 实现注解二级缓存的使用 |
springMVC
SpringBoot
- @SpringBootConfifiguration：组合了 @Confifiguration 注解，实现配置文件的功能。
- @EnableAutoConfifiguration：打开自动配置的功能，也可以关闭某个自动配置的选项， ： java 如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。
- @ComponentScan：Spring组件扫描。
特性
- 能够快速创建基于spring的程序
- 能够直接使用Java main方法启动内嵌的Tomcat服务器运行springboot程序，不需要部署war包
- 提供约定的starter POM来简化Maven配置，让Maven的配置变得简单
- 自动化配置，根据项目的Maven依赖配置，springboot自动配置spring、springmvc等
- 提供了程序的健康检查功能
- 基本可以完全不使用xml配合文件，采用注解配置
注意：Spring Boot 并不是对 Spring 功能上的增强，而是提供了一种快速使用 Spring 的方式。
核心
自动配置
起步依赖
Actuator
命令行界面
结构
static：存放静态资源。如图片、CSS、JavaScript 等
templates：存放 Web 页面的模板文件
application.properties/application.yml 用于存放程序的各种依赖模块的配置信息，比如 服务端口，数据库连接配置等
.gitignore：使用版本控制工具 git 的时候，设置一些忽略提交的内容
Application.java：SpringBoot 程序执行的入口，执行该程序中的 main 方法，启动当前SpringBoot项目。
pom.xml文件
<?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>
<!--继承 SpringBoot 框架的一个父项目，所有自己开发的 Spring Boot 都必须的继承-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.1.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<!--当前项目的 GAV 坐标-->
<groupId>com.bjpowernode.springboot</groupId>
<artifactId>002-springboot-springmvc</artifactId>
<version>1.0.0</version>
<!--maven 项目名称，可以删除-->
<name>002-springboot-springmvc</name>
<!--maven 项目描述，可以删除-->
<description>Demo project for Spring Boot</description>
<!--maven 属性配置，可以在其它地方通过${}方式进行引用-->
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<!--SpringBoot 框架 web 项目起步依赖，通过该依赖自动关联其它依赖，不需要我们一个一个去添加
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--SpringBoot 框架的测试起步依赖，例如：junit 测试，如果不需要的话可以删除-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<!--SpringBoot提供的打包编译等插件-->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project> 
controller
表示层
package tech.pdai.springboot.helloworld.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import tech.pdai.springboot.helloworld.entity.User;
import tech.pdai.springboot.helloworld.service.UserService;
/**
* @author
*/
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
/**
* http://localhost:8080/user/add .
*
* @param user user param
* @return user
*/
@RequestMapping("add")
public User add(User user) {
userService.addUser(user);
return user;
}
/**
* http://localhost:8080/user/list .
*
* @return user list
*/
@GetMapping("list")
public List<User> list() {
return userService.list();
}
}service
业务逻辑层
package tech.pdai.springboot.helloworld.service.impl;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import tech.pdai.springboot.helloworld.dao.UserRepository;
import tech.pdai.springboot.helloworld.entity.User;
import tech.pdai.springboot.helloworld.service.UserService;
/**
* user service impl.
*
* @author
*/
@Service
public class UserServiceImpl implements UserService {
/**
* user dao.
*/
@Autowired
private UserRepository userDao;
/**
* @param user user
*/
@Override
public void addUser(User user) {
userDao.save(user);
}
/**
* @return user list
*/
@Override
public List<User> list() {
return userDao.findAll();
}
}
dao
数据访问层，数据放在内存中。
package tech.pdai.springboot.helloworld.dao;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import org.springframework.stereotype.Repository;
import tech.pdai.springboot.helloworld.entity.User;
/**
* @author
*/
@Repository
public class UserRepository {
private List<User> userDemoList = new ArrayList<>();
public void save(User user) {
userDemoList.add(user);
}
public List<User> findAll() {
return userDemoList;
}
}
entity
model实体层
package tech.pdai.springboot.helloworld.entity;
/**
* User entity.
*
* @author
*/
public class User {
/**
* user id
*/
private int userId;
/**
* username.
*/
private String userName;
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
}springboot配置文件
SpringBoot是基于约定的，所以很多配置都有默认值，但如果想使用自己的配置替换默认配置的话，就可以使用application.properties或者application.yml（application.yaml）进行配置。
-
默认配置文件名称：application
-
在同一级目录下优先级为：properties>yml > yaml
SpringBoot 配置加载顺序?
1、 properties文件 2、YAML文件 3、系统环境变量 4、命令行参数
配置-获取数据
1@Value
#获取普通配置
@Value("${name}")
private String name;
#获取对象属性
@Value("${person.name}")
private String name2;
#获取数组
@Value("${address[0]}")
private String address1;
#获取纯量
@Value("${msg1}")
private String msg1;2Evironment
@Autowired
private Environment env;
System.out.println(env.getProperty("person.name"));
System.out.println(env.getProperty("address[0]"));3 @ConfigurationProperties
注意：prefix一定要写
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
private String name;
private int age;
private String[] address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String[] getAddress() {
return address;
}
public void setAddress(String[] address) {
this.address = address;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
修改controller
@Autowired
private Person person;
System.out.println(person);
String[] address = person.getAddress();
for (String s : address) {
System.out.println(s);
}
去掉报警提示：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>Spring Boot 中如何解决跨域问题 ?
跨域可以在前端通过 JSONP 来解决，但是 JSONP 只可以发送 GET 请求，无法发送其他类型的请求，在 RESTful 风格的应用中，就显得非常鸡肋，因此我们推荐在后端通过 （CORS，Crossorigin resource sharing） 来解决跨域问题。这种解决方案并非 Spring Boot 特有的，在传统的SSM 框架中，就可以通过 CORS 来解决跨域问题，只不过之前我们是在 XML 文件中配置 CORS ，现在可以通过实现WebMvcConfifigurer接口然后重写addCorsMappings方法解决跨域问题。
@Configuration
public class CorsConfig implements WebMvcConfigurer {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/**")
.allowedOrigins("*")
.allowCredentials(true)
.allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
.maxAge(3600);
}
}SpringBoot启动方式？
1. main方法
2. 命令行 java -jar 的方式
3. mvn/gradle
1373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
