TSCCG

Spring Boot学习笔记

视频出处：动力节点springboot视频教程

为什么要使用Spring Boot?

使用Spring和SpringMVC时需要用到大量的xml配置文件，配置各种对象，把使用的对象放入到Spring容器中才能使用对象，十分繁琐。同时，用Spring整合其他框架时，需要了解其他框架的配置规则。
Spring Boot就好比是不需要配置文件的Spring和SpringMVC，已经提前把常用的框架和第三方库配置好了，直接使用即可。开发起来效率更高，更为方便。

第1章 XML和JavaConfig

Spring使用XML作为容器配置文件，在3.0之后加入了JavaConfig，使得可以用java类作为配置文件使用。

这一点就是Spring Boot移除SSM中大量配置文件所用到的重要技术。

1.1 JavaConfig

1.1.1 介绍

**JavaConfig：**使用java类作为xml配置文件的代替，是配置Spring容器的纯java方法。在这个java类中可以创建java对象，把对象注入Spring容器中。

优点：

避免繁琐的xml配置。
可以使用面向对象的方式，一个配置类可以继承另一个配置类，可以重写方法。

1.1.2 XML配置容器

①创建maven工程，添加依赖

<dependencies>
    <dependency>
        <groupId>org.springframeworkgroupId>
        <artifactId>spring-contextartifactId>
        <version>5.3.1version>
    dependency>
    <dependency>
        <groupId>junitgroupId>
        <artifactId>junitartifactId>
        <version>4.12version>
        <scope>testscope>
    dependency>
dependencies>
<build>
    <plugins>
        
        <plugin>
            <artifactId>maven-compiler-pluginartifactId>
            
            <version>3.5.1version>
            
            <configuration>
                <source>1.8source>
                <target>1.8target>
                
                <encoding>UTF-8encoding>
            configuration>
        plugin>
    plugins>
build>

②创建数据类

package com.tsccg.pojo;

public class Student {
    private String name;
    private Integer age;
    private String sex;
    //get和set...
    //toString
}

③resources 目录下创建 Spring 的配置文件：beans.xml

声明一个Student对象：

<bean id="student" class="com.tsccg.pojo.Student">
    <property name="name" value="张三"/>
    <property name="age" value="20"/>
    <property name="sex" value="男"/>
bean>

单元测试：

/**
 * 使用xml方式创建对象
 */
@Test
public void beanTest01() {
    ApplicationContext app = new ClassPathXmlApplicationContext("beans.xml");
    Student student = (Student) app.getBean("student");
    System.out.println("xml方式创建对象："+student);
}

结果：

xml方式创建对象：Student{name='张三', age=20, sex='男'}

1.1.3 JavaConfig配置容器

需要使用两个注解：

@Configuration：放在类上，声明当前类为配置类。
@Bean：放在方法上，将方法返回的对象注入到容器中。

创建配置类：

package com.tsccg.javaconfig;

import com.tsccg.pojo.Student;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

/**
 * @Author: TSCCG
 * @Date: 2021/12/13 18:12
 */
@Configuration//声明此类为配置类，在这个类中有很多方法， 方法的返回值是对象。
public class SpringConfig {
    /**
     * 创建Student对象并返回
     * 通过@Bean注解将对象注入容器，对象默认id为方法名
     */
    @Bean
    public Student createStudent() {
        Student student = new Student();
        student.setName("李四");
        student.setAge(22);
        student.setSex("女");
        return student;
    }

    /**
     * 自定义Bean对象id
     */
    @Bean(name = "liSiStudent")
    public Student createStudent2() {
        Student student = new Student();
        student.setName("李四");
        student.setAge(22);
        student.setSex("女");
        return student;
    }
}

单元测试：

/**
 * 使用javaConfig创建Student对象
 */
@Test
public void beanTest02() {
    ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
    Student student = (Student) app.getBean("createStudent");
    System.out.println("javaConfig方式创建对象："+student);
}

/**
     * 自定义bean对象id
     */
@Test
public void beanTest03() {
    ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
    Student student = (Student) app.getBean("liSiStudent");
    System.out.println("自定义id："+student);
}

结果：

javaConfig方式创建对象：Student{name='李四', age=22, sex='女'}
自定义id：Student{name='李四', age=22, sex='女'}

1.2 @ImporResource

@ImporResource是在配置类里导入其他的xml配置文件，等同于xml配置的

<import resource="classpath:xxx.xml"/>

用法：

①在beans.xml文件中声明一个Student对象

<bean id="wangWuStudent" class="com.tsccg.pojo.Student">
    <property name="name" value="王五"/>
    <property name="age" value="18"/>
    <property name="sex" value="女"/>
bean>

②在配置类上添加@ImporResource注解，导入beans.xml文件

@Configuration
@ImportResource(value="classpath:beans.xml")//导入beans.xml配置文件，指定从类路径下导入
public class SpringConfig {
    ...
}

③单元测试

/**
     * 配置类导入xml配置文件
     */
@Test
public void beanTest04() {
    ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
    Student student = (Student) app.getBean("wangWuStudent");
    System.out.println("JavaConfig导入xml配置文件："+student);
}

结果：

JavaConfig导入xml配置文件：Student{name='王五', age=18, sex='女'}

④导入多个配置文件

@Configuration
@ImportResource(value={"classpath:beans.xml","classpath:applicationContext.xml"})
public class SpringConfig {
    ...
}

1.3 @PropertySource

@PropertySource用于在配置类里读取properties属性配置文件，等同于xml配置里的：

<context:property-placeholder location="classpath:xxx.properties"/>

用法：

①在resources目录下创建属性配置文件config.properties

dog.name=小哈
dog.type=哈士奇
dog.age=1

②创建数据类

使用@Component注解创建对象并放入容器，使用@Value注解读取配置文件中的数据并注入对象属性

package com.tsccg.pojo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * @Author: TSCCG
 * @Date: 2021/12/13 19:59
 */
@Component("myDog")//创建对象并注入容器中
public class Dog {
    @Value("${dog.name}")//读取属性配置文件中的数据，注入到对象属性中
    private String name;
    @Value("${dog.type}")
    private String type;
    @Value("${dog.age}")
    private Integer age;

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", type='" + type + '\'' +
                ", age=" + age +
                '}';
    }
}

③修改配置类

1)使用@PropertySource注解读取属性配置文件

2)使用@ComponentScan注解扫描数据类，等同于

@Configuration//声明此类为配置类。
@PropertySource(value="classpath:config.properties")//读取属性配置文件
@ComponentScan(basePackages = "com.tsccg.pojo")//组件扫描器
public class SpringConfig {
    ...
}

④单元测试

/**
 * @PropertySource 读取属性配置文件
 */
@Test
public void beanTest05() {
    ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
    Dog myDog = (Dog) app.getBean("myDog");
    System.out.println("外部属性配置文件注入："+myDog);
}

结果：

外部属性配置文件注入：Dog{name='小哈', type='哈士奇', age=1}

第2章 Spring Boot入门

2.1 介绍

Spring Boot是Spring家族的一个成员，可以简化Spring和SpringMVC的使用。核心还是IOC容器。

特性：

Create stand-alone Spring applications
Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
Provide opinionated ‘starter’ dependencies to simplify your build configuration
Automatically configure Spring and 3rd party libraries whenever possible
Provide production-ready features such as metrics, health checks, and externalized configuration
Absolutely no code generation and no requirement for XML configuration

翻译：

可以独立创建一个Spring应用程序
内嵌有Tomcat、Jetty或Undertow(无需部署WAR文件)，可以单独启动一个web应用。
提供了starter初始依赖以简化项目的构建配置。如在ssm项目中，整合MyBatis框架需要在Spring配置文件中配置MyBatis的对象：DataSource数据源、SqlSessionFactory、Dao代理对象。而在Spring Boot项目中，在pom.xml中加入一个mybatis-spring-boot-starter依赖即可。
尽可能地自动配置Spring以及第三方库。就是把Spring和第三方库中的对象都创建好，放到容器中，开发人员可以直接使用。(如SpringMVC的中央调度器，MyBatis框架的对象)
提供了生产准备功能，如统计(运行时长等)、健康检查(监控项目是否正常运转)和外部化配置(类如属性配置文件)
绝对不会生成代码，无需xml配置文件

2.2 创建Spring Boot项目

