朝雾轻寒

朝雾轻寒 查看完整档案

杭州编辑  |  填写毕业院校  |  填写所在公司/组织 www.zwqh.top 编辑
编辑

持之以恒

个人动态

朝雾轻寒 发布了文章 · 1月17日

Spring Boot 2.X(十九):集成 mybatis-plus 高效开发

前言

之前介绍了 SpringBoot 整合 Mybatis 实现数据库的增删改查操作,分别给出了 xml 和注解两种实现 mapper 接口的方式;虽然注解方式干掉了 xml 文件,但是使用起来并不优雅,本文将介绍 mybats-plus 的常用实例,简化常规的 CRUD 操作。

mybatis-plus

MyBatis-Plus(简称 MP)是一个 MyBatis 的增强工具,在 MyBatis 的基础上只做增强不做改变,为简化开发、提高效率而生。

学习 mybatis-plus:https://mp.baomidou.com/guide

常用实例

1. 项目搭建

1.1 pom.xml

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

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</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>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional> <!-- 这个需要为 true 热部署才有效 -->
        </dependency>

        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.0</version>
        </dependency>
    </dependencies>

1.2 application.yaml

# spring setting
spring:
  datasource:
    url: jdbc:mysql://127.0.0.1:3306/db_test?useUnicode=true&characterEncoding=UTF-8&useSSL=false
    username: root
    password: zwqh@0258

1.3 实体类 UserEntity

@TableName(value="t_user")
public class UserEntity {

    @TableId(value="id",type=IdType.AUTO)
    private Long id;
    private String userName;
    private String userSex;
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserSex() {
        return userSex;
    }
    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }
    
}
@TableName 指定数据库表名,否则默认查询表会指向 user_entity ;@TableId(value="id",type=IdType.AUTO) 指定数据库主键,否则会报错。

1.4 Dao层 UserDao

继承 BaseMapper<T>,T表示对应实体类

public interface UserDao extends BaseMapper<UserEntity>{

}

1.5 启动类

在启动类添加 @MapperScan 就不用再 UserDao 上用 @Mapper 注解。

@SpringBootApplication
@MapperScan("cn.zwqh.springboot.dao")
public class SpringBootMybatisPlusApplication {

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

}

1.6 分页插件配置

