Springboot

最新推荐文章于 2023-06-02 20:12:18 发布

一次|||

最新推荐文章于 2023-06-02 20:12:18 发布

阅读量1.5k

点赞数 1

分类专栏：笔记文章标签： spring boot

本文链接：https://blog.csdn.net/qq_51694696/article/details/123584147

版权

笔记专栏收录该内容

21 篇文章 0 订阅

订阅专栏

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

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wang</groupId>
    <artifactId>springboot08-jsp</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot08-jsp</name>
    <description>springboot08-jsp</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--
            引入springboot内嵌Tomcat对jsp的解析依赖,不添加解析不了jsp
            仅仅只是展示jsp页面,只添加一下一个依赖
        -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>

    </dependencies>

    <build>
        <!--
            springboot项目默认推荐的前端引擎是thymeleaf
            现在我们要使用springboot集成jsp,手动指定jsp最后编译好的路径
            而且springboot集成jsp编译jsp的路径是springboot规定好的位置
            META-INF/resources
        -->
        <resources>
            <resource>
                <!--源文件-->
                <directory>src/main/webapp</directory>
                <!--指定编译到META-INF/resources-->
                <targetPath>META-INF/resources</targetPath>
                <!--指定资源文件夹下的那些资源要进行编译-->
                <includes>
                    <include>*.*</include>
                </includes>
            </resource>
        </resources>

        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.2.6.RELEASE</version>
            </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" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>message:${message}</h1>
</body>
</html>

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

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

    <packaging>war</packaging>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wang.springboot</groupId>
    <artifactId>springboot30-war</artifactId>
    <version>0.0.1-SNAPSHOT</version>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--引入jsp的解析器-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>springboot</finalName>
        <resources>
            <resource>
                <!--源文件-->
                <directory>src/main/webapp</directory>
                <!--指定编译到META-INF/resources-->
                <targetPath>META-INF/resources</targetPath>
                <!--指定资源文件夹下的那些资源要进行编译-->
                <includes>
                    <include>*.*</include>
                </includes>
            </resource>

           <!--表示编译resource下的配置文件-->
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </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>Title</title>
</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

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.5</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wang.springboot</groupId>
    <artifactId>springboot31-jar</artifactId>
    <version>0.0.1-SNAPSHOT</version>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--引入jsp的解析器-->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
        </dependency>
    </dependencies>

    <build>
        <finalName>springboot</finalName>
        <resources>
            <resource>
                <!--源文件-->
                <directory>src/main/webapp</directory>
                <!--指定编译到META-INF/resources-->
                <targetPath>META-INF/resources</targetPath>
                <!--指定资源文件夹下的那些资源要进行编译-->
                <includes>
                    <include>*.*</include>
                </includes>
            </resource>

            <!--表示编译resource下的配置文件-->
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>1.4.2.RELEASE</version>
            </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" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<div>姓名:${user.name}</div>
<div>年龄:${user.age}</div>
</body>
</html>

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<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);
    }

}

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

    <groupId>com.wang.springboot</groupId>
    <artifactId>springboot32-logback</artifactId>
    <version>0.0.1-SNAPSHOT</version>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

        <!--mysql驱动连接的依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--mybatis集成springboot的依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.4</version>
        </dependency>

        <!--slef4j的依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.2</version>
        </dependency>

    </dependencies>

    <build>

        <resources>
            <!-- 表示编译java源码时，包含src/main/java和src/main/resources目录下的xml、properties一起 -->
            <!--如果mapper.xml在src/main/java目录下，就必须做这个配置，不然编译后会丢弃mapper.xml文件-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <!--逆向工程的插件-->
            <plugin>
                <groupId>org.mybatis.generator</groupId>
                <artifactId>mybatis-generator-maven-plugin</artifactId>
                <version>1.3.5</version>
                <dependencies>
                    <dependency>
                        <groupId>mysql</groupId>
                        <artifactId>mysql-connector-java</artifactId>
                        <version>8.0.26</version>
                    </dependency>
                </dependencies>
                <configuration>
                    <configurationFile>GeneratorMapper.xml</configurationFile>
                    <verbose>true</verbose>
                    <overwrite>false</overwrite>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </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= ${变量名}的形式选择表达式的格式为<div th: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

<!DOCTYPE html>
<html lang="en" xmls:th="http://www.thymeleaf.org" xmlns:xmls="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</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>
<!--
    *{}必须使用th:object属性来绑定这个对象
    在div子标签中使用*来代替绑定的对象
-->
<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}}̲ > 第二种格式(推\dots$ {username},id= ${id},age=$ {age})} >

注:当使用RESTFul风格时,只能拼接,不能用()
例:< a th:href="@{’/test2/’+ ${username}+'/'+$ {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\dots$ {#httpSession.getAttritibute(‘变量名’)}"
th:text="${session.变量名}"

7.10.2 request对象

[[ $KaTeX parse error: Expected '}', got '#' at position 2: {#̲request.getSche\dots$ {#request.getServerName()}]] 获取服务器名称
[[ $KaTeX parse error: Expected '}', got '#' at position 2: {#̲request.getServ\dots$ {#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)位截下来

一次|||

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Springboot

Spring Boot1.Spring Boot入门1.1Spring Boot简介 SpringBoot是Spring家族中的一个框架为什么要学Spring Boot?因为在我们学习SSM框架的时候,我们需要有一堆的配置文件,如Mybatis,Spring,SpringMVC, web.xml这些配置文件,而且大多的时候这些文件的配置都是重复性的工作,Spring Boot就是为了简化这一过程 Spring Boot可以非常容易和快速创建基于Spring框架的应用程序,它让编代码变得
复制链接

扫一扫