2.2.1 方式1：使用Spring Boot提供的初始化器

国外地址：https://start.spring.io/

国内地址：https://start.springboot.io/

步骤：

①新建项目

②初始化设置

③添加依赖

④设置项目路径并创建

⑤项目结构

启动类：Application.java

package com.tsccg;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

测试类：ApplicationTests.java

package com.tsccg;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class ApplicationTests {
    @Test
    void contextLoads() {
    }
}

⑥项目依赖


<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.6.1version>
        <relativePath/> 
    parent>
    
    <groupId>com.tsccggroupId>
    <artifactId>02-springboot-demo-firstartifactId>
    <version>0.0.1-SNAPSHOTversion>
    
    <name>02-springboot-demo-firstname>
    <description>Demo project for Spring Bootdescription>
    
    <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>
    dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>
project>

web起步依赖相关jar：

⑦也可以通过浏览器打开初始化器页面

下载自动生成的项目文件，导入本地即可。

2.2.2 方式2：使用Maven向导

使用Maven向导的方式就是直接创建一个maven项目，按Spring Boot项目结构添加所需文件和配置。

使用Maven创建的好处是可以不用联网。

步骤：

①创建一个空的Maven项目

②修改pom.xml文件

1)添加spring-boot-starter-parent坐标

2)添加web启动依赖及其他配置


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.6.1version>
        <relativePath/> 
    parent>

    <groupId>com.tsccggroupId>
    <artifactId>03-springboot-demo-secondartifactId>
    <version>1.0-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>
    dependencies>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>
project>

③修改项目结构

1)创建启动类Application.java，加入@SpringBootApplication 注解

package com.tsccg;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

2)在resources目录下创建static、templates文件夹，springboot核心配置文件application.properties

3)创建测试类ApplicationTests.java，加入@SpringBootTest注解

package com.tsccg;

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class ApplicationTests {
    @Test
    void contextLoads() {
    }
}

2.3 基于Spring Boot的web例子

在Spring Boot项目中，使用SpringMVC时，不需要提前在配置文件中进行配置，直接使用就行。

步骤：

①基于前面创建的Spring Boot项目，我们直接写一个Controller类：HelloController

②启动Application类的main方法

可以发现内嵌的Tomcat已启动，默认为8080端口。

③在浏览器访问 http://localhost:8080/hello

2.4 @SpringBootApplication注解分析

启动类Application上的@SpringBootApplication注解是Spring Boot项目的重要注解。

其为一个复合注解，内部主要包含@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan三个注解：

@SpringBootConfiguration：内部包含@Configuration注解，作用是声明当前类为配置类，可当作配置文件。
@EnableAutoConfiguration：开启自动配置，把一些java对象配置好，注入Spring容器中。
@ComponentScan：组件扫描器，找到注解，根据注解的功能创建对象，给属性赋值等等。组件扫描器默认扫描的是 @ComponentScan 注解所在的类，类所在的包和子包。

2.5 Spring Boot核心配置文件

Spring Boot 的核心配置文件用于配置 Spring Boot 程序。

名字必须以 application 开始，后缀有两种格式：

.properties：
```
student.name=张三
student.age=21
```

.yml /.yaml：

#属性与上级属性之间留两个空格，值与前面的冒号之间必须留一个空格
student:
  name: 张三
  age: 21

2.5.1 `.properties`文件(默认)

基于前面2.3的web例子进行修改。

①修改application.properties属性配置文件，设置Tomcat启动时开放的端口号以及上下文路径

application.properties：

#设置端口号
server.port=8082
#设置上下文路径
server.servlet.context-path=/boot

②启动应用：

③在浏览器访问 http://localhost:8082/boot/hello

2.5.2 `.yml`文件(推荐)

同基于前面2.3的web例子进行修改。

①对原有的application.properties文件进行删除或修改文件名称

若两种格式的文件同时存在，则优先用application.properties

②在resource目录下创建一个application.yml文件，在其中设置端口号和上下文路径

#设置端口号与上下文路径
#属性与上级属性之间留两个空格，值与前面的冒号之间留一个空格
server:
  port: 8083
  servlet:
    context-path: /boot2

③启动应用

若配置未生效则用maven执行clean–>install操作。

④在浏览器访问 http://localhost:8083/boot2/hello

2.5.3 多环境配置

在实际开发的过程中，我们的项目会经历很多的阶段（开发->测试->上线），每个阶段的配置也会不同。例如：端口、上下文路径、数据库等。

为了方便在不同的环境之间切换，SpringBoot 提供了多环境配置，具体操作如下：

基于2.3的web项目进行修改。

①分别为开发、测试、生产环境创建一个配置文件

命名必须以application-自定义环境标识.properties|yml为准

②在application.yml中指定使用哪个环境的配置，如下：

启动应用，在浏览器访问 http://localhost:9081/dev/hello

③修改application.yml，指定为测试环境

重启应用，在浏览器中访问 http://localhost:9082/test/hello

2.5.4 自定义配置项

SpringBoot 的核心配置文件中，除了使用内置的配置项之外，我们还可以添加自定义配置项，然后采用@Value或@ConfigurationProperties读取配置项的属性。

2.5.4.1@Value

用法：@Value("${key}") ， key 来自 application.properties(yml)

例子：基于2.3web案例进行修改

①在application.properties核心配置文件中加入内置配置项和自定义配置项

#内置配置项
server.port=8081
server.servlet.context-path=/read

#自定义配置项
student.name=张三
student.age=18
wite=www.xxx.com

②修改HelloController

1）添加私有属性并用@Value注解读取application.properties文件的数据进行注入

2）添加处理器方法将属性响应到浏览器

@RestController
public class HelloController {
    @Value("${server.port}")
    private String port;
    @Value("${student.name}")
    private String name;
    @Value("${student.age}")
    private Integer age;
    @Value("${wite}")
    private String wite;

    @RequestMapping("/data")
    public String readData() {
        return name + "由于年龄未到" + age + ",所以不能从" + port + "端口访问" + wite;
    }
}

③启动应用，在浏览器访问 http://localhost:8081/read/data

2.5.4.2@ConfigurationProperties

@ConfigurationProperties：可以把配置文件中的数据映射为java对象，适用于自定义配置项较多的情况。用在类上或配置类方法上。

属性：prefix，用于匹配配置文件中某些配置项开头的内容，如：指定prefix为student，那么就会匹配student.name、student.age等以student开头的配置项。

prefix可以不指定，如果不指定，那么会去配置文件中寻找与该类的属性名一致的配置项，prefix的作用是区分同名配置。

案例演示：(基于上一个例子)

①创建一个java类Student

1)使用@Component注解创建对象并注入容器

2)使用@ConfigurationProperties注解从配置文件中读取配置数据为该类注入属性

package com.tsccg.pojo;

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

@Component
@ConfigurationProperties(prefix = "student")
public class Student {

    private String name;
    private Integer age;
    
    //get set
    //toString
}

使用ConfigurationProperties 注解，IDEA 会出现一个警告，但是不影响程序的执行。在pom中加入如下依赖后，重启项目即可消除。


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-configuration-processorartifactId>
    <optional>trueoptional>
dependency>

②创建StudentController类

@RestController
public class StudentController {
    @Resource//自动注入
    private Student student;

    @RequestMapping("/student")
    public String readStudent() {
        return student.toString();
    }
}

③开启应用，在浏览器访问http://localhost:8081/read/student

2.6 在Spring Boot项目中使用JSP

Spring Boot默认不支持JSP，而是使用模板技术代替jsp。

若要使用jsp需要进行以下配置：

①添加依赖



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


<dependency>
    <groupId>javax.servletgroupId>
    <artifactId>javax.servlet-apiartifactId>
dependency>

<dependency>
    <groupId>javax.servlet.jspgroupId>
    <artifactId>javax.servlet.jsp-apiartifactId>
    <version>2.3.1version>
dependency>



<dependency>
    <groupId>javax.servletgroupId>
    <artifactId>jstlartifactId>
dependency>

②指定jsp文件编译后的存放目录

SpringBoot 要求 jsp 文件必须编译到指定的 META-INF/resources 目录下才能访问，否则访问不到。

在pom.xml的build标签配置如下信息

<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>

