Springboot

Spring Boot

1.Spring Boot入门

1.1Spring Boot简介

​ SpringBoot是Spring家族中的一个框架

​ 为什么要学Spring Boot?因为在我们学习SSM框架的时候,我们需要有一堆的配置文件,如Mybatis,Spring,SpringMVC,
​ web.xml这些配置文件,而且大多的时候这些文件的配置都是重复性的工作,Spring Boot就是为了简化这一过程

​ Spring Boot可以非常容易和快速创建基于Spring框架的应用程序,它让编代码变得简单了, 配置变得简单了,使得开发人 员可以专注于业务逻辑的开发

1.2 Spring Boot的特性

​ 1>能够快速创建基于Spring的程序

​ 2>能够直接使用java的main方法启动内嵌的Tomcat服务器运行Spring Boot程序,不需要部署war包

​ 3>提供约定的starter POM来简化maven配置,让maven配置更简单

​ 4>自动化配置,根据项目的maven依赖配置,Spring Boot自动配置Spring,SpringMVC,Mybatis等

​ 5>提供了程序的健康检查等功能

​ 6>基本可以完全不使用XML配置文件,采用注解配置

1.3 Spring Boot四大核心

​ 1>自动配置

​ 2>起步依赖:就相当于去饭店点的套餐,指的是依赖的套餐

​ 3>Actuator

​ 4>命令行界面

​ 在国内开发中用的最多的是前两种,后两种几乎不用

1.4 SpringBoot集成springmvc

1.4.1 基本知识

​ 1>springboot中的依赖内置了springmvc的所有依赖
​ 所以当一个springboot工程创建好了以后其实就是一个springmvc的工程

​ 2>在spring boot项目中写代码时,只能写在自动生成的Springboot01FirstApplication类的同级目录或子目录中

