万字详解，Spring Boot快速上手指南

最新推荐文章于 2024-03-10 23:55:33 发布

Java架构狮

最新推荐文章于 2024-03-10 23:55:33 发布

阅读量1.1k

点赞数 1

文章标签： java 面试 spring

本文链接：https://blog.csdn.net/m0_69860228/article/details/124517447

版权

Spring Boot

1 Spring Boot入门

1.1 Spring Boot特性：

能够快速创建基于 Spring 的应用程序
能够直接使用 java main 方法启动内嵌的 Tomcat 服务器运行 Spring Boot 程序，不需要部署 war 包文件
提供约定的 starter POM 来简化 Maven 配置，让 Maven 的配置变得简单
自动化配置，根据项目的 Maven 依赖配置，Spring boot 自动配置 Spring、Spring mvc 等
提供了程序的健康检查等功能
基本可以完全不使用 XML 配置文件，采用注解配置

1.2 SpringMvc常用注解：

1.2.1 @Controller

Spring MVC 的注解，处理 http 请求

1.2.2 @RestController

Spring 4 后新增注解，是@Controller 注解功能的增强是 @Controller 与@ResponseBody 的组合注解如果一个 Controller 类添加了@RestController，那么该 Controller 类下的所有方法都相当于添加了@ResponseBody 注解用于返回字符串或 json 数据

1.2.3 @RequestMapping（常用）

支持 Get 请求，也支持 Post 请求

1.2.4 @GetMapping

RequestMapping 和 Get 请求方法的组合只支持 Get 请求 Get 请求主要用于查询操作

1.2.5 @PostMapping

RequestMapping 和 Post 请求方法的组合只支持 Post 请求 Post 请求主要用户新增数据

1.2.6 @PutMapping

RequestMapping 和 Put 请求方法的组合只支持 Put 请求 Put 通常用于修改数据

1.2.7 @DeleteMapping

RequestMapping 和 Delete 请求方法的组合只支持 Delete 请求通常用于删除数据
- /** * 该案例主要演示了使用 Spring 提供的不同注解接收不同类型的请求 */ //RestController 注解相当于加了给方法加了@ResponseBody 注解，所以是不能跳转页面的，只能返回字符串或者 json 数据 @RestController public class MVCC ontroller { @GetMapping(value = "/query") public String get() { return "@GetMapping 注解,通常查询时使用"; } @PostMapping(value = "/add") public String add() { return "@PostMapping 注解，通常新增时使用"; } @PutMapping(value = "/modify") public String modify() { return "@PutMapping 注解，通常更新数据时使用"; } @DeleteMapping(value = "/remove") public String remove() { return "@DeleteMapping 注解，通常删除数据时使用"; } }

1.2.8 @ResponseBody

不加这个注解可以返回一个自定义html页面
加这个注解返回return后面的东西。

1.2 Spring Boot四大核心：

自动配置
起步依赖
Actuator
命令行界面

1.3 核心配置文件

在SpringBoot中 核心配置文件一般只有一个。 如果这两种核心配置文件同时存在，那项目会 优先读取application.properties 中的配置文件。
application.properties
- 设置内嵌tomcat内嵌端口号：
  - server.port=9090
- 设置上下文根
  - server.servlet.context-path=/txzmy
- 修改前
- 修改后：
application.yml(.yaml)
- 设置内嵌tomcat端口号和上下文根：
- 在使用这种方式时，先删除application.properties,后新建一个file，核心文件的命名必须以application开头。这种方式类似与python的缩进。
- server: port: 9090 servlet: context-path: /txzmy

1.4 多环境下配置核心文件

工作中的四种环境：开发环境，测试环境，准生产环境，生产环境。在不同的环境下同一个网页的访问网址不同，核心文件配置不同。
添加其他环境下的核心配置文件必须以application-开头。
- #主核心配置文件 #激活使用的配置文件 #等号后面只需要跟已定的核心配置文件的名称 spring.profiles.active=dev
三种不同文件类型的核心配置文件写法相似。

