1.springboot框架优势
回忆ssm框架:
添加各种环境的依赖,依赖非常的多,需要一个个jar包进行引入.
还需要划分父子容器,监听器创建父容器,中央控制器创建子容器.
当注册对象到容器时,还需要考虑对象注册父容器还是子容器.
当需要注册对象到容器时,还需要创建xml配置文件,在配置文件中需要bean标签,注册jar包对象到容器.
比如:druid整合spring,添加druid;创建dao.xml,通过bean标准注册DruidDataSource.
比如:mybatis整合spring,添加mybatis,mybatis-spring;创建dao.xml,通过bean标签sqlsessionFactoryBean
在ssm框架中,每一个中间件的整合,都需要做两个事情:添加jar包,创建xml注册组件核心的bean.创建以及维护很繁琐。在web开发领域相比于市面上其他开发语言Ruby,python.GO落伍.开箱即用.
（中间件就是那些组件，比如redis是缓存中间件，mybatis是持久层中间件）
（Ruby,python,Go诞生是为了做数据分析，机器学习。开箱即用，比如python的jango框架，创建出来后，dao，service，缓存，controller等都有了。）
springboot是对ssm框架搭建的简化,使开发人员不再注重于各种中间件的整合,springboot提供了预配置(依赖包,配置文件);
ssm是springboot前置技术,springboot是springcloud前置技术,springcloud是alibabaspringCloud前置技术.
springboot版本2.6.6. 最稳定的版本2.3.3-2.3.5,与springCloud兼容性最优.
2.创建springboot项目
有两种方式
1.手工创建maven项目,在pom文件中引入springboot的相关依赖.定义成骨架信息.
（建议使用该方式，因为不需要连网，springboot官网常常连不上）
①.pom.xml
pom文件具体如下：
<?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>
<groupId>com.javasm</groupId>
<artifactId>old0617boot</artifactId>
<version>1.0</version>
<!--打包方式为jar,packaging可以省略-->
<!--标准的springboot框架的项目结构如下:-->
<!--1.引入springboot父工程,统一管理依赖项的版本,使子工程不需要指定版本-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.5.RELEASE</version> <!--使用springboot最稳定的版本-->
</parent>
<!--2.指定maven-resource-plugin与maven-compile-plugin-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
</properties>
<!--3.添加依赖-->
<dependencies>
<!--spring-boot-starter-web包含如下依赖:（预配置）
spring,mvc,jackson,tomcat (有了4种环境)
还引入了一个特别特别重要的依赖:spring-boot-starter，它又包含spring-boot-autoconfigure.
spring-boot-autoconfigure包中,包含有各种开发中常用中间件的配置类（可理解成各种xml常规配置文件）
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
<!--4.配置spring-boot-maven-plugin插件.暂时可以不用配置,但是一个完整的springboot项目是需要的-->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>②.创建主类（启动类）
然后测试
（这里参数漏掉了@PathVariable）
开始启动
访问
再测试文件上传
访问
③.做成骨架前进行完善
在resources包下新建templates目录，新建application.properties文件
在pom.xml文件中加入两个依赖
<!--热部署依赖,在开发中如果改变了代码.之前需要重启服务器,对全部的资源都做重新加载.有了热部署依赖后,结合Ctrl+F9快捷键,只对改变的代码做重新编译加载-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>在test.java包下新建com.javasm.TestApplication
（注意这里@test不是junit4，因为pom引入的test依赖，它依赖的是junit5）
这样就和官方下载的基本一致了。
④.将该项目做成骨架（略）
2. 基于springboot官方提供的项目引导器来创建(要求必须联网)https://start.spring.io/
进入官网https://start.spring.io/,一步步进行即可. 或者idea集成了引导器.
运行main方法,启动项目,默认tomcat端口8080,默认部署路径''（空）.
3.认识springboot项目目录结构
它还是个maven工程
src/main/java:java源代码,该包下有main启动类
src/main/resources/static:放静态资源(html,css,js,图片,视频等)
src/main/resources/templates:放动态视图资源(jsp模板,thymeleaf模板,freemarker模板).同步开发使用.
src/main/resources/applicaiton.properties:springboot的核心配置文件,一般该配置文件会改成yml后缀（如果配置文件的图标不是如图所示，一定有问题，比如文件名打错，导致没有被idea识别成springboot项目）
4.认识boot项目pom文件
这里改成用java.version指定jdk版本。（这里用的idea2018，对应用的jdk8）
（因为父工程已经指定，见下图）
父工程:见代码注解
ctrl+点击spring-boot-starter-parent，看到父工程的父工程
spring-boot-dependencies: 此父工程指定了在服务端开发中各种常用的中间件的版本.这些版本之间兼容性之间进行过测试.
注意:springboot的父工程并不是必须的.一个springboot框架中最重要的依赖是:spring-boot-starter.只要有这个依赖,此项目就可以说是springboot项目.（若没有该父工程标签，下面的依赖就需要自己指定版本信息）（很多开源项目就不指定父工程）
这两个父工程合起来，给出了默认的配置：1.jdk的默认配置 2.默认的编码格式 3.默认的识别位置（src.java src.resources ... ） 4.指定了各种常用依赖的版本信息（springboot的版本升级主要就是引入新的依赖，常用版本更换等）
starter启动器依赖:
starter是springboot框架中的一个新的概念,本质仍然是一个依赖jar包,是某个中间件整合spring环境需要引入的依赖包与配置类的整合.本质就是一个pom文件.（依赖包与配置类的整合就叫启动器）
spring-boot-maven-plugin插件:
是对maven-jar-plugin插件（打jar包用的）打的包做二次重打包,指定当前工程的main方法所在的类作为start-class.能够使jar包以java -jar的方式运行起来.
此时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>
<groupId>com.javasm</groupId>
<artifactId>old0617boot</artifactId>
<version>1.0</version>
<!--打包方式为jar,packaging可以省略-->
<!--标准的springboot框架的项目结构如下:-->
<!--1.引入springboot父工程,统一管理依赖项的版本,使子工程不需要指定版本-->
<!--指定的springboot版本是父工程版本-->
<!--之前的maven父工程是一个pom工程，有pom文件，父工程中可以定义所有子工程自动继承的依赖,管理全部依赖项的版本信息.-->
<!--此父工程中指定了maven-compile-plugin编译插件的默认jdk版本;
指定了maven-resource-plugin资源插件的默认编码格式;
指定了maven-resource-plugin资源插件的识别文件.-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.5.RELEASE</version> <!--使用springboot最稳定的版本-->
</parent>
<!--2.指定maven-resource-plugin与maven-compile-plugin-->
<properties>
<java.version>1.8</java.version>
</properties>
<!--3.添加依赖-->
<dependencies>
<!--spring-boot-starter-web包含如下依赖:（预配置）
spring,mvc,jackson,tomcat (有了4种环境)
还引入了一个特别特别重要的依赖:spring-boot-starter，它又包含spring-boot-autoconfigure.
spring-boot-autoconfigure包中,包含有各种开发中常用中间件的配置类（可理解成各种xml常规配置文件）
-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<!--热部署依赖,在开发中如果改变了代码.之前需要重启服务器,对全部的资源都做重新加载.有了热部署依赖后,结合Ctrl+F9快捷键,只对改变的代码做重新编译加载-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<!--4.配置spring-boot-maven-plugin插件.暂时可以不用配置,但是一个完整的springboot项目是需要的-->
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>5.springboot项目运行方式
-
开发时,运行main方法即可;
-
服务器部署,以jar包方式部署,前提是工程下引入spring-boot-maven-plugin插件,指定启动类位置.
-
服务器部署,以war包方式部署:当服务器有优化性更好的应用服务器的话,我们需要把工程打war包放在tomcat的webapps目录下运行
1.修改项目打包方式为war
<packaging>war</packaging>
2.指定打包名（有默认名字，但会带版本号）
<finalName>0418boot</finalName>
3.把内嵌的tomcat服务器设置为provided作用域.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
4.从SpringBootServletInitializer派生子类,重写configure方法,指定主启动类.
//等价于web.xml角色,是项目的入口类
public class InitBootApplication extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(BootApplication.class);
}
}
之后就可以打war包了，若没有该入口类， 就相当于jar包没有main方法，tomcat会不知道启动哪个项目。
5.打包
先清理
打包
6.将该包放到tomcat下，启动tomcat时运行
启动tomcat
会加载该war包（解压该war包，并启动）。
有该标志，说明识别到了springboot项目。
启动成功后，可看到war包结构，放jar包的地方也没有tomcat包
7.访问该项目
部署路径
访问手机号
以war包形式运行，是为了用到第三方的应用服务器，这套服务器性能比内嵌服务器性能优秀。
注意:开发时main方法启动项目,需要内嵌tomcat设置的provided去掉.
服务器部署，还可以以容器的方式部署，第四阶段学。
6.starter启动器
有两类启动器:
官方启动器:spring-boot-starter-XXX: springboot开发组主动对某个中间件编写的启动器,比如:spring-boot-starter-web;-redis;-jdbc...
所有的官方启动器依赖中都没有配置类,配置类全部放在spring-boot-autoconfiguration包下.
第三方启动器:XXX-spring-boot-starter:比如mybatis-spring-boot-starter,是mybatis开发组主动打包的启动器,向springboot框架中集成.
此启动器中,含有mybaits.mybatis-spring,spring-jdbc;spring-tx;HikariCP依赖,还含有mybatis-spring-boot-autofiguration包,此包下有MybatisAutoConfiguratin配置类.此配置类下通过@Bean注解注册了SqlSessionFactory对象与MapperScannerConfigurer对象到spring容器.
总结:什么是启动器?
是某个组件整合spring环境,用到的全部依赖包与配置类的整合.为了简化ssm框架繁琐的xml配置与依赖引入.启动器分为官方与第三方.一般官方启动器中的配置类都在spring-boot-autoconfiguratin包下.第三方的启动类,会自己引入.
后续在学习其他组件,在向springboot框架整合时,如果有启动器,则优先引入启动器,如果没有启动器,则说明非常小众,需要手工引入jar依赖包,手工注册bean对象到容器.有启动器的话,一定一定要找到该组件内的配置类,阅读配置类,查看配置类中注册了哪些bean到容器.
我们在项目中引入mybaits-spring-boot-starter依赖,相当于之前:
<!--1个druid连接池包-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>${druid.version}</version>
</dependency>
<!--1个mybatis核心包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<!--1个mybaits-spring整合包-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>${mybatis.spring.version}</version>
</dependency>
<!--2个spring-jdbc事务管理包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${spring.version}</version>
</dependency>
<!--凡是Resource类型的参数,都是路径,以classpath:开头-->
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="mapperLocations" value="classpath:mapper/*/*.xml"></property>
<property name="plugins">
<array>
<bean class="com.github.pagehelper.PageInterceptor">
<property name="properties">
<value>reasonable=true</value>
</property>
</bean>
</array>
</property>
<property name="typeAliasesPackage" value="com.javasm"></property>
<property name="configLocation" value="classpath:mybatis.xml"></property>
</bean>
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.javasm.*.dao"></property>
</bean>
7.spring-dev-tools启动器
<!--热部署,在开发中如果改变了代码.之前需要重启服务器,对全部的资源都做重新加载.有了热部署依赖后,结合Ctrl+F9快捷键,只对改变的代码做重新编译加载--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> ----不可以打包，只在运行时有效 </dependency>
除了工具类的是runtime，很少有插件的scope是runtime。不参与编译，不参与打包。
是springboot开发必加的依赖，可以提高开发效率。
示例，改变代码，不重启tomcat，不会产生效果：（改后的内容未编译，内存里加载的字节码文件还是以前的）
之前会点debug或者run进行重新部署，但在springboot，点击这俩按钮，会重开一个窗口，此时上图的窗口还在运行，就会报8080端口被占用了。
这是新启一个窗口，想重启
但这很耗时，不想重启，ctrl+F9即可。
8.spring-boot-starter-test
junit5整合启动器.junit5中的@Test注解包名:import org.junit.jupiter.api.Test;
控制层要启动tomcat，主要是测服务层。
示例：
想测该服务层
可以在服务层注入，再启动tomcat测
另外也可在test包下，使用@SpringBootTest注解。在测试类中使用@SpringBootTest注解即可,该注解自动查找带有@SpringbootApplication注解的类,启动spring容器（完成初始化容器，之后就可注入对象，进行方法测试）。需要测试哪个对象，注入对象即可进行方法测试。
9.springboot配置文件
springboot中配置文件支持.properties与.yml（牙某）或.yaml. 一般我们都是用yml风格的配置文件.
properties文件的优先级较高.
当配置量多得时候,yml文件的可读性更加好.建议使用yml文件作为主配置
（在配置文件中我们配置redis连接信息，mysql连接信息等自定义的配置数据）
示例：将8080端口改为8081，切换到主启动类，启动
部署路径由空改为/boot
tomcat最大允许的链接数，默认100，这里改为200
用yml配置部署路径
再加个端口（会自动对齐，同样前缀的内容在同一层级）
这个文件和properties文件都生效，但properties优先级更高
springboot如何读取自定义配置信息?
①.可以使用@Value注解获取单个配置数据.
(麻烦，不建议使用)
②.建议使用@ConfigurationProperties注解指定配置的前缀,统一数据自定义数据.
其实不用记，随便点一个配置信息 prefix指定一个前缀。ignoreUnKnownFields，忽略一些不可识别的字段 按照它这个配置来自定义配置 获取配置信息时，建好一个类，剩下的复制 测试：
看一下ServerProperties,它有个静态内部类 仿照这个，在CrmProperties类：
private BackPwdToken backToken;
private LoginToken loginToken;
public static class BackPwdToken{ //找回密码封装成一个静态内部类
private String tokenKey;
private Long expMills;
public String getTokenKey() {
return tokenKey;
}
public void setTokenKey(String tokenKey) {
this.tokenKey = tokenKey;
}
public Long getExpMills() {
return expMills;
}
public void setExpMills(Long expMills) {
this.expMills = expMills;
}
}
public static class LoginToken{ //系统相关信息封装成一个静态内部类
private String loginTokenKey;
private Long expMills;
public String getLoginTokenKey() {
return loginTokenKey;
}
public void setLoginTokenKey(String loginTokenKey) {
this.loginTokenKey = loginTokenKey;
}
public Long getExpMills() {
return expMills;
}
public void setExpMills(Long expMills) {
this.expMills = expMills;
}
}对应的在配置文件里：
注意点：yml文件中的语法：
-
缩进要统一，使用空格进行缩进。
-
冒号后必须空格，再打数据。
-
大小写敏感
-
集合注入:可以使用[] ,可以使用-
-
字符串数据可以使用引号,也可以不使用
-
日期格式必须是/分割的年月日
server:
servlet:
context-path: /boot2
port: 8082
#自定义配置
crm:
root: D:/upload
version: 1.1
lastUpdate: 2022/11/11 12:12:12
teams: [张三,李四,王五,admin]
teams2:
- aaa
- bbb
- ccc
mapInfo: {a: 1,b: 2,c: 3}
backToken:
tokenKey: abc123
expMills: 50000
loginToken:
loginTokenKey: zxc123
expMills: 100000
teams2; //也可是数组,Set
private Map<String,Integer> mapInfo;
private BackPwdToken backToken; //对象型成员变量
private LoginToken loginToken; //对象型成员变量
public static class BackPwdToken{ //找回密码封装成一个静态内部类
private String tokenKey;
private Long expMills;
public String getTokenKey() {
return tokenKey;
}
public void setTokenKey(String tokenKey) {
this.tokenKey = tokenKey;
}
public Long getExpMills() {
return expMills;
}
public void setExpMills(Long expMills) {
this.expMills = expMills;
}
}
public static class LoginToken{ //系统相关信息封装成一个静态内部类
private String loginTokenKey;
private Long expMills;
public String getLoginTokenKey() {
return loginTokenKey;
}
public void setLoginTokenKey(String loginTokenKey) {
this.loginTokenKey = loginTokenKey;
}
public Long getExpMills() {
return expMills;
}
public void setExpMills(Long expMills) {
this.expMills = expMills;
}
}
public Map<String, Integer> getMapInfo() {
return mapInfo;
}
public void setMapInfo(Map<String, Integer> mapInfo) {
this.mapInfo = mapInfo;
}
public List<String> getTeams2() {
return teams2;
}
public void setTeams2(List<String> teams2) {
this.teams2 = teams2;
}
public List<String> getTeams() {
return teams;
}
public void setTeams(List<String> teams) {
this.teams = teams;
}
public Date getLastUpdate() {
return lastUpdate;
}
public void setLastUpdate(Date lastUpdate) {
this.lastUpdate = lastUpdate;
}
public double getVersion() {
return version;
}
public void setVersion(double version) {
this.version = version;
}
public BackPwdToken getBackToken() {
return backToken;
}
public void setBackToken(BackPwdToken backToken) {
this.backToken = backToken;
}
public LoginToken getLoginToken() {
return loginToken;
}
public void setLoginToken(LoginToken loginToken) {
this.loginToken = loginToken;
}
public String getRoot() {
return root;
}
public void setRoot(String root) {
this.root = root;
}
}总结:
pom文件中细节内容:父工程,启动器,热部署,测试,插件.
启动器概念必须明确表达出来.
yml配置文件语法,自定义数据的读取.
10.复习spring类配置的相关注解
11.springboot的主类(主启动类,主配置类)
SpringApplication.run(BootApplication.class,args);
@SpringBootApplication
扫一扫
77
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
