Java开发技术 Java面试题库 Java架构设计 大数据资讯 大数据技术 大数据应用 HTML HTML5 CSS JavaScript jQuery Vue AngularJS MySQL Oracle SQLServer MongoDB Redis Spring Boot教程 Spring MVC教程 Maven教程 Spring Cloud教程 MySQL教程 Redis教程 Java设计模式 Spring教程 NoSQL教程 大数据教程 JavaScript教程 MongoDB教程 HBase教程

Java快速开发架构Spring Boot 从入门到精通 附源码

发布时间:2020-01-09 14:44:45  作者:本站编辑  来源:本站原创  浏览次数:

摘要:这篇Java开发技术栏目下的“快速开发架构Spring Boot 从入门到精通 附源码”,介绍的技术点是“Spring Boot、Spring、开发架构、从入门到精通、附源码、Java”,希望对大家开发技术学习和问题解决有帮助。导读 篇幅较长,干货十足,阅读需花费点时间。珍惜原创,转载请注明出处,谢谢! Spring Boot基础 Spring Boot简介 Spring Boot是由Pivotal团队提供的全新框架,其设计

导读

  篇幅较长,干货十足,阅读需花费点时间。珍惜原创,转载请注明出处,谢谢!

       本文转载自https://www.cnblogs.com/chenyanbin/p/12132757.html

Spring Boot基础

Spring Boot简介

  Spring Boot由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。通过这种方式,Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

  简单来说,SpringBoot可以简化应用程序的开发,使我们再需要spring配置文件及web.xml

SpringBoot工程和创建

IDEA中的创建

工程编辑

  系统会在前面设置的包中自动生成一个启动类

  在启动类所在的包下创建一个子包,在其中编写SpringMvc的处理器类。

  注意,要求代码所在的包必须启动类所在的包的子孙宝不能是同级包。 

启动

ide方式

mac控制台方式(需maven打包)

官网创建

地址:https://start.spring.io/

配置及生成

  配置项配置完成后,点击Generate按钮后,即可打开一个下载对话框。官网将配置好的Spring Boot工程生成一个zip压缩文件,只要我们将下载后的文件解压并添加到工程即可使用

基于war的Spring Boot工程

  前面2种方式创建的Spring Boot工程最终被打为了jar包,是以可执行文件的形式出现的,他们都使用了Spring Boot内嵌的Tomcat作为web服务器来运行web应用的。新版的Dubbo的监控中心工程就是典型的应用。但在实际生产环境下,对于web工程,很多时候我们需要的是war包,然后部署到企业级web服务器中。下面来演示如何使用Spring Boot将工程打为war包。

工程创建

我们看一下pom.xml文件,可以知道,Tomcat打包的时候不打进去

将项目打包后,仍到Tomcat的wabapps目录下

启动Tomcat

接下来我们查看Tomcat目录

打开网页,注意加上项目名

注:mac启动Tomcat过程中遇到点麻烦,1、需要赋予文件夹权限;2、执行shell脚本报错:Operation not permitted,博主参考了下面2个链接配成成功哒

大概配置步骤

1、切换Tomcat的bin目录下
    sudo chmod 755 *.sh2、解决Operation not permitted
    xattr -d com.apple.quarantine .
参考链接: 注:第一、二链接,赋权限,第三个链接解决Operation not permittedhttps://blog.csdn.net/caoxiaohong1005/article/details/53463443 https://blog.csdn.net/F_Feng0628/article/details/60583250 https://blog.csdn.net/default7/article/details/80172340

工程解析

   创建Spring Boot工程后,会自动生成工程的启动类Application

   跟踪@SpringBootApplication注解源码可以看到,可以完成Spring Boot的自动配置

   继续跟踪@SpringBootConfiguration源码可以看到,其本质是一个@Configuration,使用Java类充当Spring配置文件

 src/main/resources目录

  1. static:存放静态资源,如:css,js,images等 

  2. templates目录:存放动态资源。Spring Boot不建议使用jsp作为动态数据展示页面,而是建议使用ThymeleafThymeleaf是一种Java模板引擎,可以显示动态数据。Thymeleaf文件的扩展名为html,是对html的扩展。该目录用于存放Thymeleaf文件。

  3. 两个目录中存放的资源相当于存放当前web应用的根下。一般不适用他们存放资源。

  4. application.properties:SpringBoot的主配置文件

查看当前工程

  在pom.xml文件中包含SpringBoot两个核心依赖一个核心插件一个是SpringBoot的Web启动依赖一个是SpringBoot的测试启动依赖;而这个核心插件是用于完成对SpringBoot工程打包结果的再打包

  注:他们都没有版本号,这是为什么呢?

   虽然他们都没有版本号,打开maven可以看到,他们版本均为2.2.2

   他们的版本号均继承自父工程。从pom文件中可以看到,其父工程spring-boot-starter-parent