1.5 自定义配置

1.5.1 获取自定义配置：

我们可以在核心配置文件或者其他文件里设置一些值，通过注解 @value 可以访问到这些值。
- #主核心配置文件 #激活使用的配置文件 spring.profiles.active=dev #设置自定义的值 schoolName=CTGU stuName=tx #方法类 package com.txzmy.springboot; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.RestController; @Controller public class Index { @Value("${schoolName}") public String schoolName; @Value("${stuName}") public String stuName; @RequestMapping(value = "/hello") public @ResponseBody String hello() { return "hello,"+stuName+" from "+schoolName; } }
- 通过域名http://localhost:7070/dev/hello访问结果：hello,tx from CTGU

1.5.2 将自定义配置映射到对象

在用@Value时我们只能一个一个的取值，我们可以通过 @Component和@ConfigurationProperties 将文件中的值映射到对象中。 配置对象必须有统一的前缀。 直接上代码：
- #主核心配置文件 #激活使用的配置文件 spring.profiles.active=dev #设置自定义的值 school.Name=CTGU school.stuName=tx //被映射的类 #package com.txzmy.springboot; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; //将拿到的值交给spring容器管理 @Component //@ConfigurationProperties必须有个前缀，即上面设置的自定义值的前缀，后面可以不带这个前缀。 @ConfigurationProperties(prefix = "school") public class school { private String Name; private String stuName; public String getName() { return Name; } public void setName(String name) { Name = name; } public String getStuName() { return stuName; } public void setStuName(String stuName) { this.stuName = stuName; } } //方法类 package com.txzmy.springboot; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestBody; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.RestController; @Controller public class Index { @Autowired public school school; @RequestMapping(value = "/hello") public @ResponseBody String hello() { return "hello,"+school.getStuName()+" from "+school.getName(); } }
- 运行结果：hello,tx from CTGU

1.6 SpringBoot集成JSP

1.6.1 创建存放JSP文件的文件夹：

在项目main文件夹下新建一个文件夹->在file菜单栏中选择Project Structure->选择Modules->在旁边的项目文件了选中刚刚创建的文件夹（用来存放JSP文件的文件夹）->点击右边中间的+号，再次选中刚刚创建的文件夹，最后apply再ok就完成了。

1.6.2 添加SpringBoot内嵌的Tomcat对JSp的解析依赖：

<dependency> <groupId>org.apache.tomcat.embed</groupId> <artifactId>tomcat-embed-jsper</artifactId> </dependency>

1.6.3 指定JSP编译的路径及文件夹项目：

<build>  <resources> <resource>  <directory>src/main/webapp</directory>  <targetPath>META-INF/reserous</targetPath>  <includes> <include>*.*</include> </includes> </resource> </resources> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>

1.6.4 在核心配置文件里配置视图解析器：

核心配置文件：application.properties
#配置视图解析器 #配置前缀 spring.mvc.view.prefix=/ #配置后缀 spring.mvc.view.suffix=/jsp@Controller public class Index { @RequestMapping(value = "/hello") public ModelAndView hello() { ModelAndView mv = new ModelAndView(); mv.addObject("message","Hello SpringBoot"); mv.setViewName("hello"); return mv; } }

2 Spring Boot框架Web开发：

2.1 集成Mybatis：

2.1.1 添加起步依赖：

<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency>  <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> </dependency>

2.1.2 关于MySQL的安装参考推荐：

https://www.jb51.net/article/193731.htm

2.1.3 逆向工程：

