版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 本文链接：https://blog.csdn.net/qq_36348064/article/details/96727436

springBoot————快速开发框架

一、引言

1.springboot= spring + springmvc

2.spring的特点：

1).创建独立的springboot应用 2).嵌入的tomcat,无需部署war文件

3).简化maven配置，只需引入springboot的两个核心依赖 4).自动配置spring、springmvc,没有xml配置

3.springboot约定的配置方式

①需要定义一个application类作为入口类，且必须放在所有包上边

②spring配置文件名字必须为application.yml、application.properties或者application.yaml.配置文件必须放在src/main/resources

③spring对resources文件夹要求很高，resources必须拼写正确

二、spring的第一个环境

1.引入springboot相关的依赖

<!--继承springboot的父项目 在dependencies的上面-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starster-parent</artifactId>
<version>1.5.7.RELEASE</version>
</parent>
<!--引入springboot的web支持依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>

2.开发springboot的入口类Application.java

@SpringBootApplication  //作用:标识这是一个springboot的入口类   注意:入口类扫描到项目中其他类
@MapperScan("com.baizhi.dao")  //作用：扫描dao包，以便创建dao对象
public class Application {
public static void main(String[] args) {
//启动springboot
//参数1:入口类的类对象，启动工厂，实例化组件对象 //参数2:main函数的参数，用来对项目二次传值
SpringApplication.run(Application.class,args);
}
}

3.创建springboot的配置文件 application.yml

server:
port: 8989 #修改内嵌服务器端口号,避免与oracle端口冲突

4.开发Controller

@RestController|@controller
@RequestMapping("hello")
public class HelloController {

@RequestMapping("hello")
public String hello(){
System.out.println("hello springboot");
return "hello springboot";
}
}
/*注意：controller要交给工厂管理要加注解，可以使用@controller或者@restCotroller       @RestController=@cotrller+@responseBody,要求controller中的方法返回的都是json字符串*/

5.运行Application的main函数

6.浏览器中访问

注意：springboot访问时默认没有项目名,在application.yml中使用contextpath配置后可以按照传统路径访问

http://localhost/controller类上的@requestmapping/方法上的@requestMapping

三、spring中bannner的设置

​ 在src/main/resources中存放bannner.txt

四、spring 集成jsp

问题：

spring中默认集成的是Thymelaf模板，类似html。spring对jsp的支持不是很友好，不能直接访问项目中的jsp页面

解决方案：

1.引入jsp的相关依赖

<!--顺便引入jstl,在页面遍历时使用-->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!--spring与tomcat的整合-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>
<!--tomcat解析jsp-->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>

2.在application.yml中配置视图解析的前后缀

mvc:
view:   #配置前后缀
suffix: .jsp
prefix: /

3.配置jsp运行所需的插件

<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>

4.插件方式启动项目

可以直接双击运行，也可以邮件create

[外链图片转存失败(img-jpZALshr-1563694809686)(C:\Users\15620\Desktop\2019-07-21_100218.jpg)]

五、springboot整合mybatis开发

在使用spring之前开发项目需要在spring.xml中需要：创建数据源对象、创建sqlsessionFactory、创建dao、事务管理器等，springboot为我们自动配置这些，只需要提供一些必要的信息，例如数据源的类型、dao文件的位置、mapper文件的位置等信息。controller层的开发与之前没有差异。

1.引入依赖

只需引入mybatis-spring-boot-starter核心依赖、mysql|oracle、druid

2.建表

3.创建entity

4.创建dao

5.创建mapper文件

6.创建service接口

7.创建serviceImpl实现类，注入dao依赖

8.编写application.yml