③在src/main/目录下创建存放jsp文件的目录：webapp ，并在项目中指定为Web Resource Directory，创建一个jsp文件index.jsp

④在index.jsp中获取请求作用域的数据

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    Title


    ${data}

⑤在application.properties配置文件中配置SpringMVC中的视图解析器

server.port=9090
#视图前缀
spring.mvc.view.prefix=/
#视图后缀
spring.mvc.view.suffix=.jsp

⑥创建JspController，返回视图

package com.tsccg.controller;

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

@Controller
public class JspController {
    @RequestMapping("/doSome")
    public String doSome(Model model) {
        //向请求作用域中放入数据
        model.addAttribute("data","Spring Boot整合Jsp");
        return "index";
    }
}

⑦开启应用，访问 http://localhost:9090/doSome

2.7 Spring Boot中使用容器对象(ApplicationContext)

我们点进启动类中SpringApplication的run方法，发现run方法中返回了一个ConfigurationApplicationContext类型对象，继续点开ConfigurationApplicationContext，发现是一个接口，继承了ApplicationContext。

ApplicationContext为Spring的容器对象，通过该对象可以直接获取容器中的Bean对象。

当我们在不想启动整个项目的前提下测试部分代码时，可以通过main方法中的SpringApplication.run()语句获取返回的Spring容器对象，获取业务bean进行调用。

演示：

①创建业务接口 HelloService

package com.tsccg.service;

public interface HelloService {
    void sayHello(String name);
}

②创建业务接口实现类 HelloServiceImpl

package com.tsccg.service.impl;

import com.tsccg.service.HelloService;
import org.springframework.stereotype.Service;

@Service(value = "helloService")
public class HelloServiceImpl implements HelloService {
    @Override
    public void sayHello(String name) {
        System.out.println("Hello " + name);
    }
}

③在启动类main方法中，获取容器对象，取出业务bean对象调用其方法

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        //获取容器对象
        ConfigurableApplicationContext app = SpringApplication.run(Application.class, args);
        //获取业务bean对象
        HelloService helloService = (HelloService) app.getBean("helloService");
        //调用方法
        helloService.sayHello("张三");
    }
}

④启动应用

2.8 CommandLineRunner接口

开发中可能会有这样的情景：需要在容器启动后执行一些内容，比如读取配置文件，数据库连接之类的。SpringBoot 给我们提供了两个接口来帮助我们实现这种需求，使用任意一个都可以

CommandLineRunner
ApplicationRunner

它们的执行时机为容器启动完成的时候，这两个接口中都有一个 run 抽象方法，我们只需要实现这个方法即可。这两个接口的不同之处在于：

ApplicationRunner接口中的run方法参数为 ApplicationArguments
CommandLineRunner接口中run方法的参数为 String 数组

@FunctionalInterface
public interface CommandLineRunner {
	void run(String... args) throws Exception;
}

@FunctionalInterface
public interface ApplicationRunner {
    void run(ApplicationArguments args) throws Exception;
}

演示使用：

以2.7中的例子为基础，进行修改。

①修改启动类

使启动类实现CommandLineRunner接口，实现其run方法

@SpringBootApplication
public class Application implements CommandLineRunner {
    @Resource
    private HelloService helloService;

    public static void main(String[] args) {
        System.out.println("准备创建容器对象");
        SpringApplication.run(Application.class, args);
        System.out.println("创建容器对象后");
    }
    
    @Override
    public void run(String... args) throws Exception {
        System.out.println("容器对象创建好后，执行的方法");
        String result = helloService.sayHello("李四");
        System.out.println("调用容器对象中的方法：" + result);
    }
}

②开启应用

第3章 Spring Boot与web组件

三个内容：

拦截器 HandlerInterceptor
Servlet
过滤器 Filter

3.1 拦截器

拦截器是SpringMVC中的一种对象，能够拦截对Controller的请求，实现对请求的预先处理。

3.1.1 回顾SpringMVC中使用拦截器

①自定义拦截器，实现HandlerInterceptor接口

public interface HandlerInterceptor {
    
 default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
     return true;
 }

 default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
 }

 default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
 }
}

②在SpringMVC配置文件中注册拦截器类

<mvc:interceptors>
	<mvc:interceptor>
    	<mvc:mapping path="拦截的url" />
        <bean class="拦截器类全限定名称"/>
    mvc:interceptor>
mvc:interceptors>

3.1.2 在Spring Boot中使用拦截器

在Spring Boot中使用拦截器与SpringMVC中使用的步骤大体一致，都是先自定义拦截器，然后将其注册到项目中。

只不过在Spring Boot中要把拦截器注册到@Configuration修饰的配置类中。

具体步骤：

①自定义拦截器

创建java类实现 HandlerInterceptor 接口，实现preHandle方法

package com.tsccg.handlerInterceptor;

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class MyLoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("执行了自定义拦截器的preHandle方法");
        return true;
    }
}

②注册拦截器

创建java类实现WebMvcConfigurer接口，实现其addInterceptors方法，用@Configuration注解修饰该类
将自定义的拦截器对象注册到项目中，设置拦截和放行的url

package com.tsccg.config;

import com.tsccg.handlerInterceptor.MyLoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

/**
 * 相当于SpringMVC配置文件
 */
@Configuration
public class MyAppConfig implements WebMvcConfigurer {
    /**
     * 注册拦截器
     * @param registry 登记系统中可以使用的拦截器对象
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //拦截的url
        String path = "/user/**";
        //放行的url
        String excludePath = "/user/login";
        registry.addInterceptor(new MyLoginInterceptor())
                .addPathPatterns(path).excludePathPatterns(excludePath);
    }
}

③创建测试用的Controller

@RestController
public class UserController {
    @RequestMapping("/user/account")
    public String account() {
        return "10000";
    }
    @RequestMapping("/user/login")
    public String login() {
        return "登录界面";
    }
}

④启动应用

1)通过浏览器访问受拦截的url： http://localhost:8080/user/account

可见，在发送请求后，后台执行了自定义的拦截器方法

2)通过浏览器访问放行的url： http://localhost:8080/user/login

可见，在发送请求后，后台没有执行拦截器方法

3.2 Servlet

ServletRegistrationBean用来注册Servlet对象

使用步骤：

①创建Servlet

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        PrintWriter out = resp.getWriter();
        out.print("使用Servlet对象");
        out.flush();
        out.close();
    }
}

②注册Servlet

@Configuration
public class MyAppConfig{
    /**
     * 注册Servlet
     * @return
     */
    @Bean
    public ServletRegistrationBean servletRegistrationBean() {
        //ServletRegistrationBean reg = new ServletRegistrationBean(new MyServlet(),"/myServlet");
        
        ServletRegistrationBean reg = new ServletRegistrationBean();
        //注册Servlet对象
        reg.setServlet(new MyServlet());
        //设置请求路径
        reg.addUrlMappings("/myServlet");
        return reg;
    }
}

③启动应用，在浏览器中访问 http://localhost:8080/myServlet

3.3 过滤器

FilterRegistrationBean 用来注册 Filter 对象

使用步骤：

①自定义过滤器，实现javax.servlet.Filter接口

public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("执行了自定义过滤器，方法：doFilter");
        chain.doFilter(request,response);
    }
}

②注册过滤器

@Configuration
public class MyAppConfig{
    /**
     * 注册过滤器对象
     * @return
     */
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        //注册自定义过滤器对象
        bean.setFilter(new MyFilter());
        //设置过滤的url
        bean.addUrlPatterns("/user/*");
        return bean;
    }
}

③创建Controller

@RestController
public class MyController {

    @RequestMapping("/user/account")
    public String userAccount() {
        return "过滤器使用测试";
    }
    @RequestMapping("/member/account")
    public String memberAccount() {
        return "过滤器使用测试2";
    }
}

④启动应用

1)访问过滤器指定范围内的地址： http://localhost:8080/user/account

2)访问过滤器指定范围外的地址： http://localhost:8080/member/account

3.4 字符集过滤器

3.4.1回顾SpringMVC使用字符集过滤器

CharacterEncodingFilter是框架提供的字符集过滤器，解决post方式请求中文字符乱码的问题。

在通过SpringMVC框架使用该过滤器时，需要在web.xml中注册该过滤器，配置其属性:


<filter>
    <filter-name>characterEncodingFilterfilter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
    <init-param>
        <param-name>encodingparam-name>
        <param-value>utf-8param-value>
    init-param>
    <init-param>
        <param-name>forceRequestEncodingparam-name>
        <param-value>trueparam-value>
    init-param>
    <init-param>
        <param-name>forceResponseEncodingparam-name>
        <param-value>trueparam-value>
    init-param>
filter>
<filter-mapping>
    <filter-name>characterEncodingFilterfilter-name>
    <url-pattern>/*url-pattern>
filter-mapping>

3.4.2在Spring Boot中使用字符集过滤器

使用的方式有两种：

1.在配置类中注册

2.在Spring Boot核心配置文件中设置

1.在配置类中注册

步骤：

①创建Servlet，在不设置utf-8的情况下响应中文字符

public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html");//不设置utf-8字符集
        PrintWriter out = resp.getWriter();
        out.print("====中文测试数据====");//响应中文字符
        out.flush();
        out.close();
    }
}

②注册Servlet

@Configuration
public class MyAppConfig{
    /**
     * 注册Servlet
     * @return
     */
    @Bean
    public ServletRegistrationBean servletRegistrationBean() {
        ServletRegistrationBean bean =
                new ServletRegistrationBean(new MyServlet(),"/user/inf");
        return bean;
    }
}

③开启应用，在浏览器访问 http://localhost:8080/user/inf

可见，响应的中文字符发生乱码。

④在配置类中注册字符集过滤器

@Configuration
public class MyAppConfig{
    /**
     * 注册Servlet
     * @return
     */
    @Bean
    public ServletRegistrationBean servletRegistrationBean() {
        ServletRegistrationBean bean =
                new ServletRegistrationBean(new MyServlet(),"/user/inf");
        return bean;
    }

    /**
     * 注册过滤器
     * @return
     */
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean bean = new FilterRegistrationBean();
        //创建框架提供的字符集过滤器类
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("utf-8");//设置encoding属性为utf-8
        filter.setForceEncoding(true);//设置请求对象和响应对象的字符编码集与encoding属性一致
        bean.setFilter(filter);//注册字符集过滤器
        bean.addUrlPatterns("/user/*");//设置过滤的url
        return bean;
    }
}

⑤在application.properties中添加如下配置

server.servlet.encoding.enabled=false

⑥重启应用，重新访问

2.在核心配置文件中设置

Spring Boot 项目默认启用了 CharacterEncodingFilter, 直接在application.properties中设置他的属性就可以：

#设置 spring boot 中 CharacterEncodingFitler 的属性值
server.servlet.encoding.enabled=true
server.servlet.encoding.charset=utf-8
#强制 request， response 使用 charset 他的值 utf-8
server.servlet.encoding.force=true

重启应用，重新访问：

第4章 ORM操作数据库

对象关系映射(Object Relational Mapping，简称ORM)，是一种程序设计技术，用于实现面向对象程序语言里不同类型系统的数据之间的转换。

MyBatis就是ORM的一种，下面将展示在Spring Boot项目中使用MyBatis操作MySQL数据库。

建表：

步骤分析：

创建Spring Boot项目，勾选Web、MyBatis、MySQL Driver起步依赖
在application.properties中配置数据库连接信息
创建实体类Student
创建Controller，接收浏览器请求，访问Service
创建Service接口及其实现类，调用Dao接口方法
创建Dao接口，添加查询方法
在Dao接口同级目录下创建对应Mapper文件，指定namespace，写sql语句
在pom.xml中指定把src/main/java目录中的xml文件包含到classpath中

其中，创建Dao代理对象的方式有两种：

在每个Dao接口上添加@Mapper
在启动类上添加@MapperScan(basePackages = {“com.tsccg.dao”,“com.tsccg.dao2”})

4.1 第一种方式：@Mapper

①创建Spring Boot项目，勾选Web、MyBatis、MySQL Driver起步依赖

②在application.properties中配置数据库连接信息

#项目端口号
server.port=9090
#数据库连接信息
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db_mybatis?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=123456

③创建Student实体类

package com.tsccg.pojo;

public class Student {
    private Integer id;
    private String name;
    private String email;
    private Integer age;
	//get set
    //toString
}

④创建Controller

package com.tsccg.controller;

@RestController
public class StudentController {
    @Resource
    private StudentService studentService;

    @RequestMapping("/find")
    public String findStudent(Integer id) {
        Student student = studentService.findById(id);
        return student.toString();
    }
}

⑤创建Service

StudentService接口：

package com.tsccg.service;

import com.tsccg.pojo.Student;

public interface StudentService {
    Student findById(Integer id);
}

接口实现类：

package com.tsccg.service.impl;

import javax.annotation.Resource;

@Service
public class StudentServiceImpl implements StudentService {
    @Resource
    private StudentDao studentDao;

    @Override
    public Student findById(Integer id) {
        return studentDao.findById(id);
    }
}

⑥创建Dao

StudentDao接口：

package com.tsccg.dao;

import com.tsccg.pojo.Student;
import org.apache.ibatis.annotations.Mapper;

@Mapper//告诉MyBatis这是dao接口，创建此接口的代理对象。
public interface StudentDao {
    Student findById(Integer id);
}

在同级目录下创建StudentDao.xml


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tsccg.dao.StudentDao">
    
    <select id="findById" parameterType="int" resultType="com.tsccg.pojo.Student">
        select id,name,email,age from t_student where id = #{id}
    select>
mapper>

⑦由于是在src/main/java目录下创建的mapper映射文件，故需要在pom.xml中指定把src/main/java目录中的xml文件包含到classpath中

在build标签内添加如下语句：