Mybatis提供的逆向工程可以生成实体bean，映射文件，DAO接口：
需要添加的配置文件：
- 在项目的根目录下添加GeneratorMapper.xml文件，文件具体内容如下：
  - <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"> <generatorConfiguration>  <classPathEntry location="D:/mysql-downloads/mysql-connector-java-5.1.49/mysql-connector-java-5.1.49/mysql-connector-java-5.1.49.jar"/>  <context id="txzmy" targetRuntime="MyBatis3">  <commentGenerator> <property name="suppressAllComments" value="true" /> </commentGenerator>  <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306" userId="root" password="Tx110304.."> </jdbcConnection>  <javaModelGenerator targetPackage="comzmy.model" targetProject="src/main/java"> <property name="enableSubPackages" value="false" /> <property name="trimStrings" value="false" /> </javaModelGenerator>  <sqlMapGenerator targetPackage="comzmy.mapper" targetProject="src/main/java"> <property name="enableSubPackages" value="false" /> </sqlMapGenerator>  <javaClientGenerator type="XMLMAPPER" targetPackage="comzmy.mapper" targetProject="src/main/java"> <property name="enableSubPackages" value="false" /> </javaClientGenerator>  <table tableName="student" domainObjectName="Student" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"/> </context> </generatorConfiguration>
- 在项目文件pom.xml中添加依赖：
  -  <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.0.1</version> </dependency>  <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> </dependencies> <build>  <resources> <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.6</version> <configuration>  <configurationFile>GeneratorMapper.xml</configurationFile> <verbose>true</verbose> <overwrite>true</overwrite> </configuration> </plugin> </plugins>
- 在application.properties文件中配置数据库的相关信息：
  - #配置内嵌 Tomcat 端口号 server.port=9090 #配置项目上下文根 server.servlet.context-path=/txzmy #配置数据库的连接信息 #注意这里的驱动类有变化 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8 spring.datasource.username=root spring.datasource.password=Tx110304..
- 在右侧maven结构中选择Plugins->mybatis-generator->mybatis-generator:generate.双击mybatis-generator:generate.

2.2 Spring Boot实现RESTful

2.2.1 认识RESTful：

REST（英文：Representational State Transfer，简称 REST）一种互联网软件架构设计的风格，但它并不是标准，它只是提出了一组客户端和服务器交互时的架构理念和设计原则，基于这种理念和原则设计的接口可以更简洁，更有层次，REST 这个词，是 Roy Thomas Fielding 在他 2000 年的博士论文中提出的。任何的技术都可以实现这种理念，如果一个架构符合 REST 原则，就称它为 RESTFul 架构。
比如我们要访问一个 http 接口： http://localhost:8080/boot/order?id=1021&status=1 采用 RESTFul 风格则 http 地址为： http://localhost:8080/boot/order/1021/1

2.2.2 Spring Boot开发RESTful：

Spring boot 开发 RESTFul 主要是几个注解实现：
- @PathVariable获取 url 中的数据，该注解是实现 RESTful最主要的一个注解。
- @PostMapping接收和处理 Post 方式的请求。
- @DeleteMapping接收 delete 方式的请求，可以使用 GetMapping 代替。
- @PutMapping接收 put 方式的请求，可以用 PostMapping 代替。
- @GetMapping接收 get 方式的请求。
pom.xml添加内容：
- <dependencies>  <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>  <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.0.1</version> </dependency>  <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> </dependencies> <build>  <resources> <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.6</version> <configuration>  <configurationFile>GeneratorMapper.xml</configurationFile> <verbose>true</verbose> <overwrite>true</overwrite> </configuration> </plugin> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
application.yml 核心配置文件:
- server: port: 8090 #设置 Tomcat 内嵌端口号 servlet: context-path: / #设置上下文根 #配置数据源 spring: datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/springboot?useUnicode=true&characterEncoding=UTF-8&useJDBC CompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8 username: root password: Tx110304..

2.3 SpringBoot集成Redis：

2.3.1 认识Reids：（源于百度百科）

redis是一个key-value 存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list( 链表 )、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了 memcached 这类key/value存储的不足，在部分场合可以对关系数据库起到很好的补充作用。它提供了Java，C/C++，C#，PHP，JavaScript，Perl，Object-C，Python，Ruby，Erlang等客户端，使用很方便。 [1]
Redis支持主从同步。数据可以从主服务器向任意数量的从服务器上同步，从服务器可以是关联其他从服务器的主服务器。这使得Redis可执行单层树复制。存盘可以有意无意的对数据进行写操作。由于完全实现了发布/订阅机制，使得从数据库在任何地方同步树时，可订阅一个频道并接收主服务器完整的消息发布记录。同步对读取操作的可扩展性和数据冗余很有帮助。

