springBoot快速开发框架

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相关的依赖

<parent>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starster-parentartifactId>
    <version>1.5.7.RELEASEversion>
parent>

    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-webartifactId>
    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的相关依赖

   
   <dependency>
      <groupId>jstlgroupId>
      <artifactId>jstlartifactId>
      <version>1.2version>
    dependency>
   
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-tomcatartifactId>
    dependency>
   
    <dependency>
      <groupId>org.apache.tomcat.embedgroupId>
      <artifactId>tomcat-embed-jasperartifactId>
    dependency>

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

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

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

      <plugin>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-maven-pluginartifactId>
      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

    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-testartifactId>
      <scope>testscope>
    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.bootgroupId>
      <artifactId>spring-boot-devtoolsartifactId>
      <optional>trueoptional>
    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.引入依赖

    <dependency>
      <groupId>commons-fileuploadgroupId>
      <artifactId>commons-fileuploadartifactId>
      <version>1.3.1version>
    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>warpackage>

2.springboot中打成war的配置

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

    <dependency>
      <groupId>jstlgroupId>
      <artifactId>jstlartifactId>
      <version>1.2version>
    dependency>
    <dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-starter-tomcatartifactId>
      <scope>providedscope>
    dependency>
    <dependency>
      <groupId>org.apache.tomcat.embedgroupId>
      <artifactId>tomcat-embed-jasperartifactId>
      <scope>providedscope>
    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文件的名字*/