<resources>
    <resource>
        <directory>src/main/javadirectory>
        <includes>
            <include>**/*.xmlinclude>
        includes>
    resource>
resources>

⑧开启应用，在浏览器访问 http://localhost:9090/find?id=1001

4.2 第二种方式：@MapperScan

第一种方式需要在每一个Dao接口上都加@Mapper，当Dao接口较多时不方便。

而这种方式只需要在启动类上添加@MapperScan(basePackages = “com.tsccg.dao”)即可。

@SpringBootApplication
@MapperScan(basePackages = "com.tsccg.dao")
//@MapperScan(basePackages = {"com.tsccg.dao","com.tsccg.dao2"})
public class Application {

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

}

4.3 将Mapper文件与java代码分开管理

我们在项目中更偏向于将mapper文件与java代码分开管理，就是将mapper文件都放在src/main/resources目录下，将java代码都放在src/main/java目录下。

有两种分离方式：

第一种：在resources目录下创建com.tsccg.dao目录，使得编译后将mapper文件和Dao.class文件放在一起
第二种：在resources目录下创建自定义子目录，在核心配置文件中指定从类路径下的该目录找mapper文件

4.3.1第一种分离方式

在resources目录下创建com.tsccg.dao目录，将mapper文件都放进去。

这种分离方式可以在项目编译后，将mapper文件与StudentDao.class文件放在一起，如下：

步骤：

①在resources目录下创建com.tsccg.dao目录，将mapper文件移动至该目录下。

注意，在resources目录下创建com.tsccg.dao目录时，必须用/表示分层，如下：

不然会将com.tsccg.dao当作一个目录名，编译后不会将mapper文件与StudentDao.class放在一起。

②在pom.xml中注释掉原先设置的resources标签，不然会编译报错

③重启应用，通过浏览器重新访问

4.3.2第二种分离方式

第二种方式可以告诉程序从什么位置找到mapper文件，无需让mapper文件与编译后的StudentDao.class位于同级目录。

步骤：

①在resources目录下创建自定义的子目录，如mapper，然后将mapper文件放入。

②在application.properties核心配置文件中指定mapper文件所在位置

#指定mapper文件的位置
mybatis.mapper-locations=classpath:mapper/*.xml
#指定使用mybatis的日志
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

③同样需要在pom.xml中注释掉原先设置的resources标签，不然会编译报错

④重启应用，重新访问地址

4.4事务

在Spring Boot中使用事务很简单，底层用的还是Spring提供的事务管理。

使用步骤：

在入口类上添加 @EnableTransactionManagement注解开启事务支持(默认开启,但最好添上)
在访问数据库的Service接口实现类上添加 @Transactional注解即可

实例演示：

以4.1中的例子为基础进行修改。

①分别在入口类上和Service接口实现类上添加事务注解

②在Controller里添加删除方法

使用try…catch语句监控Service中是否抛出异常，响应相应信息。

@RestController
public class StudentController {
    @Resource
    private StudentService studentService;
    
    @RequestMapping("/delete")
    public String deleteStudentById(Integer id) {
        try {
            //通过id删除学生信息
            studentService.deleteById(id);
            return "删除成功";
        } catch (Exception e) {
            e.printStackTrace();
            return "删除失败";
        }
    }
}

③在Service接口中添加删除方法并在实现类中实现

StudentService：

public interface StudentService {
	//通过id删除学生信息
    void deleteById(Integer id);
}

StudentServiceImpl：

@Service
@Transactional//开启事务
public class StudentServiceImpl implements StudentService {
    @Resource
    private StudentDao studentDao;
    
    @Override
    public void deleteById(Integer id) {
        studentDao.deleteById(id);//调用Dao删除数据
        int a = 10 / 0;//抛出运行时异常
    }
}

④在Dao接口中定义删除方法并在Mapper文件中添加对应sql语句

StudentDao：

public interface StudentDao {

    void deleteById(Integer id);
}

StudentDao.xml：


DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.tsccg.dao.StudentDao">
    <delete id="deleteById" parameterType="int">
        delete from t_student where id = #{id}
    delete>
mapper>

⑤测试

开启应用，通过浏览器访问 http://localhost:9090/delete?id=1006

第5章 RESTful 接口架构风格

5.1 RESTful简介

REST(Representational State Transfer)，表现层资源状态转移。

REST是一种互联网软件架构设计的风格，并不是标准，可用也可不用。它只是提出了一组客户端与服务器交互时的架构理念和设计原则，基于这种理念和原则设计的接口可以更简洁，更有层次。说白了，就是一种统一的url命名格式，将CRUD操作的url命名规范化，统一化。

表现层资源状态转移概念说明：

表现层：就是视图层，显示资源的，通过视图页面、jsp等显示操作资源的结果。
资源：服务器端的动静态资源文件，数据库表中的数据等都是资源。每个资源都是服务器上一个可命名的抽象概念，是以名词为核心来组织的，如用user表示用户在服务端数据库的信息。一个资源可由一个或多个url来标识，url既是资源的名称，也是Web上的地址。在浏览器等客户端上，可以通过资源的url与其进行交互。
资源状态：就是对于资源的表述，当我们通过浏览器访问一个视频、一段文字或一张图片时，对应资源的表述格式是不一样。
资源状态转移：资源状态转移说的是资源在客户端和服务端之间转移(请求资源-响应资源)的表述。通过转移和操作资源的表述来实现操作资源的目的。

5.2 RESTful的实现

我们过去访问一个资源所用的url五花八门，如访问一个用户信息：

http://localhost:8080/findUserById?id=1001		GET		//查询一个用户信息  
http://localhost:8080/addUser					POST 	//添加用户信息	
http://localhost:8080/updateUser				POST	//更新用户信息	
http://localhost:8080/deleteUserById?id=1001	GET		//删除一个用户信息

以上这些url所操作的都是同一个资源，在url内就写明了对该资源的操作。

而REST是面向资源的，资源是通过url进行暴露的。REST中，url的设计只需要把资源通过合理的方式暴露出来即可，对资源的操作与url无关，操作是通过HTTP动词来体现的。

HTTP协议中，GET、POST、DELETE、PUT都是表示操作方式的动词。

它们分别对应四种基本操作：

GET：获取资源
POST：新建资源
DELETE：删除资源
PUT：更新资源

REST风格提倡url地址使用统一的风格设计，用名词表示资源，以及访问资源的信息，在url中，使用/分隔对资源的访问信息。

修改上面的url为REST风格：

http://localhost:8080/user/1001		GET		//查询一个用户信息  
http://localhost:8080/user			POST	//添加用户信息
http://localhost:8080/user/1001		DELETE	//删除一个用户信息
http://localhost:8080/user			PUT		//更新用户信息

现在问题有两个问题：

浏览器只支持GET和POST方式的请求，如何发送DELETE和PUT请求呢？
如何获取拼接到url中的请求参数值呢？

5.3 发送DELETE和PUT请求

在SpringMVC中有一个过滤器，支持将POST请求转换为DELETE、PUT请求。

过滤器：org.springframework.web.filter.HiddenHttpMethodFilter

核心方法：

从过滤器方法中得出，我们可以在页面上用表单方式发送POST请求，在携带的请求参数中添加一个名为_method的参数，值为DELETE或PUT。

如下：

<form action="/user" method="POST">
    id：<input type="text" name="id"><br/>
    姓名：<input type="text" name="name"><br/>
    
    <input type="hidden" name="_method" value="PUT"><br/>
    <input type="submit" value="更新">
form>

然后在项目中注册该过滤器即可将POST请求转换为PUT请求。

在application.properties中注册HiddenHttpMethodFilter过滤器：

spring.mvc.hiddenmethod.filter.enabled=true

此外，我们也可以通过ajax发送DELETE或PUT请求，但只有部分浏览器支持。

5.4 RESTful中的注解

在Spring Boot中开发RESTful主要由如下几个注解实现

① @PathVariable：获取拼接到url中的参数数据，是实现RESTful最主要的一个注解

② @GetMapping：接收和处理GET方式的请求，等同于 @RequestMapping(method=RequestMethod.GET)

③ @PostMapping：接收和处理POST方式的请求，等同于 @RequestMapping(method=RequestMethod.POST)

④ @DeleteMapping：接收和处理DELETE方式的请求，等同于 @RequestMapping(method=RequestMethod.DELETE)

⑤ @PutMapping：接收和处理PUT方式的请求，等同于 @RequestMapping(method=RequestMethod.PUT)

5.4 注解使用练习

以4.4中的例子为基础进行修改。

①在application.properties中注册HiddenHttpMethodFilter过滤器：

#设置端口号
server.port=9090
#注册HiddenHttpMethodFilter过滤器
spring.mvc.hiddenmethod.filter.enabled=true

②编写前端页面

在resources/static目录下新建index.html，发送crud四种请求

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<div id="app">
    <h3>查询h3>
    <a href="/student/1001">查询a>
    <hr>

    <h3>删除h3>
    <form action="/student/1007" method="POST">
        <input type="hidden" name="_method" value="DELETE"><br>
        <input type="submit" value="删除"><br/>
    form>
    <hr>

    <h3>添加h3>
    <form action="/student" method="POST">
        id：<input type="text" name="id"><br/>
        姓名：<input type="text" name="name"><br/>
        <input type="submit" value="添加"><br/>
    form>
    <hr>

    <h3>更新h3>
    <form action="/student" method="POST">
        id：<input type="text" name="id"><br/>
        姓名：<input type="text" name="name"><br/>
        <input type="hidden" name="_method" value="PUT"><br/>
        <input type="submit" value="更新"><br/>
    form>
div>
body>
html>

③编写Controller

package com.tsccg.controller;

@RestController
public class StudentController {

    /**
     * 根据id获取学生信息
     * @PathVariable
     * 1.作用：获取url中的数据
     * 2.位置：处理器形参前
     * 3.value：路径变量值 {studentId}
     */
    @GetMapping("/student/{studentId}")//处理GET请求
    public String findStudent(@PathVariable(value="studentId") Integer id) {
        return "执行查询操作，id="+id;
    }

    /**
     * 添加学生
     */
    @PostMapping("/student")//处理POST请求
    public String addStudent(@RequestParam Map<String,String> student) {
        return "执行添加操作，student="+student;
    }
    
    /**
     * 根据id删除学生信息
     */
    @DeleteMapping("/student/{studentId}")//处理DELETE请求
    public String deleteStudent(@PathVariable("studentId") Integer id) {
        return "执行删除操作，id="+id;
    }
    
    /**
     * 更新学生信息
     */
    @PutMapping("/student")//处理PUT请求
    public String updateStudent(@RequestParam Map<String,String> student) {
        return "执行更新操作,student="+student;
    }
}

④测试

开启应用，从浏览器访问 http://localhost:9090/index.html

5.5 REST注意URL+请求方式必须唯一

在REST中，必须保证URL+请求方式是唯一的，若出现如下情况，会报错。