@Configuration
public class MybatisPlusConfig {
     /**
     *   mybatis-plus分页插件
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor page = new PaginationInterceptor();
        page.setDialectType("mysql");
        return page;
    }
 
}

2.示例

2.1 新增

新增用户
UserEntity user=new UserEntity();
user.setUserName("朝雾轻寒");
user.setUserSex("男");
userDao.insert(user);         

2.2 修改

根据id修改用户
UserEntity user=new UserEntity();
user.setUserName("朝雾轻晓");
user.setUserSex("男");
user.setId(25L);
userDao.updateById(user);
根据entity条件修改用户
UserEntity user=new UserEntity();
user.setUserSex("女");
userDao.update(user,new QueryWrapper<UserEntity>().eq("user_name", "朝雾轻寒"));

2.3 查询

根据id查询用户
UserEntity user = userDao.selectById(id);
根据entity条件查询总记录数
int count = userDao.selectCount(new QueryWrapper<UserEntity>().eq("user_sex", "男"));
根据 entity 条件,查询一条记录,返回的是实体
QueryWrapper<UserEntity> queryWrapper=new QueryWrapper<UserEntity>();
        UserEntity user=new UserEntity();
        user.setUserName("朝雾轻寒");
        user.setUserSex("男");
        queryWrapper.setEntity(user);
user = userDao.selectOne(queryWrapper);        
如果表内有两条或以上的相同数据则会报错,可以用来判断某类数据是否已存在
根据entity条件查询返回第一个字段的值(返回id列表)
QueryWrapper<UserEntity> queryWrapper=new QueryWrapper<UserEntity>();
        UserEntity user=new UserEntity();
        user.setUserSex("男");
        queryWrapper.setEntity(user);
List<Object> objs= userDao.selectObjs(queryWrapper);    
根据map条件查询返回多条数据
Map<String, Object> map=new HashMap<String, Object>();
        map.put("user_name", username);
        map.put("user_sex",sex);
List<UserEntity> list = userDao.selectByMap(map);        
根据entity条件查询返回多条数据(List<UserEntity>)
Map<String, Object> map=new HashMap<String, Object>();
        map.put("user_sex","男");
List<UserEntity> list = userDao.selectList(new QueryWrapper<UserEntity>().allEq(map));        
根据entity条件查询返回多条数据(List<Map<String, Object>> )
Map<String, Object> map=new HashMap<String, Object>();
        map.put("user_sex","男");
List<Map<String, Object>> list = userDao.selectMaps(new QueryWrapper<UserEntity>().allEq(map));
根据ID批量查询
List<Long> ids=new ArrayList<Long>();
        ids.add(1L);
        ids.add(2L);
        ids.add(3L);
List<UserEntity> list = userDao.selectBatchIds(ids);    
主键ID列表(不能为 null 以及 empty)
分页查询
Page<UserEntity> page=userDao.selectPage(new Page<>(1,5), new QueryWrapper<UserEntity>().eq("user_sex", "男"));
Page<Map<String, Object>> page=userDao.selectMapsPage(new Page<>(1,5), new QueryWrapper<UserEntity>().eq("user_sex", "男"));
需先配置分页插件bean,否则分页无效。如有pagehelper需先去除,以免冲突。

new Page<>(1,5),1表示当前页,5表示页面大小。

2.4 删除

根据id删除用户
userDao.deleteById(1);
根据entity条件删除用户
userDao.delete(new QueryWrapper<UserEntity>().eq("id", 1));
根据map条件删除用户
Map<String, Object> map=new HashMap<String, Object>();
        map.put("user_name", "zwqh");
        map.put("user_sex","男");
        userDao.deleteByMap(map);
根据ID批量删除
List<Long> ids=new ArrayList<Long>();
        ids.add(1L);
        ids.add(2L);
        ids.add(3L);
        userDao.deleteBatchIds(ids);
主键ID列表(不能为 null 以及 empty)

小结

本文介绍了 mybatis-plus 相关的 Mapper层 CRUD 接口实现,其还提供了 Service层 CRUD 的相关接口,有兴趣的小伙伴可以去使用下。 mybatis-plus 真正地提升了撸码效率。

其他学习要点:

  1. mybatis-plus 条件构造器
  2. lamda 表达式
  3. 常用注解
  4. ...
学习地址:https://mp.baomidou.com/guide/

示例代码

github

码云

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十九):集成 mybatis-plus 高效开发

原文地址: https://www.zwqh.top/article/info/33

如果文章有不足的地方,欢迎提点建议,后续会完善~

如果文章对您有帮助,请给我点个赞哦~

关注下我的公众号,文章持续更新中...

查看原文

赞 0 收藏 0 评论 0

朝雾轻寒 发布了文章 · 2019-12-09

Spring Cloud(二):Eureka 服务注册中心

前言

服务治理

随着业务的发展,微服务应用也随之增加,这些服务的管理和治理会越来越难,并且集群规模、服务位置、服务命名都会发生变化,手动维护的方式极易发生错误或是命名冲突等问题。而服务治理正是为了解决这个问题,服务治理是微服务架构中最为核心和基础的模块,它主要实现各个微服务实例的自动化注册和发现

服务注册

在服务治理框架中,都会构建一个或多个服务注册中心。

每个服务模块向注册中心登记自己所提供的服务,将主机host、端口号、版本号、通信协议等一些附加信息告知注册中心,注册中心按服务名分类组织服务清单。

服务注册中心还需要以心跳的方式去监测清单中的服务是否可用,若不可用需要从服务清单中剔除,达到排除故障服务的效果。

服务发现

服务间调用不再通过指定具体实例地址来实现,而是通过向服务名发起请求调用实现。

服务调用方需要先从服务注册中心获取所有服务的实例清单,才能实现对具体服务实例的访问。

服务调用方在发起调用时,会以某种策略取出一个具体的服务实例进行服务调用(客户端负载均衡)。

在生产环境中为了考虑性能等因素,不会采用每次都向服务注册中心获取服务的方式,并且不同的应用场景在缓存和服务剔除等机制上也会采用不同的实现策略。

Spring Cloud Eureka

Spring Cloud Eureka 是基于 Netflix Eureka 来实现服务注册和发现的。它主要包括两个组件:

  • Eureka Server(服务端):服务注册中心,支持高可用配置,依托于强一致性提供良好的服务实例可用性,服务注册中心之间可以通过异步模式互相复制各自的状态。
  • Eureka Client(客户端):处理服务的注册与发现,客户端可以通过注解和参数配置的方式实现注册与发现,客户端向注册中心注册自身提供的服务并周期性地发送心跳来更新它的服务租约,Eureka客户端从服务端查询当前注册的服务信息并把它们缓存到本地并周期性的刷新服务状态。

Eureka 基础架构

  • 服务注册中心(Eureka Server):服务端,提供服务注册和发现功能。
  • 服务提供者(Service Provider):提供服务的应用,将自己提供的服务注册到 Eureka Server,供其他应用发现。
  • 服务消费者(Service Consumer):消费者应用从 Eureka Server 获取服务列表,从而调用对应的服务(ribbon或者feign)。

基础架构图

快速搭建服务注册中心(Eureka Server)

1. 创建 Spring Boot 项目,添加依赖

<properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </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>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2. @EnableEurekaServer 注解启动服务注册中心

@SpringBootApplication
@EnableEurekaServer
public class SpringCloudEurekaServerApplication {

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

}

3. 配置文件 application.properties

server.port=9999
#eureka
eureka.instance.hostname=127.0.0.1
eureka.client.register-with-eureka=false
eureka.client.fetch-registry=false
eureka.client.serviceUrl.defaultZone=http://${eureka.instance.hostname}:${server.port}/eureka/
  • eureka.client.register-with-eureka:当前应用为服务注册中心,所以设置为false,代表不向注册中心注册自己。
  • eureka.client.fetch-registry:注册中心的职责主要是维护服务实例,所以设置为false,代表不去检索当前应用的服务。
  • eureka.client.serviceUrl.defaultZone:用于与 Eureka Server 交互的地址,注册服务和发现服务都需要依赖这个地址。

4.启动应用,访问:http://127.0.0.1:9999/

可以看到 Eureka 的信息面板,其中 Instances currently registered with Eureka 中列表显示 No instances available,说明该注册中心还没有注册任何服务。

服务提供者(Service Provider)

1. 创建 Spring Boot 项目,添加依赖

<properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
        </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>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

2. @EnableDiscoveryClient 注解启动 Eureka 客户端

@SpringBootApplication
//@EnableEurekaClient  该注解在采用eureka作为注册中心时使用,场景较为单一
@EnableDiscoveryClient //场景更为广泛
public class SpringCloudEurekaServiceApplication {

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

}

@EnableEurekaClient@EnableDiscoveryClient 在当前示例中使用效果好是一样的,@EnableEurekaClient 注解在采用eureka作为注册中心时使用,场景较为单一,@EnableDiscoveryClient 场景更为广泛。

3. 配置文件 application.properties

server.port=8888
spring.application.name=spring-cloud-eureka-service
#info 应用信息
info.app.name=spring-cloud-eureka-service
info.app.version=v1.0.0
info.app.description=spring-cloud-eureka-service
#eureka
eureka.instance.hostname=127.0.0.1
#每隔5s心跳一次,证明本服务还活着
eureka.instance.lease-renewal-interval-in-seconds=5
#本服务10s内没有心跳,就将该服务从服务端剔除
eureka.instance.lease-expiration-duration-in-seconds=10
eureka.client.serviceUrl.defaultZone=http://127.0.0.1:9999/eureka/
  • eureka.instance.lease-renewal-interval-in-seconds:设置心跳间隔秒数
  • eureka.instance.lease-expiration-duration-in-seconds:设置秒数内无心跳,则剔除服务

4. 启动应用,访问:http://127.0.0.1:9999/

在服务注册中心的控制台中我们可以看到如下输出,说明服务被注册成功了。

 c.n.e.registry.AbstractInstanceRegistry  : Registered instance SPRING-CLOUD-EUREKA-SERVICE/192.168.101.201:spring-cloud-eureka-service:8888 with status UP (replication=false)

而在 Eureka 的信息面板上,在 Instances currently registered with Eureka 列表中同样可以看到服务的注册信息。如下图:

高可用注册中心(集群)

上面介绍了单节点模式的服务注册中心,不过在实际生产环境中,通常不会采用这种模式。在分布式系统中,服务注册中心是非常重要的组成部分,如果是单节点模式,发生故障的话将会是毁灭性的灾害。所以为了维护服务的高可用性,通常采用集群的解决方案。

Eureka 的服务治理设计中,所有的节点既是服务提供方,也是服务消费方,服务注册中心也不例外。Eureka 通过互相注册服务的方式,以实现服务清单的互相同步,达到高可用的效果。

双节点注册中心

  1. 搭建服务注册中心 A,配置文件如下:
server.port=9991
spring.application.name=eureka-server
spring.profiles.active=nodea
#eureka
eureka.instance.hostname=nodea
#设置微服务调用地址为IP优先(缺省为false)
#eureka.instance.prefer-ip-address=true
eureka.client.serviceUrl.defaultZone=http://nodeb:9992/eureka/
  1. 搭建服务注册中心 B,配置文件如下:
server.port=9992
spring.application.name=eureka-server
spring.profiles.active=nodeb
#eureka
eureka.instance.hostname=nodeb
#设置微服务调用地址为IP优先(缺省为false)
#eureka.instance.prefer-ip-address=true
eureka.client.serviceUrl.defaultZone=http://nodea:9991/eureka/
  1. 在 /etc/hosts(windows系统路径为 C:WindowsSystem32driversetchosts) 文件中添加 nodea 和 nodeb 的转换,如下:
127.0.0.1 nodea
127.0.0.1 nodeb
  1. 启动两个项目,分别访问http://nodea:9991/http://nodeb:9992/,我们可以看到两个节点都已经被注册,如下图所示:

  1. 搭建完多节点服务注册中心之后,服务提供者也需要做一些简单的配置,以上面的服务提供者为例,修改如下:
eureka.client.serviceUrl.defaultZone=http://nodea:9991/eureka/,http://nodeb:9992/eureka/

启动项目后,访问两个服务注册中心,我们看到服务被注册到这两个节点内。

  1. 这时我们关闭服务注册中心节点 A,我们可以看到服务注册中心节点 B 依然可以提供服务,而节点 A 从 available-replicas(可以分片) 变为 unavailable-replicas(不可用分片)。

服务消费者(Service Consumer)

使用 Ribbon 调用服务

1. pom 相关依赖配置
<properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-ribbon</artifactId>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
2. 配置文件 application.properties
spring.application.name=spring-cloud-ribbon-consumer
server.port=8081
eureka.client.serviceUrl.defaultZone=http://nodea:9991/eureka/,http://nodeb:9992/eureka/
3. 启动类配置

通过 @EnableDiscoveryClient 注解将应用注册为 Eureka 客户端,获得服务发现能力。

创建 RestTemplate 的 Spring Bean 实例用来调用服务。

通过 @LoadBalanced 注解来开启客户端的负载均衡。

@SpringBootApplication
@EnableDiscoveryClient
public class SpringCloudRibbonConsumerApplication {

    @Bean
    @LoadBalanced
    RestTemplate restTemplate(){
        return new RestTemplate();
    }
    
    public static void main(String[] args) {
        SpringApplication.run(SpringCloudRibbonConsumerApplication.class, args);
    }

}
4. ConsumerController 来实现服务调用
@RestController
public class ConsumerController {

    @Autowired
    RestTemplate restTemplate;
    
    @RequestMapping("/test")
    public String test() {
        return restTemplate.getForEntity("http://spring-cloud-eureka-service/test", String.class).getBody();
    }
}

spring-cloud-eureka-service 为服务注册中心的应用名称,大小写均可。

使用 Feign 调用服务

1. pom 相关依赖配置
<properties>
        <java.version>1.8</java.version>
        <spring-cloud.version>Hoxton.RELEASE</spring-cloud.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-starter-openfeign</artifactId>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-dependencies</artifactId>
                <version>${spring-cloud.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>
2. 配置文件 application.properties
spring.application.name=spring-cloud-feign-consumer
server.port=8080
eureka.client.serviceUrl.defaultZone=http://nodea:9991/eureka/,http://nodeb:9992/eureka/
3. 启动类配置

通过 @EnableDiscoveryClient 注解将应用注册为 Eureka 客户端,获得服务发现能力。

通过 @EnableFeignClients 注解来启用feign进行远程调用。

@SpringBootApplication
@EnableDiscoveryClient//启用服务注册与发现
@EnableFeignClients//启用feign进行远程调用
public class SpringCloudFeignConsumerApplication {

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

}
4. 实现服务调用接口
@FeignClient(name = "spring-cloud-eureka-service")
public interface TestService {

    @RequestMapping("/test")
    public String test();
}

spring-cloud-eureka-service 为服务注册中心的应用名称,大小写均可。

此接口中的方法和远程服务中contoller中的方法名和参数需保持一致。

5. ConsumerController 来实现服务调用
@RestController
public class ConsumerController {

    @Autowired
    private TestService testService;
    
    @RequestMapping("/test")
    public String test() {
        return testService.test();
    }
}

示例代码

github

码云

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Cloud(二):Eureka 服务注册中心

原文地址: https://www.zwqh.top/article/info/28

如果文章有不足的地方,欢迎提点建议,后续会完善~

如果文章对您有帮助,请给我点个赞哦~

关注下我的公众号,文章持续更新中...

查看原文

赞 0 收藏 0 评论 0

朝雾轻寒 发布了文章 · 2019-11-26

Spring Boot 2.X(十八):集成 Spring Security-登录认证和权限控制

前言

在企业项目开发中,对系统的安全和权限控制往往是必需的,常见的安全框架有 Spring Security、Apache Shiro 等。本文主要简单介绍一下 Spring Security,再通过 Spring Boot 集成开一个简单的示例。

Spring Security

什么是 Spring Security?

Spring Security 是一种基于 Spring AOP 和 Servlet 过滤器 Filter 的安全框架,它提供了全面的安全解决方案,提供在 Web 请求和方法调用级别的用户鉴权和权限控制。

Web 应用的安全性通常包括两方面:用户认证(Authentication)和用户授权(Authorization)。

用户认证指的是验证某个用户是否为系统合法用户,也就是说用户能否访问该系统。用户认证一般要求用户提供用户名和密码,系统通过校验用户名和密码来完成认证。

用户授权指的是验证某个用户是否有权限执行某个操作。

2.原理

Spring Security 功能的实现主要是靠一系列的过滤器链相互配合来完成的。以下是项目启动时打印的默认安全过滤器链(集成5.2.0):

[
    org.springframework.security.web.context.request.async.WebAsyncManagerIntegrationFilter@5054e546,
    org.springframework.security.web.context.SecurityContextPersistenceFilter@7b0c69a6,
    org.springframework.security.web.header.HeaderWriterFilter@4fefa770,
    org.springframework.security.web.csrf.CsrfFilter@6346aba8,
    org.springframework.security.web.authentication.logout.LogoutFilter@677ac054,
    org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter@51430781,
    org.springframework.security.web.savedrequest.RequestCacheAwareFilter@4203d678,
    org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter@625e20e6,
    org.springframework.security.web.authentication.AnonymousAuthenticationFilter@19628fc2,
    org.springframework.security.web.session.SessionManagementFilter@471f8a70,
    org.springframework.security.web.access.ExceptionTranslationFilter@3e1eb569,
    org.springframework.security.web.access.intercept.FilterSecurityInterceptor@3089ab62
]
  • WebAsyncManagerIntegrationFilter
  • SecurityContextPersistenceFilter
  • HeaderWriterFilter
  • CsrfFilter
  • LogoutFilter
  • UsernamePasswordAuthenticationFilter
  • RequestCacheAwareFilter
  • SecurityContextHolderAwareRequestFilter
  • AnonymousAuthenticationFilter
  • SessionManagementFilter
  • ExceptionTranslationFilter
  • FilterSecurityInterceptor

详细解读可以参考:https://blog.csdn.net/dushiwo...

3.核心组件

SecurityContextHolder

用于存储应用程序安全上下文(Spring Context)的详细信息,如当前操作的用户对象信息、认证状态、角色权限信息等。默认情况下,SecurityContextHolder 会使用 ThreadLocal 来存储这些信息,意味着安全上下文始终可用于同一执行线程中的方法。

获取有关当前用户的信息

因为身份信息与线程是绑定的,所以可以在程序的任何地方使用静态方法获取用户信息。例如获取当前经过身份验证的用户的名称,代码如下:

Object principal = SecurityContextHolder.getContext().getAuthentication().getPrincipal();
if (principal instanceof UserDetails) {
    String username = ((UserDetails)principal).getUsername();
} else {
    String username = principal.toString();
}

其中,getAuthentication() 返回认证信息,getPrincipal() 返回身份信息,UserDetails 是对用户信息的封装类。

Authentication

认证信息接口,集成了 Principal 类。该接口中方法如下:

接口方法功能说明
getAuthorities()获取权限信息列表,默认是 GrantedAuthority 接口的一些实现类,通常是代表权限信息的一系列字符串
getCredentials()获取用户提交的密码凭证,用户输入的密码字符窜,在认证过后通常会被移除,用于保障安全
getDetails()获取用户详细信息,用于记录 ip、sessionid、证书序列号等值
getPrincipal()获取用户身份信息,大部分情况下返回的是 UserDetails 接口的实现类,是框架中最常用的接口之一

AuthenticationManager

认证管理器,负责验证。认证成功后,AuthenticationManager 返回一个填充了用户认证信息(包括权限信息、身份信息、详细信息等,但密码通常会被移除)的 Authentication 实例。然后再将 Authentication 设置到 SecurityContextHolder 容器中。

AuthenticationManager 接口是认证相关的核心接口,也是发起认证的入口。但它一般不直接认证,其常用实现类 ProviderManager 内部会维护一个 List<AuthenticationProvider> 列表,存放里多种认证方式,默认情况下,只需要通过一个 AuthenticationProvider 的认证,就可被认为是登录成功。

UserDetailsService

负责从特定的地方加载用户信息,通常是通过JdbcDaoImpl从数据库加载实现,也可以通过内存映射InMemoryDaoImpl实现。

UserDetails

该接口代表了最详细的用户信息。该接口中方法如下:

接口方法功能说明
getAuthorities()获取授予用户的权限
getPassword()获取用户正确的密码,这个密码在验证时会和 Authentication 中的 getCredentials() 做比对
getUsername()获取用于验证的用户名
isAccountNonExpired()指示用户的帐户是否已过期,无法验证过期的用户
isAccountNonLocked()指示用户的账号是否被锁定,无法验证被锁定的用户
isCredentialsNonExpired()指示用户的凭据(密码)是否已过期,无法验证凭证过期的用户
isEnabled()指示用户是否被启用,无法验证被禁用的用户

Spring Security 实战

1.系统设计

本文主要使用 Spring Security 来实现系统页面的权限控制和安全认证,本示例不做详细的数据增删改查,sql 可以在完整代码里下载,主要是基于数据库对页面 和 ajax 请求做权限控制。

1.1 技术栈

  • 编程语言:Java
  • 编程框架:Spring、Spring MVC、Spring Boot
  • ORM 框架:MyBatis
  • 视图模板引擎:Thymeleaf
  • 安全框架:Spring Security(5.2.0)
  • 数据库:MySQL
  • 前端:Layui、JQuery

1.2 功能设计

  1. 实现登录、退出
  2. 实现菜单 url 跳转的权限控制
  3. 实现按钮 ajax 请求的权限控制
  4. 防止跨站请求伪造(CSRF)攻击

1.3 数据库层设计

t_user 用户表

字段类型长度是否为空说明
idint8主键,自增长
usernamevarchar20用户名
passwordvarchar255密码

t_role 角色表

字段类型长度是否为空说明
idint8主键,自增长
role_namevarchar20角色名称

t_menu 菜单表

字段类型长度是否为空说明
idint8主键,自增长
menu_namevarchar20菜单名称
menu_urlvarchar50菜单url(Controller 请求路径)

t_user_roles 用户权限表

字段类型长度是否为空说明
idint8主键,自增长
user_idint8用户表id
role_idint8角色表id

t_role_menus 权限菜单表

字段类型长度是否为空说明
idint8主键,自增长
role_idint8角色表id
menu_idint8菜单表id

实体类这里不详细列了。

2.代码实现

2.0 相关依赖

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

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

        <!-- 热部署模块 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional> <!-- 这个需要为 true 热部署才有效 -->
        </dependency>
        
            <!-- mysql 数据库驱动. -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- mybaits -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.0</version>
        </dependency>
        
        <!-- thymeleaf -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </dependency>
        
        <!-- alibaba fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <!-- spring security -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
    </dependencies>

2.1 继承 WebSecurityConfigurerAdapter 自定义 Spring Security 配置

/**
prePostEnabled :决定Spring Security的前注解是否可用 [@PreAuthorize,@PostAuthorize,..]
secureEnabled : 决定是否Spring Security的保障注解 [@Secured] 是否可用
jsr250Enabled :决定 JSR-250 annotations 注解[@RolesAllowed..] 是否可用.
 */
@Configurable
@EnableWebSecurity
//开启 Spring Security 方法级安全注解 @EnableGlobalMethodSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true,securedEnabled = true,jsr250Enabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{

    @Autowired
    private CustomAccessDeniedHandler customAccessDeniedHandler;
    @Autowired
    private UserDetailsService userDetailsService;
    
    /**
     * 静态资源设置
     */
    @Override
    public void configure(WebSecurity webSecurity) {
        //不拦截静态资源,所有用户均可访问的资源
        webSecurity.ignoring().antMatchers(
                "/",
                "/css/**",
                "/js/**",
                "/images/**",
                "/layui/**"
                );
    }
    /**
     * http请求设置
     */
    @Override
    public void configure(HttpSecurity http) throws Exception {
        //http.csrf().disable(); //注释就是使用 csrf 功能        
        http.headers().frameOptions().disable();//解决 in a frame because it set 'X-Frame-Options' to 'DENY' 问题            
        //http.anonymous().disable();
        http.authorizeRequests()
            .antMatchers("/login/**","/initUserData")//不拦截登录相关方法        
            .permitAll()        
            //.antMatchers("/user").hasRole("ADMIN")  // user接口只有ADMIN角色的可以访问
//            .anyRequest()
//            .authenticated()// 任何尚未匹配的URL只需要验证用户即可访问
            .anyRequest()
            .access("@rbacPermission.hasPermission(request, authentication)")//根据账号权限访问            
            .and()
            .formLogin()
            .loginPage("/")
            .loginPage("/login")   //登录请求页
            .loginProcessingUrl("/login")  //登录POST请求路径
            .usernameParameter("username") //登录用户名参数
            .passwordParameter("password") //登录密码参数
            .defaultSuccessUrl("/main")   //默认登录成功页面
            .and()
            .exceptionHandling()
            .accessDeniedHandler(customAccessDeniedHandler) //无权限处理器
            .and()
            .logout()
            .logoutSuccessUrl("/login?logout");  //退出登录成功URL
            
    }
    /**
     * 自定义获取用户信息接口
     */
    @Override
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailsService).passwordEncoder(passwordEncoder());
    }
    
    /**
     * 密码加密算法
     * @return
     */
    @Bean
    public BCryptPasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
 
    }
}