​ 3>一个springboot工程只能有一个application核心配置文件,该配置文件可以:
​ [1]设置工程的根路径(如:http://localhost:8080/springboot)
​ [2]设置Tomcat服务器的端口号
​ springboot工程的配置文件有三种形式:
​ [1]一种是原本的properties形式
​ [2]还能是.yml文件的形式
​ [3]最后还有一种和.yml相同的.yaml形式
​ 注:[1]后两种形式是一样的,只不过扩展名不一样,这两种文件和第一种文件的区别就是文件中的.全部替换成了换行符并 且会缩进
​ [2]如果两种文件同时存在,优先读的是.propertiies文件

​ 4>多环境下核心配置文件的使用,工作中可能用到的环境有:开发环境,测试环境,准生产环境,生产环境
​ 为什么要用?在实际开发中,不同的环境用到的ip地址和端口号都有可能不同,所以这时候就需要频繁的修改application 配置文件中的ip地址和端口号,这就显得很繁琐
​ 怎么用?创建多个配置文件,配置文件的命名格式都是以application-开头,并且将application.properties作为主配置文件
​ 在主配置文件中通过 spring.profiles.active= 来引用配置文件即可

​ 注:所有的配置文件即可以用properties为扩展名,也可以为yml为扩展名,但要统一

​ 5>在springboot核心配置文件中能自定义配置,并且能够用@value获取
​ 用法:首先在springboot核心配置文件中配置信息(key,value的形式)
​ 然后即可在类中用@value("${key}")获取,并赋值给变量

​ 在springboot核心配置文件中自定义配置,也能够通过对象方式获取
​ 用法:实现在springboot的核心配置文件中配置信息(也是key,value的形式,但是key必须为a.b的形式)
​ 然后在待封装的类的上面加上@compinent和@ConfigurationProperties(a) 两个注解
​ 最后在定义该类中的成员变量时,成员变量的名字必须和b相同
​ 我们就可以在Controller类中使用了,通过@Autowire 注解,自动赋值
​ 注:当用该注解时, 此时可能会出现红色的警告提示,这时可以通过添加依赖来解决

​ 6.在springboot中添加jsp文件
​ 步骤:1>实现要创建webapp文件夹,然后在project structure中配置webapp
​ 2>在pom文件中添加解析jsp文件的依赖,并指明jsp文件所在的位置
​ 3>在springboot核心配置文件中配置视图解析器
​ 4>在指定的目录下创建jsp文件即可

springboot配置文件的不同形式

application.yml

server:
  port: 8081
  servlet:
    context-path: /yml

application.yaml

server:
  port: 9090
  servlet:
    context-path: /yaml

IndexController.java

package com.example.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class IndexController {

    @RequestMapping(value = "/say")
    @ResponseBody
    public Object say(String message){
        return "Say Hello "+message;
    }
}

多环境下核心配置文件的使用

package com.example.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class IndexController {

    @RequestMapping(value = "/say")
    @ResponseBody
    public String say(){
        return "Hello multi environment!";
    }
}

application.properties

#springboot 核心配置文件
#选择要加载的配置文件
spring.profiles.active=test

application-dev.properties

#开发环境
server.port=8080
server.servlet.context-path=/dev

application-product.properties

#生产环境
server.port=9090
server.servlet.context-path=/product

application-ready.properties

#准生产环境
server.port=8082
server.servlet.context-path=/ready

application-test.properties

#测试环境
server.port=8081
server.servlet.context-path=/test

获取springboot核心文件中的属性值

直接获取值

application.properties

server.port=8080
#配置跟路径
server.servlet.context-path=/
#自定义配置
school=希望小学
web=http://www.xwxx.com

IndexController.java

package com.example.springboot.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class IndexController {

    @Value("${school}")
    private String school;

    @Value("${web}")
    private String web;

    @RequestMapping(value = "say")
    @ResponseBody
    public String say(){
        return "school:"+school+"  web:"+web;
    }
}

将值保存到对象中:

application.properties

server.port=8080
#配置跟路径
server.servlet.context-path=/
#自定义配置
person.school=希望小学
person.web=http://www.xwxx.com

Person.java

package com.example.springboot.demo;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component//经此类交给springboot处理
@ConfigurationProperties(prefix = "person")//设置前缀,且必须设置
public class Person {
    private String school;
    private String web;

    @Override
    public String toString() {
        return "Person{" +
                "school='" + school + '\'' +
                ", web='" + web + '\'' +
                '}';
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public String getWeb() {
        return web;
    }

    public void setWeb(String web) {
        this.web = web;
    }

    public Person(String school, String web) {
        this.school = school;
        this.web = web;
    }

    public Person() {
    }
}

IndexController.java

package com.example.springboot.controller;

import com.example.springboot.demo.Person;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class IndexController {

    @Autowired
    private Person person;

    @RequestMapping(value = "say")
    @ResponseBody
    public String say(){
        return "person.school:"+person.getSchool()+"   person.web:"+person.getWeb();
    }

}

springboot集成jsp文件

pom.xml

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.4version>
        <relativePath/> 
    parent>
    <groupId>com.wanggroupId>
    <artifactId>springboot08-jspartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>springboot08-jspname>
    <description>springboot08-jspdescription>
    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        
        <dependency>
            <groupId>org.apache.tomcat.embedgroupId>
            <artifactId>tomcat-embed-jasperartifactId>
        dependency>

    dependencies>

    <build>
        
        <resources>
            <resource>
                
                <directory>src/main/webappdirectory>
                
                <targetPath>META-INF/resourcestargetPath>
                
                <includes>
                    <include>*.*include>
                includes>
            resource>
        resources>

        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <version>2.2.6.RELEASEversion>
            plugin>
        plugins>
    build>

project>

application.properties

#配置视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

IndexController.java

package com.example.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;

@Controller
public class IndexController {

    @RequestMapping(value = "/say")
    public ModelAndView say(){
        ModelAndView mv = new ModelAndView();
        mv.addObject("message","hello springboot");
        mv.setViewName("index");
        return mv;
    }

}

webapp下的index.jsp

<%--
  Created by IntelliJ IDEA.
  User: 14330
  Date: 2021/9/17
  Time: 19:34
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


    
message:${message}

1.4.2 springmvc的注解

1>@RestController: 用于类的上面,相当于控制层上加@Controller+方法上加@ResponseBody,意味着当前控制层类中的所 有的方法返回值都是JSON对象

2>[1]@RequestMapping(value=""): 默认post或get请求都可以
[2]@RequsMapping(value="",method=RequestMethod.get):只支持get请求
[3]@GetMapping(value=""):相当于[2]
[4]@RequsMapping(value="",method=RequestMethod.post): 只支持post请求
[5]@PostMapping(value=""):相当于[4]
[6]DeleteMapping(value=""):该注解通常在删除数据的时候使用,相当于
@RequestMapping(value="",method=RequestMethod.put)
[7]PutMapping(value=""):该注解通常做的时更新操作,相当于
@RequestMapping(value="",method=RequestMethod.put)

 注:PutMapping, PostMapping, DeleteMapping的区别:
	put、get与delete请求都是具有幂等性的，而post为非幂等性请求
	幂等性与非幂等性的区别:
 1、SELECT col1 FROM tab1 WHER col2=2，无论执行多少次都不会改变状态，是天然的幂等。
 2、UPDATE tab1 SET col1=1 WHERE col2=2，无论执行成功多少次状态都是一致的，因此也是幂等操作。
 3、UPDATE tab1 SET col1=col1+1 WHERE col2=2，每次执行的结果都会发生变化，这种不是幂等的。 

1.5 SpringBoot集成mybatis

1.5.1 集成mybatis的步骤

​ 第一种(适合mapper文件比较少):

​ 1>创建maven工程
​ 添加依赖: springboot的web工程起步依赖(作用是集成spring和springmvc的依赖)
​ mysql驱动: 不用指定版本号,因为依赖的父工程已经指定了,也可以添加标签单独指定
​ mybatis整合springboot的起步依赖:需要指明version,因为这是mybatis整合springboot,不是springboot
​ mybatis,所以父工程中没有指定版本号
​ 2>导入mybatis逆向工程的xml文件和maven依赖,并修改相关配置:
​ 需要修改的内容有:指定连接mysql的jdbc驱动
​ 修改配置数据库连接信息
​ 修改生成的三个文件的位置
​ 修改指定的表要生成的类的名称
​ 3>使用逆向工程生成model类和mapper接口以及对应的查询语句
​ 4>在serviceimpl类上加@service注解
​ 在mapper接口中加@Mapper注解
​ 5>在springboot的配置文件中添加连接数据库的信息

​ 第二种(适合多个mapper文件):

​ 1>添加依赖: 添加加载mapper文件下的xml文件插件
​ 2>使用逆向工程生成mapper和model文件
​ 3>创建Controller控制层: 调用业务层的方法
​ 4>创建业务层接口和接口的实现类
​ 5>在serviceimpl类上加@service注解
​ 在application类上加@MapperScan(basePackages=“mapper包”)注解: 和上面的不同在于: 当有多个mapper文件的时 候,不用一一的加注解

​ 6>在springboot的配置文件中添加连接数据库的信息

​ 第三种(mapper文件和xml文件不在同一个包下):
​ 和第二种不同的是主要在resource目录下创建一个和mapper接口的包名一样的文件夹
​ 并在该文件夹下存放mapper的xml文件
​ 不用在pom.xml文件下添加编译java下的xml文件插件
​ 需要在springboot的配置文件下指明mapper映射文件所存放的包路径(编译后的路径):
​ mybatis.mapper-location=classpath:mapper/*.xml

1.5.2 使用事务

​ 步骤:
​ 1>在pom文件下添加依赖: mybatis集成springboot
​ mysql驱动
​ 逆向工程插件
​ 2>使用逆向工程生成三个文件
​ 3>写控制层和service层的类和接口,并添加注解
​ 在service接口的实现类中模拟事务: 先写一条更新语句
​ 然后让被除数为0,模拟出错
​ 在待加事务的方法上面加@Transactional 即可让该方法具有事务功能

​ 4>在main方法中配置mapper的文件的位置
​ 5>在springboot的配置文件中指明数据库数据

1.6 Springboot开发RESTFul

​ 1>介绍

​ 什么时restful风格? restful是由Roy Thomas Fielding 在他 2000 年的博士论文中提出的,一种互联网软件架构设计的风 格，但它并不是标准，它只是提出了一组客户端和服务器 交互时的架构理念和设计原则，基于这种理念和原则设计的接 口可以更简洁，更有层次

​ 比如我们要访问一个 http 接口：http://localhost:8080/boot/order?id=1021&status=1
​ 采用 RESTFul 风格则 http 地址为：http://localhost:8080/boot/order/1021/1

​ 这种风格在现在的开发中也很常见

​ 2>使用步骤:

​ [1]创建一个controller类方法, 将student类拷贝进来
​ [2]在controller的方法上RequestMapping注解中的value值设为"/路径/{变量名1}/{变量名2}/…"
​ 在方法中传入的参数为@PathVariable(“变量名1”),@PathVariable(“变量名2”)…
​ [3]写一个和上面方法的value值相同, 但参数不一样的方法,
​ restful是无法区分这两个方法的不一样的,因为不知道是想往哪一个方法中传参数
​ 为了区分两个方法,可以将注解改变,如: 使用@DeleteMappring,@PostMappring 等注解来区分
​ [4]如果两个方法的路径相同,变量名也相同,所使用的注解也相同,为了区分两个方法,可以将参数的位置设置为不一样的, 来达到区分的目的

​

1.7 Springboot集成redis

​ 1>步骤
​ [1]添加redis的依赖
​ [2]在sprigboot的配置文件中添加连接redis的信息 :ip地址和端口号
​ [3]创建controller,主要的功能是存放前端发来的数据到redis
​ [4]创建service层,实现对redis数据库的修改(@Aurowired注入的mapper对象是redis依赖为我们提供好的)
​ [5]在虚拟机上开启redis服务器,并关闭防火墙

​ 注:[1]在redis数据库中存放的值是输入的值的对应的二进制
​ [2]在连接redis数据库时报错,需要将redis中的redis.conf中的bin:127.0.0.1注掉,并且修改 protected-mode yes 改为： protected-mode no
​ 然后重启redis服务器,指定按照redis.conf配置文件启动
​ 并且在idea中指明max-active,max-wait,max-idle,min-idle,timeout

1.8 Springboo集成dubbo

​ 1>介绍

​ [1]接口工程:存放实体bean和业务接口
​ [2]服务提供者:业务接口的实现类并将服务暴露且注册到注册中心,调用数据持久层
​ 需要添加的依赖:dubbo,注册中心,接口工程
​ 配置文件:服务提供者核心配置文件
​ [3]服务消费者:处理浏览器客户端发送的请求,从注册中心调用服务提供者所提供的服务
​ 需要添加的依赖:dubbo,注册中心,接口工程
​ 配置文件:消费者核心配置文件

​ 2>步骤

​ [1]首先创建三个工程,分别作为接口工程,服务提供者和消费者
​ [2]在接口工程中声明接口
​ [3]在服务提供者和消费者中添加依赖,
​ 并在核心配置文件中配置tomct的端口号根路径,
​ 以及dubbo配置: 配置当前工程的dubbo名称(唯一)
​ 指定注册中心
​ [4]在接口工程中指明接口,在服务提供者工程中指明接口的实现类,在消费者工程中实现Controller类,调用接口工程
​ [5]在服务提供者上加注解:@service(interface=“接口名.class” , version="" , timeout="" ") :作用是将创建的service类
​ 对象提赋值给接口
​ @Comonent: 作用是将该接口实现类交给spring容器管理
​ 在消费者的Controller类下的serviec变量加上dubbo的注解:
​ @Reference(interfaceClass = 接口名.class,version = “”,check = false): 作用是将存放在监听器中的接口对象
​ 赋值给下面的对象
​ 在服务者和消费者的run方法上加让dubbo的注解生效的注解(因为原本是只会让springboot的注解生效):
​ @EnableDubboConfiguration

1.9 Springboot集成Dubbo和SSM以及JSP

​ 1>分析:
​ 集成这三大块需要三个工程:
​ [1]接口工程:存放实bean和业务接口
​ [2]服务提供者:它是一个SpringBoot框架web项目,集成Mybatis,Redis
​ 需要添加的依赖有:Mybatis依赖,MySQL驱动依赖,Dubbo依赖,zookeeper依赖,Redis依赖,接口工程
​ 配置springboot的核心配置文件包括:
​ 配置连接数据库
​ 配置连接redis
​ 配置dubbo
​ [3]服务的消费者:它是springboot框架web项目,集成jsp和dubbo
​ 添加依赖:Dubbo依赖,zookeeper依赖,解析Jsp页面的依赖,接口工程
​ 配置Springboot的核心配置文件:
​ 配置视图解析器
​ 配置dubbo

​ 2>步骤:

​ [1]创建三个工程:interface,provider,consumer
​ [2]在provide下用逆向工程将model和接口以及mapper文件(model放在interface工程下,剩下俩放在当前工程下)
​ [3]添加三个工程的依赖
​ provider: mysql的驱动依赖,接口工程,dubbo集成springboot依赖,注册中心依赖,
​ springboot集成redis的依赖,Mybatis集成springboot的依赖,逆向工程的插件
​ consumer: springboot集成jsp的依赖,dubbo集成springboot的依赖,zookeepe注册中心,接口工程的依赖

​ [4]配置provide和consumer工程的springboot核心配置文件
​ provider的springboot配置:
​ tomcat的配置:端口号和上下文根
​ mysql的配置:mysql驱动,连接地址,用户名,密码
​ dubbo的配置:唯一的名称,声明当前工程为服务的提供者,设置注册中心
​ redis的配置:配置地址,配置端口号
​ consumer的springboot配置:
​ tomcat的配置:端口号和根路径
​ dubbo的配置:唯一的名称,注册中心的ip和端口号
​ springmvc的配置:视图解析器
​ [5]在consumer工程下写控制层:
​ 根据id查询学生信息的方法
​ 在run方法上加@EnableDubboConfiguration(开启dubbo配置)
​ [6]在provider中写接口的实现类
​ 在类的上面加@Compnent注解(将对象交给spring处理)和@Seervice注解(dubbo)
​ 在run类上面加@MapperScan注解(mybatis的注解,扫描mapper.xml文件)
​ 在run类上面加@EnableDubboConfiguration(开启dubbo配置)
​ [7]在interface工程中,将实体类序列化
​ 在provider的pom.xml文件中添加加载普通包下文件的xml文件的插件
​ 开启zookeeper注册中心
​ 在consumer文件中指定jsp页面的位置
​ [8]创建jsp文件
​ [9]在consumer下的controller中添加redis查询总人数的方法
​ 在provider工程下的service接口实现类中添加redis查询所有的人数的语句:
​ 如果查询不到,去mysql中查询,并将结果存到redis中,设置其将会存放30s,并返回
​ 如果能查询到,将结果直接返回
​ 在mapper的接口中声明查询总人数的sql语句,并在mapper文件中配置

2*. Springboot创建非web工程

​ 1>和web工程的不同(了解即可)

​ [1]在创建的时候不需要勾选web选项
​ [2]创建好后的web工程中的pom文件和之前的依赖有所不同:
​ web工程有个依赖是web工程的起步依赖,这个没有,换成了java工程的起步依赖
​ [3]在该工程中其实也可以使用spring的注解,并靠注解的方式获取对象,
​ 获取的方式为: 在springboot的run方法中,SpringApplication.run的返回值是ConfigurableApplicationContext,
​ 它其实是一个spring容器中的启动容器ClasspathXmlApplicationContext
​ 该容器中存放着所有的bean对象
​ 我们可以通过对象名称的方式获取该bean对象

​ 2>建立第一个springboot下的java工程

​ [1]首先创建工程
​ [2]写service层,并写一个serviec实现类,在该实现类上面加serviec注解
​ [3]在springboot的run方法中通过name的形式即可获取bean对象

​ 3>建立第二个sprinboto下的java工程

​ [1]首先创建工程
​ [2]写serviece层,并写一个serveice实现类,在该实现类上面加servece注解
​ [3]在springboot的run类中,实现CommandLineRunner接口,并重写里面的run方法
​ [4]使用注解的方式在run类中获取serviece实现类的对象
​ [5]在run方法中操作service对象

​ 4>小技巧:修改springboot启动时的图标

​ 在src/main/resources 中,放入banner.txt文件,并将新的logo粘贴到这里面

serrviceimpl

package com.wang.springboot.serviceImpl;

import com.wang.springboot.service.StudentService;
import org.springframework.stereotype.Service;

@Service
public class StudentServiceImpl implements StudentService {
    @Override
    public String sayHello() {
        return "HelloJava!!!";
    }
}

service

3.Springboot中的拦截器

​ 1>拦截器的作用: 通常用于用户是否登录的检查,如果用户没有登录,而且直接访问某个登录后才能访问的页面,那么就会
​ 被拦截器所拦截,返回到一个其它的页面(比如登录页面)

​ 2>在springboot中拦截器的使用步骤

​ [1]创建一个web工程
​ [2]创建一个model类
​ [3]创建一个interceptor拦截器,实现 HandlerInterceptor 接口,并实现3个方法,在preHandler方法中编写业务拦截的规 则: 判断用户是否登陆了,如果登陆了,就返回true,否则返回false
​ [4]创建一个config类,并在该类的上面加上@configuration注解,声明这是一个配置类
​ 并让这个类实现WebMvcConfiger接口,重写其addInterceptors()方法
​ 在这个类中定义两个string字符串,一个子符串中的内容是要拦截的路径,另一个字符串中的内容是要排除的拦截路径
​ [5]在controller层中写若干个方法,其中有的需要拦截,有的不需要拦截
​ 在该类的上面添加注解,指明访问该类的根路径

​ 说明:在拦截器的Config类中, * * 代表的是拦截当前目录和其子目录, *代表的是当前目录
​ 例:/user/ ** 代表拦截user下的所有的目录和其子目录

4*.Springboot下使用servlet

​ 1>第一种方式(注解):

​ [1]创建一个工程
​ [2]创建一个servler类,继承httpservlet,重写其doGet和doPost两个方法
​ 在该类的上面加上@WebServlet(urlPattern="/所要访问的地址名")注解
​ [3]在springboot的run方法上加@ServletComponentScan(basePackage=“servlet所在包名”)的注解

​ 说明:WebServle是servlet下注解,所以需要在run方法上扫描

​ 2>第二种方式(配置类):

​ [1]新建一个工程
​ [2]创建一个servlet类,继承httpservlet,重写其doGet和doPost两个方法
​ [3]创建一个config类,并在该类的上面加一个@configuration 注解,表明该类是一个配置类
​ 在该类的下面定义一个方法,其返回值是ServletRegistrationBean
​ 并在该方法中创建一个新的ServletRegistrationBean对象,传入的参数为servlet对象和定义的访问地址
​ 并在该方法的上面加上@bean标签:该bean标签其实就先当于spring配置文件中的bean标签,能够创建对象

​ 说明:不用在springboot的run方法上加扫描configuration 的注解,因为该注解就属于spring

方式一:

servlet:

package com.wang.springboot.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(urlPatterns = "/myservlet")
public class MyServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        resp.getWriter().println("springboot: servlet-1");
        resp.getWriter().flush();
        resp.getWriter().close();
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

main:

package com.wang.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan
public class Springboot24Servlet1Application {

    public static void main(String[] args) {
        SpringApplication.run(Springboot24Servlet1Application.class, args);
    }

}

方式二:

package com.wang.springboot.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class MyServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().println("springboot: servlet-2");
        resp.getWriter().flush();
        resp.getWriter().close();
    }

}

conf类:

package com.wang.springboot.conf;

import com.wang.springboot.servlet.MyServlet;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration  //声明这是一个配置类
public class Myconf {

    @Bean
    public ServletRegistrationBean myServletRegistrationBean(){
        ServletRegistrationBean servletRegistrationBean=new ServletRegistrationBean(new MyServlet(),"/myServlet");
        return servletRegistrationBean;
    }
}

5. Springboot下使用Filter

​ 1>方式一(注解的方式):

​ [1]创建一个springboot的web工程
​ [2]创建一个Filter类实现Filter接口
​ 该类需要实现doFilter方法
​ 并在该类的上面加上@WebFilter(url="/访问地址")注解
​ [3]在springboot的run方法上加@ServletComponentScan(basePackages=“Filter包所在的路径”)注解

​ 2>方式二(配置文件的方式):

​ [1]创建一个springboot的web工程
​ [2]创建一个Filter类实现Filter接口
​ 在该类中用filterChain.doFilter(servletRequest,servletResponse)方法过滤请求和响应
​ [3]创建一个config类
​ 在该类的上面加上@configuration注解
​ 创建一个返回值为FilterRegistrationBean的方法
​ 创建一个Filter 过滤器对象
​ 添加过滤路径(注:路径不能写**,即不能代表子包)
​ 在方法的上面加上@bean注解
​ [4]在控制层下创建两个方法,一个被过滤,另一个不被拦截

方式一:

过滤器

package com.wang.springboot.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;

@WebFilter(urlPatterns = "/myFilter")
public class MyFilter implements Filter {


    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("-------------拦截器被调用---------------");

        filterChain.doFilter(servletRequest,servletResponse);
    }
}

main

package com.wang.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan(basePackages = "com.wang.springboot.filter")
public class Springboot26Filter1Application {

    public static void main(String[] args) {
        SpringApplication.run(Springboot26Filter1Application.class, args);
    }

}

方式二:

package com.wang.springboot.conf;

import com.wang.springboot.filter.MyFilter;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import javax.servlet.FilterRegistration;

@Configuration
public class Myconf {

    @Bean
    public FilterRegistrationBean MyFilterRegistrationBean(){
        FilterRegistrationBean frb=new FilterRegistrationBean(new MyFilter());
        frb.addUrlPatterns("/user/*");
        return frb;
    }
}

过滤器

package com.wang.springboot.filter;

import javax.servlet.*;
import java.io.IOException;

public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("-----------过滤器2-------------");

        filterChain.doFilter(servletRequest,servletResponse);
    }
}

controller

package com.wang.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class MyController {

    @RequestMapping(value = "/user/sayHello")
    @ResponseBody
    public String sayHello(){
        return "hello springboot and filter, 你好springboot!你好filter!";
    }

    @RequestMapping(value = "/detail")
    @ResponseBody
    public String detail(){
        return "this is detial";
    }
}

6. Springboot下设置字符编码

​ 1>方法一(使用配置文件)

​ [1]创建一个springboot的web工程
​ [2]创建一个servlet类,继承HttpServlet类,重写其doGet方法和doPost方法
​ 并给浏览器响应一个中文的字符串
​ 设置浏览器解析的字符编码为UTF-8
​ 在该类的上面加上@WebServlet(urlPattern="/请求地址")
​ [3]在springboot的run方法上加@ServletComponentScan(basePackages="/servlet类所在的包")
​ [4]声明一个config类,在此类的上面加@Configuration注解
​ 在这个类里面写一个返回值为FilterRegistrationBean的方法
​ 首先在这个方法里面定义要拦截的字符编码
​ 然后还要定义要拦截的字符编码的路径
​ 写完该方法后在该方法的上面加上@Bean注解
​ [5]在springboot的核心配置文件中关闭springboot的http字符编码支持

​ 注:servlet中乱码的原因:tomcat的编码方式为iso, idea的编码方式我们通常设置的时utf-8,浏览器有的是utf-8,
​ 有的是gbk,还有的是其它
​ 要想解决乱码问题,就需要将这三者的解码和编码的方式都设置为utf-8
​ idea和浏览器的容易设置,浏览器直接设置数据的响应头为utf-8即可
​ (response.setContentType("text/html;charset=UTF-8")
​ get请求乱码的原因:浏览器的编码可能是utf8,而用tomcat传输的过程中为iso,所以在servlet中获取的数据就是
​ 乱码的
​ 解决get乱码:在servlet中先将获得的数据进行iso解码,然后再用utf8编码,此时在控制台显示就不乱码了
​ 解决post乱码的:post中的数据在tomcat中是以二进制的方式进行传播的,我们只需要在接受参数前设置接收的
​ 方式为方式为utf8即可
​ 解决servlet向浏览器发送的数据乱码:首先在发送数据前设置tomcat发送的数据的编码格式为utf8,其次设置
​ 浏览器解析tomact发来的数据的编码为utf8,然后再发送数据
​ 用controller不会乱码

​ 2>方法二(使用注解):

​ [1]创建一个工程
​ [2]写一个servlet类,继承HttpServlet类,重写其get和post方法
​ 并发送给客户端中文
​ [3]在springboot的核心配置文件中设置springboot的相应编码

方式一:

main:

package com.wang.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan(basePackages = "com.wang.springboot.servlet")
public class Springboot28CharacterEncoding1Application {

    public static void main(String[] args) {
        SpringApplication.run(Springboot28CharacterEncoding1Application.class, args);
    }

}

config配置类

package com.wang.springboot.conf;

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.filter.CharacterEncodingFilter;

@Configuration
public class MyConfig {

    @Bean
    public FilterRegistrationBean myFilter(){

        //创建字符编码过滤器
        CharacterEncodingFilter cef = new CharacterEncodingFilter();
        //设置强制使用指定的字符编码
        cef.setForceEncoding(true);
        //设置指定字符编码
        cef.setEncoding("utf-8");

        FilterRegistrationBean frb = new FilterRegistrationBean();

        //设置字符编码过滤器
        frb.setFilter(cef);
        //设置过滤器所要过滤的路径:所有的路径
        frb.addUrlPatterns("/*");

        return frb;
    }
}

springboot配置文件

#将springboot核心配置文件中的有关字符编码的设置停掉,
#这样我们设置的字符编码才有效
server.servlet.encoding.enabled=false

servlet

package com.wang.springboot.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/mycharacter")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;character=utf-8");
        resp.getWriter().println("你好中国!");
        resp.getWriter().flush();
        resp.getWriter().close();

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

方式二:

main:

package com.wang.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.web.servlet.ServletComponentScan;

@SpringBootApplication
@ServletComponentScan(basePackages = "com.wang.springboot.servlet")
public class Springboot29CharacterEncoding2Application {

    public static void main(String[] args) {
        SpringApplication.run(Springboot29CharacterEncoding2Application.class, args);
    }

}

​ 核心配置文件

#设置请求相应字符编码,设置服务器的传输字符编码为utf8
server.servlet.encoding.enabled=true
server.servlet.encoding.force=true
server.servlet.encoding.charset=utf-8

servlet

package com.wang.springboot.servlet;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@WebServlet(value = "/mycharacter")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        resp.setCharacterEncoding("utf-8");
        resp.setContentType("text/html;character=utf-8");
        resp.getWriter().println("你好世界!");
        resp.getWriter().flush();
        resp.getWriter().close();

    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

7. Springboot下打war,jar包

1>springboot打war包

步骤:

​ [1]创建一个springboot下的web工程
​ [2]创建一个controller类
​ [3]添加springboot集成jsp的依赖,指明编译resource(不是java)目录下的配置文件的插件
​ [4]在springboot的核心配置文件中配置视图解析器
​ [5]想要打包的方式为war包,需要在xml文件中配置war
​ 还需要在build下指明打包的名称名称
​ [6]修改springboot的main方法所在的类
​ 该类需要继承SpringbootServletInitializer
​ 并重写configure方法
​ 在该方法中return一个builder.sources(main方法名.class)重新构造资源
​ [7]执行maven中的clean后执行package命令,打好的war包在target目录下
​ [8]将打好的war包放在tomcat的webapp目录下,并启动tomcat服务器

注:[1]页面报404的时候,可能是因为没有加jsp的依赖和没有指定jsp的路径
查看静态资源的路径是否正确,因为404可能不是因为controller的问题,而是jsp页面或html页面引起的
[2]在controller中的数据如果是放在map中,则可以在jsp页面通过map.value获取其key
[3]在打war包时,sprginboot中配置的tomcat端口号会失效(因为最后是在tomcat上部署的)

pom

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <packaging>warpackaging>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.5version>
        <relativePath/> 
    parent>
    <groupId>com.wang.springbootgroupId>
    <artifactId>springboot30-warartifactId>
    <version>0.0.1-SNAPSHOTversion>

    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

        
        <dependency>
            <groupId>org.apache.tomcat.embedgroupId>
            <artifactId>tomcat-embed-jasperartifactId>
        dependency>
    dependencies>

    <build>
        <finalName>springbootfinalName>
        <resources>
            <resource>
                
                <directory>src/main/webappdirectory>
                
                <targetPath>META-INF/resourcestargetPath>
                
                <includes>
                    <include>*.*include>
                includes>
            resource>

           
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.*include>
                includes>
            resource>
        resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

project>

appliaction

spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

controller

package com.wang.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;

@Controller
public class Mycontroller {

    @RequestMapping(value = "/user/hello")
    @ResponseBody
    public String hello(){
        return "你好,springboot;你好,世界";
    }

    @RequestMapping(value = "/user/detail/hello")
    public String user(Model model){
        HashMap<Object, Object> map = new HashMap<>();
        map.put("name","张三");
        map.put("age","18");
        model.addAttribute("user",map);
        return "user";
    }
}

user.jsp

<%--
  Created by IntelliJ IDEA.
  User: 14330
  Date: 2021/10/10
  Time: 9:43
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Titletitle>
head>
<body>
<div>姓名:${user.name}div>
<div>年龄:${user.age}div>
body>
html>

2>springboot打jar包

步骤:

​ [1]添加jsp的依赖和jsp的路径
​ [2]添加编译resource下配置文件的插件
​ [3]修改plugin中的spring-boot-maven-plugin的版本号为1.4.2.RELEASE
​ [4]指明要打的jar包的名称
​ [5]jar包需要通过springboot内嵌的tomcat来启动,即:在cmd窗口下,输入命令java -jar jar包的名称.jar
​ 或者也可以建一个.bat文件,文件中的内容为java -jar jar包的名称.jar 然后双击启动

在linux中部署jar包:
需要创建一个shell脚本,在该脚本中添加jar包
脚本内容为#!/bin/sh
java -jar springboot.jar
需要赋予该jar包777的权限:chmod 777 springboot-jar.sh
在windows中将jar包和刚编写的shell脚本放在同一目录下

3>war包和jar包的不同之处

[1]jar包依赖自己springboot内部的tomcat来启动,所以在jar包内配置tomcat的端口号是有效的
而war包是依赖外部的tomcat服务器,所以war包内部配置的端口号是无效的
[2]war包必须依赖外部的tomcat来启动,所以在访问的时候必须要在原有的路径中加入finalName的值
jar包不用加
[3]在打jar包时,.jar文件和.bat或.sh文件必须在同一目录下

pom

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.5version>
        <relativePath/> 
    parent>
    <groupId>com.wang.springbootgroupId>
    <artifactId>springboot31-jarartifactId>
    <version>0.0.1-SNAPSHOTversion>

    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

        
        <dependency>
            <groupId>org.apache.tomcat.embedgroupId>
            <artifactId>tomcat-embed-jasperartifactId>
        dependency>
    dependencies>

    <build>
        <finalName>springbootfinalName>
        <resources>
            <resource>
                
                <directory>src/main/webappdirectory>
                
                <targetPath>META-INF/resourcestargetPath>
                
                <includes>
                    <include>*.*include>
                includes>
            resource>

            
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.*include>
                includes>
            resource>
        resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <version>1.4.2.RELEASEversion>
            plugin>
        plugins>
    build>

project>

核心配置文件

server.port=9090
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

controller

package com.wang.springboot.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;

@Controller
public class Mycontroller {

    @RequestMapping(value = "/student/hello")
    @ResponseBody
    public String hello(){
        return "你好,springboot;你好,世界";
    }

    @RequestMapping(value = "/student/detail/hello")
    public String user(Model model){
        HashMap<Object, Object> map = new HashMap<>();
        map.put("name","张三");
        map.put("age","18");
        model.addAttribute("user",map);
        return "user";
    }
}

user.jsp

<%--
  Created by IntelliJ IDEA.
  User: 14330
  Date: 2021/10/10
  Time: 9:43
  To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


姓名:${user.name}
年龄:${user.age}

8. Springboot集成logback

1>简介

​ logback的作用:logback主要用于sql语句日志信息的打印
​ 其功能类似于log4j(log for Java)

​ logback介绍
​ [1]几个级别, 级别从低到高分为 TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果 设置为 WARN，则低 于 WARN 的信息都不会输出
​ [2]可以将日志信息打印到控制台
​ [3]可以将日志打印到一个文件中
​ 可以设置一天打印一个日志文件
​ 可以设置当操作那些文件的时候会打印日志
​ [4]可以定义日志的格式

2>步骤

​ [1]首先要创建一个springboot工程
​ [2]在pom文件中添加连接mysql驱动,mybatis驱动(logback已经被springboot默认添加过了),配置逆向工程,解析java下的 xml文件的插件
​ [3]启动逆向工程
​ [4]创建一个控制层类
​ 写一个方法,调用service层:获取学生总人数
​ [5]写一个service层接口
​ [6]写一个service的实现类
​ [7]写mapper中的sql语句
​ [8]在main方法上加注解@MapperScan(baskpackage=“mapper文件所在的包名”)
​ [9]在springboot的配置文件中配置连接mysql的信息
​ [10]启动linux下的mysql服务
​ [11]在springboot下的resource目录下创建一个logback-spring.xml文件
​ [12]在pom文件中lomback
​ [13]在需要打印日志的类上@slf4j注解
​ 在方法中加log.info(“要传达的信息”)

​ 当报映射文件找不到时,可以查看一下pom文件中是否有加载java目录下的xml文件的插件

logback-spring.xml

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为 TRACE < DEBUG < INFO < WARN < ERROR < FATAL，如果
设置为 WARN，则低于 WARN 的信息都不会输出 -->
<!-- scan:当此属性设置为 true 时，配置文件如果发生改变，将会被重新加载，默认值为
true -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认
单位是毫秒。当 scan 为 true 时，此属性生效。默认的时间间隔为 1 分钟。 -->
<!-- debug:当此属性设置为 true 时，将打印出 logback 内部日志信息，实时查看 logback
运行状态。默认值为 false。通常不打印 -->
<configuration scan="true" scanPeriod="10 seconds">
    <!--输出到控制台-->
    <appender name="CONSOLE"
              class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志 appender 是为开发使用，只配置最底级别，控制台输出的日志级别是大
       于或等于此级别的日志信息-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
        <encoder>
            <Pattern>%date [%-5p] [%thread] %logger{60}
                [%file : %line] %msg%n</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <appender name="FILE"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!--<File>/home/log/stdout.log</File>-->
        <File>D:/Java/zothers/stdout.log</File>
        <encoder>
            <pattern>%date [%-5p] %thread %logger{60}
                [%file : %line] %msg%n</pattern>
        </encoder>
        <rollingPolicy
                class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 添加.gz 历史日志会启用压缩 大大缩小日志文件所占空间 -->

            <!--<fileNamePattern>/home/log/stdout.log.%d{yyyy-MM-dd}.log</fileNam
            ePattern>-->

            <fileNamePattern>D:/Java/zothers/stdout.log.%d{yyyy-MM-dd}.log</fileNamePattern>
            <maxHistory>30</maxHistory><!-- 保留 30 天日志 -->
        </rollingPolicy>
    </appender>
    <logger name="com.wang.springboot.mapper" level="DEBUG" />
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>
</configuration>

application.properties

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://192.168.221.131:3306/springboot?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=GMT%2B8&rewriteBatchedStatements=true&allowPublicKeyRetrieval=true
spring.datasource.username=root
spring.datasource.password=123456

serviceimpl

package com.wang.springboot.serviceIm;

import com.wang.springboot.mapper.StudentMapper;
import com.wang.springboot.model.Student;
import com.wang.springboot.service.StudentServer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class StudentServerImpl implements StudentServer {

    @Autowired
    StudentMapper mapper;

    @Override
    public Integer querryStudentCount() {
        Integer count = mapper.selectStudentCount();
        return count;
    }

    @Override
    public Integer insertIntoStudent(Student student) {
        int ret = mapper.insert(student);
        return ret;
    }

}

server

package com.wang.springboot.service;

import com.wang.springboot.model.Student;

public interface StudentServer {


    Integer querryStudentCount();

    Integer insertIntoStudent(Student student);
}

mapper

<mapper namespace="com.wang.springboot.mapper.StudentMapper">
  <resultMap id="BaseResultMap" type="com.wang.springboot.model.Student">
    <id column="id" jdbcType="INTEGER" property="id" />
    <result column="name" jdbcType="VARCHAR" property="name" />
    <result column="age" jdbcType="INTEGER" property="age" />
  resultMap>
  <sql id="Base_Column_List">
    id, name, age
  sql>
  <select id="selectByPrimaryKey" parameterType="java.lang.Integer" resultMap="BaseResultMap">
    select 
    <include refid="Base_Column_List" />
    from t_student
    where id = #{id,jdbcType=INTEGER}
  select>
  <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer">
    delete from t_student
    where id = #{id,jdbcType=INTEGER}
  delete>
  <insert id="insert" parameterType="com.wang.springboot.model.Student">
    insert into t_student (id, name, age
      )
    values (#{id,jdbcType=INTEGER}, #{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER}
      )
  insert>
  <insert id="insertSelective" parameterType="com.wang.springboot.model.Student">
    insert into t_student
    <trim prefix="(" suffix=")" suffixOverrides=",">
      <if test="id != null">
        id,
      if>
      <if test="name != null">
        name,
      if>
      <if test="age != null">
        age,
      if>
    trim>
    <trim prefix="values (" suffix=")" suffixOverrides=",">
      <if test="id != null">
        #{id,jdbcType=INTEGER},
      if>
      <if test="name != null">
        #{name,jdbcType=VARCHAR},
      if>
      <if test="age != null">
        #{age,jdbcType=INTEGER},
      if>
    trim>
  insert>
  <update id="updateByPrimaryKeySelective" parameterType="com.wang.springboot.model.Student">
    update t_student
    <set>
      <if test="name != null">
        name = #{name,jdbcType=VARCHAR},
      if>
      <if test="age != null">
        age = #{age,jdbcType=INTEGER},
      if>
    set>
    where id = #{id,jdbcType=INTEGER}
  update>
  <update id="updateByPrimaryKey" parameterType="com.wang.springboot.model.Student">
    update t_student
    set name = #{name,jdbcType=VARCHAR},
      age = #{age,jdbcType=INTEGER}
    where id = #{id,jdbcType=INTEGER}
  update>

  <select id="selectStudentCount" resultType="java.lang.Integer">
    select count(*) from t_student
  select>
mapper>

mapper.java

package com.wang.springboot.mapper;

import com.wang.springboot.model.Student;

public interface StudentMapper {
    int deleteByPrimaryKey(Integer id);

    int insert(Student record);

    int insertSelective(Student record);

    Student selectByPrimaryKey(Integer id);

    int updateByPrimaryKeySelective(Student record);

    int updateByPrimaryKey(Student record);

    Integer selectStudentCount();
}

controller

package com.wang.springboot.controller;

import com.wang.springboot.model.Student;
import com.wang.springboot.service.StudentServer;
import jdk.nashorn.internal.runtime.logging.Logger;
import lombok.extern.java.Log;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
@Slf4j
public class Mycontroller {

    @Autowired
    private StudentServer server;

    @RequestMapping(value = "/count")
    @ResponseBody
    public String StudentCount(){

        log.info("查询学生中人数!");
        Integer count = server.querryStudentCount();
        return "学生总人数为:"+count;
    }

    @RequestMapping(value = "/insert")
    @ResponseBody
    public String insertStudent(String name,Integer age){
        Student student = new Student();
        student.setName(name);
        student.setAge(age);
        Integer ret = server.insertIntoStudent(student);
        return "成功添加的人数为:"+ret;
    }

}

main

package com.wang.springboot;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@MapperScan(basePackages = "com.wang.springboot.mapper")
public class Springboot32LogbackApplication {

    public static void main(String[] args) {
        SpringApplication.run(Springboot32LogbackApplication.class, args);
    }

}

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.5.5version>
        <relativePath/> 
    parent>

    <groupId>com.wang.springbootgroupId>
    <artifactId>springboot32-logbackartifactId>
    <version>0.0.1-SNAPSHOTversion>

    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>

        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>

        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
        dependency>

        
        <dependency>
            <groupId>org.mybatis.spring.bootgroupId>
            <artifactId>mybatis-spring-boot-starterartifactId>
            <version>2.1.4version>
        dependency>

        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.2version>
        dependency>

    dependencies>

    <build>

        <resources>
            
            
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.xmlinclude>
                includes>
            resource>
        resources>
        <plugins>
            
            <plugin>
                <groupId>org.mybatis.generatorgroupId>
                <artifactId>mybatis-generator-maven-pluginartifactId>
                <version>1.3.5version>
                <dependencies>
                    <dependency>
                        <groupId>mysqlgroupId>
                        <artifactId>mysql-connector-javaartifactId>
                        <version>8.0.26version>
                    dependency>
                dependencies>
                <configuration>
                    <configurationFile>GeneratorMapper.xmlconfigurationFile>
                    <verbose>trueverbose>
                    <overwrite>falseoverwrite>
                configuration>
            plugin>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>

project>

9.Springboot集成Thymeleaf

1>Thymeleaf简介

​ Thymeleaf 是一个流行的模板引擎，该模板引擎采用 Java 语言开发

​ 模板引擎是一个技术名词，是跨领域跨平台的概念，在 Java 语言体系下有模板引擎， 在 C#、PHP 语言体系下也有模 板引擎，甚至在 JavaScript 中也会用到模板引擎技术，Java 生 态下的模板引擎有 Thymeleaf 、Freemaker、Velocity、 Beetl（国产） 等。

​ Thymeleaf 对网络环境不存在严格的要求，既能用于 Web 环境下，也能用于非 Web 环 境下。在非 Web 环境下，他能 直接显示模板上的静态数据；在 Web 环境下，它能像 Jsp 一 样从后台接收数据并替换掉模板上的静态数据。它是基于 HTML 的，以 HTML 标签为载体， Thymeleaf 要寄托在 HTML 标签下实现。

​ SpringBoot 集成了 Thymeleaf 模板技术，并且 Spring Boot 官方也推荐使用 Thymeleaf 来 替代 JSP 技术，Thymeleaf 是另外的一种模板技术，它本身并不属于 Spring Boot，Spring Boot 只是很好地集成这种模板技术，作为前端页面的数 据展示，在过去的 Java Web 开发中，我 们往往会选择使用 Jsp 去完成页面的动态渲染，但是 jsp 需要翻译编译运行，效 率低

​ Thymeleaf 的官方网站：http://www.thymeleaf.org

​ Thymeleaf 官方手册：https://www.thymeleaf.org/doc/tutorials/3.0/usingthymeleaf.html

2>使用thymeleaf

​ [1]创建一个springboot的web工程时,在最后一步额外勾选Template Engines下的Thymeleaf
​ [2]观察pom文件中,多个了springboot集成thymeleaf的依赖
​ [3]写一个控制层, 跳转的页面为一个html的thymeleaf页面
​ [4]在templates包下创建一个html页面
​ 在html的页面的< html>标签上面加上一个网址:< html lang=“en” xmls:th=“http://www.thymeleaf.org”>
​ 用th:text="${变量名}"来接收后端传来的数据

3>设置在修改thymeleaf页面表面内容时可以及时的在web页面中更新

​ [1]创建一个web工程
​ [2]在controller中写一个控制类,跳转到一个thymeleaf的页面中
​ [3]写一个thymeleaf页面,接收controller中传来的数据
​ [4]在springboot的核心配置文件中配置thymeleaf模板引擎为关闭状态
​ 在启动项那里修改on Update action 和on frame deactivation的值为Update resources

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EXGKrimm-1647607696515)(https://gitee.com/One12123/photo2/raw/master/img/202203182047756.png)]

4>Thymeleaf中的变量表达式

4.1介绍

​ 标准表达式就是th:text= 变 量 名 的 形 式 ​ 选 择 表 达 式 的 格 式 为 < d i v t h : o b j e c t = {变量名}的形式 ​ 选择表达式的格式为

变量名的形式​选择表达式的格式为<divth:object={变量名 } > < span th:text=""> < span/> < div/>
​ 混合表达式就是将标准表达式的&换成*

​ 声明:在实际开发中,不管是标准表达式还是选择变量表达式,都能起到相同的效果
​ 但是选择变量表达式容易混淆,所以在实际开发中,我们通常用的是标准变量表达式

4.2 步骤

​ [1]首先创建一个带有thymeleaf的工程
​ [2]先写一个controller控制层,在里面将参数传入到thymeleaf中
​ [3]在thymeleaf中用几种表达式来进行接收数据

controller:

package com.wang.springboot.controller;

import com.wang.springboot.model.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class MyController {

    @RequestMapping(value = "/user/message")
    public String userMessage(Model model){
        User user = new User();
        user.setName("张章");
        user.setAge(18);
        user.setId(1);
        model.addAttribute("user",user);
        return "message";

    }
}

message.html

<html lang="en" xmls:th="http://www.thymeleaf.org" xmlns:xmls="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h1>标准变量表达式---->常用h1>
用户的姓名为:<div th:text="${user.name}">div>
用户的年龄为:<div th:text="${user.age}">div>
用户的id为:<div th:text="${user.id}">div>

<h1>选择表达式----不推荐h1>

<div th:object="${user}">
    用户的姓名为:<span th:text="*{name}">span><br>
    用户的年龄为:<span th:text="*{age}">span><br>
    用户的id为:<span th:text="*{id}">span><br>
div>

<h1>标准表达式和选择表达式混合使用----不推荐h1>
用户的姓名为:<div th:text="*{user.name}">div>
用户的年龄为:<div th:text="*{user.age}">div>
用户的id为:<div th:text="*{user.id}">div>
body>

html>

5>Thymeleaf中的url路径表达式

​ 5.1为什么要用这种方式:
​ 因为传统的方式为在写跳转页面的时候,一般写的都是绝对路径
​ 如:< a href=“http://localhost:8080/user”/>
​ 这种方法有很大的局限性,如:在测试和开发或正式部署的时候ip都是不一样的,这时就需要不停的修改,很麻烦
​ 而thymeleaf的内置跳转是相对跳转,不用修改ip

​ 5.2不带参数的格式

​ < a th:href="@{/user/detail}"> 跳转至:/user/detail< /a>

​ 5.3带参数的格式

​ 带一个参数
​ < a th:href=@{/test?username=xxx} >
​ < a th:href=@{’/test?username=’+${username}} >

​ 带多个参数
​ 第一种格式(字符串拼接):< a th:href=@{’/test?username=’+KaTeX parse error: Expected 'EOF', got '&' at position 12: {usernam}+'&̲id='{id}+’&age=’KaTeX parse error: Expected 'EOF', got '}' at position 6: {age}}̲ > ​ 第二种格式(推…{username},id=$id,age=${age})} >

​ 注:当使用RESTFul风格时,只能拼接,不能用()
​ 例:< a th:href="@{’/test2/’+$username{+}^{\prime }{/}^{\prime }+${username}}">

6>thymeleaf和js以及img标签结合

​ 6.1 thymeleaf与js结合

​ 原本引入js的方法为:< script type=“text/javascript” src=“js/jquery-3.4.1.min.js”>< /script>
​ 与thymeleaf结合后为:< script type=“text/javascript” th:src="@{js/jquery-3.4.1.min.js}">< /script>

​ 6.2 thymeleaf与ing标签结合

​ 格式:< img th:src="@{/img/001.jpg}"> 引用static下的img包中的001.jpg

​ img中的路径会自动去static下去找资源

7>thymeleaf中的常用属性

​ 在获取后台值时,通常用的是表达式${name}
​ 在引用指定资源文件时,通常用的是表达式@{} :如后台的路径,一个跳转的网址,一个img路径的引用

​ 7.1 表单提交

​ th:action="@{地址值}"

​ 7.2 each遍历集合

​ 格式: th:each=“当前循环的变量名称,userStat:${循环的对象}”

​ 注:userStat可选,默认有这个变量名, 即不写也可以用
​ userStat的作用就是获取当前循环变量的信息 , 如:
​ userStat.count 获取当前变量是第几个
​ userStart.index: 获取当前变量的索引下标

​ 7.3 each遍历map集合

​ 格式: th:each=“当前循环变量的名称,userStar:${循环的对象}”

​ 注:同样的,userStat可选

​ 7.4 each遍历arry数组

​ 格式: th:each=“当前循环变量的名称,userStar:${循环的对象}”

​ 7.5 each循环遍历复杂的集合

​

​ 7.6 条件判断

​ 7.6.1 if语句
​ 格式: th:if="${变量 eq 1}" 或 th:if

​ 7.6.2 switch/case语句
​ 格式: th:switch="${变量名}"
​ th:case=“数值1”
​ th:case=“数值2”
​ th:case=“数值3”
​ …

​ 7.7 内敛表达式

​ 作用:引用后台传来的数据
​ 官方建议: 必须在div的子标签中写. 但是实际上在div的外部也可以使用
​ 格式: 在普通div中使用时,需要在div标签中指定 th:inline=“text” 然后可以用[[$变量名]]的格式使用后台的数据在javascript中使用时,需要在script标签中声明th:inline="javascript"然后才能以[[${变量名}]]的格式使用

​ 7.8 字面量

​

​ 7.9 字符串的拼接

​ 格式: th:text="|…$后台变量1......${后台变量2}…${后台变量3}…|"

​ 7.10 基本表达式对象

​ 7.10.1 session的对象

​ 有三种表达放方式:
​ th:text="KaTeX parse error: Expected '}', got '#' at position 2: {#̲session.getAttr…{#httpSession.getAttritibute(‘变量名’)}"
​ th:text="${session.变量名}"

​ 7.10.2 request对象

​ [[KaTeX parse error: Expected '}', got '#' at position 2: {#̲request.getSche…{#request.getServerName()}]] 获取服务器名称
​ [[KaTeX parse error: Expected '}', got '#' at position 2: {#̲request.getServ…{#request.getContextPath()}]] 获取上下文根

​ 7.10.3 功能表达式对象

​ th:text="${#datas.format(time,‘yyyy-MM-dd HH:mm:ss’)}" 打印出后台传来的time时间,并以
​ yyyy-MM-dd HH:mm:ss 的形式输出到页面

​ th:text="${#strings.substring(data,0,10)}" 将string字符串的[0,10)位截下来