@GetMapping("/student/{studentId}")
public String findStudentById(@PathVariable(value="studentId") Integer id) {
    return "根据id查询学生信息";
}
@GetMapping("/student/{studentName}")
public String findStudentByName(@PathVariable(value="studentName") String name) {
    return "根据姓名查询学生信息";
}

第6章 Spring Boot集成Redis

6.1 Redis简介

Redis是一个NoSQL数据库，常用作缓存使用。通过Redis客户端可以使用多种语言在程序中访问Redis数据。其中，java语言使用的客户端库有：Jedis、Lettuce、Redisson等。

那么在Spring Boot中，使用的Redis客户端库是什么呢？

创建一个Spring Boot项目，勾选Web和Redis起步依赖：

查看项目导入的Redis相关依赖：

可以看出，在Spring Boot中，默认使用的Redis客户端库为lettuce

6.2 演示添加和获取操作

①创建Spring Boot项目，勾选web和redis起步依赖

其中，Spring Boot会根据redis的起步依赖在容器中创建两个对象：

RedisTemplate
SpringRedisTemplate


<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-data-redisartifactId>
dependency>

在程序中使用RedisTemplate类的方法操作redis数据，实际就是调用的lettuce 客户端中的方法

②在核心配置文件application.properties中配置连接redis信息

#配置端口号
server.port=9090

#配置redis
spring.redis.host=localhost
spring.redis.port=6379
#spring.redis.password=123

③创建Controller

注入RedisTemplate对象，通过该对象的以ops开头的几个方法获取操作redis中各种类型数据的对象

如：

opsForValue()---->ValueOperations---->String类型数据
opsForHash()---->HashOperations---->Hash类型数据

然后就可以通过获取的对象执行set/get方法，管理redis中的数据了。

package com.tsccg.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

@RestController
public class RedisController {
	
    //注入RedisTemplate对象
    @Resource
    private RedisTemplate redisTemplate;
	
    //向redis中添加String类型数据
    @PostMapping("/student/{name}")
    public String setKey(@PathVariable String name) {
       	//获取管理redis中String类型的对象
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //执行添加操作
        valueOperations.set("name",name);
        return "添加了学生："+name;
    }
	
    //从redis中获取添加的数据
    @GetMapping("/student")
    public String getValue() {
        //获取管理redis中String类型的对象
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //执行获取操作
        return (String)valueOperations.get("name");
    }

}

④测试

1)开启windows版redis服务

2)开启项目服务，通过postman客户端软件，以POST方式发送： http://localhost:9090/student/小明

3)再以GET方式发送请求：http://localhost:9090/student

4)通过Redis Desktop Manager桌面工具查看刚刚插入的数据

发现在redis中添加的数据为序列化的数据。

⑤修改Controller，注入StringRedisTemplate对象

package com.tsccg.controller;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;

@RestController
public class RedisController {
    //修改注入StringRedisTemplate对象
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    
    //修改添加的数据为age
    @PostMapping("/student/{age}")
    public String setKey(@PathVariable String age) {
        //通过StringRedisTemplate对象获取操作Stirng类型数据的对象
        ValueOperations valueOperations = stringRedisTemplate.opsForValue();
        valueOperations.set("age",age);
        return "添加了年龄："+age;
    }
	//修改获取的数据为age
    @GetMapping("/student")
    public String getValue() {
        ValueOperations valueOperations = stringRedisTemplate.opsForValue();
        return (String)valueOperations.get("age");
    }

}

⑥重新测试

重启应用，重新发送添加请求：

再次查看redis库中存入的数据：

发现这次在redis中存入的数据是正常的。

6.3 对比RedisTemplate和StringRedisTemplate

RedisTemplate：把key和value经过序列化存到redis中，key和value是序列化的内容，不能直接识别。默认使用的是jdk的序列化方式，可以修改为其它的系列化方式。

StringRedisTemplate：把key和value作为String处理，使用的是String的序列化，可读性好。

序列化与反序列化：

序列化：把对象转换为可传输的字节序列过程就叫序列化
反序列化：把字节序列还原为对象的过程就叫反序列化。

为什么要进行序列化？

我们在实际项目开发中，使用的redis都是放在linux上的，而为了让数据对象可以从其它地方跨平台存放到linux系统上去，就必须将对象序列化。

序列化最终的目的就是为了让对象可以跨平台存储，可以通过网络传输。而我们进行跨平台存储和网络传输的方式就是IO，IO支持的数据格式就是字节数组。我们必须在把对象转换为字节数组前就指定一种规则(序列化)，那么我们从IO流读取数据的时候再以这种规则把对象还原。(反序列化)

序列化的常见方式：

序列化只是一种拆装组装对象的规则，这种规则也多种多样。比如现在常用的序列化方式有：JDK(不支持跨语言)、JSON、XML、Hessian、Kryo(不支持跨语言)、Thrift、Protofbuff 等。

jdk的序列化：把java对象转为byte[], 二进制数据
json序列化：json序列化能将对象转换为 JSON 格式或从 JSON 格式转换为对象。例如把一个Student对象转换为JSON字符串{“name”:“李四”, “age”:29} )，反序列化(将JSON字符串 {“name”:“李四”, “age”:29} 转换为Student对象)

6.4 设置key和value的序列化方式

Redis数据序列化方式有：

其中，默认的序列化方式为jdk的序列化，将key和value转换为二进制字节数组。

6.4.1 设置为String序列化方式

①修改Controller

@RestController
public class RedisController {

    @Resource
    private RedisTemplate redisTemplate;

    @PostMapping("/student/{key}/{value}")
    public String setKey(@PathVariable String key,@PathVariable String value) {
        // 使用RedisTemplate ，在存取值之前，设置序列化
        //设置key的序列化方式为String
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置value的序列化方式为String
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(key,value);
        return "添加：" + "key=" + key + ",value=" + value;
    }

    @GetMapping("/student/{key}")
    public String getValue(@PathVariable String key) {
        ValueOperations valueOperations = redisTemplate.opsForValue();
        return (String)valueOperations.get(key);
    }

}

②发送POST请求：http://localhost:9090/student/email/[email protected]

③查看redis库：

6.4.2 设置为JSON序列化方式

①设置Idea自动生成序列化版本号

②创建实体类，实现序列化接口，在实体类中自动生成序列化版本号

③修改Controller，设置value为JSON序列化方式

@Resource
private RedisTemplate redisTemplate;

@PostMapping("/student")
public String addJson() {
    //创建一个Student对象
    Student student = new Student();
    student.setName("Tom");
    student.setAge(40);
    student.setEmail("[email protected]");
    //设置key的序列化方式为String
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    //设置value的序列化方式为JSON
    redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Student.class));
    //添加操作
    redisTemplate.opsForValue().set("myStudent",student);
    return "添加："+student.toString();
}

@GetMapping("/student")
public String getValue() {
    //设置key的序列化方式为String
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    //设置value的序列化方式为JSON
    redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer(Student.class));
    ValueOperations valueOperations = redisTemplate.opsForValue();
    return valueOperations.get("myStudent").toString();
}

④发送post请求： http://localhost:9090/student (序列化)

⑤查看redis库

⑥发送get请求： http://localhost:9090/student 反序列化

第7章 Spring Boot集成Dubbo

7.1 创建父模块

创建一个普通maven模块作为父模块，模块名：16-dubbo-parent

进行如下操作：

1）删除src目录

2）修改pom.xml，指定打包方式为pom

3）继承spring-boot-starter-parent模块

4）添加dubbo和zookeeper起步依赖


<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.6.1version>
        <relativePath/> 
    parent>

    <groupId>com.tsccggroupId>
    <artifactId>16-dubbo-parentartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <packaging>pompackaging>

    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        
        <dependency>
            <groupId>org.apache.dubbogroupId>
            <artifactId>dubbo-spring-boot-starterartifactId>
            <version>2.7.8version>
        dependency>
        
        <dependency>
            <groupId>org.apache.dubbogroupId>
            <artifactId>dubbo-dependencies-zookeeperartifactId>
            <version>2.7.8version>
            <type>pomtype>
            
            <exclusions>
                <exclusion>
                    <groupId>org.slf4jgroupId>
                    <artifactId>slf4j-log4j12artifactId>
                exclusion>
            exclusions>
        dependency>
    dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>
project>

