Java旅途

Java旅途 查看完整档案

兰州编辑兰州理工大学  |  计算机科学与技术 编辑Java旅途  |  Java工程师 编辑 github.com/binzh303/spring-boot-route 编辑
编辑

公众号:Java旅途
github:https://github.com/binzh303/s...

个人动态

Java旅途 发布了文章 · 10月24日

1024|推荐一个开源免费的Spring Boot教程

2020-1024=996!

今天,星期六,你们是否加班了?我反正加了!早上去公司开了一早上会,中午回家写下了这篇文章。

今天,我要推荐一个开源免费的Spring Boot项目,就是我最近日更的Spring Boot系列文章——spring-boot-route。

github地址:https://github.com/binzh303/s...

spring-boot-route包含基础知识、Web开发、数据访问、缓存服务、消息队列、日志管理、服务监控、定时任务及其他知识等九大部分,二十三篇文章,内容几乎涉猎了开发中比较常用的技术点。具体内容目录如下:

代码如下:

代码及文章已经上传至github,点击文末的阅读原文可直接跳转到github地址。如果觉得文章不错,点个star支持一下。

这个系列的内容难易程度参差不齐,基本上都是我工作这几年用到的或者是想要了解的一些内容。最开始列提纲的时候差不多有三十篇文章,后面经过反复推敲去掉了安全框架模块及几个不常用的技术点,最终保留了23篇,组成了这个系列。

冥冥之中自有天意

九月份开始列提纲,零零碎碎的写了几篇文章。国庆的时候基本窝在家里写这个系列,同时开始在公众号上推送。没想到更新完正好是10月23,这真不是有意赶1024。直到昨晚休息,我都以为今天是10月23日,今天文章的题目我都想好了“1024前夕,我带着他向你们走来了”。但是今早发现朋友圈有太多的关于1024的话题,打开日历才发现这个日子已经到了。

为什么要写这个系列

写这个系列主要有三个原因,其一:在更新公众号的这些日子里,有很多读者加我,他们跟我说的第一句话基本上都是我工作不久或者我还在上学,问我应该学点什么。其二:我坚持每天都更新一篇文章,最难的不是写文章,而是考虑写什么内容,正好更新这个系列后,这段时间不会为写什么而发愁了,而且有些内容我也不是很熟,可以巩固一下基础。其三:在我工作的这几年里,我觉得一个合格程序员应该做的三件事,分别是搭建自己的博客,写一个开源项目,出版一本图书。搭建博客我在去年已经完成了(当然,后来关停了),出书的话我目前还没有这个打算,所以就把第二件事情做完。天天逛github,也是时候为开源出一份力了。

这段时间的得与失

说实话,这个系列的文章我觉得有点拉跨了。最明显的就是在写这个系列前公众号文章的阅读量基本200多,好点的文章可以达到400多,而这个系列的文章阅读量基本维持在100以内。虽然说写公众号最主要的还是沉淀自己,但是没有人读你写的文章还是有点难受的,就像演员没有观众。当然,也有一小部分人坚持跟着文章实践,他们留言、点赞、分享,你们是我坚持更新完的动力。

虽然公众号上看的人很少,但是在其他网站上也得到了一些业内人士的认可,其中有几个出版社的编辑也加到了我,联系我将这个系列出版图书。

目前我还没有这个打算,接下来一段时间内,我还是会持久关注这个系列。各位小伙伴如果有想补充的内容直接微信反馈给我或者github上提issue。如果我觉得有必要,我会加到这个系列中来。


Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 15 收藏 13 评论 2

Java旅途 发布了文章 · 10月23日

spring-boot-route(二十三)开发微信公众号

在讲微信公众号开发之前,先来大概了解一下微信公众号。微信公众号大体上可以分为服务号和订阅号,订阅号和服务号的区别如下:

  1. 服务号可以申请微信支付功能。
  2. 服务号只能由企业申请,订阅号可以有企业或个人申请。
  3. 订阅号和服务号每月推送消息次数不同,订阅号每天可以推送一次,服务号每月可以推送四次。
  4. 服务号推送的消息会出现在用户的聊天列表中,而订阅号推送的消息显示在订阅号文件夹中。
  5. 还有一些其他接口功能的区别和限制,总的来说服务号支持更高级的功能开发。

订阅号更加偏向于向用户传递咨询,一般各种技术类公众号都属于订阅号,订阅号的消息推送并不会有太显眼的提醒,如果你想让某个公众号的推送内容更加显眼,可以选择置为星标。置为星标后公众号会显示在所有订阅号的最顶部,同时收到消息后会有黄色五角星星标提醒。

一 公众号配置服务器

微信官方提供了非常完善的接入文档,如果想了解文档的具体内容,直接浏览器搜索微信开发文档就可以了。但是为了方便开发,一般不会直接去根据微信开发文档进行开发,gitee上有许多开源项目对微信开发文档进行了封装,这里我使用mica-weixin开发包进行演示,mica-weixinjfinal-weixin的boot版本。

配置服务器信息很简单,具体流程就是微信服务发送请求一个请求给业务服务器,业务服务器验证请求后给微信服务一个响应

1.1 搭建业务服务

本地搭建一个spring-boot-weixin的项目,使用内网穿透工具进行穿透,使其可以与外网进行通信。

1.1.1 引入mica-weixin依赖

<dependency>
    <groupId>net.dreamlu</groupId>
    <artifactId>mica-weixin</artifactId>
    <version>2.0.1</version>
</dependency>

1.1.2 配置公众号信息

mica-weixin通过配置文件进行公众号信息的配置,如果你想通过数据库配置公众号信息,可以参考我以前写过的一篇文章jfinal-weixin自定义配置支持多公众号

dream:
  weixin:
    wx-configs:
    - appId: xxxxxx
      appSecret: xxxxxx
      token: javatrip
      encodingAesKey: xxxxxx

appIdappSecret可在公众号后台进行查看,具体位置在菜单开发—>基本配置中,其中appSecret要妥善保管,现在公众号已经不支持查看appSecret了,如果你忘了appSecret,只能进行重置。

1.1.3 开发消息校验接口

mica-weixin已经为我们提供好了消息校验接口,只需要继承DreamMsgControllerAdapter就可以了。

@WxMsgController("/weixin/wx")
public class WeiXinMsgController extends DreamMsgControllerAdapter {
    @Override
    protected void processInFollowEvent(InFollowEvent inFollowEvent) {
    }

    @Override
    protected void processInTextMsg(InTextMsg inTextMsg) {
    }

    @Override
    protected void processInMenuEvent(InMenuEvent inMenuEvent) {
    }
}

同时,需要开启缓存,由于mica-weixin的将access_token等信息放在了缓存中。在启动类上加@EnableCaching就开启了。

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

1.1.4 公众号后台配置服务器信息

使用内网穿透工具穿透内网地址,然后在公众号后台菜单开发—>基本配置中填写服务器配置信息。

填写完成后点击启用,这样就完成了微信服务器和业务服务器的关系配置。开启开发者配置后,自动回复、自定义菜单等功能都不能正常使用了。这时候就需要去调用对应的接口实现这些功能。

二 实现各种消息接口

2.1 关注消息

在一步中,自定义类WeiXinMsgController中需要重写三个父类中的方法,其中processInFollowEvent()就是关注和取消关注的方法,取消关注后用户虽然不能收到消息,但是后台可以接收到用户取消关注的事件。

@Override
protected void processInFollowEvent(InFollowEvent inFollowEvent) {

    OutTextMsg defaultMsg = new OutTextMsg(inFollowEvent);
    // 关注
    if(InFollowEvent.EVENT_INFOLLOW_SUBSCRIBE.equals(inFollowEvent.getEvent())){
        // 可将关注用户录入db,此处可以获取到用户openid
        String openId = inFollowEvent.getFromUserName();
        // 查询db,根据响应消息类型封装消息体
        if("文本消息"){
            OutTextMsg otm = new OutTextMsg(inFollowEvent);
            otm.setContent("消息内容");
            render(otm);
            return;
        }else if("图片消息"){
            OutImageMsg oim = new OutImageMsg(inFollowEvent);
            // 这里需要调用微信提供的素材接口,将图片上传至素材库。
            oim.setMediaId("图片素材id");
            render(oim);
            return;
        }else if("图文消息"){
            OutNewsMsg onm = new OutNewsMsg(inFollowEvent);
            onm.addNews("标题","简介","图片地址","图文链接");
            render(onm);
            return;
        }else if("视频消息"){
            OutVideoMsg ovm = new OutVideoMsg(inFollowEvent);
            ovm.setTitle("标题");
            ovm.setDescription("简介");
            ovm.setMediaId("视频素材id");
            render(ovm);
            return;
        }else{
            defaultMsg.setContent("感谢关注");
        }
    }
    // 取消关注
    if(InFollowEvent.EVENT_INFOLLOW_UNSUBSCRIBE.equals(inFollowEvent.getEvent())){
        log.info("用户取消关注了");
        // 此处可以将取消关注的用户更新db
    }
}

2.2 关键词消息

响应内容跟关注消息一样,查询db去匹配关键词,然会根据消息内容封装对应的消息体进行返回,如果没匹配到关键词则回复统一的消息内容。processInTextMsg()方法就是用来回复关键词消息的。

@Override
protected void processInTextMsg(InTextMsg inTextMsg) {

    String content = inTextMsg.getContent();
    // 根据用户发送的content去查询db中的响应内容
    if("文本消息"){
        OutTextMsg otm = new OutTextMsg(inTextMsg);
        otm.setContent("消息内容");
        render(otm);
        return;
    }else if("图片消息"){
        OutImageMsg oim = new OutImageMsg(inTextMsg);
        // 这里需要调用微信提供的素材接口,将图片上传至素材库。
        oim.setMediaId("图片素材id");
        render(oim);
        return;
    }else if("图文消息"){
        OutNewsMsg onm = new OutNewsMsg(inTextMsg);
        onm.addNews("标题","简介","图片地址","图文链接");
        render(onm);
        return;
    }else if("视频消息"){
        OutVideoMsg ovm = new OutVideoMsg(inTextMsg);
        ovm.setTitle("标题");
        ovm.setDescription("简介");
        ovm.setMediaId("视频素材id");
        render(ovm);
        return;
    }else{
        OutTextMsg otm = new OutTextMsg(inTextMsg);
        otm.setContent("暂未查到关键词...");
    }
}

2.3 菜单消息

点击菜单后也是一样,通过processInMenuEvent()方法进行响应内容的回复。

@Override
protected void processInMenuEvent(InMenuEvent inMenuEvent) {
    String eventKey = inMenuEvent.getEventKey();
    // 根据用户发送的content去查询db中的响应内容
    if("文本消息"){
        OutTextMsg otm = new OutTextMsg(inMenuEvent);
        otm.setContent("消息内容");
        render(otm);
        return;
    }else if("图片消息"){
        OutImageMsg oim = new OutImageMsg(inMenuEvent);
        // 这里需要调用微信提供的素材接口,将图片上传至素材库。
        oim.setMediaId("图片素材id");
        render(oim);
        return;
    }else if("图文消息"){
        OutNewsMsg onm = new OutNewsMsg(inMenuEvent);
        onm.addNews("标题","简介","图片地址","图文链接");
        render(onm);
        return;
    }else if("视频消息"){
        OutVideoMsg ovm = new OutVideoMsg(inMenuEvent);
        ovm.setTitle("标题");
        ovm.setDescription("简介");
        ovm.setMediaId("视频素材id");
        render(ovm);
        return;
    }else{
        OutTextMsg otm = new OutTextMsg(inMenuEvent);
        otm.setContent("无效链接,请重试...");
    }
}