更换默认springframework的版本(视生产环境降默认版本)

查看spring-boot-starter-parent工程

  打开Maven本地仓库,在org.springframework中找到工程spring-boot-starter-parent。

打开spring-boot-starter-parent-2.2.2.RELEASE.pom文件,发现该工程的<pluginManagement>中有对该插件的配置信息。

注:<pluginManagement>中声明的插件是选择性继承插件,而非全部继承插件。

    从该插件的配置信息可以得出,其执行的目标是repackage,即对工程进行重新打包。

  首次打包是由Maven的package插件完成,其打包的结果仅仅是将当前工程中自定义的类打包成了一个普通的jar包,没有Spring Boot的相关资源,无法直接运行。当然,其打包的结果是.jar文件。

  重新打包是由spring-boot-maven-plugin插件完成的,其实将前面打成的jar包进行了二次打包,将原来的软件包变为了Spring Boot可执行包,在其中不仅添加了Spring Boot依赖,还添加了很多其他配置。同时,其还将原来的.jar文件扩展名变为了.orininal,而而二次打包后的文件扩展名成为了.jar。

  可以打开01-primary-0.0.1-SNAPSHOT.jar

BOOT-INF目录:存的是当前应用程序的类及其所依赖的类

META-INF目录:存的是Maven相关的配置文件

org目录:存的是SpringBoot启动所需的类

  打开META-INF/MANIFEST.MF,不仅可以看到主类Main-Class,还可以看到当前工程的启动类Start-Class。

maven打包

Spring Boot热部署

  idea中的Spring Boot工程若要使用热部署,需要2不操作:

  1. 导入devtools依赖

  2. 编辑工程的配置信息

  注:Spring Boot工程在idea和Eclipse中的重启时机不同。Eclipse只要修改的文件保存过了,工程会立马重新部署。而idea则对文件修改后的保存是自动的,所以其重新部署的时机是idea整个ide窗口被钝化时,即窗口切换到其他窗口时,工程会重新部署。

添加依赖

pom.xml

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

配置

  当idea被钝化时,即当idea窗口被切换时,更新类与资源。

  在开发调试过程中,已经启动了工程的运行。此时又修改了代码或配置文件,若要使修改生效,则需要重新启动工程。这种方式降低了开发效率。

  热部署,即修改了代码或配置文件后,一旦保存,系统马上对工程进行自动重启,无需手工重启。若要实现热部署,只需要在pom.xml中添加一个依赖即可。

  热部署的使用有利有弊。利:无需手动重启工程;弊:在修改代码或配置后,只要保存系统就会重启工程,即使这个修改还未完毕,其他的会重启,从而导致代码重启后报错。

1、添加依赖

pom.xml

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

2、设置自动生成项目

3、Ctrl+Shift+A,打开搜索框,输入:Registry

4、勾选即可 

Spring Boot主配置文件

配置文件形式一

  Spring Boot的主配置文件是src/main/resources中默认创建的application.properties文件。

 

  编辑配置文件

  启动

注意事项

   注:这里指定的Tomcat端口号,仅仅只针对内置Tomcat的,是测试时使用的。将工程打为war包后部署到真正的Tomcat,这些配置是不起作用的。

配置文件形式二

  Spring Boot的主配置文件也可以使用application.yml文件。.yml也可以写成.yaml

  在开发之初YAML的本意是Yet Another Markup Language(仍是一种标记语言)。后来为了强调这种语言是以数据为中心,而不是以标记为中心,所以将标记为中心,所以将YAML解释为Yaml Ain't Markup Language(Yaml不是一种标记语言)。它是一种直观的能够被电脑识别的数据序列化格式,是一个可读性高并且容易被人阅读,容易和脚本语言交互,用来表达多级资源序列的编程语言。

  yml与properties文件的主要区别是对于多级属性,即key的显示方式不同。yml文件在输入时,只需按照点(.)的方式输出key既可,输入完毕后回车即出现了如下形式。该形式要求冒号后与值之间有一个空格(语法格式)。

 注意事项

  注:application.properties与application.yml这两个文件只能有一个。要求文件名必须是:application。

Actuator

  Actuator是Spring Boot提供的对应用系统的自省和监控的集成功能,可以对应用系统进行配置查看、相关功能统计等。在Spring Colud中主要是完成微服务的监控,完成监控治理。可以查看微服务间的数据处理和调用,当它们之间出现异常,就可以快速定位到出现问题的地方

  其功能与Dubbo的监控中心类似,不同的是,Dubbo的监控中心是需要专门部署的,而Spring Boot的Actuator是存在于每个工程中。