2.2 自定义实现 UserDetails 接口,扩展属性

public class UserEntity implements UserDetails {

    /**
     * 
     */
    private static final long serialVersionUID = -9005214545793249372L;

    private Long id;// 用户id
    private String username;// 用户名
    private String password;// 密码
    private List<Role> userRoles;// 用户权限集合
    private List<Menu> roleMenus;// 角色菜单集合

    private Collection<? extends GrantedAuthority> authorities;
    public UserEntity() {
        
    }
    
    public UserEntity(String username, String password, Collection<? extends GrantedAuthority> authorities,
            List<Menu> roleMenus) {
        this.username = username;
        this.password = password;
        this.authorities = authorities;
        this.roleMenus = roleMenus;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public List<Role> getUserRoles() {
        return userRoles;
    }

    public void setUserRoles(List<Role> userRoles) {
        this.userRoles = userRoles;
    }

    public List<Menu> getRoleMenus() {
        return roleMenus;
    }

    public void setRoleMenus(List<Menu> roleMenus) {
        this.roleMenus = roleMenus;
    }

    @Override
    public Collection<? extends GrantedAuthority> getAuthorities() {
        return this.authorities;
    }

    @Override
    public boolean isAccountNonExpired() {
        return true;
    }

    @Override
    public boolean isAccountNonLocked() {
        return true;
    }

    @Override
    public boolean isCredentialsNonExpired() {
        return true;
    }

    @Override
    public boolean isEnabled() {
        return true;
    }

}

2.3 自定义实现 UserDetailsService 接口

/**
 * 获取用户相关信息
 * @author charlie
 *
 */
@Service
public class UserDetailServiceImpl implements UserDetailsService {
    private Logger log = LoggerFactory.getLogger(UserDetailServiceImpl.class);

    @Autowired
    private UserDao userDao;

    @Autowired
    private RoleDao roleDao;
    @Autowired
    private MenuDao menuDao;

    @Override
    public UserEntity loadUserByUsername(String username) throws UsernameNotFoundException {
        // 根据用户名查找用户
        UserEntity user = userDao.getUserByUsername(username);
        System.out.println(user);
        if (user != null) {
            System.out.println("UserDetailsService");
            //根据用户id获取用户角色
            List<Role> roles = roleDao.getUserRoleByUserId(user.getId());
            // 填充权限
            Collection<SimpleGrantedAuthority> authorities = new HashSet<SimpleGrantedAuthority>();
            for (Role role : roles) {
                authorities.add(new SimpleGrantedAuthority(role.getRoleName()));
            }
            //填充权限菜单
            List<Menu> menus=menuDao.getRoleMenuByRoles(roles);
            return new UserEntity(username,user.getPassword(),authorities,menus);
        } else {
            System.out.println(username +" not found");
            throw new UsernameNotFoundException(username +" not found");
        }        
    }

}

2.4 自定义实现 URL 权限控制

/**
 * RBAC数据模型控制权限
 * @author charlie
 *
 */
@Component("rbacPermission")
public class RbacPermission{

    private AntPathMatcher antPathMatcher = new AntPathMatcher();

    public boolean hasPermission(HttpServletRequest request, Authentication authentication) {
        Object principal = authentication.getPrincipal();
        boolean hasPermission = false;
        if (principal instanceof UserEntity) {
            // 读取用户所拥有的权限菜单
            List<Menu> menus = ((UserEntity) principal).getRoleMenus();
            System.out.println(menus.size());
            for (Menu menu : menus) {
                if (antPathMatcher.match(menu.getMenuUrl(), request.getRequestURI())) {
                    hasPermission = true;
                    break;
                }
            }
        }
        return hasPermission;
    }
}

2.5 实现 AccessDeniedHandler

自定义处理无权请求

/**
 * 处理无权请求
 * @author charlie
 *
 */
@Component
public class CustomAccessDeniedHandler implements AccessDeniedHandler {

    private Logger log = LoggerFactory.getLogger(CustomAccessDeniedHandler.class);

    @Override
    public void handle(HttpServletRequest request, HttpServletResponse response,
            AccessDeniedException accessDeniedException) throws IOException, ServletException {
        boolean isAjax = ControllerTools.isAjaxRequest(request);
        System.out.println("CustomAccessDeniedHandler handle");
        if (!response.isCommitted()) {
            if (isAjax) {
                String msg = accessDeniedException.getMessage();
                log.info("accessDeniedException.message:" + msg);
                String accessDenyMsg = "{\"code\":\"403\",\"msg\":\"没有权限\"}";
                ControllerTools.print(response, accessDenyMsg);
            } else {
                request.setAttribute(WebAttributes.ACCESS_DENIED_403, accessDeniedException);
                response.setStatus(HttpStatus.FORBIDDEN.value());
                RequestDispatcher dispatcher = request.getRequestDispatcher("/403");
                dispatcher.forward(request, response);
            }
        }

    }

    public static class ControllerTools {
        public static boolean isAjaxRequest(HttpServletRequest request) {
            return "XMLHttpRequest".equals(request.getHeader("X-Requested-With"));
        }

        public static void print(HttpServletResponse response, String msg) throws IOException {
            response.setCharacterEncoding("UTF-8");
            response.setContentType("application/json; charset=utf-8");
            PrintWriter writer = response.getWriter();
            writer.write(msg);
            writer.flush();
            writer.close();
        }
    }

}

2.6 相关 Controller

登录/退出跳转

/**
 * 登录/退出跳转
 * @author charlie
 *
 */
@Controller
public class LoginController {
    @GetMapping("/login")
    public ModelAndView login(@RequestParam(value = "error", required = false) String error,
            @RequestParam(value = "logout", required = false) String logout) {
        ModelAndView mav = new ModelAndView();
        if (error != null) {
            mav.addObject("error", "用户名或者密码不正确");
        }
        if (logout != null) {
            mav.addObject("msg", "退出成功");
        }
        mav.setViewName("login");
        return mav;
    }
}

登录成功跳转

@Controller
public class MainController {

    @GetMapping("/main")
    public ModelAndView toMainPage() {
        //获取登录的用户名
        Object principal= SecurityContextHolder.getContext().getAuthentication().getPrincipal();
        String username=null;
        if(principal instanceof UserDetails) {
            username=((UserDetails)principal).getUsername();
        }else {
            username=principal.toString();
        }
        ModelAndView mav = new ModelAndView();
        mav.setViewName("main");
        mav.addObject("username", username);
        return mav;
    }
    
}

用于不同权限页面访问测试

/**
 * 用于不同权限页面访问测试
 * @author charlie
 *
 */
@Controller
public class ResourceController {

    @GetMapping("/publicResource")
    public String toPublicResource() {
        return "resource/public";
    }
    
    @GetMapping("/vipResource")
    public String toVipResource() {
        return "resource/vip";
    }
}

用于不同权限ajax请求测试

/**
 * 用于不同权限ajax请求测试
 * @author charlie
 *
 */
@RestController
@RequestMapping("/test")
public class HttptestController {

    @PostMapping("/public")
    public JSONObject doPublicHandler(Long id) {
        JSONObject json = new JSONObject();
        json.put("code", 200);
        json.put("msg", "请求成功" + id);
        return json;
    }

    @PostMapping("/vip")
    public JSONObject doVipHandler(Long id) {
        JSONObject json = new JSONObject();
        json.put("code", 200);
        json.put("msg", "请求成功" + id);
        return json;
    }
}

2.7 相关 html 页面

登录页面

<form class="layui-form" action="/login" method="post">
            <div class="layui-input-inline">
                <input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}"/>
                <input type="text" name="username" required
                    placeholder="用户名" autocomplete="off" class="layui-input">
            </div>
            <div class="layui-input-inline">
                <input type="password" name="password" required  placeholder="密码" autocomplete="off"
                    class="layui-input">
            </div>
            <div class="layui-input-inline login-btn">
                <button id="btnLogin" lay-submit lay-filter="*" class="layui-btn">登录</button>
            </div>
            <div class="form-message">
                <label th:text="${error}"></label>
                <label th:text="${msg}"></label>
            </div>
        </form>
<input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}"/> 防止跨站请求伪造(CSRF)攻击

退出系统

<form id="logoutForm" action="/logout" method="post"
                                style="display: none;">
                                <input type="hidden" th:name="${_csrf.parameterName}"
                                    th:value="${_csrf.token}">
                            </form>
                            <a
                                href="javascript:document.getElementById('logoutForm').submit();">退出系统</a>

ajax 请求页面

<input type="hidden" th:name="${_csrf.parameterName}" th:value="${_csrf.token}" id="hidCSRF">
<button class="layui-btn" id="btnPublic">公共权限请求按钮</button>
<br>
<br>
<button class="layui-btn" id="btnVip">VIP权限请求按钮</button>
<script type="text/javascript" th:data-original="@{/js/jquery-1.8.3.min.js}"></script>
<script type="text/javascript" th:data-original="@{/layui/layui.js}"></script>
<script type="text/javascript">
        layui.use('form', function() {
            var form = layui.form;
            $("#btnPublic").click(function(){
                $.ajax({
                    url:"/test/public",
                    type:"POST",
                    data:{id:1},
                    beforeSend:function(xhr){
                        xhr.setRequestHeader('X-CSRF-TOKEN',$("#hidCSRF").val());    
                    },
                    success:function(res){
                        alert(res.code+":"+res.msg);
                
                    }    
                });
            });
            $("#btnVip").click(function(){
                $.ajax({
                    url:"/test/vip",
                    type:"POST",
                    data:{id:2},
                    beforeSend:function(xhr){
                        xhr.setRequestHeader('X-CSRF-TOKEN',$("#hidCSRF").val());    
                    },
                    success:function(res){
                        alert(res.code+":"+res.msg);
                        
                    }
                });
            });
        });
    </script>

2.8 测试

测试提供两个账号:user 和 admin (密码与账号一样)

由于 admin 作为管理员权限,设置了全部的访问权限,这里只展示 user 的测试结果。



完整代码

github

码云

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十八):集成 Spring Security-登录认证和权限控制

原文地址: https://www.zwqh.top/article/info/27

如果文章有不足的地方,欢迎提点,后续会完善。

如果文章对您有帮助,请给我点个赞,请扫码关注下我的公众号,文章持续更新中...

查看原文

赞 0 收藏 0 评论 0

朝雾轻寒 发布了文章 · 2019-11-14

Spring Boot 2.X(十七):应用监控之 Spring Boot Admin 使用及配置

Admin 简介

Spring Boot Admin 是 Spring Boot 应用程序运行状态监控和管理的后台界面。最新UI使用vue.js重写里。

Spring Boot Admin 为已注册的应用程序提供了丰富的监控运维功能。如下:

  • 显示健康状况
  • 显示应用运行时的详细信息,如:JVM 和内存指标等
  • 计数器和测量指标
  • 数据源度量
  • 缓存度量
  • 跟踪和下载日志文件
  • 查看 jvm 系统和环境属性
  • 一键管理loglevel
  • 管理执行 JMX-beans
  • 查看线程转储
  • 查看跟踪信息
  • Hystrix-Dashboard集成(2.X版本已删除集成)
  • 下载 heapdump
  • 状态更改通知(支持:电子邮件、Slack、Hipchat等)
  • 状态更改事件日志(非永久性)

更多可以通过考文档详细了解。

Admin 使用及配置

Spring Boot Admin 服务端

项目依赖

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- admin-server -->
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-server</artifactId>
            <version>2.1.6</version>
        </dependency>

配置启动 Admin Server

@SpringBootApplication
@EnableAutoConfiguration
@EnableAdminServer
public class SpringBootAdminApplication {

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

}

application.properties 配置

server.port=9000
spring.application.name=Spring Boot Admin Web

测试

启动项目,通过浏览器访问 http://127.0.0.1:9000

Spring Boot Admin 客户端

这里以上面是 Spring Boot Actuator 项目为例

项目依赖

<!-- admin-client -->
        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-client</artifactId>
            <version>2.1.6</version>
        </dependency>

application.properties 配置

#设置 Admin Server 地址
server.port=8080
spring.application.name=Spring Boot Actuator Demo
spring.boot.admin.client.url=http://127.0.0.1:9000

测试

启动项目,通过浏览器访问 http://127.0.0.1:9000,我们会看到 Spring Boot Admin 的管理界面中 applications 会显示相应的客户端应用,点击应用进入详细的监控界面。


Spring Boot Admin 配置属性

Spring Boot Admin Server 配置属性详解