7.2 创建公共接口模块

创建一个普通maven模块，无父模块，在此模块中只定义公共的接口和实体类。

模块名：common-interface

GAV坐标：

<groupId>com.tsccggroupId>
<artifactId>common-interfaceartifactId>
<version>0.0.1-SNAPSHOTversion>

创建实体类Student，实现序列化接口

package com.tsccg.pojo;

import java.io.Serializable;

public class Student implements Serializable {
    private String name;
    private Integer age;
    private String email;
	//get set
    //toString
}

创建公共接口 StudentService，定义方法

package com.tsccg.pojo.com.tsccg.service;

import com.tsccg.pojo.Student;

public interface StudentService {
    //获取Studnet数据
    Student getStudent();
}

7.3 创建服务消费者模块

创建普通maven模块：server-consumer，继承父模块 16-dubbo-parent

然后进行如下操作：

①在pom.xml中添加依赖

1）声明Spring Boot的web起步依赖

2）添加公共接口模块依赖

<dependencies>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    
    <dependency>
        <groupId>com.tsccggroupId>
        <artifactId>common-interfaceartifactId>
        <version>0.0.1-SNAPSHOTversion>
    dependency>
dependencies>

②在resources目录下创建application.properties核心配置文件，配置dubbo

#服务暴露接口
server.port=8081

##配置dubbo
#服务名称
spring.application.name=server-consumer
#扫描dubbo注解所在包
dubbo.scan.base-packages=com.tsccg.service
#指定注册中心地址，此处用的是本地的zookeeper
dubbo.registry.address=zookeeper://localhost:2181

③在java目录下创建com.tsccg.Application 启动类

添加开启Dubbo的注解：@EnableDubbo

package com.tsccg;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubbo//开启dubbo
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

④创建Controller

使用@DubboReference注解远程注入StudentService对象

package com.tsccg.controller;

import com.tsccg.pojo.Student;
import com.tsccg.pojo.com.tsccg.service.StudentService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class StudentController {

    @DubboReference(version = "1.0")//dubbo远程注入
    private StudentService  studentService;

    @GetMapping("/student")
    public String getStudent() {
        //调用服务方法
        Student student = studentService.getStudent();
        return student.toString();
    }
}

7.4 创建服务提供者模块

同服务消费者，创建一个普通maven模块：server-provider，继承父模块

进行如下操作：

①添加依赖

<dependencies>
    
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
    
    <dependency>
        <groupId>com.tsccggroupId>
        <artifactId>common-interfaceartifactId>
        <version>0.0.1-SNAPSHOTversion>
    dependency>
dependencies>

②创建核心配置文件：application.properties，配置dubbo

#暴露服务接口
server.port=8080

##配置dubbo
#服务名称
spring.application.name=server-provider
#扫描dubbo注解所在包
dubbo.scan.base-packages=com.tsccg.service
#指定注册中心地址
dubbo.registry.address=zookeeper://localhost:2181

③创建启动类：Application，添加开启dubbo注解

package com.tsccg;

import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
@EnableDubbo//开启dubbo
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

④创建服务实现类

package com.tsccg.service.impl;

import com.tsccg.pojo.Student;
import com.tsccg.pojo.com.tsccg.service.StudentService;
import org.apache.dubbo.config.annotation.DubboService;

//使用Dubbo提供的@DubboService注解，指定接口class为StudentService.class
@DubboService(interfaceClass = StudentService.class,version = "1.0")
public class StudentServiceImpl implements StudentService{

    @Override
    public Student getStudent() {
        //创建一个Student对象
        Student student = new Student();
        student.setName("杰瑞");
        student.setAge(30);
        student.setEmail("[email protected]");
        return student;
    }
}

7.5 测试

①开启zookeeper

②先后运行服务提供者和服务消费者应用

③在浏览器中发送请求： http://localhost:8081/student

第8章 Spring Boot打包方式

Spring Boot 可以打包为 war 或 jar 文件。以两种方式发布应用。

8.1 打war包

步骤：

1.创建一个Spring Boot项目，添加Web起步依赖

2.修改pom.xml

1)添加内嵌 Tomcat 对 jsp 的解析包依赖


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

2)指定jsp编译目录

<build>
    
    <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>
build>

3)指定打包方式为war

4)指定打包后生成war包的名称

在build标签内添加如下语句：


<finalName>myBootfinalName>

5)完整的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.6.1version>
        <relativePath/> 
    parent>
    <groupId>com.tsccggroupId>
    <artifactId>17-package-warartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <packaging>warpackaging>

    <properties>
        <java.version>1.8java.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        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>
            
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.*include>
                includes>
            resource>
        resources>
        
        <finalName>myBootfinalName>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
        plugins>
    build>
project>

3.创建webapp并引入项目，在其中创建index.jsp作为视图

4.配置视图解析器

在核心配置文件 application.properties中添加如下内容：

#前缀
spring.mvc.view.prefix=/
#后缀
spring.mvc.view.suffix=.jsp

5.创建Controller

package com.tsccg.controller;

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

@Controller
public class WarController {

    @RequestMapping("/doSome")
    public String doSome(Model model) {
        model.addAttribute("data","war包");
        return "index";
    }
}

6.测试，开启应用，在浏览器中访问 http://localhost:8080/doSome

7.让启动类继承SpringBootServletInitializer

只有继承了此类，重写其configure方法后，生成的war包才能单独部署到外部的服务器中。

SpringBootServletInitializer就是原有的web.xml文件的替代。使用了嵌入式Servlet，默认不支持jsp。

package com.tsccg;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class Application extends SpringBootServletInitializer {

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

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        return builder.sources(Application.class);
    }
}

8.部署至外部独立服务器

1）将生成的war包部署到外部的Tomcat服务器中

通过maven执行clean---->package后，将target 目录下的 war 文件拷贝到 tomcat 服务器 webapps 目录中

2）启动Tomcat

3）在浏览器中访问 http://localhost:8080/myBoot/doSome

多出的/myBoot是由于我们开启tomcat后，会自动将war文件解压缩，我们的项目文件都在解压缩的文件夹中。

8.2 打jar包

以前面打war包的例子为基础进行修改。

1.修改pom.xml

1）指定打包方式为jar

默认打包类型就是jar，删除原先指定的war包语句即可

2）指定springboot-maven-plugin版本

打包jar，有jsp文件时，必须指定maven-plugin插件的版本是 1.4.2.RELEASE

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

3）修改Controller

@RequestMapping("/doOther")
public String doOther(Model model) {
    model.addAttribute("data","jar包");
    return "index";
}

4）修改主启动类不继承SpringBootServletInitializer

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

2.执行打包，通过cmd窗口执行命令运行jar包，启动内置的Tomcat

1）通过maven执行clean–>package，生成myBoot.jar

2）进入myBoot.jar包所在目录，打开cmd窗口

3）运行启动命令，启动内置的Tomcat

java -jar myBoot.jar

4）在浏览器中发送请求 http://localhost:8080/doOther

8.3 war包部署与jar包部署的区别

war包必须部署到独立的外部服务器上，占用资源较多。但独立的服务器功能较多，这种方式能更好的利用服务器。

jar包可以通过内置的tomcat单独运行，占用资源少。但内置的服务器功能较少，性能不如war包方式。

8.4 Spring Boot项目部署和运行方式总结

8.4.1 开发阶段

在IDEA中直接运行主启动类的main方法。

8.4.2 上线部署阶段

1.打jar包

在IDEA中通过maven插件将项目打成jar包，可用java -jar xxx.jar命令启动内置的Tomcat。

上线部署到Linux系统上时，可以将该命令封装到一个Shell脚本中，步骤如下：

①在jar包同级目录里创建一个shell脚本，编写如下内容

run.sh：

#!/bin/sh
java -jar xxx.jar

②赋予权限

chmod 777 run.sh

③启动shell脚本

./run.sh

2.打war包

在IDEA中通过maven插件将项目打成war包，单独部署到tomcat等服务器的发布目录下运行