spring:
datasource:    #配置数据源相关
driver-class-name: com.mysql.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
url: jdbc:mysql://localhost:3306/ssm
username: root
password: root
mybatis:
mapper-locations: classpath:com/baizhi/mapper/*.xml  #配置mapperlocation
type-aliases-package: com.baizhi.entity   #起别名
server:
port: 8989  #配置端口号防止与oracle冲突
context-path: /springboot_day2   #配置访问路径

9.在application入口类上指出dao接口所在的位置

@SpringBootApplication  //指定为入口类
@MapperScan("com.baizhi.dao")   //指定dao接口所在的位置
public class Application {
public static void main(String[] args) {
//
SpringApplication.run(Application.class,args);
}
}

10.如果要编写测试类需要：

1).引入spring-boot-starter-test测试jar

<!--  引入测试jar springboot-test-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

2).

@RunWith(SpringJUnit4ClassRunner.class|SpringRunner.class)  //启动工厂，两者无差别
@SpringBootTest(classes = Application.class)   //指定入口类
public class TestUser {
@Autowired
private UserDAO userDAO;
@Test
public void test(){
userDAO.selectAll().forEach(user-> System.out.println(user));
}
}

六、logback日志

1.定义

springboot集成了logback日志（不要引入依赖），它是log4j创始人设计的另一个开源日志组件

2.日志的分类

根日志：rootLogger 包日志：logger

3.日志级别

(级别越低信息越多，默认级别为info)

高 -------------------------------------------------------------------------> 低

OFF FATAL ERROR WARN INFO DEBUG TRACE ALL

4.使用

在src/main/resources中配置loback.xml，在运行项目时可以打印信息。建议在类中使用日志代替输出语句进行测试，可以提高运行效率

七.热部署

1.定义

热部署就是在不启动程序的情况下使当前的修改立即生效

2.jsp热部署

application.yml中配置

server:
port: 8989
jsp-servlet:
init-parameters:
development: true

3.全局热部署

1).三种热部署方式

springboot官方的spring-loaded、spring-dev-tools(推荐使用)

第三方的jrebel(效果最好、收费)

2).步骤

a.引入spring-boot-starter-devtools依赖

<!--  引入热部署-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>

b.开启idea自动编译

File | Settings | Build, Execution, Deployment | Compiler 勾选Build project automatically

c.开启ieda运行过程中允许交换修改.class文件

ctrl+alt+shift+/ -------> registry-------->勾选compiler.automake.allow.when.app.running

八、配置文件的拆分

问题：在测试和项目上线时操作不同，因此application.yml的配置也应该不同。为了避免反复修改配置文件，可以开发不同的配置文件，在主配置文件中切换。主配置文件书写相同的配置，完成配置文件的激活

1.生产配置文件

#application-pord.yml
server:
context-path: /cmfz

2.测试配置文件

#application-dev.yml
server:
context-path: /springboot

3.主配置文件

#application.yml
server:
port: 8080
spring:
profiles:
active: prod  #active激活拆分的那个配置文件

九、aop面向切面编程

1.定义

通知(advice)：除了目标方法以外的操作都称之为通知|附加操作|额外操作

切入点(pointCut)：用来指定哪些类中的哪些方法需要加入额外通知

切面(Aspect)：通知+切入点

2.spring中切面编程的开发步骤

1. 开发通知(advice)类

前置通知、后置通知、异常通知、环绕通知

2).配置切面

a.spring.xml中管理通知类

b.组装切面

<aop:config>
<aop:pointcut id="pc" expression|within>
<aop:adviser advice-ref="" pointcut-ref="">
</aop:config>

3.spring-boot中切面编程的开发步骤

1).引入相关依赖

spring-boot-starter-aop

2).开发切面类

@Component   //将该aop类交给工厂管理
@Aspect      //说明这是aop类
public class Myaspect {

@Before("within(com.baizhi.service.*ServiceImpl)")
public void brfore(JoinPoint jp){
System.out.println("~~~~~进入前置通知~~~~");
System.out.println("方法名："+jp.getSignature().getName());
}
@Around("within(com.baizhi.service.*ServiceImpl)")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
//进入时的操作
System.out.println("进入环绕通知");
//放行
Object proceed = pjp.proceed();
//回来后的操作
System.out.println("回到环绕通知");
return proceed;
}
}

注意：

1.前置通知为Before,后置通知为After,环绕通知为Around,异常通知为AfterThrowing

2.方法内参数：环绕通知为proceedJoinPoint,其余为JoinPoint

3.在类上使用@order关键字控制不同通知类的执行顺序，数字越小优先级越高

十、springboot文件上传

spring在上传文件时需要配置文件上传解析器coommonsMultipartResolver，且id必须为multipartResolver；与spring不同，springboot不需要配置文件上传解析器

1.引入依赖

<!--    引入文件上传commons-fileupload-->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.3.1</version>
</dependency>

2.准备页面

a.表单的提交方式必须为post

b.表达enctype必须为multipart/form-data

c.input type=“file” name=“aaa”

3.开发文件上传的controller

//根据日期创建文件夹并上传
@RequestMapping("upload")
public String upload(MultipartFile aa, HttpServletRequest request) throws IOException {
//获取文件的原始名
String originalFilename = aa.getOriginalFilename();
//获取文件夹的路径
String realPath = request.getSession().getServletContext().getRealPath("files");
//根据日期创建文件夹
String date = new SimpleDateFormat("yyyy-MM-dd").format(new Date());
File finalPath = new File(realPath, date);
if(!finalPath.exists()){
finalPath.mkdirs();
}
//文件的上传
aa.transferTo(new File(finalPath,originalFilename));
return "upload";
}

十一、springboot文件下载

1.准备文件

在项目中创建文件夹并将文件放入

2.准备页面

页面中提供下载的链接

3.开发controller

@RequestMapping("download")
public void download(HttpServletRequest request, HttpServletResponse response,String fileName) throws IOException {
System.out.println(fileName);
//根据文件名读取文件(方式多种，下面只是其中一个)
//去指定的目录读取想下载的文件
String realPath = request.getSession().getServletContext().getRealPath("/files/2019-07-19");
//读取文件
FileInputStream is = new FileInputStream(new File(realPath, fileName));
//设置下载响应头(设置下载文件名以及文件名的编码方式)
response.setHeader("content-disposition","attachment;fileName="+ URLEncoder.encode(fileName,"UTF-8"));
//设置响应类型(确保下载的文件格式正确)
String type = request.getSession().getServletContext().getMimeType("." + FilenameUtils.getExtension(fileName));
//获取文件输出流
ServletOutputStream os = response.getOutputStream();
//文件拷贝、关闭流
IOUtils.copy(is,os);
IOUtils.closeQuietly(is);
IOUtils.closeQuietly(os);
}

十二、springboot拦截器

1.拦截器作用

将多个controller中共有的代码放在拦截器中执行，缉拿少controller中代码的冗余。例如强制登录的实现，放在拦截器中，避免了在每个controller中判断用户是否登录。

2.拦截器的特点

1).请求响应前经过拦截器，请求响应后回到拦截器；

2).拦截器中断了用户的请求轨迹；

3).拦截器只能拦截控制器相关的请求路径。

3.拦截器的开发步骤

1).开发拦截器类

@Component
public class Myinterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {

System.out.println("~~~~~~~~~~1~~~~~~~~~~");
return false;
}

@Override
public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {

System.out.println("~~~~~~~~~3~~~~~~~~~~");
}

@Override
public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {

System.out.println("~~~~~~~~~4~~~~~~~~~");
}
}
/*类 implements HandlerInterceptor*/
//类上必须使用@component，使工厂扫描到