环境搭建

  随便一个Spring Boot工程中都可以使用Actuator对其进行监控。

添加依赖

pom.xml

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

修改配置文件

application.properties

# 当前应用的端口与上下文路径
server.port=8888server.servlet.context-path=/cyb

# Actuator监控的端口号与上下文路径
management.server.port=9999management.server.servlet.context-path=/cyb2

# 指定监控终端的基本路径,默认为actuator
management.endpoints.web.base-path=/base

启动项目并测试

添加Info信息

修改配置文件

  在配置文件中添加如下Info信息,则可以通过Info控制终端查看到。

测试

注:博主浏览器安装了JSON格式化工具,所以显示的是JSON格式化后的状态

开发其他监控终端

  默认情况下,Actuator仅开放了health与Info两个监控终端,但它还有很多终端可以监控,需手动开放。

修改配置文件

mappings终端

  mappings可以看到当前工程中所有的URI与处理器映射关系,及详细的处理器方法以及其映射规则。很实用!!!

beans终端

evn终端

  可以到当前应用程序运行主机的所有软硬件环境信息

单独关闭某些监控终端

  在开放了所有监控终端的情况下,有些终端显示的信息并不想公开,此时可以单独关闭这些终端。

修改配置文件

测试

  其他的监控终端不受影响。

其他常用的监控终端如下

  若没有你需要的,可以自行百度搜&ldquo;springboot actuator&rdquo;

Spring Boot重要用法

自定义异常页面

  对于404、405、500等异常页面,而这些异常页面一般都是英文的,非常不友好。我们可以通过简单方式使用自定义异常页面,并将默认状态码页面进行替换

定义目录

  在src/main/resources目录下新建目录:public/error。

定义异常页面

  在error目录定义异常页面。这些异常页面的名称必须为相应的状态码,扩展名为html。

单元测试

添加依赖

pom.xml

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

接口类

ISomeService.java

package com.cyb.webdemo.controller;public interface ISomeService {    void doSome();
}

接口实现类

SomeServiceImpl.java

package com.cyb.webdemo.controller;import org.springframework.stereotype.Service;

@Servicepublic class SomeServiceImpl implements ISomeService{
    @Override    public void doSome() {
        System.out.println("执行Service的doSome");
    }
}

测试类

  类上需添加两个注解:

    1、@RunWith(SpringRunner.class)

    2、@SpringBootTest(classes = Spring Boot启动类.class)

多环境选择

什么是多环境选择?

  在开发应用时,通常同一套程序运行多个环境,例如,开发、测试、生产环境等。每个环境的数据库地址、服务器端口号等配置都会不同。若在不同环境下运行时将配置文件修改为不同内容。那么,这种做法不仅非常繁琐,而且很容易发生错误

  在开发应用时,有时不同的环境,其需要运行的接口的实现类也是不同的。例如,若要开发一个具有短信发送功能的应用,开发环境中要执行的send()方法仅需要调用短信模拟器即可,而生产环境中要执行的send()则需要调用短信运营商所提供的短信发送接口。这种情况下,就需要开发两个相关接口的实现类去实现send()方法。

  不同的环境,需使用不同的配置文件执行不同的类。而这个选择只需要Spring Boot的主配置文件中指定即可

  下面以不同环境&ldquo;使用配置有不同的端口号的配置文件,以及调用不同的接口实现类&rdquo;为例演示多环境选择问题的解决。

Example

1、创建几个配置文件,格式:application-xxxxx.properties

2、创建一个包,并创建一个接口,内容如下

2、创建DevMsgServiceImpl开发环境类

注:@Profile("xxx")中的值要和application-xxx.properties对应上

3、创建ProMsgServiceImpl生产环境

注:@Profile("xxx")中的值要和application-xxx.properties对应上

4、创建处理器:MsgController

5、测试

正确请求

错误请求

说明

  在Spring Boot中多环境配置文件名需满足application-[profile].properties格式,其中[profile]为对应的环境标识,例如

  1. application-dev.properties:开发环境

  2. application-pro.properties:生产环境

  至于那个配置文件会被加载取决于application.properties中的spring.profiles.active属性来设置,其值对应[profile]。例如spring.profiles.active=dev就会加载application-dev.properties配置文件内容

  在实现类上加@Profile注解,并在注解参数中指定前述配置文件中的[profile]值用于指定该实现类所使用的环境

  以上开发过程中碰到的问题都解决啦~~~~