属性描述默认值
spring.boot.admin.context-path上下文路径在应为Admin Server的静态资产和API提供服务的路径的前面加上前缀。相对于Dispatcher-Servlet/
spring.boot.admin.monitor.status-interval更新client端状态的时间间隔,单位是毫秒10000
spring.boot.admin.monitor.status-lifetimeclient端状态的生命周期,该生命周期内不会更新client状态,单位是毫秒10000
spring.boot.admin.monitor.connect-timeout查询client端状态信息时的连接超时,单位是毫秒2000
spring.boot.admin.monitor.read-timeout查询client端状态信息时的读取超时时间,单位是毫秒10000
spring.boot.admin.monitor.default-retries失败请求的默认重试次数。Modyfing请求(PUT,POST,PATCH,DELETE)将永远不会重试0
spring.boot.admin.monitor.retries.*键值对,具有每个endpointId的重试次数。默认为默认重试。Modyfing请求(PUT,POST,PATCH,DELETE)将永远不会重试
spring.boot.admin.metadata-keys-to-sanitize要被过滤掉的元数据(当与正则表达式相匹配时,这些数据会在输出的json数据中过滤掉)".password$", ".*secret$", ".*key$", ".$token$", ".credentials.", ".*vcap_services$"
spring.boot.admin.probed-endpoints要获取的client的端点信息"health", "env", "metrics", "httptrace:trace", "threaddump:dump", "jolokia", "info", "logfile", "refresh", "flyway", "liquibase", "heapdump", "loggers", "auditevents"
spring.boot.admin.instance-proxy.ignored-headers向client发起请求时不会被转发的headers信息"Cookie", "Set-Cookie", "Authorization"
spring.boot.admin.ui.public-url用于在ui中构建基本href的基本URL如果在反向代理后面运行(使用路径重写),则可用于进行正确的自我引用。如果省略了主机/端口,将从请求中推断出来
spring.boot.admin.ui.brand导航栏中显示的品牌<img data-original="assets/img/icon-spring-boot-admin.svg"><span>Spring Boot Admin</span>
spring.boot.admin.ui.title页面标题"Spring Boot Admin"
spring.boot.admin.ui.favicon用作默认图标的图标,用于桌面通知的图标"assets/img/favicon.png"
spring.boot.admin.ui.favicon-danger当一项或多项服务关闭并用于桌面通知时,用作网站图标"assets/img/favicon-danger.png"

Spring Boot Admin Client 配置属性详解

属性描述默认值
spring.boot.admin.client.enabled启用Spring Boot Admin Clienttrue
spring.boot.admin.client.url要注册的server端的url地址。如果要同时在多个server端口注册,则用逗号分隔各个server端的url地址
spring.boot.admin.client.api-path管理服务器上注册端点的Http路径"instances"
spring.boot.admin.client.username如果server端需要进行认证时,该属性用于配置用户名
spring.boot.admin.client.password如果server端需要进行认证时,该属性用于配置密码
spring.boot.admin.client.period重复注册的时间间隔(以毫秒为单位)10000
spring.boot.admin.client.connect-timeout连接注册的超时时间(以毫秒为单位)5000
spring.boot.admin.client.read-timeout读取注册超时(以毫秒为单位)5000
spring.boot.admin.client.auto-registration如果设置为true,则在应用程序准备就绪后会自动安排注册应用程序的定期任务true
spring.boot.admin.client.auto-deregistration当上下文关闭时,切换为在Spring Boot Admin服务器上启用自动解密。如果未设置该值,并且在检测到正在运行的CloudPlatform时,该功能处于活动状态null
spring.boot.admin.client.register-once如果设置为true,则客户端将仅向一台管理服务器注册(由定义spring.boot.admin.instance.url);如果该管理服务器出现故障,将自动向下一个管理服务器注册。如果为false,则会向所有管理服务器注册true
spring.boot.admin.client.instance.health-url要注册的health-url地址。如果可访问URL不同(例如Docker),则可以覆盖。在注册表中必须唯一默认该属性值与management-url 以及endpoints.health.id有关。比如工程中该值为:healthUrl=http://127.0.0.1:8080/actuator/health,其中http://127.0.0.1:8080/actuator是management-url,health是endpoints.health.id
spring.boot.admin.client.instance.management-base-url用于计算要注册的管理URL的基本URL。该路径是在运行时推断的,并附加到基本URL默认该属性值与management.port, service-url 以及server.servlet-path有关,如工程中该值为http://127.0.0.1:8080,其中8080端口是配置的获取actuator信息的端口。127.0.0.1是设置的service-url值,如果没有设置service-url的话,则为配置的server.servlet-path值(项目的启动路径)
spring.boot.admin.client.instance.management-url要注册的management-url。如果可访问的URL不同(例如Docker),则可以覆盖默认该属性值与management-base-url 和 management.context-path两个属性值有关,如 managementUrl=http://127.0.0.1:8080/actuator,其中http://127.0.0.1:8080为management-base-url,/actuator是management.context-path
spring.boot.admin.client.instance.service-base-url用于计算要注册的服务URL的基本URL。该路径是在运行时推断的,并附加到基本URL默认该属性值与hostname, server.port有关,如http://127.0.0.1:8080,其中8080端口是配置的server.port。127.0.0.1是client所在服务器的hostname
spring.boot.admin.client.instance.service-url要注册的服务网址。如果可访问的URL不同(例如Docker),则可以覆盖默认值是基于service-base-url 和 server.context-path进行赋值
spring.boot.admin.client.instance.name要注册的名称默认值是配置的spring.application.name的值,如果没有配置该属性的话,默认值是spring-boot-application
spring.boot.admin.client.instance.prefer-ip在猜测的网址中使用ip地址而不是主机名。如果设置了server.address/ management.address,它将被使用。否则,InetAddress.getLocalHost()将使用从返回的IP地址false
spring.boot.admin.client.instance.metadata.*要与此实例相关联的元数据键值对
spring.boot.admin.client.instance.metadata.tags.*标记作为要与此实例相关联的键值对

示例代码

github

码云

文档参考

https://codecentric.github.io...

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十七):应用监控之 Spring Boot Admin 使用及配置

原文地址: https://www.zwqh.top/article/info/26

如果文章对您有帮助,请扫码关注下我的公众号,文章持续更新中...

查看原文

赞 0 收藏 0 评论 0

朝雾轻寒 发布了文章 · 2019-11-13

Spring Boot 2.X(十六):应用监控之 Spring Boot Actuator 使用及配置

Actuator 简介

Actuator 是 Spring Boot 提供的对应用系统的自省和监控功能。通过 Actuator,可以使用数据化的指标去度量应用的运行情况,比如查看服务器的磁盘、内存、CPU等信息,系统的线程、gc、运行状态等等。

Actuator 通常通过使用 HTTP 和 JMX 来管理和监控应用,大多数情况使用 HTTP 的方式。

Actuator 端点说明

端点描述
auditevents获取当前应用暴露的审计事件信息
beans获取应用中所有的 Spring Beans 的完整关系列表
caches获取公开可以用的缓存
conditions获取自动配置条件信息,记录哪些自动配置条件通过和没通过的原因
configprops获取所有配置属性,包括默认配置,显示一个所有 @ConfigurationProperties 的整理列版本
env获取所有环境变量
flyway获取已应用的所有Flyway数据库迁移信息,需要一个或多个 Flyway Bean
liquibase获取已应用的所有Liquibase数据库迁移。需要一个或多个 Liquibase Bean
health获取应用程序健康指标(运行状况信息)
httptrace获取HTTP跟踪信息(默认情况下,最近100个HTTP请求-响应交换)。需要 HttpTraceRepository Bean
info获取应用程序信息
integrationgraph显示 Spring Integration 图。需要依赖 spring-integration-core
loggers显示和修改应用程序中日志的配置
logfile返回日志文件的内容(如果已设置logging.file.name或logging.file.path属性)
metrics获取系统度量指标信息
mappings显示所有@RequestMapping路径的整理列表
scheduledtasks显示应用程序中的计划任务
sessions允许从Spring Session支持的会话存储中检索和删除用户会话。需要使用Spring Session的基于Servlet的Web应用程序
shutdown关闭应用,要求endpoints.shutdown.enabled设置为true,默认为 false
threaddump获取系统线程转储信息
heapdump返回hprof堆转储文件
jolokia通过HTTP公开JMX bean(当Jolokia在类路径上时,不适用于WebFlux)。需要依赖 jolokia-core
prometheus以Prometheus服务器可以抓取的格式公开指标。需要依赖 micrometer-registry-prometheus

Actuator 使用及配置

快速使用

项目依赖

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

配置文件

management.endpoints.enabled-by-default=true
#启动所有端点
management.endpoints.web.exposure.include=*
#自定义管理端点路径
#management.endpoints.web.base-path=/manage

Spring Boot 2.X 中,Actuator 默认只开放 health 和 info 两个端点。

添加management.endpoints.web.exposure.include=*配置后启动应用,访问 http://127.0.0.1:8080/actuator 我们可以看到所有的 Actuator 端点列表。

如果将management.endpoints.enabled-by-default设置为false,则禁用所有端点,如需启用则如下:

management.endpoints.enabled-by-default=false
management.endpoint.info.enabled=true
禁用的端点将从应用程序上下文中完全删除。如果只想更改公开端点,使用include和exclude属性。使用如下:
management.endpoints.web.exposure.include=*
management.endpoints.web.exposure.exclude=env,beans

management.endpoints.web.base-path=/manage 配置表示将 /actuator 路径重定义为 /manage。

常用端点详解

health

主要用来检测应用的运行状况,是使用最多的一个监控点。监控软件通常使用该接口实时监测应用运行状况,在系统出现故障时把报警信息推送给相关人员,如磁盘空间使用情况、数据库和缓存等的一些健康指标。
默认情况下 health 端点是开放的,访问 http://127.0.0.1:8080/actuator/health 即可看到应用运行状态。

{"status":"UP"}

如果需要看到详细信息,则需要做添加配置:

management.endpoint.health.show-details=always

访问返回信息如下:

{"status":"UP","details":{"diskSpace":{"status":"UP","details":{"total":180002725888,"free":8687988736,"threshold":10485760}}}}

info

查看应用信息是否在 application.properties 中配置。如我们在项目中配置是:

info.app.name=Spring Boot Actuator Demo
info.app.version=v1.0.0
info.app.description=Spring Boot Actuator Demo

启动项目,访问 http://127.0.0.1:8080/actuator/info 返回信息如下:

{"app":{"name":"Spring Boot Actuator Demo","version":"v1.0.0","description":"Spring Boot Actuator Demo"}}

env

通过 env 可以获取到所有关于当前 Spring Boot 应用程序的运行环境信息,如:操作系统信息(systemProperties)、环境变量信息、JDK 版本及 ClassPath 信息、当前启用的配置文件(activeProfiles)、propertySources、应用程序配置信息(applicationConfig)等。

可以通过 http://127.0.0.1:8080/actuator/env/{name} ,name表示想要查看的信息,可以独立显示。

beans

访问 http://127.0.0.1:8080/actuator/beans 返回部分信息如下:

{
    "contexts": {
        "Spring Boot Actuator Demo": {
            "beans": {
                "endpointCachingOperationInvokerAdvisor": {
                    "aliases": [
                    ],
                    "scope": "singleton",
                    "type": "org.springframework.boot.actuate.endpoint.invoker.cache.CachingOperationInvokerAdvisor",
                    "resource": "class path resource [org/springframework/boot/actuate/autoconfigure/endpoint/EndpointAutoConfiguration.class]",
                    "dependencies": [
                        "environment"
                    ]
                },
                "defaultServletHandlerMapping": {
                    "aliases": [
                    ],
                    "scope": "singleton",
                    "type": "org.springframework.web.servlet.HandlerMapping",
                    "resource": "class path resource [org/springframework/boot/autoconfigure/web/servlet/WebMvcAutoConfiguration$EnableWebMvcConfiguration.class]",
                    "dependencies": [
                    ]
                },
                ...
            }
        }
    }
}

从返回的信息中我们可以看出主要展示了 bean 的别名、类型、是否单例、类的地址、依赖等信息。

conditions

通过 conditions 可以在应用运行时查看代码了某个配置在什么条件下生效,或者某个自动配置为什么没有生效。

访问 http://127.0.0.1:8080/actuator/conditions 返回部分信息如下:

{
    "contexts": {
        "Spring Boot Actuator Demo": {
            "positiveMatches": {
                "SpringBootAdminClientAutoConfiguration": [
                    {
                        "condition": "OnWebApplicationCondition",
                        "message": "@ConditionalOnWebApplication (required) found 'session' scope"
                    },
                    {
                        "condition": "SpringBootAdminClientEnabledCondition",
                        "message": "matched"
                    }
                ],
                "SpringBootAdminClientAutoConfiguration#metadataContributor": [
                    {
                        "condition": "OnBeanCondition",
                        "message": "@ConditionalOnMissingBean (types: de.codecentric.boot.admin.client.registration.metadata.CompositeMetadataContributor; SearchStrategy: all) did not find any beans"
                    }
                ],
                ...
            }
        }
    }
}

loggers

获取系统的日志信息。

访问 http://127.0.0.1:8080/actuator/loggers 返回部分信息如下:

{
    "levels": [
        "OFF",
        "ERROR",
        "WARN",
        "INFO",
        "DEBUG",
        "TRACE"
    ],
    "loggers": {
        "ROOT": {
            "configuredLevel": "INFO",
            "effectiveLevel": "INFO"
        },
        "cn": {
            "configuredLevel": null,
            "effectiveLevel": "INFO"
        },
        "cn.zwqh": {
            "configuredLevel": null,
            "effectiveLevel": "INFO"
        },
        "cn.zwqh.springboot": {
            "configuredLevel": null,
            "effectiveLevel": "INFO"
        },
        ...
    }
}

mappings

查看所有 URL 映射,即所有 @RequestMapping 路径的整理列表。

访问 http://127.0.0.1:8080/actuator/mappings 返回部分信息如下:

{
    "contexts": {
        "Spring Boot Actuator Demo": {
            "mappings": {
                "dispatcherServlets": {
                    "dispatcherServlet": [
                        {
                            "handler": "ResourceHttpRequestHandler [class path resource [META-INF/resources/], class path resource [resources/], class path resource [static/], class path resource [public/], ServletContext resource [/], class path resource []]",
                            "predicate": "/**/favicon.ico",
                            "details": null
                        },
                        ...
                    ]
                }
            }
        }
    }
}

heapdump

访问:http://127.0.0.1:8080/actuator/heapdump会自动生成一个 GZip 压缩的 Jvm 的堆文件 heapdump,我们可以使用 JDK 自带的 Jvm 监控工具 VisualVM 打开此文件查看。如图:

VisualVM下载:https://visualvm.github.io/do...

threaddump

获取系统线程的转储信息,主要展示了线程名、线程ID、线程的状态、是否等待锁资源等信息。在工作中,我们可以通过查看线程的情况来排查相关问题。

访问 http://127.0.0.1:8080/actuator/threaddump 返回部分信息如下:

{
    "threads": [
        {
            "threadName": "DestroyJavaVM",
            "threadId": 40,
            "blockedTime": -1,
            "blockedCount": 0,
            "waitedTime": -1,
            "waitedCount": 0,
            "lockName": null,
            "lockOwnerId": -1,
            "lockOwnerName": null,
            "inNative": false,
            "suspended": false,
            "threadState": "RUNNABLE",
            "stackTrace": [
            ],
            "lockedMonitors": [
            ],
            "lockedSynchronizers": [
            ],
            "lockInfo": null
        },
        ...
    ]
}

shutdown

开启可以接口关闭 Spring Boot 应用,要使用这个功能需要做如下配置:

management.endpoint.shutdown.enabled=true

可以通过 post(仅支持 post) 请求访问 http://127.0.0.1:8080/actuator/shutdown 关闭应用。

metrics

访问 http://127.0.0.1:8080/actuator/metrics 可以获取系统度量指标信息项如下:

{
    "names": [
        "jvm.memory.max",
        "jvm.threads.states",
        "jvm.gc.pause",
        "http.server.requests",
        "process.files.max",
        "jvm.gc.memory.promoted",
        "system.load.average.1m",
        "jvm.memory.used",
        "jvm.gc.max.data.size",
        "jvm.memory.committed",
        "system.cpu.count",
        "logback.events",
        "tomcat.global.sent",
        "jvm.buffer.memory.used",
        "tomcat.sessions.created",
        "jvm.threads.daemon",
        "system.cpu.usage",
        "jvm.gc.memory.allocated",
        "tomcat.global.request.max",
        "tomcat.global.request",
        "tomcat.sessions.expired",
        "jvm.threads.live",
        "jvm.threads.peak",
        "tomcat.global.received",
        "process.uptime",
        "tomcat.sessions.rejected",
        "process.cpu.usage",
        "tomcat.threads.config.max",
        "jvm.classes.loaded",
        "jvm.classes.unloaded",
        "tomcat.global.error",
        "tomcat.sessions.active.current",
        "tomcat.sessions.alive.max",
        "jvm.gc.live.data.size",
        "tomcat.threads.current",
        "process.files.open",
        "jvm.buffer.count",
        "jvm.buffer.total.capacity",
        "tomcat.sessions.active.max",
        "tomcat.threads.busy",
        "process.start.time"
    ]
}

对应访问 names 中的指标,可以查看具体的指标信息。如访问 http://127.0.0.1:8080/actuator/metrics/jvm.memory.used 返回信息如下:

{
    "name": "jvm.memory.used",
    "description": "The amount of used memory",
    "baseUnit": "bytes",
    "measurements": [
        {
            "statistic": "VALUE",
            "value": 1.16828136E8
        }
    ],
    "availableTags": [
        {
            "tag": "area",
            "values": [
                "heap",
                "nonheap"
            ]
        },
        {
            "tag": "id",
            "values": [
                "Compressed Class Space",
                "PS Survivor Space",
                "PS Old Gen",
                "Metaspace",
                "PS Eden Space",
                "Code Cache"
            ]
        }
    ]
}

示例代码

github

码云

参考文档

https://docs.spring.io/spring...

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十六):应用监控之 Spring Boot Actuator 使用及配置

原文地址: https://www.zwqh.top/article/info/25

如果文章对您有帮助,请扫码关注下我的公众号,文章持续更新中...

查看原文

赞 0 收藏 0 评论 0

朝雾轻寒 发布了文章 · 2019-11-07

Spring Boot 2.X(十五):集成 Swagger2 开发 API 文档(在线+离线)

前言

相信很多后端开发在项目中都会碰到要写 api 文档,不管是给前端、移动端等提供更好的对接,还是以后为了以后交接方便,都会要求写 api 文档。

而手写 api 文档的话有诸多痛点:

  • 文档更新的时候,需要再次发送给对接人
  • 接口太对,手写文档很难管理
  • 接口返回的结果不明确
  • 不能直接在线测试接口,通常需要使用工具,如 postman 等

Swagger 就很好的解决了这个问题。

Swagger 简介

Swagger 是一个规范和完整的框架,用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。总体目标是使客户端和文件系统作为服务器以同样的速度来更新。文件的方法,参数和模型紧密集成到服务器端的代码,允许API来始终保持同步。

官网:https://swagger.io

Swagger 使用

1.相关依赖

<!--swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

2.Swagger 配置类

@Configuration
@EnableSwagger2
public class SwaggerConfig {
    @Bean
    public Docket buildDocket() {
        return new Docket(DocumentationType.SWAGGER_2)
        .apiInfo(buildApiInf()) //将api的元信息设置为包含在json resourcelisting响应中
        //.host("127.0.0.1:8080") //设置ip和端口,或者域名
        .select()  //启动用于api选择的生成器
        //.apis(RequestHandlerSelectors.any())
        .apis(RequestHandlerSelectors.basePackage("cn.zwqh.springboot.controller"))//指定controller路径
        .paths(PathSelectors.any()).build();
    }

    private ApiInfo buildApiInf() {
        
        Contact contact=new Contact("朝雾轻寒","https://www.zwqh.top/","zwqh@clover1314.com");
        return new ApiInfoBuilder()
        .title("Swagger Demo Restful API Docs")//文档标题
        .description("Swagger 示例 Restful Api 文档")//文档描述
        .contact(contact)//联系人
        .version("1.0")//版本号
        //.license("")//更新此API的许可证信息
        //.licenseUrl("")//更新此API的许可证Url
        //.termsOfServiceUrl("")//更新服务条款URL
        .build();

    }
}

3.Spring MVC 相关配置

@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {
    /**
     * 静态资源配置(默认)
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/**").addResourceLocations("classpath:/static/");// 静态资源路径
        registry.addResourceHandler("swagger-ui.html").addResourceLocations("classpath:/META-INF/resources/");
        registry.addResourceHandler("/webjars/**").addResourceLocations("classpath:/META-INF/resources/webjars/");
        super.addResourceHandlers(registry);
    }


}
如果不添加此静态资源配置会报错,找不到相关路径

4.Model 中使用 Swagger 注解

@ApiModel(value = "UserEntity", description = "用户对象")
public class UserEntity implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 5237730257103305078L;
    @ApiModelProperty(value ="用户id",name="id",dataType="Long",required = false,example = "1",hidden = false )
    private Long id;
    @ApiModelProperty(value ="用户名",name="userName",dataType="String",required = false,example = "关羽" )
    private String userName;
    @ApiModelProperty(value ="用户性别",name="userSex",dataType="String",required = false,example = "男" )
    private String userSex;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserSex() {
        return userSex;
    }

    public void setUserSex(String userSex) {
        this.userSex = userSex;
    }

}

5. Controller 中使用 Swagger 注解


@RestController
@RequestMapping("/api")
@Api(tags = { "接口分组1", "接口分组2" })
public class ApiController {

    @Autowired
    private UserDao userDao;

    @GetMapping("/getAllUser")
    @ApiOperation(value = "获取所有用户", notes = "", httpMethod = "GET", tags = "接口分组3")
    public List<UserEntity> getAll() {
        return userDao.getAll();
    }

    @GetMapping("/getUserById")
    @ApiOperation(value = "根据id获取用户", notes = "id必传", httpMethod = "GET")
    @ApiImplicitParam(name = "id", value = "用户id",example = "1", required = true, dataType = "long", paramType = "query")
    public UserEntity getOne(Long id) {
        return userDao.getOne(id);
    }

    @PostMapping("/getUserByNameAndSex")
    @ApiOperation(value = "根据name和sex获取用户", notes = "", httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "userName", value = "用户名", example = "关羽", required = true, dataType = "string", paramType = "query"),
            @ApiImplicitParam(name = "userSex", value = "用户性别", example = "男", required = true, dataType = "string", paramType = "query") })
    public UserEntity getUserByNameAndSex(String userName, String userSex) {
        return userDao.getUserByNameAndSex(userName, userSex);
    }

    @PostMapping("/insertUser")
    @ApiOperation(value = "新增用户", notes = "传json,数据放body", httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "body", value = "用户对象json", example = "{userName:'朝雾轻寒',userSex:'男'}", required = true) })
    public String insertUser(@RequestBody String body) {
        System.out.println(body);
        UserEntity user = JSON.parseObject(body, UserEntity.class);
        userDao.insertUser(user);
        return "{code:0,msg:'success'}";
    }

    @PostMapping("/updateUser")
    @ApiOperation(value = "修改用户", notes = "传json,数据放body", httpMethod = "POST")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "body", value = "用户对象json", example = "{id:23,userName:'朝雾轻寒',userSex:'女'}", required = true) })
    public String updateUser(@RequestBody String body) {
        System.out.println(body);
        UserEntity user = JSON.parseObject(body, UserEntity.class);
        userDao.updateUser(user);
        return "{code:0,msg:'success'}";
    }

    @PostMapping("/deleteUser")
    @ApiOperation(value = "删除用户", notes = "id必传", httpMethod = "POST")
    public String deleteUser(@ApiParam(name = "id", value = "用户id", required = true) Long id) {
        userDao.deleteUser(id);
        return "{code:0,msg:'success'}";
    }
}

5.测试

访问 http://127.0.0.1:8080/swagger-ui.html 进行接口在线测试

Swagger 常用注解

1.@Api

用于类,表示标识这个类是swagger的资源。属性如下:

  • tags 表示说明,tags如果有多个值,会生成多个列表
  • value 表示说明,可以使用tags替代

2.@ApiOperation

用于方法,表示一个http请求的操作。属性如下:

  • value 用于方法描述
  • notes 用于提示内容
  • tags 用于API文档控制的标记列表,视情况而用,可以进行独立分组

3.@ApiParam

用于方法、参数、字段说明;表示对参数的添加元数据。

  • name 参数名
  • value 参数说明
  • required 是否必填

4.@ApiModel

用于类,表示对类进行说明,用于参数用实体类接受。

  • value 对象名
  • description 描述

5.@ApiModelProperty

用于方法、字段,表示对model属性的说明或者数据操作更改。

  • value 字段说明
  • name 重写属性名
  • dataType 重写属性数据类型
  • required 是否必填
  • example 举例说明
  • hidden 隐藏

6.@ApiIgnore

用于类、方法、方法参数,表示这个方法或者类被忽略,不在swagger-ui.html上显示。

7.@ApiImplicitParam

用于方法,表示单独的请求参数。

  • name 参数名
  • value 参数说明
  • dataType 数据类型
  • paramType 参数类型
  • example 举例说明

8.@ApiImplicitParams

用于方法,包含多个 @ApiImplicitParam。

9.@ApiResponses @ApiResponse

用于类或者方法,描述操作的可能响应。

  • code 响应的HTTP状态代码
  • message 响应附带的可读消息

10.@ResponseHeader

用于方法,响应头设置。

  • name 响应头名称
  • description 头描述
  • response 默认响应类 void
  • responseContainer 参考ApiOperation中配置

Swagger 导出离线 api 文档

1.导出 AsciiDocs、Markdown、Confluence 格式文档

添加依赖

<!-- swagger2markup 相关依赖 -->
        <dependency>
            <groupId>io.github.swagger2markup</groupId>
            <artifactId>swagger2markup</artifactId>
            <version>1.3.3</version>
        </dependency>

转换工具类

public class SwaggerUtils {

    private static final String url = "http://127.0.0.1:8080/v2/api-docs";
    /**
     * 生成AsciiDocs格式文档
     * @throws MalformedURLException
     */
    public static void generateAsciiDocs() throws MalformedURLException {
        Swagger2MarkupConfig config = new Swagger2MarkupConfigBuilder()
                .withMarkupLanguage(MarkupLanguage.ASCIIDOC)
                .withOutputLanguage(Language.ZH)
                .withPathsGroupedBy(GroupBy.TAGS)
                .withGeneratedExamples()
                .withoutInlineSchema().build();

        Swagger2MarkupConverter.from(new URL(url))
                .withConfig(config)
                .build()
                .toFolder(Paths.get("./docs/asciidoc/generated"));
    }
    /**
     * 生成AsciiDocs格式文档,并汇总成一个文件
     * @throws MalformedURLException
     */
    public static void generateAsciiDocsToFile() throws MalformedURLException {
        Swagger2MarkupConfig config = new Swagger2MarkupConfigBuilder()
                .withMarkupLanguage(MarkupLanguage.ASCIIDOC)
                .withOutputLanguage(Language.ZH)
                .withPathsGroupedBy(GroupBy.TAGS)
                .withGeneratedExamples()
                .withoutInlineSchema()
                .build();

        Swagger2MarkupConverter.from(new URL(url))
                .withConfig(config)
                .build()
                .toFile(Paths.get("./docs/asciidoc/generated/all"));
    }
    
    /**
     * 生成Markdown格式文档
     * @throws MalformedURLException
     */
    public static void generateMarkdownDocs() throws MalformedURLException {
        Swagger2MarkupConfig config = new Swagger2MarkupConfigBuilder()
                .withMarkupLanguage(MarkupLanguage.MARKDOWN)
                .withOutputLanguage(Language.ZH)
                .withPathsGroupedBy(GroupBy.TAGS)
                .withGeneratedExamples()
                .withoutInlineSchema()
                .build();

        Swagger2MarkupConverter.from(new URL(url))
                .withConfig(config)
                .build()
                .toFolder(Paths.get("./docs/markdown/generated"));
    }
    /**
     * 生成Markdown格式文档,并汇总成一个文件
     * @throws MalformedURLException
     */
    public static void generateMarkdownDocsToFile() throws MalformedURLException {
        Swagger2MarkupConfig config = new Swagger2MarkupConfigBuilder()
                .withMarkupLanguage(MarkupLanguage.MARKDOWN)
                .withOutputLanguage(Language.ZH)
                .withPathsGroupedBy(GroupBy.TAGS)
                .withGeneratedExamples()
                .withoutInlineSchema()
                .build();

        Swagger2MarkupConverter.from(new URL(url))
                .withConfig(config)
                .build()
                .toFile(Paths.get("./docs/markdown/generated/all"));
    }
    
    /**
     * 生成Confluence格式文档
     * @throws MalformedURLException
     */
    public static void generateConfluenceDocs() throws MalformedURLException {
        Swagger2MarkupConfig config = new Swagger2MarkupConfigBuilder()
                .withMarkupLanguage(MarkupLanguage.CONFLUENCE_MARKUP)
                .withOutputLanguage(Language.ZH)
                .withPathsGroupedBy(GroupBy.TAGS)
                .withGeneratedExamples()
                .withoutInlineSchema()
                .build();

        Swagger2MarkupConverter.from(new URL(url))
                .withConfig(config)
                .build()
                .toFolder(Paths.get("./docs/confluence/generated"));
    }
    
    /**
     * 生成Confluence格式文档,并汇总成一个文件
     * @throws MalformedURLException
     */
    public static void generateConfluenceDocsToFile() throws MalformedURLException {
        Swagger2MarkupConfig config = new Swagger2MarkupConfigBuilder()
                .withMarkupLanguage(MarkupLanguage.CONFLUENCE_MARKUP)
                .withOutputLanguage(Language.ZH)
                .withPathsGroupedBy(GroupBy.TAGS)
                .withGeneratedExamples()
                .withoutInlineSchema()
                .build();

        Swagger2MarkupConverter.from(new URL(url))
                .withConfig(config)
                .build()
                .toFile(Paths.get("./docs/confluence/generated/all"));
    }
    
    
}