2.3.2 添加依赖：

在Pom.xml添加操作redis数据类型的依赖：
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
在SpringBoot核心配置文件中添加Redis的配置（配置连接信息）：
#redis连接信息 spring.redis.host= sring.redis.port= sring.redis.password=

2.3.3 相关类：

RestController类：
@RestController public class RedisController { @Autowired private StudentService studentService; @GetMapping(value = "/springboot/allStudentCount") public Object allStudentCount(HttpServletRequest request) { Long allStudentCount = studentService.queryAllStudentCount(); return "学生总人数：" + allStudentCount; } }
StudentService 接口：
public interface StudentService { /** * 获取学生总人数 * @return */ Long queryAllStudentCount(); }
在 StudentServiceImpl 中注入 RedisTemplate 并修改根据 id 获取学生的方法:
@Service public class StudentServiceImpl implements StudentService { @Autowired private StudentMapper studentMapper; @Autowired private RedisTemplate<Object,Object> redisTemplate; @Override public Long queryAllStudentCount() { //设置 redisTemplate 对象 key 的序列化方式 redisTemplate.setKeySerializer(new StringRedisSerializer()); //从 redis 缓存中获取总人数 Long allStudentCount = (Long) redisTemplate.opsForValue().get("allStudentCount"); //判断是否为空 if (null == allStudentCount) { //去数据库查询，并存放到 redis 缓存中 allStudentCount = studentMapper.selectAllStudentCount(); redisTemplate.opsForValue().set("allStudentCount",allStudentCount,15, TimeUnit.SECONDS); } return allStudentCount; } }
StudentMapper 接口:
public interface StudentMapper { /** * 获取学生总人数 * @return */ Long selectAllStudentCount(); }
StudentMapper 映射文件:
<select id="selectAllStudentCount" resultType="java.lang.Long"> select count(*) from t_student </select>
启动类 Application:
- 在 SpringBoot 启动类上添加扫描数据持久层的注解并指定扫描包:
- @SpringBootApplication @MapperScan(basePackages = "com.txzmy.mapper")//扫描数据持久层 public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }

2.4 集成dubbo：

2.4.1. 准备工作

创建一个Maven空项目，作为项目的父工程，此工程的子项目基于Spring Boot 2.0.5 实现

在父工程的pom.xml引入之后要创建的子工程

<modules>
        <module>gmall-interface</module>
        <module>user-service-provider</module>
        <module>order-service-consumer</module>
    </modules>

可以提前看一下工程结构

下面分别来实现子工程：（子工程的实现方式都是在gmall工程下新建Module）

2.4.2. 公共API

项目中共用的接口和POJO类，代码和之前一样，这里不再展开

2.4.3. 服务提供者

工程结构如下

引入依赖

<!-- 引入公共API,以实现其接口 -->
        <dependency>
            <groupId>com.zang</groupId>
            <artifactId>gmall-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
        <!-- 引入spring-boot-starter以及dubbo和curator的依赖 -->
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
        <!-- Spring Boot相关依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

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

需要注意的是，根据jdk和Spring Boot版本的不同，dubbo-spring-boot-starter的版本需要有根据的选择

dubbo提供了@Service注解，可将类声明为提供方，省去了大量配置的麻烦

import com.alibaba.dubbo.config.annotation.Service;
import com.zang.gmall.bean.UserAddress;
import com.zang.gmall.service.UserService;
import org.springframework.stereotype.Component;

import java.util.Arrays;
import java.util.List;

@Service   //属于Dubbo的@Service注解，非Spring  作用：暴露服务
@Component
public class UserServiceImpl implements UserService {