6、在命令行下选择环境

  将工程打为Jar包后,在命令行运行。若要想切换运行环境,必须要修改主配置文件吗?答案是否定的。只需添加一个命令参数即可动态指定。

  例如,现在的主配置文件中指定的是dev环境

   将当前工程打为Jar包后,在命令行运行时添加如下参数

  此时执行的就是生产环境,调用的就是ProduceServiceImpl类

读取自定义配置

  自定义配置,可以是定义在主配置文件:application.properties中的自定义属性,也可以是自定义配置文件中的属性。

读取主配置文件中的属性

application.properties

SomeController.java

实现

读取指定配置文件中的属性

创建配置文件:cybApplication.properties

SomeController.java 

实现 

读取对象属性

cybApplication.properties

实体类:cyb.java

说明

  1. @PropertySource:用于指定要读取的配置文件。

  2. @ConfigurationProperties:用于指定要读取配置文件中的对象属性。

  3. @Component:当前从配置文件读取来的对象,由Spring容器创建。

SomeController.java

实现

读取List属性1

cybApplication.properties

实体类:UserName

SomeController.java

实现

读取List属性2

cybApplication.properties

Group.java

students.java

SomeController.java

实现

补充知识(lombok)

  lombok方式配置实体类。没用过的小伙伴,可以参考Lombok介绍、使用方法和总结进行脑补,这里只演示使用

1、idea安装lombok

2、添加依赖

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

3、实体类上加@Data即可

package com.cyb.webdemo.controller;import lombok.Data;

@Datapublic class studens {    private String name;    private int age;//    public String getName() {//        return name;//    }////    public void setName(String name) {//        this.name = name;//    }////    public int getAge() {//        return age;//    }////    public void setAge(int age) {//        this.age = age;//    }}

注:lombok省去了get/set,让代码更简洁。

Spring Boot下使用JSP页面

添加JSP解析依赖

pom.xml

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

创建webapp目录

  在src/main下建webapp目录,用于存放jsp文件。创建的是一个普通目录指定为web资源目录,然后才可以创建jsp文件。File->Project Structure

添加JSP注册资源目录

pom.xml

    <build>
        <resources>
            <!--注册dao包下mybatis映射文件为资源目录-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <!--注册webapp目录为资源目录-->
            <resource>
                <directory>src/main/webapp</directory>
                <targetPath>META-INF/resources</targetPath>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
    </build>

创建JSP页面

实现

 

创建welcome.jsp

创建home.jsp

SomeController.java

实现

关于静态资源请求

  Spring Boot已经处理好了静态资源访问问题。

视图前/后缀

Spring Boot中使用MyBatis

添加依赖项

MyBatis与Spring Boot整合依赖

pom.xml

        <!--Mybatis与Spring Boot整合依赖,必须要版本号-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

MySql驱动依赖

pom.xml

        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

Druid连接池依赖

pom.xml

        <!--Druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

lombok依赖(可忽略,用于实体类)

pom.xml

        <!--lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

  注:若使用lombok需配置ide。

注册资源目录文件

pom.xml

    <build>
        <resources>
            <!--注册dao包下mybatis映射文件为资源目录-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <!--注册webapp目录为资源目录-->
            <resource>
                <directory>src/main/webapp</directory>
                <targetPath>META-INF/resources</targetPath>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
    </build>

  注:若不注册dao包下的mybatis映射文件,需将xxx.xml文件放到:/resource,并且修改application.properties文件中的mybatis.mapper-locations映射路径!!!!!!!

资源文件

application.properties

# 视图的前缀和后缀
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

# 注册映射文件
mybatis.mapper-locations=classpath:com/cyb/webdemo/dao/EmployeeDao.xml
# 注册实体类别名
mybatis.type-aliases-package=com.cyb.webdemo.bean.EmployeePo
# 注册数据源类型
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
# 数据库连接字符串
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/cyb
spring.datasource.username=root
spring.datasource.password=root

创建jsp

index.jsp

实体类(Po)

EmployeePo.java

注意

  案例中使用了lombok依赖(idea中需要配置,可以参考前面讲解lombok配置环境方法),所以实体类中可以不设置get/set方法

dao层(数据访问层)

EmployeeDao.java

EmployeeDao.xml