使用测试 Controller

@RestController
@RequestMapping("/export")
@ApiIgnore
public class ExportController {

    
    @RequestMapping("/ascii")
    public String exportAscii() throws MalformedURLException{
        SwaggerUtils.generateAsciiDocs();
        return "success";
    }
    
    @RequestMapping("/asciiToFile")
    public String asciiToFile() throws MalformedURLException{
        SwaggerUtils.generateAsciiDocsToFile();
        return "success";
    }
    
    @RequestMapping("/markdown")
    public String exportMarkdown() throws MalformedURLException{
        SwaggerUtils.generateMarkdownDocs();
        return "success";
    }
    
    @RequestMapping("/markdownToFile")
    public String exportMarkdownToFile() throws MalformedURLException{
        SwaggerUtils.generateMarkdownDocsToFile();
        return "success";
    }
    
    @RequestMapping("/confluence")
    public String confluence() throws MalformedURLException{
        SwaggerUtils.generateConfluenceDocs();
        return "success";
    }
    
    @RequestMapping("/confluenceToFile")
    public String confluenceToFile() throws MalformedURLException{
        SwaggerUtils.generateConfluenceDocsToFile();
        return "success";
    }
}

2.导出 html、pdf、xml 格式

添加依赖

<!--离线文档 -->
        <dependency>
            <groupId>org.springframework.restdocs</groupId>
            <artifactId>spring-restdocs-mockmvc</artifactId>
            <scope>test</scope>
        </dependency>
        <!--springfox-staticdocs 生成静态文档 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-staticdocs</artifactId>
            <version>2.6.1</version>
        </dependency>
<build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
                <plugin>
                    <groupId>io.github.swagger2markup</groupId>
                    <artifactId>swagger2markup-maven-plugin</artifactId>
                    <version>1.3.1</version>
                    <configuration>
                        <swaggerInput>http://127.0.0.1:8080/v2/api-docs</swaggerInput>
                        <outputDir>./docs/asciidoc/generated</outputDir>
                        <config>
                            <swagger2markup.markupLanguage>ASCIIDOC</swagger2markup.markupLanguage>
                        </config>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.asciidoctor</groupId>
                    <artifactId>asciidoctor-maven-plugin</artifactId>
                    <version>1.5.3</version>
                    <!-- <version>2.0.0-RC.1</version> -->
                    <!-- Include Asciidoctor PDF for pdf generation -->
                    <dependencies>
                        <dependency>
                            <groupId>org.asciidoctor</groupId>
                            <artifactId>asciidoctorj-pdf</artifactId>
                            <version>1.5.0-alpha.10.1</version>
                        </dependency>
                        <dependency>
                            <groupId>org.jruby</groupId>
                            <artifactId>jruby-complete</artifactId>
                            <version>1.7.21</version>
                        </dependency>
                    </dependencies>
                    <configuration>
                        <sourceDirectory>./docs/asciidoc/generated</sourceDirectory>
                        <outputDirectory>./docs/asciidoc/html</outputDirectory> 
                        <backend>html</backend>
                        <!-- <outputDirectory>./docs/asciidoc/pdf</outputDirectory> 
                        <backend>pdf</backend> -->
                        <headerFooter>true</headerFooter> 
                        <doctype>book</doctype> 
                        <sourceHighlighter>coderay</sourceHighlighter>
                        <attributes>
                            <!-- 菜单栏在左边 -->
                            <toc>left</toc>
                            <!-- 多标题排列 -->
                            <toclevels>3</toclevels>
                            <!-- 自动打数字序号 -->
                            <sectnums>true</sectnums>
                        </attributes>
                    </configuration>                    
                </plugin>
            </plugins>
        </pluginManagement>

    </build>

可以修改此处 html 和 pdf,通过 mvn asciidoctor:process-asciidoc 可以导出相应格式文件

<outputDirectory>./docs/asciidoc/html</outputDirectory> 
                        <backend>html</backend>

执行 mvn asciidoctor:process-asciidoc 后再执行 mvn generate-resources,可在 targt/generated-docs 目录下生成 xml 格式文件。

完整代码

github

码云

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十五):集成 Swagger2 开发 API 文档(在线+离线)

原文地址: https://www.zwqh.top/article/info/24

如果文章对您有帮助,请扫码关注下我的公众号,文章持续更新中...

查看原文

赞 1 收藏 1 评论 0

朝雾轻寒 发布了文章 · 2019-11-07

Spring Boot 2.X(十四):日志功能 Logback

Logback 简介

Logback 是由 SLF4J 作者开发的新一代日志框架,用于替代 log4j。

主要特点是效率更高,架构设计够通用,适用于不同的环境。

Logback 分为三个模块:logback-core,logback-classic和logback-access。

logback-core 模块是其他两个模块的基础。

logback-classic 模块是 core 的扩展,是log4j的改进版。logback-classic 本身实现了 SLF4J API,因此可以很容易的在 logback 和其他日志框架之间来回切换,例如 log4j、java.util.logging(JUL)。

logback-access 模块集成了 Servlet 容器,提供了 HTTP 访问日志的功能。

官网:http://logback.qos.ch

中文网:http://www.logback.cn

github:https://github.com/qos-ch/log...

Logback 使用

1.使用 logback-spring.xml 配置

<?xml version="1.0" encoding="UTF-8"?>
<!-- 日志级别从低到高分为TRACE < DEBUG < INFO < WARN < ERROR < FATAL,如果设置为WARN,则低于WARN的信息都不会输出 -->
<!-- scan:当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。 -->
<!-- scanPeriod:设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。 -->
<!-- debug:当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。 -->
<configuration scan="true" scanPeriod="60 seconds" debug="false">
    <!-- 定义日志根目录 -->
    <property name="LOG_PATH" value="/usr/local/log/" />
    <!-- 定义应用名称 -->
    <property name="APP_NAME" value="springboot-logback" />
    <!-- 应用名称 -->
    <contextName>${APP_NAME}</contextName>
    <!-- 引用 Spring Boot 中默认的 logback 配置 -->
    <!-- <include resource="org/springframework/boot/logging/logback/base.xml" /> -->
    <!-- 可以动态修改日志输出等级 -->
    <jmxConfigurator />
        
     <!--输出到控制台-->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用,只配置最底级别,控制台输出的日志级别是大于或等于此级别的日志信息-->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
        <encoder>
            <pattern>%d [%t] %5p %c:%L - %m%n</pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
     <!-- 时间滚动输出 level为 INFO 日志 -->
    <appender name="INFO_FILE"
        class="ch.qos.logback.core.rolling.RollingFileAppender">
        <File>${LOG_PATH}${APP_NAME}-info.log</File>
        <encoder>
            <pattern>%d [%t] %5p %c:%L - %m%n</pattern>
        </encoder>
        <!-- 日志记录器的滚动策略,按日期,按大小记录,日志按天分类压缩保存-->
        <rollingPolicy
            class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <timeBasedFileNamingAndTriggeringPolicy
                class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <FileNamePattern>${LOG_PATH}${APP_NAME}/info/%d{yyyy-MM-dd}-%i.log.gz
            </FileNamePattern>
             <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
    </appender>
    <!-- 时间滚动输出 level为 ERROR 日志 -->
    <appender name="ERROR_FILE"
        class="ch.qos.logback.core.rolling.RollingFileAppender">
        <File>${LOG_PATH}${APP_NAME}-error.log</File>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>error</level>
        </filter>
        <encoder>
            <pattern>%d [%t] %5p %c:%L - %m%n</pattern>
        </encoder>
        <!-- 日志记录器的滚动策略,按日期,按大小记录,日志按天分类压缩保存-->
        <rollingPolicy
            class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <timeBasedFileNamingAndTriggeringPolicy
                class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>256MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <FileNamePattern>${LOG_PATH}${APP_NAME}/error/%d{yyyy-MM-dd}-%i.log.gz
            </FileNamePattern>
             <!--日志文件保留天数-->
            <MaxHistory>30</MaxHistory>
        </rollingPolicy>
    </appender>
    <!-- 设置需要打印日志的包及输出级别 -->
    <logger name="org.springframework.web" level="INFO" />
    <logger name="cn.zwqh.springboot.controller" level="TRACE" />
    <!--
        使用mybatis的时候,sql语句只有在 debug 级别下才会打印
     -->
    <logger name="cn.zwqh.springboot.dao" level="debug" />

    <!--
        root节点是必选节点,用来指定最基础的日志输出级别,只有一个level属性
        level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,
        不能设置为INHERITED或者同义词NULL。默认是DEBUG
        可以包含零个或多个元素,标识这个appender将会添加到这个logger。
    -->
    <root level="info">
        <appender-ref ref="CONSOLE" />
        <appender-ref ref="INFO_FILE" />
        <appender-ref ref="ERROR_FILE" />
    </root>
</configuration>

2.使用 logback.groovy 配置

使用 groovy 配置需要添加依赖
 <dependency>
            <groupId>org.codehaus.groovy</groupId>
            <artifactId>groovy-all</artifactId>
            <version>2.4.17</version>
        </dependency>
import ch.qos.logback.classic.encoder.PatternLayoutEncoder
import ch.qos.logback.classic.filter.ThresholdFilter
import ch.qos.logback.core.ConsoleAppender
import ch.qos.logback.core.rolling.RollingFileAppender
import ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP
import ch.qos.logback.core.rolling.TimeBasedRollingPolicy
import java.nio.charset.Charset

import static ch.qos.logback.classic.Level.DEBUG
import static ch.qos.logback.classic.Level.ERROR
import static ch.qos.logback.classic.Level.INFO
import static ch.qos.logback.classic.Level.TRACE