    @Override
    public List<UserAddress> getUserAddressList(String userId) {
    //省略
}}

通过属性配置的方式设置application.properties

#当前服务/应用的名字
dubbo.application.name=user-service-provider
#注册中心的协议和地址
dubbo.registry.protocol=zookeeper
dubbo.registry.address=127.0.0.1:2181
#通信规则（通信协议和接口）
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
#连接监控中心
dubbo.monitor.protocol=registry
#开启包扫描，可替代 @EnableDubbo 注解
##dubbo.scan.base-packages=com.zang.gmall

springboot容器根据配置启动服务提供方，这里需要添加 @EnableDubbo 注解

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

// 开启基于注解的dubbo功能（主要是包扫描@DubboComponentScan）
// 也可以在配置文件中使用dubbo.scan.base-package来替代   @EnableDubbo
@EnableDubbo

@SpringBootApplication
public class UserServiceProviderApplication {

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

提供方顺利启动

2.4.4. 服务消费者

消费者工程在初始化时设置为web项目，结构如下

引入和服务提供方同样的依赖，除此之外，添加springboot web模块的依赖。

<!-- springboot web模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

dubbo提供了@Reference注解，可替换@Autowired注解，用于引入远程服务

import com.alibaba.dubbo.config.annotation.Reference;
import com.zang.gmall.bean.UserAddress;
import com.zang.gmall.service.OrderService;
import com.zang.gmall.service.UserService;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class OrderServiceImpl implements OrderService {

    @Reference
    UserService userService;

    @Override
    public List<UserAddress> initOrder(String userId) {
　　//代码省略
   }}

配置文件application.properties

#避免和监控中心端口冲突，设为8081端口访问
server.port=8081  

dubbo.application.name=order-service-consumer
dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.monitor.protocol=registry

启动类同样加上@EnableDubbo注解

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

@EnableDubbo
@SpringBootApplication
public class OrderServiceConsumerApplication {

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

为查看调用是否成功，新增控制层用于访问

import com.zang.gmall.bean.UserAddress;
import com.zang.gmall.service.OrderService;
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.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.List;

@Controller
public class OrderController {

    @Autowired
    OrderService orderService;