三 接口API调用

目前,微信提供的接口对订阅号的限制比较大,未认证的订阅号基本上只有接收消息的几个功能接口。

调用接口的时候需要传递token,获取token需要在微信后台中配置业务服务器的白名单。如下:

如果需要配置多个白名单ip,使用回车键将多个ip分隔开。

mica-weixin提供了所有的接口封装,具体可参考它的官方文档,如果要获取微信菜单,可以这样写:

@WxApi("weixin/api")
public class WeiXinApiController {
    @GetMapping("menu")
    @ResponseBody
    public String getMenu(){
        ApiResult menu = MenuApi.getMenu();
        return menu.getJson();
    }
}

@WxApi这个是它的自定义注解,其实就是包含了@RequestMapping@Controller

四 其他事项

4.1 多公众号配置

mica-weixin提供了多公众号配置的功能,使用ThreadLocalappid进行绑定。只需要简单配置即可实现多公众号配置。

dream:
  weixin:
    wx-configs:
      - appId: xxxxxx
        appSecret: xxxxxx
        token: javatrip
        encodingAesKey: xxxxxx
      - appId: xxxxxx
        appSecret: xxxxxx
        token: javatrip
        encodingAesKey: xxxxxx

4.2 redis配置

access_token的有效期是2小时,并且该接口有调用次数限制,mica-weixinaccess_token存储在redis中,避免每次调用接口都去获取access-token,因此项目需要配置redis。

spring:
  redis:
    host: localhost
    port: 6379

4.3 手动选择ThreadLocal

如果想要开发微信公众号的后台管理功能,多公众号的时候就需要手动去指定当前线程使用哪个公众号信息。如下:

ApiConfigKit.setThreadLocalAppId(appid);

至此,SpringBoot开发微信公众号就算完成了,由于订阅号开放的接口太少了,好多功能不能正常演示。还有mica-weixin也许不是最好的选择,如果想试着开发微信公众号,可以在gitee上找一下开发包。至于我为什么会使用mica-weixin,是因为我曾用过一段时间的jfinal框架,与之配套的微信开发包就是jfinal-weixin,也就是jfinal版的mica-weixin


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 1 评论 0

Java旅途 发布了文章 · 10月22日

spring-boot-route(二十二)实现邮件发送功能

在项目开发中,除了需要短信验证外,有时候为了节省 短信费也会使用邮件发送。在Spring项目中发送邮件需要封装复杂的消息体,不太方便。而在Spring Boot项目中发送邮件就太简单了,下面一起来看看Spring Boot如何发送邮件。

本文以126邮箱为例进行邮件发送功能,其他邮箱的配置也都大同小异。

1. 获取授权码

常用的电子协议有POP3SMTPIMAP,协议的具体区别就不进行详细介绍了。这里选择smtp协议进行演示。登录邮箱,在设置中找到协议地址,点击开启。授权码只会显示一次,需要保存好。

下面是126邮箱对应的三种协议主机地址:

2. 添加依赖

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

3. 配置邮箱信息

需要注意的是password不是邮箱登录密码,而是第一步中获取的授权码。

spring:
  mail:
    default-encoding: utf-8
    # 主机地址
    host: smtp.126.com
    # 邮箱名
    username: xxx@126.com
    # 授权码(不是密码)
    password: xxxxxxxxxx

4. 发送邮件

封装SimpleMailMessage消息内容,注入JavaMailSender调用其send()方法,完成邮件发送。其中收件人和抄送人支持多个发送,多个地址用,拼接起来完成批量发送。

@RestController
public class Email {

    @Autowired
    private JavaMailSender mailSender;
    @GetMapping("send")
    private void send(){

        SimpleMailMessage message = new SimpleMailMessage();
        // 发件人
        message.setFrom("xxx@126.com");
        // 收件人
        message.setTo("xxx@163.com");
        // 邮件标题
        message.setSubject("Java发送邮件第二弹");
        // 邮件内容
        message.setText("你好,这是一条用于测试Spring Boot邮件发送功能的邮件!哈哈哈~~~");
        // 抄送人
        message.setCc("xxx@qq.com");
        mailSender.send(message);
    }
}

5. 发送效果

最后一起来看看上面内容中涉及到的三个邮箱是否接收到数据了。

发件人:

收件人:

抄送人:


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 3 收藏 2 评论 2

Java旅途 发布了文章 · 10月21日

spring-boot-route(二十一)quartz实现动态定时任务

Quartz是一个定时任务的调度框架,涉及到的主要概念有以下几个:

Scheduler:调度器,所有的调度都由它控制,所有的任务都由它管理。

Job:任务,定义业务逻辑。

JobDetail:基于Job,进一步封装。其中关联一个Job,并为Job指定更详细的信息。

Trigger:触发器,可以指定给某个任务,指定任务的触发机制。

一 创建简单任务

1.1 Quartz依赖

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

1.2 创建任务

任务创建需要实现Job接口,重写execute(JobExecutionContext jobExecutionContext)方法,增加定时任务的业务逻辑,这里我只是简单的打印一下定时任务执行。

@Slf4j
public class SimpleJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("job execute---"+new Date());
    }
}

1.3 JobDetail增加属性

这里增加的属性可以在Job实现类中获取,来处理业务。

JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
                                // 任务标识,及任务分组
                                .withIdentity("job1", "group1")
                                // 链接调用,增加需要的参数
                                .usingJobData("name","Java旅途")
                                .usingJobData("age",18)
                                .build();

1.4 Trigger实现

Trigger分为两种,SimpleTriggerCronTriggerSimpleTrigger是根据Quartz的一些api实现的简单触发行为。CronTrigger用的比较多,使用cron表达式进行触发。这里先用SimpleTrigger来实现。

SimpleTrigger simpleTrigger = TriggerBuilder.newTrigger()
                                            .withIdentity("trigger1", "group1")
                                            // 立即执行
                                            .startNow()
                                            // 10s后停止
                                            .endAt(new Date(System.currentTimeMillis()+10*1000))
                                            .withSchedule(
                                            SimpleScheduleBuilder.simpleSchedule()
                                            // 每秒执行一次
                                            .withIntervalInSeconds(1)
                                            // 一直执行
                                            .repeatForever()
                                            ).build();

1.5 启动任务

@Autowired
private Scheduler scheduler;

scheduler.scheduleJob(jobDetail,simpleTrigger);

1.6 执行效果

启动项目后,任务立即执行,每秒执行一次,10s后停止,执行效果图如下:

二 动态操作定时任务

有时候除了已经开发好的定时任务外,还需要我们手动去创建任务并且控制任务的执行。

2.1 创建任务

@GetMapping("create")
public void createJob(String jobName,String jobGroup,String cron,String triggerName,String triggerGroup) throws SchedulerException {

    JobKey jobKey = new JobKey(jobName,jobGroup);
    // 如果存在这个任务,则删除
    if(scheduler.checkExists(jobKey)) {
        scheduler.deleteJob(jobKey);
    }

    JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
        .withIdentity(jobKey)
        .build();

    CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cron);

    Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity(triggerName,triggerGroup)
        .withSchedule(cronScheduleBuilder).build();
    scheduler.scheduleJob(jobDetail,trigger);
}

2.2 暂停任务

@GetMapping("pause")
public void pauseJob(String jobName,String jobGroup) throws SchedulerException {

    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
    JobDetail jobDetail = scheduler.getJobDetail(jobKey);
    if (jobDetail == null) {
        return;
    }
    scheduler.pauseJob(jobKey);
}

2.3 恢复暂停的任务

@GetMapping("remuse")
public void remuseJob(String jobName, String jobGroup) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
    JobDetail jobDetail = scheduler.getJobDetail(jobKey);
    if (jobDetail == null) {
        return;
    }
    scheduler.resumeJob(jobKey);
}

2.4 删除定时任务

@GetMapping("remove")
public void removeJob(String jobName, String jobGroup,String triggerName,String triggerGroup) throws SchedulerException {

    TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroup);
    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
    Trigger trigger =  scheduler.getTrigger(triggerKey);
    if (trigger == null) {
        return;
    }
    // 停止触发器
    scheduler.pauseTrigger(triggerKey);
    // 移除触发器
    scheduler.unscheduleJob(triggerKey);
    // 删除任务
    scheduler.deleteJob(jobKey);
}

三 任务持久化

Quartz默认使用RAMJobStore存储方式将任务存储在内存中,除了这种方式还支持使用JDBC将任务存储在数据库,为了防止任务丢失,我们一般会将任务存储在数据库中。

这里使用mysql进行存储,在quartz的源码包中找到文件tables_mysql_innodb.sql,然后在客户端进行运行sql文件。如果嫌源码包不好下载的话,我已经将sql文件上传至GitHub了,可以直接访问github拉去表结构,数据表如下:

3.1 增加mysql和jdbc依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>

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

3.2 指定使用jdbc存储

quartz默认使用memory存储,这里修改成jdbc进行存储,并配置jdbc的相关信息

spring:
  quartz:
    job-store-type: jdbc
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/simple_fast
    username: root
    password: root

3.3 创建任务

启动项目,调用create接口创建任务,然后数据表中就会新增任务相关的数据了。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 1 评论 0

Java旅途 发布了文章 · 10月20日

spring-boot-route(二十)Spring Task实现简单定时任务

Spring Task是Spring 3.0自带的定时任务,可以将它看作成一个轻量级的Quartz,功能虽然没有Quartz那样强大,但是使用起来非常简单,无需增加额外的依赖,可直接上手使用。

一 如何实现定时任务

1. 开启定时任务

在启动类上增加@EnableScheduling注解,开启定时任务

2. 定时任务方法

使用@Scheduled注解的方法就会被声明成一个定时任务

@Slf4j
@Component
public class ScheduledTest {

    @Scheduled(cron = "*/1 * * * * ?")
    public void test1(){
        log.info("这个定时任务1----");
    }
    @Scheduled(cron = "*/1 * * * * ?")
    public void test2(){
        log.info("这个定时任务2----");
    }
    @Scheduled(cron = "*/1 * * * * ?")
    public void test3(){
        log.info("这个定时任务3----");
    }
}

3. 注册bean

使用@Component将这个定时任务类注册成一个bean组件,交给Spring容器管理。

二 cron表达式详解

在spring 4.x中已经不支持7个参数的cronin表达式了,要求必须是6个参数。cron表达式格式如下:

{秒} {分} {时} {日期(具体哪天)} {月} {星期}
  • 秒:必填项,允许的值范围是0-59,支持的特殊符号包括,-*/,表示特定的某一秒才会触发任务,-表示一段时间内会触发任务,*表示每一秒都会触发,/表示从哪一个时刻开始,每隔多长时间触发一次任务。
  • 分:必填项,允许的值范围是0-59,支持的特殊符号和秒一样,含义类推
  • 时:必填项,允许的值范围是0-23,支持的特殊符号和秒一样,含义类推
  • 日期:必填项,允许的值范围是1-31,支持的特殊符号相比秒多了?,表示与{星期}互斥,即意味着若明确指定{星期}触发,则表示{日期}无意义,以免引起冲突和混乱。
  • 月:必填项,允许的值范围是1-12(JAN-DEC),支持的特殊符号与秒一样,含义类推
  • 星期:必填项,允许值范围是1~7 (SUN-SAT),1代表星期天(一星期的第一天),以此类推,7代表星期六,支持的符号相比秒多了?,表达的含义是与{日期}互斥,即意味着若明确指定{日期}触发,则表示{星期}无意义。

如果对cron表达式不是很熟悉,可以网上找一下,有许多生产cron表达式的网站。Spring Task就简单介绍到这了,使用起来非常方便,下一章将介绍Quartz的使用及将任务持久化存储。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 2 评论 0

Java旅途 发布了文章 · 10月19日

spring-boot-route(十九)spring-boot-admin监控服务

SpringBootAdmin不是Spring官方提供的模块,它包含了ClientServer两部分。server部分提供了用户管理界面,client即为被监控的服务。client需要注册到server端。

SpringBootAdmin提供了很少的几个监控服务端点,需要依赖SpringBootActuator丰富监控功能。

server端配置

server端的配置很简单,无需任何开发。

第一步:引入依赖

<dependency>
    <groupId>de.codecentric</groupId>
    <artifactId>spring-boot-admin-starter-server</artifactId>
    <version>2.3.0</version>
</dependency>

第二步:在启动类上增加@EnableAdminServer注解,开启对spring-boot-admin的支持。

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

做好以上配置,然后访问http://ip:port;效果如下

目前还没有客户端注册到服务端,所以看不到任何监控的内容,接下来我们创建一个客户端并且注册到服务端后再来看看效果。

Client端配置

这里使用上一章的演示项目——spring-boot-actuator做为客户端。

第一步:引入依赖

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

第二部:将客户端注册到服务器端,

spring:
  boot:
    admin:
      client:
        # 服务端地址
        url: http://localhost:7019

效果如下:

为了监控更多的状态信息,我们在客户端引入spring-boot-actuator依赖。

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

由于actuator默认只开启了health和info两个web端口,如果想要在server端页面看到所有的监控信息,需要开启其他接口的web端口。

management:
  endpoints:
    web:
      exposure:
        include: "*"

现在的效果如下:

spring-boot-admin的应用就简单介绍完了。spring-boot-admin配合spring-boot-actuator实现多服务监控,不仅能提供查看服务监控信息的ui,而且可以监控更加全面的内容。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 2 评论 0

Java旅途 发布了文章 · 10月18日

spring-boot-route(十八)spring-boot-adtuator监控应用

Spring Boot提供了良好的服务监控模块,只需要通过简单的配置便可以完成服务监控和管理。但是服务监控这块内容往往是最容易被忽略的一块内容,今天我们一起来学习一下使用spring-boot-actuator进行服务监控。spring-boot-actuator提供了监控端点,这些端点直接返回JSON字符串,通过这些端点可以查询服务运行状况,为了防止端点直接暴露,一般情况下会使用安全框架,如Spring Security来管理这些端点的安全性。

一 常用的端点

端点地址描述默认启用
auditevents获取当前应用暴露的审计事件信息
beans获取应用中所有的bean的完整关系列表
caches获取公开可以用的缓存
conditions获取自动配置条件信息,记录哪些自动配置条件通过和没通过的原因
configprops获取所有配置属性,包括默认配置,显示一个所有 @ConfigurationProperties 的整理列版本
env获取所有环境变量
flyway获取已应用的所有Flyway数据库迁移信息,需要一个或多个 Flyway Bean
health获取应用程序健康指标(运行状况信息)
httptrace获取HTTP跟踪信息(默认情况下,最近100个HTTP请求-响应交换)。需要 HttpTraceRepository Bean
info获取应用程序信息
integrationgraph显示 Spring Integration 图。需要依赖 spring-integration-core
loggers显示和修改应用程序中日志的配置
liquibase获取应用的所有Liquibase数据库迁移。需要一个或多个 Liquibase Bean
metrics获取系统度量指标信息
mappings显示所有@RequestMapping路径的整理列表
scheduledtasks显示应用程序中的计划任务
sessions允许从Spring Session支持的会话存储中检索和删除用户会话。需要使用Spring Session的基于Servlet的Web应用程序
shutdown关闭应用
threaddump获取系统线程转储信息

默认情况下,除了shutdown,其他端点都是启动状态。

1.1 如何使用

在项目中引入spring-boot-actuator的依赖,就可以正常使用了

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

1.2 如何访问

/actuator+端点地址

例如想要访问health端点,则访问http://ip:port/actuator/health;

1.3 端点开启/关闭

management:
  endpoint:
      # 开启shutdown端点
    shutdown:
      enabled: true

启用/禁用所有端点

management:
  endpoints:
    enabled-by-default: true

1.4 端点暴露

默认情况下,只有healthinfo暴露了http端口,这些端点支持通过httpJMX访问,如果需要访问具体的端点则需要配置暴露。

暴露http端点

management:
  endpoints:
    web:
      exposure:
        include: health,info

暴露JMX端点

management:
  endpoints:
    jmx:
      exposure:
        include: health,info

二 常用端点解析

2.1 health

health包含的健康检查项有DataSourceHealthIndicatorDiskSpaceHealthIndicatorMongoHealthIndicatorReidsHealthIndicatorCassandraHealthIndicator

关闭特定的检查项配置如下,关闭redis检查项:

management:
  health:
    redis:
      enabled: false

默认情况下health只是简单的展示了UPDOWN两种状态,如果想要看详细信息,则需要配置

management:
  endpoint:
    health:
      show-details: always

2.2 metrics

metrics可以使用带PathVariable参数,参数为具体的度量值,如查看cpu大小,http://localhost:8080/actuator/metrics/system.cpu.count;

2.3 info

info使用的时候需要在配置文件中自定义信息,自定义信息以info开头。

例如在配置文件中增加如下内容:

info:
  person:
    name: Java旅途
    age: 18

访问info端点显示的是去掉info的一个JSON串:

person:
  name: Java旅途
  age: 18

Spring-Boot-acturator使用起来很方便,但是缺点也很明显,就是没有图形化界面。使用起来也不是很友好,下一章中,我们将使用有图形化的Spring-Boot-Admin来进行服务监控。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 1 收藏 1 评论 0

Java旅途 发布了文章 · 10月17日

spring-boot-route(十七)使用aop记录操作日志

在上一章内容中——使用logback管理日志,我们详细讲述了如何将日志生成文件进行存储。但是在实际开发中,使用文件存储日志用来快速查询问题并不是最方便的,一个优秀系统除了日志文件还需要将操作日志进行持久化,来监控平台的操作记录。今天我们一起来学习一下如何通过apo来记录日志。

为了让记录日志更加灵活,我们将使用自定义的注解来实现重要操作的日志记录功能。

一 日志记录表

日志记录表主要包含几个字段,业务模块,操作类型,接口地址,处理状态,错误信息以及操作时间。数据库设计如下:

CREATE TABLE `sys_oper_log` (
   `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '日志主键',
   `title` varchar(50) CHARACTER SET utf8 DEFAULT '' COMMENT '模块标题',
   `business_type` int(2) DEFAULT '0' COMMENT '业务类型(0其它 1新增 2修改 3删除)',
   `method` varchar(255) CHARACTER SET utf8 DEFAULT '' COMMENT '方法名称',
   `status` int(1) DEFAULT '0' COMMENT '操作状态(0正常 1异常)',
   `error_msg` varchar(2000) CHARACTER SET utf8 DEFAULT '' COMMENT '错误消息',
   `oper_time` datetime DEFAULT NULL COMMENT '操作时间',
   PRIMARY KEY (`id`)
 ) ENGINE=InnoDB CHARSET=utf8mb4 CHECKSUM=1 COMMENT='操作日志记录'

对应的实体类如下:

@Data
@NoArgsConstructor
@AllArgsConstructor
public class SysOperLog implements Serializable {
    private static final long serialVersionUID = 1L;

    /** 日志主键 */
    private Long id;

    /** 操作模块 */
    private String title;

    /** 业务类型(0其它 1新增 2修改 3删除) */
    private Integer businessType;

    /** 请求方法 */
    private String method;

    /** 错误消息 */
    private String errorMsg;

    private Integer status;

    /** 操作时间 */
    private Date operTime;
}

二 自定义注解及处理

自定义注解包含两个属性,一个是业务模块title,另一个是操作类型businessType

@Target({ ElementType.PARAMETER, ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Log {
    /**
     * 模块
     */
    String title() default "";

    /**
     * 功能
     */
    BusinessType businessType() default BusinessType.OTHER;
}

使用aop对自定义的注解进行处理

@Aspect
@Component
@Slf4j
public class LogAspect {

    @Autowired
    private AsyncLogService asyncLogService;

    // 配置织入点
    @Pointcut("@annotation(com.javatrip.aop.annotation.Log)")
    public void logPointCut() {}

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "logPointCut()", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, Object jsonResult) {
        handleLog(joinPoint, null, jsonResult);
    }

    /**
     * 拦截异常操作
     * 
     * @param joinPoint 切点
     * @param e 异常
     */
    @AfterThrowing(value = "logPointCut()", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, Exception e) {
        handleLog(joinPoint, e, null);
    }

    protected void handleLog(final JoinPoint joinPoint, final Exception e, Object jsonResult) {
        try {
            // 获得注解
            Log controllerLog = getAnnotationLog(joinPoint);
            if (controllerLog == null) {
                return;
            }

            SysOperLog operLog = new SysOperLog();
            operLog.setStatus(0);
            if (e != null) {
                operLog.setStatus(1);
                operLog.setErrorMsg(StringUtils.substring(e.getMessage(), 0, 2000));
            }
            // 设置方法名称
            String className = joinPoint.getTarget().getClass().getName();
            String methodName = joinPoint.getSignature().getName();
            operLog.setMethod(className + "." + methodName + "()");
            // 处理设置注解上的参数
            getControllerMethodDescription(joinPoint, controllerLog, operLog);
            // 保存数据库
            asyncLogService.saveSysLog(operLog);
        } catch (Exception exp) {
            log.error("==前置通知异常==");
            log.error("日志异常信息 {}", exp);
        }
    }

    /**
     * 获取注解中对方法的描述信息 用于Controller层注解
     * 
     * @param log 日志
     * @param operLog 操作日志
     * @throws Exception
     */
    public void getControllerMethodDescription(JoinPoint joinPoint, Log log, SysOperLog operLog) {
        // 设置action动作
        operLog.setBusinessType(log.businessType().ordinal());
        // 设置标题
        operLog.setTitle(log.title());
    }

    /**
     * 是否存在注解,如果存在就获取
     */
    private Log getAnnotationLog(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        MethodSignature methodSignature = (MethodSignature) signature;
        Method method = methodSignature.getMethod();
        if (method != null) {
            return method.getAnnotation(Log.class);
        }
        return null;
    }
}

操作类型的枚举类:

public enum BusinessType {
    /**
     * 其它
     */
    OTHER,

    /**
     * 新增
     */
    INSERT,

    /**
     * 修改
     */
    UPDATE,

    /**
     * 删除
     */
    DELETE,
}

使用异步方法将操作日志存库,为了方便我直接使用jdbcTemplate在service中进行存库操作。

@Service
public class AsyncLogService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    /**
     * 保存系统日志记录
     */
    @Async
    public void saveSysLog(SysOperLog log) {

        String sql = "INSERT INTO sys_oper_log(title,business_type,method,STATUS,error_msg,oper_time) VALUES(?,?,?,?,?,?)";
        jdbcTemplate.update(sql,new Object[]{log.getTitle(),log.getBusinessType(),log.getMethod(),log.getStatus(),log.getErrorMsg(),new Date()});
    }
}

三 编写接口测试

将自定义注解写在业务方法上,测试效果

@RestController
@RequestMapping("person")
public class PersonController {
    @GetMapping("/{name}")
    @Log(title = "system",businessType = BusinessType.OTHER)
    public Person getPerson(@PathVariable("name") String name, @RequestParam int age){
        return new Person(name,age);
    }

    @PostMapping("add")
    @Log(title = "system",businessType = BusinessType.INSERT)
    public int addPerson(@RequestBody Person person){
        if(StringUtils.isEmpty(person)){
            return -1;
        }
        return 1;
    }

    @PutMapping("update")
    @Log(title = "system",businessType = BusinessType.UPDATE)
    public int updatePerson(@RequestBody Person person){
        if(StringUtils.isEmpty(person)){
            return -1;
        }
        return 1;
    }

    @DeleteMapping("/{name}")
    @Log(title = "system",businessType = BusinessType.DELETE)
    public int deletePerson(@PathVariable(name = "name") String name){
        if(StringUtils.isEmpty(name)){
            return -1;
        }
        return 1;
    }
}

当然,还可以在数据库中将请求参数和响应结果也进行存储,这样就能看出具体接口的操作记录了。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 1 评论 2

Java旅途 发布了文章 · 10月16日

如何设计一个牛逼的API接口

在日常开发中,总会接触到各种接口。前后端数据传输接口,第三方业务平台接口。一个平台的前后端数据传输接口一般都会在内网环境下通信,而且会使用安全框架,所以安全性可以得到很好的保护。这篇文章重点讨论一下提供给第三方平台的业务接口应当如何设计?我们应该考虑哪些问题?

主要从以上三个方面来设计一个安全的API接口。

一 安全性问题

安全性问题是一个接口必须要保证的规范。如果接口保证不了安全性,那么你的接口相当于直接暴露在公网环境中任人蹂躏。

1.1 调用接口的先决条件-token

获取token一般会涉及到几个参数appidappkeytimestampnoncesign。我们通过以上几个参数来获取调用系统的凭证。

appidappkey可以直接通过平台线上申请,也可以线下直接颁发。appid是全局唯一的,每个appid将对应一个客户,appkey需要高度保密。

timestamp是时间戳,使用系统当前的unix时间戳。时间戳的目的就是为了减轻DOS攻击。防止请求被拦截后一直尝试请求接口。服务器端设置时间戳阀值,如果请求时间戳和服务器时间超过阀值,则响应失败。

nonce是随机值。随机值主要是为了增加sign的多变性,也可以保护接口的幂等性,相邻的两次请求nonce不允许重复,如果重复则认为是重复提交,响应失败。

sign是参数签名,将appkeytimestampnonce拼接起来进行md5加密(当然使用其他方式进行不可逆加密也没问题)。

token,使用参数appidtimestampnoncesign来获取token,作为系统调用的唯一凭证。token可以设置一次有效(这样安全性更高),也可以设置时效性,这里推荐设置时效性。如果一次有效的话这个接口的请求频率可能会很高。token推荐加到请求头上,这样可以跟业务参数完全区分开来。

1.2 使用POST作为接口请求方式

一般调用接口最常用的两种方式就是GET和POST。两者的区别也很明显,GET请求会将参数暴露在浏览器URL中,而且对长度也有限制。为了更高的安全性,所有接口都采用POST方式请求。

1.3 客户端IP白名单

ip白名单是指将接口的访问权限对部分ip进行开放。这样就能避免其他ip进行访问攻击,设置ip白名单比较麻烦的一点就是当你的客户端进行迁移后,就需要重新联系服务提供者添加新的ip白名单。设置ip白名单的方式很多,除了传统的防火墙之外,spring cloud alibaba提供的组件sentinel也支持白名单设置。为了降低api的复杂度,推荐使用防火墙规则进行白名单设置。

1.4 单个接口针对ip限流

限流是为了更好的维护系统稳定性。使用redis进行接口调用次数统计,ip+接口地址作为key,访问次数作为value,每次请求value+1,设置过期时长来限制接口的调用频率。

1.5 记录接口请求日志

使用aop全局记录请求日志,快速定位异常请求位置,排查问题原因。

1.6 敏感数据脱敏

在接口调用过程中,可能会涉及到订单号等敏感数据,这类数据通常需要脱敏处理,最常用的方式就是加密。加密方式使用安全性比较高的RSA非对称加密。非对称加密算法有两个密钥,这两个密钥完全不同但又完全匹配。只有使用匹配的一对公钥和私钥,才能完成对明文的加密和解密过程。

二 幂等性问题

幂等性是指任意多次请求的执行结果和一次请求的执行结果所产生的影响相同。说的直白一点就是查询操作无论查询多少次都不会影响数据本身,因此查询操作本身就是幂等的。但是新增操作,每执行一次数据库就会发生变化,所以它是非幂等的。

幂等问题的解决有很多思路,这里讲一种比较严谨的。提供一个生成随机数的接口,随机数全局唯一。调用接口的时候带入随机数。第一次调用,业务处理成功后,将随机数作为key,操作结果作为value,存入redis,同时设置过期时长。第二次调用,查询redis,如果key存在,则证明是重复提交,直接返回错误。

三 数据规范问题

3.1 版本控制

一套成熟的API文档,一旦发布是不允许随意修改接口的。这时候如果想新增或者修改接口,就需要加入版本控制,版本号可以是整数类型,也可以是浮点数类型。一般接口地址都会带上版本号,http://ip:port//v1/list。

3.2 响应状态码规范

一个牛逼的API,还需要提供简单明了的响应值,根据状态码就可以大概知道问题所在。我们采用http的状态码进行数据封装,例如200表示请求成功,4xx表示客户端错误,5xx表示服务器内部发生错误。状态码设计参考如下:

分类描述
1xx信息,服务器收到请求,需要请求者继续执行操作
2xx成功
3xx重定向,需要进一步的操作以完成请求
4xx客户端错误,请求包含语法错误或无法完成请求
5xx服务端错误

状态码枚举类:

public enum CodeEnum {

    // 根据业务需求进行添加
    SUCCESS(200,"处理成功"),
    ERROR_PATH(404,"请求地址错误"),
    ERROR_SERVER(505,"服务器内部发生错误");
    
    private int code;
    private String message;
    
    CodeEnum(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

3.3 统一响应数据格式

为了方便给客户端响应,响应数据会包含三个属性,状态码(code),信息描述(message),响应数据(data)。客户端根据状态码及信息描述可快速知道接口,如果状态码返回成功,再开始处理数据。

响应结果定义及常用方法:

public class R implements Serializable {

    private static final long serialVersionUID = 793034041048451317L;

    private int code;
    private String message;
    private Object data = null;

    public int getCode() {
        return code;
    }
    public void setCode(int code) {
        this.code = code;
    }

    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }

    public Object getData() {
        return data;
    }

    /**
     * 放入响应枚举
     */
    public R fillCode(CodeEnum codeEnum){
        this.setCode(codeEnum.getCode());
        this.setMessage(codeEnum.getMessage());
        return this;
    }

    /**
     * 放入响应码及信息
     */
    public R fillCode(int code, String message){
        this.setCode(code);
        this.setMessage(message);
        return this;
    }

    /**
     * 处理成功,放入自定义业务数据集合
     */
    public R fillData(Object data) {
        this.setCode(CodeEnum.SUCCESS.getCode());
        this.setMessage(CodeEnum.SUCCESS.getMessage());
        this.data = data;
        return this;
    }
}

总结

本篇文章从安全性、幂等性、数据规范等方面讨论了API设计规范。除此之外,一个好的API还少不了一个优秀的接口文档。接口文档的可读性非常重要,虽然很多程序员都不喜欢写文档,而且不喜欢别人不写文档。为了不增加程序员的压力,推荐使用swagger或其他接口管理工具,通过简单配置,就可以在开发中测试接口的连通性,上线后也可以生成离线文档用于管理API。

点关注、不迷路

如果觉得文章不错,欢迎关注点赞收藏,你们的支持是我创作的动力,感谢大家。

如果文章写的有问题,请不要吝啬,欢迎留言指出,我会及时核查修改。

如果你还想更加深入的了解我,可以微信搜索「Java旅途」进行关注。回复「1024」即可获得学习视频及精美电子书。每天7:30准时推送技术文章,让你的上班路不在孤独,而且每月还有送书活动,助你提升硬实力!

查看原文

赞 32 收藏 29 评论 1

Java旅途 发布了文章 · 10月15日

spring-boot-route(十六)使用logback生产日志文件

日志是一个系统非常重要的一部分,我们经常需要通过查看日志来定位问题,今天我们一起来学习一下Spring Boot的日志系统。有很多同学习惯性的在生产代码中使用System.out来输出日志,这是不推荐的一种做法,因为System.out是一个同步操作,会在一定程度上影响系统性能,而Logger是一个异步操作。

Spring Boot默认的日志系统是logback,当然我们并不需要去引用logback的依赖,因为在spring-boot-starter中已经应用了logback的依赖。

一、控制台日志信息介绍

1.1 日志级别

日志级别从高到低为:TRACE < DEBUG < INFO < WARN < ERROR < ALL < OFF

如果日志设置为ERROR,那么低于ERROR级别的日志将不会输出。

如果我们想要设置某个包的日志级别,则在pom文件中加入下面这行配置:

logging:
  level:
      # 包名
    com.javatrip: warn

如果想修改Spring Boot默认级别,则将包名改为root

logging:
  level:
    root: warn

1.2 控制台日志介绍

默认情况下,Spring Boot会将INFO级别的日志输出到控制台。控制台输出信息如下:

日志输出内容具体含义如下:

  • 时间日期:精确到毫秒
  • 日志级别:ERROR, WARN, INFO, DEBUG or TRACE
  • 进程ID
  • 分隔符:--- 标识实际日志的开始
  • 线程名:方括号括起来(可能会截断控制台输出)
  • Logger名:通常使用源代码的类名
  • 日志内容

二、日志文件输出

在实际项目中,我们需要将日志输出为文件,以便快速定位问题。Spring Boot关于日志文件的信息可以参考官网https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-logging

Because the standard logback.xml configuration file is loaded too early, you cannot use extensions in it. You need to either use logback-spring.xml or define a logging.config property.

这句话的意思大概就是:由于标准的logback.xml配置文件加载得太早,因此您不能在其中使用扩展名。您需要使用logback-spring.xml或定义logging.config属性。

因此我们来定义一个logback-spring.xml的文件来进行日志信息的配置。

logback-spring.xml文件定义及注释:

<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 日志文件名 -->
    <property name="LOG_FILE" value="myLog" />
    <!-- 日志文件路径 -->
    <property name="LOG_PATH" value="D://log//dev" />
    <!-- 控制台日志输出格式 -->
    <property name="LOG_PATTERN_CONSOLE" value="%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{50} --> %msg%n" />
    <!-- 文件日志输出格式 -->
    <property name="LOG_PATTERN_FILE" value="%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{50} --> %msg%n" />
    <!--- 设置控制台日志 -->
    <appender name="consoleLog" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>${LOG_PATTERN_CONSOLE}</pattern>
        </encoder>
    </appender>
    <!-- 设置日志文件 -->
    <appender name="fileLog" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <encoder>
            <pattern>${LOG_PATTERN_FILE}</pattern>
        </encoder>
        <!-- 总文件日志 -->
        <file>${LOG_PATH}/${LOG_FILE}.log</file>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 每天的文件日志 -->
            <fileNamePattern>${LOG_PATH}/${LOG_FILE}-%d{yyyy-MM-dd}.log</fileNamePattern>
            <!-- 日志文件保存7天,超过7天的自动删除 -->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
    </appender>

    <!-- 设置日志级别,及需要记录日志的类 -->
    <root level="INFO">
        <appender-ref ref="consoleLog" />
        <appender-ref ref="fileLog" />
    </root>
</configuration>

启动项目后,在D:\log\dev中会生产我们的日志文件myLog.log,加入我们系统一直运行,则在我们的文件目录下会生成一个myLog.log文件和7个最近日志的文件myLog-某年-某月-某日.log


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 3 收藏 2 评论 0

Java旅途 发布了文章 · 10月14日

spring-boot-route(十五)整合RocketMQ

RocketMQ简介

RocketMQ是阿里巴巴开源的消息中间件。目前已经贡献给Apache软件基金会,成为Apache的顶级项目。

rocketMQ基本概念

1. Producer Group

生产者组:是一类生产者的集合,通常发送同一类消息并且发送逻辑一致。

2. Producer

生产者:负责发送消息,有三种消息发送模式。

  • 同步发送:收到确认后再发送下一条消息
  • 异步发送:发送后,不等待确认继续发送下一条
  • 单向发送:只负责发送消息,无法确认并且没有回调,适合收集日志

3. Consumer Group

消费者组:是一类消费者的集合,通常消费同一类消息并且消费逻辑一致。

4. Consumer

消息者:负责消费消息,有两种消费模式

  • 拉取型消费:主动从消息服务器拉取信息,只要批量拉取到消息,用户应用就会启动消费过程
  • 推送型消费:实际上也是拉取消息,只不过是将拉取逻辑进行了封装,将消息到达时执行的回调接口留给用户来实现

5. Broker

消息服务器:存储消息

6. NameServer

作用和zookeeper类似,用来保存broker相关元素,并给producer和consumer查找broker消息,Producer 在发送消息前会根据 Topic 到 NameServer 获取到 Broker 的路由信息,Consumer 也会定时获取 Topic 的路由信息。

7. Topic

消息主题

8. Tag

标签,Topic的二级分类,也可以理解为消息队列,主题被划分为一个或多个子主题,即消息队列。一个 Topic 下可以设置多个消息队列,发送消息时执行该消息的 Topic ,RocketMQ 会轮询该 Topic 下的所有队列将消息发出去。

Spring Boot整合Rocketmq

1. 引入依赖

<dependency>
    <groupId>org.apache.rocketmq</groupId>
    <artifactId>rocketmq-spring-boot-starter</artifactId>
    <version>2.1.0</version>
</dependency>

2. 配置rocketmq信息

rocketmq:
  name-server: 127.0.0.1:9876
  producer:
    group: my-producer-group

3. 构建生产者

@RestController
public class Producer {

    @Autowired
    private RocketMQTemplate rocketMQTemplate;

    @GetMapping("send")
    public void send(){

        rocketMQTemplate.convertAndSend("first-topic","你好,Java旅途");
    }
}

4. 构建消费者

@Component
@RocketMQMessageListener(topic = "first-topic",consumerGroup = "my-consumer-group")
@Slf4j
public class Consumer implements RocketMQListener<String> {

    @Override
    public void onMessage(String message) {
        log.info("我收到消息了!消息内容为:"+message);
    }
}

emmm,消息队列的内容就暂时告一段落了,文章中只是演示了最简单的收发消息,在实际应用中需要考虑的问题远比这要多。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 2 评论 0

Java旅途 发布了文章 · 10月13日

spring-boot-route(十四)整合Kafka

在上一章中SpringBoot整合RabbitMQ,已经详细介绍了消息队列的作用,这一种我们直接来学习SpringBoot如何整合kafka发送消息。

kafka简介

kafka是用Scala和Java语言开发的,高吞吐量的分布式消息中间件。高吞吐量使它在大数据领域具有天然的优势,被广泛用来记录日志。

kafka架构分析

注1:图中的红色箭头表示消息的流动过程,蓝色表示分区备份,绿色表示kafka集群注册到zookeeper。

注2:在kafka0.9版本之前,消费者消费消息的位置记录在zookeeper中,在0.9版本之后,消费消息的位置记录在kafka的一个topic上。

kafka名词简介

  1. Producer:消息生产者
  2. Consumer:消息消费者
  3. Consumer Group(CG):消费者组,一个topic可以有多个CG,每个Partition只会把消息发送给GG中的一个Consumer
  4. Broker:一台kafka服务器就是一个broker,一个broker有多个topic
  5. Topic:消息主题,消息分类,可看作队列
  6. Partition:分区,为了实现扩展,一个大的topic可能分布到多个broker上,一个topic可以分为多个partition,partition中的每条消息都会被分配一个有序的id(offset),每个partiton中的消息是有序的。
  7. Offset:kafka的存储文件都是按照offset.kafka来命名的,方便查找,第一个offset为0000000000.kafka。
  8. Leader:分区具有被备份,主分区
  9. Follower:从分区

1. 生产者分区策略

  1. 指定分区。
  2. 没有指定分区但有key值,将key的hash值与当前topic的分区个数进行取余得到分区。
  3. 如果既没有指定分区又没有指定key,第一次调用时随机生成一个整数(以后调用每次在这个整数上自增),将这个随机数与该topic的分区数取余得到分区。

2. 消息可靠性问题

采用ack确认机制来保证消息的可靠性。

kafka在发送消息后会同步到其他分区副本,等所有副本都接收到消息后,kafka才会发送ack进行确认。采用这种模式的劣势就是当其中一个副本宕机后,则消息生产者就不会收到kafka的ack。

kafka采用ISR来解决这个问题。

ISR:Leader维护的一个和leader保持同步的follower集合。

当ISR中的folower完成数据同步之后,leader就会向follower发送ack,如果follower长时间未向leader同步数据,则该follower就会被踢出ISR,该时间阀值的设置参数为replica.lag.time.max.ms,默认时间为10s,leader发生故障后,就会从ISR中选举新的leader。

注:本文所讲的kafka版本为0.11,在0.9版本以前成为ISR还有一个条件,就是同步消息的条数。

ack参数配置

0:生产者不等待broker的ack。

1:leader分区接收到消息向生产者发送ack。

-1(all):ISR中的leader和follower同步成功后,向生产者发送ack。

3. 消息一致性问题

假如leader中有10条消息,向两个follower同步数据,follower A同步了8条,follower B同步了9条。这时候leader宕机了,follower A和follower B中的消息是不一致的,剩下两个follower就会重新选举出一个leader。

  • LEO(log end offset):每个副本的最后一个offset
  • HW(high watermark):所有副本中最小的offset

为了保证数据的一致性,所有的follower会将各自的log文件高出HW的部分截掉,然后再从新的leader中同步数据。

4. 消息重复性问题

在kafka0.11版本中引入了一个新特性:幂等性。启用幂等性后,ack默认为-1。将生产者中的enable.idompotence设置为true,即启用了幂等性。

开启幂等性的Producer在初始化的时候会被分配一个PID,发往同一Partition的消息会附带Sequence Number。Broker端会对<PID,Partition,SeqNumber>做缓存,当具有相同主键的消息提交时,Broker只会缓存一条。但是每次重启PID就会发生变化,因此只能保证一次会话同一分区的消息不重复。

5. 消费者组分区分配策略

kafka有两种分配策略,一种是RoundRobin,另一种是Range

RoundRobin是按照消费者组以轮询的方式去给消费者分配分区的方式,前提条件是消费者组中的消费者需要订阅同一个topic。

Range是kafka默认的分配策略,它是通过当前的topic按照一定范围来分配的,假如有3个分区,消费者组有两个消费者,则消费者A去消费1和2分区,消费者B去消费3分区。

6. 消费者offset维护

Kafka 0.9 版本之前,consumer默认将offset保存在zookeeper中,0.9 版本开始,offset保存在kafka的一个内置topic中,该topic为_consumer_offsets

7. 生产者事务

为了实现跨分区会话的事务,需要引入一个全局唯一的Tracscation ID,并将Producer 获得的PID与之绑定。这样当Producer重启后就可以通过正在进行的Transaction ID获得原来的PID。

为了管理Transcation ID,kafka引入了一个新的组件Transcation Coordinator。Producer就是通过和Transcation Coordinator交互获得Transction ID对应的任务状态。

Spring Boot 整合kafka

1. 引入kafka依赖

<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
</dependency>

2. 配置kafka服务信息

spring:
  kafka:
    # kafka服务地址
    bootstrap-servers: 47.104.155.182:9092
    producer:
      # 生产者消息key序列化方式
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      # 生产者消息value序列化方式
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      # 消费者组
      group-id: test-consumer-group
      # 消费者消息value反序列化方式
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      # 消费者消息value反序列化方式
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

3. 消费者

@Component
@Slf4j
@KafkaListener(topics = {"first-topic"},groupId = "test-consumer-group")
public class Consumer {

    @KafkaHandler
    public void receive(String message){
        
        log.info("我是消费者,我接收到的消息是:"+message);
    }
}

4. 生产者

@RestController
public class Producer {

    @Autowired
    private KafkaTemplate kafkaTemplate;

    @GetMapping("send")
    public void send(){

        String message = "你好,我是Java旅途";
        // 第一个参数 topic
        // 第二个参数 消息
        kafkaTemplate.send("first-topic",message);
    }
}

本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 1 收藏 1 评论 0

Java旅途 发布了文章 · 10月12日

spring-boot-route(十三)整合RabbitMQ

这篇是SpringBoot整合消息队列的第一篇文章,我们详细介绍下消息队列的相关内容。

消息队列简介

1. 什么是消息队列

MQ(Message Quene):通过典型的生产者和消费者模型,生产者不断向消息队列中产生消息,消费者不断的从队列中获取消息。因为生产者和消费者都是异步的,而且生产者只关心消息的发送,消费者只关心消息的接收,没有业务逻辑的侵入,轻松实现业务解耦。

2. 消息队列有什么用

  • 异步处理

场景描述:某商场具有注册功能,注册的时候需要发送短信验证码。

传统的做法是用户提交信息到用户服务,用户服务调用短信服务发送短信,然后给用户返回响应,这种是同步的处理方式,耗时较长。加入消息队列后,用户直接提交信息到用户服务,将信息写入消息队列,直接给用户返回响应,短信服务从消息队列中读取消息进行发送短信。

  • 应用解耦

场景描述:某商场下单流程。

传统做法是用户下单,订单系统去查询库存系统,如果库存系统宕机了,则下单失败,损失订单量。加入消息队列后,用户下单,订单系统记录订单,将订单信息写入消息队列,下单成功,然后库存系统恢复正常后去操作数据库库存(不考虑库存为0的情况)。这样订单系统和库存系统就达到松耦合的目的了

  • 流量削峰

场景描述:秒杀活动。

流量过大肯定会导致响应超时或系统宕机,加入消息队列,用户秒杀请求写入消息队列,设置消息队列的长度等属性,达到消息队列最大长度后,直接返回秒杀失败,然后再去消费消息队列的数据,完成秒杀。

RabbitMQ简介

RabbitMQ是用Erlang语言编写的,实现了高级消息队列协议(AMQP)的消息中间件。

1. AMQP协议概念

AMQPAMQP是一种链接协议,直接定义网络交换的数据格式,这使得实现了AMQPprovider本身就是跨平台的。以下是AMQP协议模型:

  • server - 又称broker,接收客户端的链接,实现amqp实体服务。
  • Connection - 链接,应用程序跟broker的网络链接。
  • channel - 网络信道,几乎所有的操作都是在channel中进行,数据的流转都要在channel上进行。channel是进行消息读写的通道。客户端可以建立多个channel,每个channel代表一个会话任务。
  • message - 消息,服务器与应用程序之间传送的数据。由properties和body组成。properties可以对消息进行修饰,比如消息的升级,延迟等高级特性。body就是消息体的内容。
  • virtual host - 虚拟主机,用于进行逻辑隔离,最上层的消息路由,一个虚拟地址里面可以有多个交换机。exchange和消息队列message quene。
  • exchange - 交换机,接收消息,根据路由器转发消息到绑定的队列。
  • binding - 绑定,交换机和队列之间的虚拟链接,绑定中可以包含routing key。
  • routing key - 一个路由规则,虚拟机可以用它来确定jiekyi如何路由一个特定消息。
  • quene - 消息队列,保存消息并将它们转发给消费者。

2. RabbitMQ的消息模型

1. 简单模型

img

在上图中:

  • p:生成者
  • C:消费者
  • 红色部分:quene,消息队列

2. 工作模型

img

在上图中:

  • p:生成者
  • C1、C2:消费者
  • 红色部分:quene,消息队列

当消息处理比较耗时时,就会出现生产消息的速度远远大于消费消息的速度,这样就会出现消息堆积,无法及时处理。这时就可以让多个消费者绑定一个队列,去消费消息,队列中的消息一旦消费就会丢失,因此任务不会重复执行。

3. 广播模型(fanout)

img

这种模型中生产者发送的消息所有消费者都可以消费。

在上图中:

  • p:生成者
  • X:交换机
  • C1、C2:消费者
  • 红色部分:quene,消息队列

4. 路由模型(routing)

python-four.png (423×171)

这种模型消费者发送的消息,不同类型的消息可以由不同的消费者去消费。

在上图中:

  • p:生成者
  • X:交换机,接收到生产者的消息后将消息投递给与routing key完全匹配的队列
  • C1、C2:消费者
  • 红色部分:quene,消息队列

5. 订阅模型(topic)

img

这种模型和direct模型一样,都是可以根据routing key将消息路由到不同的队列,只不过这种模型可以让队列绑定routing key 的时候使用通配符。这种类型的routing key都是由一个或多个单词组成,多个单词之间用.分割。

通配符介绍:

*:只匹配一个单词

#:匹配一个或多个单词

6. RPC模型

img

这种模式需要通知远程计算机运行功能并等待返回运行结果。这个过程是阻塞的。

当客户端启动时,它创建一个匿名独占回调队列。并提供名字为call的函数,这个call会发送RPC请求并且阻塞直到收到RPC运算的结果。

Spring Boot整合RabbitMQ

第一步:引入pom依赖

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

第二步:增加RabbitMQ服务配置信息

spring:
  rabbitmq:
    virtual-host: javatrip
    port: 5672
    host: 127.0.0.1
    username: guest
    password: guest

这里我们用广播模型来举例使用,广播模型(fanout)比较好理解,就像公众号一样,我每天推文章后,会推送给每个关注用户,他们都可以看到这条消息。

广播模型注意点:

  1. 可以有多个队列
  2. 每个队列都需要绑定交换机
  3. 每个消费者有自己的队列
  4. 交换机把消息发送给绑定过的所有队列

1. 定义两个队列

@Configuration
public class RabbitConfig {

    final static String queueNameA = "first-queue";
    final static String queueNameB = "second-queue";

    /***
     * 定义一个队列,设置队列属性
     * @return
     */
    @Bean("queueA")
    public Queue queueA(){

        Map<String,Object> map = new HashMap<>();
        // 消息过期时长,10秒过期
        map.put("x-message-ttl",10000);
        // 队列中最大消息条数,10条
        map.put("x-max-length",10);
        // 第一个参数,队列名称
        // 第二个参数,durable:持久化
        // 第三个参数,exclusive:排外的,
        // 第四个参数,autoDelete:自动删除
        Queue queue = new Queue(queueNameA,true,false,false,map);
        return queue;
    }
    
    @Bean("queueB")
    public Queue queueB(){

        Map<String,Object> map = new HashMap<>();
        // 消息过期时长,10秒过期
        map.put("x-message-ttl",10000);
        // 队列中最大消息条数,10条
        map.put("x-max-length",10);
        // 第一个参数,队列名称
        // 第二个参数,durable:持久化
        // 第三个参数,exclusive:排外的,
        // 第四个参数,autoDelete:自动删除
        Queue queue = new Queue(queueNameB,true,false,false,map);
        return queue;
    }
}

2. 定义扇形交换机

@Bean
public FanoutExchange fanoutExchange(){

    // 第一个参数,交换机名称
    // 第二个参数,durable,是否持久化
    // 第三个参数,autoDelete,是否自动删除
    FanoutExchange fanoutExchange = new FanoutExchange(exchangeName,true,false);
    return fanoutExchange;
}

3. 交换机和队列绑定

@Bean
public Binding bindingA(@Qualifier("queueA") Queue queueA, FanoutExchange fanoutExchange){
    Binding binding = BindingBuilder.bind(queueA).to(fanoutExchange);
    return binding;
}

@Bean
public Binding bindingB(@Qualifier("queueB") Queue queueB,FanoutExchange fanoutExchange){
    Binding binding = BindingBuilder.bind(queueB).to(fanoutExchange);
    return binding;
}

4. 创建两个消费者分别监听两个队列

@RabbitListener(queues = RabbitConfig.queueNameA)
@Component
@Slf4j
public class ConsumerA {

    @RabbitHandler
    public void receive(String message){
        log.info("消费者A接收到的消息:"+message);
    }
}
@RabbitListener(queues = RabbitConfig.queueNameB)
@Component
@Slf4j
public class ConsumerB {

    @RabbitHandler
    public void receive(String message){
        log.info("消费者B接收到的消息:"+message);
    }
}

5. 创建生产者生产消息

@RestController
public class provider {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("send")
    public void sendMessage(){

        String message = "你好,我是Java旅途";
        rabbitTemplate.convertAndSend(RabbitConfig.exchangeName,null,message);
    }
}

这样生产者发送一条消息后,两个消费者就能同时消费到消息了。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 6 收藏 4 评论 0

Java旅途 发布了文章 · 10月11日

spring-boot-route(十二)整合redis做为缓存

redis简介

redis作为一种非关系型数据库,读写非常快,应用十分广泛,它采用key-value的形式存储数据,value常用的五大数据类型有string(字符串),list(链表),set(集合),zset(有序集合)和hash(哈希表)。

redis的特性决定了它的功能,它可以用来做以下这些事情!

  1. 排行榜,利用zset可以方便的实现排序功能
  2. 计数器,利用redis中原子性的自增操作,可以统计到阅读量,点赞量等功能
  3. 简单消息队列,list存储结构,满足先进先出的原则,可以使用lpush/rpop或rpush/lpop实现简单消息队列
  4. session共享,分布式系统中,可以利用redis实现session共享。spring官方提供的分布式解决方案Spring Session就是利用redis 实现的。

Spring Boot对redis也实现自动化装配,使用非常方便。

Spring Boot整合redis

1. 引入redis依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
           <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
</dependencies>

2. 配置redis相关信息

spring:
  redis:
    # redis库
    database: 0
    # redis 服务器地址
    host: localhost
    # redis 端口号
    port: 6379
    # redis 密码
    password:
    # 连接超时时间(毫秒)
    timeout: 1000
    lettuce:
      pool:
        # 连接池最大链接数(负数表示没有限制)
        max-active: 8
        # 连接池最大阻塞等待时间(负数表示没有限制)
        max-wait: -1
        # 连接池最大空闲连接数
        max-idle: 8
        # 连接池最小空闲连接数
        min-idle: 0

3. 操作redis

SpringBoot提供了两个bean来操作redis,分别是RedisTemplateStringRedisTemplate,这两者的主要区别如下。

RedisTemplate使用的是JdkSerializationRedisSerializer 存入数据会将数据先序列化成字节数组然后在存入Redis数据库。

StringRedisTemplate使用的是StringRedisSerializer。

下面一起来看看效果:

@RestController
public class RedisDemo {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @GetMapping("redisTmeplateData")
    public void redisTemplateData(){

        redisTemplate.opsForValue().set("name","Java旅途");
    }

    @GetMapping("stringRedisTemplateData")
    public void stringRedisTemplateData(){

        stringRedisTemplate.opsForValue().set("desc","坚持分享java技术栈");
    }
}

第一个方法存入的数据如下图

第二个方法存入的数据如下图

由于RedisTemplate是序列化成字节数组存储的,因此在redis客户端的可读性并不好。

自动缓存

@Cacheable可以标记在一个方法上,也可以标记在一个类上。当标记在一个方法上时表示该方法是支持缓存的,当标记在一个类上时则表示该类所有的方法都是支持缓存的。

如果添加了@Cacheable注解,那么方法被调用后,值会被存入redis,下次再调用的时候会直接从redis中取值返回。

@GetMapping("getStudent")
@Cacheable(value = "student:key")
public Student getStudent(){
    log.info("我不是缓存,我是new的对象!");
    Student student = new Student("Java旅途",26);
    return student;
}

记得要开启缓存,在启动类加上@EnableCaching注解

访问上面的方法,如果不打印日志,则是从缓存中获取的值。

封装redisUtils

RedisTemplate提供了很多方法来操作redis,但是找起来比较费事,为了更好的操作redis,一般会封装redisUtils来满足业务开发。这里简单封装几个做个示例,如果开发中有需求可以自己封装。

public class RedisUtils {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 普通存入
     * @param key
     * @param value
     * @return
     */
    public boolean set(String key,Object value){
        try {
            redisTemplate.opsForValue().set(key,value);
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通获取key
     * @param key
     * @return
     */
    public Object get(String key){
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 存入key,设置过期时长
     * @param key
     * @param value
     * @param time
     * @return
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time > 0){
                redisTemplate.opsForValue().set(key,value,time, TimeUnit.SECONDS);
            }else{
                redisTemplate.opsForValue().set(key,value);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    public boolean exists(String key){
        try {
            return redisTemplate.hasKey(key);
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除key
     * @param key
     */
    public void del(String key){
        try {
            if(key != null && key.length() > 0){
                redisTemplate.delete(key);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 4 收藏 2 评论 0

Java旅途 发布了文章 · 10月11日

spring-boot-route(十一)数据库配置信息加密

Spring Boot最大的特点就是自动配置了,大大的减少了传统Spring框架的繁琐配置,通过几行简单的配置就可以完成其他组件的接入。比如你想要连接mysql数据库,只需要的配置文件里面加入mysql的一些配置信息就可以了。为了保护数据的安全性,越来越多的公司选择加密这些重要信息。接下来一起来看看如何实现配置加密文件并且成功连接数据库的。

配置信息加密有好几种方式,这里我只详细的写一下我比较常用的一种方式。首先通过某种加密算法将用户名和密码进行加密,然后在配置文件中用加密串代替原来的明文。然后自定义数据源,在自定义数据源中解密用户名和密码。

SpringBoot自动装配

SpringBoot的自动装配,以前的推文中也详细的讲到过,今天简单来复习一下。在每个Spring Boot的应用的启动类上都能发现有一个注解@SpringBootApplication,这个注解包含的注解@EnableAutoConfiguration就是用来完成自动装配的。这个注解通过导入类AutoConfigurationImportSelector,这个类中有一个方法selectImports,其作用就是扫描所有jar包中的META-INF/spring.factories文件,去加载里面的具体实现类,完成自动装配。

spring-boot-autoconfigurejar包的META-INF/spring.factories文件中指定了一个类用来加载数据库配置信息,这个类就是org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration

自定义数据源

这里使用HikariDataSource作为自定义的数据源,自定义的数据源目的就是为了解密配置文件中的配置信息。

@Configuration
public class DataSourceConfiguration {

    @Autowired
    DataSourceProperties properties;

    @Bean
    public DataSource dataSource() throws Exception{
        String username = Des3.decryptThreeDESECB(properties.getUsername(),Des3.DES3KEY);
        String password = Des3.decryptThreeDESECB(properties.getPassword(),Des3.DES3KEY);
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setDriverClassName(properties.getDriverClassName());
        dataSource.setJdbcUrl(properties.getUrl());
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

配置文件信息如下:

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/xxx
    username: aMkeRCLWqNw=
    password: rq-fzucH32I=

具体的加解密算法这里就不在提及了,根据具体要求选择一种可逆的加密算法就可以了,如果还不是很了解加密算法的种类,可以参考我以前写的一篇文章——面试官:说一下你常用的加密算法


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 2 评论 0

Java旅途 回答了问题 · 10月10日

关于?用作返回值的参数类型,有没有什么隐患?

无任何隐患,相当于泛型,其实用Object类型代替就行啦

关注 5 回答 4

Java旅途 发布了文章 · 10月9日

spring-boot-route(十)多数据源切换

前面我们已经介绍了三种方式来操作数据库,在实际开发中,往往会出现一个服务连接多个数据库的需求,这时候就需要在项目中进行灵活切换数据源来完成多个数据库操作。这一章中,我们使用jdbcTemplate来学习多数据源的配置。

一 准备工作

1.1 建库、建表

我们新建两个库db1db2,数据结构还是用前面演示的,分别在两个库中新建表student

CREATE TABLE `student` (
   `student_id` int(30) NOT NULL AUTO_INCREMENT,
   `age` int(1) DEFAULT NULL COMMENT '年龄',
   `name` varchar(45) DEFAULT NULL COMMENT '姓名',
   `sex` int(1) DEFAULT NULL COMMENT '性别:1:男,2:女,0:未知',
   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
   `status` int(1) DEFAULT NULL COMMENT '状态:1:正常,-1:删除',
   PRIMARY KEY (`student_id`)
 ) ENGINE=InnoDB CHARSET=utf8mb4 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC COMMENT='学生表'

1.2 引入mysql和jdbcTemplate依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

1.3 写入两个数据源配置

spring:
  datasource:
    db1:
      driver-class-name: com.mysql.cj.jdbc.Driver
      jdbc-url: jdbc:mysql://localhost:3306/db1
      username: root
      password: root
    db2:
      driver-class-name: com.mysql.cj.jdbc.Driver
      jdbc-url: jdbc:mysql://localhost:3306/db2
      username: root
      password: root

二 多数据源配置

@Configuration
public class DataSourceConfig {

    @Primary
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.db1")
    public DataSource db1DataSource(){
        return DataSourceBuilder.create().build();
    }

    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.db2")
    public DataSource db2DataSource(){
        return DataSourceBuilder.create().build();
    }
}
  • @Primary:表示主的,即出现多个bean的时候如果不指定具体的bean,则会采用这个
  • @bean:标注为一个bean,如果不指定name属性,则会使用创建bean方法的名字做为bean的名字
  • @ConfigurationProperties:读取配置文件

三 配置JdbcTemplate对象

@Configuration
public class DataSourceConfig {
    
    @Bean
    public JdbcTemplate db1JdbcTemplate(@Qualifier("db1DataSource") DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
    @Primary
    @Bean
    public JdbcTemplate db2JdbcTemplate(@Qualifier("db2DataSource") DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
}
  • @Qualifier:bean类型相同后,指定使用的bean的name

四 测试类

4.1 测试@Primary属性

不指定使用哪个JdbcTemplate对象时,会使用标注了@Primary属性的对象

@SpringBootTest
class SpringBootDatasourceApplicationTests {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Test
    void testPrimary() {
        jdbcTemplate.update("insert into student(name,age) values(?,?)",new Object[]{"Java旅途",18});
    }
}

4.2 测试多数据源

@SpringBootTest
class SpringBootDatasourceApplicationTests {


    @Autowired
    private JdbcTemplate db1JdbcTemplate;
    @Autowired
    private JdbcTemplate db2JdbcTemplate;

    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Test
    void contextLoads() {

        db1JdbcTemplate.update("insert into student(name,age) values(?,?)",new Object[]{"Java旅途",18});
        db2JdbcTemplate.update("insert into student(name,age) values(?,?)",new Object[]{"Java旅途",18});
    }
    }
}

这里分享一道面试题:@Autowired 与@Resource有什么区别

@Autowired是Spring提供的,@Resource是JDK提供的;

@Autowired是根据bean的类型匹配的,@Resource是根据bean的name匹配的;

如果@Autowird想要根据name匹配应该怎么做呢?

  1. 配合@Qualifier注解指定bean的name
  2. 使用变量名称作为bean的id,@Autowired如果匹配到多个符合条件的对象后,会自动根据变量名称做为bean的id继续匹配。我们在4.2中采用的就是这种方式。

本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 1 收藏 1 评论 0

Java旅途 发布了文章 · 10月8日

spring-boot-route(九)整合JPA操作数据库

单调的增删改查让越来越多的程序员感到乏味,这时候就出现了很多优秀的框架,完成了对增删改查操作的封装,只需要简单配置,无需书写任何sql,就可以完成增删改查。这里比较推荐的是Spring Data Jpa。

Spring Data JPA是Spring Data家族的一部分,可以轻松实现基于JPA的存储库。 此模块处理对基于JPA的数据访问层的增强支持。 它使构建使用数据访问技术的Spring驱动应用程序变得更加容易。

我们继续使用前两章用的数据库结构来进行演示。

一 引入mysql和spring-data-jpa依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

二 创建实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Student implements Serializable {

    private static final long serialVersionUID = 6712540741269055064L;

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer studentId;
    private Integer age;
    private String name;
    private Integer sex;
    private Date createTime;
    private Integer status;
}

@GeneratedValue是主键生成策略,Jpa自带的几种主键生成策略如下:

  • TABLE: 使用一个特定的数据库表格来保存主键
  • SEQUENCE: 根据底层数据库的序列来生成主键,条件是数据库支持序列。这个值要与generator一起使用,generator 指定生成主键使用的生成器(可能是orcale中自己编写的序列)
  • IDENTITY: 主键由数据库自动生成(主要是支持自动增长的数据库,如mysql)
  • AUTO: 主键由程序控制,也是GenerationType的默认值

主键生成策略扩展

自定义主键生成器:

public class MyGenerator implements IdentifierGenerator {
    
    @Override
    public Serializable generate(SharedSessionContractImplementor sharedSessionContractImplementor, Object o) throws HibernateException {
        return getId();
    }
    
    public static long getId(){
        return System.currentTimeMillis();
    }
}

然后在实体类做一下配置:

@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class Student implements Serializable {

    private static final long serialVersionUID = 6712540741269055064L;

    @Id
    @GenericGenerator(name="idGenerator",strategy = "com.javatrip.springdatajpa.entity.MyGenerator")
    @GeneratedValue(generator = "idGenerator")
    private Integer studentId;
    private Integer age;
    private String name;
    private Integer sex;
    private Date createTime;
    private Integer status;
}

三 创建dao接口

dao层接口实现JpaRepository,泛型选择pojo和其主键类型,就会自动实现简单的CRUD等接口,无需手动开发,就能快速进行调用。

public interface StudentRepository extends JpaRepository<Student,Integer> {

    /**
     * 根据年龄,名字模糊查询
     * @return
     */
    Student findByNameLikeAndAge(String name,int age);
}

Jpa除了实现CRUD方法,还支持字段名模糊查询等各种不用手写sql的操作。

四 测试类测试CRUD

@SpringBootTest
class SpringDataJpaApplicationTests {

    @Autowired
    StudentRepository repository;
    @Test
    void contextLoads() {
        // 查询所有实体
        List<Student> all = repository.findAll();
        // 根据id查询实体类
        Optional<Student> byId = repository.findById(100);
        // 根据id删除数据
        repository.deleteById(100);
        // 插入一条数据
        // 如果数据库存在该实体的主键,则更新,否则插入
        Student student = new Student();
        student.setAge(18);
        student.setName("Java旅途");
        repository.save(student);

        repository.findByNameLikeAndAge("Java",18);
    }
}

spring-data-jpa在外国程序员界非常普遍。相比其他两种方式,它不需要写sql就可以完成非常完善的数据操作,我也是比较推荐使用它作为orm框架。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 2 评论 0

Java旅途 发布了文章 · 10月7日

spring-boot-route(八)整合mybatis操作数据库

MyBatis 是一款优秀的持久层框架,它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息,将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。

通过注解完成数据操作

第一步:引入mysql依赖和mybatis依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>LATEST</version>
</dependency>

第二步:新建学生表及对应的实体类

CREATE TABLE `student` (
   `student_id` int(30) NOT NULL AUTO_INCREMENT,
   `age` int(1) DEFAULT NULL COMMENT '年龄',
   `name` varchar(45) DEFAULT NULL COMMENT '姓名',
   `sex` int(1) DEFAULT NULL COMMENT '性别:1:男,2:女,0:未知',
   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
   `status` int(1) DEFAULT NULL COMMENT '状态:1:正常,-1:删除',
   PRIMARY KEY (`student_id`)
 ) ENGINE=InnoDB AUTO_INCREMENT=617354 DEFAULT CHARSET=utf8mb4 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC COMMENT='学生表'
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Student implements Serializable {

    private static final long serialVersionUID = 6712540741269055064L;

    private Integer studentId;
    private Integer age;
    private String name;
    private Integer sex;
    private Date createTime;
    private Integer status;
}

第三步:配置数据库连接信息

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/simple_fast
    username: root
    password: root

增删改查

@Mapper
public interface StudentMapper {

    @Select("select * from student where student_id = #{studentId}")
    Student findById(@Param("studentId") Integer studentId);

    @Insert("insert into student(age,name) values(#{age},#{name})")
    int addStudent(@Param("name") String name,@Param("age") Integer age);

    @Update("update student set name = #{name} where student_id = #{studentId}")
    int updateStudent(@Param("studentId") Integer studentId,@Param("name") String name);

    @Delete("delete from student where student_id = #{studentId}")
    int deleteStudent(@Param("studentId") Integer studentId);
}

上面演示的传参方式是通过单个参数传递的,如果想通过Map或实体类传参数,就不需要使用@Param来绑定参数了,将map中的key或者实体类中的属性与sql中的参数值对应上就可以了

通过XML配置完成数据操作

@Mapper和@MapperScan

@Mapper加在数据层接口上,将其注册到ioc容器上,@MapperScan加在启动类上,需要指定扫描的数据层接口包。如下:

@Mapper
public interface StudentMapper {}
@SpringBootApplication
@MapperScan("com.javatrip.mybatis.mapper")
public class MybatisApplication {
    public static void main(String[] args) {
        SpringApplication.run(MybatisApplication.class, args);
    }
}

两个注解的作用一样,在开发中为了方便,通常我们会使用@MapperScan。

指定mapper.xml的位置

mybatis:
  mapper-locations: classpath:mybatis/*.xml

开启数据实体映射驼峰命名

mybatis:
  configuration:
    map-underscore-to-camel-case: true

编写xml和与之对应的mapper接口

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.javatrip.mybatis.mapper.StudentXMapper">
    <select id="findById" resultType="com.javatrip.mybatis.entity.Student">
        select * from student where student_id = #{studentId}
    </select>
    <insert id="addStudent" parameterType="com.javatrip.mybatis.entity.Student">
        insert into student(name,age) values(#{name},#{age})
    </insert>
    
    <update id="updateStudent" parameterType="com.javatrip.mybatis.entity.Student">
        update student set name = #{name} where  student_id = #{studentId}
    </update>

    <delete id="deleteStudent" parameterType="Integer">
        delete from student where student_id = #{studentId}
    </delete>
</mapper>
@Mapper
public interface StudentXMapper {

    Student findById(@Param("studentId") Integer studentId);

    int addStudent(Student student);

    int updateStudent(@Param("studentId") Integer studentId,@Param("name") String name);

    int deleteStudent(@Param("studentId") Integer studentId);
}

编写测试类

@SpringBootTest
class MybatisApplicationTests {

    @Autowired
    StudentMapper mapper;

    @Autowired
    StudentXMapper xMapper;

    @Test
    void testMapper() {

        Student student = mapper.findById(10);
        mapper.addStudent("Java旅途",19);
        mapper.deleteStudent(31);
        mapper.updateStudent(10,"Java旅途");
    }

    @Test
    void contextLoads() {
        
        Student student = xMapper.findById(10);
        Student studentDo = new Student();
        studentDo.setAge(18);
        studentDo.setName("Java旅途呀");
        xMapper.addStudent(studentDo);
        xMapper.deleteStudent(32);
        xMapper.updateStudent(31,"Java旅途");
    }
}

这里有几个需要注意的点:mapper标签中namespace属性对应的是mapper接口;select标签的id对应mapper接口中的方法名字;select标签的resultType对应查询的实体类,使用全路径。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 2 收藏 1 评论 0

Java旅途 发布了文章 · 10月7日

spring-boot-route(七)整合jdbcTemplate操作数据库

在一部分内容中,我们学习了Restful接口的编写,及接口文档的生成。我们需要将接口数据进行持久化存储,这一部分我们主要学习几种持久化框架将数据进行存储。本部分内容中,我们都将使用mysql为例来做为演示数据库。

在刚开始接触数据库操作的时候我们都会使用JDBC来进行数据库操作,但是每次都要创建连接,关闭连接非常麻烦,Spring将JDBC进行了简易的封装成了一个新的框架——JdbcTemplate。

项目搭建

1 添加mysql依赖

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>

2. 添加jdbcTemplate依赖

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

3. 配置mysql

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/simple_fast?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&zeroDateTimeBehavior=CONVERT_TO_NULL&useSSL=false&useAffectedRows=true&allowPublicKeyRetrieval=true
    username: root
    password: root

简单操作数据库

新建一张表student用来测试JdbcTemplate的常用功能。建表语句如下:

CREATE TABLE `student` (
   `student_id` int(30) NOT NULL,
   `age` int(1) DEFAULT NULL COMMENT '年龄',
   `name` varchar(45) DEFAULT NULL COMMENT '姓名',
   `sex` int(1) DEFAULT NULL COMMENT '性别:1:男,2:女,0:未知',
   `create_time` datetime DEFAULT NULL COMMENT '创建时间',
   `status` int(1) DEFAULT NULL COMMENT '状态:1:正常,-1:删除',
   PRIMARY KEY (`student_id`)
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 CHECKSUM=1 DELAY_KEY_WRITE=1 ROW_FORMAT=DYNAMIC COMMENT='学生表'

对应的实体类如下:

@Data
@NoArgsConstructor
@AllArgsConstructor
public class StudentBean implements Serializable {
    
    private static final long serialVersionUID = 4618004018169112427L;

    private Integer studentId;
    private Integer age;
    private String name;
    private Integer sex;
    private Date createTime;
    private Integer status;
}

JdbcTemplate提供了比较完善的数据库操作API,日常开发中比较常用的API主要为两类,分别是

  • query与queryXXX
  • update与batchUpdate

JdbcTemplate的使用也非常简单,哪儿需要使用注入即可

@Autowired
private JdbcTemplate jdbcTemplate;

1 查询单个实体

public StudentBean getStudent(int status){
    String sql = "select * from student where status = ? limit 1";
    return jdbcTemplate.queryForObject(sql,new Object[]{status},new BeanPropertyRowMapper<>(StudentBean.class));
}

2 查询List集合

public List<StudentBean> studentBeanList(int status){
    String sql = "select * from student where status = ?";
    return  jdbcTemplate.query(sql,new Object[]{status},new BeanPropertyRowMapper<>(StudentBean.class));
}

3. 删除操作

public int deleteStudent(int status){
    String sql = "delete from student where status = 0";
    return jdbcTemplate.update(sql);
}

4. 更新操作

public int updateStudent(int studentId,String name){
    String sql = "update student set name = ? where student_id = ?";
    return jdbcTemplate.update(sql,new Object[]{name,studentId});
}

5. 插入操作

public int addStudent(){
    String sql = "insert into student(student_id,age,name,status) values(?,?,?,?)";
    return jdbcTemplate.update(sql,new Object[]{30,18,"Java旅途",0});
}

6. 批量插入

JdbcTemplate提供了批量插入的API,为了减少与数据库的操作,提高插入效率,将待插入的数据批量放在缓冲区,一次批量插入多条数据。

public int batchAddStudent(){

    // 构造list集合
    List<StudentBean> studentBeanList = new ArrayList<>();
    StudentBean studentBean = new StudentBean(31, 31, "Java旅途", 1, new Date(), 1);
    StudentBean studentBean1 = new StudentBean(32, 32, "javatrip", 1, new Date(), 1);
    studentBeanList.add(studentBean);
    studentBeanList.add(studentBean1);
    String sql = "insert into student values(?,?,?,?,?,?)";

    int[] ints = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
        @Override
        public void setValues(PreparedStatement ps, int i) throws SQLException {
            StudentBean student = studentBeanList.get(i);
            ps.setInt(1, student.getStudentId());
            ps.setInt(2, student.getAge());
            ps.setString(3, student.getName());
            ps.setInt(4, student.getSex());
            ps.setDate(5,new java.sql.Date(System.currentTimeMillis()));
            ps.setInt(6, student.getStatus());
        }

        @Override
        public int getBatchSize() {
            return studentBeanList.size();
        }
    });
    return ints.length;
}

上面只是演示了几个简单的例子,如果需要更详细的用法可以参考官方提供的JdbcTemplate API。JdbcTemplate对于初学者来说是比较容易上手的一个框架,使用起来也非常方便。但是也存在一些缺点,它是将sql硬编码到java代码中,如果需要修改sql,就需要重新编译java代码,不利于维护。


本文示例代码已上传至github,点个star支持一下!

Spring Boot系列教程目录

spring-boot-route(一)Controller接收参数的几种方式

spring-boot-route(二)读取配置文件的几种方式

spring-boot-route(三)实现多文件上传

spring-boot-route(四)全局异常处理

spring-boot-route(五)整合swagger生成接口文档

spring-boot-route(六)整合JApiDocs生成接口文档

spring-boot-route(七)整合jdbcTemplate操作数据库

spring-boot-route(八)整合mybatis操作数据库

spring-boot-route(九)整合JPA操作数据库

spring-boot-route(十)多数据源切换

spring-boot-route(十一)数据库配置信息加密

spring-boot-route(十二)整合redis做为缓存

spring-boot-route(十三)整合RabbitMQ

spring-boot-route(十四)整合Kafka

spring-boot-route(十五)整合RocketMQ

spring-boot-route(十六)使用logback生产日志文件

spring-boot-route(十七)使用aop记录操作日志

spring-boot-route(十八)spring-boot-adtuator监控应用

spring-boot-route(十九)spring-boot-admin监控服务

spring-boot-route(二十)Spring Task实现简单定时任务

spring-boot-route(二十一)quartz实现动态定时任务

spring-boot-route(二十二)实现邮件发送功能

spring-boot-route(二十三)开发微信公众号

这个系列的文章都是工作中频繁用到的知识,学完这个系列,应付日常开发绰绰有余。如果还想了解其他内容,扫面下方二维码告诉我,我会进一步完善这个系列的文章!

查看原文

赞 1 收藏 1 评论 0