scan("60 seconds")
def LOG_PATH = "/usr/local/log/"
def APP_NAME = "springboot-logback"
context.name = "${APP_NAME}"
jmxConfigurator()
appender("CONSOLE", ConsoleAppender) {
  filter(ThresholdFilter) {
    level = DEBUG
  }
  encoder(PatternLayoutEncoder) {
    pattern = "%d [%t] %5p %c:%L - %m%n"
    charset = Charset.forName("UTF-8")
  }
}
appender("INFO_FILE", RollingFileAppender) {
  file = "${LOG_PATH}${APP_NAME}-info.log"
  encoder(PatternLayoutEncoder) {
    pattern = "%d [%t] %5p %c:%L - %m%n"
    charset = Charset.forName("UTF-8")
  }
  rollingPolicy(TimeBasedRollingPolicy) {
    timeBasedFileNamingAndTriggeringPolicy(SizeAndTimeBasedFNATP) {
      maxFileSize = "100MB"
    }
    fileNamePattern = "${LOG_PATH}${APP_NAME}/info/%d{yyyy-MM-dd}-%i.log.gz"
    maxHistory = 30
  }
}
appender("ERROR_FILE", RollingFileAppender) {
  file = "${LOG_PATH}${APP_NAME}-error.log"
  filter(ThresholdFilter) {
    level = ERROR
  }
  encoder(PatternLayoutEncoder) {
    pattern = "%d [%t] %5p %c:%L - %m%n"
    charset = Charset.forName("UTF-8")
  }
  rollingPolicy(TimeBasedRollingPolicy) {
    timeBasedFileNamingAndTriggeringPolicy(SizeAndTimeBasedFNATP) {
      maxFileSize = "256MB"
    }
    fileNamePattern = "${LOG_PATH}${APP_NAME}/error/%d{yyyy-MM-dd}-%i.log.gz"
    maxHistory = 30
  }
}
logger("org.springframework.web", INFO)
logger("cn.zwqh.springboot.controller", TRACE)
logger("cn.zwqh.springboot.dao", DEBUG)
root(INFO, ["CONSOLE", "INFO_FILE", "ERROR_FILE"])
详细的 logback.groovy 语法可以参考 http://logback.qos.ch/manual/... 。logback 也提供了 logback.xml 转 logback.groovy 的在线工具,地址:http://logback.qos.ch/transla... (include 标签未作解析,所以转换前把该标签去除,否则会报错)

logback.xml 配置说明

configuration

配置文件的根节点,主要包含以下三个属性:

  • scan:当此属性设置为true时,配置文件如果发生改变,将会被重新加载,默认值为true。
  • scanPeriod:设置监测配置文件是否有修改的时间间隔,如果没有给出时间单位,默认单位是毫秒。当scan为true时,此属性生效。默认的时间间隔为1分钟。
  • debug:当此属性设置为true时,将打印出logback内部日志信息,实时查看logback运行状态。默认值为false。

contextName

设置日志上下文名称,后面输出格式中可以通过定义 %contextName 来打印日志上下文名称。

property

配置文件的变量定义,name 代表变量的名称,value 代表变量定义的值。通过定义的值会被插入到logger上下文中。定义变量后,可以使“${name}”来使用变量。

jmxConfigurator

开启 JMX 的功能,可以从默认配置文件,指定文件或URL重新配置登录,列出记录器并修改记录器级别。

JMX(Java Management Extensions,即 Java 管理扩展)是一个为应用程序、设备、系统等植入管理功能的框架。JMX 可以跨越一系列异构操作系统平台、系统体系结构和网络传输协议,灵活的开发无缝集成的系统、网络和服务管理应用。相关文档:http://logback.qos.ch/manual/...

appender

日志输出组件,主要负责日志的输出以及格式化日志。常用的属性有name和class。

  • name:appender组件的名称,后面给logger指定appender使用。
  • class:appender的具体实现类。常用的有 ConsoleAppender、FileAppender、RollingFileAppender。

appender的具体实现类:

  • ConsoleAppender:向控制台输出日志内容的组件,只要定义好encoder节点就可以使用。
  • FileAppender:向文件输出日志内容的组件,用法也很简单,不过由于没有日志滚动策略,一般很少使用。
  • RollingFileAppender:向文件输出日志内容的组件,同时可以配置日志文件滚动策略,在日志达到一定条件后生成一个新的日志文件。

Threshold filter

Logback 定义的日志打印级别的过滤器。可以过滤掉指定级别以下的日志不输出到文件。

encoder charset

表示对日志进行编码。

encoder pattern

  • %d{HH:mm:ss.SSS} —— 日志输出时间。
  • %thread —— 输出日志的进程名称,用方括号括起来。这个信息在 Web 应用以及异步任务处理中很有用。
  • %-5level —— 日志级别,使用5个字符靠左对齐。
  • %logger{36} —— 日志输出者的名字。
  • %msg —— 日志消息。
  • %n —— 换行符。

rollingPolicy

日志记录器的滚动策略。

  • FileNamePattern:定义日志的切分方式,本文把每一天的日志归档到一个文件。
  • MaxHistory:表示日志保留的天数,本文设置为30天。

logger

用来设置某一个包或者具体的某一个类的日志打印级别、以及指定<appender>。

  • name:用来指定受此logger约束的某一个包或者具体的某一个类。
  • level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,还有一个特殊值INHERITED或者同义词NULL,代表强制执行上级的级别。如果未设置此属性,那么当前logger将会继承上级的级别。
使用mybatis的时候,sql语句只有在 debug 级别下才会打印

root

必选节点,用来指定最基础的日志输出级别,只有一个level属性
level:用来设置打印级别,大小写无关:TRACE, DEBUG, INFO, WARN, ERROR, ALL 和 OFF,不能设置为INHERITED或者同义词NULL。默认是 DEBUG 可以包含零个或多个元素,标识这个appender将会添加到这个logger。

示例代码

github

码云

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十四):日志功能 Logback

原文地址: https://www.zwqh.top/article/info/23

如果文章对您有帮助,请扫码关注下我的公众号,文章持续更新中...

查看原文

赞 0 收藏 0 评论 0

朝雾轻寒 发布了文章 · 2019-11-06

Spring Boot 2.X(十三):邮件服务

前言

邮件服务在开发中非常常见,比如用邮件注册账号、邮件作为找回密码的途径、用于订阅内容定期邮件推送等等,下面就简单的介绍下邮件实现方式。

准备

一个用于发送的邮箱,本文是用腾讯的域名邮箱,可以自己搞一个域名绑定下,登录地址:http://domain.mail.qq.com

邮件服务实现

1.添加依赖

<!-- 启用邮箱 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
        </dependency>

2.配置文件

spring.mail.host=smtp.qq.com
spring.mail.username=zwqh@clover1314.com
spring.mail.password=*****
spring.mail.properties.mail.smtp.auth=true
spring.mail.properties.mail.smtp.starttls.enable=true
spring.mail.properties.mail.smtp.starttls.required=true

3.实现示例

@Service
public class MailTool {
    
    @Value("${spring.mail.username}")
    private String from;

    @Autowired
    private JavaMailSender mailSender;

    /**
     * 发送邮件
     * 
     * @return
     */
    public boolean send() {
        try {
            SimpleMailMessage message = new SimpleMailMessage();
            message.setFrom(from);//发送者
            message.setTo("zwqh@clover1314.com");//接受者
            message.setCc("sohuniuer@sina.com");// 抄送
            message.setSubject("邮件主题"); //邮件主题
            message.setText("这里是邮件内容");//邮件内容
            mailSender.send(message);
            System.out.println("邮件发送成功");
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 发送富文本邮件
     * 
     * @return
     */
    public boolean sendHtml() {
        // 使用 JavaMail 的 MimeMessage,支持更多复杂的邮件格式和内容
        MimeMessage mimeMessage = mailSender.createMimeMessage();
        try {
            // 创建 MimeMessageHelper 对象,处理 MimeMessage 辅助类
            MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
            // 使用辅助类 MimeMessage 设定参数
            helper.setFrom(from);
            helper.setTo("zwqh@clover1314.com");
            helper.setBcc("sohuniuer@sina.com");//密送
            helper.setSubject("富文本邮件主题");
            helper.setText("<h1>这是富文本邮件内容标题</h1><p style='color:red;'>这里是段落一</p><p style='color:orange;'>这里是段落二</p>",
                    true);        
            mailSender.send(mimeMessage);
            System.out.println("邮件发送成功");
            return true;
        } catch (MessagingException e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 发送富文本带附件的邮件
     * @return
     */
    public boolean sendHtmlWithAttach() {
        // 使用 JavaMail 的 MimeMessage,支持更多复杂的邮件格式和内容
        MimeMessage mimeMessage = mailSender.createMimeMessage();

        try {
            // 创建 MimeMessageHelper 对象,处理 MimeMessage 辅助类
            MimeMessageHelper helper = new MimeMessageHelper(mimeMessage, true);
            helper.setFrom(from);
            helper.setTo("zwqh@clover1314.com");
            helper.setSubject("富文本带附件的邮件主题");
            helper.setText("<h1>这是富文本邮件内容标题</h1><p style='color:red;'>这里是段落一</p><p style='color:orange;'>这里是段落二</p>",
                    true);
            //加载文件资源作为附件
            ClassPathResource file=new ClassPathResource("static/avatar2.jpg");
            //添加附件,并重命名
            helper.addAttachment("附件.jpg", file);
            mailSender.send(mimeMessage);
            System.out.println("邮件发送成功");
            return true;
        } catch (MessagingException e) {
            e.printStackTrace();
            return false;
        }

    }

}

4.Controller 用于测试

@RestController
public class MailController {

    @Autowired
    private MailTool mailTool;
    
    @RequestMapping("/send")
    public String send() {
        mailTool.send();
        return "send success";
    }
    
    @RequestMapping("/sendHtml")
    public String sendHtml() {
        mailTool.sendHtml();
        return "sendHtml success";
    }
    
    @RequestMapping("/sendHtmlWithAttach")
    public String sendHtmlWithAttach() {
        mailTool.sendHtmlWithAttach();
        return "sendHtmlWithAttach success";
    }
    
    
}

5.测试效果

示例代码

github

码云

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十三):邮件服务

原文地址: https://www.zwqh.top/article/info/22

如果文章对您有帮助,请扫码关注下我的公众号,文章持续更新中...

查看原文

赞 0 收藏 0 评论 0

朝雾轻寒 发布了文章 · 2019-11-06

Spring Boot 2.X(十二):定时任务

简介

定时任务是后端开发中常见的需求,主要应用场景有定期数据报表、定时消息通知、异步的后台业务逻辑处理、日志分析处理、垃圾数据清理、定时更新缓存等等。

Spring Boot 集成了一整套的定时任务工具,让我们专注于完成逻辑,剩下的基础调度工作将自动完成。

通用实现方式

实现方式描述
java.util.TimerTimer 提供了一个 java.util.TimerTask 任务支持任务调度。该方式只能按指定频率执行,不能在指定时间运行。由于功能过于单一,使用较少。
QuartzQuartz 是一个功能比较强大的调度器,支持在指定时间运行,也可以按照指定频率执行。缺点是使用起来相对麻烦。
Spring 框架自带的 Schedule 模块可以看做是轻量级的 Quartz

静态定时任务

@Component
@EnableScheduling
public class StaticScheduleJob {
    
    /**
     * 上次开始执行时间点后5秒再次执行
     */
    @Scheduled(fixedRate = 5000)
    public void job3() {
        System.out.println("执行任务job3:"+DateUtil.formatDateTime(new Date()));
    }
    
    /**
     * 上次执行完毕时间点后3秒再次执行
     */
    @Scheduled(fixedDelay = 3000)
    public void job2() {
        System.out.println("执行任务job2:"+DateUtil.formatDateTime(new Date()));
    }
    
    /**
     * 每隔10秒执行一次(按照 corn 表达式规则执行)
     */
    @Scheduled(cron = "0/10 * * * * ?")
    public void job1() {
        System.out.println("执行任务job1:"+DateUtil.formatDateTime(new Date()));
    }

    
}

@EnableScheduling 注解启用定时调动功能

@Scheduled 参数说明:

  • @Scheduled(fixedRate = 5000):上次开始执行时间点后5秒再次执行
  • @Scheduled(fixedDelay = 3000):上次执行完毕时间点后3秒再次执行
  • @Scheduled(cron = "0/10 ?"):每隔10秒执行一次(按照 corn 表达式规则执行)

Cron 表达式

1.Cron表达式格式

{秒} {分} {时} {日} {月} {周} {年(可选)}

2.Cron 表达式字段取值范围及说明

字段取值范围允许的特殊字符
Seconds(秒)0 ~ 59, - * /
Minutes(分)0 ~ 59, - * /
Hours(时)0 ~ 23, - * /
Day-of-Month(天)可以用数字 1 ~ 31 中的任意一个值,但要注意特殊月份, - * ? / L W C
Month(月)可以用 0 ~ 11 或者字符串 “JAN、FEB、MAR、APR、MAY、JUN、JUL、AUG、SEP、OCT、NOV、DEC” 表示, - * /
Day-of-Week(每周)可以用数字 1 ~ 7 表示(1=星期日)或者用字符串 “SUN、MON、TUE、WED、THU、FRI、SAT” 表示, - * ? / L C #
Year(年)取值范围(1970-2099),允许为空值, - * /

3.Cron 表达式中特殊字符的意义

特殊字符说明
  • | 表示可以匹配该域的所有值

?| 主要用于日和星期,可以匹配域的任意值,但实际不会。当2个子表达式其中之一被指定了值以后,为了避免冲突,需要将另一个子表达式的值设为?
/ | 表示为每隔一段时间。如 0 0/10 * ? 其中的 0/10表示从0分钟开始,每隔10分钟执行一次

  • | 表示范围。如 0 0-5 14 ? 表示在每天14:00到14:05期间每1分钟执行一次

, | 表示枚举多个值,这些值之间是"或"的关系。如 0 10,30 14 * 3 ? 表示每个星期二14点10分或者14点30分执行一次
L | 表示每月或者每周的最后一天。如 0 0 0 L ? 表示每月的最后一天执行
W | 表示最近工作日。如 0 0 0 15W 表示每月15号最近的那个工作日执行

| 用来指定具体的周数,"#"前面代表星期,"#"后面代表本月的第几周。如"2#1"表示本月第二周的星期日

4.Cron 在线生成工具

http://www.bejson.com/otherto...

动态定时任务

1.实现 SchedulingConfigurer 接口

@Configuration
public class CustomScheduleConfig implements SchedulingConfigurer {

    @Autowired
    private CronTriggerDao cronTriggerDao;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        // 上次开始执行时间点后5秒再执行
        taskRegistrar.addFixedRateTask(() -> System.out.println("CustomScheduleConfig执行任务job1=>"
                + DateUtil.formatDateTime(new Date()) + ",线程:" + Thread.currentThread().getName()), 5000);
        // 上次执行完毕时间点后3秒再执行
        taskRegistrar.addFixedDelayTask(() -> System.out.println("CustomScheduleConfig执行任务job2=>"
                + DateUtil.formatDateTime(new Date()) + ",线程:" + Thread.currentThread().getName()), 3000);
        // 添加一个配合数据库动态执行的定时任务
        TriggerTask triggerTask = new TriggerTask(
                // 任务内容.拉姆达表达式
                () -> {
                    // 1)添加任务 Runnable
                    System.out.println("CustomScheduleConfig执行动态任务job3=>" + DateUtil.formatDateTime(new Date()) + ",线程:"
                            + Thread.currentThread().getName());
                    // 2)设置执行周期
                }, triggerContext -> {
                    // 3)从数据库获取执行周期
                    String cron = cronTriggerDao.getCronTriggerById(1L);
                    if (cron != null) {
                        // 4)返回执行周期(Date)
                        return new CronTrigger(cron).nextExecutionTime(triggerContext);
                    } else {
                        return null;
                    }

                });
        taskRegistrar.addTriggerTask(triggerTask);

    }

}

2.数据库中初始化数据

这边为了测试简单初始化两行数据:

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_cron_trigger
-- ----------------------------
DROP TABLE IF EXISTS `t_cron_trigger`;
CREATE TABLE `t_cron_trigger` (
  `id` int(8) NOT NULL AUTO_INCREMENT COMMENT '任务id',
  `cron` varchar(20) COLLATE utf8_bin DEFAULT NULL COMMENT 'cron表达式',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `is_deleted` int(1) DEFAULT '0' COMMENT '作废状态 0-否 1-是',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

-- ----------------------------
-- Records of t_cron_trigger
-- ----------------------------
BEGIN;
INSERT INTO `t_cron_trigger` VALUES (1, '0/10 * * * * ?', '2019-10-30 13:40:14', NULL, 0);
INSERT INTO `t_cron_trigger` VALUES (2, '0/7 * * * * ?', '2019-10-30 13:40:34', NULL, 0);
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

3.从数据库中读取 cron 表达式值

CronTrigger 实体类

public class CronTrigger implements Serializable{

    /**
     * 
     */
    private static final long serialVersionUID = 880141459783509786L;
    
    private Long id;//任务id
    private String cron;//cron表达式
    private String createTime;//创建时间
    private String updateTime;//更新时间
    private boolean isDeleted=false;//删除状态
    
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getCron() {
        return cron;
    }
    public void setCron(String cron) {
        this.cron = cron;
    }
    public String getCreateTime() {
        return createTime;
    }
    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }
    public String getUpdateTime() {
        return updateTime;
    }
    public void setUpdateTime(String updateTime) {
        this.updateTime = updateTime;
    }
    public boolean isDeleted() {
        return isDeleted;
    }
    public void setDeleted(boolean isDeleted) {
        this.isDeleted = isDeleted;
    }
}

CronTriggerDao

public interface CronTriggerDao {
    /**
     * 根据id获取cron表达式
     * @param id
     * @return
     */
    String getCronTriggerById(Long id);

}

CronTriggerMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.4//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.zwqh.springboot.dao.CronTriggerDao">
    <resultMap type="cn.zwqh.springboot.model.CronTrigger" id="cronTrigger">
        <id property="id" column="id"/>
        <result property="cron" column="cron"/>
        <result property="createTime" column="create_time"/>
        <result property="updateTime" column="update_time"/>
        <result property="isDeleted" column="is_deleted"/>
    </resultMap>
    <!-- 根据id获取cron表达式 -->
    <select id="getCronTriggerById" resultType="String">
        select cron from t_cron_trigger where is_deleted=0 and id=#{id}
    </select>
</mapper>

4.测试

启动前记得在启动类上加上 @EnableScheduling

打印日志如下:

多线程定时任务

通过上面的日志我们可以看到任务执行都是单线程的。如果要实现多线程执行任务,我们可以通过在 SchedulingConfigurer 接口的 configureTasks方法中添加线程池即可。

1.CustomScheduleConfig

@Configuration
public class CustomScheduleConfig implements SchedulingConfigurer {

    @Autowired
    private CronTriggerDao cronTriggerDao;

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        
        //设定一个长度为10的定时任务线程池
        taskRegistrar.setScheduler(Executors.newScheduledThreadPool(10));
        
        // 上次开始执行时间点后5秒再执行
        taskRegistrar.addFixedRateTask(() -> System.out.println("CustomScheduleConfig执行任务job1=>"
                + DateUtil.formatDateTime(new Date()) + ",线程:" + Thread.currentThread().getName()), 5000);
        // 上次执行完毕时间点后3秒再执行
        taskRegistrar.addFixedDelayTask(() -> System.out.println("CustomScheduleConfig执行任务job2=>"
                + DateUtil.formatDateTime(new Date()) + ",线程:" + Thread.currentThread().getName()), 3000);
        // 添加第一个配合数据库动态执行的定时任务
        TriggerTask triggerTask = new TriggerTask(
                // 任务内容.拉姆达表达式
                () -> {
                    // 1)添加任务 Runnable
                    System.out.println("CustomScheduleConfig执行动态任务job3=>" + DateUtil.formatDateTime(new Date()) + ",线程:"
                            + Thread.currentThread().getName());
                    // 2)设置执行周期
                }, triggerContext -> {
                    // 3)从数据库获取执行周期
                    String cron = cronTriggerDao.getCronTriggerById(1L);
                    if (cron != null) {
                        // 4)返回执行周期(Date)
                        return new CronTrigger(cron).nextExecutionTime(triggerContext);
                    } else {
                        return null;
                    }

                });
        taskRegistrar.addTriggerTask(triggerTask);
        // 添加第二个配合数据库动态执行的定时任务
        TriggerTask triggerTask2 = new TriggerTask(
                // 任务内容.拉姆达表达式
                () -> {
                    // 1)添加任务 Runnable
                    System.out.println("CustomScheduleConfig执行动态任务job4=>" + DateUtil.formatDateTime(new Date()) + ",线程:"
                            + Thread.currentThread().getName());
                    // 2)设置执行周期
                }, triggerContext -> {
                    // 3)从数据库获取执行周期
                    String cron = cronTriggerDao.getCronTriggerById(2L);
                    if (cron != null) {
                        // 4)返回执行周期(Date)
                        return new CronTrigger(cron).nextExecutionTime(triggerContext);
                    } else {
                        return null;
                    }

                });
        taskRegistrar.addTriggerTask(triggerTask2);

    }

}

2.测试

打印日志如下:

示例代码

github

码云

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十二):定时任务