2).配置拦截器类

@Component
public class InterceptorConfig extends WebMvcConfigurerAdapter {
@Autowired   //注入创建的拦截器类
private Myinterceptor myInterceptor;

//添加自定义拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(myInterceptor)    //创建指定拦截器的实例
.addPathPatterns("/**")   //添加要拦截的请求
.excludePathPatterns("/file/upload");    //指定排除的请求
}
}
//注意！！！springboot拦截器中所有路径必须为/**
//类 extends WebMvcConfigurerAdapter
//类上必须使用@component，使工厂扫描到

十三、springboot全局异常处理

为了改进用户使用体验，是用户界面更加友好，设定出现异常时的页面

1.开发全局异常处理类

@Component
public class ResloveException implements HandlerExceptionResolver {
@Override
public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
ModelAndView modelAndView = new ModelAndView();  //创建modelAndView
modelAndView.setViewName("500");   //设置错误页面
httpServletRequest.setAttribute("message",e.getMessage());  //将错误信息存入
return modelAndView;
}
}
/*注意：
1.类上使用@component
2.类  implements HandlerExceptionResolver*/

2.测试

@RequestMapping("testException")
public String test(){
System.out.println("testExeception-------");
throw new RuntimeException("test出问题了");
}

十四、springboot的war包部署

1.在pom.xml中指定打包方式为war

<package>war</package>

2.springboot中打成war的配置

由于springboot内嵌了tomcat服务器，我们在配置访问jsp页面时引入有关tomcat的配置，因此需要provided。provided是指编译测试时生效，运行时不生效。

<!--  引入springboot 与  jsp的集成jar-->
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>

3.修改启动出口类

@SpringBootApplication  //指定为入口类
@MapperScan("com.baizhi.dao")   //指定dao接口所在的位置
//为了打包war,需要extends SpringBootServletInitializer，覆盖configure方法
public class Application extends SpringBootServletInitializer {
public static void main(String[] args) {
//
SpringApplication.run(Application.class,args);
}

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(Application.class);
}
}
/*注意：
1.根据war包部署项目后，项目中配置的端口号失效
2.springboot中配置的访问项目名失效，访问路径中的项目名是war文件的名字*/

3.修改启动出口类

@SpringBootApplication  //指定为入口类
@MapperScan("com.baizhi.dao")   //指定dao接口所在的位置
//为了打包war,需要extends SpringBootServletInitializer，覆盖configure方法
public class Application extends SpringBootServletInitializer {
public static void main(String[] args) {
//
SpringApplication.run(Application.class,args);
}

@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(Application.class);
}
}
/*注意：
1.根据war包部署项目后，项目中配置的端口号失效
2.springboot中配置的访问项目名失效，访问路径中的项目名是war文件的名字*/