    @ResponseBody   //以json格式返回
    @RequestMapping("/initOrder")
    public List<UserAddress> initOrder(@RequestParam("uid") String userId){

       return orderService.initOrder(userId);
    }

}

2.4.5. 测试调用

启动消费方，在浏览器访问

调用成功

附：springboot也允许引用xml文件配置，方法是在启动类中加入如下注解

//@EnableDubbo
//引入配置信息
@ImportResource(locations="classpath:provider.xml")
@SpringBootApplication
public class UserServiceProviderApplication {
//略
}

3 Spring Boot下的非Web程序：

3.1 创建一个非Web程序：

3.1.1 方式一：

直接在 main 方法中，根据 SpringApplication.run()方法获取返回的 Spring 容器对象，再获取业务 bean 进行调用：
- //Application.java文件 package com.txzmy; import com.txzmy.TestInterface1.UserService; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.ConfigurableApplicationContext; @SpringBootApplication public class Application { public static void main(String[] args) { /** * SpringBoot 程序启动后，返回值是 ConfigurableApplicationContext，它也是一个 Spring 容器对象 * 它其它相当于原来 Spring 中启动容器 ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(""); */ //获取 SpringBoot 程序启动后的 Spring 容器 ConfigurableApplicationContext context = SpringApplication.run(Application.class, args); //从 Spring 容器中获取指定 bean 的对象 UserService userService = (UserService) context.getBean("userServiceImpl"); //调用业务 bean 的方法 String sayHello = userService.SayHello(); System.out.println(sayHello); } } //UserService接口 package com.txzmy.TestInterface1; public interface UserService { String SayHello(); } //UserServiceImpl接口实现类 package com.txzmy.TestAchieve; import com.txzmy.TestInterface1.UserService; import org.springframework.stereotype.Service; @Service public class UserServiceImpl implements UserService { @Override public String SayHello() { return "Hello"; } }
- 运行结果：
- 注意：在getBean方法中，如果接口实现类的名称首字母是大写，则 在getBean方法的参数中首字母必须换为小写。 解决“No bean named 'UserServiceImpl' available”报错。

3.1.2 方式二：

Spring boot 的入口类实现 CommandLineRunner 接口。
- //Application.java文件 package com.txzmy; //import javafx.application.Application; import com.txzmy.TestInterface1.UserService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.CommandLineRunner; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.context.ConfigurableApplicationContext; @SpringBootApplication public class Application implements CommandLineRunner { @Autowired private UserService userService; @Override // 重写CommandLineRunner中的run方法 public void run(String... args) throws Exception { System.out.println(userService.SayHello()); } public static void main(String[] args) { SpringApplication.run(Application.class); } } //接口类和接口实现类和上面相同
- 运行结果：

3.2 关闭，修改SpringBoot启动logo：

3.2.1 关闭Logo：

@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication springApplication = new SpringApplication(Application.class); //关闭启动 logo 的输出 springApplication.setBannerMode(Banner.Mode.OFF); springApplication.run(args); } }

3.2.2 修改logo:

在 src/main/resources 放入 banner.txt 文件，该文件名字不能随意，文件中的内容就是要输出的 logo ；
可以利用网站生成图标： https://www.bootschool.net/ascii 或者 http://patorjk.com/software/taag/，将生成好的图标文字粘贴到 banner.txt 文件中，然后将关闭 logo 输出的语句注释，启动看效果。

4 Spring Boot 使用拦截器：

4.1 使用拦截器的步骤：

定义一个拦截器，实现HandlerInterceptor接口。
- package com.txzmy.interceptor; import com.txzmy.model.User; import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.servlet.ModelAndView; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; public class UserInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { System.out.println("进入拦截器-----------------"); //编写业务中拦截的规则 //从session中获取用户的信息 User user = (User)request.getSession().getAttribute("user"); //判断用户是否登录 if(null==user) { response.sendRedirect(request.getContextPath()+"/user/error"); return false; } return true; } @Override public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception { } @Override public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception { } }
创建一个配置类(即:在SpringMvc配置文件中使用MVC：拦截器标签)。
- package com.txzmy.config; import com.txzmy.interceptor.UserInterceptor; import org.springframework.context.annotation.Configuration; import org.springframework.web.servlet.config.annotation.InterceptorRegistry; import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; @Configuration //定义此类为配置文件（即相当于之前的xml配置文件） public class InterceptorConfig implements WebMvcConfigurer { @Override //拦截器注册类，需要我们把自己定义的拦截器注册进去 public void addInterceptors(InterceptorRegistry registry) { //定义需要拦截的和不需要拦截的String容器 //要拦截user下面的所有的访问请求，必须用户登录后才可以访问 String[] addPathPatterns={ "/user/**" }; //要排除的路径，排除的路径说明用户不需要登陆也可以访问 String[] excludePathPatterns={ "/user/out","/user/error","/user/login" }; registry.addInterceptor(new UserInterceptor()).addPathPatterns(addPathPatterns).excludePathPatterns(excludePathPatterns); } }
请求页面类：
- package com.txzmy.web; import com.txzmy.model.User; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; import javax.servlet.http.HttpServletRequest; @Controller @RequestMapping("/user") public class UserController { @RequestMapping(value = "/login") public @ResponseBody Object login(HttpServletRequest request) { //将用户信息放到session中 User user=new User(); user.setId(1001); user.setName("张满月"); request.getSession().setAttribute("user",user); return "login success"; } //该请求需要用户登录后才可以访问 @RequestMapping(value = "/center") public @ResponseBody Object center() { return "Center Message"; } //该请求不需要用户可以访问 @RequestMapping(value = "/out") public @ResponseBody Object out() { return "out Message"; } //如果用户未登录访问了需要登陆才可以访问的数据，会跳转至该请求 @RequestMapping(value = "/error") public @ResponseBody Object error() { return "error"; } }
用户类：
- package com.txzmy.model; public class User { private int id; private String name; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } }

5 Spring Boot中使用Servlet：

5.1 Servlet：

5.1.1 认识Servlet：

Java Servlet 是运行在 Web 服务器或应用服务器上的程序，它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中间层。使用 Servlet，您可以收集来自网页表单的用户输入，呈现来自数据库或者其他源的记录，还可以动态创建网页.

5.1.2 Servlet 任务：

读取客户端（浏览器）发送的显式的数据。这包括网页上的 HTML 表单，或者也可以是来自 applet 或自定义的 HTTP 客户端程序的表单。
读取客户端（浏览器）发送的隐式的 HTTP 请求数据。这包括 cookies、媒体类型和浏览器能理解的压缩格式等等。
处理数据并生成结果。这个过程可能需要访问数据库，执行 RMI 或 CORBA 调用，调用 Web 服务，或者直接计算得出对应的响应。
发送显式的数据（即文档）到客户端（浏览器）。该文档的格式可以是多种多样的，包括文本文件（HTML 或 XML）、二进制文件（GIF 图像）、Excel 等。
发送隐式的 HTTP 响应到客户端（浏览器）。这包括告诉浏览器或其他客户端被返回的文档类型（例如 HTML），设置 cookies 和缓存参数，以及其他类似的任务。

5.2 两种使用Servlet的方式：

5.2.1 方式一通过注解方式实现：

MyServlet.java
- package com.example.demo.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 request, HttpServletResponse response) throws ServletException, IOException { response.getWriter().print("My SpringBoot Servlet"); response.getWriter().flush(); response.getWriter().close(); } @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } }
Application.java
- package com.example.demo; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.web.servlet.ServletComponentScan; @SpringBootApplication //开启Spring配置 @ServletComponentScan(basePackages = "com.example.demo.Servlet") //指定要扫描的Servlet public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }

5.2.2 方式二通过 SpringBoot 的配置类实现（组件注册）

ServletConfiguration.java
- package com.example.demo.Servlet; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class ServletConfiguration { //@Bean 是一个方法级别上的注解，主要用在配置类里 /* * 相当于一个<beans> * <bean id="" class=""/> * </beans> * */ @Bean public ServletRegistrationBean servletRegistrationBean() { //将自定义 servlet 注册到注册 Servlet 类中，并指定访问路径 ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new MyServlet(), "/MyServlet"); return servletRegistrationBean; } }
MyServlet.java
- package com.example.demo.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; public class MyServlet extends HttpServlet { @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.getWriter().print("My SpringBoot Servlet2222"); response.getWriter().flush(); response.getWriter().close(); } @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { doGet(request, response); } }
application.java不变

6 Spring Boot中使用过滤器Filter

6.1 过滤器的作用：

Filter 过滤器它是 JavaWeb 的三大组件之一。三大组件分别是：Servlet 程序、Listener 监听器、Filter 过滤器
Filter 过滤器它是 JavaEE 的规范。也就是接口
Filter 过滤器它的作用是：拦截请求，过滤响应。

6.2 创建Filter的两种方法：

6.2.1 方式一通过注解方式实现:

MyFilter.java
- @WebFilter(urlPatterns = "/springboot/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); } }
Application文件
- import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; import org.springframework.boot.web.servlet.ServletComponentScan; @ServletComponentScan(basePackages = "com.demo.filter") @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); }
结果：通过 .../springboot/myFilter...的访问路径全部无法访问。

6.2.2 方式二通过 Spring Boot 的配置类实现：

FilterConfiguration.java
- package com.example.demo.Filter; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import javax.servlet.FilterRegistration; @Configuration public class FilterConfiguration { @Bean public FilterRegistrationBean myFilterRegistration (){ //注册过滤器 FilterRegistrationBean filterRegistrationBean =new FilterRegistrationBean(new MyFilter()); //添加过滤路径 filterRegistrationBean.addUrlPatterns("/User/*"); return filterRegistrationBean; } }
MyFilter.java
- package com.example.demo.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("get access to filter"); filterChain.doFilter(servletRequest,servletResponse); } }
userController.java
- package com.example.demo.Filter; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.ResponseBody; @Controller public class userController { @RequestMapping(value = "/User/one") public @ResponseBody String one() { return "one"; } @RequestMapping(value = "/two") public @ResponseBody String two() { return "two"; } }

7 Spring Boot 项目配置字符编码：

7.1 目的：

解决网页中的中文乱码问题，不需要用户手动更改浏览器的encoding。

7.2 两种配置字符编码的方式：

7.2.1 方式一：使用传统的 Spring 提供的字符编码过滤器

MyServlet.java
- package com.example.demo.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 doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req,resp); } @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { resp.getWriter().println("张满月：Hello,demo"); //设置浏览器编码格式 resp.setContentType("text/html;character=utf-8"); resp.getWriter().flush(); resp.getWriter().close(); } }
配置类：
- package com.example.demo.Servlet; import org.springframework.boot.web.servlet.FilterRegistrationBean; import org.springframework.boot.web.servlet.ServletRegistrationBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.web.filter.CharacterEncodingFilter; @Configuration //定义此类为配置类 public class SystemConfiguration { @Bean public ServletRegistrationBean servletRegistrationBean() { ServletRegistrationBean servletRegistrationBean=new ServletRegistrationBean(new MyServlet(),"/Servlet/MyServlet"); return servletRegistrationBean; } @Bean public FilterRegistrationBean filterRegistrationBean() { //设置字符编码过滤器 //CharacterEncoding 是由 Spring 提供的一个字符编码过滤器，之前是配置在web.xml 文件中 CharacterEncodingFilter characterEncodingFilter = new CharacterEncodingFilter(); //强制使用指定字符编码 characterEncodingFilter.setForceEncoding(true); //设置指定字符编码 characterEncodingFilter.setEncoding("utf-8"); //创建过滤器注册 bean FilterRegistrationBean filterRegistrationBean=new FilterRegistrationBean(); //设置字符编码过滤器 filterRegistrationBean.setFilter(characterEncodingFilter); //设置字符编码过滤器路径 filterRegistrationBean.addUrlPatterns("/*"); return filterRegistrationBean; } }
application.properties
- #关闭 springboot 的 http 字符编码支持 #只有关闭该选项后，spring 字符编码过滤器才生效 server.servlet.encoding.enabled=false
不设置解码方式中文可能会乱码。

7.2.2 方式二：在 application.properties 中配置字符编码（推荐）

核心配置文件application.properties：
- #设置请求响应的字符编码 spring.http.encoding.enabled=true spring.http.encoding.force=true spring.http.encoding.charset=UTF-8
MyServlet.java
- package com.example.demo.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("/ServletDemo") public class MyServlet extends HttpServlet { @Override protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { doGet(req,resp); } @Override protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { resp.getWriter().println("张满月：Hello,demo"); //设置浏览器编码格式 resp.setContentType("text/html;character=utf-8"); resp.getWriter().flush(); resp.getWriter().close(); } }
在主类中定义扫描路径：
- @SpringBootApplication @ServletComponentScan(basePackages = "com.example.demo.Servlet") public class DemoApplication { public static void main(String[] args) { SpringApplication.run(DemoApplication.class, args); } }
未设置前：
- 网页显示结果：????Hello,demo
设置后：
- 网页显示结果：张满月：Hello,demo

Java架构狮

关注

1
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
万字详解，Spring Boot快速上手指南

Spring Boot1 Spring Boot入门1.1 Spring Boot特性：能够快速创建基于 Spring 的应用程序能够直接使用 java main 方法启动内嵌的 Tomcat 服务器运行 Spring Boot 程序，不需要部署 war 包文件提供约定的 starter POM 来简化 Maven 配置，让 Maven 的配置变得简单自动化配置，根据项目的 Maven 依赖配置，Spring boot 自动配置 Spring、Spring mvc 等提供了程序
复制链接

扫一扫