原文地址: https://www.zwqh.top/article/info/21

如果文章对您有帮助,请扫码关注下我的公众号,文章持续更新中...

查看原文

赞 0 收藏 0 评论 0

朝雾轻寒 发布了文章 · 2019-11-06

Spring Boot 2.X(十一):全局异常处理

前言

在 Java Web 系统开发中,不管是 Controller 层、Service 层还是 Dao 层,都有可能抛出异常。如果在每个方法中加上各种 try catch 的异常处理代码,那样会使代码非常繁琐。在Spring MVC 中,我们可以将所有类型的异常处理从各个单独的方法中解耦出来,进行异常信息的统一处理和维护。

在 Spring MVC 中全局异常捕获处理的解决方案通常有两种方式:

1.使用 @ControllerAdvice + @ExceptionHandler 注解进行全局的 Controller 层异常处理。

2.实现 org.springframework.webb.servlet.HandlerExceptionResolver 接口中的 resolveException 方法。

使用 @ControllerAdvice + @ExceptionHandler 注解

1.定义统一异常处理类

@ControllerAdvice
public class GlobalExceptionHandler {

    private Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(value = Exception.class)
    public ModelAndView defaultErrorHandler(HttpServletRequest req, Exception e) {
        log.error("ExceptionHandler ===>" + e.getMessage());
        e.printStackTrace();
        // 这里可根据不同异常引起的类做不同处理方式
        String exceptionName = ClassUtils.getShortName(e.getClass());
        log.error("ExceptionHandler ===>" + exceptionName);
        ModelAndView mav = new ModelAndView();
        mav.addObject("stackTrace", e.getStackTrace());
        mav.addObject("errorMessage", e.getMessage());
        mav.addObject("url", req.getRequestURL());
        mav.setViewName("forward:/error/500");
        return mav;
    }
}

其中 @ExceptionHandler(value = Exception.class) 中的捕获异常 value 可以自定义,如下:

类型描述
NullPointerException当应用程序试图访问空对象时,则抛出该异常
SQLException提供关于数据库访问错误或其他错误信息的异常
IndexOutOfBoundsException指示某排序索引(例如对数组、字符串或向量的排序)超出范围时抛出
NumberFormatException当应用程序试图将字符串转换成一种数值类型,但该字符串不能转换为适当格式时,抛出该异常
FileNotFoundException当试图打开指定路径名表示的文件失败时,抛出此异常
IOException当发生某种I/O异常时,抛出此异常。此类是失败或中断的I/O操作生成的异常的通用类
ClassCastException当试图将对象强制转换为不是实例的子类时,抛出该异常
ArrayStoreException试图将错误类型的对象存储到一个对象数组时抛出的异常
IllegalArgumentException抛出的异常表明向方法传递了一个不合法或不正确的参数
ArithmeticException当出现异常的运算条件时,抛出此异常。例如,一个整数“除以零”时,抛出此类的一个实例
NegativeArraySizeException如果应用程序试图创建大小为负的数组,则抛出该异常
NoSuchMethodException无法找到某一特定方法时,抛出该异常
SecurityException由安全管理器抛出的异常,指示存在安全侵犯
UnsupportedOperationException当不支持请求的操作时,抛出该异常
RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类

当捕获到响应的异常类型时,会进入 defaultErrorHandler() 方法中的逻辑:把异常信息放入 model,跳转至 /error/500 请求URL。

2.异常信息展现

视图控制器配置

@Configuration
public class WebMvcConfig extends WebMvcConfigurationSupport {

    /**
     * 视图控制器配置
     */
    @Override
    public void addViewControllers(ViewControllerRegistry registry) {    
        registry.addViewController("/").setViewName("/index");//设置默认跳转视图为 /index
        registry.addViewController("/error/500").setViewName("/error/500");
        registry.setOrder(Ordered.HIGHEST_PRECEDENCE);
        super.addViewControllers(registry);
        
    }
    
}

视图模板

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h1>Exception</h1>
<h3 th:text="${url}"></h3>
<h3 th:text="${errorMessage}"></h3>
<p  th:each="line : ${stackTrace}" th:text="${line}">  </p>
</body>
</html>

3.测试异常类

@Controller
public class TestController {

    @GetMapping("/index")
    public String hello() {
        int x = 1 / 0;
        return "hello";
    }
}

4.运行测试

浏览器访问:http://127.0.0.1:8080/index

@ControllerAdvice 还能结合 @ModelAttribute 、@InitBinder 注解一起使用,实现全局数据绑定和全局数据预处理等功能。

实现 HandlerExceptionResolver 接口

1.定义统一异常处理类

@Component
public class GlobalHandlerExceptionResolver implements HandlerExceptionResolver {

    private Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @Override
    public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
            Exception ex) {
        Exception e = new Exception();
        //处理 UndeclaredThrowableException
        if (ex instanceof UndeclaredThrowableException) {
            e = (Exception) ((UndeclaredThrowableException) ex).getUndeclaredThrowable();
        } else {
            e = ex;
        }
        e.printStackTrace();
        //这里可以根据不同异常引起的类做不同处理方式
        String exceptionName = ClassUtils.getShortName(e.getClass());
        if(exceptionName.equals("ArrayIndexOutOfBoundsException")) {
            log.error("GlobalHandlerExceptionResolver resolveException ===>" + exceptionName);
            ModelAndView mav = new ModelAndView();
            mav.addObject("stackTrace", e.getStackTrace());
            mav.addObject("exceptionName", exceptionName);
            mav.addObject("errorMessage", e.getMessage());
            mav.addObject("url", request.getRequestURL());
            mav.setViewName("forward:/error/500");
            return mav;
        }
        return null;
    }

}
UndeclaredThrowableException 异常通常是在 RPC 接口调用场景或者使用 JDK 动态代理的场景时发生。如果不预先处理转换,测试捕获到的异常则为 UndeclaredThrowableException,而不是真实的异常对象。

2.异常信息展现 同上

3.测试异常类

@Controller
public class TestController {

    @GetMapping("/test")
    public String test() {
        String[] ss = new String[] { "1", "2" };
        System.out.print(ss[2]);
        return "hello";
    }

}

4.测试运行

测试前先把 @ControllerAdvice 注释了。
浏览器访问:http://127.0.0.1:8080/test

示例代码

github

码云

非特殊说明,本文版权归 朝雾轻寒 所有,转载请注明出处.

原文标题:Spring Boot 2.X(十一):全局异常处理

原文地址: https://www.zwqh.top/article/info/20

如果文章对您有帮助,请扫码关注下我的公众号,文章持续更新中...

查看原文

赞 1 收藏 0 评论 0

认证与成就

  • 获得 2 次点赞
  • 获得 0 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 0 枚铜徽章

擅长技能
编辑

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 2019-10-28
个人主页被 274 人浏览