你可能感兴趣的:(常用框架,java,spring,spring,boot,restful)

Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
SpringBlade dict-biz/list 接口 SQL 注入漏洞文章永久免费只为良心 oracle 数据库
SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
spring如何整合druid连接池？惜.己 spring spring junit 数据库 java idea 后端 xml
目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
springboot+vue项目实战一-创建SpringBoot简单项目苹果酱0567 面试题汇总与解析 spring boot 后端 java 中间件开发语言
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
Spring MVC 全面指南：从入门到精通的详细解析一杯梅子酱技术栈学习 spring mvc java
引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
Spring Boot中实现跨域请求 BABA8891 spring boot 后端 java
在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Java java 爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
博客网站制作教程 2401_85194651 java maven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
对股票分析时要注意哪些主要因素？会飞的奇葩猪股票分析云掌股吧
　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。一、成交量　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
【Scala十八】视图界定与上下文界定 bit1129 scala
Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。隐式参数首先引入一个泛型函数max，用于取a和b的最大值 def max[T](a: T, b: T) = { if (a > b) a else b } 因为T是未知类型，只有运行时才会代入真正的类型，因此调用a >
C语言的分支——Object-C程序设计阅读有感 darkblue086 apple c 框架 cocoa
自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 Object-C程序设计这本书
去除浏览器对表单值的记忆周凡杨 html 记忆 autocomplete form 浏览
&n
java的树形通讯录 g21121 java
最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 // 首先取出每个部门的联系人 for (int i = 0; i < depList.size(); i++) { List<Contacts> list = getContactList(depList.get(i
Nginx安装部署 510888780 nginx linux
Nginx ("engine x") 是一个高性能的 HTTP 和反向代理服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
java servelet异步处理请求墙头上一根草ｊａｖａ异步返回ｓｅｒｖｌｅｔ
servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能， final AsyncContext ac = request.startAsync(request, response); ac.s
我的spring学习笔记8-Spring中Bean的实例化 aijuans Spring 3
在Spring中要实例化一个Bean有几种方法： 1、最常用的（普通方法） <bean id="myBean" class="www.6e6.org.MyBean" /> 使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。（有构造方法的下个文细说） 2、还
为Mysql创建最优的索引 annan211 mysql 索引
索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。索引经常会被误解甚至忽略，而且经常被糟糕的设计。索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比较好的索引性能要好2个数量级。 1 索引的类型 (1) B-Tree 不出意外，这里提到的索引都是指 B-
日期函数百合不是茶 oracle sql 日期函数查询
ORACLE日期时间函数大全 TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年显示值:07 yyy three digits 三位年显示值:007
线程优先级 bijian1013 java thread 多线程 java多线程
多线程运行时需要定义线程运行的先后顺序。线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。实例： package com.bijian.study; /** * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
适配器模式和代理模式的区别 bijian1013 java 设计模式
一.简介适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。 &nbs
【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件 bit1129 Mybatis3
SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句，这些元素包含三方面内容 1. 要执行的SQL语句 2. SQL语句的入参，比如查询条件 3. SQL语句的返回结果
oracle大数据表复制备份个人经验 bitcarter oracle 大表备份大表数据复制
前提：数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。
HTTP加速器varnish安装小记 ronin47 http varnish 加速
上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度 bylijinnan java
public class LongestSymmtricalLength { /* * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 */ public static void main(String[] args) { Str
学习编程的一点感想 Cb123456 编程感想 Gis
写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目. 本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
[能源与安全]美国与中国 comsci 能源
现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。在这个大
SEMI-JOIN执行计划突然变成HASH JOIN了的原因分析 cwqcwqmax9 oracle
甲说： A B两个表总数据量都很大，在百万以上。 idx1 idx2字段表示是索引字段 A B 两表上都有 col1字段表示普通字段 select xxx from A where A.idx1 between mmm and nnn and exists (select 1 from B where B.idx2 =
SpringMVC-ajax返回值乱码解决方案 dashuaifu Ajax springMVC response 中文乱码
SpringMVC-ajax返回值乱码解决方案一：（自己总结，测试过可行） ajax返回如果含有中文汉字，则使用：（如下例：） @RequestMapping(value="/xxx.do") public @ResponseBody void getPunishReasonB
Linux系统中查看日志的常用命令 dcj3sjt126com OS
因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 cat tail -f 日志文件说明 /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信
[应用结构]应用 dcj3sjt126com PHP yii2
应用主体应用主体是管理 Yii 应用系统整体结构和生命周期的对象。每个Yii应用系统只能包含一个应用主体，应用主体在入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
assertThat用法 eksliang JUnit assertThat
junit4.0 assertThat用法一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 2、assertThat( testedNumber, anyOf( g
android点滴2 gundumw100 应用服务器 android 网络应用 OS HTC
如何让Drawable绕着中心旋转？ Animation a = new RotateAnimation(0.0f, 360.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f); a.setRepeatCount(-1); a.setDuration(1000); 如何控制Andro
超简洁的CSS下拉菜单 ini html Web 工作 html5 css
效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>简洁的HTML+CSS下拉菜单-HoverTree</title>
kafka consumer防止数据丢失 kane_xie kafka offset commit
kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。考虑这样一个case，partiton_num=2
@Repository、@Service、@Controller 和 @Component mhtbbx DAO spring bean prototype
@Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
java 多线程高并发读写控制误区 qifeifei java thread
先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ public class testTh7 { private String data; public String read(){ System.out.println(Thread.currentThread().getName() + "read data "
mongodb replica set(副本集)设置步骤 tcrct java mongodb
网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下：首先先去下载一个mongodb最新版，目前最新版应该是2.6 cd /usr/local/bin wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz tar -zxvf mongodb-linux-x86_64-2.6.0.t
rust学习笔记 wudixiaotie 学习笔记
1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 let x = 1; let mut y = 2; 2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 4.每个语句结尾都要加分

Spring Boot学习笔记

第1章 XML和JavaConfig

1.1 JavaConfig

1.1.1 介绍

1.1.2 XML配置容器

1.1.3 JavaConfig配置容器

1.2 @ImporResource

1.3 @PropertySource

第2章 Spring Boot入门

2.1 介绍

2.2 创建Spring Boot项目

2.2.1 方式1：使用Spring Boot提供的初始化器

2.2.2 方式2：使用Maven向导

2.3 基于Spring Boot的web例子

2.4 @SpringBootApplication注解分析

2.5 Spring Boot核心配置文件

2.5.1 .properties文件(默认)

2.5.2 .yml文件(推荐)

2.5.3 多环境配置

2.5.4 自定义配置项

2.5.4.1@Value

2.5.4.2@ConfigurationProperties

2.6 在Spring Boot项目中使用JSP

2.7 Spring Boot中使用容器对象(ApplicationContext)

2.8 CommandLineRunner接口

第3章 Spring Boot与web组件

3.1 拦截器

3.1.1 回顾SpringMVC中使用拦截器

3.1.2 在Spring Boot中使用拦截器

3.2 Servlet

3.3 过滤器

3.4 字符集过滤器

3.4.1回顾SpringMVC使用字符集过滤器

3.4.2在Spring Boot中使用字符集过滤器

1.在配置类中注册

2.在核心配置文件中设置

第4章 ORM操作数据库

4.1 第一种方式：@Mapper

4.2 第二种方式：@MapperScan

4.3 将Mapper文件与java代码分开管理

4.3.1第一种分离方式

4.3.2第二种分离方式

4.4事务

第5章 RESTful 接口架构风格

5.1 RESTful简介

5.2 RESTful的实现

5.3 发送DELETE和PUT请求

5.4 RESTful中的注解

5.4 注解使用练习

5.5 REST注意URL+请求方式必须唯一

第6章 Spring Boot集成Redis

6.1 Redis简介

6.2 演示添加和获取操作

6.3 对比RedisTemplate和StringRedisTemplate

6.4 设置key和value的序列化方式

6.4.1 设置为String序列化方式

6.4.2 设置为JSON序列化方式

第7章 Spring Boot集成Dubbo

7.1 创建父模块

7.2 创建公共接口模块

7.3 创建服务消费者模块

7.4 创建服务提供者模块

7.5 测试

第8章 Spring Boot打包方式

8.1 打war包

8.2 打jar包

8.3 war包部署与jar包部署的区别

8.4 Spring Boot项目部署和运行方式总结

8.4.1 开发阶段

8.4.2 上线部署阶段

你可能感兴趣的:(常用框架,java,spring,spring,boot,restful)

2.5.1 `.properties`文件(默认)

2.5.2 `.yml`文件(推荐)