  注:mybatis映射文件的存放位置!!!!!

代码拷贝区

package com.cyb.webdemo.dao;import com.cyb.webdemo.bean.EmployeePo;import org.apache.ibatis.annotations.Mapper;

@Mapperpublic interface EmployeeDao {    void insertEmployee(EmployeePo employeePo);
}
<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE mapper
                PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
                "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.cyb.webdemo.dao.EmployeeDao"><insert id="insertEmployee">
    insert into employee (name,age) values (#{name},#{age})</insert></mapper>

service层(业务层)

EmployeeService.java(接口)

EmployeeServiceImpl.java(接口实现类)

代码拷贝区

package com.cyb.webdemo.service;import com.cyb.webdemo.bean.EmployeePo;public interface EmployeeService {    void addEmployee(EmployeePo employee);
}
package com.cyb.webdemo.service;import com.cyb.webdemo.bean.EmployeePo;import com.cyb.webdemo.dao.EmployeeDao;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;

@Servicepublic class EmployeeServiceImpl implements EmployeeService{

    @Autowired(required = false)    private EmployeeDao dao;
    @Override    public void addEmployee(EmployeePo employee) {
        dao.insertEmployee(employee);
    }
}

数据库表结构

实现

项目源码

直接下载

Spring Boot事务支持

步骤

  1. 启动类上添加@EnableTransactionManagement
    注解,开启事务

  2. Service实现类方法上加@Transactional
    注解

启动类

 业务层接口实现类

Spring Boot对日志的控制 

logback日志技术

  Spring Boot中使用日志技术为logback。其与Log4J都出自一人性能优于Log4J,是Log4J的替代者

  在Spring Boot中若要使用logback,则需要具有spring-boot-starter-logging依赖,而该依赖被spring-boot-starter-web依赖,即不用直接导入spring-boot-starter-logging依赖(间接依赖)。

方式一

xml方式

  必须放到src/main/resources类路径下!!!

代码拷贝区

<?xml version="1.0" encoding="utf-8" ?><configuration>
    <appender name="myConsole" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%-5level - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="WARN">
        <appender-ref ref="myConsole"></appender-ref>
    </root>
    <logger name="com.cyb.webdemo.dao.EmployeeDao" level="DEBUG"></logger></configuration>

方式二

application.properties

代码拷贝区

application.properties

# 控制日志显示格式
logging.pattern.console=%leven %msg%n
logging.level.root=warn
# 格式:logging.level.dao层命名空间
logging.level.com.cyb.webdemo.dao.EmployeeDao=debug

实现

Spring Boot中使用Redis(解决高并发,重点!!)

注意

  案例从头到尾,使用都是同一个项目,代码配置结构复杂,看红色圈中的代码,敲黑板划重点!!!!!

学前预习

  Redis还不会的小伙伴,请先预习:分布式架构-Redis 从入门到精通 。

应用场景

  使用Redis缓存的数据划分为两类:

  1. DB表中的数据更新后,Redis缓冲的相关数据要清除,要不然客户端获取的不是最新数据。

  2. 对数据准确性要求不高的数据,可以与DB表中的数据不一致,但差别不能太大,所以该类数据一般会设置过期1时效

启动redis服务器

Spring Boot与Redis整合依赖

完整pom.xml

<?xml version="1.0" encoding="UTF-8"?><project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cyb</groupId>
    <artifactId>webdemo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war</packaging>
    <name>webdemo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>13</java.version>
    </properties>

    <dependencies>
        <!--Mybatis与Spring Boot整合依赖,必须要版本号-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

        <!--mysql驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--Druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <!--lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--Spring Boot与redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

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

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <resources>
            <!--注册dao包下mybatis映射文件为资源目录-->
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <!--注册webapp目录为资源目录-->
            <resource>
                <directory>src/main/webapp</directory>
                <targetPath>META-INF/resources</targetPath>
                <includes>
                    <include>**/*.*</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build></project>

修改主配置文件

application.properties

代码拷贝区

# 视图的前缀和后缀
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

# 注册映射文件
mybatis.mapper-locations=classpath:com/cyb/webdemo/dao/EmployeeDao.xml
# 注册实体类别名
mybatis.type-aliases-package=com.cyb.webdemo.bean.EmployeePo
# 注册数据源类型
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
# 数据库连接字符串
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/cyb
spring.datasource.username=root
spring.datasource.password=root

# 控制日志显示格式
logging.pattern.console=%leven %msg%n
logging.level.root=warn
# 格式:logging.level.dao层命名空间
logging.level.com.cyb.webdemo.dao.EmployeeDao=debug

# 连接redis
spring.redis.host=192.168.31.200
spring.redis.port=6379
spring.redis.password=root
# 连接redis集群,redis利用哨兵机制实现高可用
# spring.redis.sentinel.master=mymaster
# spring.redis.sentinel.nodes=sentinel1:6370,sentinel2:6371,sentinel3:6372

# 指定缓存类型
spring.cache.type=redis
# 设置缓存名称
spring.cache.cache-names=realTimeCache

JSP页面

index.jsp

代码拷贝区

<%--
  Created by IntelliJ IDEA.
  User: chenyanbin  Date: 2020/1/6
  Time: 7:13 下午  To change this template use File | Settings | File Templates.--%><%@ page contentType="text/html;charset=UTF-8" language="java" %><html><head>
    <title>Title</title></head><body><form action="register" method="post">
    姓名:<input type="text" name="name"><br/>
    年龄:<input type="number" name="age"><br/>
    <input type="submit" value="注册"></form><hr><form action="find" method="post">
    id:<input type="text" name="id">
    <input type="submit" value="查询"></form><a href="count">查看员工总数</a></body></html>

实体类

EmployeePo.java

数据库表字段

Dao层(数据访问层)

EmployeeDao.java

映射文件

EmployeeDao.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd"><mapper namespace="com.cyb.webdemo.dao.EmployeeDao">
    <insert id="insertEmployee">
    insert into employee (name,age) values (#{name},#{age})</insert>
    <select id="selectEmployeeById" resultType="com.cyb.webdemo.bean.EmployeePo">
        select id,name,age from employee where id=#{id}    </select>
    <select id="selectEmployeeCount" resultType="int">
        select count(1) from employee    </select></mapper>

Service(业务层)

EmployeeService.java(接口)

EmployeeServiceImpl.java(接口实现类)

  注:双重检测锁非常重要!!!!

代码拷贝区

package com.cyb.webdemo.service;import com.cyb.webdemo.bean.EmployeePo;import com.cyb.webdemo.dao.EmployeeDao;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.cache.annotation.CacheEvict;import org.springframework.cache.annotation.Cacheable;import org.springframework.data.redis.core.BoundValueOperations;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import java.util.concurrent.TimeUnit;
@Servicepublic class EmployeeServiceImpl implements EmployeeService {
    @Autowired(required = false)    private EmployeeDao dao;
    @CacheEvict(value = "realTimeCache", allEntries = true)    // 清除缓存,实际生产环境就这样玩,因为每个实体类设置不同的缓存区空间,范围小,清除缓存好操作    @Transactional
    @Override    public void addEmployee(EmployeePo employee) {
        dao.insertEmployee(employee);
    }
    @Cacheable(value = "realTimeCache", key = "'employee_'+#id")    // 先会去缓存中查下key是否存在,存在:则直接拿缓存中的数据;不存在:去数据库中查,查完将结果放入缓存中    @Override    public EmployeePo findEmployeeById(int id) {        return dao.selectEmployeeById(id);
    }
    @Autowired    private RedisTemplate<Object, Object> redisTemplate;    //使用双重检测锁,解决热点缓存问题    //双重检测锁,解决了高并发下,对数据库访问的压力!!!!    //热点缓存脑补,请参考:https://www.jianshu.com/p/6e37a1a9c160    @Override    public int findEmployeeCount() {        //获取Redis操作对象
        BoundValueOperations<Object, Object> ops = redisTemplate.boundValueOps("count");        //从缓存中读取数据
        Object count = ops.get();        if (count == null) {            synchronized (this) {
                count = ops.get();                if (count == null) {                    //从DB中查询
                    count = dao.selectEmployeeCount();                    //将查询的数据,写入Redis缓存,并设置到期时限
                    ops.set(count,10, TimeUnit.SECONDS);
                }
            }
        }        return (int) count;
    }
}

实现

注:细心的小伙伴发现,一个问题,根据id查询数据库的时候,为什么控制台没有打印sql语句呢???对表进行增删改时,清除缓存,查询时设置缓存,因为之前演示的时候,已经将缓存写入到redis服务器中了,查询的时候,拿的是缓存数据!!

完整项目

直接下载

Redis自动生成key(高级用法)

自动生成类

RedisCacheConfig.java

package com.cyb.webdemo.controller;import org.springframework.cache.annotation.CachingConfigurerSupport;import org.springframework.cache.interceptor.KeyGenerator;import org.springframework.context.annotation.Configuration;

@Configurationpublic class RedisCacheConfig extends CachingConfigurerSupport {    // 自定义生成key结构:类名_方法名_参数值    // 本例:EmployeeServiceImpl_findEmployeeById_1
    public KeyGenerator keyGenerator() {        return (target, method, params) -> {            //获取注解所标的方法所在类的类名
            String className = target.getClass().getName();            //获取注解所标注的方法的方法名
            String methodName = method.getName();            return className + "_" + methodName + "_" + params[0].toString();
        };
    }
}

实现

Spring Boot拦截器

  在非Spring Boot工程中若要使用Spring Mvc的拦截器,在定义好拦截器后,需要在Spring配置文件中对其进行注册。但在Spring Boot工程中没有Spring的配置文件,那么如何使用拦截器呢?

  Spring Boot对于原来在配置文件配置的内容,现在全部体现在一个类中,该要继承WebMvcConfigurationSupport类,并使用@Configuration进行注册,表示该类为一个JavaConfig/codeConfig类,充当配置文件的角色。

定义拦截器

SomeInterceptor.java

package com.cyb.webdemo.controller;import org.springframework.web.servlet.HandlerInterceptor;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public class SomeInterceptor implements HandlerInterceptor {
    @Override    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("拦截器:"+request.getRequestedSessionId());        return true;
    }
}

  注:返回值 true:不拦截;false:拦截

配置文件类

MyMvcConfiguration.java

package com.cyb.webdemo.controller;import org.springframework.context.annotation.Configuration;import org.springframework.web.servlet.config.annotation.InterceptorRegistry;import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

@Configuration //表示该类充当配置文件public class MyMvcConfiguration extends WebMvcConfigurationSupport {
    @Override    protected void addInterceptors(InterceptorRegistry registry) {
        SomeInterceptor someInterceptor = new SomeInterceptor();
        registry.addInterceptor(someInterceptor)
                .addPathPatterns("/one/**") //拦截one开头请求
                .excludePathPatterns("/two/**"); //允许two开头的请求    }
}

  注:**:代表多级目录;*:只有一级目录;

一般设置全部拦截addPathPatterns("/**");再设置局部的不拦截excludePathPatterns("/xx/**")

定义处理器

package com.cyb.webdemo.controller;import com.cyb.webdemo.bean.EmployeePo;import com.cyb.webdemo.service.EmployeeService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.ui.Model;import org.springframework.web.bind.annotation.*;

@Controllerpublic class SomeController {
    @RequestMapping("/two/index")    public String RegisterHandler(){        return "two";
    }
    @RequestMapping("/one/index")    public String RegisterHandler2(){        return "one";
    }
}

Spring Boot中使用Servlet

  在Spring Boot使用Servlet,根据Servlet注册方式的不同,有两种使用方式。若使用的是Servlet3.0+版本,则两种方式均可使用;若使用的是Servlet2.5版本,则只能使用配置类方式。

注解方式

  若使用Servlet3.0+版本,可以使用注解方式,分两步。

  1. 在定义好的Servlet上使用@WebServlet注解

  2. 在入口类上添加@ServletComponentScan注解

cybServlet.java

package com.cyb.webdemo.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(name = "/cyb")public class cybServlet extends HttpServlet {    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.getWriter().println("hello spring boot servlet!");
    }
}

入口类

WebdemoApplication

实现

配置类方式

  若使用的是Servlet2.5版本,没有Servlet注解,此时只能使用配置类方式。其总步骤有两步,无需再入口类上添加@ServletComponentScan注解

定义Servlet

package com.cyb.webdemo.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 SomeServlet extends HttpServlet {
    @Override    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().println("servlet");
    }
}

定义配置类

package com.cyb.webdemo.servlet;import org.springframework.boot.web.servlet.ServletRegistrationBean;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;

@Configuration //表示其为配置类,相当于applicationContext.xml文件public class MyApplicationContext {
    @Bean //表示该方法返回的对象即为Spring容器中的Bean,方法名随意
    public ServletRegistrationBean<SomeServlet> getServletBean(){        // 创建Servlet
        SomeServlet someServlet=new SomeServlet();        // 注册Servlet
        return new ServletRegistrationBean<SomeServlet>(someServlet,"/cyb");
    }
}

实现

 Spring Boot中使用Filter

  在Spring Boot中使用Filter前面的使用Servlet相似,根据Filter注册方式的不同,有两种使用方式。若使用的是Servlet3.0+版本,则两种方式均可使用;若使用的是Servlet2.5版本,则只能使用配置类方式

注解方式

  若使用的是Servlet3.0+版本,可以直接使用Filter的注解对Filter进行注册。有两步

  1. 在定义好的Filter上使用@WebFilter注解

  2. 在入口类添加@ServletComponentScan注解

SomeFilter.java

package com.cyb.webdemo.file;import javax.servlet.*;import javax.servlet.annotation.WebFilter;import java.io.IOException;
@WebFilter("/*")public class SomeFilter implements Filter {

    @Override    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("信息已被过滤");
        chain.doFilter(request,response);
    }

    @Override    public void destroy() {

    }
}

修改入口类

package com.cyb.webdemo;import org.springframework.boot.SpringApplication;import org.springframework.boot.autoconfigure.SpringBootApplication;import org.springframework.boot.web.servlet.ServletComponentScan;import org.springframework.cache.annotation.EnableCaching;import org.springframework.transaction.annotation.EnableTransactionManagement;

@SpringBootApplication
@EnableTransactionManagement //开启事务@EnableCaching //开启缓存@ServletComponentScan("com.cyb.webdemo.file") //注意是包名public class WebdemoApplication {    public static void main(String[] args) {

        SpringApplication.run(WebdemoApplication.class, args);
    }
}

配置方式

  若使用的是Servlet2.5版本,没有Filter注解,此时只能使用配置类方式。有两步,与@ServletComponentScan注解无关

定义Filter

package com.cyb.webdemo.file;import javax.servlet.*;import java.io.IOException;public class SomeFilter implements Filter {

    @Override    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("信息已被过滤");
        chain.doFilter(request, response);
    }

    @Override    public void destroy() {

    }
}

修改配置类

package com.cyb.webdemo.file;import org.springframework.boot.web.servlet.FilterRegistrationBean;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;

@Configurationpublic class MyFilter {
    @Bean    public FilterRegistrationBean<SomeFilter> getFilterBean(){
        FilterRegistrationBean<SomeFilter> registrationBean=new FilterRegistrationBean<SomeFilter>(new SomeFilter());
        registrationBean.addUrlPatterns("/*");        return registrationBean;
    }
}

Thymeleaf

  Thymeleaf,百里香叶。Thymeleaf是一个流行的模板引擎,该模板引擎采用Java语言开发。模板引擎为了使用户界面与业务数据(内容)分离而产生,它可以生成特定格式的文档。例如,用于网站的模板引擎就会生成一个标准的HTML文档。不同的语言体系中都有自己的模板引擎,例如,Java中常见的模板引擎有Velocity、Freemaker、Thymeleaf等。不同的模板引擎都会具有自己的特定的标签体系,而Thymeleaf以HTML标签为载体,在HTML的标签下实现对数据的展示。

  Thymeleaf本身与Spring Boot没有关系,但Spring Boot官方推荐使用Thymeleaf作为前端页面的数据展示技术,Spring Boot很好地集成了这种模板技术。

  官网:https://www.thymeleaf.org/

Spring Boot集成Thymeleaf

创建项目

配置文件

application.properties

处理器

index.html

  在页面的<html>标签中添加Thymeleaf的命名空间属性:

<html lang="en" xmlns:th="https://www.thymeleaf.org/">

实现

Thymeleaf标准表达式

  常用的Thymeleaf标准表达式有三种。标准表达式都是用于获取代码中存放到Model中的属性值,只不过获取方式不同罢了

变量表达式:${...}

  使用${...}的表达式,称为变量表达式。该表达式的内容会显示在HTML标签体文本处

  该表达式一般都是通过th:text标签属性进行展示的。

实体类(Po)

处理器

index.html

方式一,直接使用实体类属性

方式二:使用实体类get方法获取值

  注:两种获取值的方式效果都是一样的。

实现

选择表达式:*{...}

  选择表达式,也称为星号表达式。一般用于展示对象的属性。该表达式的内容会显示在HTML标签体文本处。但其需要与th:object标签属性联用,先使用th:object标签选择了对象,再使用*{...}选择要展示的对象属性。该表达式可以有效降低页面中代码的冗余

  也可以不与th:object联用,在*{...}中直接使用&ldquo;对象.属性&rdquo;方式,这种写法与变量表达式相同

  该表达式一般都是通过th:text标签属性进行展示

index.html修改

实现

URL表达式:@{...}

  其中只能写一个绝对URL或相对URL地址的表达式,称为URL表达式。这个绝对/相对URL地址中一般包含有动态参数的需要结合变量表达式${...}进行字符串拼接

  @{...}中的URL地址有3种写法。

以Http协议开头的绝对地址

  在进行字符串拼接时使用&ldquo;+&rdquo;连接,容易出错。但使用双竖线则无需字符串拼接,简单易读。但是,在idea中的问号会报错,不影响程序运行,可能是idea的bug吧。

index.html

查看网页源码

以/开头的相对地址

  在URL表达式中,Thymeleaf会将/解析为当前工程的上下文路径ContextPath,而浏览器会自动为其添加"http://主机名:端口号",即为一个绝对路径

不以/开头的相对地址

  查看页面源码可以看到解析结果是没有添加任何东西的,没有上下文路径,其实相对于当前请求路径的一个绝对地址。

自行学习

  授人以鱼不如授人以渔,其他具体的使用用法,请参照官网API:https://www.thymeleaf.org/documentation.html

文章关键词: Spring Boot Spring 开发架构 从入门到精通 附源码 Java

  • 0

    开心

  • 0

    板砖

  • 0

    感动

  • 0

    有用

  • 0

    疑问

  • 0

    难过

  • 0

    无聊

  • 0

    震惊

评论已有 0

相关文章

加载更多